Python:What the f*ck Python(下)
GitHub 上有一個名為《What the f*ck Python!》的專案,這個有趣的專案意在收集 Python 中那些難以理解和反人類直覺的例子以及鮮為人知的功能特性,並嘗試討論這些現象背後真正的原理!
原版地址:https://github.com/satwikkansal/wtfpython
最近,一位名為“暮晨”的貢獻者將其翻譯成了中文。
中文版地址:https://github.com/leisurelicht/wtfpython-cn
上一篇 Python:What the f*ck Python(上)
原本每個的標題都是原版中的英文,有些取名比較奇怪,不直觀,我換成了可以描述主題的中文形式,有些是自己想的,不足之處請指正。另外一些 Python 中的彩蛋被我去掉了。
26. 非英文字元
>>> value = 11
>>> valuе = 32
>>> value
11
什麼鬼?
將程式碼複製到 pycharm 裡看一下就明白了。
有些一些非西方字元雖然看起來和英語字母相同,但會被直譯器識別為不同的字母。我們基本不會用到。
27. 空間移動
import numpy as np def energy_send(x): # 初始化一個 numpy 陣列 np.array([float(x)]) def energy_receive(): # 返回一個空的 numpy 陣列 return np.empty((), dtype=np.float).tolist()
Output:
>>> energy_send(123.456)
>>> energy_receive()
123.456
說明:
energy_send 函式中建立的 numpy 陣列並沒有返回,因此記憶體空間被釋放並可以被重新分配。
numpy.empty() 直接返回下一段空閒記憶體,而不重新初始化。而這個記憶體點恰好就是剛剛釋放的那個(通常情況下,並不絕對)。
28. 不要混用製表符(tab)和空格(space)
tab 是8個空格,而用空格表示則一個縮排是4個空格,混用就會出錯。python3 裡直接不允許這種行為了,會報錯:
TabError: inconsistent use of tabs and spaces in indentation
很多編輯器,例如 pycharm,可以直接設定 tab 表示 4 個空格。
29. 迭代字典時的修改
x = {0: None}
for i in x:
del x[i]
x[i+1] = None
print(i)
Output(Python 2.7- Python 3.5):
0
1
2
3
4
5
6
7
說明:
Python 不支援 對字典進行迭代的同時修改它,它之所以執行 8 次,是因為字典會自動擴容以容納更多鍵值(譯: 應該是因為字典的初始最小值是8, 擴容會導致散列表地址發生變化而中斷迴圈)。
在不同的Python實現中刪除鍵的處理方式以及調整大小的時間可能會有所不同,python3.6開始,到5就會擴容。
而在 list 中,這種情況是允許的,list 和 dict 的實現方式是不一樣的,list 雖然也有擴容,但 list 的擴容是整體搬遷,並且順序不變。
list = [1]
j = 0
for i in list:
print(i)
list.append(i + 1)
這個程式碼可以一直執行下去直到 int 越界。但一般不建議在迭代的同時修改 list。
30. __del__
class SomeClass:
def __del__(self):
print("Deleted!")
Output:
>>> x = SomeClass()
>>> y = x
>>> del x # 這裡應該會輸出 "Deleted!"
>>> del y
Deleted!
說明:
del x 並不會立刻呼叫x.__del__()
,每當遇到del x
,Python 會將 x 的引用數減 1,當 x 的引用數減到 0 時就會呼叫x.__del__()
。
我們再加一點變化:
>>> x = SomeClass()
>>> y = x
>>> del x
>>> y # 檢查一下y是否存在
<__main__.SomeClass instance at 0x7f98a1a67fc8>
>>> del y # 像之前一樣,這裡應該會輸出 "Deleted!"
>>> globals() # 好吧, 並沒有。讓我們看一下所有的全域性變數
Deleted!
{'__builtins__': <module '__builtin__' (built-in)>, 'SomeClass': <class __main__.SomeClass at 0x7f98a1a5f668>, '__package__': None, '__name__': '__main__', '__doc__': None}
y.__del__()
之所以未被呼叫,是因為前一條語句(>>> y)對同一物件建立了另一個引用,從而防止在執行del y
後物件的引用數變為 0。(這其實是 Python 互動直譯器的特性,它會自動讓_
儲存上一個表示式輸出的值。)
呼叫globals()
導致引用被銷燬,因此我們可以看到 "Deleted!" 終於被輸出了。
31. 迭代列表時刪除元素
在 29 中,我附加了一個迭代列表時新增元素的例子,現在來看看迭代列表時刪除元素。
list_1 = [1, 2, 3, 4]
list_2 = [1, 2, 3, 4]
list_3 = [1, 2, 3, 4]
list_4 = [1, 2, 3, 4]
for idx, item in enumerate(list_1):
del item
for idx, item in enumerate(list_2):
list_2.remove(item)
for idx, item in enumerate(list_3[:]):
list_3.remove(item)
for idx, item in enumerate(list_4):
list_4.pop(idx)
Output:
>>> list_1
[1, 2, 3, 4]
>>> list_2
[2, 4]
>>> list_3
[]
>>> list_4
[2, 4]
說明:
在迭代時修改物件是一個很愚蠢的主意,正確的做法是迭代物件的副本,list_3[:]
就是這麼做的。
del、remove、pop 的不同:
- del var_name 只是從本地或全域性名稱空間中刪除了 var_name(這就是為什麼 list_1 沒有受到影響)。
- remove 會刪除第一個匹配到的指定值,而不是特定的索引,如果找不到值則丟擲 ValueError 異常。
- pop 則會刪除指定索引處的元素並返回它,如果指定了無效的索引則丟擲 IndexError 異常。
為什麼輸出是 [2, 4]?
列表迭代是按索引進行的,所以當我們從list_2
或list_4
中刪除 1 時,列表的內容就變成了[2, 3, 4]
。剩餘元素會依次位移,也就是說,2
的索引會變為 0,3
會變為 1。由於下一次迭代將獲取索引為 1 的元素(即3
), 因此2
將被徹底的跳過。類似的情況會交替發生在列表中的每個元素上。
32. 迴圈變數洩漏!
①
for x in range(7):
if x == 6:
print(x, ': for x inside loop')
print(x, ': x in global')
Output:
6 : for x inside loop
6 : x in global
②
# 這次我們先初始化x
x = -1
for x in range(7):
if x == 6:
print(x, ': for x inside loop')
print(x, ': x in global')
Output:
6 : for x inside loop
6 : x in global
③
x = 1
print([x for x in range(5)])
print(x, ': x in global')
Output:
[0, 1, 2, 3, 4]
(4, ': x in global')
Output:
[0, 1, 2, 3, 4]
1 : x in global
說明:
在 Python 中,for 迴圈使用所在作用域並在結束後保留定義的迴圈變數。如果我們曾在全域性名稱空間中定義過迴圈變數,它會重新繫結現有變數。
Python 2.x 和 Python 3.x 直譯器在列表推導式示例中的輸出差異,在文件 What’s New In Python 3.0 中可以找到相關的解釋:
"列表推導不再支援句法形式
[... for var in item1, item2, ...]
。使用[... for var in (item1, item2, ...)]
代替。另外注意,列表推導具有不同的語義:它們更接近於list()
建構函式中生成器表示式的語法糖,特別是迴圈控制變數不再洩漏到周圍的作用域中。"
簡單來說,就是 python2 中,列表推導式依然存在迴圈控制變數洩露,而 python3 中不存在。
33. 當心預設的可變引數!
def some_func(default_arg=[]):
default_arg.append("some_string")
return default_arg
Output:
>>> some_func()
['some_string']
>>> some_func()
['some_string', 'some_string']
>>> some_func([])
['some_string']
>>> some_func()
['some_string', 'some_string', 'some_string']
說明:
Python 中函式的預設可變引數並不是每次呼叫該函式時都會被初始化。相反,它們會使用最近分配的值作為預設值。當我們明確的將[]
作為引數傳遞給some_func
的時候,就不會使用default_arg
的預設值, 所以函式會返回我們所期望的結果。
>>> some_func.__defaults__ # 這裡會顯示函式的預設引數的值
([],)
>>> some_func()
>>> some_func.__defaults__
(['some_string'],)
>>> some_func()
>>> some_func.__defaults__
(['some_string', 'some_string'],)
>>> some_func([])
>>> some_func.__defaults__
(['some_string', 'some_string'],)
避免可變引數導致的錯誤的常見做法是將None
指定為引數的預設值,然後檢查是否有值傳給對應的引數。例:
def some_func(default_arg=None):
if not default_arg:
default_arg = []
default_arg.append("some_string")
return default_arg
34. 捕獲異常
這裡將的是 python2
some_list = [1, 2, 3]
try:
# 這裡會丟擲異常 ``IndexError``
print(some_list[4])
except IndexError, ValueError:
print("Caught!")
try:
# 這裡會丟擲異常 ``ValueError``
some_list.remove(4)
except IndexError, ValueError:
print("Caught again!")
Output:
Caught!
ValueError: list.remove(x): x not in list
說明:
如果你想要同時捕獲多個不同型別的異常時,你需要將它們用括號包成一個元組作為第一個引數傳遞。第二個引數是可選名稱,如果你提供,它將與被捕獲的異常例項繫結。
也就是說,程式碼原意是捕獲IndexError, ValueError
兩種異常,但在 python2 中,必須寫成(IndexError, ValueError)
,示例中的寫法解析器會將ValueError
理解成繫結的異常例項名。
在 python3 中,不會有這種誤解,因為必須使用as
關鍵字。
35. +=就地修改
①
a = [1, 2, 3, 4]
b = a
a = a + [5, 6, 7, 8]
Output:
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> b
[1, 2, 3, 4]
②
a = [1, 2, 3, 4]
b = a
a += [5, 6, 7, 8]
Output:
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]
>>> b
[1, 2, 3, 4, 5, 6, 7, 8]
說明:
a += b
並不總是與 a = a + b
表現相同。
表示式 a = a + [5,6,7,8]
會生成一個新列表,並讓 a
引用這個新列表,同時保持 b
不變。
表示式 a += [5, 6, 7, 8]
實際上是使用的是 "extend"
函式,就地修改列表,所以 a
和 b
仍然指向已被修改的同一列表。
36. 外部作用域變數
a = 1
def some_func():
return a
def another_func():
a += 1
return a
Output:
>>> some_func()
1
>>> another_func()
UnboundLocalError: local variable 'a' referenced before assignment
說明:
當在函式中引用外部作用域的變數時,如果不對這個變數進行修改,則可以直接引用,如果要對其進行修改,則必須使用 global
關鍵字,否則解析器將認為這個變數是區域性變數,而做修改之前並沒有定義它,所以會報錯。
def another_func()
global a
a += 1
return a
Output:
>>> another_func()
2
37. 小心鏈式操作
>>> (False == False) in [False] # 可以理解
False
>>> False == (False in [False]) # 可以理解
False
>>> False == False in [False] # 為毛?
True
>>> True is False == False
False
>>> False is False is False
True
>>> 1 > 0 < 1
True
>>> (1 > 0) < 1
False
>>> 1 > (0 < 1)
False
根據https://docs.python.org/2/reference/expressions.html#not-in
形式上,如果 a, b, c, ..., y, z 是表示式,而 op1, op2, ..., opN 是比較運算子,那麼 a op1 b op2 c ... y opN z 就等於 a op1 b and b op2 c and ... y opN z,除了每個表示式最多被評估一次。
False == False in [False]
就相當於False == False and False in [False]
1 > 0 < 1
就相當於1 > 0 and 0 < 1
雖然上面的例子似乎很愚蠢, 但是像 a == b == c
或 0 <= x <= 100
就很棒了。
38. 忽略類作用域的名稱解析
① 生成器表示式
x = 5
class SomeClass:
x = 17
y = (x for i in range(10))
Output:
>>> list(SomeClass.y)
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
② 列表推導式
x = 5
class SomeClass:
x = 17
y = [x for i in range(10)]
Output(Python 2.x):
>>> SomeClass.y
[17, 17, 17, 17, 17, 17, 17, 17, 17, 17]
Output(Python 3.x):
>>> SomeClass.y
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
說明:
- 類定義中巢狀的作用域會忽略類內的名稱繫結。
- 生成器表示式有它自己的作用域。
- 從 Python 3 開始,列表推導式也有自己的作用域。
39. 元組
①
x, y = (0, 1) if True else None, None
Output:
>>> x, y # 期望的結果是 (0, 1)
((0, 1), None)
②
t = ('one', 'two')
for i in t:
print(i)
t = ('one')
for i in t:
print(i)
t = ()
print(t)
Output:
one
two
o
n
e
tuple()
說明:
對於 1,正確的語句是 x, y = (0, 1) if True else (None, None)
。
對於 2,正確的語句是 t = ('one',)
或者 t = 'one'
, (缺少逗號) 否則直譯器會認為 t 是一個字串,並逐個字元對其進行迭代。
()
是一個特殊的標記,表示空元組。
40. else
① 迴圈末尾的 else
def does_exists_num(l, to_find):
for num in l:
if num == to_find:
print("Exists!")
break
else:
print("Does not exist")
Output:
>>> some_list = [1, 2, 3, 4, 5]
>>> does_exists_num(some_list, 4)
Exists!
>>> does_exists_num(some_list, -1)
Does not exist
② try 末尾的 else
try:
pass
except:
print("Exception occurred!!!")
else:
print("Try block executed successfully...")
Output:
Try block executed successfully...
說明:
迴圈後的 else
子句只會在迴圈執行完成(沒有觸發 break、return 語句)的情況下才會執行。
try
之後的 else
子句也被稱為 "完成子句",因為在 try
語句中到達 else
子句意味著 try
塊實際上已成功完成。
41. 名稱改寫
class Yo(object):
def __init__(self):
self.__honey = True
self.bitch = True
Output:
>>> Yo().bitch
True
>>> Yo().__honey
AttributeError: 'Yo' object has no attribute '__honey'
>>> Yo()._Yo__honey
True
說明:
python 中不能像 Java 那樣使用 private 修飾符建立私有屬性。但是,直譯器會通過給類中以 _(雙下劃線)開頭且結尾最多隻有一個下劃線的類成員名稱加上 類名 來修飾。這能避免子類意外覆蓋父類的“私有”屬性。
舉個例子:有人編寫了一個名為 Dog
的類,這個類的內部用到了 mood
例項屬性,但是沒有將其開放。現在,你建立了 Dog
類的子類 Beagle
,如果你在毫不知情的情況下又建立了一個 mood
例項屬性,那麼在繼承的方法中就會把 Dog
類的 mood
屬性覆蓋掉。
為了避免這種情況,python 會將 __mood
變成 _Dog__mood
,而對於 Beagle 類來說,會變成 _Beagle__mood
。這個語言特性就叫名稱改寫(name mangling)。
42. +=更快
>>> timeit.timeit("s1 = s1 + s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
0.25748300552368164
# 用 "+=" 連線三個字串:
>>> timeit.timeit("s1 += s2 + s3", setup="s1 = ' ' * 100000; s2 = ' ' * 100000; s3 = ' ' * 100000", number=100)
0.012188911437988281
說明:
連線兩個以上的字串時 += 比 + 更快,因為在計算過程中第一個字串(例如, s1 += s2 + s3 中的 s1)不會被銷燬。(就是 += 執行的是追加操作,少了一個銷燬新建的動作。)