Python陷阱与缺陷列表，老司机都会出错！

我个人对陷阱的定义是这样的：代码看起来可以工作，但不是以你“想当然“”的方式。如果一段代码直接出错，抛出了异常，我不认为这是陷阱。比如，Python程序员应该都遇到过的“UnboundLocalError”, 示例：

> >>> a=1
> 
> >>> def func():
> 
> ...     a+=1
> 
> ...     print a
> 
> ...
> 
> >>> func()
> 
> Traceback (most recent call last):
> 
> File "<stdin>", line 1, in <module>
> 
> File "<stdin>", line 2, in func
> 
> UnboundLocalError: local variable 'a' referenced before assignment
Python资源分享qun 784758214 ,内有安装包，PDF，学习视频，这里是Python学习者的聚集地，零基础，进阶，都欢迎

对于“UnboundLocalError”,还有更高级的版本：

> import random
> 
> def func(ok):
> 
>     if ok:
> 
>         a = random.random()
> 
>     else:
> 
>         import random
> 
>         a = random.randint(1, 10)
> 
>     return a
> 
> func(True)# UnboundLocalError: local variable 'random' referenced before assignment

可能对于很多python新手来说，这个Error让人摸不着头脑。但我认为这不算陷阱，因为这段代码一定会报错，而不是默默的以错误的方式运行。不怕真小人，就怕伪君子。我认为缺陷就好比伪君子。

那么Python中哪些真正算得上陷阱呢？

第一：以mutable对象作为默认参数

这个估计是最广为人知的了，Python和其他很多语言一样，提供了默认参数，默认参数确实是个好东西，可以让函数调用者忽略一些细节（比如GUI编程，Tkinter，QT），对于lambda表达式也非常有用。但是如果使用了可变对象作为默认参数，那么事情就不那么愉快了。

> >>> def f(lst = []):
> 
> ...     lst.append(1)
> 
> ...     return lst
> 
> ...
> 
> >>> f()
> 
> [1]
> 
> >>> f()
> 
> [1, 1]

惊喜不惊喜？！究其原因，python中一切都是对象，函数也不列外，默认参数只是函数的一个属性。而默认参数在函数定义的时候已经求值了。

> Default parameter values are evaluated when the function definition is executed.

stackoverflow上有一个更适当的例子来说明默认参数是在定义的时候求值，而不是调用的时候。　

> >>> import time
> 
> >>> def report(when=time.time()):
> 
> ... return when
> 
> ...
> 
> >>> report()
> 
> 1500113234.487932
> 
> >>> report()
> 
> 1500113234.487932

python docoment 给出了标准的解决办法：

> A way around this is to use None as the default, and explicitly test for it in the body of the function

> >>> def report(when=None):
> 
> ...  if when is None:
> 
> ...  when = time.time()
> 
> ... return when
> 
> ...
> 
> >>> report()
> 
> 1500113446.746997
> 
> >>> report()
> 
> 1500113448.552873

第二: x += y vs x = x + y

一般来说，二者是等价的，至少看起来是等价的（这也是陷阱的定义 — 看起来都OK，但不一定正确）。

> >>> x=1;x += 1;print x
> 
> 2 
> 
> >>> x=1;x = x+1;print x
> 
> 2
> 
> >>> x=[1];x+=[2];print x
> 
> [1, 2]
> 
> >>> x=[1];x=x+[2];print x
> 
> [1, 2]

呃，被光速打脸了？

> >>> x=[1];print id(x);x=x+[2];print id(x) 
> 
> 4357132800
> 
> 4357132728
> 
> >>> x=[1];print id(x);x+=[2];print id(x)
> 
> 4357132800
> 
> 4357132800
Python资源分享qun 784758214 ,内有安装包，PDF，学习视频，这里是Python学习者的聚集地，零基础，进阶，都欢迎

前者x指向一个新的对象，后者x在原来的对象是修改，当然，那种效果是正确的取决于应用场景。至少，得知道，二者有时候并不一样

第三，神奇的小括号–()

小括号（parenthese）在各种编程语言中都有广泛的应用，python中，小括号还能表示元组（tuple）这一数据类型, 元组是immutable的序列。

> >>> a = (1, 2)
> 
> >>> type(a)
> 
> <type 'tuple'>
> 
> >>> type(())
> 
> <type 'tuple'>

但如果只有一个元素呢

> >>> a=(1)
> 
> >>> type(a)
> 
> <type 'int'>

神奇不神奇，如果要表示只有一个元素的元组，正确的姿势是:

> >>> a=(1,)
> 
> >>> type(a) 
> 
> <type 'tuple'>

第四：生成一个元素是列表的列表

这个有点像二维数组，当然生成一个元素是字典的列表也是可以的，更通俗的说，生成一个元素是可变对象的序列

很简单嘛：

> >>> a= [[]] * 10
> 
> >>> a
> 
> [[], [], [], [], [], [], [], [], [], []]
> 
> >>> a[0].append(10)
> 
> >>> a[0] 
> 
> [10]

看起来很不错，简单明了，but

> >>> a[1]
> 
> [10]
> 
> >>> a
> 
> [[10], [10], [10], [10], [10], [10], [10], [10], [10], [10]]

我猜，这应该不是你预期的结果吧，究其原因，还是因为python中list是可变对象，上述的写法大家都指向的同一个可变对象，正确的姿势

> >>> a = [[] for _ in xrange(10)]
> 
> >>> a[0].append(10)
> 
> >>> a
> 
> [[10], [], [], [], [], [], [], [], [], []]

第五，在访问列表的时候，修改列表

列表（list）在python中使用非常广泛，当然经常会在访问列表的时候增加或者删除一些元素。比如，下面这个函数，试图删掉列表中为3的倍数的元素：

> >>> def modify_lst(lst):
> 
> ... for idx, elem in enumerate(lst):
> 
> ... if elem % 3 == 0:
> 
> ... del lst[idx]

测试一下，

> >>> lst = [1,2,3,4,5,6]
> 
> >>> modify_lst(lst)
> 
> >>> lst
> 
> [1, 2, 4, 5]

好像没什么错，不过这只是运气好

> >>> lst = [1,2,3,6,5,4]
> 
> >>> modify_lst(lst)
> 
> >>> lst
> 
> [1, 2, 6, 5, 4]

上面的例子中，6这个元素就没有被删除。如果在modify_lst函数中print idx， item就可以发现端倪：lst在变短，但idx是递增的，所以在上面出错的例子中，当3被删除之后，6变成了lst的第2个元素（从0开始）。在C++中，如果遍历容器的时候用迭代器删除元素，也会有同样的问题。

如果逻辑比较简单，使用list comprehension是不错的注意

第六，闭包与lambda

这个也是老生长谈的例子，在其他语言也有类似的情况。先看一个例子:

> >>> def create_multipliers():
> 
> ...  return [lambda x:i*x for i in range(5)]
> 
> ...
> 
> >>> for multiplier in create_multipliers():
> 
> ... print multiplier(2)
> 
> ...

create_multipliers函数的返回值时一个列表，列表的每一个元素都是一个函数 －－ 将输入参数x乘以一个倍数i的函数。预期的结果时0，2，4，6，8. 但结果是5个8，意外不意外。

由于出现这个陷阱的时候经常使用了lambda，所以可能会认为是lambda的问题，但lambda表示不愿意背这个锅。问题的本质在与python中的属性查找规则，LEGB（local，enclousing，global，bulitin），在上面的例子中，i就是在闭包作用域（enclousing），而Python的闭包是 迟绑定 ， 这意味着闭包中用到的变量的值，是在内部函数被调用时查询得到的。

解决办法也很简单，那就是变闭包作用域为局部作用域。

> >>> def create_multipliers():
> 
> ... return [lambda x, i = i:i*x for i in range(5)]
> 
> ...
Python资源分享qun 784758214 ,内有安装包，PDF，学习视频，这里是Python学习者的聚集地，零基础，进阶，都欢迎

第七，定义del

大多数计算机专业的同学可能都是先学的C、C++，构造、析构函数的概念应该都非常熟。于是，当切换到python的时候，自然也想知道有没有相应的函数。比如，在C++中非常有名的RAII，即通过构造、析构来管理资源（如内存、文件描述符）的声明周期。那在python中要达到同样的效果怎么做呢，即需要找到一个对象在销毁的时候一定会调用的函数，于是发现了init, del函数，可能简单写了两个例子发现确实也能工作。但事实上可能掉进了一个陷阱，在python documnet是有描述的：

> Circular references which are garbage are detected when the option cycle detector is enabled (it’s on by default), but can only be cleaned up if there are no Python-level __del__() methods involved.

简单来说，如果在循环引用中的对象定义了del,那么python gc不能进行回收，因此，存在内存泄漏的风险

第八，不同的姿势import同一个module

示例在stackoverflow的例子上稍作修改，假设现在有一个package叫mypackage，里面包含三个python文件：mymodule.py, main.py, init.py。mymodule.py代码如下：

> l = []
> 
> class A(object):
> 
>     pass

main.py代码如下：

> def add(x):
> 
>     from mypackage import mymodule
> 
>     mymodule.l.append(x)
> 
>     print "updated list",mymodule.l, id(mymodule)
> 
> def get():
> 
>     import mymodule
> 
>     print 'module in get', id(mymodule)
> 
>     return mymodule.l
> 
> if __name__ == '__main__':
> 
>     import sys
> 
>     sys.path.append('../')
> 
>     add(1)
> 
>     ret = get()
> 
>     print "lets check", ret

运行python main.py，结果如下：

> updated list [1] 4406700752
> 
> module in get 4406700920
> 
> lets check []
Python资源分享qun 784758214 ,内有安装包，PDF，学习视频，这里是Python学习者的聚集地，零基础，进阶，都欢迎

从运行结果可以看到，在add 和 get函数中import的mymodule不是同一个module，ID不同。当然，在python2.7.10中，需要main.py的第13行才能出现这样的效果。你可能会问，谁会写出第13行这样的代码呢？事实上，在很多项目中，为了import的时候方便，会往sys.path加入一堆路径。那么在项目中，大家同意一种import方式就非常有必要了

第九，python升级

python3.x并不向后兼容，所以如果从2.x升级到3.x的时候得小心了，下面列举两点：

在python2.7中，range的返回值是一个列表；而在python3.x中，返回的是一个range对象。

map()、filter()、 dict.items()在python2.7返回列表，而在3.x中返回迭代器。当然迭代器大多数都是比较好的选择，更加pythonic，但是也有缺点，就是只能遍历一次。在instagram的分享中，也提到因为这个导致的一个坑爹的bug。

第十，gil

以GIL结尾，因为gil是Python中大家公认的缺陷！

从其他语言过来的同学可能看到python用threading模块，拿过来就用，结果发现效果不对啊，然后就会喷，什么鬼。

总结：

毫无疑问的说，python是非常容易上手，也非常强大的一门语言。python非常灵活，可定制化很强。同时，也存在一些陷阱，搞清楚这些陷阱能够更好的掌握、使用这么语言。本文列举了一些python中的一些缺陷，这是一份不完全列表，欢迎大家补充。