# 程式開發常見問答集

## 常見問題

### 是否有具有中斷點和單步執行功能的原始碼級偵錯器？

有的。

下面描述了幾個 Python 偵錯器，內建函式 `breakpoint()` 允許你進入其中任何一個。

pdb 模組是一個簡單但足夠的 Python 控制台模式偵錯器。它是標準 Python 函式庫的一部分，並`記錄在函式庫參考手冊`中。你也可以參考 pdb 的程式碼作為範例來編寫自己的偵錯器。

IDLE 互動式開發環境，它是標準 Python 發行版的一部分（通常作為 `idlelib` 提供），包括一個圖形偵錯器。

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

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

trepan3k 是一個類似 gdb 的偵錯器。

Visual Studio Code 是一個整合了版本控制軟體與偵錯工具的 IDE。

有數個商業化 Python IDE 包含圖形偵錯器。這些包含：

- Wing IDE

- PyCharm

### 有沒有工具能夠幫忙找 bug 或執行靜態分析？

有的。

Ruff、Pylint 和 Pyflakes 進行基本檢查以幫助你儘早抓出錯誤。

靜態型別檢查器，例如 mypy、ty、Pyrefly 和 pytype 可以檢查 Python 原始碼中的型別提示。

### 如何從 Python 腳本建立獨立的二進位檔案？

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

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

它的工作原理是遞迴地掃描你的原始碼以查找引入陳述式（兩種形式）並在標準 Python 路徑和原始碼目錄（對於內建模組）中查找模組。然後它將用 Python 編寫的模組的位元組碼轉換為 C 程式碼（陣列初始化器可以使用 marshal 模組轉換為程式碼物件）並建立一個自訂的組態檔案，該檔案僅包含那些在程式中實際使用的內建模組。然後它編譯產生的 C 程式碼並將其與 Python 直譯器的其餘部分連結以形成一個獨立的二進位檔案，其行為與你的腳本完全一樣。

以下套件可以幫助建立 console 和 GUI 可執行檔案：

- Nuitka（跨平台）

- PyInstaller（跨平台）

- PyOxidizer（跨平台）

- cx_Freeze（跨平台）

- py2app（僅限 macOS）

- py2exe（僅限 Windows）

### 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: cannot access local variable 'x' where it is not associated with a value

這是因為當你在某個作用域中對變數進行賦值時，該變數會成為該作用域的區域變數，並遮蔽外部作用域中任何同名的變數。由於 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)

這會提供一個包含五個計算 `x**2` 的 lambda 串列。你可能會預期在呼叫它時，它們會分別回傳 `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 並在定義 lambda 時計算，因此它具有與 `x` 在迴圈中該點相同的值。這意味著 `n` 的值在第一個 lambda 中為 `0`，在第二個中為 `1`，在第三個中為 `2`，依此類推。因此每個 lambda 現在將回傳正確的結果：

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

請注意，此行為並非 lambda 所特有，也適用於常規函式。

### 如何跨模組共享全域變數？

在單一程式中跨模組共享資訊的標準方法是建立一個特殊模組（通常稱為 config 或 cfg）。只需在應用程式的所有模組中引入該設定模組；然後該模組就可作為全域名稱使用。因為每個模組只有一個實例，所以對模組物件所做的任何變更都會反映到各處。例如：

config.py：

    x = 0   # 'x' 配置設定的預設值

mod.py：

    import config
    config.x = 1

main.py：

    import config
    import mod
    print(config.x)

請注意，出於同樣的原因，使用模組也是實作單例設計模式的基礎。

### 在模組中使用 import 的「最佳做法」有哪些？

一般來說，不要使用 `from modulename import *`。這樣做會使引入者的命名空間變得混亂，並使 linter 更難以檢測未定義的名稱。

在檔案頂部引入模組。這樣做可以清楚地知道你的程式碼需要哪些其他模組，並避免模組名稱是否在作用域內的問題。每行使用一個引入可以輕鬆新增和刪除模組引入，但每行使用多個引入會佔用較少的螢幕空間。

按以下順序引入模組是一個良好的做法：

1. 標準函式庫模組 —— 例如 `sys`、`os`、`argparse`、`re`

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

3. 本地開發的模組

有時需要將引入移動到函式或類別中，以避免循環引入的問題。Gordon McMillan 說：

> 在兩個模組都使用 "import <module>" 引入形式的情況下，循環引入是沒問題的。當第二個模組想要從第一個模組中取得一個名稱（"from module import name"）並且引入位於頂層時，它們會失敗。那是因為第一個模組中的名稱尚不可用，因為第一個模組正忙於引入第二個模組。

在這種情況下，如果第二個模組只在一個函式中使用，那麼引入可以很容易地移到那個函式中。當引入被呼叫時，第一個模組將已經完成初始化，第二個模組就可以進行它的引入。

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

只有在需要解決避免循環引入等問題，或試圖減少模組的初始化時間時，才將引入移動到區域範圍內，例如在函式定義內。如果根據程式的執行方式，許多引入是不必要的，則此技術特別有用。如果模組僅在該函式中使用，你可能也會想將引入移到該函式中。請注意，由於模組的一次性初始化，第一次載入模組的代價可能很高，但多次載入模組實際上是免費的，只需幾次字典查找。即使模組名稱已超出範圍，該模組也可能在 `sys.modules` 中可用。

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

這種類型的錯誤通常會困擾新手程式設計師。像是這個函式：

    def foo(mydict={}):  # 危險：所有呼叫共享對字典的參照
        ... 計算一些東西 ...
        mydict[key] = value
        return mydict

第一次呼叫此函式時， `mydict` 包含一個項目。第二次後 `mydict` 包含兩個項目，因為當 `foo()` 開始執行時，`mydict` 以其中已有的項目開始。

人們通常預期函式呼叫會為預設值建立新物件。但事實並非如此。預設值只會在函式被定義時建立一次。如果該物件被更改，如本例中的字典，則對該函式的後續呼叫將參照到該已更改的物件。

根據定義，數字、字串、tuple 和 `None` 等不可變物件不會被更改。對字典、list 和類別實例等可變物件的更改可能會導致混淆。

由於這個特性，不使用可變物件作為預設值是一個很好的程式設計習慣，而是應使用 `None` 作為預設值，並在函式內部檢查參數是否為 `None`，再建立一個新的串列/字典/或其他東西。例如，不要這樣寫：

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

而是寫成：

    def foo(mydict=None):
        if mydict is None:
            mydict = {}  # 為區域命名空間建立一個新字典

此功能可能很有用。當你有一個計算起來很耗時的函式時，一種常用的技術是快取參數和每次呼叫該函式的結果值，並在再次請求相同的值時回傳快取的值。這稱為「記憶化 (memoizing)」，可以像這樣實作：

    # 呼叫者只能提供兩個參數，並選擇性地透過關鍵字傳遞 _cache
    def expensive(arg1, arg2, *, _cache={}):
        if (arg1, arg2) in _cache:
            return _cache[(arg1, arg2)]

        # Calculate the value
        result = ... expensive computation ...
        _cache[(arg1, arg2)] = result           # 將結果儲存在快取中
        return result

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

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

在函式的參數列表中使用 `*` 和 `**` 指定符來收集引數；這會將位置引數作為 tuple 提供給你，並將關鍵字引數作為字典提供。然後你可以在使用 `*` 和 `**` 呼叫另一個函式時傳遞這些引數：

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

### 引數 (arguments) 和參數 (parameters) 有什麼區別？

參數由出現在函式定義中的名稱定義，而引數是呼叫函式時實際傳遞給函式的值。參數定義函式可以接受的引數種類。例如，給定以下函式定義：

    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` 不會建立 list 的副本——它會建立一個新變數 `y`，參照到 `x` 所參照的同一物件。這意味著只有一個物件（list），並且 `x` 和 `y` 都參照它。

2. list 是 mutable，這意味著你可以變更它們的內容。

在呼叫 `append()` 之後，可變物件的內容從 `[]` 變成了 `[10]`。由於這兩個變數都參照同一個物件，因此使用任一名稱都可以存取修改後的值 `[10]`。

如果我們改為賦予一個不可變物件給 `x`：

    >>> x = 5  # 整數為不可變的
    >>> y = x
    >>> x = x + 1  # 5 不可變，在這邊會建立一個新物件
    >>> x
    6
    >>> y
    5

我們可以看到，在這種情況下 `x` 和 `y` 不再相等。這是因為整數是 immutable，當我們執行 `x = x + 1` 時，我們並沒有透過增加 int `5` 的值來改變它；相反地，我們建立了一個新物件（int `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`，這可能會導致你的程式產生一個容易診斷的錯誤。

但是，有一類操作中，相同的操作有時對不同型別有不同的行為：擴增賦值運算子。例如，`+=` 會改變 list 但不會改變 tuple 或 int（`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()`。

### 如何編寫帶有輸出參數的函式（透過傳參照呼叫 (call by reference)）？

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

1. 透過回傳結果的 tuple：

       >>> def func1(a, b):
       ...     a = 'new-value'        # a 和 b 為區域名稱
       ...     b = b + 1              # 賦值到新物件
       ...     return a, b            # 回傳新值
       ...
       >>> x, y = 'old-value', 99
       >>> func1(x, y)
       ('new-value', 100)

   這幾乎都會是最清楚的方案。

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

3. 透過傳遞一個可變的（可於原地 (in-place) 改變的）物件：

       >>> def func2(a):
       ...     a[0] = 'new-value'     # 'a' 參照一個可變的串列
       ...     a[1] = a[1] + 1        # 改變共享的物件
       ...
       >>> args = ['old-value', 99]
       >>> func2(args)
       >>> args
       ['new-value', 100]

4. 透過傳入一個發生改變的字典：

       >>> def func3(args):
       ...     args['a'] = 'new-value'     # args 是可變字典
       ...     args['b'] = args['b'] + 1   # 原地改變它
       ...
       >>> 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 是可變命名空間
       ...     args.b = args.b + 1         # 原地改變物件
       ...
       >>> args = Namespace(a='old-value', b=99)
       >>> func4(args)
       >>> vars(args)
       {'a': 'new-value', 'b': 100}

   幾乎不會有要讓事情變得如此複雜的充分理由。

你最好的選擇是回傳一個包含多個結果的 tuple。

### 你如何在 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()

序列可以透過切片 (slicing) 複製：

    new_l = l[:]

### 如何找到物件的方法或屬性？

對於使用者定義類別的實例 `x`，`dir(x)` 回傳一個按字母順序排列的名稱 list，其中包含實例屬性，以及其類別定義的方法和屬性。

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

一般來說，它無法做到，因為物件並沒有真正的名稱。本質上，賦值總是將名稱綁定到值；`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"

而不是：

    "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` 是一個等著出問題的錯誤。

### 如何存取 int 字面值屬性而不會得到 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-string（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()` 等效的方法，能用於從字串中移除尾端的換行符號？

You can use `S.rstrip("\r\n")` to remove all occurrences of any line terminator from the end of the string `S` without removing other trailing whitespace. If the string `S` represents more than one line, with several empty lines at the end, the line terminators for all the blank lines will be removed:

    >>> 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` 更強大，也更適合這項任務。

### `UnicodeDecodeError` 或 `UnicodeEncodeError` 錯誤是什麼意思？

請參閱 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 擴充模組。

也參考

有個 wiki 頁面專門介紹效能改進小提示。

### 將多個字串連接在一起最有效率的方法是什麼？

`str` 和 `bytes` 物件是不可變的，因此將多個字串連接在一起的效率很低，因為每次連接都會建立一個新物件。在一般情況下，總 runtime 成本與總字串長度呈二次方關係。

要累積許多 `str` 物件，推薦的慣用做法是將它們放入 list 中並在最後呼叫 `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 以得到有關執行此操作的各種方法的詳細討論：

> https://code.activestate.com/recipes/52560/

如果你不介意重新排序串列，可以對其進行排序，然後從串列末尾開始掃描，同時刪除重複項：

    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]

如果串列的所有元素都可以做為集合的鍵（即它們都是 hashable），那這通常會更快：

    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` 模組還提供了建立具有緊湊表示的固定型別陣列的方法，但它們的索引速度比 list 慢。另請注意，NumPy 和其他第三方套件也定義了具有各種特徵的類陣列結構。

要取得 Lisp 風格的鏈結串列，你可以使用元組模擬 cons cells：

    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 個對長度為 2 的相同串列的參照。對其中一列的變更也將顯示在所有其他列中，而這幾乎不會是你想要的。

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

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

這會產生一個包含 3 個長度為 2 的不同串列的串列。你也可以使用串列綜合運算：

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

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

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

要呼叫一個方法或函式並將回傳值累積到一個 list 中，一個 list comprehension 是一個優雅的解決方案：

    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 中可變物件和不可變物件之間的差異。

當增強賦值運算子應用於指向可變物件的 tuple 元素時，此討論普遍適用，但我們將使用 `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` 賦值給 tuple 的元素 `0` 時，我們會得到一個錯誤，因為我們無法更改 tuple 元素所指向的內容。

這個增強賦值陳述式在背後大致是做這些事情：

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

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

當你寫這樣的東西時：

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

這個例外更令人驚訝，而更令人驚訝的是，即使出現了錯誤，追加仍然有效：

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

要了解為什麼會發生這種情況，你需要知道 (a) 如果一個物件實作了 `__iadd__()` 魔術方法，它會在執行 `+=` 增強賦值時被呼叫，並且它的回傳值會被用在賦值陳述式中；(b) 對於 list，`__iadd__()` 相當於在 list 上呼叫 `extend()` 並回傳該 list。這就是為什麼我們說對於 list，`+=` 是 `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__()` 成功了，因此 list 被擴充，但即使 `result` 指向與 `a_tuple[0]` 已經指向的同一個物件，最終的賦值仍然會導致錯誤，因為 tuple 是不可變的。

### 我想做一個複雜的排序：你能用 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']

## 物件

### 什麼是類別 (class)？

類別是透過執行 class 陳述式所建立的特定物件型別。類別物件被用作建立實例物件的模板，實例物件包含了特定於某個資料型別的資料（屬性）和程式碼（方法）。

一個類別可以基於一個或多個其他類別，稱為它的基底類別。然後它會繼承其基底類別的屬性和方法。這使得物件模型可以透過繼承逐步細化。你可能會有一個通用的 `Mailbox` 類別，它為郵箱提供基本的存取器方法，以及處理各種特定郵箱格式的子類別，例如 `MboxMailbox`、`MaildirMailbox`、`OutlookMailbox`。

### 什麼是方法 (method)？

方法是某個物件 `x` 上的函式，你通常以 `x.name(arguments...)` 來呼叫它。方法在類別定義中被定義為函式：

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

### 什麼是 self？

Self 只是方法第一個引數的約定名稱。對於所定義類別的某個實例 `x`，一個定義為 `meth(self, a, b, c)` 的方法應該以 `x.meth(a, b, c)` 形式來呼叫；被呼叫的方法會認為它是以 `meth(x, a, b, c)` 來呼叫的。

另請參閱 為何「self」在方法 (method) 定義和呼叫時一定要明確使用？。

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

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

請注意，`isinstance()` 還會檢查來自抽象基底類別 (abstract base class) 的虛擬繼承。因此對已註冊類別的檢驗會回傳 `True`，即使沒有直接或間接繼承自它。要測試「真正繼承」，請掃描該類別的方法解析順序 (MRO)：

    from collections.abc import Mapping

    class P:
         pass

    class C(P):
        pass

    Mapping.register(P)

    >>> c = C()
    >>> isinstance(c, C)        # 直接
    True
    >>> isinstance(c, P)        # 間接
    True
    >>> isinstance(c, Mapping)  # 虛擬
    True

    # 實際的繼承鏈結
    >>> type(c).__mro__
    (<class 'C'>, <class 'P'>, <class 'object'>)

    # 「真正繼承」的檢驗
    >>> Mapping in type(c).__mro__
    False

請注意，大多數程式不會經常對使用者定義的類別使用 `isinstance()`。如果你自己在開發類別，更恰當的物件導向風格是在類別上定義封裝特定行為的方法，而不是檢查物件的類別並根據它是什麼類別來做不同的事情。例如，如果你有一個函式做某事：

    def search(obj):
        if isinstance(obj, Mailbox):
            ...  # 搜尋信箱的程式碼
        elif isinstance(obj, Document):
            ...  # 搜尋文件的程式碼
        elif ...

更好的方法是在所有類別上定義一個 `search()` 方法然後呼叫它：

    class Mailbox:
        def search(self):
            ...  # 搜尋信箱的程式碼

    class Document:
        def search(self):
            ...  # 搜尋文件的程式碼

    obj.search()

### 什麼是委派 (delegation)？

委派是一種物件導向的技法（也稱為設計模式）。假設你有一個物件 `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__()` 以設定 self 的屬性，而不會導致無限遞迴：

    class X:
        def __setattr__(self, name, value):
            # 自訂邏輯放在這裡...
            object.__setattr__(self, name, value)

Alternatively, it is possible to set attributes by inserting entries into `self.__dict__` directly.

### 如何從擴充基底類別的衍生類別中呼叫基底類別中定義的方法？

使用內建的 `super()` 函式：

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

In the example, `super()` will automatically determine the instance from which it was called (the `self` value), look up the method resolution order (MRO) with `type(self).__mro__`, and return the next in line after `Derived` in the MRO: `Base`.

### 我可以如何組織我的程式碼以使得更改基底類別變得更容易？

你可以將基底類別分配給別名並從別名衍生。然後，你只需更改分配給別名的值。順便說一句，如果你想動態決定（例如，取決於資源的可用性）使用哪個基底類別，這個技巧也很方便。範例：

    class Base:
        ...

    BaseAlias = Base

    class Derived(BaseAlias):
        ...

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

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

對於靜態資料，只需定義一個類別屬性即可。要為屬性分配新值，你必須在分配中顯式使用類別名稱：

    class C:
        count = 0   # C.__init__ 被呼叫的次數

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

        def getcount(self):
            return C.count  # 或回傳 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):
            # 沒有 'self' 參數！
            ...

然而，獲得靜態方法效果的一種更直接的方法是透過一個簡單的模組層級函式：

    def getcount():
        return C.count

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

### 如何在 Python 中多載 (overload) 建構函式（或方法）？

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

在 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 的錯誤。

帶有雙前導底線的變數名會被「破壞 (mangled)」作為定義類別私有變數的一種簡單但有效的方法。`__spam` 形式的任何識別字（至少兩個前導底線，最多一個尾隨底線）在文字上會被替換為 `_classname__spam`，其中 `classname` 是目前類別之所有前導底線被去除的名稱。

The identifier can be used unchanged within the class, but to access it outside the class, the mangled name must be used:

    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 程式設計師根本懶得使用私有變數名稱。

也參考

The private name mangling specifications for details and special cases.

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

這有幾個可能的原因。

`del` 陳述式不一定會呼叫 `__del__()` -- 它只是減少物件的參照計數，如果達到零則呼叫 `__del__()`。

如果你的資料結構包含循環連結（例如，一棵樹，其中每個子項都有一個父項參照，每個父項都有一個子項 list），參照計數將永遠不會回到零。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. 將物件放入儲存物件參照的容器中不會改變物件識別性。在 list 賦值 `s[0] = x` 之後，保證 `s[0] is x`。

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

在大多數其他情況下，識別性測試是不可取的，相等性測試是首選。特別是，識別性測試不應用於檢查常數，例如不能保證是單例的 `int` 和 `str`：

    >>> a = 10_000_000
    >>> b = 5_000_000
    >>> c = b + 5_000_000
    >>> 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` 的首選方法。這在程式碼中讀起來像簡單的英語，並避免與其他可能具有評估為 false 的布林值的物件混淆。

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

       _sentinel = sentinel('_sentinel')

       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__()` 方法。後者僅在實例建立之後才運行，此時要更改不可變實例中的資料已經太遲了。

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

    import datetime as dt

    class FirstOfMonthDate(dt.date):
        "總是選擇每個月的第一天"
        def __new__(cls, year, month, day):
            return super().__new__(cls, year, month, 1)

    class NamedInt(int):
        "允許一些數字的文字名稱"
        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):
        "將 str 轉換成適合作為 URL 路徑的名稱"
        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` 方法適用於具有可雜湊引數的方法。除非特別努力傳遞弱參照，否則它會建立對實例的參照。

最近最少使用 (least recently used) 演算法的優點是快取受指定的 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 檔案？

第一次引入模組時（或原始碼檔案在目前編譯檔案建立後發生更改時），應在包含 `.py` 檔案的目錄之 `__pycache__` 子目錄中建立包含編譯程式碼的 `.pyc` 檔案。`.pyc` 檔案的檔案名稱以與 `.py` 檔案相同的名稱開頭，以 `.pyc` 結尾，中間部分取決於建立它的特定 `python` 二進位檔案。（詳情請參閱 PEP 3147。）

`.pyc` 檔案可能無法建立的原因之一是包含原始碼檔案的目錄存在權限問題，這意味著無法建立 `__pycache__` 子目錄。例如，如果你以一個使用者的身份開發但以另一個使用者的身份運行，例如你正在使用網頁伺服器進行測試，就會發生這種情況。

除非 `PYTHONDONTWRITEBYTECODE` 環境變數有被設定，如果你正在引入一個模組並且 Python 有能力（權限、空閒空間等），建立 .pyc 檔案是自動的，會建立一個 `__pycache__` 子目錄並將編譯後的模組寫入該子目錄。

在頂層腳本上運行 Python 不被視為引入，也不會建立 `.pyc`。例如，如果你有一個頂層模組 `foo.py` 引入另一個模組 `xyz.py`，當你運行 `foo` 時（透過輸入 `python foo.py` 作為一個 shell 命令），將為 `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

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

- 主要引入 `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 不太喜歡這種方法，因為引入出現在一個奇怪的地方，但它確實有效。

Matthias Urlichs 建議重組 (restructuring) 你的程式碼，以便打從一開始就不需要遞迴引入。

這些方案並不衝突。

### __import__('x.y.z') 回傳 <module 'x'>，那我怎麼得到 z？

考慮改用來自 `importlib` 的便利函式 `import_module()`：

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

### 當我編輯需要引入的模組並重新引入它時，更動沒有反應出來。為什麼會這樣？

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

    import importlib
    import modname
    importlib.reload(modname)

警告：此技術並非 100% 萬無一失。尤其是包含像這樣陳述式的模組：

    from modname import some_objects

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

    >>> import importlib
    >>> import cls
    >>> c = cls.C()                # 建立一個 C 的實例
    >>> importlib.reload(cls)
    <module 'cls' from 'cls.py'>
    >>> isinstance(c, cls.C)       # isinstance 為 false？！？
    False

如果印出類別物件的「識別性」，問題的本質就很清楚了：

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