常见错误1：在函数参数中乱用表达式作为默认值
Python允许给一个函数的某个参数设置默认值以使该参数成为一个可选参数。尽管这是这门语言很棒的一个功能，但是这当这个默认值是可变对象（mutable）时，那就有些麻烦了。例如，看下面这个Python函数定义：
>>> def foo(bar=[]): # bar是可选参数，如果没有指明的话，默认值是[]
... bar.append("baz") # 但是这行可是有问题的，走着瞧…
... return bar人们常犯的一个错误是认为每次调用这个函数时不给这个可选参数赋值的话，它总是会被赋予这个默认表达式的值。例如，在上面的代码中，程序员可能会认为重复调用函数foo() （不传参数bar给这个函数），这个函数会总是返回‘baz’，因为我们假定认为每次调用foo()的时候（不传bar），参数bar会被置为[]（即，一个空的列表）。
（这个错误我之前不是见过吗，但是我忘了。。。）
那么我们来看看这么做的时候究竟会发生什么：
>>> foo()
["baz"]
>>> foo()
["baz", "baz"]
>>> foo()
["baz", "baz", "baz"]嗯？为什么每次调用foo()的时候，这个函数总是在一个已经存在的列表后面添加我们的默认值“baz”，而不是每次都创建一个新的列表？
答案是一个函数参数的默认值，仅仅在该函数定义的时候，被赋值一次。 （卧槽，怎么能这样） 如此，只有当函数foo()第一次被定义的时候，才讲参数bar的默认值初始化到它的默认值（即一个空的列表）。当调用foo()的时候（不给参数bar），会继续使用bar最早初始化时的那个列表。
由此，可以有如下的解决办法：
>>> def foo(bar=None):
... if bar is None: # 或者用 if not bar:
... bar = []
... bar.append("baz")
... return bar
...
>>> foo()
["baz"]
>>> foo()
["baz"]
>>> foo()
["baz"]感觉不太对啊，除非bar.append("baz")这句再往后缩4格
所以，定义默认参数要牢记一点：默认参数必须指向不变对象！
要修改上面的例子，我们可以用None这个不变对象来实现：
所以现在，无论调用多少次，都不会有问题：
原来如此
常见错误2：不正确的使用类变量
看下面一个例子：
>>> class A(object):
... x = 1
...
>>> class B(A):
... pass
...
>>> class C(A):
... pass
...
>>> print A.x, B.x, C.x
1 1 1看起来没有问题。
>>> B.x = 2
>>> print A.x, B.x, C.x
1 2 1嗯哈，还是和预想的一样。
>>> A.x = 3
>>> print A.x, B.x, C.x
3 2 3我了个去。只是改变了A.x，为啥C.x也变了？
在Python里，类变量通常在内部被当做字典来处理并遵循通常所说的方法解析顺序（Method Resolution Order (MRO)）。因此在上面的代码中，因为属性x在类C中找不到，因此它会往上去它的基类中查找（在上面的例子中只有A这个类，当然Python是支持多重继承（multiple inheritance）的）。换句话说，C没有它自己独立于A的属性x。因此对C.x的引用实际上是对A.x的引用。（B.x不是对A.x的引用是因为在第二步里B.x=2将B.x引用到了2这个对象上，倘若没有如此，B.x仍然是引用到A.x上的。——译者注）
实例间原来还能这样影响啊，虽然之前好像也学过，但是。。。我果然漏了好多东西
常见错误3：在异常处理时错误的使用参数
假设你有如下的代码：
>>> try:
... l = ["a", "b"]
... int(l[2])
... except ValueError, IndexError: # 想捕捉两个异常
... pass
...
Traceback (most recent call last):
File "<stdin>", line 3, in <module>
IndexError: list index out of range这里的问题在于except语句不会像这样去接受一系列的异常。并且，在Python 2.x里面，语法except Exception, e是用来将异常和这个可选的参数绑定起来（即这里的e），以用来在后面查看的。因此，在上面的代码中，IndexError异常不会被except语句捕捉到；而最终ValueError这个异常被绑定在了一个叫做IndexError的参数上。
在except语句中捕捉多个异常的正确做法是将所有想要捕捉的异常放在一个元组（tuple）里并作为第一个参数给except语句。并且，为移植性考虑，使用as关键字，因为Python 2和Python 3都支持这样的语法，例如：
>>> try:
... l = ["a", "b"]
... int(l[2])
... except (ValueError, IndexError) as e:
... pass
...确实没有注意过两个放一起该怎么写。
常见错误4：误解Python作用域的规则
Python的作用域解析是基于叫做LEGB（Local（本地），Enclosing（封闭），Global（全局），Built-in（内置））的规则进行操作的。这看起来很直观，对吧？事实上，在Python中这有一些细微的地方很容易出错。看这个例子：
>>> x = 10
>>> def foo():
... x += 1
... print x
...
>>> foo()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'x' referenced before assignment这是怎么回事？
x和foo里的x并不是一回事，你要是想这么操作需要把x传入函数内
这是因为，在一个作用域里面给一个变量赋值的时候，Python自动认为这个变量是这个作用域的本地变量，并屏蔽作用域外的同名的变量。
很多时候可能在一个函数里添加一个赋值的语句会让你从前本来工作的代码得到一个UnboundLocalError。
在使用列表（lists）的时候，这种情况尤为突出。看下面这个例子：
>>> lst = [1, 2, 3]
>>> def foo1():
... lst.append(5) # 这没有问题...
...
>>> foo1()
>>> lst
[1, 2, 3, 5]
>>> lst = [1, 2, 3]
>>> def foo2():
... lst += [5] # ... 这就有问题了！
...
>>> foo2()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'lst' referenced before assignment嗯？为什么foo2有问题，而foo1没有问题？
我去，我觉得第一个就有问题啊，第一个是怎么能运行出结果的啊
答案和上一个例子一样，但是更加不易察觉。foo1并没有给lst赋值，但是foo2尝试给lst赋值。 啊？ 注意lst+=[5]只是lst=lst+[5]的简写，由此可以看到我们尝试给lst赋值（因此Python假设作用域为本地）。但是，这个要赋给lst的值是基于lst本身的（这里的作用域仍然是本地），而lst却没有被定义，这就出错了。
也就是不赋值就可以跨作用域了？能翻到之前的List定义里去？
常见错误5：在遍历列表的同时又在修改这个列表
下面这个例子中的代码应该比较明显了：
>>> odd = lambda x : bool(x % 2)
>>> numbers = [n for n in range(10)]
>>> for i in range(len(numbers)):
... if odd(numbers[i]):
... del numbers[i] # 这不对的：在遍历列表时删掉列表的元素。
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
IndexError: list index out of range从前往后删显然是有问题的吧。。
遍历一个列表或者数组的同时又删除里面的元素，对任何有经验的软件开发人员来说这是个很明显的错误。但是像上面的例子那样明显的错误，即使有经验的程序员也可能不经意间在更加复杂的程序中不小心犯错。
所幸，Python集成了一些优雅的编程范式，如果使用得当，可以写出相当简化和精简的代码。一个附加的好处是更简单的代码更不容易遇到这种“不小心在遍历列表时删掉列表元素”的bug。例如列表推导式（list comprehensions）就提供了这样的范式。再者，列表推导式在避免这样的问题上特别有用，接下来这个对上面的代码的重新实现就相当完美：
>>> odd = lambda x : bool(x % 2)
>>> numbers = [n for n in range(10)]
>>> numbers[:] = [n for n in numbers if not odd(n)] # 啊，这多优美 #啥？
>>> numbers
[0, 2, 4, 6, 8]odd是个判断一个数是不是奇数的函数！！！
我居然没看出来，我还在想把if not odd(n)直接改成判断函数
但是改成这样有问题吗？
numbers[:] = [n for n in numbers if n%2 == 0]
话说我改成这样也行的
numbers = [n for n in numbers if n%2 == 0]
大概讲了一个删除不如重新赋值的故事吧
常见错误6：搞不清楚在闭包（closures）中Python是怎样绑定变量的
…闭包是啥…
看这个例子：
>>> def create_multipliers():
... return [lambda x : i * x for i in range(5)]
>>> for multiplier in create_multipliers():
... print multiplier(2)第一个是返回个List这次我看出来了)，大概是给一个数，生成一个x从0乘到5的List
乘到4，sb
讲道理这个遍历我是不懂的
卧槽，这个函数x从哪来的？怎么赋值？
等等，难道这就是闭包，查了下，好像不太一样啊
先往下看吧
期望得到下面的输出：
0
2
4
6
8但是实际上得到的是：
8
8
8
8
8意外吧！
是的。。。
这是由于Python的后期绑定（late binding）机制导致的，这是指在闭包中使用的变量的值，是在内层函数被调用的时候查找的。因此在上面的代码中，当任一返回函数被调用的时候，i的值是在它被调用时的周围作用域中查找（到那时，循环已经结束了，所以i已经被赋予了它最终的值4）。
解决的办法比较巧妙：
>>> def create_multipliers():
... return [lambda x, i=i : i * x for i in range(5)]
>>> for multiplier in create_multipliers():
... print multiplier(2)
0
2
4
6
8这下对了！这里利用了默认参数去产生匿名函数以达到期望的效果。有人会说这很优美，有人会说这很微妙，也有人会觉得反感。但是如果你是一名Python程序员，重要的是能理解任何的情况。
关键是我很不理解！！！
测试了一些，multiplier的类型也是一个函数
经过不断的测试大概明白了些
1.create_multipliers()返回了一个List，但其中的每一个元素都是一个函数？
2.不清楚为什么就可以进行赋值了。（我晕了，lambda函数的具体概念我弄错了）
3.这道题的问题还没解决呢！（大概是因为在返回函数时才进行计算导致的结果？）
4.终于大致弄懂了，这个匿名函数只有这么长,lambda x, i=i : i * x。后边相当于重复赋值5次得到一个List（但是我不能类似的定义出来匿名函数以外的List）
非常骚气的操作
还差得远呢
常见错误7：循环加载模块
可能我现在看这篇文章还有点早
假设你有两个文件，a.py和b.py，在这两个文件中互相加载对方，例如：
在a.py中：
import b
def f():
return b.x
print f()在b.py中：
import a
x = 1
def g():
print a.f()厉害了
首先，我们试着加载a.py：
>>> import a
1没有问题。也许让人吃惊，毕竟有个感觉应该是问题的循环加载在这儿。
为什么会有个1输出来啊真可怜啊，年级轻轻就这么瞎了
事实上在Python中仅仅是表面上的出现循环加载并不是什么问题。如果一个模块以及被加载了，Python不会傻到再去重新加载一遍。但是，当每个模块都想要互相访问定义在对方里的函数或者变量时，问题就来了。
让我们再回到之前的例子，当我们加载a.py时，它再加载b.py不会有问题，因为在加载b.py时，它并不需要访问a.py的任何东西，而在b.py中唯一的引用就是调用a.f()。但是这个调用是在函数g()中完成的，并且a.py或者b.py中没有人调用g()，所以这会儿心情还是美丽的。
但是当我们试图加载b.py时（之前没有加载a.py），会发生什么呢：
>>> import b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "b.py", line 1, in <module>
import a
File "a.py", line 6, in <module>
print f()
File "a.py", line 4, in f
return b.x
AttributeError: 'module' object has no attribute 'x'恭喜你，出错了。这里问题出在加载b.py的过程中，Python试图加载a.py，并且在a.py中需要调用到f()，而函数f()又要访问到b.x，但是这个时候b.x却还没有被定义。这就产生了AttributeError异常。
解决的方案可以做一点细微的改动。改一下b.py，使得它在g()里面加载a.py：
x = 1
def g():
import a # 只有当g()被调用的时候才加载
print a.f()这会儿当我们加载b.py的时候，一切安好：
>>> import b
>>> b.g()
1 # 第一次输出，因为模块a在最后调用了‘print f()’
1 # 第二次输出，这是我们调用g()擦，又瞎了
我一直以为a.f()调用b.g()，b.g()调用a.f()。结果a.f()调用的是b.x。我还想怎么会有数输出。
常见错误8：与Python标准库模块命名冲突
Python的一个优秀的地方在于它提供了丰富的库模块。但是这样的结果是，如果你不下意识的避免，很容易你会遇到你自己的模块的名字与某个随Python附带的标准库的名字冲突的情况（比如，你的代码中可能有一个叫做email.py的模块，它就会与标准库中同名的模块冲突）。
这会导致一些很粗糙的问题，例如当你想加载某个库，这个库需要加载Python标准库里的某个模块，结果呢，因为你有一个与标准库里的模块同名的模块，这个包错误的将你的模块加载了进去，而不是加载Python标准库里的那个模块。这样一来就会有麻烦了。
所以在给模块起名字的时候要小心了，得避免与Python标准库中的模块重名。相比起你提交一个“Python改进建议（Python Enhancement Proposal (PEP)）”去向上要求改一个标准库里包的名字，并得到批准来说，你把自己的那个模块重新改个名字要简单得多。
哈哈哈
常见错误9：不能区分Python 2和Python 3
之前就有这个问题 print后面都不加括号的
看下面这个文件foo.py：
import sys
def bar(i):
if i == 1:
raise KeyError(1)
if i == 2:
raise ValueError(2)
def bad():
e = None
try:
bar(int(sys.argv[1]))
except KeyError as e:
print('key error')
except ValueError as e:
print('value error')
print(e)
bad()在Python 2里，运行起来没有问题：
$ python foo.py 1
key error
1
$ python foo.py 2
value error
2但是如果拿到Python 3上面玩玩
$ python3 foo.py 1
key error
Traceback (most recent call last):
File "foo.py", line 19, in <module>
bad()
File "foo.py", line 17, in bad
print(e)
UnboundLocalError: local variable 'e' referenced before assignment这是怎么回事？“问题”在于，在Python 3里，在except块的作用域以外，异常对象（exception object）是不能被访问的。（原因在于，如果不这样的话，Python会在内存的堆栈里保持一个引用链直到Python的垃圾处理将这些引用从内存中清除掉。）
避免这样的问题可以这样做：保持在execpt块作用域以外对异常对象的引用，这样是可以访问的。下面是用这个办法对之前的例子做的改动，这样在Python 2和Python 3里面都运行都没有问题。
import sys
def bar(i):
if i == 1:
raise KeyError(1)
if i == 2:
raise ValueError(2)
def good():
exception = None
try:
bar(int(sys.argv[1]))
except KeyError as e:
exception = e
print('key error')
except ValueError as e:
exception = e
print('value error')
print(exception)
good()在Py3k里面运行：
$ python3 foo.py 1
key error
1
$ python3 foo.py 2
value error
2耶！
这个。。。。
常见错误10：错误的使用__del__方法
假设有一个文件mod.py中这样使用：
import foo
class Bar(object):
...
def __del__(self):
foo.cleanup(self.myhandle)然后试图在another_mod.py里这样：
import mod
mybar = mod.Bar()那么你会得到一个恶心的AttributeError异常。
为啥呢？这是因为，当解释器关闭时，模块所有的全局变量会被置为空（None）。结果便如上例所示，当__del__被调用时，名字foo已经被置为空了。
使用atexit.register()可以解决这个问题。如此，当你的程序结束的时候（退出的时候），你的注册的处理程序会在解释器关闭之前处理。
这样理解的话，对上面的mod.py可以做如下的修改：
import foo
import atexit
def cleanup(handle):
foo.cleanup(handle)
class Bar(object):
def __init__(self):
...
atexit.register(cleanup, self.myhandle)这样的实现方式为在程序正常终止时调用清除功能提供了一种干净可靠的办法。显然，需要foo.cleanup决定怎么处理绑定在self.myhandle上的对象，但你知道怎么做的。
144
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
