函数的执行需要对函数进行压栈,什么是压栈呢,简而言之就是在函数执行时在栈中创建栈帧存放需要的变量以及指针的意思。具体涉及的知识非常多,这里就以一个 Python 脚本简单进行分析。
def foo1(b, b1=3):
print('call foo1', b, b1)
def foo2(c):
foo3(c)
print('call foo2', c)
def foo3(d):
print('call foo3', d)
def main ():
print('call main')
foo1(100, 101)
foo2(20)
print('main ending')
main ()
当我们运行上面代码时,它的执行流程如下:
Python 代码先被编译为字节码后,再由 Python 虚拟机来执行字节码, Python 的字节码是一种类似汇编指令的中间语言, 一个 Python 语句会对应若干字节码指令,虚拟机一条一条执行字节码指令, 从而完成程序执行。Python dis 模块
支持对 Python 代码进行反汇编, 生成字节码指令。下面针对上面的例子通过字节码理解函数调用时的过程。
import dis
print(dis.dis(main))
# ======> result
53 0 LOAD_GLOBAL 0(print)
2 LOAD_CONST 1('call main')
4 CALL_FUNCTION 1
6 POP_TOP
54 8 LOAD_GLOBAL 1(foo1)
10 LOAD_CONST 2(100)
12 LOAD_CONST 3(101)
14 CALL_FUNCTION 2
16 POP_TOP
55 18 LOAD_GLOBAL 2(foo2)
20 LOAD_CONST 4(20)
22 CALL_FUNCTION 1
24 POP_TOP
56 26 LOAD_GLOBAL 0(print)
28 LOAD_CONST 5('main ending')
30 CALL_FUNCTION 1
32 POP_TOP
34 LOAD_CONST 0(None)
36 RETURN_VALUE
字节码含义:
LOAD_GLOBAL
:加载全局函数 (print)LOAD_CONST
: 加载常量CALL_FUNCTION
: 函数调用POP_TOP
:弹出栈顶RETURN_VALUE
: 返回值def outer():
c = 100
def inner():
nonlocal c
c += 200
return c
return inner
a = outer()
a()
注意:这种情况叫做闭包,自由变量 c 会被当成内部函数 inner 的一个属性,被调用。
PS:内存两大区域 (栈,堆)。垃圾回收,清理的是堆中的空间。函数的调用就是压栈的过程,而变量的创建都是在堆中完成的。 栈中存储的都是堆中的内存地址的指向,栈清空,并不会使堆中的对象被清除,只是指向已经被删除。函数,变量都是在堆内创建的,函数调用需要压栈。
函数直接或者间接的调用自身就叫递归,递归需要有边界条件、递归前进段、递归返回段,当边界条件不满足的时候,递归前进,当边界条件满足时,递归返回。注意:递归一定要有边界条件,否则可能会造成内存溢出。
前面我们学过斐波那契序列,利用递归函数,我们可以更简洁的编写一个计算斐波那契序列第 N 项,或者前 N 项的代码:
在数学上,斐波纳契数列以如下被以递推的方法定义:
F(1)=1,F(2)=1, F(n)=F(n-1)+F(n-2)(n >= 3,n ∈ N*)
# 公式版本
def fib(n):
if n < 3:
return 1
return fib(n-1) + fib(n-2)
# 公式版本之简洁版
def fib(n):
return 1 if n <3 else fib(n-1) + fib(n-2)
很多人可能不明白其中原理,这里简要说明一下,以 fib(6) 为例子:
[外链图片转存失败(img-AbD3k3t3-1562240946327)(https://github.com/colinlee19860724/Study_Notebook/raw/master/Photo/re_fib.png)]
递归的要求:
RecursionError
异常。使用
import sys; sys.getrecursionlimit()
获取当前解释器限制的最大递归深度
由于 Python 是预先计算等式右边的,所以我们发现,上图中,重复计算了 fib(4)
和 fib(3)
那么效率呢?由于只是计算了 fib(6),如果 fib(35)
呢?可以预想,它要重复计算多少次啊。这里我们来测试一下它执行的时间。
# 递归版本
import timeit
def fib(n):
return 1 if n <3 else fib(n - 2) + fib(n - 1)
start = timeit.default_timer()
fib(35)
duration = timeit.default_timer() - start
print('{:.6f}'.format(duration)) # 1.783832
# 循环版本
def fib(n):
a = 1
b = 1
count = 2
while count < n:
a, b = b, a + b
count += 1
return b
start = timeit.default_timer()
fib(35)
duration = timeit.default_timer() - start
print('{:.6f}'.format(duration)) # 0.000037
经过对比,我们发现使用递归虽然代码更优美了,但是运行时间还不如我们的普通循环的版本,这是因为递归重复计算了很多次,当规模到达一定程度时,那么这个时间是成指数递增的。
总结一下现在的问题:
如何优化呢?前面的版本使用递归函数时会重复计算一些相同的数据,那么我们来改进一下,在代码层面对递归的特性进行优化。
import timeit
def fib(n, a=1, b=1):
a, b = b, a + b
if n < 3:
return b
return fib(n - 1, a, b)
start = timeit.default_timer()
fib(35)
duration = timeit.default_timer() - start
print('{:.6f}'.format(duration)) # 0.000038
代码优化后,发现运行时间很快,因为计算的是fib(n),fib(n-1)..fib(1)
并没有进行重复计算,所以要使用递归,必须要考虑重复计算以及函数递归调用时产生的内存浪费等。
间接递归,就是通过别的函数,来调用函数本身,下面来看一个例子,来理解间接递归的概念:
def foo1():
foo2()
def foo2():
foo1()
foo1() # RecursionError: maximum recursion depth exceeded
我们可以看到,这种递归调用是非常危险的,但是往往在代码复杂的情况下,还是可能发生这种调用。要用代码规范来避免这种递归调用的发生。
递归是一种很自然的表达,符合逻辑思维:
没有名字的函数,在 Python 中被称为匿名函数,考虑一下,我们之前都是通过 def 语句定义函数的名字,而开始定义一个函数的,那么不用名字该如何定义函数?函数没有名字又该如何调用呢?
Python 中借助 lambda 表达式构建匿名函数。它的格式为:
lambda ' 参数列表 ':' 返回值 '
# 等于:
def xxx(参数列表):
return 返回值
需要注意的是:
下面来看一下各种匿名函数的写法
(lambda x,y: x + y)(4,5) # 9
(lambda x,y=10: x+y)(10) # 20
(lambda x,y=10: x+y)(x=10) # 20
(lambda x,y=10: x+y)(10,y=10) # 20
(lambda x, y=10, *args: x+y)(10, y=10) # 20
(lambda x, y=10, *args, **kwargs: x+y)(10, y=10) # 20
(lambda *args:(i for i in args))(1,2,3,4,5) # generate<1,2,3,4,5>
(lambda *args:(i for i in args))(*range(5)) # generate<0,1,2,3,4>
[x for x in (lambda *args: (i for i in args))(*range(5)) ] # [0, 1, 2, 3, 4]
[x for x in (lambda *args: map(lambda x:x+1,(i for i in args)))(*range(5))] # [1, 2, 3, 4, 5]
还记得,我们之前的默认值字典吗,这里的:
d = collections.defaultdict(lambda :0)
,其实就等于(lambda :0)()
,即当我们传入任意值时都返回 0
生成器指生成器对象,可以由生成器表达式得到,也可以使用 yield 关键字得到一个生成器函数,调用这个函数返回一个生成器对象。
生成器函数,函数体中包含 yield 关键字的函数,就是生成器函数,调用后返回生成器对象。关于生成器对象,我们可以理解它就是一个可迭代对象,是一个迭代器,只不过它是延迟计算的,惰性求值的。
我们说在函数中使用 yield 关键字来返回数据的函数,叫做生成器函数,那么我们来写一个生成器函数,看看和 return 函数有什么区别
def func():
for i in range(2):
yield i
g = func()
In : next(g)
Out: 0
In : next(g)
Out: 1
In : next(g)
---------------------------------------------------------------------------
StopIteration Traceback(most recent call last)
<ipython-input-93-e734f8aca5ac> in <module>
----> 1 next(g)
StopIteration:
这个报错看起来是不是很熟悉?没错,和生成器表达式的结果是相同的,只不过生成器函数可以写的更加的复杂,现在我们来看下生成器函数的执行过程。
yield 关键字
,和return 关键字
在生成器场景下,不能一起使用。因为 return 语句会导致当前函数立即返回,无法继续执行,也无法继续获取下一个值,并且 return 语句的返回值也不能被next()
获取到,还会产生 StopIteration 的异常.
再来总结一下生成器的特点:
yield
语句的生成器函数调用生成生成器对象的时候,生成器函数的函数体不会立即执行。next(genreator)
会从函数的当前位置向后执行到之后碰到的一个 yield
语句,会弹出值,并暂停函数执行。next
函数,和上一条一样的处理结果next
函数,生成器函数如果结束执行了(显示或隐式调用了 return
语句),会抛出 StopIteration 异常我们想要生成一个无限自然数的序列时,生成器就是一个很好的方式
def counter():
c = 0
while True:
c += 1
yield c
c = counter()
In : next(c)
Out: 1
In : next(c)
Out: 2
In : next(c)
Out: 3
又或者前面的斐波那契序列,我们也可以利用生成器的特点,惰性计算。
def fib(n, a=0, b=1):
for i in range(n):
yield b
a, b = b, a + b
print(list(fib(5))) # [1, 1, 2, 3, 5]
或者包含所有斐波那契序列的生成器
def fib():
a = 0
b = 1
while True:
yield b
a, b = b, a + b
g = fib()
for i in range(101):
print(next(g))
协程是生成器的一种高级方法,比进程、线程更轻量级,是在用户空间调度函数的一种实现,Python 3 的 asyncio 就是协程实现,已经加入到了标准库中,Python 3.5 使用 async、await 关键字直接原生支持协程。协程在现阶段来说比较复杂,后面会详细进行说明,这里提一下实现思路:
协程是一种非抢占式调度
在 Python 3.3 以后,出现了 yield from
语法糖。它的用法是
def counter():
yield from range(10)
yield from iterable
实际上等同于 for item in iterable: yield item
当然 yield from
也可以结合生成器来使用,因为生成器也是一个可迭代对象啊。
def fib(n):
a = 0
b = 1
for i in range(n):
yield b
a,b = b,a+b
def counter():
yield from fib(10)
g = counter()
print(list(g)) # [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
生成器包生成器,真是妙极了!