【python总结】-常见问题汇总

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是参数组成的元组，值是计算后的结果，这里使用加法计算两个参数的和，你也可以换成任何计算结果，当下次同样的参数传递过来后，不会再次执行计算，直接获取缓存的结果。