python是一门清晰简洁的语言，如果你对一些细节不了解的话，就会掉入到那些深不见底的“坑”里，下面，我就来总结一些python里常见的坑。
列表创建和引用
嵌套列表的创建
使用*号来创建一个嵌套的list:
|
1
2
3
|
li = [[]] * 3print(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 + elementprint(li)# out: [[], [], []]element.append(1)print(li)# out: [[1], [1], [1]] |
我们可以打印出元素的内存地址一探究竟：
|
1
2
3
|
li = [[]] * 3print([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 #1index = 0alist = [0, 1, 2]alist.pop(0) # removes '0'# iteration #2index = 1alist = [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 = 0a = [i for i in range(3)]print(i) # outputs 2 |
python2中列表推导改变了i变量的值，而python3修复了这个问题：
|
1
2
3
|
i = 0a = [i for i in range(3)]print(i) # outputs 0 |
类似地，for循环对于它们的迭代变量没有私有的作用域
|
1
2
3
4
|
i = 0for i in range(3): passprint(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
