我通过艰辛的方式学习了它们，但是您不需要

面对现实吧。 学习编程很难。

许多人会同意，但有些人不同意。 我不相信。

这是因为我总能发现微妙的方法来用不同的编程语言来完成我想做的事情。 我以为我已经掌握了它们。 但是我错了。 您可以在代码中执行任何操作，但不应执行任何操作。

我很快意识到，我尝试过的那些"微妙"方法都是不好的做法。 但是，一段有效的代码怎么会变坏呢？ 我习惯于采用这些不良（微妙）的做法，后来又困扰了我。 我了解到这很困难。

在分享每个Python新手应该知道的4个常见错误之前，请确保您熟悉以下文章中的一些Python内置功能。

 1.不使用迭代器

每个Python新手都会这样做，无论他们是否熟练使用其他编程语言。 跑不了的。

给定一个列表list_，您将如何使用for循环逐个访问列表中的元素？ 我们知道Python中的列表已建立索引，因此我们可以通过list_ [i]访问第i个元素。 然后，我们可以为for循环创建一个介于0到len（list_）之间的整数的迭代器，如下所示：

for i in range(len(list_)):foo(list_[i])

 有用。 代码没有问题。 这也是在其他语言（例如C）中构造for循环的标准方法。但是实际上，我们可以在Python中做得更好。

怎么样？

您知道Python中的列表是可迭代的吗？ 通过利用其可迭代的性质，我们可以生成更具可读性的代码，如下所示：

for element in list_:foo(element)

 

通过zip函数可以在for循环中并行遍历多个列表，而如果您坚持在迭代可迭代对象时获取索引号（即计数器），则枚举可能会有所帮助。 我希望早先了解的5个Python功能对它们进行了介绍和解释。

 2.使用全局变量

全局变量是在主脚本中声明的具有全局范围的变量，而局部变量是在具有局部范围的函数内声明的变量。 在Python中使用global关键字可让您在函数中本地访问和更改全局变量。 这是一个例子：

a = 1 # a variable    def increment():    a += 1    return adef increment2():    global a # can make changes to global variable "a"    a += 1     return a  increment()  # UnboundLocalError: local variable 'a' referenced before assignmentincrement2() # returns 2

许多初学者都喜欢它，因为使用global似乎可以避免传递函数所需的所有参数。 但这实际上是不正确的。 它只是隐藏了动作。

使用全局变量也不利于调试。 功能应被视为功能块框，并且应可重复使用。 修改全局变量的函数可能会给很难发现的主脚本带来副作用，并且可能导致复杂的意大利面条式代码，并且调试起来要困难得多。

在局部函数中修改全局变量是不良的编程习惯。 您应该将变量作为参数传递，对其进行修改，并在函数末尾将其返回。

*不要将全局变量与全局常量混淆，因为在大多数情况下使用后者非常好。

3.不了解可变对象

对于新的Python学习者来说，这也许是最常见的惊喜，因为此功能在该语言中非常独特。

Python中有两种对象。 可变对象可以在运行时更改其状态或内容，而不可变对象则不能。 许多内置对象类型是不可变的，包括int，float，string，bool和tuple。

st = 'A string' st[0] = 'B' # You cannot do this in Python

 另一方面，诸如list，set和dict的数据类型是可变的。 因此，您可以更改列表中元素的内容，例如 list_ [0] ='new'。

如果函数中的默认参数是可变的，则会发生意外情况。 让我们以以下函数为例，其中可变的空列表是参数list_的默认值。

def foo(element, list_=[]): list_.append(element) r  eturn list_

 

让我们两次调用该函数，而不用输入list_的参数，以使其采用默认值。 理想情况下，如果不提供第二个参数，则每次调用该函数时都会创建一个新的空列表。

a = foo(1) # returns [1]b = foo(2) # returns [1,2], not [2]! WHY?

 什么？

事实证明，在定义函数时，Python中的默认参数会被评估一次。 这意味着调用该函数不会刷新其默认参数。

因此，如果默认参数是可变的，并且每次调用该函数时都会将其更改。可变的默认参数将适用于所有将来的函数调用。 "标准"解决方案是使用（不可变）None默认值，如下所示。

def foo(element, list_=None): if list_ is None: list_ = [] list_.append(element) return list_

 

4.不复制

复制的概念对于学习者而言可能是陌生的，甚至是违反直觉的。 假设您有一个列表a = [[0,1]，[2,3]]，然后通过b = a声明一个新列表。 现在，您将拥有两个具有相同元素的列表。 通过更改列表b中的某些元素，它应该不会对列表a产生任何（副作用），对吗？

错误。

a = [[0,1],[2,3]]b = ab[1][1] = 100print(a,b) # [[0, 1], [2, 100]] [[0, 1], [2, 100]]print(id(a)==id(b))# True

当您使用赋值语句（即b = a）"复制"列表时，在一个列表元素上所做的任何修改在两个列表中均可见。 赋值运算符仅在目标和对象之间创建绑定，因此示例中的列表a和b共享相同的引用，即Python中的id（）。

如何复制对象？

如果您要"复制"对象并且仅修改新（或旧）对象中的值而没有绑定，则有两种创建副本的方法：浅副本和深副本。 两个对象将具有不同的引用。

使用前面的示例，可以通过b = copy.copy（a）创建a的浅表副本。 浅表副本会创建一个新对象，该对象存储原始元素的引用。 这听起来可能很复杂，但让我们看下面的示例：

import copya = [[0,1],[2,3]]b = copy.copy(a)print(id(a)==id(b))# Falseb[1] = 100print(a,b)# [[0, 1], [2, 3]] [[0, 1], 100]b[0][0] = -999print(a,b)# [[-999, 1], [2, 3]] [[-999, 1], 100]print(id(a[0]) == id(b[0]))# True

在创建嵌套列表a的浅副本（我们称为b）之后，两个列表具有不同的引用id（a）！= id（b），符号！=表示"不等于"。 但是，它们的元素具有相同的引用，因此id（a [0]）== id（b [0]）。

这意味着更改b内部的元素不会影响列表a，但是修改b [1]内部的元素确实会影响a [1]，因此此副本很浅。

简而言之，如果b是a的浅副本，则对b中的嵌套对象内的元素进行的任何更改都将显示在a中。

如果要复制嵌套对象而元素之间没有任何绑定，则需要使用b = copy.deepcopy（a）的深拷贝。 深层副本将创建一个新对象，然后以递归方式在原始元素中创建嵌套对象的副本。

简而言之，深拷贝复制所有内容而没有任何绑定。