8大Python小陷阱，深入理解Python

学习了解python常见的使用陷阱，避免二次踩坑

Python是最流行的且适合初学者学习的语言之一。它的语法非常优雅简洁。只要知道python基础知识，阅读代码几无障碍。

然而，就像其他语言一样，Python确实有一些古怪特殊的地方。本文将介绍Python8大高频陷阱，告诉你冰山之下的世界！

注意：文章中将只提到与Python3相关的使用陷阱，因为Python2即将废弃。

1. 命名空间和作用域

当站在计算机底层观察Python时，有两件事注意：命名空间和作用域。

命名空间

Python是一种面向对象的编程语言，所有东西都被认为是一个对象。命名空间本质上是一个容器，将对象名称映射到对象。

function_namespace = { 
    name_of_obj_a: obj_1, 
    name_of_obj_b: obj_2 
}

for_loop_namespace = { 
    name_of_obj_a: obj_3, 
    name_of_obj_b: obj_4 
}

可以把命名空间看作是Python字典，其中对象的变量名是键，而值是对象本身。我们每次定义一个循环、一个函数或一个类时，都会创建一个新的、独立的命名空间。每个命名空间都有自己的层次结构，称为作用域。

作用域

作用域，是Python解释器可以"看到"所以定义的对象的层次结构。解释器从最小的作用域 (local) 开始，如果找不到声明的变量，就向外寻找封闭的作用域。如果解释器在封闭的作用域中找不到它，它就看向全局作用域。

如下代码所示:

i = 1

def foo():
   i = 5
   print(i, 'in foo()')
   print("local foo() namespace", locals())
   return i

print("global namespace", globals())
foo()

"""
global namespace {'__builtins__': , '__spec__': None, 'foo': , '__file__': 'main.py', '__cached__': None, '__doc__': None, 'i': 1, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f790953ada0>, '__name__': '__main__'}
5 in foo()
local foo() namespace {'i': 5}
"""

代码中一个全局命名空间和一个foo()函数命名空间。可以通过在代码的指定位置打印globals() 和 locals() 来查看各个命名空间的具体内容。

本地命名空间是非常直接的。可以清楚地看到i和它的值5。全局命名空间有一点不同，它还包括来自 Python系统内置的一些内容。

在全局命名空间中，foo()函数显示为内存中的一个位置，而不是函数的返回值，但可以看到变量i的值为1，而不是内存地址。

虽然上面例子中，foo()重新申请了变量i(在本地命名空间中)，但也可以在变量名前面使用 global 关键字将其放到全局命名空间中：

i = 1

def foo():
   global i
   i = 5
   print(i, 'in foo()')
   print("local namespace", locals())
   return i

print("global i before func invocation", globals()["i"])


foo()

print("global i after func invocation", globals()["i"])
"""
global i before func invocation 1
5 in foo()
local namespace {}
global i after func invocation 5
"""

2. 迭代时删除列表项

在Python中处理列表时，我们需要看一下当我们在列表上循环时从列表中删除项目会发生什么。一般来说，由于意外的后果，从一个列表中迭代并删除项目不是一个好主意。以这些例子为例。

del关键字

del关键字只删除本地命名空间中的对象实例，而不是全局命名空间中的对象实例。所以全局定义的list_1不受影响:

list_1 = ["apples", "oranges", "bananas", "strawberries"]

for item in list_1:
   del item

print("list_1: ",list_1); # ['apples', 'oranges', 'bananas', 'strawberries']
"""
list_1:  ['apples', 'oranges', 'bananas', 'strawberries']
"""

remove()方法

在remove()方法中，一旦Python从列表中移除一项，所有其他项将向左移动一次，但是迭代直到所有项都被移动之后才会发生。

list_2 = ["apples", "oranges", "bananas", "strawberries"]

for item in list_2:
   list_2.remove(item)
   print(list_2)

print("list_2: ",list_2)# ['oranges', 'strawberries']
"""
['oranges', 'bananas', 'strawberries']
['oranges', 'strawberries']
list_2:  ['oranges', 'strawberries']
"""

下面是迭代步骤:

1. 第1次迭代：删除apples。oranges向左移动，现在oranges处于当前迭代索引位置。bananas向左移动，成为下一个索引，即下一次迭代的位置。当然strawberries也向左移动。
2. 第2次迭代：bananas在当前索引，所以方法删除bananas。strawberries向左移动，处于当前迭代索引位置。由于没有更多待迭代索引，循环结束。
3. 结果: 列表中只剩下oranges和strawberries。

pop(idx)方法

与列表循环时不推荐使用remove()方法的原因相同，迭代时也不推荐使用pop(idx)方法。

注意: 如果没有传递 idx给 pop()函数，Python将删除列表中的最后一项。

list_3 = ["apples", "oranges", "bananas", "strawberries"]

for item in list_3:
   list_3.pop()
   print(list_3)

print("list_3: ",list_3) # ['apples', 'oranges']
"""
['apples', 'oranges', 'bananas']
['apples', 'oranges']
list_3:  ['apples', 'oranges']
"""

1. 第1次迭代: 删除strawberries，列表长度变为3。继续下一次迭代。
2. 第2次迭代: 删除bananas，列表长度变为2。没有可迭代索引值，循环结束。
3. 结果: 列表中只剩下apples和oranges。

注意：如果索引被传递到 pop()方法中，而它并不存在，会引发 IndexError异常。

如何迭代时删除了？

上述remove()、pop()在迭代时进行列表删除操作没有符合预期，本质上是因为迭代时列表的长度不断的变化。所以一种思路是通过列表切片[:]操作复制一个新的列表，循环时迭代新的列表，但删除操作针对原列表，如下代码：

list_4 = ["apples", "oranges", "bananas", "strawberries"]


for item in list_4[:]: 
      list_4.remove()  #pop() 这里也可以工作 

print("list_4: ",list_4) # []

list_4[:]列表切片操作将在内存中复制一个新列表。当迭代时，本质上不是对原列表进行迭代，但在for函数里面进行了删除原列表的操作，所以最终列表list_4删除了所有项！

3. bool有什么问题？

说到布尔bool值，似乎很简单。下面这个混合类型的列表，有多少个布尔值，有多少个整数值？

mixed_type_list = [
  False, 
  4.55, 
  "edu.py2fun.com",
  3, 
  True,
  [],
  False,
  dict()
]
integers_count = 0
booleans_count = 0

for item in mixed_type_list:
   if isinstance(item, int): # 优先判断int
       integers_count += 1
   elif isinstance(item, bool): # 其次判断bool
       booleans_count += 1


print(integers_count)
print(booleans_count)
"""
4
0
"""

为什么输出是4、0？简而言之，Python中的布尔值是整数int的一个子类。在Python中，True等于1，False等于0。

4. 类变量和实例变量

Python面向对象中，类是一个模板，实例是一个基于该模板的新对象。如果我们试图改变或混淆对类变量和实例变量的赋值，会发生什么？

class Animal:
   x = "tiger"

class Vertebrate(Animal):
   pass

class Cat(Animal):
   pass

print(Animal.x, Vertebrate.x, Cat.x)

Vertebrate.x = "monkey"
print(Animal.x, Vertebrate.x, Cat.x)

Animal.x = "lion"
print(Animal.x, Vertebrate.x, Cat.x)

a = Animal()
print(a.x, Animal.x)

a.x += "ess"
print(a.x, Animal.x)
"""
tiger tiger tiger
tiger monkey tiger
lion monkey lion
lion lion
lioness lion
"""

代码中有三个类: Animal、Vertebrate和Cat。当我们在Animal类中分配一个变量，而其他类是Animal类的子类时，这些子类可以访问Animal类中创建的变量。

在处理类和实例对象时，如果你想改变类的变量，请使用类名。如果想改变实例的变量，请使用实例对象名。

5. 小心默认可变参数

下面代码中nums参数默认为[]，并且作为return返回。如果连续多次调用该函数，可能会有一些意想不到的后果：

def num_list(nums=[]):
   num = 1
   nums.append(num)
   return nums

print(num_list())
print(num_list())
print(num_list([]))
print(num_list())
print(num_list([4]))
"""
[1]
[1, 1]
[1]
[1, 1, 1]
[4, 1]
"""

前两次调用num_list()时，都会在nums列表中追加一个1。结果是[1, 1]。要重置这个列表，必须在下一次调用时传入一个空的列表[]。

6. 相同操作符，不同的故事

Python中的重新赋值经常引发疑惑。比如列表一起使用时，= 和 += 操作符有两种不同的含义。

# reassignment
a = [1, 2, 3, 4]
b = a
a = a + [5, 6, 7, 8]

print(a) # [1, 2, 3, 4, 5, 6, 7, 8]
print(b) # [1, 2, 3, 4]
# extends
a = [1, 2, 3, 4]
b = a
a += [5, 6, 7, 8]

print(a) # [1, 2, 3, 4, 5, 6, 7, 8]
print(b) #
"""
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4]
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8]
"""

在操作列表时，=运算符只是意味着重新赋值。当b被赋值为a时，创建了一个当时a的副本。当a被重新赋值为a+[5，6，7，8]时，它将原来的a与[5，6，7，8]连接起来，创建[1，2，3，4，5，6，7，8]。b列表与原来的赋值相比保持不变。

+=运算符，当它涉及到列表时，是extends()方法的一个快捷方式。这样做的结果是列表就地改变，最终a和b都是[1, 2, 3, 4, 5, 6, 7, 8]。

7. split()方法

split()方法在Python中具有一些独特的属性。看下下面例子:

# case 1
print('         foo '.split(" ")) # ['', '', '', '', '', '', '', '', '', 'foo', '']
# case 2
print(' foo        bar   '.split()) # ['foo', 'bar']
# case 3
print(''.split(' ')) #['']
"""
['', '', '', '', '', '', '', '', '', 'foo', '']
['foo', 'bar']
['']
"""

当给split()方法传递分隔符时，在本例中是(" ")，并在任何长度的字符串上使用它，它将在空白处分割。不管你有多少个空白字符，它都会在每个字符上进行分割。

如果没有指明分隔符，Python解释器将把所有重复的空白字符压缩成一个，并在这个字符上进行分割，只留下非空白字符组的分离。

在空白" "字符上分割的空字符''将返回一个以空字符串''为首个元素的列表。

8. 通配符导入

当通配符导入比较省事，但它们有一些特殊细节，经常产生非预期的结果。以此为例：

def hello_world(str):
   return str;

def _hello_world(str):
   return str
from helpers import *
hello_world("hello world -- WORKS!")
_hello_world("_hello_world -- WORKS!")

如果试图在这些文件所在目录中运行该程序，hello_world()函数的第一次调用会正常工作。第二个就不太妙了。当使用通配符*导入时，以下划线_开头的函数不会被导入。

对于这些方法，将不得不直接导入函数，或者使用 __all__ 列表允许通配符*导入。

from helpers import *
print(hello_world("hello world -- WORKS!"))
print(_private_hello_world("__all__ -- WORKS!"))

小节

! 现在你已经知晓Python常见的8大陷阱，希望对你有所启发，避免二次踩坑。

深入理解Python底层实现对了解这些陷阱非常有用。但要真正掌握Python，还有更多的路要走，比如:

• del 如何删除
• 字符串使用技巧
• 子类与父类的关系
• 动态扩展的字典
• 以及更多。

【python学习】
学Python的伙伴,欢迎加入新的交流【君羊】：1020465983
一起探讨编程知识,成为大神,群里还有软件安装包，实战案例、学习资料