程式設計常見問題

一般問題

有帶斷點、單步執行等的原始碼級偵錯程式嗎？

是的。

下面介紹了一些 Python 偵錯程式，內建函式 breakpoint() 允許您進入其中任何一個。

pdb 模組是一個簡單但功能足夠的 Python 控制檯模式偵錯程式。它是標準 Python 庫的一部分，並在 庫 參考 手冊中 有詳細介紹。您還可以使用 pdb 的程式碼作為示例編寫自己的偵錯程式。

IDLE 互動式開發環境是標準 Python 發行版的一部分（通常以 Tools/scripts/idle3 的形式提供），其中包含一個圖形偵錯程式。

PythonWin 是一個 Python IDE，包含一個基於 pdb 的 GUI 偵錯程式。PythonWin 偵錯程式對斷點進行著色，並具有許多很酷的功能，例如除錯非 PythonWin 程式。PythonWin 可作為 pywin32 專案的一部分和 ActivePython 發行版的一部分提供。

Eric 是一個基於 PyQt 和 Scintilla 編輯元件構建的 IDE。

trepan3k 是一個類似 gdb 的偵錯程式。

Visual Studio Code 是一個具有除錯工具的 IDE，可與版本控制軟體整合。

有許多商業 Python IDE 包含圖形偵錯程式。它們包括

有什麼工具可以幫助查詢錯誤或執行靜態分析嗎？

是的。

Pylint 和 Pyflakes 進行基本檢查，可幫助您更快地發現錯誤。

靜態型別檢查器，例如 Mypy、Pyre 和 Pytype，可以檢查 Python 原始碼中的型別提示。

如何從 Python 指令碼建立獨立二進位制檔案？

如果您只想要一個使用者可以下載和執行而無需先安裝 Python 發行版的獨立程式，則不需要將 Python 編譯為 C 程式碼的能力。有許多工具可以確定程式所需模組的集合，並將這些模組與 Python 二進位制檔案繫結在一起以生成單個可執行檔案。

其中之一是使用 freeze 工具，它包含在 Python 原始碼樹中作為 Tools/freeze。它將 Python 位元組碼轉換為 C 陣列；使用 C 編譯器，您可以將所有模組嵌入到新程式中，然後將其與標準 Python 模組連結。

它的工作原理是遞迴掃描您的原始檔以查詢 import 語句（兩種形式），並在標準 Python 路徑以及源目錄（用於內建模組）中查詢模組。然後，它將用 Python 編寫的模組的位元組碼轉換為 C 程式碼（可以使用 marshal 模組轉換為程式碼物件的陣列初始化器），並建立一個只包含程式中實際使用的內建模組的自定義配置檔案。然後，它編譯生成的 C 程式碼並將其與 Python 直譯器的其餘部分連結，形成一個自包含的二進位制檔案，其行為與您的指令碼完全相同。

以下軟體包可以幫助建立控制檯和 GUI 可執行檔案

Python 程式有編碼標準或風格指南嗎？

是的。標準庫模組所需的編碼風格記錄在 PEP 8 中。

核心語言

為什麼變數有值時，我卻收到 UnboundLocalError 錯誤？

當透過在函式體中的某個位置新增賦值語句來修改以前工作的程式碼時，收到 UnboundLocalError 可能會令人驚訝。

這段程式碼

>>> x = 10
>>> def bar():
...     print(x)
...
>>> bar()
10

有效，但這段程式碼

>>> x = 10
>>> def foo():
...     print(x)
...     x += 1

導致 UnboundLocalError 錯誤

>>> foo()
Traceback (most recent call last):
  ...
UnboundLocalError: local variable 'x' referenced before assignment

這是因為當您在某個作用域中為變數賦值時，該變數將成為該作用域的區域性變數，並遮蔽外部作用域中任何同名變數。由於 foo 中的最後一條語句為 x 賦值了一個新值，因此編譯器將其識別為區域性變數。因此，當早期的 print(x) 嘗試列印未初始化的區域性變數時，就會發生錯誤。

在上面的示例中，您可以透過將其宣告為全域性變數來訪問外部作用域變數

>>> x = 10
>>> def foobar():
...     global x
...     print(x)
...     x += 1
...
>>> foobar()
10

需要此顯式宣告是為了提醒您（與類和例項變數的表面上類似的情況不同），您實際上正在修改外部作用域中變數的值

>>> print(x)
11

您可以使用 nonlocal 關鍵字在巢狀作用域中執行類似的操作

>>> def foo():
...    x = 10
...    def bar():
...        nonlocal x
...        print(x)
...        x += 1
...    bar()
...    print(x)
...
>>> foo()
10
11

Python 中區域性變數和全域性變數的規則是什麼？

在 Python 中，只在函式內部引用的變數是隱式全域性的。如果變數在函式體內的任何地方賦值，則除非明確宣告為全域性變數，否則它將被假定為區域性變數。

雖然起初有點令人驚訝，但稍加思考即可解釋這一點。一方面，要求對賦值變數使用 global 可以防止意外的副作用。另一方面，如果所有全域性引用都需要 global，那麼您將一直使用 global。您必須將對內建函式或匯入模組元件的每個引用都宣告為全域性。這種混亂會降低 global 宣告在識別副作用方面的有用性。

為什麼迴圈中用不同值定義的 lambda 函式都返回相同的結果？

假設您使用 for 迴圈定義了幾個不同的 lambda（甚至是普通函式），例如

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda: x**2)

這將為您提供一個包含 5 個 lambda 的列表，這些 lambda 計算 x**2。您可能期望，當呼叫它們時，它們將分別返回 0、1、4、9 和 16。然而，當您實際嘗試時，您會看到它們都返回 16

>>> squares[2]()
16
>>> squares[4]()
16

發生這種情況是因為 x 不是 lambda 的區域性變數，而是在外部作用域中定義的，並且在呼叫 lambda 時（而不是定義時）訪問它。在迴圈結束時，x 的值為 4，因此所有函式現在都返回 4**2，即 16。您還可以透過更改 x 的值來驗證這一點，並檢視 lambda 的結果如何變化

>>> x = 8
>>> squares[2]()
64

為了避免這種情況，您需要將值儲存在 lambda 的區域性變數中，這樣它們就不依賴於全域性 x 的值

>>> squares = []
>>> for x in range(5):
...     squares.append(lambda n=x: n**2)

這裡，n=x 建立了一個新的區域性變數 n，該變數在定義 lambda 時計算，因此它與 x 在迴圈中的該點所具有的值相同。這意味著 n 的值在第一個 lambda 中將是 0，在第二個 lambda 中是 1，在第三個 lambda 中是 2，依此類推。因此，每個 lambda 現在都將返回正確的結果

>>> squares[2]()
4
>>> squares[4]()
16

請注意，此行為並非 lambda 特有，也適用於普通函式。

如何在模組之間共享全域性變數？

在單個程式中跨模組共享資訊的規範方法是建立一個特殊模組（通常稱為 config 或 cfg）。只需在應用程式的所有模組中匯入 config 模組；然後該模組將作為全域性名稱可用。因為每個模組只有一個例項，所以對模組物件所做的任何更改都會反映到所有地方。例如

config.py

x = 0   # Default value of the 'x' configuration setting

mod.py

import config
config.x = 1

main.py

import config
import mod
print(config.x)

請注意，使用模組也是實現單例設計模式的基礎，原因相同。

在模組中使用 import 的“最佳實踐”是什麼？

一般來說，不要使用 from modulename import *。這樣做會弄亂匯入器的名稱空間，並使 linters 更難檢測未定義的名稱。

在檔案頂部匯入模組。這樣做可以清楚地表明您的程式碼需要哪些其他模組，並避免模組名稱是否在作用域中的問題。每行使用一個 import 可以輕鬆新增和刪除模組匯入，但每行使用多個 import 可以節省螢幕空間。

按照以下順序匯入模組是好的做法

  1. 標準庫模組 – 例如 sys、os、argparse、re

  2. 第三方庫模組（安裝在 Python 的 site-packages 目錄中的任何模組）——例如 dateutil、requests、PIL.Image

  3. 本地開發模組

有時需要將 import 移動到函式或類中，以避免迴圈匯入問題。Gordon McMillan 說：

當兩個模組都使用“import <module>”形式的 import 時，迴圈匯入是允許的。當第二個模組想從第一個模組中獲取一個名稱（“from module import name”）並且 import 在頂層時，它們會失敗。這是因為第一個模組中的名稱尚未可用，因為第一個模組正忙於匯入第二個模組。

在這種情況下，如果第二個模組僅在一個函式中使用，那麼 import 可以很容易地移動到該函式中。當呼叫 import 時，第一個模組將完成初始化，第二個模組可以執行其 import。

如果某些模組是平臺特定的，可能還需要將 import 移出程式碼的頂層。在這種情況下，甚至可能無法在檔案頂部匯入所有模組。在這種情況下，在相應的平臺特定程式碼中匯入正確的模組是一個不錯的選擇。

僅在需要解決迴圈匯入等問題或嘗試減少模組初始化時間時，才將 import 移動到區域性作用域（例如函式定義內部）。如果許多 import 根據程式執行方式是不必要的，這種技術特別有用。如果模組僅在該函式中使用，您可能還希望將 import 移動到函式中。請注意，首次載入模組可能很昂貴，因為模組會進行一次性初始化，但多次載入模組實際上是免費的，只需進行幾次字典查詢。即使模組名稱已超出作用域，該模組也可能在 sys.modules 中可用。

為什麼預設值在物件之間共享？

這種型別的錯誤通常會困擾新手程式設計師。考慮這個函式

def foo(mydict={}):  # Danger: shared reference to one dict for all calls
    ... compute something ...
    mydict[key] = value
    return mydict

您第一次呼叫此函式時，mydict 包含一個項。第二次呼叫時，mydict 包含兩個項，因為當 foo() 開始執行時，mydict 已經包含一個項。

通常會期望函式呼叫為預設值建立新物件。事實並非如此。預設值在函式定義時只建立一次。如果該物件被更改，就像此示例中的字典一樣，後續對函式的呼叫將引用此更改的物件。

根據定義，數字、字串、元組和 None 等不可變物件是安全的，不會被更改。對字典、列表和類例項等可變物件的更改可能會導致混淆。

由於此特性，不使用可變物件作為預設值是良好的程式設計習慣。相反，使用 None 作為預設值，並在函式內部檢查引數是否為 None，如果是，則建立新的列表/字典/其他。例如，不要這樣寫

def foo(mydict={}):
    ...

而是這樣

def foo(mydict=None):
    if mydict is None:
        mydict = {}  # create a new dict for local namespace

此功能可能很有用。當您有一個耗時的函式要計算時，一種常見的技術是快取每個函式呼叫的引數和結果值，如果再次請求相同的值，則返回快取的值。這稱為“記憶化”，可以透過以下方式實現

# Callers can only provide two parameters and optionally pass _cache by keyword
def expensive(arg1, arg2, *, _cache={}):
    if (arg1, arg2) in _cache:
        return _cache[(arg1, arg2)]

    # Calculate the value
    result = ... expensive computation ...
    _cache[(arg1, arg2)] = result           # Store result in the cache
    return result

您可以使用包含字典的全域性變數而不是預設值；這取決於個人喜好。

如何將可選引數或關鍵字引數從一個函式傳遞到另一個函式？

使用函式引數列表中的 * 和 ** 說明符收集引數；這將為您提供作為元組的位置引數和作為字典的關鍵字引數。然後，您可以在呼叫另一個函式時使用 * 和 ** 傳遞這些引數

def f(x, *args, **kwargs):
    ...
    kwargs['width'] = '14.3c'
    ...
    g(x, *args, **kwargs)

引數和形參之間有什麼區別？

形參 由函式定義中出現的名稱定義，而 實參 是呼叫函式時實際傳遞給函式的值。形參定義了函式可以接受何種實參。例如，給定函式定義

def func(foo, bar=None, **kwargs):
    pass

foo、bar 和 kwargs 是 func 的形參。但是，當呼叫 func 時，例如

func(42, bar=314, extra=somevar)

值 42、314 和 somevar 是實參。

為什麼改變列表“y”也改變了列表“x”？

如果你寫了這樣的程式碼

>>> x = []
>>> y = x
>>> y.append(10)
>>> y
[10]
>>> x
[10]

你可能想知道為什麼向 y 追加一個元素也會改變 x。

導致此結果的有兩個因素

  1. 變數只是引用物件的名稱。y = x 並不會建立列表的副本——它會建立一個新的變數 y，該變數引用 x 引用的同一個物件。這意味著只有一個物件（列表），並且 x 和 y 都引用它。

  2. 列表是可變的，這意味著您可以更改其內容。

呼叫 append() 後，可變物件的內容已從 [] 更改為 [10]。由於兩個變數都引用同一個物件，因此使用任何一個名稱都可以訪問修改後的值 [10]。

如果我們轉而將一個不可變物件賦值給 x

>>> x = 5  # ints are immutable
>>> y = x
>>> x = x + 1  # 5 can't be mutated, we are creating a new object here
>>> x
6
>>> y
5

我們可以看到在這種情況下 x 和 y 不再相等。這是因為整數是不可變的，當我們執行 x = x + 1 時，我們不是透過增加其值來修改整數 5；相反，我們是建立一個新物件（整數 6）並將其賦值給 x（即，更改 x 引用的物件）。在此賦值之後，我們有兩個物件（整數 6 和 5）和兩個引用它們​​的變數（x 現在引用 6，但 y 仍然引用 5）。

有些操作（例如 y.append(10) 和 y.sort()）會修改物件，而表面上類似的操作（例如 y = y + [10] 和 sorted(y)）會建立一個新物件。通常在 Python 中（在標準庫的所有情況下），修改物件的方法將返回 None，以幫助避免將這兩種型別的操作混淆。因此，如果您錯誤地編寫 y.sort() 以為它會給您一個 y 的排序副本，您最終會得到 None，這很可能會導致您的程式生成一個易於診斷的錯誤。

然而，有一類操作，相同的操作有時對不同的型別有不同的行為：增廣賦值運算子。例如，+= 會修改列表，但不會修改元組或整數（a_list += [1, 2, 3] 等同於 a_list.extend([1, 2, 3]) 並修改 a_list，而 some_tuple += (1, 2, 3) 和 some_int += 1 會建立新物件）。

換句話說

  • 如果我們有一個可變物件（list、dict、set 等），我們可以使用一些特定的操作來修改它，所有引用它的變數都將看到更改。

  • 如果我們有一個不可變物件（str、int、tuple 等），所有引用它的變數將始終看到相同的值，但將該值轉換為新值的操作始終返回一個新物件。

如果您想知道兩個變數是否引用同一個物件，可以使用 is 運算子或內建函式 id()。

如何編寫具有輸出引數的函式（按引用呼叫）？

請記住，在 Python 中，引數是透過賦值傳遞的。由於賦值只建立對物件的引用，因此呼叫者和被呼叫者中的引數名稱之間沒有別名，因此本身沒有按引用呼叫。您可以透過多種方式實現所需的效果。

  1. 透過返回結果的元組

    >>> def func1(a, b):
...     a = 'new-value'        # a and b are local names
...     b = b + 1              # assigned to new objects
...     return a, b            # return new values
...
>>> x, y = 'old-value', 99
>>> func1(x, y)
('new-value', 100)

    這幾乎總是最清晰的解決方案。

  2. 透過使用全域性變數。這不是執行緒安全的，不推薦。

  3. 透過傳遞一個可變（原地可更改）物件

    >>> def func2(a):
...     a[0] = 'new-value'     # 'a' references a mutable list
...     a[1] = a[1] + 1        # changes a shared object
...
>>> args = ['old-value', 99]
>>> func2(args)
>>> args
['new-value', 100]

  4. 透過傳遞一個被修改的字典

    >>> def func3(args):
...     args['a'] = 'new-value'     # args is a mutable dictionary
...     args['b'] = args['b'] + 1   # change it in-place
...
>>> args = {'a': 'old-value', 'b': 99}
>>> func3(args)
>>> args
{'a': 'new-value', 'b': 100}

  5. 或者將值捆綁在一個類例項中

    >>> class Namespace:
...     def __init__(self, /, **args):
...         for key, value in args.items():
...             setattr(self, key, value)
...
>>> def func4(args):
...     args.a = 'new-value'        # args is a mutable Namespace
...     args.b = args.b + 1         # change object in-place
...
>>> args = Namespace(a='old-value', b=99)
>>> func4(args)
>>> vars(args)
{'a': 'new-value', 'b': 100}

    幾乎沒有充分的理由搞得這麼複雜。

您的最佳選擇是返回一個包含多個結果的元組。

如何在 Python 中建立高階函式？

您有兩種選擇：可以使用巢狀作用域或可呼叫物件。例如，假設您想定義 linear(a,b)，它返回一個計算值 a*x+b 的函式 f(x)。使用巢狀作用域

def linear(a, b):
    def result(x):
        return a * x + b
    return result

或者使用可呼叫物件

class linear:

    def __init__(self, a, b):
        self.a, self.b = a, b

    def __call__(self, x):
        return self.a * x + self.b

兩種情況下，

taxes = linear(0.3, 2)

都會給出一個可呼叫物件，其中 taxes(10e6) == 0.3 * 10e6 + 2。

可呼叫物件方法的缺點是它有點慢，並且程式碼稍長。但是，請注意，可呼叫物件的集合可以透過繼承共享它們的簽名

class exponential(linear):
    # __init__ inherited
    def __call__(self, x):
        return self.a * (x ** self.b)

物件可以封裝多種方法的狀態

class counter:

    value = 0

    def set(self, x):
        self.value = x

    def up(self):
        self.value = self.value + 1

    def down(self):
        self.value = self.value - 1

count = counter()
inc, dec, reset = count.up, count.down, count.set

這裡，inc()、dec() 和 reset() 就像共享相同計數變數的函式一樣。

如何在 Python 中複製物件？

通常，對於一般情況，請嘗試 copy.copy() 或 copy.deepcopy()。並非所有物件都可以複製，但大多數都可以。

有些物件可以更輕鬆地複製。字典有一個 copy() 方法

newdict = olddict.copy()

序列可以透過切片複製

new_l = l[:]

如何查詢物件的方法或屬性？

對於使用者定義類的例項 x，dir(x) 返回一個按字母順序排列的列表，其中包含例項屬性和方法以及其類定義的屬性。

我的程式碼如何發現物件的名稱？

一般來說，它不能，因為物件實際上沒有名稱。本質上，賦值總是將名稱繫結到值；def 和 class 語句也是如此，但在這種情況下，值是可呼叫的。考慮以下程式碼

>>> class A:
...     pass
...
>>> B = A
>>> a = B()
>>> b = a
>>> print(b)
<__main__.A object at 0x16D07CC>
>>> print(a)
<__main__.A object at 0x16D07CC>

可以說這個類有一個名字：即使它被繫結到兩個名字並透過名字 B 呼叫，建立的例項仍然被報告為類 A 的例項。然而，不可能說這個例項的名字是 a 還是 b，因為兩個名字都繫結到相同的值。

一般來說，您的程式碼不應該需要“知道”特定值的名稱。除非您故意編寫內省程式，否則這通常表明更改方法可能是有益的。

在 comp.lang.python 中，Fredrik Lundh 曾針對這個問題給出了一個很好的類比

就像你找到你家門口的那隻貓的名字一樣：貓（物件）本身不能告訴你它的名字，它也不在乎——所以唯一能找出它叫什麼的方法是問你所有的鄰居（名稱空間），看看那是不是他們的貓（物件）……

……別驚訝，你會發現它有許多名字，或者根本沒有名字！

逗號運算子的優先順序怎麼了？

逗號在 Python 中不是運算子。考慮這個會話

>>> "a" in "b", "a"
(False, 'a')

由於逗號不是運算子，而是表示式之間的分隔符，因此上述表示式的計算結果等同於您輸入了

("a" in "b"), "a"

not

"a" in ("b", "a")

各種賦值運算子（=、+= 等）也是如此。它們並非真正的運算子，而是賦值語句中的語法分隔符。

有 C 語言“?:”三元運算子的等效項嗎？

是的，有。語法如下

[on_true] if [expression] else [on_false]

x, y = 50, 25
small = x if x < y else y

在 Python 2.5 引入此語法之前，一種常見的慣用語是使用邏輯運算子

[expression] and [on_true] or [on_false]

但是，這種習慣用法不安全，因為當 *on_true* 具有錯誤的布林值時，它可能會給出錯誤的結果。因此，始終最好使用 ... if ... else ... 形式。

可以在 Python 中編寫混淆的單行程式碼嗎？

是的。通常這是透過在 lambda 中巢狀 lambda 來完成的。請參閱以下三個示例，稍作修改自 Ulf Bartelt

from functools import reduce

# Primes < 1000
print(list(filter(None,map(lambda y:y*reduce(lambda x,y:x*y!=0,
map(lambda x,y=y:y%x,range(2,int(pow(y,0.5)+1))),1),range(2,1000)))))

# First 10 Fibonacci numbers
print(list(map(lambda x,f=lambda x,f:(f(x-1,f)+f(x-2,f)) if x>1 else 1:
f(x,f), range(10))))

# Mandelbrot set
print((lambda Ru,Ro,Iu,Io,IM,Sx,Sy:reduce(lambda x,y:x+'\n'+y,map(lambda y,
Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,Sy=Sy,L=lambda yc,Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,i=IM,
Sx=Sx,Sy=Sy:reduce(lambda x,y:x+y,map(lambda x,xc=Ru,yc=yc,Ru=Ru,Ro=Ro,
i=i,Sx=Sx,F=lambda xc,yc,x,y,k,f=lambda xc,yc,x,y,k,f:(k<=0)or (x*x+y*y
>=4.0) or 1+f(xc,yc,x*x-y*y+xc,2.0*x*y+yc,k-1,f):f(xc,yc,x,y,k,f):chr(
64+F(Ru+x*(Ro-Ru)/Sx,yc,0,0,i)),range(Sx))):L(Iu+y*(Io-Iu)/Sy),range(Sy
))))(-2.1, 0.7, -1.2, 1.2, 30, 80, 24))
#    \___ ___/  \___ ___/  |   |   |__ lines on screen
#        V          V      |   |______ columns on screen
#        |          |      |__________ maximum of "iterations"
#        |          |_________________ range on y axis
#        |____________________________ range on x axis

孩子們，請勿在家嘗試！

函式引數列表中的斜槓(/)是什麼意思？

函式引數列表中的斜槓表示它之前的引數是僅限位置的。僅限位置的引數是沒有外部可用名稱的引數。在呼叫接受僅限位置引數的函式時，實參僅根據其位置對映到形參。例如，divmod() 是一個接受僅限位置引數的函式。其文件如下

>>> help(divmod)
Help on built-in function divmod in module builtins:

divmod(x, y, /)
    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.

引數列表末尾的斜槓表示這兩個引數都是僅限位置的。因此，使用關鍵字引數呼叫 divmod() 將導致錯誤

>>> divmod(x=3, y=4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: divmod() takes no keyword arguments

數字和字串

如何指定十六進位制和八進位制整數？

要指定八進位制數字，請在八進位制值前面加上零，然後是小寫或大寫“o”。例如，要將變數“a”設定為八進位制值“10”（十進位制為 8），請鍵入

>>> a = 0o10
>>> a
8

十六進位制也同樣簡單。只需在十六進位制數前面加上零，然後是小寫或大寫“x”。十六進位制數字可以用小寫或大寫指定。例如，在 Python 直譯器中

>>> a = 0xa5
>>> a
165
>>> b = 0XB2
>>> b
178

為什麼 -22 // 10 返回 -3？

這主要是出於希望 i % j 具有與 j 相同的符號。如果您希望如此，並且還希望

i == (i // j) * j + (i % j)

那麼整數除法必須返回向下取整的值。C 語言也要求該恆等式成立，然後截斷 i // j 的編譯器需要使 i % j 具有與 i 相同的符號。

當 j 為負數時，i % j 的實際用例很少。當 j 為正數時，有許多用例，並且在幾乎所有這些用例中，i % j 為 >= 0 更實用。如果現在是 10 點，200 小時前是幾點？-190 % 12 == 2 是有用的；-190 % 12 == -10 是一個潛在的錯誤。

如何獲取整數文字屬性而不是 SyntaxError？

嘗試以正常方式查詢 int 文字屬性會產生 SyntaxError，因為句點被視為小數點

>>> 1.__class__
  File "<stdin>", line 1
  1.__class__
   ^
SyntaxError: invalid decimal literal

解決方案是用空格或括號將文字與句點分開。

>>> 1 .__class__
<class 'int'>
>>> (1).__class__
<class 'int'>

如何將字串轉換為數字？

對於整數，使用內建的 int() 型別建構函式，例如 int('144') == 144。類似地，float() 轉換為浮點數，例如 float('144') == 144.0。

預設情況下，它們將數字解釋為十進位制，因此 int('0144') == 144 成立，並且 int('0x144') 會引發 ValueError。int(string, base) 接受要轉換的基數作為第二個可選引數，因此 int( '0x144', 16) == 324。如果基數指定為 0，則數字將使用 Python 的規則進行解釋：前導“0o”表示八進位制，“0x”表示十六進位制數。

如果您只需要將字串轉換為數字，請勿使用內建函式 eval()。eval() 會顯著變慢，並且存在安全風險：有人可能會向您傳遞一個可能產生不必要副作用的 Python 表示式。例如，有人可能會傳遞 __import__('os').system("rm -rf $HOME")，這會擦除您的主目錄。

eval() 還會將數字解釋為 Python 表示式，因此例如 eval('09') 會導致語法錯誤，因為 Python 不允許十進位制數中使用前導“0”（除了“0”）。

如何將數字轉換為字串？

要將數字（例如 144）轉換為字串（'144'），請使用內建型別建構函式 str()。如果您需要十六進位制或八進位制表示，請使用內建函式 hex() 或 oct()。有關花式格式化，請參閱 f-字串 和 格式字串語法 部分，例如 "{:04d}".format(144) 產生 '0144'，"{:.3f}".format(1.0/3.0) 產生 '0.333'。

如何就地修改字串？

你不能，因為字串是不可變的。在大多數情況下，您應該簡單地從您想要組合的各個部分構造一個新字串。但是，如果您需要一個能夠就地修改 Unicode 資料的物件，請嘗試使用 io.StringIO 物件或 array 模組

>>> import io
>>> s = "Hello, world"
>>> sio = io.StringIO(s)
>>> sio.getvalue()
'Hello, world'
>>> sio.seek(7)
7
>>> sio.write("there!")
6
>>> sio.getvalue()
'Hello, there!'

>>> import array
>>> a = array.array('w', s)
>>> print(a)
array('w', 'Hello, world')
>>> a[0] = 'y'
>>> print(a)
array('w', 'yello, world')
>>> a.tounicode()
'yello, world'

如何使用字串呼叫函式/方法？

有多種技術。

  • 最好的方法是使用將字串對映到函式的字典。這種技術的主要優點是字串不需要與函式名稱匹配。這也是用於模擬 case 構造的主要技術

    def a():
    pass

def b():
    pass

dispatch = {'go': a, 'stop': b}  # Note lack of parens for funcs

dispatch[get_input()]()  # Note trailing parens to call function

  • 使用內建函式 getattr()

    import foo
getattr(foo, 'bar')()

    請注意，getattr() 適用於任何物件，包括類、類例項、模組等。

    這在標準庫的幾個地方使用，像這樣

    class Foo:
    def do_foo(self):
        ...

    def do_bar(self):
        ...

f = getattr(foo_instance, 'do_' + opname)
f()

  • 使用 locals() 來解析函式名稱

    def myFunc():
    print("hello")

fname = "myFunc"

f = locals()[fname]
f()

有沒有類似於 Perl 的 chomp() 函式，用於從字串中刪除末尾換行符？

您可以使用 S.rstrip("\r\n") 從字串 S 的末尾刪除所有行結束符，而不會刪除其他尾隨空格。如果字串 S 表示多行，末尾有幾個空行，則所有空行的行結束符都將被刪除

>>> lines = ("line 1 \r\n"
...          "\r\n"
...          "\r\n")
>>> lines.rstrip("\n\r")
'line 1 '

由於通常只有在一次讀取一行文字時才需要這樣做，因此以這種方式使用 S.rstrip() 效果很好。

有沒有 scanf() 或 sscanf() 的等效項？

並非如此。

對於簡單的輸入解析，最簡單的方法通常是使用字串物件的 split() 方法將行拆分為以空格分隔的單詞，然後使用 int() 或 float() 將十進位制字串轉換為數值。split() 支援可選的“sep”引數，如果行使用空格以外的分隔符，則此引數很有用。

對於更復雜的輸入解析，正則表示式比 C 語言的 sscanf 更強大，也更適合這項任務。

What does UnicodeDecodeError or UnicodeEncodeError error mean?

請參閱 Unicode HOWTO。

我可以用奇數個反斜槓結束原始字串嗎？

以奇數個反斜槓結尾的原始字串將跳脫字元串的引號

>>> r'C:\this\will\not\work\'
  File "<stdin>", line 1
    r'C:\this\will\not\work\'
    ^
SyntaxError: unterminated string literal (detected at line 1)

有幾種解決方法。一種是使用普通字串並加倍反斜槓

>>> 'C:\\this\\will\\work\\'
'C:\\this\\will\\work\\'

另一種方法是將包含轉義反斜槓的普通字串連線到原始字串

>>> r'C:\this\will\work' '\\'
'C:\\this\\will\\work\\'

也可以使用 os.path.join() 在 Windows 上附加反斜槓

>>> os.path.join(r'C:\this\will\work', '')
'C:\\this\\will\\work\\'

請注意，雖然反斜槓會“轉義”引號以確定原始字串的結尾，但在解釋原始字串的值時不會發生任何轉義。也就是說，反斜槓仍然存在於原始字串的值中

>>> r'backslash\'preserved'
"backslash\\'preserved"

另請參閱 語言參考 中的規範。

效能

我的程式太慢了。如何加速它？

一般來說，這是一個難題。首先，在深入探討之前，請記住以下幾點

  • Python 實現的效能特徵各不相同。本 FAQ 側重於 CPython。

  • 行為可能因作業系統而異，尤其是在涉及 I/O 或多執行緒時。

  • 在嘗試最佳化任何程式碼之前，您應該始終找到程式中的熱點（請參閱 profile 模組）。

  • 編寫基準測試指令碼將使您在尋找改進時能夠快速迭代（請參閱 timeit 模組）。

  • 強烈建議在可能引入隱藏在複雜最佳化中的迴歸之前，擁有良好的程式碼覆蓋率（透過單元測試或任何其他技術）。

話雖如此，加速 Python 程式碼的方法有很多。以下是一些有助於達到可接受效能水平的通用原則

  • 使您的演算法更快（或更改為更快的演算法）可以帶來比嘗試在您的程式碼中散佈微最佳化技巧更大的好處。

  • 使用正確的資料結構。查閱 內建型別 和 collections 模組的文件。

  • 當標準庫提供一個執行某項操作的原語時，它可能（儘管不保證）比您可能想到的任何替代方案都快。對於用 C 編寫的原語，例如內建函式和一些擴充套件型別，這一點尤其正確。例如，請務必使用 list.sort() 內建方法或相關的 sorted() 函式進行排序（並參閱 排序技術 以獲取中等高階用法的示例）。

  • 抽象往往會建立間接性並迫使直譯器做更多的工作。如果間接性的級別超過了所做的有用工作量，您的程式就會變慢。您應該避免過度抽象，尤其是以微小函式或方法的形式（這通常也會損害可讀性）。

如果您已達到純 Python 所能提供的極限，則有一些工具可以幫助您走得更遠。例如，Cython 可以將略微修改的 Python 程式碼編譯成 C 擴充套件，並可在許多不同平臺上使用。Cython 可以利用編譯（和可選的型別註釋）使您的程式碼比解釋時顯著更快。如果您對自己的 C 程式設計技能有信心，您還可以自己編寫 C 擴充套件模組。

參見

專門討論效能技巧的維基頁面。

連線許多字串最有效的方法是什麼？

str 和 bytes 物件是不可變的，因此將許多字串連線在一起效率低下，因為每次連線都會建立一個新物件。在一般情況下，總執行時間成本是總字串長度的二次方。

要累積許多 str 物件，推薦的慣用法是將它們放入列表中，並在末尾呼叫 str.join()

chunks = []
for s in my_strings:
    chunks.append(s)
result = ''.join(chunks)

（另一種相當有效的慣用法是使用 io.StringIO）

要累積許多 bytes 物件，推薦的慣用法是使用原地連線（+= 運算子）擴充套件 bytearray 物件

result = bytearray()
for b in my_bytes_objects:
    result += b

序列（元組/列表）

如何在元組和列表之間進行轉換？

型別建構函式 tuple(seq) 將任何序列（實際上，任何可迭代物件）轉換為一個元組，其中包含相同項並按相同順序排列。

例如，tuple([1, 2, 3]) 產生 (1, 2, 3)，而 tuple('abc') 產生 ('a', 'b', 'c')。如果引數是一個元組，它不會建立副本，而是返回相同的物件，因此當您不確定物件是否已經是元組時，呼叫 tuple() 是廉價的。

型別建構函式 list(seq) 將任何序列或可迭代物件轉換為一個列表，其中包含相同項並按相同順序排列。例如，list((1, 2, 3)) 產生 [1, 2, 3]，而 list('abc') 產生 ['a', 'b', 'c']。如果引數是一個列表，它會像 seq[:] 一樣建立副本。

什麼是負索引？

Python 序列用正數和負數進行索引。對於正數，0 是第一個索引，1 是第二個索引，依此類推。對於負索引，-1 是最後一個索引，-2 是倒數第二個（倒數第二個）索引，依此類推。可以將 seq[-n] 視為與 seq[len(seq)-n] 相同。

使用負索引非常方便。例如，S[:-1] 是除最後一個字元外的所有字串，這對於從字串中刪除末尾的換行符很有用。

如何以相反的順序迭代序列？

使用內建函式 reversed()

for x in reversed(sequence):
    ...  # do something with x ...

這不會影響你的原始序列，但會建立一個新的副本，以反轉的順序進行迭代。

如何從列表中刪除重複項？

請參閱 Python Cookbook，其中有關於多種方法的詳細討論。

如果你不介意重新排序列表，可以先對其進行排序，然後從列表末尾掃描，刪除重複項。

if mylist:
    mylist.sort()
    last = mylist[-1]
    for i in range(len(mylist)-2, -1, -1):
        if last == mylist[i]:
            del mylist[i]
        else:
            last = mylist[i]

如果列表中的所有元素都可以用作集合鍵（即它們都是可雜湊的），這種方法通常更快。

mylist = list(set(mylist))

這會將列表轉換為集合，從而刪除重複項，然後再轉換回列表。

如何從列表中刪除多個專案？

與刪除重複項一樣，明確地以反向迭代並帶有刪除條件是一種可能性。然而，使用切片替換並帶有隱式或顯式正向迭代更容易且更快。這裡有三種變體。

mylist[:] = filter(keep_function, mylist)
mylist[:] = (x for x in mylist if keep_condition)
mylist[:] = [x for x in mylist if keep_condition]

列表推導式可能是最快的。

如何在 Python 中建立陣列？

使用列表。

["this", 1, "is", "an", "array"]

列表在時間複雜度上等同於 C 或 Pascal 陣列；主要區別在於 Python 列表可以包含許多不同型別的物件。

array 模組也提供了建立具有緊湊表示的固定型別陣列的方法，但它們的索引速度比列表慢。另請注意，NumPy 和其他第三方包也定義了具有各種特性的類陣列結構。

要獲得 Lisp 風格的連結串列，可以使用元組模擬 cons cell。

lisp_list = ("like",  ("this",  ("example", None) ) )

如果需要可變性，可以使用列表而不是元組。這裡 Lisp car 的類似物是 lisp_list[0]，而 cdr 的類似物是 lisp_list[1]。只有當你確定你真的需要這樣做時才這樣做，因為它通常比使用 Python 列表慢得多。

如何建立多維列表？

你可能嘗試過像這樣建立多維陣列：

>>> A = [[None] * 2] * 3

如果你列印它，它看起來是正確的：

>>> A
[[None, None], [None, None], [None, None]]

但是當你賦值時，它會出現在多個位置：

>>> A[0][0] = 5
>>> A
[[5, None], [5, None], [5, None]]

原因是使用 * 複製列表不會建立副本，它只會建立對現有物件的引用。*3 建立一個包含 3 個對同一長度為二的列表的引用的列表。對一行的更改將顯示在所有行中，這幾乎肯定不是你想要的。

建議的方法是首先建立所需長度的列表，然後用新建立的列表填充每個元素：

A = [None] * 3
for i in range(3):
    A[i] = [None] * 2

這會生成一個包含 3 個不同長度為二的列表的列表。你也可以使用列表推導式：

w, h = 2, 3
A = [[None] * w for i in range(h)]

或者，你可以使用提供矩陣資料型別的擴充套件；NumPy 是最著名的。

如何將方法或函式應用於物件序列？

要呼叫方法或函式並累積返回值到一個列表，列表推導式是一個優雅的解決方案：

result = [obj.method() for obj in mylist]

result = [function(obj) for obj in mylist]

如果只是執行方法或函式而不儲存返回值，一個普通的 for 迴圈就足夠了：

for obj in mylist:
    obj.method()

for obj in mylist:
    function(obj)

為什麼 a_tuple[i] += ['item'] 在加法有效時會引發異常？

這是因為複合賦值運算子是 賦值 運算子，以及 Python 中可變和不可變物件之間的差異。

此討論通常適用於將複合賦值運算子應用於指向可變物件的元組元素時，但我們將使用 list 和 += 作為示例。

如果你寫了：

>>> a_tuple = (1, 2)
>>> a_tuple[0] += 1
Traceback (most recent call last):
   ...
TypeError: 'tuple' object does not support item assignment

異常的原因應該立刻清楚：1 被新增到 a_tuple[0] 指向的物件（1），產生結果物件 2，但是當我們嘗試將計算結果 2 賦值給元組的元素 0 時，我們得到一個錯誤，因為我們不能改變元組元素指向的物件。

在底層，這個複合賦值語句做的事情大致是這樣的：

>>> result = a_tuple[0] + 1
>>> a_tuple[0] = result
Traceback (most recent call last):
  ...
TypeError: 'tuple' object does not support item assignment

是操作中的賦值部分產生了錯誤，因為元組是不可變的。

當你寫類似這樣的東西時：

>>> a_tuple = (['foo'], 'bar')
>>> a_tuple[0] += ['item']
Traceback (most recent call last):
  ...
TypeError: 'tuple' object does not support item assignment

這個異常有點令人驚訝，更令人驚訝的是，即使出現錯誤，append 操作也成功了：

>>> a_tuple[0]
['foo', 'item']

要了解為什麼會發生這種情況，你需要知道 (a) 如果一個物件實現了 __iadd__() 魔術方法，它會在執行 += 複合賦值時被呼叫，並且它的返回值被用於賦值語句；(b) 對於列表，__iadd__() 等價於在列表上呼叫 extend() 並返回列表。這就是為什麼我們說對於列表，+= 是 list.extend() 的“簡寫”。

>>> a_list = []
>>> a_list += [1]
>>> a_list
[1]

這等價於：

>>> result = a_list.__iadd__([1])
>>> a_list = result

a_list 指向的物件已被修改，並且指向修改後物件的指標被重新賦值回 a_list。賦值的最終結果是一個無操作，因為它是指向 a_list 之前指向的同一個物件的指標，但賦值仍然發生。

因此，在我們的元組示例中發生的事情等同於：

>>> result = a_tuple[0].__iadd__(['item'])
>>> a_tuple[0] = result
Traceback (most recent call last):
  ...
TypeError: 'tuple' object does not support item assignment

__iadd__() 成功，因此列表得到了擴充套件，但即使 result 指向與 a_tuple[0] 已經指向的同一物件，最終的賦值仍然導致錯誤，因為元組是不可變的。

我想進行復雜的排序：您可以在 Python 中進行 Schwartzian 轉換嗎？

這項技術由 Perl 社群的 Randal Schwartz 提出，透過一個度量標準對列表元素進行排序，該度量標準將每個元素對映到其“排序值”。在 Python 中，使用 list.sort() 方法的 key 引數。

Isorted = L[:]
Isorted.sort(key=lambda s: int(s[10:15]))

如何根據另一個列表中的值對一個列表進行排序？

將它們合併成一個元組的迭代器，對生成的列表進行排序，然後選擇你想要的元素。

>>> list1 = ["what", "I'm", "sorting", "by"]
>>> list2 = ["something", "else", "to", "sort"]
>>> pairs = zip(list1, list2)
>>> pairs = sorted(pairs)
>>> pairs
[("I'm", 'else'), ('by', 'sort'), ('sorting', 'to'), ('what', 'something')]
>>> result = [x[1] for x in pairs]
>>> result
['else', 'sort', 'to', 'something']

物件

什麼是類？

類是透過執行類語句建立的特定物件型別。類物件用作模板來建立例項物件，例項物件包含資料（屬性）和程式碼（方法），這些資料和程式碼特定於某種資料型別。

一個類可以基於一個或多個其他類，這些類被稱為其基類。然後，它繼承其基類的屬性和方法。這允許透過繼承逐步完善物件模型。你可能有一個通用的 Mailbox 類，它提供郵箱的基本訪問方法，以及 MboxMailbox、MaildirMailbox、OutlookMailbox 等子類，它們處理各種特定的郵箱格式。

什麼是方法？

方法是某個物件 x 上的一個函式，你通常將其呼叫為 x.name(arguments...)。方法在類定義內部定義為函式：

class C:
    def meth(self, arg):
        return arg * 2 + self.attribute

什麼是 self？

Self 只是方法第一個引數的常規名稱。定義為 meth(self, a, b, c) 的方法應該像 x.meth(a, b, c) 一樣被呼叫，其中 x 是定義該方法的類的某個例項；被呼叫的方法會認為它被呼叫為 meth(x, a, b, c)。

另請參閱為什麼在方法定義和呼叫中必須顯式使用'self'？。

如何檢查物件是否是給定類或其子類的例項？

使用內建函式 isinstance(obj, cls)。你可以透過提供一個元組而不是單個類來檢查物件是否是多個類中的任何一個的例項，例如 isinstance(obj, (class1, class2, ...))，也可以檢查物件是否是 Python 的內建型別之一，例如 isinstance(obj, str) 或 isinstance(obj, (int, float, complex))。

請注意 isinstance() 還會檢查來自抽象基類的虛擬繼承。因此，即使註冊類沒有直接或間接繼承它，測試也會返回 True。要測試“真實繼承”，請掃描類的方法解析順序：

from collections.abc import Mapping

class P:
     pass

class C(P):
    pass

Mapping.register(P)

>>> c = C()
>>> isinstance(c, C)        # direct
True
>>> isinstance(c, P)        # indirect
True
>>> isinstance(c, Mapping)  # virtual
True

# Actual inheritance chain
>>> type(c).__mro__
(<class 'C'>, <class 'P'>, <class 'object'>)

# Test for "true inheritance"
>>> Mapping in type(c).__mro__
False

請注意，大多數程式不經常在使用者定義的類上使用 isinstance()。如果你正在自己開發類，更合適的面向物件風格是在類上定義封裝特定行為的方法，而不是檢查物件的類並根據其類執行不同的操作。例如，如果你有一個執行某種操作的函式：

def search(obj):
    if isinstance(obj, Mailbox):
        ...  # code to search a mailbox
    elif isinstance(obj, Document):
        ...  # code to search a document
    elif ...

更好的方法是在所有類上定義一個 search() 方法並直接呼叫它：

class Mailbox:
    def search(self):
        ...  # code to search a mailbox

class Document:
    def search(self):
        ...  # code to search a document

obj.search()

什麼是委託？

委託是一種面嚮物件的技術（也稱為設計模式）。假設你有一個物件 x，並且想要改變其某個方法的行為。你可以建立一個新類，該類提供你想要改變的方法的新實現，並將所有其他方法委託給 x 的相應方法。

Python 程式設計師可以輕鬆實現委託。例如，以下類實現了一個行為類似於檔案但將所有寫入資料轉換為大寫的類：

class UpperOut:

    def __init__(self, outfile):
        self._outfile = outfile

    def write(self, s):
        self._outfile.write(s.upper())

    def __getattr__(self, name):
        return getattr(self._outfile, name)

這裡 UpperOut 類重新定義了 write() 方法，在呼叫底層 self._outfile.write() 方法之前，將引數字串轉換為大寫。所有其他方法都委託給底層 self._outfile 物件。委託是透過 __getattr__() 方法完成的；有關控制屬性訪問的更多資訊，請參閱語言參考。

請注意，對於更一般的情況，委託可能會變得更加棘手。當屬性必須設定和檢索時，該類還必須定義一個 __setattr__() 方法，並且必須小心操作。 __setattr__() 的基本實現大致等同於以下內容：

class X:
    ...
    def __setattr__(self, name, value):
        self.__dict__[name] = value
    ...

許多 __setattr__() 實現會呼叫 object.__setattr__() 來設定自身的屬性，而不會導致無限遞迴：

class X:
    def __setattr__(self, name, value):
        # Custom logic here...
        object.__setattr__(self, name, value)

或者，可以透過直接向 self.__dict__ 插入條目來設定屬性。

如何從擴充套件了基類的派生類中呼叫基類中定義的方法？

使用內建函式 super()：

class Derived(Base):
    def meth(self):
        super().meth()  # calls Base.meth

在這個例子中，super() 將自動確定呼叫它的例項（self 值），使用 type(self).__mro__ 查詢方法解析順序 (MRO)，並返回 MRO 中 Derived 之後的下一個類：Base。

如何組織我的程式碼，以便更容易更改基類？

你可以將基類分配給一個別名，然後從該別名派生。這樣你只需要更改分配給別名的值即可。順便說一句，如果你想動態地決定（例如，根據資源的可用性）使用哪個基類，這個技巧也很有用。示例：

class Base:
    ...

BaseAlias = Base

class Derived(BaseAlias):
    ...

如何建立靜態類資料和靜態類方法？

Python 支援靜態資料和靜態方法（C++ 或 Java 意義上的）。

對於靜態資料，只需定義一個類屬性。要為屬性分配新值，你必須在賦值中明確使用類名：

class C:
    count = 0   # number of times C.__init__ called

    def __init__(self):
        C.count = C.count + 1

    def getcount(self):
        return C.count  # or return self.count

對於任何滿足 isinstance(c, C) 的 c，c.count 也指向 C.count，除非 c 本身或從 c.__class__ 返回到 C 的基類搜尋路徑上的某個類重寫了它。

注意：在 C 的方法中，像 self.count = 42 這樣的賦值會在 self 自己的字典中建立一個新的、不相關的名為“count”的例項。類靜態資料名稱的重新繫結必須始終指定類，無論是否在方法內部：

C.count = 314

靜態方法是可能的：

class C:
    @staticmethod
    def static(arg1, arg2, arg3):
        # No 'self' parameter!
        ...

然而，實現靜態方法效果的一個更直接的方法是使用簡單的模組級函式：

def getcount():
    return C.count

如果你的程式碼結構是每個模組定義一個類（或緊密相關的類層次結構），這就能提供所需的封裝。

如何在 Python 中過載建構函式（或方法）？

這個答案實際上適用於所有方法，但這個問題通常首先出現在建構函式的上下文中。

在 C++ 中你會這樣寫：

class C {
    C() { cout << "No arguments\n"; }
    C(int i) { cout << "Argument is " << i << "\n"; }
}

在 Python 中，你必須編寫一個建構函式，使用預設引數處理所有情況。例如：

class C:
    def __init__(self, i=None):
        if i is None:
            print("No arguments")
        else:
            print("Argument is", i)

這不完全等價，但在實踐中足夠接近。

你也可以嘗試使用可變長度的引數列表，例如：

def __init__(self, *args):
    ...

同樣的方法適用於所有方法定義。

我嘗試使用 __spam，結果得到一個關於 _SomeClassName__spam 的錯誤。

帶有兩個前導下劃線的變數名會被“篡改”，以提供一種簡單但有效的方式來定義類私有變數。任何形式為 __spam 的識別符號（至少兩個前導下劃線，最多一個尾隨下劃線）在文字上會被替換為 _classname__spam，其中 classname 是當前類名，並去掉了任何前導下劃線。

識別符號可以在類內部不變地使用，但要在類外部訪問它，必須使用篡改後的名稱：

class A:
    def __one(self):
        return 1
    def two(self):
        return 2 * self.__one()

class B(A):
    def three(self):
        return 3 * self._A__one()

four = 4 * A()._A__one()

特別地，這並不能保證隱私，因為外部使用者仍然可以故意訪問私有屬性；許多 Python 程式設計師根本不屑於使用私有變數名。

參見

有關詳細資訊和特殊情況，請參閱私有名稱修飾規範。

我的類定義了 __del__，但是當我刪除物件時它沒有被呼叫。

這有幾個可能的原因。

del 語句不一定呼叫 __del__() – 它只是減少物件的引用計數，如果引用計數達到零，則呼叫 __del__()。

如果你的資料結構包含迴圈連結（例如，一棵樹，其中每個子節點都有一個父節點引用，每個父節點都有一個子節點列表），引用計數將永遠不會回到零。Python 會偶爾執行演算法來檢測此類迴圈，但是垃圾回收器可能在對你的資料結構的最後一個引用消失後一段時間才執行，所以你的 __del__() 方法可能會在一個不方便和隨機的時間被呼叫。如果你試圖重現一個問題，這很不方便。更糟糕的是，物件 __del__() 方法的執行順序是任意的。你可以執行 gc.collect() 來強制進行回收，但確實存在一些極端情況，物件永遠不會被回收。

儘管有迴圈收集器，但仍然建議在物件上定義一個顯式的 close() 方法，當不再需要這些物件時呼叫它。close() 方法可以移除引用子物件的屬性。不要直接呼叫 __del__() —— __del__() 應該呼叫 close()，並且 close() 應該確保可以為同一個物件多次呼叫。

另一種避免迴圈引用的方法是使用 weakref 模組，它允許你指向物件而不增加它們的引用計數。例如，樹資料結構應該為其父引用和兄弟引用（如果需要）使用弱引用。

最後，如果你的 __del__() 方法引發異常，警告訊息將列印到 sys.stderr。

如何獲取給定類的所有例項的列表？

Python 不會跟蹤一個類（或內建型別）的所有例項。你可以程式設計類的建構函式來透過維護每個例項的弱引用列表來跟蹤所有例項。

為什麼 id() 的結果似乎不是唯一的？

內建函式 id() 返回一個整數，該整數在物件的生命週期內保證是唯一的。由於在 CPython 中，這是物件的記憶體地址，因此經常發生在一個物件從記憶體中刪除後，下一個新建立的物件被分配到記憶體中的相同位置。這個例子說明了這一點：

>>> id(1000)
13901272
>>> id(2000)
13901272

這兩個 ID 屬於不同的整數物件，它們在 id() 呼叫執行之前建立，並在執行之後立即刪除。為了確保你想要檢查 ID 的物件仍然存活，請建立對該物件的另一個引用：

>>> a = 1000; b = 2000
>>> id(a)
13901272
>>> id(b)
13891296

何時可以依賴於 is 運算子的身份測試？

is 運算子測試物件身份。a is b 等價於 id(a) == id(b)。

身份測試最重要的特性是物件總是與自身相同，a is a 總是返回 True。身份測試通常比相等測試快。並且與相等測試不同，身份測試保證返回布林值 True 或 False。

然而，只有在物件身份得到保證時，身份測試才能替代相等測試。通常，有三種情況保證身份：

  1. 賦值建立新名稱，但不會改變物件身份。在賦值 new = old 之後，保證 new is old。

  2. 將物件放入儲存物件引用的容器中不會改變物件身份。在列表賦值 s[0] = x 之後，保證 s[0] is x。

  3. 如果一個物件是單例，這意味著該物件只能存在一個例項。在賦值 a = None 和 b = None 之後，保證 a is b，因為 None 是一個單例。

在大多數其他情況下，不建議進行身份測試，而首選相等測試。特別是，不應使用身份測試來檢查像 int 和 str 這樣的常量，它們不保證是單例的：

>>> a = 1000
>>> b = 500
>>> c = b + 500
>>> a is c
False

>>> a = 'Python'
>>> b = 'Py'
>>> c = b + 'thon'
>>> a is c
False

同樣，可變容器的新例項永遠不會相同：

>>> a = []
>>> b = []
>>> a is b
False

在標準庫程式碼中，你會看到幾種正確使用身份測試的常見模式：

  1. 正如 PEP 8 所建議的，身份測試是檢查 None 的首選方式。這在程式碼中讀起來就像純英語，並避免了與其他可能具有布林值但評估為假的物件混淆。

  2. 當 None 是有效輸入值時，檢測可選引數可能很棘手。在這種情況下，你可以建立一個單例哨兵物件，保證與其他物件不同。例如，這裡是如何實現一個行為類似於 dict.pop() 的方法：

    _sentinel = object()

def pop(self, key, default=_sentinel):
    if key in self:
        value = self[key]
        del self[key]
        return value
    if default is _sentinel:
        raise KeyError(key)
    return default

  3. 容器實現有時需要使用身份測試來增強相等測試。這可以防止程式碼被諸如 float('NaN') 之類的物件混淆，這些物件不等於自身。

例如，以下是 collections.abc.Sequence.__contains__() 的實現：

def __contains__(self, value):
    for v in self:
        if v is value or v == value:
            return True
    return False

子類如何控制不可變例項中儲存的資料？

當繼承不可變型別時，請重寫 __new__() 方法而不是 __init__() 方法。後者僅在例項建立 之後 執行，這對於更改不可變例項中的資料來說太晚了。

所有這些不可變類的簽名都與其父類不同：

from datetime import date

class FirstOfMonthDate(date):
    "Always choose the first day of the month"
    def __new__(cls, year, month, day):
        return super().__new__(cls, year, month, 1)

class NamedInt(int):
    "Allow text names for some numbers"
    xlat = {'zero': 0, 'one': 1, 'ten': 10}
    def __new__(cls, value):
        value = cls.xlat.get(value, value)
        return super().__new__(cls, value)

class TitleStr(str):
    "Convert str to name suitable for a URL path"
    def __new__(cls, s):
        s = s.lower().replace(' ', '-')
        s = ''.join([c for c in s if c.isalnum() or c == '-'])
        return super().__new__(cls, s)

這些類的使用方式如下：

>>> FirstOfMonthDate(2012, 2, 14)
FirstOfMonthDate(2012, 2, 1)
>>> NamedInt('ten')
10
>>> NamedInt(20)
20
>>> TitleStr('Blog: Why Python Rocks')
'blog-why-python-rocks'

如何快取方法呼叫？

快取方法的兩個主要工具是 functools.cached_property() 和 functools.lru_cache()。前者在例項級別儲存結果，後者在類級別儲存結果。

_cached_property_ 方法只適用於不帶任何引數的方法。它不會建立對例項的引用。快取的方法結果只會在例項存活期間保留。

優點是當一個例項不再使用時，快取的方法結果會立即釋放。缺點是如果例項累積，累積的方法結果也會隨之增加。它們可以無限增長。

_lru_cache_ 方法適用於具有可雜湊引數的方法。除非特別注意傳遞弱引用，否則它會建立對例項的引用。

最近最少使用演算法的優點是快取受指定的 maxsize 限制。缺點是例項會一直存活，直到它們從快取中老化或快取被清除。

這個例子展示了各種技術：

class Weather:
    "Lookup weather information on a government website"

    def __init__(self, station_id):
        self._station_id = station_id
        # The _station_id is private and immutable

    def current_temperature(self):
        "Latest hourly observation"
        # Do not cache this because old results
        # can be out of date.

    @cached_property
    def location(self):
        "Return the longitude/latitude coordinates of the station"
        # Result only depends on the station_id

    @lru_cache(maxsize=20)
    def historic_rainfall(self, date, units='mm'):
        "Rainfall on a given date"
        # Depends on the station_id, date, and units.

上述示例假設 station_id 永不改變。如果相關的例項屬性是可變的，則 cached_property 方法將無法工作，因為它無法檢測到屬性的更改。

為了在 station_id 可變時使 lru_cache 方法工作，類需要定義 __eq__() 和 __hash__() 方法，以便快取可以檢測到相關的屬性更新：

class Weather:
    "Example with a mutable station identifier"

    def __init__(self, station_id):
        self.station_id = station_id

    def change_station(self, station_id):
        self.station_id = station_id

    def __eq__(self, other):
        return self.station_id == other.station_id

    def __hash__(self):
        return hash(self.station_id)

    @lru_cache(maxsize=20)
    def historic_rainfall(self, date, units='cm'):
        'Rainfall on a given date'
        # Depends on the station_id, date, and units.

模組

如何建立 .pyc 檔案？

當模組首次匯入時（或自當前編譯檔案建立以來原始檔已更改時），包含編譯程式碼的 .pyc 檔案應在包含 .py 檔案的目錄的 __pycache__ 子目錄中建立。.pyc 檔案的檔名將以與 .py 檔案相同的名稱開頭，並以 .pyc 結尾，中間部分取決於建立它的特定 python 二進位制檔案。（有關詳細資訊，請參閱 PEP 3147。）

一個可能導致不建立 .pyc 檔案 的原因是原始檔所在目錄的許可權問題，這意味著無法建立 __pycache__ 子目錄。例如，如果你以一個使用者開發，但以另一個使用者執行（比如你正在使用 Web 伺服器進行測試），就可能發生這種情況。

除非設定了PYTHONDONTWRITEBYTECODE 環境變數，否則如果你匯入模組且 Python 能夠（許可權、可用空間等）建立 __pycache__ 子目錄並將編譯後的模組寫入該子目錄，則會自動建立 .pyc 檔案。

在頂層指令碼上執行 Python 不被視為匯入，也不會建立 .pyc 檔案。例如，如果你有一個頂層模組 foo.py 匯入了另一個模組 xyz.py，當你執行 foo 時（透過在 shell 命令中輸入 python foo.py），會為 xyz 建立一個 .pyc 檔案，因為 xyz 被匯入了，但不會為 foo 建立 .pyc 檔案，因為 foo.py 沒有被匯入。

如果你需要為 foo 建立一個 .pyc 檔案——也就是說，為一個未被匯入的模組建立一個 .pyc 檔案——你可以使用 py_compile 和 compileall 模組來完成。

py_compile 模組可以手動編譯任何模組。一種方法是在該模組中互動式地使用 compile() 函式：

>>> import py_compile
>>> py_compile.compile('foo.py')

這會將 .pyc 檔案寫入到與 foo.py 相同位置的 __pycache__ 子目錄中（或者你可以使用可選引數 cfile 覆蓋此設定）。

你還可以使用 compileall 模組自動編譯一個或多個目錄中的所有檔案。你可以透過在 shell 提示符下執行 compileall.py 並提供包含要編譯的 Python 檔案的目錄路徑來完成此操作：

python -m compileall .

如何找到當前模組的名稱？

模組可以透過檢視預定義的全域性變數 __name__ 來找到它自己的模組名稱。如果它的值是 '__main__'，則程式正在作為指令碼執行。許多通常透過匯入使用的模組也提供命令列介面或自測試，並且只有在檢查 __name__ 後才執行此程式碼：

def main():
    print('Running test...')
    ...

if __name__ == '__main__':
    main()

如何讓模組互相匯入？

假設你有以下模組：

foo.py:

from bar import bar_var
foo_var = 1

bar.py:

from foo import foo_var
bar_var = 2

問題在於直譯器將執行以下步驟：

  • main 匯入 foo

  • 為 foo 建立空的全域性變數

  • foo 被編譯並開始執行

  • foo 匯入 bar

  • 為 bar 建立空的全域性變數

  • bar 被編譯並開始執行

  • bar 匯入 foo（這是一個無操作，因為已經存在一個名為 foo 的模組）

  • 匯入機制嘗試從 foo 全域性變數中讀取 foo_var，以設定 bar.foo_var = foo.foo_var

最後一步失敗，因為 Python 尚未完成對 foo 的解釋，並且 foo 的全域性符號字典仍然為空。

當你使用 import foo，然後在全域性程式碼中嘗試訪問 foo.foo_var 時，也會發生同樣的事情。

這個問題至少有三種可能的解決方案。

Guido van Rossum 建議避免所有使用 from <module> import ... 的情況，並將所有程式碼放在函式內部。全域性變數和類變數的初始化應僅使用常量或內建函式。這意味著所有從匯入模組來的內容都以 <module>.<name> 的形式引用。

Jim Roskind 建議在每個模組中按以下順序執行步驟：

  • 匯出（不需要匯入基類的全域性變數、函式和類）

  • import 語句

  • 活動程式碼（包括從匯入值初始化的全域性變數）。

Van Rossum 不太喜歡這種方法，因為 import 語句出現在一個奇怪的地方，但它確實有效。

Matthias Urlichs 建議重構你的程式碼，以便遞迴匯入根本不必要。

這些解決方案並非互斥。

__import__('x.y.z') 返回 ；如何獲取 z？

考慮使用來自 importlib 的便捷函式 import_module()：

z = importlib.import_module('x.y.z')

當我編輯匯入的模組並重新匯入時，更改沒有顯示。為什麼會發生這種情況？

出於效率和一致性的原因，Python 只在模組第一次匯入時讀取模組檔案。如果不是這樣，在一個由許多模組組成，並且每個模組都匯入相同基本模組的程式中，基本模組將被多次解析和重新解析。要強制重新讀取已更改的模組，請執行以下操作：

import importlib
import modname
importlib.reload(modname)

警告：這種技術並非百分之百萬無一失。特別是，包含以下語句的模組：

from modname import some_objects

將繼續使用匯入物件的舊版本。如果模組包含類定義，現有類例項將 不會 更新為使用新的類定義。這可能導致以下矛盾行為：

>>> import importlib
>>> import cls
>>> c = cls.C()                # Create an instance of C
>>> importlib.reload(cls)
<module 'cls' from 'cls.py'>
>>> isinstance(c, cls.C)       # isinstance is false?!?
False

如果你打印出類物件的“身份”，問題的本質就會變得清晰：

>>> hex(id(c.__class__))
'0x7352a0'
>>> hex(id(cls.C))
'0x4198d0'