文章目录
for循环和lambda表达式
In [7]: s = []
In [8]: for x in range(5):
...: s.append(lambda: x ** 2)
...:
In [9]: s[0]()
Out[9]: 16
In [10]: s[1]()
Out[10]: 16
In [11]: s[4]()
Out[11]: 16
我们首先定义了一个列表,然后通过for
循环5次,对s
列表每次增加了一个lambda
,这个函数没有参数,返回值是x ** 2
(就是求平方),但是我们看见了最终的结果是每次调用都获得的是4的平方,也就是for
循环的最后一个x
的值。
因为我们在函数定义的时候,并不会执行函数,只有在真正调用的时候,函数才会被执行,那么在执行的时候,
x
已经是4了,所以得到了上面的结果。
我们修改一下x
,看一下结果
In [12]: x = 5
In [13]: s[4]()
Out[13]: 25
In [14]:
可以证明我们上面说的结论了,那么我们可以按照下面的方式进行修改:
In [14]: s = []
In [15]: for x in range(5):
...: s.append(lambda n=x: n ** 2)
...:
In [16]: s[0]()
Out[16]: 0
In [17]: s[3]()
Out[17]: 9
In [18]:
简单的给
lambda
加上了参数,并且有默认值是x
,那么相当于在定义函数的时候,这个语句已经被执行,也就是x
在当时的实际值。
参数默认值
def fun(a=[]):
a.append(1)
return a
print(fun())
print(fun())
print(fun())
结果是:
[1]
[1, 1]
[1, 1, 1]
我们的预期是,每次调用fun
,返回一个列表,列表只有一个元素,就是1,为什么后面的调用,每次都增加了一个元素呢,因为python在定义函数的时候,参数已经产生了一个对象,并且这个对象已经总是存在,那么每次调用修改的时候,这个对象也就被修改了。
如果对象是不可变的,那么不会有这个影响,比如我们可以把参数的默认值修改为
None
def fun(a=None):
if a is None:
a = []
a.append(1)
return a
print(fun())
print(fun())
print(fun())
结果是:
[1]
[1]
[1]
我们判断了
a
这个参数,然后判断a
是否为None
,是的话,我们赋值为[]
,也就是一个空列表,然后在增加元素,这样就确保了参数的影响。
类似于列表,字典,类的实例可变对象,都会产生上面的困惑,但是对应不可变对象,比如字符串,整形,元组和None对象就不会产生类似的影响
我们可以使用参数默认值是字典来缓冲计算结果,减少计算量:
def fun(arg1, arg2, *, __cache={}):
if (arg1, arg2) in __cache:
print('Get result directly.')
return __cache[(arg1, arg2)]
result = arg1 + arg2
__cache[(arg1, arg2)] = result
return result
print(fun(1, 2))
print(fun(1, 2))
结果是:
3
Get result directly.
3
在第二个调用函数的时候,直接取的缓存值,没有在一次进行计算。
按照上面的定义
fun
函数只能接受两个参数,函数体对_cache
字典进行了赋值,key是参数组成的元组,值是计算后的结果,这里使用加法计算两个参数的和,你也可以换成任何计算结果,当下次同样的参数传递过来后,不会再次执行计算,直接获取缓存的结果。