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）不會被銷燬。（就是 += 執行的是追加操作，少了一個銷燬新建的動作。）