Python 初學者容易踩的 5 個坑

哈嘍大家好，我是鹹魚。

今天鹹魚列出了一些大家在初學 Python 的時候容易踩的一些坑，看看你有沒有中招過。

原文：https://www.bitecode.dev/p/unexpected-python-traps-for-beginners

不明顯的字元串拼接

Python 在詞法分析的時候會把多個字元串自動拼接起來。

data = "very""lazy"
print(data) # verylazy

這個特性可以讓我們在聲明一個長字元串的時候可以分成多行來寫，這樣看起來比較優雅。

msg = (
    "I want this to be on a single line when it prints " 
    "but I want it to be broken into several lines in "
    "the code"
    )


print(msg)
# I want this to be on a single line when it prints but I want it to be broken into several lines in the code

msg ="I want this to be on a single line when it prints " \
    "but I want it to be broken into several lines in " \
    "the code"

print(msg)
# I want this to be on a single line when it prints but I want it to be broken into several lines in the code

但初學者往往會忽略這一點，他們在使用包含字元串的列表時把分隔符漏掉，造成了意想不到的字元串拼接。

比如說他們想要聲明一個包含功能變數名稱的列表host。

host = [
    "localhost",
    "bitecode.dev",
    "www.bitecode.dev"
]

print(host) # ['localhost', 'bitecode.dev', 'www.bitecode.dev']

但是寫成了下麵這樣。

host = [
    "localhost",
    "127.0.0.1",
    "bitecode.dev" # 這裡把逗號忘掉了
    "www.bitecode.dev"
]

print(host) # ['localhost', 'bitecode.devwww.bitecode.dev']

這是有效的代碼，不會觸發語法錯誤，但是解析的時候會把 "bitecode.dev" 和 "www.bitecode.dev" 拼接在一起，變成 'bitecode.devwww.bitecode.dev' 。

sorted() 和 .sort() 傻傻分不清

在 Python 中，大多數函數或方法都會返回一個值。比如說我們要對一個列表裡面的內容進行排序，可以使用 sorted() 方法。

# sorted() 方法會返回一個排序後的新列表
numbers = [4, 2, 3]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # [2, 3, 4]

我們也可以用列表自帶的 .sort() 方法來排序，需要註意的是： .sort() 直接對原有列表進行排序，不會返回任何值。

# .sort() 方法直接對原列表進行排序
numbers = [4, 2, 3]
numbers.sort()
print(numbers) # [2, 3, 4]

但是初學者很容易把 sorted() 的用法用在 .sort() 上，結果發現怎麼返回了一個 None。

numbers = [4, 2, 3]
sorted_numbers = numbers.sort()
print(sorted_numbers) # None

list.sort() 修改原列表，它不會返回任何內容。當 Python 可調用對象不返回任何內容時，會得到 None 。

或者把 .sort() 的用法用在了 sorted() 上。

numbers = [4, 2, 3]
sorted(numbers)
print(numbers) # [4, 2, 3]

不要亂加尾隨逗號

我們在創建一個空元組的時候可以用下麵的兩種方法：

t1 = ()
t2 = tuple()
print(type(t1))
print(type(t2))

在 Python 中，雖然元組通常都是使用一對小括弧將元素包圍起來的，但是小括弧不是必須的，只要將各元素用逗號隔開，Python 就會將其視為元組。

t1 = 1,
print(t1) # (1,)
print(type(t1)) # <class 'tuple'>

所以如果在數據後面多加了一個逗號，就會產生一些問題。

比如說下麵是一個列表：

colors = [
    'red',
    'blue',
    'green',
]
print(colors) # ['red', 'blue', 'green']

如果不小心加了一個尾隨逗號，列表就變成了元組。

colors = [
    'red',
    'blue',
    'green',
],
print(colors) # (['red', 'blue', 'green'],)

在 python 中，包含一個元素的元組必須有逗號，比如下麵是包含一個列表的元組：

colors = [
    'red',
    'blue',
    'green',
],

這是列表：

colors = ([
    'red',
    'blue',
    'green',
])

可怕的 is

在 python 中， is 和 == 都是用來比較 python 對象的，區別是：

• is 比較需要對象的值和記憶體地址都相等
• == 比較只需要對象的值相等就行了

事實上，這兩者的實際使用要遠遠複雜的多。

比如說下麵的 a 和 b 是兩個不同的對象，a is b 應該返回 False，但是卻返回了 True。

a = 4
b = 4

print(a == b) # True
print(a is b) # True

在 python 中，由於小整數池和緩存機制，使用 is 來比較對象往往會出現意想不到的結果。

關於小整數池和緩存機制可以看我這篇文章：

《Python 中 is 和 == 的區別》

奇怪的引用

在Python中，如果 * 運算符用於數字與非數字型數據（列表、字元串、元組等）的結合，它將重覆非數字型數據。

print("0" * 3) # '000'
print((0,) * 3) # (0, 0, 0)

在創建一個多個列表元素的元組時候，如果使用下麵的代碼：

t1 = ([0],) * 3
print(t1) # ([0], [0], [0])

會帶來意想不到的問題：我們對元組中的第一個列表元素中的數據進行算數運算（自增 1）

t1[0][0] += 1
print(t1) # ([1], [1], [1])

我們發現元組中的所有列表元素內的數據都自增 1 了，我們不是只對第一個列表元素進行自增的嗎？

實際上，當我們執行 t1 = ([0],) * 3 的時候，不會創建一個包含三個列表組成的元組，而是創建一個包含 3 個 引用的元組，每個引用都指向同一個列表。

元組中的每個元素都是對同一個可變對象（列表）的引用，所以當我們修改其中的元素時，另外的對象也會跟著發生變化。

正確的方法應該是：

t2 = ([0], [0], [0])  
# 或者 t2 = tuple([0] for _ in range(3))
t2[0][0] += 1             
print(t2) # ([1], [0], [0]) 

在 python 的其他地方中也有這種類似的坑：

def a_bugged_function(reused_list=[]):  
    reused_list.append("woops")         
    return reused_list                  
                                        
print(a_bugged_function())  # ['woops']            
print(a_bugged_function())  # ['woops', 'woops']            
print(a_bugged_function())  # ['woops', 'woops', 'woops']          

可以看到，reused_list 在函數定義中被初始化為一個空列表 []，然後每次函數調用時都使用這個預設的空列表。

在第一次調用 a_bugged_function() 後，列表變成了 ['woops']。然後，在第二次和第三次調用中，它分別繼續被修改，導致輸出的結果為：

['woops']
['woops', 'woops']
['woops', 'woops', 'woops']

這是因為在函數定義中，如果將可變對象（例如列表）作為預設參數，會導致該對象在函數調用時被共用和修改：每次調用函數時，使用的都是同一個列表對象的引用。

為了避免這種情況，常見的做法是使用不可變對象（如 None）作為預設值，併在函數內部根據需要創建新的可變對象。

def a_fixed_function(reused_list=None):
    if reused_list is None:
        reused_list = []
    reused_list.append("woops")
    return reused_list

print(a_fixed_function())
print(a_fixed_function())
print(a_fixed_function())