python-Functional Programiming基础知识

函数是面向过程的程序设计的基本单元，函数式编程的思想更接近数学计算。
函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，
因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有
副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，
可能得到不同的输出，因此，这种函数是有副作用的。
	函数式编程最大的特点：允许把函数本身作为参数传入另一个函数，还允许返回一个函数。

1.高阶函数：
(1).变量可以指向函数：
	>>>f = abs
	>>>f
	<built-in function abs>

	>>>f = abs(-7)
	>>>f
	7

	#如果一个变量指向一个函数，可以通过调用该变量来调用该函数，函数名就是指向函数的变量。
	
	函数的参数可以接收变量，变量可以指向函数，那么一个函数就可以接收另一个函数
作为参数，这种函数就称为高阶函数。
	
	def add(x, y, f):
		return f(x) + f(y)
	print(add(-5, 6, abs))	
	Output:11
(2).map()/reduce() (python内置):
	(1).map():接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用
	到序列的每个元素，并把结果作为新的Iterator返回。

	def f(x):
		return x * x

	list_t = [1, 2, 3, 4]	
	r = map(f, list_t)
	print(list(r))
	Output:	[1, 4, 9, 16]   
	#将f(x)作用于list_t的每一个元素，将新的生成元素放在新的列表r中

	>>>list(map(str, [1, 2, 3, 4, 5]))
	['1', '2', '3', '4', '5']	#将每个元素转换为字符串\


	(2).reduce():把一个函数作用在一个序列[x1, x2, x3, ...]上，
	必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
	reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

	#对一个序列求和
	from functools import reduce
	def add(x, y):
		return x + y
	sum_t = reduce(add, [1, 2, 3, 4])	
	print(sum_t)
	Output:10

	#把序列[1, 3, 5, 7, 9]变换成整数13579
	from functools import reduce
	def fn(x, y):
		return x * 10 + y
	sum_t = reduce(fn, [1, 3, 5, 7, 9])
	print(sum_t)	
	Output:13579

	#转换str为int
	from functools import reduce
	def fn(x, y):
			return x * 10 + y
	def char2num(s):
		digits = 	{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, 
		'7': 7, '8': 8, '9': 9}	
		return digits[s]
	sum_t = reduce(fn, map(char2num, '13579'))
	print(sum_t)	
	Output:13579

	#str2int:
	from functools import reduce
	DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, 
	'8': 8, '9': 9}
	def str2int(s):
	    def fn(x, y):
	        return x * 10 + y
	    def char2num(s):
	        return DIGITS[s]
	    return reduce(fn, map(char2num, s))

	#使用lambda函数（匿名函数）进一步简化 
	#lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边是返回值
	#匿名函数也是一个函数对象，可以赋值给变量，再通过变量调用
	from functools import reduce
	DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, 
	'8': 8, '9': 9}
	def char2num(s):
	    return DIGITS[s]
	def str2int(s):
	    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

(3). filter():过滤序列，接收一个函数和序列，将函数依次作用于序列的每个元素，然后根据
返回值是True还是False决定是否保留该元素。该函数返回的是一个Iterator，即惰性序列，
需要使用 list()函数获得所有结果并返回list。

#删除list中的所有奇数
list_t = [1, 2, 3, 4, 5, 6]
def is_odd(n):
	return n % 2 == 0
list_t = list(filter(is_odd, list_t))	
print(list_t)
Output:[2, 4, 6]

#删除序列中的空字符串
def not_empty(s):
    return s and s.strip()
#strip()函数删除序列的头尾的指定字符，默认是空格
#strip([chars])，char为指定的字符
list_t = list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
print(list_t)
Output:['A', 'B', 'C']

#使用filter求素数
算法：埃式筛法
首先，列出从2开始的所有自然数，构造一个序列：
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：
3, 5, 7, 9, 11, 13, 15, 17, 19,  ...
取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：
5, 7, 11, 13, 17, 19,  ...
取新序列的第一个数5，然后用5把序列的5的倍数筛掉：
7, 11, 13, 17, 19,  ...
不断筛下去，就可以得到所有的素数。

python的计算思路：
先定义从3开始的一个奇数序列，然后定义筛选函数，最后使用生成器不断返回下一个素数。

def _odd_iter():
	'''定义一个生成器，返回一个无限奇数序列'''
	n = 1
	while True:
		n += 2
		yield n

def _not_divisible(n):
	'''定义筛选函数，用于删除奇数序列的元素的倍数'''
	return lambda x : x % n > 0 		

def primes():
	'''定义一个生成器，不断返回下一个素数'''
	yield 2	#先返回第一个素数2
	it = _odd_iter()
	while  True:
		n = next(it)
		yield n 
		it = filter(_not_divisible(n), it)
	
#获取输入的数字，转换为int类型，以此为跳出范围
num = int(input("Enter a number: "))

for n in primes():
    '''定义退出条件'''

    if n < num:
        print(n)
    else:
        break

#回数：从左往右读和从右往左读都是一样的。
#设计一个程序筛选出回数       

def is_palindrome(n):
    m = str(n)        
    for i in range(len(m)):
        if m[i-1] != m[-i]:
            return False
        return True
#Test
output = list(filter(is_palindrome, range(1,1000))) 
print('1~1000: \n', output)  
Output:1~1000: 
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 
 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282,
 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444,
 454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555, 565, 575, 585, 595, 606, 
 616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767,
 777, 787, 797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 
 929, 939, 949, 959, 969, 979, 989, 999]

(4). sorted():排序，作为高阶函数，允许接收一个key函数来实现自定义的排序。
#按绝对值大小排序
>>>sorted([-1, -4, 2, 3], key = abs)
[-1, 2, 3, -4]

key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。
然后 sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素。

#对字符串排序（默认按照ASCII的大小比较，'Z'<'a'）
>>>sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']
#忽略大小写，按照字母排序(先都变大写或小写再比较)
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key = str.lower)
['about', 'bob', 'Credit', 'Zoo']
#反向排序
>>>sorted(['bob', 'about', 'Zoo', 'Credit'], key = str.lower, reverse = True)
['Zoo', 'Credit', 'bob', 'about']


2.返回函数：在高阶函数中把函数作为结果值返回

#普通可变参数求和
def calc_sum(*args):
	ax = 0
	for n in args:
		ax += n
	return	ax

#不需要立即求和，不返回求和结果，只返回求和函数
def lazy_sum(*args):
	def sum_test():
		ax = 0
		for n in args:
			ax += n
		return ax
	return sum_test		
#调用lazy_sum()函数时，返回的不是求和结果，而是函数sum_test()
>>>f = lazy_sum(1, 2, 3, 4)
>>>f	
<function lazy_sum.<locals>.sum_test at 0x000001E76A13E6A8>
#调用函数f()时，才真正计算求和结果
>>>f()
10


闭包：
上面的例子中，在函数 lazy_sum()内部又定义了函数 sum_test()，且内部函数
sum_test()可以引用外部函数 lazy_sum()的参数和局部变量。当 lazy_sum()返回
函数 sum_test()时，相关参数和变量都保存在返回的函数中。这种程序结构称为
“闭包(Closure)”
需要注意，当调用 lazy_sum()时，每次都会返回一个新的函数，即使传入的参数相同：
>>> f = lazy_sum(1, 2, 3, 4)
>>> f1 = lazy_sum(1, 2, 3, 4)
>>> f == f1
False

返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，
其内部的局部变量还被新函数引用.另一个需要注意的问题是，返回的函数并没有立刻执行，
而是直到调用了 f()才执行。
#python中的循环结束以后，循环体中的临时变量i不会销毁，而是继续存在于执行环境中。
#并且python的函数只有在执行时，才会去找函数体里的变量的值。
def count():
    fs = []
    for i in range(1, 4):
        def f():
            return i * i
        fs.append(f)
    return fs

f1, f2, f3 = count()

>>> f1()
9
>>> f2()
9
>>> f3()
9
#当把函数加入fs列表里时，python还没有给i赋值，只有当执行时才去找。
#当for循环结束后，i的值为3，所以才会有上面的输出结果
	返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，
它们所引用的变量i已经变成了3，因此最终结果为9.返回闭包时牢记一点：
返回函数不要引用任何循环变量，或者后续会发生变化的变量。
	如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环
变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：
def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

f1, f2, f3 = count()

>>> f1()
1
>>> f2()
4
>>> f3()
9

3.装饰器：decorator（本质上是返回函数的高阶函数），在代码运行期间动态增加功能
def now():
	print('2018-5-22')

#在程序运行前打印日志
def log(func):
	def wrapper(*args, **kw):
		print('call %s():' % func.__name__)		#获取函数对象的名字
		return func(*args, **kw)
	return wrapper	

@log			#相当于执行了now = log(now) 
def now():
	print('2018-5-22')

now()
Output:	call now():
		2018-5-22

'''
由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在
同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的
wrapper()函数。rapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以
接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
'''	

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数

#自定义log的文本：
def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

这个3层嵌套的decorator用法如下：

@log('execute')		#相当于执行了now = log('execute')(now)
def now():
    print('2018-5-22')

Output:
>>> now()
execute now():
20188-5-22

首先执行 log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，
返回值最终是 wrapper()函数。

函数也是对象，它有__name__等属性，但经过decorator装饰之后的函数，__name__已经从
原来的'now'变成了'wrapper'：
>>> now.__name__
'wrapper'
因为返回的那个 wrapper()函数名字就是'wrapper'，所以，需要把原始函数的 __name__ 
等属性复制到 wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。

不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps
就是干这个事的，所以，一个完整的decorator的写法如下：
import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

针对带参数的decorator：
import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator   


4.偏函数：当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新
的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：
>>> int('12345')
12345

#利用base参数实现N进制转换  
>>> int('123', base = 8)  
83
>>> int('123', 16)
291

#假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦,
#可以定义一个int2()的函数，默认把base=2传进去
def int2(x, base = 2):
	return int(x, base)
>>> int2('1000000')	
64
>>> int2('1010101')
85

#借助functools.partial可以不用自己定义 int2()
#functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），
#返回一个新的函数，调用这个新函数会更简单。
import functools
int2 = functools.partial(int, base = 2)
>>> int2('1000000')	
64
>>> int2('1010101')
85

'''
创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数，当传入：
int2 = functools.partial(int, base=2)
实际上固定了 int()函数的关键字参数base，也就是：
int2('10010')相当于：
kw = { 'base': 2 }
int('10010', **kw)

当传入：max2 = functools.partial(max, 10)
实际上会把10作为*args的一部分自动加到左边，也就是：
max2(5, 6, 7)相当于：
args = (10, 5, 6, 7)
max(*args)
'''