python 高级特性
迭代
字符串，元组，列表和字典都是可迭代的，使用下面的方法可以判定一个变量是否是可迭代的
>>> from collections import Iterable >>> isinstance('abc', Iterable) # str是否可迭代 True
可迭代对象调用 iter() 函数，可以得到一个迭代器。迭代器可以通过 next() 函数来得到下一个元素，从而支持遍历。
一般都是采用for...in进行迭代遍历。
列表生成式
对于需要迭代生成列表的形式可以改为使用一个语句实现
例如
>>> L = [] >>> for x in range(1, 11): ... L.append(x * x) ... >>> L [1, 4, 9, 16, 25, 36, 49, 64, 81, 100
可以改为
>>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
它的方法就是在一个[]内加入语句，将for...in内部的语句加到for的前面就可以实现，并且可以加不止一个for...in语句
>>> [x * x for x in range(1, 11) if x % 2 == 0] [4, 16, 36, 64, 100]
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
生成器
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器（Generator）。
要创建一个generator，有很多种方法。
方法一
第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
>>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x104feab40>
generator保存的是算法，每次调用next()，就计算出下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。
当然，上面这种不断调用next()方法实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：
>>> g = (x * x for x in range(10)) >>> for n in g: ... print n ... 0 1 4 9 16 25 36 49 64 81
generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。
比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：
def fib(max): n, a, b = 0, 0, 1 while n < max: print b a, b = b, a + b n = n + 1
上面的函数可以输出斐波那契数列的前N个数：
>>> fib(6)
1
1
2
3
5
8
仔细观察，可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print b改为yield b就可以了：
def fib(max): n, a, b = 0, 0, 1 while n < max: yield b a, b = b, a + b n = n + 1
这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：
>>> fib(6)
<generator object fib at 0x104feaaa0>
这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。
同样的，把函数改成generator后，我们基本上从来不会用next()来调用它，而是直接使用for循环来迭代：
>>> for n in fib(6):
... print n
...
1
1
2
3
5
8
迭代器和生成器只能被遍历一次，而列表和元组等却可以被重复遍历。
匿名函数
以下是匿名函数的格式：
lambda argument1, argument2,... argumentN : expression
匿名函数lambda x: x * x实际上就是：
def f(x): return x * x
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。
此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
>>> f = lambda x: x * x >>> f <function <lambda> at 0x10453d7d0> >>> f(5) 25
可以看到，匿名函数 lambda 和常规函数一样，它们的用法也极其相似，不过还是有下面几点区别。
第一，lambda 是一个表达式（expression），并不是一个语句（statement）。
因此，lambda 可以用在一些常规函数 def 不能用的地方，比如，lambda 可以用在列表内部，而常规函数却不能：
[(lambda x: x*x)(x) for x in range(10)] # 输出 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
再比如，lambda 可以被用作某些函数的参数，而常规函数 def 也不能：
l = [(1, 20), (3, 0), (9, 10), (2, -1)] l.sort(key=lambda x: x[1]) # 按列表中元组的第二个元素排序 print(l) # 输出 [(2, -1), (3, 0), (9, 10), (1, 20)]
第二，lambda 的主体是只有一行的简单表达式，并不能扩展成一个多行的代码块。
字典排序
# 字典排序 d = {'mike': 10, 'lucy': 2, 'ben': 30} # d.sort(key=lambda x: x[1]) # 按列表中元组的第二个元素排序,字典没有sort方法 dd = sorted(d.items(), key=lambda x: x[1], reverse=True)#可以指定根据key或者value排序，得到排好序的字典 print(dd) dd = sorted(d, key=lambda x: x[0], reverse=False) #此时是根据key中的第几个字母排序，并得到排好序的key元组 print(dd) dd = sorted(d.keys(), key=lambda x: x[0], reverse=False) #功能跟上面一样 print(dd) dd = sorted(d.values(), key=lambda x: x, reverse=False) #此时是根据value排序，并得到排好序的value元组 print(dd)
装饰器
假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。本质上，decorator就是一个返回函数的高阶函数。也就是闭包。比如：
def func_closure(): def get_message(message): print('Got a message: {}'.format(message)) return get_message send_message = func_closure() send_message('hello world') # 输出 Got a message: hello world
我们可以先来看一个装饰器的简单例子：
def my_decorator(func): def wrapper(): print('wrapper of decorator') func() return wrapper def greet(): print('hello world') greet = my_decorator(greet) greet() # 输出 wrapper of decorator hello world
这里的函数 my_decorator() 就是一个装饰器，它把真正需要执行的函数 greet() 包裹在其中，并且改变了它的行为，但是原函数 greet() 不变。
事实上，上述代码在 Python 中有更简单、更优雅的表示：
def my_decorator(func): def wrapper(): print('wrapper of decorator') func() return wrapper @my_decorator def greet(): print('hello world') greet()
@my_decorator就相当于前面的greet=my_decorator(greet)语句，只不过更加简洁。
带有参数的装饰器
通常情况下，我们会把*args和**kwargs，作为装饰器内部函数 wrapper() 的参数。*args和**kwargs，表示接受任意数量和类型的参数，因此装饰器就可以写成下面的形式：
def my_decorator(func): def wrapper(*args, **kwargs): print('wrapper of decorator') func(*args, **kwargs) return wrapper
带有自定义参数的装饰器
其实，装饰器还有更大程度的灵活性。刚刚说了，装饰器可以接受原函数任意类型和数量的参数，除此之外，它还可以接受自己定义的参数。
举个例子，比如我想要定义一个参数，来表示装饰器内部函数被执行的次数，那么就可以写成下面这种形式：
def repeat(num): def my_decorator(func): def wrapper(*args, **kwargs): for i in range(num): print('wrapper of decorator') func(*args, **kwargs) return wrapper return my_decorator @repeat(4) def greet(message): print(message) greet('hello world') # 输出： wrapper of decorator hello world wrapper of decorator hello world wrapper of decorator hello world wrapper of decorator hello world
原函数还是原函数吗？
元信息告诉我们“它不再是以前的那个 greet() 函数，而是被 wrapper() 函数取代了”。
为了解决这个问题，我们通常使用内置的装饰器@functools.wrap，它会帮助保留原函数的元信息（也就是将原函数的元信息，拷贝到对应的装饰器函数里）。
import functools def my_decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): print('wrapper of decorator') func(*args, **kwargs) return wrapper @my_decorator def greet(message): print(message) greet.__name__ # 输出 'greet'
类装饰器
类装饰器主要依赖于函数__call__()，每当你调用一个类的实例时，函数__call__()就会被执行一次。
class Count: def __init__(self, func): self.func = func self.num_calls = 0 def __call__(self, *args, **kwargs): self.num_calls += 1 print('num of calls is: {}'.format(self.num_calls)) return self.func(*args, **kwargs) @Count def example(): print("hello world") example() # 输出 num of calls is: 1 hello world example() # 输出 num of calls is: 2 hello world ...
Count类会被实例化一次，之后每次调用example方法，都会调用Count类实例的__call__方法
装饰器的嵌套
Python 也支持多个装饰器，比如写成下面这样的形式：
@decorator1 @decorator2 @decorator3 def func(): ...
它的执行顺序从里到外，所以上面的语句也等效于下面这行代码：
decorator1(decorator2(decorator3(func)))
这样，'hello world'这个例子，就可以改写成下面这样：
import functools def my_decorator1(func): @functools.wraps(func) def wrapper(*args, **kwargs): print('execute decorator1') func(*args, **kwargs) return wrapper def my_decorator2(func): @functools.wraps(func) def wrapper(*args, **kwargs): print('execute decorator2') func(*args, **kwargs) return wrapper @my_decorator1 @my_decorator2 def greet(message): print(message) greet('hello world') # 输出 execute decorator1 execute decorator2 hello world
也就是装饰器的执行顺序跟它定义的顺序保持一致。
装饰器用来增强跟业务功能无关的通用操作，比如身份认证，日志，合法性检查和缓存等等功能。
装饰器跟Java中的AOP功能是一样的，但是实现不一样，装饰器是通过闭包函数，AOP则是通过反射生成代理类。
函数式编程
Python 的函数式编程特性，这与我们今天所讲的匿名函数 lambda，有着密切的联系。
所谓函数式编程，是指代码中每一块都是不可变的（immutable），都由纯函数（pure function）的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。
举个很简单的例子，比如对于一个列表，我想让列表中的元素值都变为原来的两倍，我们可以写成下面的形式：
def multiply_2(l): for index in range(0, len(l)): l[index] *= 2 return l
这段代码就不是一个纯函数的形式，因为列表中元素的值被改变了，如果我多次调用 multiply_2() 这个函数，那么每次得到的结果都不一样。要想让它成为一个纯函数的形式，就得写成下面这种形式，重新创建一个新的列表并返回。
def multiply_2_pure(l): new_list = [] for item in l: new_list.append(item * 2) return new_list
函数式编程的优点，主要在于其纯函数和不可变的特性使程序更加健壮，易于调试（debug）和测试；
缺点主要在于限制多，难写。
当然，Python 不同于一些语言（比如 Scala），它并不是一门函数式编程语言，不过，Python 也提供了一些函数式编程的特性，值得我们了解和学习。
Python 主要提供了这么几个函数：map()、filter() 和 reduce()，通常结合匿名函数 lambda 一起使用。
map
它表示，对 iterable 中的每个元素，都运用 function 这个函数，最后返回一个新的可遍历的集合。比如刚才列表的例子，要对列表中的每个元素乘以 2，那么用 map 就可以表示为下面这样：
l = [1, 2, 3, 4, 5] new_list = map(lambda x: x * 2, l) # [2， 4， 6， 8， 10]
我们可以以 map() 函数为例，看一下 Python 提供的函数式编程接口的性能。还是同样的列表例子，它还可以用 for 循环和 list comprehension（目前没有统一中文叫法，你也可以直译为列表理解等）实现，我们来比较一下它们的速度：
python3 -mtimeit -s'xs=range(1000000)' 'map(lambda x: x*2, xs)' 2000000 loops, best of 5: 171 nsec per loop python3 -mtimeit -s'xs=range(1000000)' '[x * 2 for x in xs]' 5 loops, best of 5: 62.9 msec per loop python3 -mtimeit -s'xs=range(1000000)' 'l = []' 'for i in xs: l.append(i * 2)' 5 loops, best of 5: 92.7 msec per loop
你可以看到，map() 是最快的。因为 map() 函数直接由 C 语言写的，运行时不需要通过 Python 解释器间接调用，并且内部做了诸多优化，所以运行速度最快。
filter
filter(function, iterable) 函数，它和 map 函数类似，function 同样表示一个函数对象。filter() 函数表示对 iterable 中的每个元素，都使用 function 判断，并返回 True 或者 False，最后将返回 True 的元素组成一个新的可遍历的集合。
reduce
reduce(function, iterable) 函数，它通常用来对一个集合做一些累积操作。
表示对 iterable 中的每个元素以及上一次调用后的结果，运用 function 进行计算，所以最后返回的是一个单独的数值。
举个例子，我想要计算某个列表元素的乘积，就可以用 reduce() 函数来表示：
l = [1, 2, 3, 4, 5] product = reduce(lambda x, y: x * y, l) # 1*2*3*4*5 = 120
filter() 和 reduce() 的功能，也可以用 for 循环或者 list comprehension （列表推导）来实现。
关于map()、filter() 和 reduce()三个函数，需要注意的是：
- 1.map()在 Python 2.x 返回的是一个列表；而在 Python 3.x 中返回一个 map 类，可以看成是一个迭代器。
- 2.filter()在 Python 2.x 中返回的是过滤后的列表, 而在 Python 3.x 中返回的是一个 filter 类，可以看成是一个迭代器，有惰性运算的特性, 相对 Python2.x 提升了性能, 可以节约内存。
- 3.reduce() 函数在 Python3 中已经被从全局名字空间里移除了，它现在被放置在 functools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数。
python的纯函数编程跟Java的stream编程比较类似，都是可迭代对象结合lambda表达式使用。
