# 函数 基本上所有的高级语言都支持函数，Python 也不例外。Python 不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。 借助抽象，我们才能不关心底层的具体计算过程，而直接在更高的层次上思考问题。 写计算机程序也是一样，函数就是最基本的一种代码抽象的方式 ## 调用函数 要调用一个函数，需要知道函数的名称和参数 调用函数的时候，如果传入的参数数量不对，会报 TypeError 的错误， Python 内置的常用函数还包括数据类型转换函数，比如 int() 函数可以把其他数据类型转换为整数： ```js >>> int('123') 123 >>> int(12.34) 12 >>> float('12.34') 12.34 >>> str(1.23) '1.23' >>> str(100) '100' >>> bool(1) True >>> bool('') False ``` 函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个 “别名”： ```js >>> a = abs # 变量a指向abs函数 >>> a(-1) # 所以也可以通过a调用abs函数 1 ``` ## 定义函数 ### 定义函数 ```js def my_abs(x): if x >= 0: return x else: return -x ``` 函数体内部的语句在执行时，一旦执行到 return 时，函数就执行完毕，并将结果返回。 如果没有 return 语句，函数执行完毕后也会返回结果，只是结果为 None。return None 可以简写为 return。 如果你已经把 my_abs() 的函数定义保存为 abstest.py 文件了，那么，可以在**该文件**的当前目录下启动 Python 解释器，用 from abstest import my_abs 来导入 my_abs() 函数， > 注意 abstest 是文件名（不含.py 扩展名） ```js >>> from abstest import my_abs >>> my_abs(-9) 9 ``` 如果想定义一个什么事也不做的空函数，可以用 pass 语句： ```js def nop(): pass ``` 实际上 pass 可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个 pass，让代码能运行起来 ### 参数检查 调用函数时，如果参数个数不对，Python 解释器会自动检查出来，并抛出 TypeError，但是如果参数类型不对，Python 解释器无法帮我们检查。 我们可以修改一下 my_abs 的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数 isinstance() 实现： ```js def my_abs(x): if not isinstance(x, (int, float)): raise TypeError('bad operand type') if x >= 0: return x else: return -x ``` ### 返回多个值 ```js import math def move(x, y, step, angle=0): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx, ny ``` 然后调用函数 ```python >>> x, y = move(100, 100, 60, math.pi / 6) >>> r = move(100, 100, 60, math.pi / 6) >>> print(r) (151.96152422706632, 70.0) ``` 原来返回值是一个 tuple！但是，在语法上，返回一个 tuple 可以省略括号，而多个变量可以同时接收一个 tuple，按位置赋给对应的值，所以，Python 的函数返回多值其实就是返回一个 tuple，但写起来更方便。 ## 函数的参数 Python 的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数 ### 默认参数 一是必选参数在前，默认参数在后，否则 Python 的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）； 二是如何设置默认参数。 当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。 使用默认参数有什么好处？ 最大的好处是能降低调用函数的难度 > 定义默认参数要牢记一点：默认参数必须指向不变对象！ 因为函数在定义的时候，默认参数的值就被计算出来了，如果默认参数指向可变对象，每次调用的时候，默认参数的内容就改变了，不再是定义时的对象 。 比如 ```js def add_end(L=[]): L.append('END') return L ``` 当使用默认参数调用的时候， ```js >>> add_end() ['END'] ``` 但是再次调用的时候： ```js >>> add_end() ['END', 'END'] >>> add_end() ['END', 'END', 'END'] ``` 默认参数明明是 "[]"，但是函数每次都记住了上次添加'END'的list了 要修改上面的例子，我们可以用 None 这个不变对象来实现 ```js def add_end(L=None): if L is None: L = [] L.append('END') return L ``` 我们在编写程序的时候，如果可以设计一个不变对象，就尽量设计成不变对象。 因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。 此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有 ### 可变参数 顾名思义，可变参数就是传输的参数的个数是可变的。 由于要输入的参数个数是不确定的，所以可以将参数作为一个list或者tuple传进来。 ```js def calc(numbers): sum = 0 for n in numbers: sum = sum + n * n return sum >>> calc([1, 2, 3]) 14 ``` 这样在调用的时候，需要将参数先组装成list或者tuple，如果利用可变参数，可以将调用方式简化为： ```js def calc(*numbers): sum = 0 for n in numbers: sum = sum + n * n return sum ``` 与定义一个list参数相比，仅仅在参数前面加了一个*号。 在函数内部，参数numbers仍然被当作一个tuple 如果已经有一个list或者tuple，，要调用一个可变参数怎么半？ 可以在传入的时候，在list前面加一个*号， ```js >>> nums = [1, 2, 3] >>> calc(*nums) 14 ``` ### 关键字参数 上面我们讲到了可变参数，它允许我们传入任意个参数，这些参数可以在函数调用的时候自动组装成一个tuple，适用于可能传入任意个数个参数的情况。 有的时候，我们还希望参数的关键字也不固定，所以可以传入一个dict，然后在函数内部自动组装成一个dict ```js def person(name, age, **kw): print('name:', name, 'age:', age, 'other:', kw) ``` 我们可以传视频入任意个数的关键字 ```js >>> person('Adam', 45, gender='M', job='Engineer') name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'} ``` 这样可以扩展函数的功能，比如说现在在做一个用户注册功能，除了用户名和年龄是必选项，其他的都是可选项，利用关键字来定义函数就可以满足这个要求。 同样，我们也可以先组装成一个dict，然后把该dict转换成关键字传进去。 ```js >>> extra = {'city': 'Beijing', 'job': 'Engineer'} >>> person('Jack', 24, **extra) name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'} ``` > **extra 表示把 extra 这个 dict 的所有 key-value 用关键字参数传入到函数的 **kw 参数，kw 将获得一个 dict，注意 kw 获得的 dict 是 extra 的一份拷贝，对 kw 的改动不会影响到函数外的 extra。 ### 命名关键字参数 如果要限制关键字参数的名字，例如只接受city和job作为关键字参数， ```js def person(name, age, *, city, job): print(name, age, city, job) >>> person('Jack', 24, city='Beijing', job='Engineer') Jack 24 Beijing Engineer ``` *号后面的参数被视为命名关键字参数。 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符 * 了 ```js def person(name, age, *args, city, job): print(name, age, args, city, job) ``` 使用命名关键字参数，需要注意，必须得传入参数名，如果没有传入的话，调用将会报错。 ```js >>> person('Jack', 24, 'Beijing', 'Engineer') Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: person() takes 2 positional arguments but 4 were given ``` 同样命名关键字参数可以有缺省值 ```js def person(name, age, *, city='Beijing', job): print(name, age, city, job) # 调用的时候可以不传入有默认值的 city参数 >>> person('Jack', 24, job='Engineer') Jack 24 Beijing Engineer ``` ### 参数的组合 在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数、命名关键字参数 而且这5种参数可以组合使用， 但是需要注意一定的顺序：必选参数、默认参数、可变参数、命名关键字参数、关键字参数 比如 ```js def f1(a, b, c=0, *args, **kw): print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw) def f2(a, b, c=0, *, d, **kw): print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw) ``` 在函数调用的时候，Python 解释器自动按照参数位置和参数名把对应的参数传进去。 如果通过一个 tuple 和 dict，你也可以调用上述函数： ```js >>> args = (1, 2, 3, 4) >>> kw = {'d': 99, 'x': '#'} >>> f1(*args, **kw) a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'} >>> args = (1, 2, 3) >>> kw = {'d': 88, 'x': '#'} >>> f2(*args, **kw) a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'} ``` 对于任意函数，都可以通过类似 func(*args, **kw) 的形式调用它，无论它的参数是如何定义的。 ### 小结 Python 的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。 默认参数一定要用 **不可变对象**，如果是可变对象，程序运行时会有逻辑错误！ 要注意定义可变参数和关键字参数的语法： *args 是可变参数，args 接收的是一个 tuple； **kw 是关键字参数，kw 接收的是一个 dict。 以及调用函数时如何传入可变参数和关键字参数的语法： 可变参数既可以直接传入：func(1, 2, 3)，又可以先组装 list 或 tuple，再通过 *args 传入：func(*(1, 2, 3))； 关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装 dict，再通过 **kw 传入：func(**{'a': 1, 'b': 2})。 使用 *args 和 **kw 是 Python 的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。 命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。 定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符 *，否则定义的将是位置参数。 ## 递归函数 如果一个函数在内部调用自身本身，这个函数就是递归函数。 比如说阶乘，使用递归方式写出来就是 ```python def fact(n): if n == 1: return 1 return n * fact(n - 1) ``` 如果我们计算 fact(5)，可以根据函数定义看到计算过程如下： ===> fact(5) ===> 5 * fact(4) ===> 5 * (4 * fact(3)) ===> 5 * (4 * (3 * fact(2))) ===> 5 * (4 * (3 * (2 * fact(1)))) ===> 5 * (4 * (3 * (2 * 1))) ===> 5 * (4 * (3 * 2)) ===> 5 * (4 * 6) ===> 5 * 24 ===> 120 如果我们计算 fact(5)，可以根据函数定义看到计算过程如下： ```js ===> fact(5) ===> 5 * fact(4) ===> 5 * (4 * fact(3)) ===> 5 * (4 * (3 * fact(2))) ===> 5 * (4 * (3 * (2 * fact(1)))) ===> 5 * (4 * (3 * (2 * 1))) ===> 5 * (4 * (3 * 2)) ===> 5 * (4 * 6) ===> 5 * 24 ===> 120 ``` 递归函数的优点在于定义简单，逻辑清晰。理论上所有的递归函数都可以写成循环的方式，但是循环的方式不如递归清晰。 但是使用递归函数需要注意栈溢出。 如果递归调用次数过多，就会导致栈溢出。 可以使用 **尾递归**来进行优化。 也就是说，在函数返回的时候，调用自身本身，并且return语句不能包含表达式。这样，编译器会把尾递归做优化，不管调用多少次，都只占用一个栈帧 比如说 `fact(n)` ```python def fact(n): return fact_iter(n, 1 ) def fact_iter(num , product): if num == 1: return product return fact_iter ( num -1 , num * product) ``` 可以看到，return fact_iter(num - 1, num * product) 仅返回递归函数本身，num - 1 和 num * product 在函数调用前就会被计算，不影响函数调用。 fact(5) 对应的 fact_iter(5, 1) 的调用如下： ```js ===> fact_iter(5, 1) ===> fact_iter(4, 5) ===> fact_iter(3, 20) ===> fact_iter(2, 60) ===> fact_iter(1, 120) ===> 120 ``` 尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。 遗憾的是，大多数编程语言没有针对尾递归做优化，Python 解释器也没有做优化，所以，即使把上面的 fact(n) 函数改成尾递归方式，也会导致栈溢出。 # 函数式编程 函数是 Python 内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为**面向过程的程序设计**。函数就是面向过程的程序设计的基本单元。 而函数式编程——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。 函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。 而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。 函数式编程的一个**特点**就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！ Python 对函数式编程提供部分支持。由于 Python 允许使用变量，因此，Python 不是纯函数式编程语言。 ## 高阶函数 变量可以指向函数，而函数的参数能接收变量，所以一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。 ### 变量指向函数 对于Python内置的函数 `abs()`，如果只写 `abs` ```js >>> abs <built-in function abs> ``` 我们可以把函数本身赋给变量 ```js >>> f = abs >>> f <built-in function abs> ``` 这样变量就指向了函数。 这个时候，可以使用该变量来调用函数 ```js >>> f = abs >>> f(-10) 10 ``` 那么函数名其实就是指向函数的变量。 所以说高阶函数指的就是一个函数可以接收另一个函数作为参数。 ```js def add(x, y, f): return f(x) + f(y) add(-5, 6, abs) ``` 把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。 ### map reduce Python内建了 map()和reduce() map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素中。并且把新的结果作为新的Iterable返回。 比如我们有一个函数 f (x)=x2，要把这个函数作用在一个 list [1, 2, 3, 4, 5, 6, 7, 8, 9] 上，就可以用 map() 实现如下： ```js f(x) = x * x │ │ ┌───┬───┬───┬───┼───┬───┬───┬───┐ │ │ │ │ │ │ │ │ │ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ [ 1 2 3 4 5 6 7 8 9 ] │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ ▼ [ 1 4 9 16 25 36 49 64 81 ] ``` 使用代码实现： ```js >>> def f(x): ... return x * x ... >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> list(r) [1, 4, 9, 16, 25, 36, 49, 64, 81] ``` map() 传入的第一个参数是 f，即函数对象本身。由于结果 r 是一个 Iterator，Iterator 是惰性序列，因此通过 list() 函数让它把整个序列都计算出来并返回一个 list。 同样，如果我们不使用 `map()`函数，使用循环也可以得到这样的计算结果，但是使用循环，就不能一眼看明白把 f (x) 作用在 list 的每一个元素并把结果生成一个新的 list map() 作为高阶函数，事实上它把运算规则抽象了 我们甚至可以定义更复杂的函数，比如说将list所有数字都转换成字符串 ```python list(map(str,[1,2,3,4,5])) ``` 再看 reduce. reduce把一个函数作用在一个序列上，这个序列必须接收两个参数，它会把结果继续和序列的下一个元素做累积计算。 ```python reduce(f,[x1,x2,x3,x4])=f(f(f(x1,x2),x3),x4) ``` 首先是将f作用到x1和x2上，然后再把得到的值与x3一起带入f里面。 比如说对一个序列求活，或者把序列变成整数 ```python from functools import reduce def f (x,y): return x*10 + y reduce(fn , [1,3,4,5]) ``` 我们将这个例子稍加改动就可以写出str转int的函数。 对于一个str序列里面每一个元素，使用map将其转换成 int类型。 然后再使用reduce将其归并到一起。 ```python from functools imprt reduce def char2num(s): digit = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} return digit[s] def fn (x, y ): return x * 10 +y reduce(fn , map(char2num, "12345")) ``` 可以整理成一个函数，并且使用lambda函数进行简化 ```python 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)) ``` ### filter 与map()类似，filter()也接收一个函数和一个序列。 filter()把传入函数依次作用于每一个元素，然后根据返回值是True还是False来决定保留还是丢弃元素 比如说我们可以先定义一个规则 ```python def is_odd(n): return n % 2 == 1 ``` 如果 输入的n除以2 余数为1 的话，说明n为奇数。 然后使用filter函数将奇数过滤出来 ```python list(filter(is_odd , [1,2,3,4,5,6])) # 结果为[1,3,5] ``` 也可以把一个序列的空字符串删除掉 ```Python # 因为需要把不为空的过滤出来，所以定义一个函数，如果字符不为空，则返回1 def not_empty(s): return s and s.strip() list(filter(not_empty , ['A',"","B",None])) ``` 我们知道，如果为空，则求他的bool值为0 我们可以使用filter来求素数 计算素数的一个方法是埃氏筛法 第一步，需要列出从2开始所有自然数，构成一个序列 取序列中的第一个数2，它一定是素数，然后把2的倍数给筛选掉 取新序列的第一个数3，然后把3的倍数筛掉。 同理可推其他步骤 我们可以构建一个从3开始的奇数序列 ```python def _odd_iter(): n = 1 while True: n = n + 2 yield n ``` 这是应该 生成器，而且是一个无限序列 然后定义一个筛选器 ```python # 不是n的倍数的值需要被筛选出来 def _not_divisible(n): return lambda x: x % n > 0 ``` 最后定义一个生成器，不断返回下一个素数 ```pythoh def prime(): yield 2 it = _odd_iter ()#初始序列 while True: n = next (it) # 返回序列中的第一个数 yield n it = filter (_not_divisible(n) , it) ``` 由于 primes() 也是一个无限序列，所以调用时需要设置一个退出循环的条件： ```js # 打印1000以内的素数: for n in primes(): if n < 1000: print(n) else: break ``` ### sorted 排序的核心是比较两个元素的大小。 如果是数字，则可以直接进行比较，但是如果是字符串呢？直接比较数学上的大小是没有意义的 ，我们可以使用函数来自定义比较的过程。 sorted() 函数也是一个高阶函数，它还可以接收一个 key 函数来实现自定义的排序，例如按绝对值大小排序： ```Python sorted([36, 5, -12, 9, -21], key=abs) ``` 再比如，对于字符串排序，默认情况下，是按照ASCII大小比较的。也就是说 ，有于 'Z' < 'a'， 所以大写字母Z会排在小写字符a的前面。 但是我们更希望能忽略大小写 ```python sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) ``` ## 返回函数 对于一个可变参数的求和 ```js def calc_sum(*args): ax = 0 for n in args: ax = ax + n return ax ``` 但是，如果不需要立刻求和，而是需要在后面的代码里面根据需要再计算？ 可以返回求和的函数，而不是求和的结果 ```python def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum ``` 当我们调用 lazy_sum() 时，返回的并不是求和结果，而是求和函数： ```js >>> f = lazy_sum(1, 3, 5, 7, 9) >>> f <function lazy_sum.<locals>.sum at 0x101c6ed90> ``` 调用函数 f 时，才真正计算求和的结果： ```python f() 25 ``` 我们在函数 lazy_sum中又定义了一个sum函数，并且内部函数sum可以引用外部函数lazy_sum的参数和局部变量。 同时，当lazy_sum返回函数sum的时候，相关参数和变量都是保存在返回的函数中的，这种程序结构叫做“闭包” 另外返回的函数并没有立刻执行，而是直到调用了 f() 才执行 ```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()，f2() 和 f3() 结果应该是 1，4，9，但实际结果是： ```js >>> f1() 9 >>> f2() 9 >>> f3() 9 ``` 全部都是 9！原因就在于返回的函数引用了变量 i，但它并非立刻执行。等到 3 个函数都返回时，它们所引用的变量 i 已经变成了 3，因此最终结果为 9。 > 返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。 > 也就是返回的函数的外层不能有循环变量 另外，当我们调用lazy_sum()的时候，每次调用都会返回一个新的函数，这两个函数的调用结果互不影响。 ```js >>> f1 = lazy_sum(1, 3, 5, 7, 9) >>> f2 = lazy_sum(1, 3, 5, 7, 9) >>> f1==f2 False ``` ## 匿名函数 lambda 匿名函数有个限制，就是只能有一个表达式，不用写 return，返回值就是该表达式的结果 用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。 此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数： ## 装饰器 假设需要增强now函数的功能，比如说在函数调用前自动打印日志，这种在代码运行期间动态增加功能的方式称为 “装饰器” 本质上， decorator就是一个返回函数的高阶函数。 ```python def log(func): def wrapper(*args, **kw): print ('call %s():' % func.__name__) return func(*args , **kw) return wrapper ``` 函数其实就是一个对象，同时，函数对象有一个 `__name__`属性，可以拿到函数的名字 ```python now.__name__ 'now' ``` 观察上面的 log，因为它是一个 decorator，所以接受一个函数作为参数，并返回一个函数。 那么如何调用呢？ 可以把decorator置于函数的定义处 ```python @log def now(): print('2015-03-25') ``` 调用now()函数的时候，不仅会运行函数本身，还会在函数前打日志 ```js >>> now() call now(): 2015-3-25 ``` 把 @log 放到 now() 函数的定义处，相当于执行了语句： ```js now = log(now) ``` 由于 log() 是一个 decorator，返回一个函数，所以，原来的 now() 函数仍然存在，只是现在同名的 now 变量指向了新的函数，于是调用 now() 将执行新函数，即在 log() 函数中返回的 wrapper() 函数。 如果 decorator 本身需要传入参数，那就需要编写一个返回 decorator 的高阶函数，写出来会更复杂。比如，要自定义 log 的文本： ```python 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 用法如下： ```js @log('execute') def now(): print('2015-3-25') ``` 执行结果如下： ```python >>> now() execute now(): 2015-3-25 ``` 和两层嵌套的 decorator 相比，3 层嵌套的效果是这样的： ```python >>> now = log('execute')(now) ``` 首先执行 `log('execute')`，返回的是 decorator函数，再调用返回的函数，参数是now函数，返回的是 wrapper 另外，还需要把原始函数的__name__等属性复制到 wrapper() 函数中，否则，有些依赖函数签名的代码执行就会出错。 Python 内置的 functools.wraps可以实现 `wrapper.__name__ = func.__name__`这样的功能。 所以一个完整的decorator的写法是 ```Python import functools def log (func): @functools.wraps(func) def wrapper(*args, **kw): print ('call %s():' % func.__name__) return func(*args , **kw) return wrapper ``` 或者针对带参数的decorator ```python 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 ``` ## 偏函数 当函数的参数个数太多，需要简化的时候，可以使用 `functools.partial`可以创建一个新的函数，这个新的函数可以固定住原函数的部分参数，从而在调用的时候更简单。 这就是 偏函数(partial function) 比如说 int()默认将字符串转成十进制整数，这里面base参数的值默认为10 但是假设我们需要大量转换成二进制字符，如果要每次都传入 int(x , base = 2)非常的麻烦，所以可以再定义一个 `int2` ```python import functools int2 = functools.partial(int , base = 2 ) ``` functools.partial 的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。 ## 柯里化 最简单的柯里化 (currying) 指的是将原来接收 2 个参数的函数 f (x, y) 变成新的接收 1 个参数的函数 g (x) 的过程，其中新函数 g = f (y)。 以普通的加法函数为例： ```python def add1(x, y): return x + y ``` 通过嵌套函数可以把函数 add1 转换成柯里化函数 add2。 ```python def add2(x): def add(y): return x + y return add ``` 仔细看看函数 add1 和 add2 的参数 - add1：参数是 x 和 y，输出 x + y - add2：参数是 x，输出 x + y - g = add2(2)：参数是 y，输出 2 + y 下面代码也证实了上述分析： ```python add1 add2 g = add2(2) g <function __main__.add1(x, y)> <function __main__.add2(x)> <function __main__.add2.<locals>.add(y)> ``` - add1：参数是 x 和 y，输出 x + y - add2：参数是 x，输出 x + y - g = add2（2）：参数是 y，输出 2 + y 比较「普通函数 add1」和「柯里化函数 add2」的调用，结果都一样。 ```python print( add1(2, 3) ) print( add2(2)(3) ) print( g(3) ) 5 5 5 ``` # 解析式 解析式是将一个可迭代对象转换成另一个可迭代对象的工具。 不严谨的说，容器类型数据(str,tuple,list,dict,set)都是可迭代对象。 - 第一个可迭代对象：可以是任意容器类型数据 - 第二个可迭代对象：需要看是什么类型的解析试 - 列表解析式：可迭代对象是list - 字典解析式：可迭代对象是dict - 集合解析式：可迭代对象是set 解析式就是为了把「带条件的 for 循环」简化成一行代码的。 列表解析式整个语句用「中括号 []」框住，而字典和集合解析式整个语句中「大括号 {}」框住。想想 list, dict 和 set 用什么括号定义就明白了 ```python # list comprehension [值 for 元素 in 可迭代对象 if 条件] # dict comprehension {键值对 for 元素 in 可迭代对象 if 条件} # set comprehension {值 for 元素 in 可迭代对象 if 条件} ``` 根据 input-operation-output 这个过程总结： - input：任何「可迭代数据 A」 - operation：用 for 循环来遍历 A 中的每个元素，用 if 来筛选满足条件的元素 Agood - output：将 Agood 打包成「可迭代数据」，生成列表用 []，生成列表用 {} ## 列表解析式 如何从一个含整数列表中把奇数挑出来？ ```python odds = [n * 2 for n in lst if n % 2 == 1] ```  你可以把「for 循环」到「解析式」的过程想像成一个「复制 - 粘贴」的过程： - 将「for 循环」的新列表复制到「解析式」里 - 将 append 里面的表达式 n * 2 复制到 新列表里 - 复制循环语句 for n in lst 到新列表里，不要最后的冒号 - 复制条件语句 if n%2 == 1 到新列表里，不要最后的冒号 在把上面具体的例子推广到一般的例子，从「for 循环」到「列表解析式」的过程如下：  上面「for 循环」只有一层，如果两层怎么转换「列表解析式」？ 套用一维列表解析式的做法  两点需要注意： - 该例没有「if 条件」条件，或者认为有，写成「if True」。如果有 「if 条件」那么直接加在「内 for 循环」后面。 - 「外 for 循环」写在「内 for 循环」前面。 ## 其他解析式 可以举一反三 比如说字典解析式  ## 小结 再回顾下三种解析式，我们发现其实它们都可以实现上节提到的 filter 和 map 函数的功能，用专业计算机的语言说，解析式可以看成是 filter 和 map 函数的语法糖 - 语法糖 (syntactic sugar)：指计算机语言中添加的某种语法，对语言的功能没有影响，但是让程序员更方便地使用。 - 语法盐 (syntactic salt)：指计算机语言中添加的某种语法，使得程序员更难写出坏的代码。 - 语法糖浆 (syntactic syrup)：指计算机语言中添加的某种语法，没能让编程更加方便。 为什么说「列表解析式」是 「map/filter」的语法糖，两者的类比图如下：  两者的主要作用就是将原列表根据某些条件转换成新列表， 再者 - 列表解析式用 if条件来做筛选得到item，然后再用f函数作用到item上 - map/filter：用filter函数做筛选，再用map函数作用在筛选的元素上。 「列表解析式」是种更简洁的方式。 用「在列表中先找出奇数再乘以 2」，如果用列表解析式来实现 ```python [n * 2 for n in lst if n % 2 == 1] ``` 如果使用 map/filter来实现 ```python list(map(lambda n: n*2 , filter (lambda n : n%2 == 1 , lst))) ``` ## 小例子 用解析试将二维元组里面的每个元素提取出来并存储到一个列表中 ```python tup = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ``` 先遍历第一层元组，用 for t in tup，然后遍历第二层元组，用 for x in t，提取每个 x 并 " 放在 “列表中，用 [] ```python flattend = [x for t in tup for x in t] ```  如果我们想把上面「二维元组」转换成「二维列表」呢？ ```python [[x for x in t ] for t in tup ] ``` ## 复杂例子 用解析试把不规则的列表a打平 ```python a = [1, 2, [3, 4], [[5, 6], [7, 8]]] ``` 用解析式一步到位解决上面问题有点难，特别是列表 a 不规则，每个元素还可以是 n 层列表，因此我们需要递推函数 (recursive function)，即一个函数里面又调用自己。 ```python def f(x): if type(x) is list: return [ y for l in x for y in f(l)] else: return [x] a = [1, 2, [3, 4], [[5, 6], [7, 8]]] f(a) ``` 把整个列表遍历一遍，有四个元素， 1, 2, [3,4]和[[5,6],[7,8]] 当x是元素的时候（不是list），返回[x] - f(1)的返回值为[1] - f(2)的返回值为[2] 当x是列表的时候，会执行 `[y for l in x for y in f(l)]` 当 `x=[3,4]` - `for l in x`：指的是x里面每个元素l，那么l遍历3和4 - `for y in f(l)`：指的是f(l)里面每个元素y - 当l= 3 ，由于是一个元素，所以 `f(l)=[3]`，y遍历3 - 当l=4，由于是一个元素，那么f(l) = [4]，y遍历4 整个 f ([3 ,4]) 的返回值是 [3 ,4]。同理，当 x = [[5, 6], [7, 8]] 时，f (x) 的返回值是 [5, 6, 7, 8]。 把这所有的 y 再合成一个列表不就是 ```python [1, 2, 3, 4, 5, 6, 7, 8] ``` 再写成匿名函数 ```python a = [1, 2, [3, 4], [[5, 6], [7, 8]]] f = lambda x: [y for l in x for y in f(l)] if type(y) is list else [x] ```  # 总结 优雅清晰是 python 的核心价值观，高阶函数和解析式都符合这个价值观。 函数包括正规函数 (用 def) 和匿名函数 (用 lambda)， 函数的参数形态也多种多样，有位置参数、默认参数、可变参数、关键字参数、命名关键字参数。 匿名函数主要用在高阶函数中，高阶函数的参数可以是函数 (Python 里面内置 map/filter/reduce 函数)，返回值也可以是参数 (闭包、偏函数、柯里化函数)。 解析式并没有解决新的问题，只是以一种更加简洁，可读性更高的方式解决老的问题。解析式可以把「带 if 条件的 for 循环」用一行程序表达出来，也可以实现 map 加 filter 的功能。