递归函数, 匿名函数, yield from

递归函数

函数执行流程

http://pythontutor.com/visualize.html#mode=edit

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

def foo1(b, b1=3):     print('foo1 called', b, b1)   def foo2(c):     foo3(c)     print('foo2 called', c)   def foo3(d):     print('foo3 called', d)   def main():     print('main called')     foo1(100, 101)     foo2(200)     print('main ending')   main()   # 执行结果: main called foo1 called 100 101 foo3 called 200 foo2 called 200 main ending

1)  全局帧中生成foo1,foo2,foo3,main函数对象.   2)  main函数调用.   3)main中查找内建函数print压栈,将常量字符串压栈,调用函数,弹出栈顶.   4)main中全局查找函数foo1压栈,将常量100,101压栈,调用函数foo1,创建栈帧.print函数压栈,字符串和变量b,b1压栈,调用函数,弹出栈顶,返回值.   5)main中全局查找foo2函数压栈,将常量200压栈,调用foo2,创建栈帧.foo3函数压栈,变量c引用压栈,调用foo3,创建栈帧.foo3完成print函数调用后返回.foo2恢复调用,执行print后,返回值.main中foo2调用结束弹出栈顶,main继续执行print函数调回,弹出栈顶.main函数返回.

递归Recursion

    递归动态图示: http://codingpy.com/article/10-gifs-to-understand-some-programming-concepts/

    函数直接或间接调用自身就是递归.

    递归需要有边界条件,递归前进段,递归返回段.

    递归一定要有边界条件.

    当边界条件不满足的时候,递归前进.

    当边界条件满足的时候,递归返回.  

   

    斐波那契数列:

    如果设F(n)为该数列的第n项,(n∈N-1),那么这句话可以写成:F(n) = F(n-1) + F(n-2)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# F(0) = 0, F(1) = 1, F(n) = F(n-1)+F(n-2) pre = 0 cur = 1 print(pre, cur, end=' ') n = 4   for i in range(n-1):     pre, cur = cur, pre + cur     print(cur, end=' ')   # 运行结果: 0 1 1 2 3

# F(0) = 0, F(1) = 1, F(n) = F(n-1)+F(n-2) def fib(n):     return 1 if n < 2 else fib(n-1) + fib(n-2)   for i in range(4):     print(fib(i), end = ' ')   # 运行结果: 1 1 2 3   # 解析: fib(3) + fib(2). fib(3)调用fib(3), fib(2), fib(1). fib(2)调用fib(2), fib(1). fib(1)是边界.

     递归要求:

       递归一定要有退出条件,递归调用一定要执行到这个退出条件.没有退出条件的递归调用,就是无限调用.

       递归调用的深度不宜过深:

           python对递归调用的深度做了限制.

           超过递归深度限制,抛出RecursionError:maxinum recursion depth exceeded超出最大深度.

           sys.getrecursionlimit().

递归的性能

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# for循环. import datetime start = datetime.datetime.now() pre = 0 cur = 1 print(pre, cur, end=' ') n = 35 for i in range(n-1):     pre, cur = cur, pre + cur     print(cur, end=' ') delta = (datetime.datetime.now() - start).total_seconds() print(delta)   # 运行结果: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 0.0

# 递归: import datetime n = 35 start = datetime.datetime.now() def fib(n):     return 1 if n < 2 else fib(n-1) + fib(n-2) for i in range(n):     print(fib(i), end=' ') delta = (datetime.datetime.now() - start).total_seconds() print(delta)   # 运行结果: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 8.26452

    循环稍微复杂一些,但是只要不是死循环,可以多次迭代直至算出结果.

    fib函数代码极简易懂,但是只能获取到最外层的函数调用,内部递归结果都是中间结果,而且给定一个n都要进行2n次递归,深度越深,效率越低.

    为了获取斐波那契数列需要外面再套一个n次的循环,效率就更低了.

    递归还有深度限制,如果递归复杂,函数反复压栈,栈内存很快就溢出了.

    斐波那契数列的改进:

1 2 3 4 5 6 7 8 9 10 11 12 13

pre = 0 cur = 1 print(pre, cur, end = ' ') def fib(n, pre=0, cur=1):     pre, cur = cur, pre + cur     print(cur, end = ' ')     if n == 2:         return     fib(n-1, pre, cur)   fib(4)

# 改进 1)左边的fib函数和循环的思想类似. 2)参数n是边界条件,用n来计数. 3)上一次的计算结果直接作为函数的实参. 4)效率很高. 5)和循环相比,性能近似,所以并不是说递归一定效率低下,但是递归有深度限制.

间接递归

1 2 3 4 5 6 7 8

# 间接递归 def foo1():     foo2()   def foo2():     foo1()   foo1()

    间接递归,是通过别的函数调用了函数自身.

    但是,如果构成了循环递归是非常危险的,但是往往这种情况在复杂代码情况下,还是可能发生这种调用.要用代码规范来避免这种递归调用的发生.

递归总结

    递归是一种很自然的表达,符合逻辑思维.

    递归相对运行效率低,每一次调用函数都要开辟栈帧.

    递归有深度限制,如果递归层次太深,函数反复压栈,栈内存很快就溢出了.

   如果是有限次数的递归,可以使用递归调用,或者使用循环代替,循环代码稍微要复杂一些,但是只要不是死循环,可以多次迭代直至算出结果.

    绝大多数递归,都可以使用循环实现.

    即使递归代码很简洁,但是能不用则不用递归.

匿名函数

    匿名,即没有名字.

    匿名函数,即没有名字的函数.

       没有名字如何定义?

       没有名字如何调用?

       如果能调用,如何使用?

    python借助lambda表达式构建匿名函数.

    格式:

       lambda 参数列表: 表达式

    如:

       lambda x: x**2

       (lambda x: x**2)(4)  # 调用.

       foo = lambda x,y:(x+y)**2  # 不推荐这么用.

       foo(2,1)

       def foo(x,y):  # 建议使用普通函数.

           return (x+y)**2

       foo(2,1)

   

    使用lambda关键字来定义匿名函数.

    参数列表不需要小括号.

    冒号是用来分割参数列表和表达式的.

    不需要使用return,表达式的值,就是匿名函数返回值.

    lambda表达式(匿名函数)只能写在一行上,被称为单行函数.

   

    用途: 在高阶函数传参时,使用lambda表达式,往往能简化代码.

1 2 3 4 5 6 7 8 9 10

print((lambda :0)()) print((lambda x, y=3: x + y)(5)) print((lambda x, y=3: x + y)(5, 6)) print((lambda x, *, y=30: x + y)(5)) print((lambda x, *, y=30: x + y)(5, y=10)) print((lambda *args: (x for x in args))(*range(5))) print((lambda *args: [x+1 for x in args])(*range(5))) print((lambda *args: {x+2 for x in args})(*range(5))) [x for x in (lambda *args: map(lambda x: x+1, args))(*range(5))] # 高阶函数. [x for x in (lambda *args: map(lambda x: (x+1,args), args))(*range(5))]

生成器

    生成器generator  

       生成器指的是生成器对象,可以由生成器表达式得到,也可以使用yield关键字得到一个生成器函数,调用这个函数得到一个生成器对象. 

    生成器函数:

       函数体中包含yield语句的函数,返回生成器对象.

       生成器对象,是一个可迭代对象,是一个迭代器.

       生成器对象,是延迟计算,惰性求值的.

举例:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

def inc():     for i in range(5):         yield i print(type(inc)) print(type(inc())) x = inc() print(type(x)) print(next(x)) for m in x:     print(m, '*') for m in x:     print(m, '**')   # 运行结果: <class 'function'> <class 'generator'> <class 'generator'> 0 1 * 2 * 3 * 4 *

y = (i for i in range(5)) print(type(y)) print(next(y)) print(next(y))   # 运行结果: <class 'generator'> 0 1

   

    普通的函数调用fn(),函数会立即执行完毕,但是生成器函数可以使用next函数多次执行.

    生成器函数等价于生成器表达式,只不过生成器函数可以更加的复杂. 

   举例:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

def gen():     print('line 1')     yield 1     print('line 2')     yield 2     print('line 3')     return 3 next(gen()) # line 1 next(gen()) # line 1 g = gen() print(next(g)) # line 1 print(next(g)) # line 2 # print(next(g)) # StopIteration, 此处生成器找不到yield所以抛异常. print(next(g, 'End')) # 没有元素给个缺省值.   # 运行结果: line 1 line 1 line 1 1 line 2 2 line 3 End

在生成器函数中,使用多个yield语句,执行一次后会暂停执行,把yield表达式的值返回.

再次执行,会执行到下一个yield语句.

return语句依然可以终止函数运行,但return语句的返回值不能被获取到.

return会导致无法继续获取下一个值,抛出StopIteration异常.

如果函数没有显示的return语句,如果生成器函数执行到结尾,一样会抛出异常StopIteration.

生成器函数:

    包含yield语句的生成器函数生成生成器对象的时候,生成器函数的函数体不会立即执行.

    next(generator)会从函数的当前位置向后执行之后碰到的第一个yield语句,会弹出值,并暂停函数执行.

    再次调用next函数,和上一条一样的处理过程.

    没有多余的yield与能被执行,继续调用next函数,会抛异常StopIteration.

生成器应用

    生成器函数:

       包含yield语句的生成器函数生成生成器的时候,生成器函数的函数体不会立即执行.  

    next(generator)会从函数的当前位置向后执行到之后碰到的一个yield语句,会弹出值,并暂停函数执行.

       再次调用next函数,和上一条一样的处理过程.

       没有多余的yield语句能被执行,继续调用next函数,会抛异常StopIterator.  

       判断一个函数是否为generator函数: 使用isgeneratorfunction判断.

In [6]: from inspect import isgeneratorfunction

In [7]: isgeneratorfunction(func)

Out[7]: True

要注意区分 fab 和 fab(5)，fab 是一个 generator function，而 fab(5) 是调用 fab 返回的一个 generator.

>>> from collections import Iterable

>>> isinstance(fab, Iterable)

False

>>> isinstance(fab(5), Iterable)

True

    在一个 generator function 中，如果没有 return，则默认执行至函数完毕，如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def counter():     i = 0     while True:         i += 1         yield i def inc(c):     return next(c) c = counter() print(inc(c)) print(inc(c))  # 对同一函数对象进行操作.   # 运行结果: 1 2

def counter():     i = 0     while True:         i += 1         yield i def inc():     c = counter()     return next(c) print(inc()) print(inc()) print(inc())  # 对三个不同的函数对象进行操作.   # 运行结果: 1 1 1

       计数器:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def inc():     def counter():         i = 0         while True:             i += 1             yield i     c = counter()     return lambda : next(c) foo = inc() print(foo()) print(foo())   # 运行结果: 1 2

Lambda表达式是匿名函数. Return返回的是一个匿名函数.   左边第8行等价于: def _inc():     return next(c) return _inc

    处理递归问题:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

def fib():     x = 0     y = 1     while True:         yield y         x, y = y, x+y   foo = fib() for _ in range(5):     print(next(foo))   for _ in range(100):     # print(next(foo))     next(foo)   print(next(foo))   # 运行结果: 1 1 2 3 5 6356306993006846248183

# 等价于下面代码:   pre = 0 cur = 1 print(pre, cur, end = ' ')   def fib1(n, pre=0, cur=1):     pre, cur = cur, pre + cur     print(cur, end = ' ')     if n == 2:         return     fib1(n-1, pre, cur)     fib1(5)

     协程coroutine:

       生成器的高级用法.

       比进程,线程轻量级.

       是在用户空间调度函数的一种实现.

       python3 asyncio就是协程实现,已经加入到标准库.

       python3.5使用async,await关键字直接原生支持协程.

       协程调度实现思路:

           有2个生成器A,B.

           next(A)后,A执行到yield语句暂停,然后执行next(B),B执行到yield语句也暂停,就再次调用next(A),再调用next(B),周而复始,就实现了调度的效果.

           可以引入调度的策略来实现切换的方式.

    协程是一种非抢占式调度.

    另一个 yield 的例子来源于文件读取。如果直接对文件对象调用 read() 方法，会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。

通过 yield，我们不再需要编写读文件的迭代类，就可以轻松实现文件读取：

1 2 3 4 5 6 7 8 9

def read_file(fpath):    BLOCK_SIZE = 1024    with open(fpath, 'rb') as f:        while True:            block = f.read(BLOCK_SIZE)            if block:                yield block            else:                return

yield from

    举例:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

def inc():     for x in range(1000):         yield x   foo = inc() print(next(foo)) print(next(foo)) print(next(foo))   # 运行结果: 0 1 2

# 左边等同于如下代码: def inc():     # for x in range(1000):     #     yield x     yield from range(1000)   foo = inc() print(next(foo)) print(next(foo)) print(next(foo))

    yield from是python3.3出现的新的语法.

    yield from iterable是for item in iterable: yield item形式的语法糖.

1 2 3 4 5 6 7 8 9 10 11 12

# 从可迭代对象中一个个拿元素:   def counter(n):  # 生成器,迭代器     for x in range(n):         yield x   def inc(n):     yield from counter(n)   foo = inc(10) print(next(foo)) print(next(foo))