程式設計常見問題

一般性問題

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

有。

下面描述了幾種 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 的區域性變數，並在定義 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. 本地開發的模組

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

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

在這種情況下，如果第二個模組僅在一個函式中使用，則可以輕鬆地將匯入移動到該函式中。當呼叫匯入時，第一個模組將完成初始化，並且第二個模組可以進行匯入。

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

僅當有必要解決諸如避免迴圈匯入或試圖減少模組的初始化時間之類的問題時，才將匯入移動到區域性作用域（例如在函式定義內）。如果許多匯入取決於程式的執行方式而變得不必要，則此技術特別有用。如果模組僅在該函式中使用，則你可能還需要將匯入移動到函式中。請注意，由於模組的一次性初始化，第一次載入模組可能很耗時，但是多次載入模組幾乎是免費的，僅需幾次字典查詢。即使模組名稱已超出範圍，該模組也可能在 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)

實參和形參有什麼區別？

形參（Parameters） 是在函式定義中出現的名稱，而 實參（arguments） 是在呼叫函式時實際傳遞給函式的值。形參定義了函式可以接受的 實參型別。例如，給定函式定義：

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. 列表是可變的（mutable），這意味著你可以更改它們的內容。

在呼叫 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 不再相等。這是因為整數是不可變的（immutable），當我們執行 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 中編寫帶有輸出引數（按引用呼叫）的函式？

請記住，在 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)，它返回一個函式 f(x)，該函式計算值 a*x+b。使用巢狀作用域：

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"

不是

"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-字串 和 格式化字串語法 部分，例如 "{: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 更強大，並且更適合該任務。

“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 擴充套件模組。

另請參閱

致力於 效能提示 的維基頁面。

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

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 單元*。

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 建立一個列表，其中包含對長度為 2 的同一列表的 3 個引用。對一行的更改將顯示在所有行中，這幾乎肯定不是您想要的。

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

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 是最著名的。

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

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

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

的語句時，該異常有點令人驚訝，更令人驚訝的是，即使存在錯誤，追加操作也有效：

>>> 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 中進行施瓦茨變換嗎？

該技術歸因於 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。要測試“真正的繼承”，請掃描該類的 MRO。

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__() 來設定 self 上的屬性，而不會導致無限遞迴。

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 自己的 dict 中建立一個新的、不相關的名為“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 的首選方法。這在程式碼中看起來像純英文，並且避免與其他可能具有布林值且計算結果為 false 的物件混淆。

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 方法將無法工作，因為它無法檢測到屬性的更改。

為了使 lru_cache 方法在 station_id 可變時也能工作，類需要定義 __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__ 子目錄。例如，如果你以一個使用者身份進行開發，但以另一個使用者身份執行（例如，如果你正在使用 Web 伺服器進行測試），則可能會發生這種情況。

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

在頂層指令碼上執行 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 模組自動編譯一個或多個目錄中的所有檔案。你可以透過執行 compileall.py 並提供包含要編譯的 Python 檔案的目錄路徑來從 shell 提示符執行此操作

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 <模組> import ...，並將所有程式碼放在函式內部。全域性變數和類變數的初始化應僅使用常量或內建函式。這意味著從匯入的模組中的所有內容都引用為 <模組>.<名稱>。

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

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

  • import 語句

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

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

Matthias Urlichs 建議重構你的程式碼，以便首先不需要遞迴匯入。

這些解決方案並非互斥。

__import__(‘x.y.z’) 返回 <模組 ‘x’>；如何獲取 z？

請考慮改用 import_module() 來自 importlib 的便捷函式

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()                # 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'