网站性能检测评分
注：本网站页面html检测工具扫描网站中存在的基本问题，仅供参考。
python3经典
学习python经常遇到的错误 流量视频课程
Python简介
Python是一种动态的、面向对象的、解释性高级编程语言。由于内置的高级数据结构和对动态类型和动态绑定的支持，使用python进行快速应用程序开发是非常方便的。同时，作为一种脚本语言，它与现有的组件和服务兼容。Python还支持模块和各种库的扩展，有助于实现模块化编程和提高代码重用性。
在这篇文章
刚刚接触过该语言的新来者可能无法适应Python简单而灵活的语法，或者低估Python的强大性能。鉴于此，本文列出了Python开发人员经常犯的10个小错误。
这篇文章是供Python高级开发人员参考的，Python白可以参考下面的文章：
http://onlamp/pub/a/python/2004/02/05/learn_python.html
常见错误1：滥用表达式作为函数参数的默认值
Python允许开发人员指定函数参数的默认值。这也是Python的一个主要特性，但是当默认值是可变的时，它可能会给开发人员带来一些问题。例如，下面定义的函数：
>>> def foo(bar=[]): # bar is optional and defaults to [] if not specified... bar.append("baz")# but this line could be problematic, as we'll see...... return bar
你看到虫子了吗？也就是说，在每次调用之前不要为函数分配一个变量参数，并认为参数是默认值。例如，上面的代码，一个可能会多次调用foo（）returns'baz'when，每个调用foo（），为[ ]的价值吧，那是一个空的列表。
但是让我们看看代码运行的结果：
>；>；>；foo（）[“巴兹”] >；>；>；foo（）[“巴兹”、“Baz”] & gt；
嗯？你为什么要加上“巴兹”每次调用foo到现有列表（），而不是一个新的列表？答案是函数定义的默认值只在函数定义时执行一次。因此，当第一次定义富时，bar被初始化为默认值（空列表）。此后，每次调用富（）函数时，参数栏就是第一次初始化时生成的列表。
常见的解决方案：
>>> def foo(bar=None):... if bar is None: # or if not bar:... bar = []... bar.append("baz")... return bar...>>> foo()["baz"]>>> foo()["baz"]>>>foo()["baz"]
常见错误2：类变量的错误使用
代码示例：
>；>；>；类（对象）：…x＝1…>；>；>；B（A）：通…
结果没有问题。
>；>；>；b.x = 2 >；>；>；打印A.x，b.x，c.x121
结果也是正确的。
>；>；>；内= 3 >；>；>；打印A.x，b.x，c.x323
到底是什么？我们只改变了A.x.，C.x为什么要改变呢？
在Python中，类变量是以字典的形式在内部处理的，其次是解析的方法（方法解析顺序，MRO）。因此，在上面的代码中，因为在类C中找不到属性x，所以它从父类中查找x的值。虽然Python支持多重继承，上述代码，换句话说，只有一个父类A，C没有自己的X是独立的类，那么，C.x实际上指的是a.x.如果处理得当，它会使Python的错误。
如果您想深入了解Python的类特性，请盖章：
https://toptal/python/python-class-attributes-an-overly-thorough-guide
常见错误3：指定异常代码块参数的错误
假设您有以下代码：
尝试：…l“A”，“B”…int（L [ 2 ]）除了ValueError，#误差系数…要捕获这两个异常，对吗？Traceback（最）…通过…最近的电话最后文件”）：；3号线，；误差系数：列表索引超出范围
这里的问题是，除语句不接受以这种方式指定的异常列表。在python2. x，变量在除了异常语句可以用来绑定异常信息的第二可选参数进一步查看异常。因此，在上面的代码中，除了声明不捕捉误差系数的例外；相反，例外的是绑定到参数误差系数。
在一个例外语句中同时捕获多个异常的正确方法是将第一个参数分配给元组，并编写要写入元组的异常类型。为了方便起见，您可以使用AS关键字、Python 2和Python 3来支持这种语法格式：
尝试：…L =“A”，“B”…int（l [ 2 ]）…除了（ValueError，IndexError）的…
常见错误4：错误理解Python中变量的范围
Python变量的范围如下legb规则。legb是缩写的地方，封闭，全球和内置。它分别代表本地范围、封闭范围、全局范围和内置范围。这条规则一目了然。事实上，Python中的这种工作更为独特，并导致一些编程错误，如：
（10）…1…X. ..>；>；>；foo（最）追踪（最近的电话上）：stdin文件；1号线，；；2号线：在foounboundlocalerror，当地variable'x'referenced之前分配
问题在哪里？
上述错误是因为在将变量分配给作用域时，Python自动将变量视为作用域中的局部变量，并屏蔽同名变量的外部定义。因此，正确的原代码，添加在一个函数的赋值语句后，意外地收到了unboundlocalerror错误消息。
请把更多关于UnboundLocalError：
http：/ /文档。Python。org / 2 /常/ HTML # why-am-i-getting-an-unboundlocalerror-when-the-variable-has-a-value编程。
当使用列表时，Python程序员更容易陷入这样的陷阱，例如：
>；>；>；1 = 2，[ 1, 3 ] >；>；>；DEF（匹配foo1）：（5）# lst.append…这个效果不错…& gt…；>；>；匹配foo1（& gt）；>；>；1 [ 1, 2, 3，5 ] >；>；>；1 = [ 1 2, 3 ] >，>；>；定义；Foo2（LST = [ 5 ]）：…#…但是这些炸弹！& gt…>；>；Foo2；Traceback（最）最近通话（上）：stdin文件；1号线，；；文件”线，2，在foounboundlocalerror：当地variable'lst'referenced之前分配
奇怪的是，为什么匹配foo1正常运行，和Foo2死机？
原因与前面的问题类似，但这里的错误更为微妙。功能匹配foo1不指定一个值的变量和函数的LST，Foo2有一个赋值操作。
首先，LST =【5】= 1＋1的缩写[ 5 ]，在Foo2功能在试图做一个分配给变量的LST（Python变量LST默认为局部变量）。然而，LST + = [ 5 ]声明是一变量自动赋值操作（在可变LST范围是一个功能，但功能Foo2 Foo2）不声明变量，所以他们叫你！
常见错误5：遍历列表时修改列表
下面代码中的错误是显而易见的：
>；>；>；奇数=λx：bool（x 2）>；>；>；数= [ N N的范围（10）] >；>；>；我在范围（Len（数字）：奇（数）[我]）：如果…德尔数[我]：删除项目#坏…从listwhile迭代Traceback（最近的叫它…最后文件”）：；2号线，；误差系数：列表索引超出范围
有经验的程序员知道，在使用Python遍历列表或数组时，不应删除列表（数组）中的元素。虽然上述代码的错误是显而易见的，但是高级程序员在编写复杂代码时会犯这样的错误。
幸运的是，Python集成了大量经典编程范例，如果使用得当，可以大大简化代码并提高编程效率。简单的代码将减少错误的可能性。列表解析（列表推导式）是一种工具，将完美的避免了上述缺陷，以及解决方法如下：
>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> numbers[:] = [n for n in numbers if not odd(n)] # ahh, the beauty of it all>>> numbers[0, 2, 4, 6, 8]
关于列表解析，更多详情请戳：http：/ /文档。Python。org / 2 /教程/数据结构。HTML #啧啧listcomps
常见错误6：不理解Python闭包中的变量绑定
代码示例：
>；>；>；create_multipliers（DEF）：…返回[λx：i x，i（5）；”；“；”；“；”；“gt”：…
你认为运行结果会是：
02468
但实际产出结果如下：8
八千八百八十八
没有惊喜！
这种情况是由Python延迟绑定（后期绑定）机制引起的，也就是说，只有在调用内部函数时，才会搜索闭包中的变量的值。所以在上面的代码中，每次在create_multipliers回归函数（）函数被调用时，该变量的值我是在附近的范围查询。（此时，返回的循环结束，所以i值为4）。
常见的解决方案：
>；>；>；DEF create_multipliers（）：返回[λx，我=我：我×××，我（5）]；…；”；“；”；“；“；”；“诗”：“02468”…
是的，我们使用匿名函数lambda的默认参数生成结果序列。有些人认为它很简单，有人会说它很聪明，其他人会觉得很难理解。如果您是Python开发人员，对语法有深刻的理解是非常重要的。
常见错误7：模块之间的循环依赖关系
假设你有两个文件，a.py和b.py，并互相介绍，如下图所示：
在a.py模块代码：
进口bdef f（）：返回b.xprint f（）
在b.py模块代码：
进口AX = 1def G（）：打印A.f（）
首先，我们尝试导入a.py：
进口A1
运行结果正确！这似乎有点意外，因为我们在这里进行循环介绍，应该报错了！
答案是，如果Python中只有一个循环导入，程序就不会出错。如果导入了一个模块，Python将自动识别并不再次导入。但如果每个模块的功能或变量以不同的位置访问其他模块，那么错误易出现双倍。
回到上面的例子中，输入a.py模块时，程序可以导入b.py模块正常，因为b.py模块不当时参观a.py任何变量或函数。的b.py模块只引用A.f（）在a.py模块功能。调用A.f（）函数属于G（）函数，和G（）函数不叫在a.py或b.py模块。所以程序没有错。
但是，如果我们进口的b.py模块导入前的a.py模块，结果会怎样？
>；>；>；进口btraceback（最后调用文件”）：；1号线，；文件”b.py”线，1，在& lt；模块& gt进口；文件a.py，6号线，在；F（文件）”a.py”，4号线，在freturn b.xattributeerror：'module'object没有attribute'x”
错了！问题是，在进口b.py过程，它试图进口a.py模块，和a.py模块调用f（）函数，和f（）函数试图访问b.x变量。但在这一点上，b.x变量未定义，那么还有一个意思是例外。
上述问题可以通过稍微修改b.py，即解决，进口在G a.py（）函数。
改性b.py：
x = 1def g（）：
进口这将只计算#当G（是）calledprint（A.f）
现在我们进入b.py模块，不给你！
>；>；>；进口B >；>；>；（1）不到印刷# module'a'calls'print以来第一次（F）在可以印刷#”了一次，这是我们的电话to'g”
常见错误8：文件命名与Python标准库模块的名称冲突
Python的优点之一是它集成了一个丰富的标准库。因此，稍微关注一下Python标准库模块名和文件名。例如，如果有一个模块的代码中的命名email.py，只是email.py模块和Python标准库中的名字。）
上述问题更为复杂。例如，当导入模块A时，如果模块A试图在Python标准库中导入模块B，但您定义了一个同名的模块B，模块A将错误地将您的自定义模块B替换为Python标准库中的模块B。这是一个严重的错误，因为程序员很难意识到它是由命名冲突引起的。
因此，Python程序员应该注意避免与Python标准库模块的命名冲突。毕竟，修改自己模块的名称比修改标准库的名称要容易得多！当然，您还可以编写一个Python改进建议（Python增强建议，PEP），用于修改标准库的名称。
常见错误9：不熟悉python2和Python3之间的差异
首先看代码在叫foo.py文件：
进口系统定义的酒吧（我）：如果我= = 1：提高KeyError（1）如果我= = 2（2）：提高ValueError DEF坏（nonetry：）：E =酒吧（int（sys. argv [ 1 ]））除了KeyError E：打印（关键错误”）作为除ValueError E：打印（币值误差）打印（E（坏））
在Python 2中，上述代码正常运行。
Python 1key错误值1美元美元叫foo.py Python叫foo.py 2value 2
但在Python 3中运行时：
1key Python3美元叫foo.py errortraceback（最后调用）：文件“foo。PY”，19行，叫foo.py；”、“，”*（”）、“17”、“于”、“于”、“
发生了什么事？结果表明，在Python 3中，除了代码块操作区域外，不能访问异常对象。（原因是Python 3将循环引用保存在内存堆栈中，直到垃圾收集器在垃圾收集器运行之后在内存中清除。）
更多内容，请戳：
http：/ /文档。Python。org / 3 /参考/ compound_stmts HTML #除外。
一种解决方案是，在除代码块的范围之外，可以通过对异常对象的引用来访问异常对象。以下是处理代码和运行结果python2和Python3是一致的：
进口系统定义的酒吧（我）：如果我= = 1：提高KeyError（1）如果我= = 2（2）：提高ValueError DEF好（nonetry：）：例外=酒吧（int（sys. argv [ 1 ]））除了KeyError E：例外= E打印（关键错误”）除了E = E：ValueError异常打印（币值误差）打印（例外）（好的）
再次，在Python3运行代码：
1key错误值1美元美元叫foo.py Python3 Python3叫foo.py 2value 2
问题解决了！
更多关于python2和Python3的区别，请戳：
http：/ / toptal。COM / Python #招聘指南
常见错误10：_del_误用的方法
假设文件名为mod.py有以下代码：
进口fooclassbar（对象）：…DEF __del__（自我）：foo.cleanup（自我。myhandle）
那么，你想在another_mod.py文件做如下：
进口modmybar = MOD吧（）。
如果你尝试运行another_mod.py，会有一个意思是例外。
为什么？因为当Python解释器关闭时，模块全局变量的值设置为。因此，在上面的例子中，当__del__函数被调用foo的值已经没有。
有关Python解释器的更多信息，请盖章：
https://mail.python.org/pipermail/python-bugs-list/2009-january/069209.html
调用atexit.register（）函数可以解决以上Python高阶编程问题。atexit.register（）函数调用后，当你的代码运行时，它将运行解释器关闭之前。
利用上述方法，修改后的mod.py文件如下：
进...
Python程序员最常犯的10个错误，你中招了吗？ 流量视频课程
大数据文摘作品
编译：什锦甜、Gao Ning、小鱼
Python简介
Python是一种具有动态语义的、面向对象的解释型高级编程语言。因其内置了高级数据结构，并支持动态类型和动态绑定，使用Python进行快速应用程序开发十分便利。同时作为一门脚本语言，它兼容部分现有的组件和服务。Python还支持模块和各种库的扩展，有助于实现模块化编程和提高代码复用率。
关于本文
刚接触这门语言的新手可能会对Python简洁灵活的语法有些不适应，或是低估了Python强大的性能。鉴于此，本文列出了Python开发人员常犯的10个小错误，资深程序猿也难免会中招哦。
本文供Python高级开发人员参考，Python小白可以参考下面这篇文章：
http://onlamp/pub/a/python/2004/02/05/learn_python.html
常见错误1：滥用表达式作为函数参数的默认值
Python允许开发者指定函数参数的默认值，这也是Python的一大特色，但当默认值可变时，可能会给开发者带来一些困扰。例如下面定义的函数：
>>> def foo(bar=[]): # bar is optional and defaults to [] if not specified... bar.append("baz") # but this line could be problematic, as we'll see...... return bar
看出bug了吗？那就是在每次调用函数前没有对可变参数进行赋值，而认为该参数就是默认值。比如上面的代码，有人可能期望在反复调用foo()时返回'baz'，以为每次调用foo()时，bar的值都为[]，即一个空列表。
但是，让我们来看看代码运行结果：
>>> foo()["baz"]>>> foo()["baz", "baz"]>>> foo()["baz", "baz", "baz"]
嗯？为什么每次调用foo()后会不断把"baz"添加到已有的列表，而不是新建一个新列表呢？答案就是，函数参数的默认值仅在定义函数时执行一次。因此，仅在第一次定义foo()时，bar初始化为默认值（即空列表），此后，每次调用foo()函数时，参数bar都是第一次初始化时生成的列表。
常见的解决方案：
>>> def foo(bar=None):... if bar is None: # or if not bar:... bar = []... bar.append("baz")... return bar...>>> foo()["baz"]>>> foo()["baz"]>>>foo()["baz"]
常见错误2：错误地使用类变量
代码示例：
>>> class A(object):... x = 1...>>> class B(A):... pass...>>> class C(A):... pass...>>> print A.x, B.x, C.x1 1 1
运行结果没问题。
>>> B.x = 2>>> print A.x, B.x, C.x1 2 1
结果也正确。
>>> A.x = 3>>> print A.x, B.x, C.x3 2 3
什么鬼？我们只改变了A.x.，为什么C.x 也变了？
在Python中，类变量是以字典形式进行内部处理，遵循方法解析顺序（Method Resolution Order ，MRO）。因此，在上述代码中，因为在类C中没有找到属性x，它就会从父类中查找x的值（尽管Python支持多重继承，但上述代码只存在一个父类A）。换句话说，C没有独立于类A的属于自己的x。因此，C.x实际上指的是A.x。除非处理得当，否则就会导致Python出现错误。
如果想更深入了解Python的类特性，请戳：
https://toptal/python/python-class-attributes-an-overly-thorough-guide
常见错误3：错误指定异常代码块的参数
假设你有如下代码：
>>> try:... l = ["a", "b"]... int(l[2])... except ValueError, IndexError: # To catch both exceptions, right?... pass...Traceback (most recent call last):File "
这里的问题是except语句不接受以这种方式指定的异常列表。在Python2.x中，except Exception语句中变量e可用来把异常信息绑定到第二个可选参数上，以便进一步查看异常的情况。因此，在上述代码中，except语句并没有捕捉到IndexError异常；而是将出现的异常绑定到了参数IndexError中。
想在一个except语句同时捕捉到多个异常的正确方式是，将第一个参数指定为元组，并将要捕捉的异常类型都写入该元组中。为了方便起见，可以使用as关键字，Python 2 和Python 3都支持这种语法格式：
>>> try:... l = ["a", "b"]... int(l[2])... except (ValueError, IndexError) as e: ... pass...>>>
常见错误4：错误理解Python中变量的作用域
Python变量作用域遵循LEGB规则，LEGB是Local，Enclosing，Global，Builtin的缩写，分别代表本地作用域、封闭作用域、全局作用域和内置作用域，这个规则看起来一目了然。事实上，Python的这种工作方式较为独特，会导致一些编程错误，例如：
>>> x = 10>>> def foo():... x += 1... print x...>>> foo()Traceback (most recent call last):File "
问题出在哪？
上面的错误是因为在作用域内对变量赋值时，Python自动将该变量视为该作用域的本地变量，并对外部定义的同名变量进行了屏蔽。因此，原本正确的代码，在某个函数内部添加了一个赋值语句后，却意外收到了UnboundLocalError的报错信息。
关于UnboundLocalError更多内容请戳：
https://docs.python.org/2/faq/programming.html#why-am-i-getting-an-unboundlocalerror-when-the-variable-has-a-value
在使用列表时，Python程序员更容易掉入此类陷阱，例如：
>>> lst = [1, 2, 3]>>> def foo1():... lst.append(5) # This works ok......>>> foo1()>>> lst[1, 2, 3, 5]>>> lst = [1, 2, 3]>>> def foo2():... lst += [5] # ... but this bombs!...>>> foo2()Traceback (most recent call last):File "
奇怪，为什么foo1正常运行，而foo2崩溃了呢？
原因和上一个案例中出现的问题相似，但这里的错误更加细微。函数foo1没有对变量lst进行赋值操作，而函数foo2有赋值操作。
首先， lst += [5]是lst = lst + [5]的缩写形式，在函数foo2中试图对变量lst进行赋值操作（Python将变量lst默认为本地作用域的变量）。但是，lst += [5]语句是对lst变量自身进行的赋值操作（此时变量lst的作用域是函数foo2），但是在函数foo2中还未声明该变量，所以就报错啦！
常见错误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] # BAD: Deleting item from a list while iterating over it...Traceback (most recent call last):File "
有经验的程序员都知道，在Python中遍历列表或数组时不应该删除该列表（数组）中的元素。虽然上面代码的错误很明显，但是在编写复杂代码时，资深程序员也难免会犯此类错误。
幸好Python集成了大量经典的编程范式，如果运用得当，可以大大简化代码并提高编程效率。简单的代码会降低出现上述bug的几率。列表解析式（list comprehensions）就是利器之一，它将完美避开上述bug，解决方案如下：
>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> numbers[:] = [n for n in numbers if not odd(n)] # ahh, the beauty of it all>>> numbers[0, 2, 4, 6, 8]
更多有关列表解析式的详细内容，请戳：https://docs.python.org/2/tutorial/datastructures.html#tut-listcomps
常见错误6：不理解Python闭包中的变量绑定
代码示例：
>>> def create_multipliers():... return [lambda x : i * x for i in range(5)]>>> for multiplier in create_multipliers():... print multiplier(2)...
你以为运行结果会是：
02468
但实际输出结果是：8
8888
惊不惊喜！
这种情况是由于Python延迟绑定（late binding）机制造成的，也就是说只有在内部函数被调用时才会搜索闭包中变量的值。所以在上述代码中，每次调用create_multipliers()函数中的return函数时，会在附近作用域中查询变量i的值。（此时，return中循环已结束，所以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)...02468
没错！我们利用了匿名函数lambda的默认参数来生成结果序列。有人觉得这种用法很简洁，有人会说它很巧妙，还有人会觉得晦涩难懂。如果你是Python开发人员，那么深刻理解上述语法对你而言非常重要。
常见错误7：模块之间出现循环依赖
假设你有两个文件，分别是a.py和b.py，两者相互导入，如下所示：
a.py模块中的代码：
import bdef f():return b.xprint f()
b.py模块中的代码：
import ax = 1def g():print a.f()
首先，我们尝试导入a.py：
>>> import a1
运行结果正确！这似乎有点出人意料，因为我们在这里进行循环导入，应该会报错呀！
答案是，在Python中如果仅存在一个循环导入，程序不会报错。如果一个模块已经被导入，Python会自动识别而不会再次导入。但是如果每个模块试图访问其他模块不同位置的函数或变量时，那么Error又双叒叕出现了。
回到上面的示例中，当导入a.py模块时，程序可以正常导入b.py模块，因为此时b.py模块未访问a.py中定义任何的变量或函数。b.py模块仅引用了a.py模中的a.f()函数。调用的a.f()函数隶属于g()函数，而a.py或b.py模块中并没有调用g()函数。所以程序没有报错。
但是，如果我们在未导入a.py模块之前先导入b.py模块，结果会怎样？
>>> import bTraceback (most recent call last):File "
报错了！问题在于，在导入b.py的过程中，它试图导入a.py模块，而a.py模块会调用f()函数，f()函数又试图访问b.x变量。但此时，还未对变量b.x进行定义，所以出现了AttributeError异常。
稍微修改下b.py，即在g()函数内部导入a.py就可以解决上述问题。
修改后的b.py：
x = 1def g():
import a # This will be evaluated only when g() is calledprint a.f()
现在我们再导入b.py模块，就不会报错啦！
>>> import b>>> b.g()1 # Printed a first time since module 'a' calls 'print f()' at the end1 # Printed a second time, this one is our call to 'g'
常见错误8：文件命名与Python标准库模块的名称冲突
Python的优势之一就是其集成了丰富的标准库。正因为如此，稍不留神就会在为自己的文件命名时与Python自带标准库模块重名。例如，如果你的代码中有一个名为email.py的模块，恰好就和Python标准库中email.py模块重名了。）
上述问题比较复杂。举个例子，在导入模块A的时候，假如该模块A试图导入Python标准库中的模块B，但你已经定义了一个同名模块B，模块A会错误导入你自定义的模块B，而不是Python标准库中的模块B。这种错误很糟糕，因为程序员很难察觉到是因为命名冲突而导致的。
因此，Python程序员要注意避免与Python标准库模块的命名冲突。毕竟，修改自己模块的名称比修改标准库的名称要容易的多！当然你也可以写一份Python改善建议书（Python Enhancement Proposal，PEP）提议修改标准库的名称。
常见错误9：不熟悉Python2和Python3之间的差异
先来看看foo.py文件中的代码：
import sysdef 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 1key error1$ python foo.py 2value error2
但是在Python 3中运行时：
$ python3 foo.py 1key errorTraceback (most recent call last):File "foo.py", line 19, in
什么情况？原来，在Python 3中，在except代码块作用域外无法访问异常对象。（原因是，Python 3会将内存堆栈中的循环引用进行保留，直到垃圾回收...
