#py函数式编程.py#高阶函数map/reduce/filter/sorted、闭包函数/返回函数、匿名函数lamber、@装饰器decorator、偏函数functool.partial()# =============================================================================# #Py函数式编程.py# #高阶函数、闭包函数/返回函数、匿名函数lamber、@装饰器decorator、偏函数functool.partial()# #参考链接：/wiki/1016959663602400/1017328525009056# ============================================================================='''深入：一、import functools #functools 模块中主要包含了一些函数装饰器和便捷的功能函数。1、使用：@functools.wraps(func)通过给decorator装饰器主函数内return返回的子函数 加上装饰器functools.wraps(func) 来纠正被此装饰器装饰过的func函数属性。2、#使用：functools.partial()用来创建一个偏函数，即把一个函数的某些参数给固定住（即设置默认值），返回一个新函数。#注意：偏函数实质上是一个 @装饰器 的原理，即在参数列表里追加进去 设置默认值的参数。#如：int2('1000') 实则是运行的 int('1000',base=2)#使用：一、高阶函数（map/reduce/filter/sorted等）高阶函数就是一个函数就可以接收另一个函数作为参数的函数。1、map(func,*iterables)将参数func函数 作用于 参数*iterables里的每一个内容,返回一个可迭代对象。#注意 map(,)返回一个迭代器iterator，需要序列化才能输出。`2、reduce(func,*iterables,initial) 将参数func函数 作用于 参数序列上，并把结果继续和序列的下一个元素做累计计算。并最终返回值。#注意 reduce(,) 直接返回累计作用的值。3、filter(func,iters) 过滤序列序列。用参数func函数 过滤 参数iters序列，为True则留下，为False则丢弃。 #注意 filter(,)返回一个迭代器iterator，需要序列化才能输出。4、sorted(iterable, key=None, reverse=False) 对参数iterable序列list进行排序，#注意 参数key可用来接收一个函数来实现自定义的排序。#注意 参数reverse为True则反向排序二、返回函数（闭包）闭包函数#高阶函数除了可以接受函数作为参数外，还可以把函数作为 结果值返回。#闭包 即在 外部函数中 又定义了 内部函数，并且，内部函数 可以引用 外部函数 的参数和局部变量。#当 外部函数 返回 内部函数 时，相关参数和变量都保存在返回的函数中，这种闭包程序结构拥有极大的威力，称谓“闭包”。#参考网址：/sc_lilei/article/details/804646451、使用：通过获取主函数的魔法属性__closure__返回的值来确定主函数是否存在闭包。#__closure__属性返回一个元组对象，包含了闭包引用的外部变量。#对闭包主函数的__closure__属性迭代后通过cell_contents来输出闭包引用的外部变量#如果主函数 没有return子函数，就不存在闭包，主函数不存在_closure__属性，返回None#如果主函数 return的子函数不引用外部变量，也就不存在闭包，主函数的__closure__属性同样返回None。 2、注意：闭包函数中的return返回内容指向(return返回子函数名称 而不是调用函数)、函数作用域。3、注意：闭包时牢记一点：返回函数（子函数、内部函数）不要引用任何 循环变量，或者后续会发生变化的变量。#如果子函数一定要引用循环变量，方法是再创建一个函数。#用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：三、匿名函数lambda#关键字lambda表示匿名函数，lambda x : x*x，冒号前面表示函数参数，冒号后面表达式表示函数内容1、#使用：匿名函数可以赋值变量，lambda也是一个函数对象，也可以赋值给变量，然后通过变量来调用匿名函数。2、#使用：匿名函数可以作为返回值返回,如在函数定义里最后return lambda ：x*x + y*y#注意：匿名函数作为返回值返回，等同于return子函数，就是一个闭包函数。3、#注意：匿名函数有个限制：只能有一个表达式，不用填写return，返回值就是该表达式的结果四、装饰器@（decorator装饰器 = 高阶函数 + 闭包函数)装饰器本质上是接受一个函数作为参数（高阶函数行为），并返回一个函数（闭包函数行为）。返回函数即子函数 中定义添加内容后 再返回主函数的参数函数。从而实现不修改 参数函数的基础上 在代码运行期间动态增加功能的方式。1、#使用：functools.wraps(func)装饰器#注意：装饰器装饰过的函数的原属性已经改变，因为装饰器内部是闭包主函数return返回了子函数。#解决办法是 通过给decorator装饰器主函数内return返回的子函数 加上装饰器functools.wraps(func) 来纠正被此装饰器装饰过的func函数属性。2、#深入：import functools #functools 模块中主要包含了一些函数装饰器和便捷的功能函数。2.1、使用：@functools.wraps(func)通过给decorator装饰器主函数内return返回的子函数 加上装饰器functools.wraps(func) 来纠正被此装饰器装饰过的func函数属性。五、偏函数functools.partial()#functools 模块中主要包含了一些函数装饰器和便捷的功能函数。其中一个就是偏函数（Partial function）。#偏函数可以通过设定参数的默认值，从而降低函数调用的难度。1、#使用：functools.partial()用来创建一个偏函数，即把一个函数的某些参数给固定住（即设置默认值），返回一个新函数。2、#注意：偏函数实质上是一个 @装饰器 的原理，即在参数列表里追加进去 设置默认值的参数。#如：int2('1000') 实则是运行的 int('1000',base=2)''''''函数式编程就是一种抽象程度很高的编程范式。函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！Python允许使用变量，因此，Python不是纯函数式编程语言。'''#################### 高阶函数#高阶函数#高阶函数就是一个函数就可以接收另一个函数作为参数的函数。#一个函数就可以接收另一个函数作为 参数，这种函数就称之为高阶函数。def add(x,y,fun):return fun(x)+fun(y)print(add(-5,6,abs))###########使用 map(func,*iterables) 将参数func函数 作用于 参数*iterables里的每一个内容,返回一个可迭代对象。#注意 map(,)函数返回的是一个迭代器iterato,可迭代对象，需要list获取序列化才能输出。help(map)type(map)def f(x):return x*xr=map(f,[1,2,3,4,5,6,7,8,9])print(list(r))#注意 map(,)函数返回的是一个可迭代对象，需要list获取序列化才能输出。#通过map(,)函数将int内容批量转换成str内容list(map(str,[1,2,3,4,5,6,7,8,9]))###########使用 reduce(func,*iterables,initial) 将参数func函数 作用于 参数序列上，并把结果继续和序列的下一个元素做累计计算。并最终返回值。#注意 reduce(,) 直接返回累计作用的值。#参数: func指定参数，iterables指定作用序列，initial指定初始化的序列值。#注意：如果传入了 initial 参数值， 那么首先传的就不是 iterables 的第一个和第二个元素，而是 initial值 和 iterables的第一个元素from functools import reducehelp(reduce)def add(x,y):return x+yreduce(add,[1,3,5,7,9]) #注意 reduce(,)函数返回一个累计后的值。######示例1：#如果考虑到字符串str也是一个序列，可作为reduce的参数2，则配合map()，就可以写出把str转换为int的函数from functools import reducedef fn(x,y):return x*10 + ydef 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] #注意参数s需要是一个str类型 来 对应字典的键明keyprint(reduce(fn,map(char2num,'13579'))) #将字符串'13579'作为一个可迭代的类型参数。######示例2#使用匿名函数lambda来简写示例1from functools import reduceDIGITS={'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))str2int('12580')###########使用 filter(func,iters) 过滤序列序列。用参数func函数 过滤 参数iters序列，为True则留下，为False则丢弃。 #注意 filter(,)返回一个迭代器iterator，需要序列化才能输出。#和map()类似，filter()也接收一个函数和一个序列。#不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。help(filter)#示例在一个list中，删掉偶数，值保留奇数：def is_odd(n):return n%2 == 1 #符号 %求余，//取整。print(list(filter(is_odd,[1,2,3,4,6,7,8,9])))#示例把一个序列中的空字符串删掉：def not_empty(s):return s and s.strip() #.strip()方法用于移除字符串头尾指定的字符（默认移除空格或换行符，注意只能删除开头和结尾）print(list(filter(not_empty,['A','','B',None,'c',' '])))######示例用fielter求素数。（素数：一个正整数，如果只有1和它本身两个因数，则叫做素数，也叫做质数。）#计算素数的一个方法是埃氏筛法，它的算法理解起来非常简单：#首先，列出从2开始的所有自然数，构造一个序列：2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...#取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...#取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...#取新序列的第一个数5，然后用5把序列的5的倍数筛掉：7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...#不断筛下去，就可以得到所有的素数。def _odd_iter():"""先构造一个从3开始的奇数序列，注意 这是一个生成器，并且是一个无限序列的生成器。"""n=1while True:n=n+2yield ndef _not_divisible(n):"""然后定义一个筛选函数"""return lambda x: x%n > 0def prines():"""最后定义一个生成器，不断返回下一个素数这个生成器先返回第一个素数2，然后，利用filter()过滤函数不断产生筛选后的新的序列"""yield 2it=_odd_iter()#初始化序列while True:n=next(it)yield nit= filter(_not_divisible(n),it) #构造新序列"""由于prines()也是一个无限序列，所有调用时需要设置一个退出循环的条件"""for n in prines():if n<1000:print(n)else:break#生成器 yield#包含yield的语句被称为 生成器。#包含 基线条件 和 递归条件。 即最后一个条件处理 和 循环的条件处理。a=_odd_iter()print(a)next(a)###########使用 sorted(iterable, key=None, reverse=False) 对参数iterable序列list进行排序，#注意 参数key可用来接收一个函数来实现自定义的排序。#注意 参数reverse为True则反向排序#示例 按绝对值大小排序"""key参数指定的函数将作用于每一个元素上，并根据key函数返回的结果进行排序"""sorted([36,5,-12,9,-21],key=abs)sorted([36,5,-12,9,-21],key=abs,reverse=True)help(sorted)#################### 闭包函数（返回函数）#使用 闭包函数#高阶函数除了可以接受函数作为参数外，还可以把函数作为 结果值返回。#闭包 即在 外部函数中 又定义了 内部函数，并且，内部函数 可以引用 外部函数 的参数和局部变量。#当 外部函数 返回 内部函数 时，相关参数和变量都保存在返回的函数中，这种闭包程序结构拥有极大的威力，称谓“闭包”。#参考网址：/sc_lilei/article/details/80464645#注意：闭包函数中的return返回内容指向(return返回子函数名称 而不是调用函数)、函数作用域。#注意：闭包时牢记一点：返回函数（子函数、内部函数）不要引用任何循环变量，或者后续会发生变化的变量。#如果子函数一定要引用循环变量，方法是再创建一个函数。#用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：#使用：通过获取主函数的魔法属性__closure__返回的值来确定主函数是否存在闭包。#__closure__属性返回一个元组对象，包含了闭包引用的外部变量。#对闭包主函数的__closure__属性迭代后通过cell_contents来输出闭包引用的外部变量#如果主函数 没有return子函数，就不存在闭包，主函数不存在_closure__属性，返回None#如果主函数 return的子函数不引用外部变量，也就不存在闭包，主函数的__closure__属性同样返回None。 #一个可变参数的求和函数def calc_sum(*args):"""该函数 立刻返回求和的结果ax"""ax=0for n in args:ax=ax+nreturn ax#一个返回求和函数名的函数def lazy_sum(*args):"""该函数 返回一个函数名（不带括号表示不运行函数），不立即求和，而是等到调用函数()时再进行求和；闭包：#闭包 即在 外部函数中 又定义了 内部函数，并且，内部函数 可以引用 外部函数 的参数和局部变量。#当 外部函数 返回 内部函数 时，相关参数和变量都保存在返回的函数中，这种闭包程序结构拥有极大的威力，称谓“闭包”。"""def sum():ax=0for n in args:ax=ax+nreturn ax""" 闭包return返回了子函数名，不是调用子函数()"""return sum #注意这里是返回的 函数名，不带括号表示不运行函数。f=lazy_sum(1,3,5,7,9) #相当于赋值给f，赋值内容为 主函数内return返回的子函数名f() #这里才是进行了 主函数内return返回的子函数的调用，即立即求和计算结果。#注意：闭包时牢记一点：返回函数（子函数、内部函数）不要引用任何循环变量，或者后续会发生变化的变量。def count():fs=[]for i in range(1,4):def f():"""#注意：闭包时牢记一点：返回函数（子函数、内部函数）不要引用任何循环变量，或者后续会发生变化的变量。#如果子函数一定要引用循环变量，方法是再创建一个函数。#用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：如下内容即引用了循环变量，导致实例化后输出结果都为9"""return i*i '''for循环，追加 函数名 进 fs空列表'''fs.append(f)return fsf1,f2,f3=count() #等于 f1,f2,f3=[f, f, f]f1()#等于运行 f() 实质子函数f()里i已经运行完毕为最后的 3 。f2()#等于运行 f() 实质子函数f()里i已经运行完毕为最后的 3 。f3()#等于运行 f() 实质子函数f()里i已经运行完毕为最后的 3 。#注意：闭包时牢记一点：返回函数（子函数、内部函数）不要引用任何循环变量，或者后续会发生变化的变量。#如果子函数一定要引用循环变量，方法是再创建一个函数。#用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：def count():def f(j):def g():return j*jreturn g"""一个空列表fs，接下来准备append追加进如内容：内容为 函数名带绑定后的参数i 即 f(1)、f(2)、f(3)"""fs=[]for i in range(1,4):fs.append(f(i))return fsf1,f2,f3=count() #这里实质是列表多重赋值，等于 f1,f2,f3=[f(1),f(2),f(3)]f1()f2()f3()count()#继续加深对闭包的理解_list = []for i in range(3):def func():return i+1func.__num__= i""" 这里实则添加完毕以后的 _list内容为[func,func,func],但是每一个func的__num__不同"""_list.append(func)for f in _list:print(f.__num__,f())#实际输出#0 3#1 3#2 3#通过主函数的参数判断 来return指定子函数。def get_math_func(type) :# 定义一个计算平方的局部函数def square(n) :return n * n# 定义一个计算立方的局部函数def cube(n) :return n * n * n# 定义一个计算阶乘的局部函数def factorial(n) :result = 1for index in range(2 , n + 1):result *= indexreturn result# 返回局部函数if type == "square" :return squareif type == "cube" :return cubeelse:return factorial# 调用get_math_func()，程序返回一个嵌套函数math_func = get_math_func("cube") # 得到cube函数print(math_func(5)) # 输出125math_func = get_math_func("square") # 得到square函数print(math_func(5)) # 输出25math_func = get_math_func("other") # 得到factorial函数print(math_func(5)) # 输出120###########使用：通过获取主函数的魔法属性__closure__返回的值来确定主函数是否存在闭包。#__closure__属性返回一个元组对象，包含了闭包引用的外部变量。#对闭包主函数的__closure__属性迭代后通过cell_contents来输出闭包引用的外部变量#如果主函数 没有return子函数，就不存在闭包，主函数不存在_closure__属性，返回None#如果主函数 return的子函数不引用外部变量，也就不存在闭包，主函数的__closure__属性同样返回None。 # NO.1def line_conf1(a, b):def line(x):return a * x + breturn line# NO.2def line_conf2():a = 1b = 2def line(x):print(a * x + b)return line# NO.3def _line_(a,b):def line_c(c):def line(x):return a*(x**2)+b*x+creturn linereturn line_cL=line_conf2()print(line_conf2().__closure__)#通过获取主函数的魔法属性__closure__返回的值来确定主函数是否存在闭包。for i in line_conf2().__closure__:print(i.cell_contents) #对闭包主函数的__closure__属性迭代后通过cell_contents来输出闭包引用的外部变量######闭包的实际应用1def who(name):def do(what):print(name,'say:',what)return dolucy=who('lucy')lucy('I want drink!')######闭包的实际应用#闭包实现快速给不同项目记录日志：import loggingdef log_header(logger_name):""" """logging.basicConfig(level=logging.DEBUG, format='%(asctime)s [%(name)s] %(levelname)s %(message)s',datefmt='%Y-%m-%d %H:%M:%S')logger = logging.getLogger(logger_name)def _logging(something,level):""" 返回的数（子函数），通过判断参数2 来调用日志输出类型，输出内容为参数1 """if level == 'debug':logger.debug(something)elif level == 'warning':logger.warning(something)elif level == 'error':logger.error(something)else:""" 如果没有传入参数2日志级别，则手动引发异常"""raise Exception("I dont know what you want to do?" )return _loggingproject_1_logging = log_header('project_1')project_2_logging = log_header('project_2')def project_1():#多此一举加函数project_1_logging('this is a debug info','debug')project_1_logging('this is a warning info','warning')project_1_logging('this is a error info','error')def project_2():#多此一举加函数project_2_logging('this is a debug info','debug')project_2_logging('this is a warning info','warning')project_2_logging('this is a critical info','error')project_1()project_2()#################### 匿名函数#关键字lambdab表示匿名函数，lambda x : x*x，冒号前面表示函数参数，冒号后面表达式表示函数内容#使用：匿名函数可以赋值变量，lambda也是一个函数对象，也可以赋值给变量，然后通过变量来调用匿名函数。#使用：匿名函数可以赋值变量，lambda也是一个函数对象，也可以赋值给变量，然后通过变量来调用匿名函数。#使用：匿名函数可以作为返回值返回,如在函数定义里最后return lambda ：x*x + y*y#注意：匿名函数作为返回值返回，等同于return子函数，就是一个闭包函数。#注意：匿名函数有个限制：只能有一个表达式，不用填写return，返回值就是该表达式的结果#可以使用 lambda匿名函数 结合 map高阶函数 来计算乘方list(map(lambda x: x*x,[1,2,3,4,5,6,7,8,9]))#使用：匿名函数可以赋值变量，lambda也是一个函数对象，也可以赋值给变量，然后通过变量来调用匿名函数。f=lambda x: x*xf(5)f#使用：匿名函数作为返回值返回,如在函数定义里最后return lambda ：x*x + y*y#注意：匿名函数作为返回值返回，等同于return子函数，就是一个闭包函数。 def build(x,y):""" 匿名函数作为返回值返回，等同于return子函数，就是一个闭包函数注意：闭包函数注意 return的返回指向是否存在()的调用形式"""return lambda :x*x + y*yb=build(5,10)b()#可以使用lambda匿名函数 结合 map高阶函数 来过滤偶数list(filter(lambda n: n%2==1,range(1,21)))################### 装饰器@（decorator装饰器 = 高阶函数 + 闭包函数)#装饰器本质上是接受一个函数作为参数（高阶函数行为），并返回一个函数（闭包函数行为）。#返回函数即子函数 中定义添加内容后 再返回主函数的参数函数。#从而实现不修改 参数函数的基础上 在代码运行期间动态增加功能的方式。#使用：functools.wraps(func)装饰器#注意：装饰器装饰过的函数的原属性已经改变，因为装饰器内部是闭包主函数return返回了子函数。#解决办法是 通过给decorator装饰器主函数内return返回的子函数 加上装饰器functools.wraps(func) 来纠正被此装饰器装饰过的func函数属性。#深入：import functools 使用：@functools.wraps(func)######定义一个本身不需要传入参数的装饰器 打印日志的装饰器decoratordef log(func):"""接收一个函数作为参数，称为高阶函数返回子函数，称为闭包函数"""def wrapper(*args,**kw):"""返回主函数的参数函数，从而达到不修改参数函数的基础上 动态增加print功能"""print('开始调用函数：%s()' %func.__name__)"""动态增加print功能后，继续调用原函数()执行"""return func(*args,**kw)return wrapper"""使用：@decorator放到 func函数定义前，相当于执行了 func=decorator(func),重新赋值定义了一个同名新函数"""@log def now():print('/11/08')now()"""等同于不添加装饰器@log情况下的如下表示："""#log(now)()#now=log(now)#now()######定义一个本身需要传入参数的装饰 打印日志的装饰器#使用：如果装饰器decorator本身需要传入参数，那就需要编写一个返回装饰器的高阶函数（即三层嵌套装饰器函数）。def log(who):def decorator(func):def wrapper(*args,**kw):print('%s开始调用函数：%s()' %(who,func.__name__))return func(*args,**kw)return wrapperreturn decorator@log('小王')def now():print('/11/09')now()"""等同于不添加#log('小王')的如下表示："""#log('小张')(now)()#now=log('小张')(now)#now()######使用：functools.wraps(func)装饰器#注意：装饰器装饰过的函数的原属性已经改变，因为装饰器内部是闭包主函数return返回了子函数。#解决办法是 通过给decorator装饰器主函数内return返回的子函数 加上装饰器functools.wraps(func) 来纠正被此装饰器装饰过的func函数属性。#深入：import functools #functools 模块中主要包含了一些函数装饰器和便捷的功能函数。#2.1、使用：@functools.wraps(func)#通过给decorator装饰器主函数内return返回的子函数 加上装饰器functools.wraps(func) 来纠正被此装饰器装饰过的func函数属性。import functoolsdef log(func):# @functools.wraps(func)def wrapper(*args,**kw):print('开始调用函数：%s()' %func.__name__)return func(*args,**kw)return wrapper@logdef now():print('/11/09')now()print(now.__name__)#对比添加了 @functools.wraps(func) 装饰器之后的 now.__name__import functoolsdef log(who):def decorator(func):"""使用：functools.wraps(func)装饰器通过给decorator装饰器主函数内return返回的子函数 加上装饰器functools.wraps(func) 来纠正被此装饰器装饰过的func函数属性。"""@functools.wraps(func)def wrapper(*args,**kw):print('%s \n %s开始调用函数：%s' %('接下来使用了functools.wraps(func)技术',who,func.__name__))return func(*args,**kw)return wrapperreturn decorator@log('小刘')def now():print('/11/10')now()now.__name__#################### 偏函数functools.partial()#functools 模块中主要包含了一些函数装饰器和便捷的功能函数。其中一个就是偏函数（Partial function）。#偏函数可以通过设定参数的默认值，从而降低函数调用的难度。#使用：functools.partial()用来创建一个偏函数，即把一个函数的某些参数给固定住（即设置默认值），返回一个新函数。#注意：偏函数实质上是一个 @装饰器 的原理，即在参数列表里追加进去 设置默认值的参数。#如：int2('1000') 实则是运行的 int('1000',base=2)#修改int()函数的默认base参数，来达到 N进制的转换。int('1000', base=8) #八进制：十位数上表示*8、百位数上表示64（8*8）、千位数上表示512（8*8*8）int('10000',base=2)#二进制：十位数上表示*2、百位数上表示4（2*2）、千位数上表示8（2*2*2）#使用：functools.partial()用来创建一个偏函数，即把一个函数的某些参数给固定住（即设置默认值），返回一个新函数。import functoolsint2=functools.partial(int,base=2)int2('1000')#注意：偏函数实质上是一个 @装饰器 的原理，即在参数列表里追加进去 设置默认值的参数。#如：int2('1000') 实则是运行的 int('1000',base=2)max2=functools.partial(max,10)max2(2,5,9) #max2(2,5,9) 实则是运行的max(2,5,9,10)
py函数式编程（高阶函数map/reduce/filter/sorted 闭包函数/返回函数 匿名函数lamber @装饰器decorator 偏函数functool.partial()）
