脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - Python中一些深不见底的“坑”

Python中一些深不见底的“坑”

2021-07-10 00:20python派森 Python

这篇文章主要给大家介绍了关于Python中一些深不见底的“坑”，文中通过示例代码介绍的非常详细，对大家学习或者使用Python具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧

python是一门清晰简洁的语言，如果你对一些细节不了解的话，就会掉入到那些深不见底的“坑”里，下面，我就来总结一些python里常见的坑。

列表创建和引用

嵌套列表的创建

使用*号来创建一个嵌套的list:

?
1
2
3
li = [[]] * 3
print(li)
# out: [[], [], []]

通过这个方法，可以得到一个包含3个list的嵌套list，我们来给第一个list增加一个元素：

?
1
2
3
li[0].append(1)
print(li)
# out: [[1], [1], [1]]

通过输出的结果可以看初，我们只给第一元素增加元素，结果三个list都增加了一个元素。这是因为[[]]*3并不是创建了三个不同list，而是创建了三个指向同一个list的对象，所以，当我们操作第一个元素时，其他两个元素内容也会发生变化的原因。效果等同于下面这段代码：

?
1
2
3
4
5
6
7
8
li = []
element = [[]]
li = element + element + element
print(li)
# out: [[], [], []]
element.append(1)
print(li)
# out: [[1], [1], [1]]

我们可以打印出元素的内存地址一探究竟：

?
1
2
3
li = [[]] * 3
print([id(inner_list) for inner_list in li])
# out: [6830760, 6830760, 6830760]

到这我们可以明白原因了。那如何解决了？可以这样：

?
1
li = [[] for _ in range(3)]

这样我们就创建了三个不同的list对象

?
1
2
print([id(inner_list) for inner_list in li])
# out: [6331048, 6331528, 6331488]

列表元素的引用

不要使用索引方法遍历list，例如：

?
1
2
for i in range(len(tab)):
  print(tab[i])

比较好的方法是：

?
1
2
for elem in tab:
print(elem)

for语句会自动生成一个迭代器。如果你需要索引位置和元素，使用enumerate函数：

?
1
2
for i, elem in enumerate(tab):
  print((i, elem))

注意 == 符号的使用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
if (var == true):
  # 当var是：true、1、 1.0、 1l时if条件成立
if (var != true):
  # 当var不是 true 和 1 时if条件成立
if (var == false):
  # 当var是 false 或者 0 (or 0.0, 0l, 0j) if条件成立
 
if (var == none):
  # var是none if条件成立
 
if var:
  # 当var非空(none或者大小为0)对象 string/list/dictionary/tuple, non-0等if条件成立
 
if not var:
  # 当var空(none或者大小为0)对象 string/list/dictionary/tuple, non-0等if条件成立
 
if var is true:
  # 只有当var时true时 if条件成立 1也不行
 
if var is false:
  # 只有当var时false时 if条件成立 0也不行
 
if var is none:
# 和var == none 一致

捕获异常由于提前检查

不够优雅的代码：

?
1
2
3
4
if os.path.isfile(file_path):
  file = open(file_path)
else:
  # do something

比较好的做法：

?
1
2
3
4
try:
  file = open(file_path)
except oserror as e:
  # do something

在python2.6+的里面可以更简洁：

?
1
with open(file_path) as file:

之所以这么用，是这么写更加通用，比如file_path给你传个none就瞎了，还得判断是不是none，如果不判断，就又得抓异常，判断的话，代码有多写了很多。

类变量初始化

不要在对象的init函数之外初始化类属性，主要有两个问题

  • 如果类属性更改，则初始值更改。
  • 如果将可变对象设置为默认值，您将获得跨实例共享的相同对象。

错误示范(除非你想要静态变量)

?
1
2
3
4
5
```
  class car(object):
    color = "red"
    wheels = [wheel(), wheel(), wheel(), wheel()]
```

正确的做法：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
```
  class car(object):
    def __init__(self):
      self.color = "red"
      self.wheels = [wheel(), wheel(), wheel(), wheel()]
```
 
**函数默认参数**
 
```
def foo(li=[]):
  li.append(1)
  print(li)
 
foo([2])
# out: [2, 1]
foo([3])
# out: [3, 1]
```

该代码的行为与预期的一样，但如果我们不传递参数呢？

?
1
2
3
4
5
6
7
```
foo()
# out: [1] as expected...
 
foo()
# out: [1, 1] not as expected...
```

这是因为函数参数类型是定义是确认的而不是运行时，所以在两次函数调用时，li指向的是同一个list对象，如果要解决这个问题，可以这样：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
```
def foo(li=none):
  if not li:
    li = []
  li.append(1)
  print(li)
 
foo()
# out: [1]
 
foo()
# out: [1]
```

这虽然解决了上述的问题，但，其他的一些对象，比如零长度的字符串，输出的结果就不是我们想要的。

?
1
2
3
4
5
6
7
8
9
10
11
```
x = []
foo(li=x)
# out: [1]
 
foo(li="")
# out: [1]
 
foo(li=0)
# out: [1]
```

最常用的办法是检查参数是不是none

?
1
2
3
4
5
6
7
8
9
10
11
12
```
def foo(li=none):
  if li is none:
    li = []
  li.append(1)
  print(li)
 
foo()
# out: [1]
```
 
**在遍历时修改**

for语句在遍历对象是会生成一个迭代器，如果你在遍历的过程中修改对象，会产生意想不到的结果：

?
1
2
3
4
5
alist = [0, 1, 2]
for index, value in enumerate(alist):
  alist.pop(index)
print(alist)
# out: [1]

第二个元素没有被删除，因为迭代按顺序遍历索引。上述循环遍历两次，结果如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
# iteration #1
index = 0
alist = [0, 1, 2]
alist.pop(0) # removes '0'
 
# iteration #2
index = 1
alist = [1, 2]
alist.pop(1) # removes '2'
 
# loop terminates, but alist is not empty:
alist = [1]

如果避免这个问题了，可以创建另外一个list

?
1
2
3
4
5
6
7
alist = [1,2,3,4,5,6,7]
for index, item in reversed(list(enumerate(alist))):
  # delete all even items
  if item % 2 == 0:
    alist.pop(index)
print(alist)
# out: [1, 3, 5, 7]

整数和字符串定义

python预先缓存了一个区间的整数用来减少内存的操作，但也正是如此，有时候会出很奇特的错误，例如：

?
1
2
3
4
>>> -8 is (-7 - 1)
false
>>> -3 is (-2 - 1)
true

另外一个例子

?
1
2
3
4
>>> (255 + 1) is (255 + 1)
true
>>> (256 + 1) is (256 + 1)
false

通过不断的测试，会发现(-3,256)这区间的整数都返回true，有的甚至是(-8,257)。默认情况下，[-5,256]会在解释器第一次启动时创建并缓存，所以才会有上面的奇怪的行为。这是个很常见但很容易被忽略的一个坑。解决方案是始终使用equality（==）运算符而不是 identity（is）运算符比较值。

python还保留对常用字符串的引用，并且可以在比较is字符串的身份（即使用）时产生类似的混淆行为。

?
1
2
>>> 'python' is 'py' + 'thon'
true

python字符串被缓存了，所有python字符串都是该对象的引用，对于不常见的字符串，即使字符串相等，比较身份也会失败。

?
1
2
3
4
>>> 'this is not a common string' is 'this is not' + ' a common string'
false
>>> 'this is not a common string' == 'this is not' + ' a common string'
true

所以，就像整数规则一样，总是使用equal（==）运算符而不是 identity（is）运算符比较字符串值。
列表推导和循环中的变量泄漏

有个例子：

?
1
2
3
i = 0
a = [i for i in range(3)]
print(i) # outputs 2

python2中列表推导改变了i变量的值，而python3修复了这个问题：

?
1
2
3
i = 0
a = [i for i in range(3)]
print(i) # outputs 0

类似地，for循环对于它们的迭代变量没有私有的作用域

?
1
2
3
4
i = 0
for i in range(3):
  pass
print(i) # outputs 2

这种行为发生在python 2和python 3中。

为了避免泄漏变量的问题，请在列表推导和for循环中使用新的变量。

or操作符

例如

?
1
if a == 3 or b == 3 or c == 3:

这个很简单，但是，再看一个：

?
1
if a or b or c == 3: # wrong

这是由于or的优先级低于==，所以表达式将被评估为if (a) or (b) or (c == 3):。正确的方法是明确检查所有条件：

?
1
if a == 3 or b == 3 or c == 3: # right way

或者，可以使用内置函数any()代替链接or运算符：

?
1
if any([a == 3, b == 3, c == 3]): # right

或者，为了使其更有效率：

?
1
if any(x == 3 for x in (a, b, c)): # right

更加简短的写法：

?
1
if 3 in (a, b, c): # right

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对服务器之家的支持。

原文链接：https://segmentfault.com/a/1190000019450201

  • Python
  • 坑

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 csv.DictReader 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2022 脚本之家 | 服务器之家(www.tuohang.net)旗下站点 版权所有关于我们联系我们版权申明网站地图