內置類型 · Python3.7.3官方文檔簡體中文

### 導航 - [索引](../genindex.xhtml "總目錄") - [模塊](../py-modindex.xhtml "Python 模塊索引") | - [下一頁](exceptions.xhtml "內置異常") | - [上一頁](constants.xhtml "內置常量") | - ![](https://box.kancloud.cn/a721fc7ec672275e257bbbfde49a4d4e_16x16.png) - [Python](https://www.python.org/) ? - zh\_CN 3.7.3 [文檔](../index.xhtml) ? - [Python 標準庫](index.xhtml) ? - $('.inline-search').show(0); | # 內置類型以下部分描述了解釋器中內置的標準類型。主要內置類型有數字、序列、映射、類、實例和異常。有些多項集類是可變的。它們用于添加、移除或重排其成員的方法將原地執行，并不返回特定的項，絕對不會返回多項集實例自身而是返回 `None`。有些操作受多種對象類型的支持；特別地，實際上所有對象都可以被比較、檢測邏輯值，以及轉換為字符串（使用 [`repr()`](functions.xhtml#repr "repr") 函數或略有差異的 [`str()`](#str "str") 函數）。后一個函數是在對象由 [`print()`](functions.xhtml#print "print") 函數輸出時被隱式地調用的。 ## 邏輯值檢測任何對象都可以進行邏輯值的檢測，以便在 [`if`](../reference/compound_stmts.xhtml#if) 或 [`while`](../reference/compound_stmts.xhtml#while) 作為條件或是作為下文所述布爾運算的操作數來使用。一個對象在默認情況下均被視為真值，除非當該對象被調用時其所屬類定義了 [`__bool__()`](../reference/datamodel.xhtml#object.__bool__ "object.__bool__") 方法且返回 `False` 或是定義了 [`__len__()`](../reference/datamodel.xhtml#object.__len__ "object.__len__") 方法且返回零。 [1](#id12) 下面基本完整地列出了會被視為假值的內置對象: > - 被定義為假值的常量: `None` 和 `False`。 - 任何數值類型的零: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0, 1)` - 空的序列和多項集: `''`, `()`, `[]`, `{}`, `set()`, `range(0)` 產生布爾值結果的運算和內置函數總是返回 `0` 或 `False` 作為假值，`1` 或 `True` 作為真值，除非另行說明。（重要例外：布爾運算 `or` 和 `and` 總是返回其中一個操作數。） ## 布爾運算 --- `and`, `or`, `not` 這些屬于布爾運算，按優先級升序排列: 運算結果注釋 `x or y` if *x* is false, then *y*, else *x* (1) `x and y` if *x* is false, then *x*, else *y* (2) `not x` if *x* is false, then `True`, else `False` (3) 注釋: 1. 這是個短路運算符，因此只有在第一個參數為假值時才會對第二個參數求值。 2. 這是個短路運算符，因此只有在第一個參數為真值時才會對第二個參數求值。 3. `not` 的優先級比非布爾運算符低，因此 `not a == b` 會被解讀為 `not (a == b)` 而 `a == not b` 會引發語法錯誤。 ## 比較在 Python 中有八種比較運算符。它們的優先級相同（比布爾運算的優先級高）。比較運算可以任意串連；例如，`x < y <= z` 等價于 `x < y and y <= z`，前者的不同之處在于 *y* 只被求值一次（但在兩種情況下當 `x < y` 結果為假值時 *z* 都不會被求值）。此表格匯總了比較運算: 運算含義 `<` 嚴格小于 `<=` 小于或等于 `>` 嚴格大于 `>=` 大于或等于 `==` 等于 `!=` 不等于 `is` 對象標識 `is not` 否定的對象標識除了不同數字類型以外，不同類型的對象比較時絕對不會相等。而且，某些類型（例如函數對象）僅支持簡化比較形式，即任何兩個該種類型的對象必定不相等。 `<`, `<=`, `>` 和 `>=` 運算符在以下情況中將引發 [`TypeError`](exceptions.xhtml#TypeError "TypeError") 異常：當比較復數與另一個內置數字類型時，當兩個對象具有無法被比較的不同類型時，或在未定義次序的其他情況時。具有不同標識的類的實例比較結果通常為不相等，除非類定義了 [`__eq__()`](../reference/datamodel.xhtml#object.__eq__ "object.__eq__") 方法。一個類實例不能與相同類或的其他實例或其他類型的對象進行排序，除非該類定義了足夠多的方法，包括 [`__lt__()`](../reference/datamodel.xhtml#object.__lt__ "object.__lt__"), [`__le__()`](../reference/datamodel.xhtml#object.__le__ "object.__le__"), [`__gt__()`](../reference/datamodel.xhtml#object.__gt__ "object.__gt__") 以及 [`__ge__()`](../reference/datamodel.xhtml#object.__ge__ "object.__ge__") (而如果你想實現常規意義上的比較操作，通常只要有 [`__lt__()`](../reference/datamodel.xhtml#object.__lt__ "object.__lt__") 和 [`__eq__()`](../reference/datamodel.xhtml#object.__eq__ "object.__eq__") 就可以了)。 [`is`](../reference/expressions.xhtml#is) 和 [`is not`](../reference/expressions.xhtml#is-not) 運算符無法自定義；并且它們可以被應用于任意兩個對象而不會引發異常。還有兩種具有相同語法優先級的運算 [`in`](../reference/expressions.xhtml#in) 和 [`not in`](../reference/expressions.xhtml#not-in)，它們被 [iterable](../glossary.xhtml#term-iterable) 或實現了 [`__contains__()`](../reference/datamodel.xhtml#object.__contains__ "object.__contains__") 方法的類型所支持。 ## 數字類型 --- [`int`](functions.xhtml#int "int"), [`float`](functions.xhtml#float "float"), [`complex`](functions.xhtml#complex "complex") 存在三種不同的數字類型: *整數*, *浮點數* 和 *復數*。此外，布爾值屬于整數的子類型。整數具有無限的精度。浮點數通常使用 C 中的 `double` 來實現；有關你的程序運行所在機器上浮點數的精度和內部表示法可在 [`sys.float_info`](sys.xhtml#sys.float_info "sys.float_info") 中查看。復數包含實部和虛部，分別以一個浮點數表示。要從一個復數 *z* 中提取這兩個部分，可使用 `z.real` 和 `z.imag`。（標準庫包含附加的數字類型，如表示有理數的 [`fractions`](fractions.xhtml#module-fractions "fractions: Rational numbers.") 以及以用戶定制精度表示浮點數的 [`decimal`](decimal.xhtml#module-decimal "decimal: Implementation of the General Decimal Arithmetic Specification.")。）數字是由數字字面值或內置函數與運算符的結果來創建的。不帶修飾的整數字面值（包括十六進制、八進制和二進制數）會生成整數。包含小數點或冪運算符的數字字面值會生成浮點數。在數字字面值末尾加上 `'j'` 或 `'J'` 會生成虛數（實部為零的復數），你可以將其與整數或浮點數相加來得到具有實部和虛部的復數。 Python 完全支持混合算術：當一個二元運算符用于不同數字類型的操作數時，具有“較窄” 類型的操作數會被擴展為另一個操作數的類型，整數比浮點數更窄，浮點數又比復數更窄。混合類型數字之間的比較也使用相同的規則。 [2](#id13) 構造器 [`int()`](functions.xhtml#int "int"), [`float()`](functions.xhtml#float "float") 和 [`complex()`](functions.xhtml#complex "complex") 可被用于生成特定類型的數字。所有數字類型（復數除外）都支持下列運算，按優先級升序排序（所有數字運算的優先級都高于比較運算）: 運算結果注釋完整文檔 `x + y` *x* 和 *y* 的和 `x - y` *x* 和 *y* 的差 `x * y` *x* 和 *y* 的乘積 `x / y` *x* 和 *y* 的商 `x // y` *x* 和 *y* 的商數 (1) `x % y` remainder of `x / y` (2) `-x` *x* 取反 `+x` *x* 不變 `abs(x)` *x* 的絕對值或大小 [`abs()`](functions.xhtml#abs "abs") `int(x)` 將 *x* 轉換為整數 (3)(6) [`int()`](functions.xhtml#int "int") `float(x)` 將 *x* 轉換為浮點數 (4)(6) [`float()`](functions.xhtml#float "float") `complex(re, im)` 一個帶有實部 *re* 和虛部 *im* 的復數。*im* 默認為0。 (6) [`complex()`](functions.xhtml#complex "complex") `c.conjugate()` 復數 *c* 的共軛 `divmod(x, y)` `(x // y, x % y)` (2) [`divmod()`](functions.xhtml#divmod "divmod") `pow(x, y)` *x* 的 *y* 次冪 (5) [`pow()`](functions.xhtml#pow "pow") `x ** y` *x* 的 *y* 次冪 (5) 注釋: 1. 也稱為整數除法。結果值是一個整數，但結果的類型不一定是 int。運算結果總是向負無窮的方向舍入: `1//2` 為 `0`, `(-1)//2` 為 `-1`, `1//(-2)` 為 `-1` 而 `(-1)//(-2)` 為 `0`。 2. 不可用于復數。而應在適當條件下使用 [`abs()`](functions.xhtml#abs "abs") 轉換為浮點數。 3. 從浮點數轉換為整數會被舍入或是像在 C 語言中一樣被截斷；請參閱 [`math.floor()`](math.xhtml#math.floor "math.floor") 和 [`math.ceil()`](math.xhtml#math.ceil "math.ceil") 函數查看轉換的完整定義。 4. float 也接受字符串 "nan" 和附帶可選前綴 "+" 或 "-" 的 "inf" 分別表示非數字 (NaN) 以及正或負無窮。 5. Python 將 `pow(0, 0)` 和 `0 ** 0` 定義為 `1`，這是編程語言的普遍做法。 6. 接受的數字字面值包括數碼 `0` 到 `9` 或任何等效的 Unicode 字符（具有 `Nd` 特征屬性的代碼點）。請參閱 <http://www.unicode.org/Public/10.0.0/ucd/extracted/DerivedNumericType.txt> 查看具有 `Nd` 特征屬性的代碼點的完整列表。所有 [`numbers.Real`](numbers.xhtml#numbers.Real "numbers.Real") 類型 ([`int`](functions.xhtml#int "int") 和 [`float`](functions.xhtml#float "float")) 還包括下列運算: 運算結果 [`math.trunc(x)`](math.xhtml#math.trunc "math.trunc") *x* 截斷為 [`Integral`](numbers.xhtml#numbers.Integral "numbers.Integral") [``` round(x[, n]) ```](functions.xhtml#round "round") *x* 舍入到 *n* 位小數，半數值會舍入到偶數。如果省略 *n*，則默認為 0。 [`math.floor(x)`](math.xhtml#math.floor "math.floor") <= *x* 的最大 [`Integral`](numbers.xhtml#numbers.Integral "numbers.Integral") [`math.ceil(x)`](math.xhtml#math.ceil "math.ceil") \>= *x* 的最小 [`Integral`](numbers.xhtml#numbers.Integral "numbers.Integral") 有關更多的數字運算請參閱 [`math`](math.xhtml#module-math "math: Mathematical functions (sin() etc.).") 和 [`cmath`](cmath.xhtml#module-cmath "cmath: Mathematical functions for complex numbers.") 模塊。 ### 整數類型的按位運算按位運算只對整數有意義。計算按位運算的結果，就相當于使用無窮多個二進制符號位對二的補碼執行操作。二進制按位運算的優先級全都低于數字運算，但又高于比較運算；一元運算 `~` 具有與其他一元算術運算 (`+` and `-`) 相同的優先級。此表格是以優先級升序排序的按位運算列表: 運算結果注釋 `x | y` *x* 和 *y* 按位 *或* (4) `x ^ y` *x* 和 *y* 按位 *異或* (4) `x & y` *x* 和 *y* 按位 *與* (4) `x << n` *x* 左移 *n* 位 (1)(2) `x >> n` *x* 右移 *n* 位 (1)(3) `~x` *x* 逐位取反注釋: 1. 負的移位數是非法的，會導致引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。 2. 左移 *n* 位等價于不帶溢出檢測地乘以 `pow(2, n)`。 3. 右移 *n* 位等價于不帶溢出檢測地除以 `pow(2, n)`。 4. 使用帶有至少一個額外符號擴展位的有限個二進制補碼表示（有效位寬度為 `1 + max(x.bit_length(), y.bit_length())` 或以上）執行這些計算就足以獲得相當于有無數個符號位時的同樣結果。 ### 整數類型的附加方法 int 類型實現了 [`numbers.Integral`](numbers.xhtml#numbers.Integral "numbers.Integral") [abstract base class](../glossary.xhtml#term-abstract-base-class)。此外，它還提供了其他幾個方法: `int.``bit_length`()返回以二進制表示一個整數所需要的位數，不包括符號位和前面的零: ``` >>> n = -37 >>> bin(n) '-0b100101' >>> n.bit_length() 6 ``` 更準確地說，如果 `x` 非零，則 `x.bit_length()` 是使得 `2**(k-1) <= abs(x) < 2**k` 的唯一正整數 `k`。同樣地，當 `abs(x)` 小到足以具有正確的舍入對數時，則 `k = 1 + int(log(abs(x), 2))`。如果 `x` 為零，則 `x.bit_length()` 返回 `0`。等價于: ``` def bit_length(self): s = bin(self) # binary representation: bin(-37) --> '-0b100101' s = s.lstrip('-0b') # remove leading zeros and minus sign return len(s) # len('100101') --> 6 ``` 3\.1 新版功能. `int.``to_bytes`(*length*, *byteorder*, *\**, *signed=False*)返回表示一個整數的字節數組。 ``` >>> (1024).to_bytes(2, byteorder='big') b'\x04\x00' >>> (1024).to_bytes(10, byteorder='big') b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> (-1024).to_bytes(10, byteorder='big', signed=True) b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little') b'\xe8\x03' ``` 整數會使用 *length* 個字節來表示。如果整數不能用給定的字節數來表示則會引發 [`OverflowError`](exceptions.xhtml#OverflowError "OverflowError")。 *byteorder* 參數確定用于表示整數的字節順序。如果 *byteorder* 為 `"big"`，則最高位字節放在字節數組的開頭。如果 *byteorder* 為 `"little"`，則最高位字節放在字節數組的末尾。要請求主機系統上的原生字節順序，請使用 [`sys.byteorder`](sys.xhtml#sys.byteorder "sys.byteorder") 作為字節順序值。 *signed* 參數確定是否使用二的補碼來表示整數。如果 *signed* 為 `False` 并且給出的是負整數，則會引發 [`OverflowError`](exceptions.xhtml#OverflowError "OverflowError")。 *signed* 的默認值為 `False`。 3\.2 新版功能. *classmethod* `int.``from_bytes`(*bytes*, *byteorder*, *\**, *signed=False*)返回由給定字節數組所表示的整數。 ``` >>> int.from_bytes(b'\x00\x10', byteorder='big') 16 >>> int.from_bytes(b'\x00\x10', byteorder='little') 4096 >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True) -1024 >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False) 64512 >>> int.from_bytes([255, 0, 0], byteorder='big') 16711680 ``` *bytes* 參數必須為一個 [bytes-like object](../glossary.xhtml#term-bytes-like-object) 或是生成字節的可迭代對象。 *byteorder* 參數確定用于表示整數的字節順序。如果 *byteorder* 為 `"big"`，則最高位字節放在字節數組的開頭。如果 *byteorder* 為 `"little"`，則最高位字節放在字節數組的末尾。要請求主機系統上的原生字節順序，請使用 [`sys.byteorder`](sys.xhtml#sys.byteorder "sys.byteorder") 作為字節順序值。 *signed* 參數指明是否使用二的補碼來表示整數。 3\.2 新版功能. ### 浮點類型的附加方法 float 類型實現了 [`numbers.Real`](numbers.xhtml#numbers.Real "numbers.Real") [abstract base class](../glossary.xhtml#term-abstract-base-class)。 float 還具有以下附加方法。 `float.``as_integer_ratio`()返回一對整數，其比率正好等于原浮點數并且分母為正數。無窮大會引發 [`OverflowError`](exceptions.xhtml#OverflowError "OverflowError") 而 NaN 則會引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。 `float.``is_integer`()如果 float 實例可用有限位整數表示則返回 `True`，否則返回 `False`: ``` >>> (-2.0).is_integer() True >>> (3.2).is_integer() False ``` 兩個方法均支持與十六進制數字符串之間的轉換。由于 Python 浮點數在內部存儲為二進制數，因此浮點數與 *十進制數* 字符串之間的轉換往往會導致微小的舍入錯誤。而十六進制數字符串卻允許精確地表示和描述浮點數。這在進行調試和數值工作時非常有用。 `float.``hex`()以十六進制字符串的形式返回一個浮點數表示。對于有限浮點數，這種表示法將總是包含前導的 `0x` 和尾隨的 `p` 加指數。 *classmethod* `float.``fromhex`(*s*)返回以十六進制字符串 *s* 表示的浮點數的類方法。字符串 *s* 可以帶有前導和尾隨的空格。請注意 [`float.hex()`](#float.hex "float.hex") 是實例方法，而 [`float.fromhex()`](#float.fromhex "float.fromhex") 是類方法。十六進制字符串采用的形式為: ``` [sign] ['0x'] integer ['.' fraction] ['p' exponent] ``` 可選的 `sign` 可以是 `+` 或 `-`，`integer` 和 `fraction` 是十六進制數碼組成的字符串，`exponent` 是帶有可選前導符的十進制整數。大小寫沒有影響，在 integer 或 fraction 中必須至少有一個十六進制數碼。此語法類似于 C99 標準的 6.4.4.2 小節中所描述的語法，也是 Java 1.5 以上所使用的語法。特別地，[`float.hex()`](#float.hex "float.hex") 的輸出可以用作 C 或 Java 代碼中的十六進制浮點數字面值，而由 C 的 `%a` 格式字符或 Java 的 `Double.toHexString` 所生成的十六進制數字符串由為 [`float.fromhex()`](#float.fromhex "float.fromhex") 所接受。請注意 exponent 是十進制數而非十六進制數，它給出要與系數相乘的 2 的冪次。例如，十六進制數字符串 `0x3.a7p10` 表示浮點數 `(3 + 10./16 + 7./16**2) * 2.0**10` 即 `3740.0`: ``` >>> float.fromhex('0x3.a7p10') 3740.0 ``` 對 `3740.0` 應用反向轉換會得到另一個代表相同數值的十六進制數字符串: ``` >>> float.hex(3740.0) '0x1.d380000000000p+11' ``` ### 數字類型的哈希運算對于可能為不同類型的數字 `x` 和 `y`，要求 `x == y` 時必定 `hash(x) == hash(y)` (詳情參見 [`__hash__()`](../reference/datamodel.xhtml#object.__hash__ "object.__hash__") 方法的文檔)。為了便于在各種數字類型 (包括 [`int`](functions.xhtml#int "int"), [`float`](functions.xhtml#float "float"), [`decimal.Decimal`](decimal.xhtml#decimal.Decimal "decimal.Decimal") 和 [`fractions.Fraction`](fractions.xhtml#fractions.Fraction "fractions.Fraction")) 上實現并保證效率，Python 對數字類型的哈希運算是基于為任意有理數定義統一的數學函數，因此該運算對 [`int`](functions.xhtml#int "int") 和 [`fractions.Fraction`](fractions.xhtml#fractions.Fraction "fractions.Fraction") 的全部實例，以及 [`float`](functions.xhtml#float "float") 和 [`decimal.Decimal`](decimal.xhtml#decimal.Decimal "decimal.Decimal") 的全部有限實例均可用。從本質上說，此函數是通過以一個固定質數 `P` 進行 `P` 降模給出的。 `P` 的值在 Python 中可以 [`sys.hash_info`](sys.xhtml#sys.hash_info "sys.hash_info") 的 `modulus` 屬性的形式被訪問。 **CPython implementation detail:** 目前所用的質數設定，在 C long 為 32 位的機器上 `P = 2**31 - 1` 而在 C long 為 64 位的機器上 `P = 2**61 - 1`。詳細規則如下所述: - 如果 `x = m / n` 是一個非負的有理數且 `n` 不可被 `P` 整除，則定義 `hash(x)` 為 `m * invmod(n, P) % P`，其中 `invmod(n, P)` 是對 `n` 模 `P` 取反。 - 如果 `x = m / n` 是一個非負的有理數且 `n` 可被 `P` 整除（但 `m` 不能）則 `n` 不能對 `P` 降模，以上規則不適用；在此情況下則定義 `hash(x)` 為常數值 `sys.hash_info.inf`。 - 如果 `x = m / n` 是一個負的有理數則定義 `hash(x)` 為 `-hash(-x)`。如果結果哈希值為 `-1` 則將其替換為 `-2`。 - 特定值 `sys.hash_info.inf`, `-sys.hash_info.inf` 和 `sys.hash_info.nan` 被用作正無窮、負無窮和空值（所分別對應的）哈希值。（所有可哈希的空值都具有相同的哈希值。） - 對于一個 [`complex`](functions.xhtml#complex "complex") 值 `z`，會通過計算 `hash(z.real) + sys.hash_info.imag * hash(z.imag)` 將實部和虛部的哈希值結合起來，并進行降模 `2**sys.hash_info.width` 以使其處于 `range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1))` 范圍之內。同樣地，如果結果為 `-1` 則將其替換為 `-2`。為了闡明上述規則，這里有一些等價于內置哈希算法的 Python 代碼示例，可用于計算有理數、[`float`](functions.xhtml#float "float") 或 [`complex`](functions.xhtml#complex "complex") 的哈希值: ``` import sys, math def hash_fraction(m, n): """Compute the hash of a rational number m / n. Assumes m and n are integers, with n positive. Equivalent to hash(fractions.Fraction(m, n)). """ P = sys.hash_info.modulus # Remove common factors of P. (Unnecessary if m and n already coprime.) while m % P == n % P == 0: m, n = m // P, n // P if n % P == 0: hash_value = sys.hash_info.inf else: # Fermat's Little Theorem: pow(n, P-1, P) is 1, so # pow(n, P-2, P) gives the inverse of n modulo P. hash_value = (abs(m) % P) * pow(n, P - 2, P) % P if m < 0: hash_value = -hash_value if hash_value == -1: hash_value = -2 return hash_value def hash_float(x): """Compute the hash of a float x.""" if math.isnan(x): return sys.hash_info.nan elif math.isinf(x): return sys.hash_info.inf if x > 0 else -sys.hash_info.inf else: return hash_fraction(*x.as_integer_ratio()) def hash_complex(z): """Compute the hash of a complex number z.""" hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag) # do a signed reduction modulo 2**sys.hash_info.width M = 2**(sys.hash_info.width - 1) hash_value = (hash_value & (M - 1)) - (hash_value & M) if hash_value == -1: hash_value = -2 return hash_value ``` ## 迭代器類型 Python 支持在容器中進行迭代的概念。這是通過使用兩個單獨方法來實現的；它們被用于允許用戶自定義類對迭代的支持。將在下文中詳細描述的序列總是支持迭代方法。容器對象要提供迭代支持，必須定義一個方法: `container.``__iter__`()返回一個迭代器對象。該對象需要支持下文所述的迭代器協議。如果容器支持不同的迭代類型，則可以提供額外的方法來專門地請求不同迭代類型的迭代器。（支持多種迭代形式的對象的例子有同時支持廣度優先和深度優先遍歷的樹結構。）此方法對應于 Python/C API 中 Python 對象類型結構體的 [`tp_iter`](../c-api/typeobj.xhtml#c.PyTypeObject.tp_iter "PyTypeObject.tp_iter") 槽位。迭代器對象自身需要支持以下兩個方法，它們共同組成了 *迭代器協議*: `iterator.``__iter__`()返回迭代器對象本身。這是同時允許容器和迭代器配合 [`for`](../reference/compound_stmts.xhtml#for) 和 [`in`](../reference/expressions.xhtml#in) 語句使用所必須的。此方法對應于 Python/C API 中 Python 對象類型結構體的 [`tp_iter`](../c-api/typeobj.xhtml#c.PyTypeObject.tp_iter "PyTypeObject.tp_iter") 槽位。 `iterator.``__next__`()從容器中返回下一項。如果已經沒有項可返回，則會引發 [`StopIteration`](exceptions.xhtml#StopIteration "StopIteration") 異常。此方法對應于 Python/C API 中 Python 對象類型結構體的 [`tp_iternext`](../c-api/typeobj.xhtml#c.PyTypeObject.tp_iternext "PyTypeObject.tp_iternext") 槽位。 Python 定義了幾種迭代器對象以支持對一般和特定序列類型、字典和其他更特別的形式進行迭代。除了迭代器協議的實現，特定類型的其他性質對迭代操作來說都不重要。一旦迭代器的 [`__next__()`](#iterator.__next__ "iterator.__next__") 方法引發了 [`StopIteration`](exceptions.xhtml#StopIteration "StopIteration")，它必須一直對后續調用引發同樣的異常。不遵循此行為特性的實現將無法正常使用。 ### 生成器類型 Python 的 [generator](../glossary.xhtml#term-generator) 提供了一種實現迭代器協議的便捷方式。如果容器對象 [`__iter__()`](../reference/datamodel.xhtml#object.__iter__ "object.__iter__") 方法被實現為一個生成器，它將自動返回一個迭代器對象（從技術上說是一個生成器對象），該對象提供 [`__iter__()`](../reference/datamodel.xhtml#object.__iter__ "object.__iter__") 和 [`__next__()`](../reference/expressions.xhtml#generator.__next__ "generator.__next__") 方法。有關生成器的更多信息可以參閱 [yield 表達式的文檔](../reference/expressions.xhtml#yieldexpr)。 ## 序列類型 --- [`list`](#list "list"), [`tuple`](#tuple "tuple"), [`range`](#range "range") 有三種基本序列類型：list, tuple 和 range 對象。為處理 [二進制數據](#binaryseq) 和 [文本字符串](#textseq) 而特別定制的附加序列類型會在專門的小節中描述。 ### 通用序列操作大多數序列類型，包括可變類型和不可變類型都支持下表中的操作。 [`collections.abc.Sequence`](collections.abc.xhtml#collections.abc.Sequence "collections.abc.Sequence") ABC 被提供用來更容易地在自定義序列類型上正確地實現這些操作。此表按優先級升序列出了序列操作。在表格中，*s* 和 *t* 是具有相同類型的序列，*n*, *i*, *j* 和 *k* 是整數而 *x* 是任何滿足 *s* 所規定的類型和值限制的任意對象。 `in` 和 `not in` 操作具有與比較操作相同的優先級。 `+` (拼接) 和 `*` (重復) 操作具有與對應數值運算相同的優先級。 [3](#id14) 運算結果注釋 `x in s` 如果 *s* 中的某項等于 *x* 則結果為 `True`，否則為 `False` (1) `x not in s` 如果 *s* 中的某項等于 *x* 則結果為 `False`，否則為 `True` (1) `s + t` *s* 與 *t* 相拼接 (6)(7) `s * n` 或 `n * s` 相當于 *s* 與自身進行 *n* 次拼接 (2)(7) `s[i]` *s* 的第 *i* 項，起始為 0 (3) `s[i:j]` *s* 從 *i* 到 *j* 的切片 (3)(4) `s[i:j:k]` *s* 從 *i* 到 *j* 步長為 *k* 的切片 (3)(5) `len(s)` *s* 的長度 `min(s)` *s* 的最小項 `max(s)` *s* 的最大項 `s.index(x[, i[, j]])` *x* 在 *s* 中首次出現項的索引號（索引號在 *i* 或其后且在 *j* 之前） (8) `s.count(x)` *x* 在 *s* 中出現的總次數相同類型的序列也支持比較。特別地，tuple 和 list 的比較是通過比較對應元素的字典順序。這意味著想要比較結果相等，則每個元素比較結果都必須相等，并且兩個序列長度必須相同。（完整細節請參閱語言參考的 [比較運算](../reference/expressions.xhtml#comparisons) 部分。）注釋: 1. 雖然 `in` 和 `not in` 操作在通常情況下僅被用于簡單的成員檢測，某些專門化序列 (例如 [`str`](#str "str"), [`bytes`](#bytes "bytes") 和 [`bytearray`](#bytearray "bytearray")) 也使用它們進行子序列檢測: ``` >>> "gg" in "eggs" True ``` 2. 小于 `0` 的 *n* 值會被當作 `0` 來處理 (生成一個與 *s* 同類型的空序列)。請注意序列 *s* 中的項并不會被拷貝；它們會被多次引用。這一點經常會令 Python 編程新手感到困擾；例如: ``` >>> lists = [[]] * 3 >>> lists [[], [], []] >>> lists[0].append(3) >>> lists [[3], [3], [3]] ``` 具體的原因在于 `[[]]` 是一個包含了一個空列表的單元素列表，所以 `[[]] * 3` 結果中的三個元素都是對這一個空列表的引用。修改 `lists` 中的任何一個元素實際上都是對這一個空列表的修改。你可以用以下方式創建以不同列表為元素的列表: ``` >>> lists = [[] for i in range(3)] >>> lists[0].append(3) >>> lists[1].append(5) >>> lists[2].append(7) >>> lists [[3], [5], [7]] ``` 進一步的解釋可以在 FAQ 條目 [如何創建多維列表？](../faq/programming.xhtml#faq-multidimensional-list) 中查看。 3. 如果 *i* 或 *j* 為負值，則索引順序是相對于序列 *s* 的末尾: 索引號會被替換為 `len(s) + i` 或 `len(s) + j`。但要注意 `-0` 仍然為 `0`。 4. *s* 從 *i* 到 *j* 的切片被定義為所有滿足 `i <= k < j` 的索引號 *k* 的項組成的序列。如果 *i* 或 *j* 大于 `len(s)`，則使用 `len(s)`。如果 *i* 被省略或為 `None`，則使用 `0`。如果 *j* 被省略或為 `None`，則使用 `len(s)`。如果 *i* 大于等于 *j*，則切片為空。 5. *s* 從 *i* 到 *j* 步長為 *k* 的切片被定義為所有滿足 `0 <= n < (j-i)/k` 的索引號 `x = i + n*k` 的項組成的序列。換句話說，索引號為 `i`, `i+k`, `i+2*k`, `i+3*k`，以此類推，當達到 *j* 時停止 (但一定不包括 *j*)。當 *k* 為正值時，*i* 和 *j* 會被減至不大于 `len(s)`。當 *k* 為負值時，*i* 和 *j* 會被減至不大于 `len(s) - 1`。如果 *i* 或 *j* 被省略或為 `None`，它們會成為“終止”值 (是哪一端的終止值則取決于 *k* 的符號)。請注意，*k* 不可為零。如果 *k* 為 `None`，則當作 `1` 處理。 6. 拼接不可變序列總是會生成新的對象。這意味著通過重復拼接來構建序列的運行時開銷將會基于序列總長度的乘方。想要獲得線性的運行時開銷，你必須改用下列替代方案之一： - 如果拼接 [`str`](#str "str") 對象，你可以構建一個列表并在最后使用 [`str.join()`](#str.join "str.join") 或是寫入一個 [`io.StringIO`](io.xhtml#io.StringIO "io.StringIO") 實例并在結束時獲取它的值 - 如果拼接 [`bytes`](#bytes "bytes") 對象，你可以類似地使用 [`bytes.join()`](#bytes.join "bytes.join") 或 [`io.BytesIO`](io.xhtml#io.BytesIO "io.BytesIO")，或者你也可以使用 [`bytearray`](#bytearray "bytearray") 對象進行原地拼接。 [`bytearray`](#bytearray "bytearray") 對象是可變的，并且具有高效的重分配機制 - 如果拼接 [`tuple`](#tuple "tuple") 對象，請改為擴展 [`list`](#list "list") 類 - 對于其它類型，請查看相應的文檔 7. 某些序列類型 (例如 [`range`](#range "range")) 僅支持遵循特定模式的項序列，因此并不支持序列拼接或重復。 8. 當 *x* 在 *s* 中找不到時 `index` 會引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。不是所有實現都支持傳入額外參數 *i* 和 *j*。這兩個參數允許高效地搜索序列的子序列。傳入這兩個額外參數大致相當于使用 `s[i:j].index(x)`，但是不會復制任何數據，并且返回的索引是相對于序列的開頭而非切片的開頭。 ### 不可變序列類型不可變序列類型普遍實現而可變序列類型未實現的唯一操作就是對 [`hash()`](functions.xhtml#hash "hash") 內置函數的支持。這種支持允許不可變類型，例如 [`tuple`](#tuple "tuple") 實例被用作 [`dict`](#dict "dict") 鍵，以及存儲在 [`set`](#set "set") 和 [`frozenset`](#frozenset "frozenset") 實例中。嘗試對包含有不可哈希值的不可變序列進行哈希運算將會導致 [`TypeError`](exceptions.xhtml#TypeError "TypeError")。 ### 可變序列類型以下表格中的操作是在可變序列類型上定義的。 [`collections.abc.MutableSequence`](collections.abc.xhtml#collections.abc.MutableSequence "collections.abc.MutableSequence") ABC 被提供用來更容易地在自定義序列類型上正確實現這些操作。表格中的 *s* 是可變序列類型的實例，*t* 是任意可迭代對象，而 *x* 是符合對 *s* 所規定類型與值限制的任何對象 (例如，[`bytearray`](#bytearray "bytearray") 僅接受滿足 `0 <= x <= 255` 值限制的整數)。運算結果注釋 `s[i] = x` 將 *s* 的第 *i* 項替換為 *x* `s[i:j] = t` 將 *s* 從 *i* 到 *j* 的切片替換為可迭代對象 *t* 的內容 `del s[i:j]` 等同于 `s[i:j] = []` `s[i:j:k] = t` 將 `s[i:j:k]` 的元素替換為 *t* 的元素 (1) `del s[i:j:k]` 從列表中移除 `s[i:j:k]` 的元素 `s.append(x)` 將 *x* 添加到序列的末尾 (等同于 `s[len(s):len(s)] = [x]`) `s.clear()` 從 *s* 中移除所有項 (等同于 `del s[:]`) (5) `s.copy()` 創建 *s* 的淺拷貝 (等同于 `s[:]`) (5) `s.extend(t)` 或 `s += t` 用 *t* 的內容擴展 *s* (基本上等同于 `s[len(s):len(s)] = t`) `s *= n` 使用 *s* 的內容重復 *n* 次來對其進行更新 (6) `s.insert(i, x)` 在由 *i* 給出的索引位置將 *x* 插入 *s* (等同于 `s[i:i] = [x]`) `s.pop([i])` 提取在 *i* 位置上的項，并將其從 *s* 中移除 (2) `s.remove(x)` 刪除 *s* 中第一個 `s[i]` 等于 *x* 的項目。 (3) `s.reverse()` 就地將列表中的元素逆序。 (4) 注釋: 1. *t* 必須與它所替換的切片具有相同的長度。 2. 可選參數 *i* 默認為 `-1`，因此在默認情況下會移除并返回最后一項。 3. 當在 *s* 中找不到 *x* 時 `remove` 操作會引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。 4. 當反轉大尺寸序列時 `reverse()` 方法會原地修改該序列以保證空間經濟性。為提醒用戶此操作是通過間接影響進行的，它并不會返回反轉后的序列。 5. 包括 `clear()` 和 `copy()` 是為了與不支持切片操作的可變容器 (例如 [`dict`](#dict "dict") 和 [`set`](#set "set")) 的接口保持一致 3\.3 新版功能: `clear()` 和 `copy()` 方法。 6. *n* 值為一個整數，或是一個實現了 [`__index__()`](../reference/datamodel.xhtml#object.__index__ "object.__index__") 的對象。 *n* 值為零或負數將清空序列。序列中的項不會被拷貝；它們會被多次引用，正如 [通用序列操作](#typesseq-common) 中有關 `s * n` 的說明。 ### 列表列表是可變序列，通常用于存放同類項目的集合（其中精確的相似程度將根據應用而變化）。 *class* `list`(\[*iterable*\])可以用多種方式構建列表： - 使用一對方括號來表示空列表: `[]` - 使用方括號，其中的項以逗號分隔: `[a]`, `[a, b, c]` - 使用列表推導式: `[x for x in iterable]` - 使用類型的構造器: `list()` 或 `list(iterable)` 構造器將構造一個列表，其中的項與 *iterable* 中的項具有相同的的值與順序。 *iterable* 可以是序列、支持迭代的容器或其它可迭代對象。如果 *iterable* 已經是一個列表，將創建并返回其副本，類似于 `iterable[:]`。例如，`list('abc')` 返回 `['a', 'b', 'c']` 而 `list( (1, 2, 3) )` 返回 `[1, 2, 3]`。如果沒有給出參數，構造器將創建一個空列表 `[]`。其它許多操作也會產生列表，包括 [`sorted()`](functions.xhtml#sorted "sorted") 內置函數。列表實現了所有 [一般](#typesseq-common) 和 [可變](#typesseq-mutable) 序列的操作。列表還額外提供了以下方法： `sort`(*\**, *key=None*, *reverse=False*)此方法會對列表進行原地排序，只使用 `<` 來進行各項間比較。異常不會被屏蔽 —— 如果有任何比較操作失敗，整個排序操作將失敗（而列表可能會處于被部分修改的狀態）。 [`sort()`](#list.sort "list.sort") 接受兩個僅限以關鍵字形式傳入的參數 ([僅限關鍵字參數](../glossary.xhtml#keyword-only-parameter)): *key* 指定帶有一個參數的函數，用于從每個列表元素中提取比較鍵 (例如 `key=str.lower`)。對應于列表中每一項的鍵會被計算一次，然后在整個排序過程中使用。默認值 `None` 表示直接對列表項排序而不計算一個單獨的鍵值。可以使用 [`functools.cmp_to_key()`](functools.xhtml#functools.cmp_to_key "functools.cmp_to_key") 將 2.x 風格的 *cmp* 函數轉換為 *key* 函數。 *reverse* 為一個布爾值。如果設為 `True`，則每個列表元素將按反向順序比較進行排序。當順序大尺寸序列時此方法會原地修改該序列以保證空間經濟性。為提醒用戶此操作是通過間接影響進行的，它并不會返回排序后的序列（請使用 [`sorted()`](functions.xhtml#sorted "sorted") 顯示地請求一個新的已排序列表實例）。 [`sort()`](#list.sort "list.sort") 方法確保是穩定的。如果一個排序確保不會改變比較結果相等的元素的相對順序就稱其為穩定的 --- 這有利于進行多重排序（例如先按部門、再接薪級排序）。 **CPython implementation detail:** 在一個列表被排序期間，嘗試改變甚至進行檢測也會造成未定義的影響。 Python 的 C 實現會在排序期間將列表顯示為空，如果發現列表在排序期間被改變將會引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。 ### 元組元組是不可變序列，通常用于儲存異構數據的多項集（例如由 [`enumerate()`](functions.xhtml#enumerate "enumerate") 內置函數所產生的二元組）。元組也被用于需要同構數據的不可變序列的情況（例如允許存儲到 [`set`](#set "set") 或 [`dict`](#dict "dict") 的實例）。 *class* `tuple`(\[*iterable*\])可以用多種方式構建元組： - 使用一對圓括號來表示空元組: `()` - 使用一個后綴的逗號來表示單元組: `a,` 或 `(a,)` - 使用以逗號分隔的多個項: `a, b, c` or `(a, b, c)` - 使用內置的 [`tuple()`](#tuple "tuple"): `tuple()` 或 `tuple(iterable)` 構造器將構造一個元組，其中的項與 *iterable* 中的項具有相同的值與順序。 *iterable* 可以是序列、支持迭代的容器或其他可迭代對象。如果 *iterable* 已經是一個元組，會不加改變地將其返回。例如，`tuple('abc')` 返回 `('a', 'b', 'c')` 而 `tuple( [1, 2, 3] )` 返回 `(1, 2, 3)`。如果沒有給出參數，構造器將創建一個空元組 `()`。請注意決定生成元組的其實是逗號而不是圓括號。圓括號只是可選的，生成空元組或需要避免語法歧義的情況除外。例如，`f(a, b, c)` 是在調用函數時附帶三個參數，而 `f((a, b, c))` 則是在調用函數時附帶一個三元組。元組實現了所有 [一般](#typesseq-common) 序列的操作。對于通過名稱訪問相比通過索引訪問更清晰的異構數據多項集，[`collections.namedtuple()`](collections.xhtml#collections.namedtuple "collections.namedtuple") 可能是比簡單元組對象更為合適的選擇。 ### range 對象 [`range`](#range "range") 類型表示不可變的數字序列，通常用于在 [`for`](../reference/compound_stmts.xhtml#for) 循環中循環指定的次數。 *class* `range`(*stop*)*class* `range`(*start*, *stop*\[, *step*\])range 構造器的參數必須為整數（可以是內置的 [`int`](functions.xhtml#int "int") 或任何實現了 `__index__` 特殊方法的對象）。如果省略 *step* 參數，其默認值為 `1`。如果省略 *start* 參數，其默認值為 `0`，如果 *step* 為零則會引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。如果 *step* 為正值，確定 range `r` 內容的公式為 `r[i] = start + step*i` 其中 `i >= 0` 且 `r[i] < stop`。如果 *step* 為負值，確定 range 內容的公式仍然為 `r[i] = start + step*i`，但限制條件改為 `i >= 0` 且 `r[i] > stop`. 如果 `r[0]` 不符合值的限制條件，則該 range 對象為空。 range 對象確實支持負索引，但是會將其解讀為從正索引所確定的序列的末尾開始索引。元素絕對值大于 [`sys.maxsize`](sys.xhtml#sys.maxsize "sys.maxsize") 的 range 對象是被允許的，但某些特性 (例如 [`len()`](functions.xhtml#len "len")) 可能引發 [`OverflowError`](exceptions.xhtml#OverflowError "OverflowError")。一些 range 對象的例子: ``` >>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(1, 11)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> list(range(0, 30, 5)) [0, 5, 10, 15, 20, 25] >>> list(range(0, 10, 3)) [0, 3, 6, 9] >>> list(range(0, -10, -1)) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] >>> list(range(0)) [] >>> list(range(1, 0)) [] ``` range 對象實現了 [一般](#typesseq-common) 序列的所有操作，但拼接和重復除外（這是由于 range 對象只能表示符合嚴格模式的序列，而重復和拼接通常都會違反這樣的模式）。 `start`*start* 形參的值 (如果該形參未提供則為 `0`) `stop`*stop* 形參的值 `step`*step* 形參的值 (如果該形參未提供則為 `1`) [`range`](#range "range") 類型相比常規 [`list`](#list "list") 或 [`tuple`](#tuple "tuple") 的優勢在于一個 [`range`](#range "range") 對象總是占用固定數量的（較小）內存，不論其所表示的范圍有多大（因為它只保存了 `start`, `stop` 和 `step` 值，并會根據需要計算具體單項或子范圍的值）。 range 對象實現了 [`collections.abc.Sequence`](collections.abc.xhtml#collections.abc.Sequence "collections.abc.Sequence") ABC，提供如包含檢測、元素索引查找、切片等特性，并支持負索引 (參見 [序列類型 --- list, tuple, range](#typesseq)): ``` >>> r = range(0, 20, 2) >>> r range(0, 20, 2) >>> 11 in r False >>> 10 in r True >>> r.index(10) 5 >>> r[5] 10 >>> r[:5] range(0, 10, 2) >>> r[-1] 18 ``` 使用 `==` 和 `!=` 檢測 range 對象是否相等是將其作為序列來比較。也就是說，如果兩個 range 對象表示相同的值序列就認為它們是相等的。（請注意比較結果相等的兩個 range 對象可能會具有不同的 [`start`](#range.start "range.start"), [`stop`](#range.stop "range.stop") 和 [`step`](#range.step "range.step") 屬性，例如 `range(0) == range(2, 1, 3)` 而 `range(0, 3, 2) == range(0, 4, 2)`。）在 3.2 版更改: 實現 Sequence ABC。支持切片和負數索引。使用 [`int`](functions.xhtml#int "int") 對象在固定時間內進行成員檢測，而不是逐一迭代所有項。在 3.3 版更改: 定義 '==' 和 '!=' 以根據 range 對象所定義的值序列來進行比較（而不是根據對象的標識）。 3\.3 新版功能: [`start`](#range.start "range.start"), [`stop`](#range.stop "range.stop") 和 [`step`](#range.step "range.step") 屬性。參見 - [linspace recipe](http://code.activestate.com/recipes/579000/) \[http://code.activestate.com/recipes/579000/\] 演示了如何實現一個延遲求值版本的適合浮點數應用的 range 對象。 ## 文本序列類型 --- [`str`](#str "str") 在 Python 中處理文本數據是使用 [`str`](#str "str") 對象，也稱為 *字符串*。字符串是由 Unicode 碼位構成的不可變 [序列](#typesseq)。字符串字面值有多種不同的寫法： - 單引號: `'允許包含有 "雙" 引號'` - 雙引號: `"允許包含有 '單' 引號"`。 - 三重引號: `'''三重單引號'''`, `"""三重雙引號"""` 使用三重引號的字符串可以跨越多行 —— 其中所有的空白字符都將包含在該字符串字面值中。作為單一表達式組成部分，之間只由空格分隔的多個字符串字面值會被隱式地轉換為單個字符串字面值。也就是說，`("spam " "eggs") == "spam eggs"`。請參閱 [字符串和字節串字面值](../reference/lexical_analysis.xhtml#strings) 有解有關不同字符串字面值的更多信息，包括所支持的轉義序列，以及使用 `r` ("raw") 前綴來禁用大多數轉義序列的處理。字符串也可以通過使用 [`str`](#str "str") 構造器從其他對象創建。由于不存在單獨的“字符”類型，對字符串做索引操作將產生一個長度為 1 的字符串。也就是說，對于一個非空字符串 *s*, `s[0] == s[0:1]`。不存在可變的字符串類型，但是 [`str.join()`](#str.join "str.join") 或 [`io.StringIO`](io.xhtml#io.StringIO "io.StringIO") 可以被被用來根據多個片段高效率地構建字符串。在 3.3 版更改: 為了與 Python 2 系列的向下兼容，再次允許字符串字面值使用 `u` 前綴。它對字符串字面值的含義沒有影響，并且不能與 `r` 前綴同時出現。 *class* `str`(*object=''*)*class* `str`(*object=b''*, *encoding='utf-8'*, *errors='strict'*)返回 *object* 的 [字符串](#textseq) 版本。如果未提供 *object* 則返回空字符串。在其他情況下 `str()` 的行為取決于 *encoding* 或 *errors* 是否有給出，具體見下。如果 *encoding* 或 *errors* 均未給出，`str(object)` 返回 [`object.__str__()`](../reference/datamodel.xhtml#object.__str__ "object.__str__")，這是 *object* 的“非正式”或格式良好的字符串表示。對于字符串對象，這是該字符串本身。如果 *object* 沒有 [`__str__()`](../reference/datamodel.xhtml#object.__str__ "object.__str__") 方法，則 [`str()`](#str "str") 將回退為返回 [`repr(object)`](functions.xhtml#repr "repr")。如果 *encoding* 或 *errors* 至少給出其中之一，則 *object* 應該是一個 [bytes-like object](../glossary.xhtml#term-bytes-like-object) (例如 [`bytes`](#bytes "bytes") 或 [`bytearray`](#bytearray "bytearray"))。在此情況下，如果 *object* 是一個 [`bytes`](#bytes "bytes") (或 [`bytearray`](#bytearray "bytearray")) 對象，則 `str(bytes, encoding, errors)` 等價于 [`bytes.decode(encoding, errors)`](#bytes.decode "bytes.decode")。否則的話，會在調用 [`bytes.decode()`](#bytes.decode "bytes.decode") 之前獲取緩沖區對象下層的 bytes 對象。請參閱 [二進制序列類型 --- bytes, bytearray, memoryview](#binaryseq) 與 [緩沖協議](../c-api/buffer.xhtml#bufferobjects) 了解有關緩沖區對象的信息。將一個 [`bytes`](#bytes "bytes") 對象傳入 [`str()`](#str "str") 而不給出 *encoding* 或 *errors* 參數的操作屬于第一種情況，將返回非正式的字符串表示（另請參閱 Python 的 [`-b`](../using/cmdline.xhtml#cmdoption-b) 命令行選項）。例如: ``` >>> str(b'Zoot!') "b'Zoot!'" ``` 有關 `str` 類及其方法的更多信息，請參閱下面的 [文本序列類型 --- str](#textseq) 和 [字符串的方法](#string-methods) 小節。要輸出格式化字符串，請參閱 [格式化字符串字面值](../reference/lexical_analysis.xhtml#f-strings) 和 [格式字符串語法](string.xhtml#formatstrings) 小節。此外還可以參閱 [文本處理服務](text.xhtml#stringservices) 小節。 ### 字符串的方法字符串實現了所有 [一般](#typesseq-common) 序列的操作，還額外提供了以下列出的一些附加方法。字符串還支持兩種字符串格式化樣式，一種提供了很大程度的靈活性和可定制性 (參閱 [`str.format()`](#str.format "str.format"), [格式字符串語法](string.xhtml#formatstrings) 和 [自定義字符串格式](string.xhtml#string-formatting)) 而另一種是基于 C `printf` 樣式的格式化，它可處理的類型范圍較窄，并且更難以正確使用，但對于它可處理的情況往往會更為快速 ([printf 風格的字符串格式化](#old-string-formatting))。標準庫的 [文本處理服務](text.xhtml#textservices) 部分涵蓋了許多其他模塊，提供各種文本相關工具（例如包含于 [`re`](re.xhtml#module-re "re: Regular expression operations.") 模塊中的正則表達式支持）。 `str.``capitalize`()返回原字符串的副本，其首個字符大寫，其余為小寫。 `str.``casefold`()返回原字符串消除大小寫的副本。消除大小寫的字符串可用于忽略大小寫的匹配。消除大小寫類似于轉為小寫，但是更加徹底一些，因為它會移除字符串中的所有大小寫變化形式。例如，德語小寫字母 `'?'` 相當于 `"ss"`。由于它已經是小寫了，[`lower()`](#str.lower "str.lower") 不會對 `'?'` 做任何改變；而 [`casefold()`](#str.casefold "str.casefold") 則會將其轉換為 `"ss"`。消除大小寫算法的描述請參見 Unicode 標準的 3.13 節。 3\.3 新版功能. `str.``center`(*width*\[, *fillchar*\])返回長度為 *width* 的字符串，原字符串在其正中。使用指定的 *fillchar* 填充兩邊的空位（默認使用 ASCII 空格符）。如果 *width* 小于等于 `len(s)` 則返回原字符串的副本。 `str.``count`(*sub*\[, *start*\[, *end*\]\])反回子字符串 *sub* 在 \[*start*, *end*\] 范圍內非重疊出現的次數。可選參數 *start* 與 *end* 會被解讀為切片表示法。 `str.``encode`(*encoding="utf-8"*, *errors="strict"*)返回原字符串編碼為字節串對象的版本。默認編碼為 `'utf-8'`。可以給出 *errors* 來設置不同的錯誤處理方案。 *errors* 的默認值為 `'strict'`，表示編碼錯誤會引發 [`UnicodeError`](exceptions.xhtml#UnicodeError "UnicodeError")。其他可用的值為 `'ignore'`, `'replace'`, `'xmlcharrefreplace'`, `'backslashreplace'` 以及任何其他通過 [`codecs.register_error()`](codecs.xhtml#codecs.register_error "codecs.register_error") 注冊的值，請參閱 [Error Handlers](codecs.xhtml#error-handlers) 小節。要查看可用的編碼列表，請參閱 [標準編碼](codecs.xhtml#standard-encodings) 小節。在 3.1 版更改: 加入了對關鍵字參數的支持。 `str.``endswith`(*suffix*\[, *start*\[, *end*\]\])如果字符串以指定的 *suffix* 結束返回 `True`，否則返回 `False`。 *suffix* 也可以為由多個供查找的后綴構成的元組。如果有可選項 *start*，將從所指定位置開始檢查。如果有可選項 *end*，將在所指定位置停止比較。 `str.``expandtabs`(*tabsize=8*)返回字符串的副本，其中所有的制表符會由一個或多個空格替換，具體取決于當前列位置和給定的制表符寬度。每 *tabsize* 個字符設為一個制表位（默認值 8 時設定的制表位在列 0, 8, 16 依次類推）。要展開字符串，當前列將被設為零并逐一檢查字符串中的每個字符。如果字符為制表符 (`\t`)，則會在結果中插入一個或多個空格符，直到當前列等于下一個制表位。（制表符本身不會被復制。）如果字符為換行符 (`\n`) 或回車符 (`\r`)，它會被復制并將當前列重設為零。任何其他字符會被不加修改地復制并將當前列加一，不論該字符在被打印時會如何顯示。 ``` >>> '01\t012\t0123\t01234'.expandtabs() '01 012 0123 01234' >>> '01\t012\t0123\t01234'.expandtabs(4) '01 012 0123 01234' ``` `str.``find`(*sub*\[, *start*\[, *end*\]\])返回子字符串 *sub* 在 `s[start:end]` 切片內被找到的最小索引。可選參數 *start* 與 *end* 會被解讀為切片表示法。如果 *sub* 未被找到則返回 `-1`。注解 [`find()`](#str.find "str.find") 方法應該只在你需要知道 *sub* 所在位置時使用。要檢查 *sub* 是否為子字符串，請使用 [`in`](../reference/expressions.xhtml#in) 操作符: ``` >>> 'Py' in 'Python' True ``` `str.``format`(*\*args*, *\*\*kwargs*)執行字符串格式化操作。調用此方法的字符串可以包含字符串字面值或者以花括號 `{}` 括起來的替換域。每個替換域可以包含一個位置參數的數字索引，或者一個關鍵字參數的名稱。返回的字符串副本中每個替換域都會被替換為對應參數的字符串值。 ``` >>> "The sum of 1 + 2 is {0}".format(1+2) 'The sum of 1 + 2 is 3' ``` 請參閱 [格式字符串語法](string.xhtml#formatstrings) 了解有關可以在格式字符串中指定的各種格式選項的說明。注解當使用 `n` 類型 (例如: `'{:n}'.format(1234)`) 來格式化數字 ([`int`](functions.xhtml#int "int"), [`float`](functions.xhtml#float "float"), [`complex`](functions.xhtml#complex "complex"), [`decimal.Decimal`](decimal.xhtml#decimal.Decimal "decimal.Decimal") 及其子類) 的時候，該函數會臨時性地將 `LC_CTYPE` 區域設置為 `LC_NUMERIC` 區域以解碼 `localeconv()` 的 `decimal_point` 和 `thousands_sep` 字段，如果它們是非 ASCII 字符或長度超過 1 字節的話，并且 `LC_NUMERIC` 區域會與 `LC_CTYPE` 區域不一致。這個臨時更改會影響其他線程。在 3.7 版更改: 當使用 `n` 類型格式化數字時，該函數在某些情況下會臨時性地將 `LC_CTYPE` 區域設置為 `LC_NUMERIC` 區域。 `str.``format_map`(*mapping*)類似于 `str.format(**mapping)`，不同之處在于 `mapping` 會被直接使用而不是復制到一個 [`dict`](#dict "dict")。適宜使用此方法的一個例子是當 `mapping` 為 dict 的子類的情況： ``` >>> class Default(dict): ... def __missing__(self, key): ... return key ... >>> '{name} was born in {country}'.format_map(Default(name='Guido')) 'Guido was born in country' ``` 3\.2 新版功能. `str.``index`(*sub*\[, *start*\[, *end*\]\])類似于 [`find()`](#str.find "str.find")，但在找不到子類時會引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。 `str.``isalnum`()如果字符串中至少有一個字符且所有字符均為字母或數字則返回真值，否則返回假值。如果以下方法中的一個返回 `True` 則字符 `c` 為字母或數字: `c.isalpha()`, `c.isdecimal()`, `c.isdigit()`, or `c.isnumeric()`。 `str.``isalpha`()如果字符串中至少有一個字符且所有字符均為字母則返回真值，否則返回假值。字母類字符是在 Unicode 字符數據庫中被定義為 "Letter" 的字符，即一般分類特征屬性為 "Lm", "Lt", "Lu", "Ll" 或 "Lo" 其中之一。請注意這不同于 Unicode 標準所定義的 "Alphabetic" 特征屬性。 `str.``isascii`()如果字符串為空或所有字符均為 ASCII 字符則返回真值，否則返回假值。 ASCII 字符的碼位范圍為 U+0000-U+007F。 3\.7 新版功能. `str.``isdecimal`()如果字符串中至少有一個字符且所有字符均為十進制數字符則返回真值，否則返回假值。十進制數字符是以 10 為基數的計數制會用來組成數值的字符，例如 U+0660, ARABIC-INDIC DIGIT ZERO。正式的定義為：十進制數字符就是 Unicode 一般分類 "Nd" 中的字符。 `str.``isdigit`()如果字符串中至少有一個字符且所有字符均為數字字符則返回真值，否則返回假值。數字字符包括十進制數字符和需要特別處理的數字，例如兼容性上標數字。這也涵蓋了不能被用來組成以 10 為基數的數值的數字，例如 Kharosthi 數字。正式的定義為：數字字符就是特征屬性值 Numeric\_Type=Digit 或 Numeric\_Type=Decimal 的字符。 `str.``isidentifier`()如果字符串根據語言定義屬于有效的標識符則返回真值，參見 [標識符和關鍵字](../reference/lexical_analysis.xhtml#identifiers)。請使用 [`keyword.iskeyword()`](keyword.xhtml#keyword.iskeyword "keyword.iskeyword") 來檢測保留標識符，例如 [`def`](../reference/compound_stmts.xhtml#def) 和 [`class`](../reference/compound_stmts.xhtml#class)。 `str.``islower`()如果字符串中至少有一個區分大小寫的字符 [4](#id15) 且此類字符均為小寫則返回真值，否則返回假值。 `str.``isnumeric`()如果字符串中至少有一個字符且所有字符均為數值字符則返回真值，否則返回假值。數值字符包括數字字符，以及所有在 Unicode 中設置了數值特性屬性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。正式的定義為：數值字符就是具有特征屬性值 Numeric\_Type=Digit, Numeric\_Type=Decimal 或 Numeric\_Type=Numeric 的字符。 `str.``isprintable`()如果字符串中所有字符均為可打印字符或字符串為空則返回真值，否則返回假值。不可打印字符是在 Unicode 字符數據庫中被定義為 "Other" 或 "Separator" 的字符，例外情況是 ASCII 空格字符 (0x20) 被視作可打印字符。（請注意在此語境下可打印字符是指當對一個字符串發起調用 [`repr()`](functions.xhtml#repr "repr") 時不必被轉義的字符。它們與字符串寫入 [`sys.stdout`](sys.xhtml#sys.stdout "sys.stdout") 或 [`sys.stderr`](sys.xhtml#sys.stderr "sys.stderr") 時所需的處理無關。） `str.``isspace`()如果字符串中至少有一個字符且所有字符均為空白字符則返回真值，否則返回假值。空白字符是在 Unicode 字符數據庫中被定義為 "Other" 或 "Separator" 并且其雙向特征屬性為 "WS", "B" 或 "S" 之一的字符。 `str.``istitle`()如果字符串中至少有一個字符且為標題字符串則返回真值，例如大寫字符之后只能帶非大寫字符而小寫字符必須有大寫字符打頭。否則返回假值。 `str.``isupper`()如果字符串中至少有一個區分大小寫的字符 [4](#id15) 具此類字符均為大寫則返回真值，否則返回假值。 `str.``join`(*iterable*)返回一個由 *iterable* 中的字符串拼接而成的字符串。如果 *iterable* 中存在任何非字符串值包括 [`bytes`](#bytes "bytes") 對象則會引發 [`TypeError`](exceptions.xhtml#TypeError "TypeError")。調用該方法的字符串將作為元素之間的分隔。 `str.``ljust`(*width*\[, *fillchar*\])返回長度為 *width* 的字符串，原字符串在其中靠左對齊。使用指定的 *fillchar* 填充空位 (默認使用 ASCII 空格符)。如果 *width* 小于等于 `len(s)` 則返回原字符串的副本。 `str.``lower`()返回原字符串的副本，其所有區分大小寫的字符 [4](#id15) 均轉換為小寫。所用轉換小寫算法的描述請參見 Unicode 標準的 3.13 節。 `str.``lstrip`(\[*chars*\])返回原字符串的副本，移除其中的前導字符。 *chars* 參數為指定要移除字符的字符串。如果省略或為 `None`，則 *chars* 參數默認移除空格符。實際上 *chars* 參數并非指定單個前綴；而是會移除參數值的所有組合: ``` >>> ' spacious '.lstrip() 'spacious ' >>> 'www.example.com'.lstrip('cmowz.') 'example.com' ``` *static* `str.``maketrans`(*x*\[, *y*\[, *z*\]\])此靜態方法返回一個可供 [`str.translate()`](#str.translate "str.translate") 使用的轉換對照表。如果只有一個參數，則它必須是一個將 Unicode 碼位序號（整數）或字符（長度為 1 的字符串）映射到 Unicode 碼位序號、（任意長度的）字符串或 `None` 的字典。字符鍵將會被轉換為碼位序號。如果有兩個參數，則它們必須是兩個長度相等的字符串，并且在結果字典中，x 中每個字符將被映射到 y 中相同位置的字符。如果有第三個參數，它必須是一個字符串，其中的字符將在結果中被映射到 `None`。 `str.``partition`(*sep*)在 *sep* 首次出現的位置拆分字符串，返回一個 3 元組，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。如果分隔符未找到，則返回的 3 元組中包含字符本身以及兩個空字符串。 `str.``replace`(*old*, *new*\[, *count*\])返回字符串的副本，其中出現的所有子字符串 *old* 都將被替換為 *new*。如果給出了可選參數 *count*，則只替換前 *count* 次出現。 `str.``rfind`(*sub*\[, *start*\[, *end*\]\])返回子字符串 *sub* 在字符串內被找到的最大（最右）索引，這樣 *sub* 將包含在 `s[start:end]` 當中。可選參數 *start* 與 *end* 會被解讀為切片表示法。如果未找到則返回 `-1`。 `str.``rindex`(*sub*\[, *start*\[, *end*\]\])類似于 [`rfind()`](#str.rfind "str.rfind")，但在子字符串 *sub* 未找到時會引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。 `str.``rjust`(*width*\[, *fillchar*\])返回長度為 *width* 的字符串，原字符串在其中靠右對齊。使用指定的 *fillchar* 填充空位 (默認使用 ASCII 空格符)。如果 *width* 小于等于 `len(s)` 則返回原字符串的副本。 `str.``rpartition`(*sep*)在 *sep* 最后一次出現的位置拆分字符串，返回一個 3 元組，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。如果分隔符未找到，則返回的 3 元組中包含兩個空字符串以及字符串本身。 `str.``rsplit`(*sep=None*, *maxsplit=-1*)返回一個由字符串內單詞組成的列表，使用 *sep* 作為分隔字符串。如果給出了 *maxsplit*，則最多進行 *maxsplit* 次拆分，從 *最右邊* 開始。如果 *sep* 未指定或為 `None`，任何空白字符串都會被作為分隔符。除了從右邊開始拆分，[`rsplit()`](#str.rsplit "str.rsplit") 的其他行為都類似于下文所述的 [`split()`](#str.split "str.split")。 `str.``rstrip`(\[*chars*\])返回原字符串的副本，移除其中的末尾字符。 *chars* 參數為指定要移除字符的字符串。如果省略或為 `None`，則 *chars* 參數默認移除空格符。實際上 *chars* 參數并非指定單個后綴；而是會移除參數值的所有組合: ``` >>> ' spacious '.rstrip() ' spacious' >>> 'mississippi'.rstrip('ipz') 'mississ' ``` `str.``split`(*sep=None*, *maxsplit=-1*)返回一個由字符串內單詞組成的列表，使用 *sep* 作為分隔字符串。如果給出了 *maxsplit*，則最多進行 *maxsplit* 次拆分（因此，列表最多會有 `maxsplit+1` 個元素）。如果 *maxsplit* 未指定或為 `-1`，則不限制拆分次數（進行所有可能的拆分）。如果給出了 *sep*，則連續的分隔符不會被組合在一起而是被視為分隔空字符串 (例如 `'1,,2'.split(',')` 將返回 `['1', '', '2']`)。 *sep* 參數可能由多個字符組成 (例如 `'1<>2<>3'.split('<>')` 將返回 `['1', '2', '3']`)。使用指定的分隔符拆分空字符串將返回 `['']`。例如: ``` >>> '1,2,3'.split(',') ['1', '2', '3'] >>> '1,2,3'.split(',', maxsplit=1) ['1', '2,3'] >>> '1,2,,3,'.split(',') ['1', '2', '', '3', ''] ``` 如果 *sep* 未指定或為 `None`，則會應用另一種拆分算法：連續的空格會被視為單個分隔符，其結果將不包含開頭或末尾的空字符串，如果字符串包含前綴或后綴空格的話。因此，使用 `None` 拆分空字符串或僅包含空格的字符串將返回 `[]`。例如: ``` >>> '1 2 3'.split() ['1', '2', '3'] >>> '1 2 3'.split(maxsplit=1) ['1', '2 3'] >>> ' 1 2 3 '.split() ['1', '2', '3'] ``` `str.``splitlines`(\[*keepends*\])返回由原字符串中各行組成的列表，在行邊界的位置拆分。結果列表中不包含行邊界，除非給出了 *keepends* 且為真值。此方法會以下列行邊界進行拆分。特別地，行邊界是 [universal newlines](../glossary.xhtml#term-universal-newlines) 的一個超集。表示符描述 `\n` 換行 `\r` 回車 `\r\n` 回車 + 換行 `\v` 或 `\x0b` 行制表符 `\f` 或 `\x0c` 換表單 `\x1c` 文件分隔符 `\x1d` 組分隔符 `\x1e` 記錄分隔符 `\x85` 下一行 (C1 控制碼) `\u2028` 行分隔符 `\u2029` 段分隔符在 3.2 版更改: `\v` 和 `\f` 被添加到行邊界列表例如: ``` >>> 'ab c\n\nde fg\rkl\r\n'.splitlines() ['ab c', '', 'de fg', 'kl'] >>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True) ['ab c\n', '\n', 'de fg\r', 'kl\r\n'] ``` 不同于 [`split()`](#str.split "str.split")，當給出了分隔字符串 *sep* 時，對于空字符串此方法將返回一個空列表，而末尾的換行不會令結果中增加額外的行: ``` >>> "".splitlines() [] >>> "One line\n".splitlines() ['One line'] ``` 作為比較，`split('\n')` 的結果為: ``` >>> ''.split('\n') [''] >>> 'Two lines\n'.split('\n') ['Two lines', ''] ``` `str.``startswith`(*prefix*\[, *start*\[, *end*\]\])如果字符串以指定的 *prefix* 開始則返回 `True`，否則返回 `False`。 *prefix* 也可以為由多個供查找的前綴構成的元組。如果有可選項 *start*，將從所指定位置開始檢查。如果有可選項 *end*，將在所指定位置停止比較。 `str.``strip`(\[*chars*\])返回原字符串的副本，移除其中的前導和末尾字符。 *chars* 參數為指定要移除字符的字符串。如果省略或為 `None`，則 *chars* 參數默認移除空格符。實際上 *chars* 參數并非指定單個前綴或后綴；而是會移除參數值的所有組合: ``` >>> ' spacious '.strip() 'spacious' >>> 'www.example.com'.strip('cmowz.') 'example' ``` 最外側的前導和末尾 *chars* 參數值將從字符串中移除。開頭端的字符的移除將在遇到一個未包含于 *chars* 所指定字符集的字符時停止。類似的操作也將在結尾端發生。例如: ``` >>> comment_string = '#....... Section 3.2.1 Issue #32 .......' >>> comment_string.strip('.#! ') 'Section 3.2.1 Issue #32' ``` `str.``swapcase`()返回原字符串的副本，其中大寫字符轉換為小寫，反之亦然。請注意 `s.swapcase().swapcase() == s` 并不一定為真值。 `str.``title`()返回原字符串的標題版本，其中每個單詞第一個字母為大寫，其余字母為小寫。例如: ``` >>> 'Hello world'.title() 'Hello World' ``` 該算法使用一種簡單的與語言無關的定義，將連續的字母組合視為單詞。該定義在多數情況下都很有效，但它也意味著代表縮寫形式與所有格的撇號也會成為單詞邊界，這可能導致不希望的結果: ``` >>> "they're bill's friends from the UK".title() "They'Re Bill'S Friends From The Uk" ``` 可以使用正則表達式來構建針對撇號的特別處理: ``` >>> import re >>> def titlecase(s): ... return re.sub(r"[A-Za-z]+('[A-Za-z]+)?", ... lambda mo: mo.group(0)[0].upper() + ... mo.group(0)[1:].lower(), ... s) ... >>> titlecase("they're bill's friends.") "They're Bill's Friends." ``` `str.``translate`(*table*)返回原字符串的副本，其中每個字符按給定的轉換表進行映射。轉換表必須是一個使用 [`__getitem__()`](../reference/datamodel.xhtml#object.__getitem__ "object.__getitem__") 來實現索引操作的對象，通常為 [mapping](../glossary.xhtml#term-mapping) 或 [sequence](../glossary.xhtml#term-sequence)。當以 Unicode 碼位序號（整數）為索引時，轉換表對象可以做以下任何一種操作：返回 Unicode 序號或字符串，將字符映射為一個或多個字符；返回 `None`，將字符從結果字符串中刪除；或引發 [`LookupError`](exceptions.xhtml#LookupError "LookupError") 異常，將字符映射為其自身。你可以使用 [`str.maketrans()`](#str.maketrans "str.maketrans") 基于不同格式的字符到字符映射來創建一個轉換映射表。另請參閱 [`codecs`](codecs.xhtml#module-codecs "codecs: Encode and decode data and streams.") 模塊以了解定制字符映射的更靈活方式。 `str.``upper`()返回原字符串的副本，其中所有區分大小寫的字符 [4](#id15) 均轉換為大寫。請注意如果 `s` 包含不區分大小寫的字符或者如果結果字符的 Unicode 類別不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 則 `s.upper().isupper()` 有可能為 `False`。所用轉換大寫算法的描述請參見 Unicode 標準的 3.13 節。 `str.``zfill`(*width*)返回原字符串的副本，在左邊填充 ASCII `'0'` 數碼使其長度變為 *width*。正負值前綴 (`'+'`/`'-'`) 的處理方式是在正負符號 *之后* 填充而非在之前。如果 *width* 小于等于 `len(s)` 則返回原字符串的副本。例如: ``` >>> "42".zfill(5) '00042' >>> "-42".zfill(5) '-0042' ``` ### `printf` 風格的字符串格式化注解此處介紹的格式化操作具有多種怪異特性，可能導致許多常見錯誤（例如無法正確顯示元組和字典）。使用較新的 [格式化字符串字面值](../reference/lexical_analysis.xhtml#f-strings)，[`str.format()`](#str.format "str.format") 接口或 [模板字符串](string.xhtml#template-strings) 有助于避免這樣的錯誤。這些替代方案中的每一種都更好地權衡并提供了簡單、靈活以及可擴展性優勢。字符串具有一種特殊的內置操作：使用 `%` (取模) 運算符。這也被稱為字符串的 *格式化* 或 *插值* 運算符。對于 `format % values` (其中 *format* 為一個字符串)，在 *format* 中的 `%` 轉換標記符將被替換為零個或多個 *values* 條目。其效果類似于在 C 語言中使用 `sprintf()`。如果 *format* 要求一個單獨參數，則 *values* 可以為一個非元組對象。 [5](#id16) 否則的話，*values* 必須或者是一個包含項數與格式字符串中指定的轉換符項數相同的元組，或者是一個單獨映射對象（例如字典）。轉換標記符包含兩個或更多字符并具有以下組成，且必須遵循此處規定的順序： 1. `'%'` 字符，用于標記轉換符的起始。 2. 映射鍵（可選），由加圓括號的字符序列組成 (例如 `(somename)`)。 3. 轉換旗標（可選），用于影響某些轉換類型的結果。 4. 最小字段寬度（可選）。如果指定為 `'*'` (星號)，則實際寬度會從 *values* 元組的下一元素中讀取，要轉換的對象則為最小字段寬度和可選的精度之后的元素。 5. 精度（可選），以在 `'.'` (點號) 之后加精度值的形式給出。如果指定為 `'*'` (星號)，則實際精度會從 *values* 元組的下一元素中讀取，要轉換的對象則為精度之后的元素。 6. 長度修飾符（可選）。 7. 轉換類型。當右邊的參數為一個字典（或其他映射類型）時，字符串中的格式 *必須* 包含加圓括號的映射鍵，對應 `'%'` 字符之后字典中的每一項。映射鍵將從映射中選取要格式化的值。例如： ``` >>> print('%(language)s has %(number)03d quote types.' % ... {'language': "Python", "number": 2}) Python has 002 quote types. ``` 在此情況下格式中不能出現 `*` 標記符（因其需要一個序列類的參數列表）。轉換旗標為：標志含義 `'#'` 值的轉換將使用“替代形式”（具體定義見下文）。 `'0'` 轉換將為數字值填充零字符。 `'-'` 轉換值將靠左對齊（如果同時給出 `'0'` 轉換，則會覆蓋后者）。 `' '` (空格) 符號位轉換產生的正數（或空字符串）前將留出一個空格。 `'+'` 符號字符 (`'+'` 或 `'-'`) 將顯示于轉換結果的開頭（會覆蓋 "空格" 旗標）。可以給出長度修飾符 (`h`, `l` 或 `L`)，但會被忽略，因為對 Python 來說沒有必要 -- 所以 `%ld` 等價于 `%d`。轉換類型為：轉換符含義注釋 `'d'` 有符號十進制整數。 `'i'` 有符號十進制整數。 `'o'` 有符號八進制數。 (1) `'u'` 過時類型 -- 等價于 `'d'`。 (6) `'x'` 有符號十六進制數（小寫）。 (2) `'X'` 有符號十六進制數（大寫）。 (2) `'e'` 浮點指數格式（小寫）。 (3) `'E'` 浮點指數格式（大寫）。 (3) `'f'` 浮點十進制格式。 (3) `'F'` 浮點十進制格式。 (3) `'g'` 浮點格式。如果指數小于 -4 或不小于精度則使用小寫指數格式，否則使用十進制格式。 (4) `'G'` 浮點格式。如果指數小于 -4 或不小于精度則使用大寫指數格式，否則使用十進制格式。 (4) `'c'` 單個字符（接受整數或單個字符的字符串）。 `'r'` 字符串（使用 [`repr()`](functions.xhtml#repr "repr") 轉換任何 Python 對象）。 (5) `'s'` 字符串（使用 [`str()`](#str "str") 轉換任何 Python 對象）。 (5) `'a'` 字符串（使用 [`ascii()`](functions.xhtml#ascii "ascii") 轉換任何 Python 對象）。 (5) `'%'` 不轉換參數，在結果中輸出一個 `'%'` 字符。注釋: 1. 此替代形式會在第一個數碼之前插入標示八進制數的前綴 (`'0o'`)。 2. 此替代形式會在第一個數碼之前插入 `'0x'` 或 `'0X'` 前綴（取決于是使用 `'x'` 還是 `'X'` 格式）。 3. 此替代形式總是會在結果中包含一個小數點，即使其后并沒有數碼。小數點后的數碼位數由精度決定，默認為 6。 4. 此替代形式總是會在結果中包含一個小數點，末尾各位的零不會如其他情況下那樣被移除。小數點前后的有效數碼位數由精度決定，默認為 6。 5. 如果精度為 `N`，輸出將截短為 `N` 個字符。 6. 參見 [**PEP 237**](https://www.python.org/dev/peps/pep-0237) \[https://www.python.org/dev/peps/pep-0237\]。由于 Python 字符串顯式指明長度，`%s` 轉換不會將 `'\0'` 視為字符串的結束。在 3.1 版更改: 絕對值超過 1e50 的 `%f` 轉換不會再被替換為 `%g` 轉換。 ## 二進制序列類型 --- [`bytes`](#bytes "bytes"), [`bytearray`](#bytearray "bytearray"), [`memoryview`](#memoryview "memoryview") 操作二進制數據的核心內置類型是 [`bytes`](#bytes "bytes") 和 [`bytearray`](#bytearray "bytearray")。它們由 [`memoryview`](#memoryview "memoryview") 提供支持，該對象使用 [緩沖區協議](../c-api/buffer.xhtml#bufferobjects) 來訪問其他二進制對象所在內存，不需要創建對象的副本。 [`array`](array.xhtml#module-array "array: Space efficient arrays of uniformly typed numeric values.") 模塊支持高效地存儲基本數據類型，例如 32 位整數和 IEEE754 雙精度浮點值。 ### bytes 對象 bytes 對象是由單個字節構成的不可變序列。由于許多主要二進制協議都基于 ASCII 文本編碼，因此 bytes 對象提供了一些僅在處理 ASCII 兼容數據時可用，并且在許多特性上與字符串對象緊密相關的方法。 *class* `bytes`(\[*source*\[, *encoding*\[, *errors*\]\]\])首先，表示 bytes 字面值的語法與字符串字面值的大致相同，只是添加了一個 `b` 前綴： - 單引號: `b'同樣允許嵌入 "雙" 引號'`。 - 雙引號: `b"同樣允許嵌入 '單' 引號"`。 - 三重引號: `b'''三重單引號'''`, `b"""三重雙引號"""` bytes 字面值中只允許 ASCII 字符（無論源代碼聲明的編碼為何）。任何超出 127 的二進制值必須使用相應的轉義序列形式加入 bytes 字面值。像字符串字面值一樣，bytes 字面值也可以使用 `r` 前綴來禁用轉義序列處理。請參閱 [字符串和字節串字面值](../reference/lexical_analysis.xhtml#strings) 了解有關各種 bytes 字面值形式的詳情，包括所支持的轉義序列。雖然 bytes 字面值和表示法是基于 ASCII 文本的，但 bytes 對象的行為實際上更像是不可變的整數序列，序列中的每個值的大小被限制為 `0 <= x < 256` (如果違反此限制將引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError"))。這種限制是有意設計用以強調以下事實，雖然許多二進制格式都包含基于 ASCII 的元素，可以通過某些面向文本的算法進行有用的操作，但情況對于任意二進制數據來說通常卻并非如此（盲目地將文本處理算法應用于不兼容 ASCII 的二進制數據格式往往將導致數據損壞）。除了字面值形式，bytes 對象還可以通過其他幾種方式來創建： - 指定長度的以零值填充的 bytes 對象: `bytes(10)` - 通過由整數組成的可迭代對象: `bytes(range(20))` - 通過緩沖區協議復制現有的二進制數據: `bytes(obj)` 另請參閱 [bytes](functions.xhtml#func-bytes) 內置類型。由于兩個十六進制數碼精確對應一個字節，因此十六進制數是描述二進制數據的常用格式。相應地，bytes 類型具有從此種格式讀取數據的附加類方法： *classmethod* `fromhex`(*string*)此 [`bytes`](#bytes "bytes") 類方法返回一個解碼給定字符串的 bytes 對象。字符串必須由表示每個字節的兩個十六進制數碼構成，其中的 ASCII 空白符會被忽略。 ``` >>> bytes.fromhex('2Ef0 F1f2 ') b'.\xf0\xf1\xf2' ``` 在 3.7 版更改: [`bytes.fromhex()`](#bytes.fromhex "bytes.fromhex") 現在會忽略所有 ASCII 空白符而不只是空格符。存在一個反向轉換函數，可以將 bytes 對象轉換為對應的十六進制表示。 `hex`()返回一個字符串對象，該對象包含實例中每個字節的兩個十六進制數字。 ``` >>> b'\xf0\xf1\xf2'.hex() 'f0f1f2' ``` 3\.5 新版功能. 由于 bytes 對象是由整數構成的序列（類似于元組），因此對于一個 bytes 對象 *b*，`b[0]` 將為一個整數，而 `b[0:1]` 將為一個長度為 1 的 bytes 對象。（這與文本字符串不同，索引和切片所產生的將都是一個長度為 1 的字符串）。 bytes 對象的表示使用字面值格式 (`b'...'`)，因為它通常都要比像 `bytes([46, 46, 46])` 這樣的格式更好用。你總是可以使用 `list(b)` 將 bytes 對象轉換為一個由整數構成的列表。注解針對 Python 2.x 用戶的說明：在 Python 2.x 系列中，允許 8 位字符串（ 2.x 所提供的最接近內置二進制數據類型的對象）與 Unicode 字符串進行各種隱式轉換。這是為了實現向下兼容的變通做法，以適應 Python 最初只支持 8 位文本而 Unicode 文本是后來才被加入這一事實。在 Python 3.x 中，這些隱式轉換已被取消 —— 8 位二進制數據與 Unicode 文本間的轉換必須顯式地進行，bytes 與字符串對象的比較結果將總是不相等。 ### bytearray 對象 [`bytearray`](#bytearray "bytearray") 對象是 [`bytes`](#bytes "bytes") 對象的可變對應物。 *class* `bytearray`(\[*source*\[, *encoding*\[, *errors*\]\]\])bytearray 對象沒有專屬的字面值語法，它們總是通過調用構造器來創建： - 創建一個空實例: `bytearray()` - 創建一個指定長度的以零值填充的實例: `bytearray(10)` - 通過由整數組成的可迭代對象: `bytearray(range(20))` - 通過緩沖區協議復制現有的二進制數據: `bytearray(b'Hi!')` 由于 bytearray 對象是可變的，該對象除了 [bytes 和 bytearray 操作](#bytes-methods) 中所描述的 bytes 和 bytearray 共有操作之外，還支持 [可變](#typesseq-mutable) 序列操作。另請參見 [bytearray](functions.xhtml#func-bytearray) 內置類型。由于兩個十六進制數碼精確對應一個字節，因此十六進制數是描述二進制數據的常用格式。相應地，bytearray 類型具有從此種格式讀取數據的附加類方法： *classmethod* `fromhex`(*string*)[`bytearray`](#bytearray "bytearray") 類方法返回一個解碼給定字符串的 bytearray 對象。字符串必須由表示每個字節的兩個十六進制數碼構成，其中的 ASCII 空白符會被忽略。 ``` >>> bytearray.fromhex('2Ef0 F1f2 ') bytearray(b'.\xf0\xf1\xf2') ``` 在 3.7 版更改: [`bytearray.fromhex()`](#bytearray.fromhex "bytearray.fromhex") 現在會忽略所有 ASCII 空白符而不只是空格符。存在一個反向轉換函數，可以將 bytearray 對象轉換為對應的十六進制表示。 `hex`()返回一個字符串對象，該對象包含實例中每個字節的兩個十六進制數字。 ``` >>> bytearray(b'\xf0\xf1\xf2').hex() 'f0f1f2' ``` 3\.5 新版功能. 由于 bytearray 對象是由整數構成的序列（類似于列表），因此對于一個 bytearray 對象 *b*，`b[0]` 將為一個整數，而 `b[0:1]` 將為一個長度為 1 的 bytearray 對象。（這與文本字符串不同，索引和切片所產生的將都是一個長度為 1 的字符串）。 bytearray 對象的表示使用 bytes 對象字面值格式 (`bytearray(b'...')`)，因為它通常都要比 `bytearray([46, 46, 46])` 這樣的格式更好用。你總是可以使用 `list(b)` 將 bytearray 對象轉換為一個由整數構成的列表。 ### bytes 和 bytearray 操作 bytes 和 bytearray 對象都支持 [通用](#typesseq-common) 序列操作。它們不僅能與相同類型的操作數，也能與任何 [bytes-like object](../glossary.xhtml#term-bytes-like-object) 進行互操作。由于這樣的靈活性，它們可以在操作中自由地混合而不會導致錯誤。但是，操作結果的返回值類型可能取決于操作數的順序。注解 bytes 和 bytearray 對象的方法不接受字符串作為其參數，就像字符串的方法不接受 bytes 對象作為其參數一樣。例如，你必須使用以下寫法: ``` a = "abc" b = a.replace("a", "f") ``` 和: ``` a = b"abc" b = a.replace(b"a", b"f") ``` 某些 bytes 和 bytearray 操作假定使用兼容 ASCII 的二進制格式，因此在處理任意二進數數據時應當避免使用。這些限制會在下文中說明。注解使用這些基于 ASCII 的操作來處理未以基于 ASCII 的格式存儲的二進制數據可能會導致數據損壞。 bytes 和 bytearray 對象的下列方法可以用于任意二進制數據。 `bytes.``count`(*sub*\[, *start*\[, *end*\]\])`bytearray.``count`(*sub*\[, *start*\[, *end*\]\])返回子序列 *sub* 在 \[*start*, *end*\] 范圍內非重疊出現的次數。可選參數 *start* 與 *end* 會被解讀為切片表示法。要搜索的子序列可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object) 或是 0 至 255 范圍內的整數。在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。 `bytes.``decode`(*encoding="utf-8"*, *errors="strict"*)`bytearray.``decode`(*encoding="utf-8"*, *errors="strict"*)返回從給定 bytes 解碼出來的字符串。默認編碼為 `'utf-8'`。可以給出 *errors* 來設置不同的錯誤處理方案。 *errors* 的默認值為 `'strict'`，表示編碼錯誤會引發 [`UnicodeError`](exceptions.xhtml#UnicodeError "UnicodeError")。其他可用的值為 `'ignore'`, `'replace'` 以及任何其他通過 [`codecs.register_error()`](codecs.xhtml#codecs.register_error "codecs.register_error") 注冊的名稱，請參閱 [Error Handlers](codecs.xhtml#error-handlers) 小節。要查看可用的編碼列表，請參閱 [標準編碼](codecs.xhtml#standard-encodings) 小節。注解將 *encoding* 參數傳給 [`str`](#str "str") 允許直接解碼任何 [bytes-like object](../glossary.xhtml#term-bytes-like-object)，無須創建臨時的 bytes 或 bytearray 對象。在 3.1 版更改: 加入了對關鍵字參數的支持。 `bytes.``endswith`(*suffix*\[, *start*\[, *end*\]\])`bytearray.``endswith`(*suffix*\[, *start*\[, *end*\]\])如果二進制數據以指定的 *suffix* 結束則返回 `True`，否則返回 `False`。 *suffix* 也可以為由多個供查找的后綴構成的元組。如果有可選項 *start*，將從所指定位置開始檢查。如果有可選項 *end*，將在所指定位置停止比較。要搜索的后綴可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object)。 `bytes.``find`(*sub*\[, *start*\[, *end*\]\])`bytearray.``find`(*sub*\[, *start*\[, *end*\]\])返回子序列 *sub* 在數據中被找到的最小索引，*sub* 包含于切片 `s[start:end]` 之內。可選參數 *start* 與 *end* 會被解讀為切片表示法。如果 *sub* 未被找到則返回 `-1`。要搜索的子序列可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object) 或是 0 至 255 范圍內的整數。注解 [`find()`](#bytes.find "bytes.find") 方法應該只在你需要知道 *sub* 所在位置時使用。要檢查 *sub* 是否為子串，請使用 [`in`](../reference/expressions.xhtml#in) 操作符: ``` >>> b'Py' in b'Python' True ``` 在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。 `bytes.``index`(*sub*\[, *start*\[, *end*\]\])`bytearray.``index`(*sub*\[, *start*\[, *end*\]\])類似于 [`find()`](#bytes.find "bytes.find")，但在找不到子序列時會引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。要搜索的子序列可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object) 或是 0 至 255 范圍內的整數。在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。 `bytes.``join`(*iterable*)`bytearray.``join`(*iterable*)返回一個由 *iterable* 中的二進制數據序列拼接而成的 bytes 或 bytearray 對象。如果 *iterable* 中存在任何非 [字節類對象](../glossary.xhtml#term-bytes-like-object) 包括存在 [`str`](#str "str") 對象值則會引發 [`TypeError`](exceptions.xhtml#TypeError "TypeError")。提供該方法的 bytes 或 bytearray 對象的內容將作為元素之間的分隔。 *static* `bytes.``maketrans`(*from*, *to*)*static* `bytearray.``maketrans`(*from*, *to*)此靜態方法返回一個可用于 [`bytes.translate()`](#bytes.translate "bytes.translate") 的轉換對照表，它將把 *from* 中的每個字符映射為 *to* 中相同位置上的字符；*from* 與 *to* 必須都是 [字節類對象](../glossary.xhtml#term-bytes-like-object) 并且具有相同的長度。 3\.1 新版功能. `bytes.``partition`(*sep*)`bytearray.``partition`(*sep*)在 *sep* 首次出現的位置拆分序列，返回一個 3 元組，其中包含分隔符之前的部分、分隔符本身或其 bytearray 副本，以及分隔符之后的部分。如果分隔符未找到，則返回的 3 元組中包含原序列以及兩個空的 bytes 或 bytearray 對象。要搜索的分隔符可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object)。 `bytes.``replace`(*old*, *new*\[, *count*\])`bytearray.``replace`(*old*, *new*\[, *count*\])返回序列的副本，其中出現的所有子序列 *old* 都將被替換為 *new*。如果給出了可選參數 *count*，則只替換前 *count* 次出現。要搜索的子序列及其替換序列可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object)。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``rfind`(*sub*\[, *start*\[, *end*\]\])`bytearray.``rfind`(*sub*\[, *start*\[, *end*\]\])返回子序列 *sub* 在序列內被找到的最大（最右）索引，這樣 *sub* 將包含在 `s[start:end]` 當中。可選參數 *start* 與 *end* 會被解讀為切片表示法。如果未找到則返回 `-1`。要搜索的子序列可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object) 或是 0 至 255 范圍內的整數。在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。 `bytes.``rindex`(*sub*\[, *start*\[, *end*\]\])`bytearray.``rindex`(*sub*\[, *start*\[, *end*\]\])類似于 [`rfind()`](#bytes.rfind "bytes.rfind")，但在子序列 *sub* 未找到時會引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError")。要搜索的子序列可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object) 或是 0 至 255 范圍內的整數。在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。 `bytes.``rpartition`(*sep*)`bytearray.``rpartition`(*sep*)在 *sep* 最后一次出現的位置拆分序列，返回一個 3 元組，其中包含分隔符之前的部分，分隔符本身或其 bytearray 副本，以及分隔符之后的部分。如果分隔符未找到，則返回的 3 元組中包含兩個空的 bytes 或 bytearray 對象以及原序列的副本。要搜索的分隔符可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object)。 `bytes.``startswith`(*prefix*\[, *start*\[, *end*\]\])`bytearray.``startswith`(*prefix*\[, *start*\[, *end*\]\])如果二進制數據以指定的 *prefix* 開頭則返回 `True`，否則返回 `False`。 *prefix* 也可以為由多個供查找的前綴構成的元組。如果有可選項 *start*，將從所指定位置開始檢查。如果有可選項 *end*，將在所指定位置停止比較。要搜索的前綴可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object)。 `bytes.``translate`(*table*, *delete=b''*)`bytearray.``translate`(*table*, *delete=b''*)返回原 bytes 或 bytearray 對象的副本，移除其中所有在可選參數 *delete* 中出現的 bytes，其余 bytes 將通過給定的轉換表進行映射，該轉換表必須是長度為 256 的 bytes 對象。你可以使用 [`bytes.maketrans()`](#bytes.maketrans "bytes.maketrans") 方法來創建轉換表。對于僅需移除字符的轉換，請將 *table* 參數設為 `None`: ``` >>> b'read this short text'.translate(None, b'aeiou') b'rd ths shrt txt' ``` 在 3.6 版更改: 現在支持將 *delete* 作為關鍵字參數。以下 bytes 和 bytearray 對象的方法的默認行為會假定使用兼容 ASCII 的二進制格式，但通過傳入適當的參數仍然可用于任意二進制數據。請注意本小節中所有的 bytearray 方法都 *不是* 原地執行操作，而是會產生新的對象。 `bytes.``center`(*width*\[, *fillbyte*\])`bytearray.``center`(*width*\[, *fillbyte*\])返回原對象的副本，在長度為 *width* 的序列內居中，使用指定的 *fillbyte* 填充兩邊的空位（默認使用 ASCII 空格符）。對于 [`bytes`](#bytes "bytes") 對象，如果 *width* 小于等于 `len(s)` 則返回原序列的副本。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``ljust`(*width*\[, *fillbyte*\])`bytearray.``ljust`(*width*\[, *fillbyte*\])反回原對象的副本，在長度為 *width* 的序列中靠左對齊。使用指定的 *fillbyte* 填充空位（默認使用 ASCII 空格符）。對于 [`bytes`](#bytes "bytes") 對象，如果 *width* 小于等于 `len(s)` 則返回原序列的副本。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``lstrip`(\[*chars*\])`bytearray.``lstrip`(\[*chars*\])返回原序列的副本，移除指定的前導字節。 *chars* 參數為指定要移除字節值集合的二進制序列 —— 這個名稱表明此方法通常是用于 ASCII 字符。如果省略或為 `None`，則 *chars* 參數默認移除 ASCII 空白符。 *chars* 參數并非指定單個前綴；而是會移除參數值的所有組合: ``` >>> b' spacious '.lstrip() b'spacious ' >>> b'www.example.com'.lstrip(b'cmowz.') b'example.com' ``` 要移除的字節值二進制序列可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object)。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``rjust`(*width*\[, *fillbyte*\])`bytearray.``rjust`(*width*\[, *fillbyte*\])返回原對象的副本，在長度為 *width* 的序列中靠右對齊。使用指定的 *fillbyte* 填充空位（默認使用 ASCII 空格符）。對于 [`bytes`](#bytes "bytes") 對象，如果 *width* 小于等于 `len(s)` 則返回原序列的副本。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``rsplit`(*sep=None*, *maxsplit=-1*)`bytearray.``rsplit`(*sep=None*, *maxsplit=-1*)將二進制序列拆分為相同類型的子序列，使用 *sep* 作為分隔符。如果給出了 *maxsplit*，則最多進行 *maxsplit* 次拆分，從 *最右邊* 開始。如果 *sep* 未指定或為 `None`，任何只包含 ASCII 空白符的子序列都會被作為分隔符。除了從右邊開始拆分，[`rsplit()`](#bytearray.rsplit "bytearray.rsplit") 的其他行為都類似于下文所述的 [`split()`](#bytearray.split "bytearray.split")。 `bytes.``rstrip`(\[*chars*\])`bytearray.``rstrip`(\[*chars*\])返回原序列的副本，移除指定的末尾字節。 *chars* 參數為指定要移除字節值集合的二進制序列 —— 這個名稱表明此方法通常是用于 ASCII 字符。如果省略或為 `None`，則 *chars* 參數默認移除 ASCII 空白符。 *chars* 參數并非指定單個后綴；而是會移除參數值的所有組合: ``` >>> b' spacious '.rstrip() b' spacious' >>> b'mississippi'.rstrip(b'ipz') b'mississ' ``` 要移除的字節值二進制序列可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object)。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``split`(*sep=None*, *maxsplit=-1*)`bytearray.``split`(*sep=None*, *maxsplit=-1*)將二進制序列拆分為相同類型的子序列，使用 *sep* 作為分隔符。如果給出了 *maxsplit* 且非負值，則最多進行 *maxsplit* 次拆分（因此，列表最多會有 `maxsplit+1` 個元素）。如果 *maxsplit* 未指定或為 `-1`，則不限制拆分次數（進行所有可能的拆分）。如果給出了 *sep*，則連續的分隔符不會被組合在一起而是被視為分隔空子序列 (例如 `b'1,,2'.split(b',')` 將返回 `[b'1', b'', b'2']`)。 *sep* 參數可能為一個多字節序列 (例如 `b'1<>2<>3'.split(b'<>')` 將返回 `[b'1', b'2', b'3']`)。使用指定的分隔符拆分空序列將返回 `[b'']` 或 `[bytearray(b'')]`，具體取決于被拆分對象的類型。 *sep* 參數可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object)。例如: ``` >>> b'1,2,3'.split(b',') [b'1', b'2', b'3'] >>> b'1,2,3'.split(b',', maxsplit=1) [b'1', b'2,3'] >>> b'1,2,,3,'.split(b',') [b'1', b'2', b'', b'3', b''] ``` 如果 *sep* 未指定或為 `None`，則會應用另一種拆分算法：連續的 ASCII 空白符會被視為單個分隔符，其結果將不包含序列開頭或末尾的空白符。因此，在不指定分隔符的情況下對空序列或僅包含 ASCII 空白符的序列進行拆分將返回 `[]`。例如: ``` >>> b'1 2 3'.split() [b'1', b'2', b'3'] >>> b'1 2 3'.split(maxsplit=1) [b'1', b'2 3'] >>> b' 1 2 3 '.split() [b'1', b'2', b'3'] ``` `bytes.``strip`(\[*chars*\])`bytearray.``strip`(\[*chars*\])返回原序列的副本，移除指定的開頭和末尾字節。 *chars* 參數為指定要移除字節值集合的二進制序列 —— 這個名稱表明此方法通常是用于 ASCII 字符。如果省略或為 `None`，則 *chars* 參數默認移除 ASCII 空白符。 *chars* 參數并非指定單個前綴或后綴；而是會移除參數值的所有組合: ``` >>> b' spacious '.strip() b'spacious' >>> b'www.example.com'.strip(b'cmowz.') b'example' ``` 要移除的字節值二進制序列可以是任意 [bytes-like object](../glossary.xhtml#term-bytes-like-object)。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。以下 bytes 和 bytearray 對象的方法會假定使用兼容 ASCII 的二進制格式，不應當被應用于任意二進制數據。請注意本小節中所有的 bytearray 方法都 *不是* 原地執行操作，而是會產生新的對象。 `bytes.``capitalize`()`bytearray.``capitalize`()返回原序列的副本，其中每個字節將都將被解讀為一個 ASCII 字符，并且第一個字節的字符大寫而其余的小寫。非 ASCII 字節值將保持原樣不變。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``expandtabs`(*tabsize=8*)`bytearray.``expandtabs`(*tabsize=8*)返回序列的副本，其中所有的 ASCII 制表符會由一個或多個 ASCII 空格替換，具體取決于當前列位置和給定的制表符寬度。每 *tabsize* 個字節設為一個制表位（默認值 8 時設定的制表位在列 0, 8, 16 依次類推）。要展開序列，當前列位置將被設為零并逐一檢查序列中的每個字節。如果字節為 ASCII 制表符 (`b'\t'`)，則并在結果中插入一個或多個空格符，直到當前列等于下一個制表位。（制表符本身不會被復制。）如果當前字節為 ASCII 換行符 (`b'\n'`) 或回車符 (`b'\r'`)，它會被復制并將當前列重設為零。任何其他字節會被不加修改地復制并將當前列加一，不論該字節值在被打印時會如何顯示: ``` >>> b'01\t012\t0123\t01234'.expandtabs() b'01 012 0123 01234' >>> b'01\t012\t0123\t01234'.expandtabs(4) b'01 012 0123 01234' ``` 注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``isalnum`()`bytearray.``isalnum`()如果序列中所有字節都是字母類 ASCII 字符或 ASCII 十進制數碼并且序列非空則返回真值，否則返回假值。字母類 ASCII 字符就是字節值包含在序列 `b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'` 中的字符。 ASCII 十進制數碼就是字節值包含在序列 `b'0123456789'` 中的字符。例如: ``` >>> b'ABCabc1'.isalnum() True >>> b'ABC abc1'.isalnum() False ``` `bytes.``isalpha`()`bytearray.``isalpha`()如果序列中所有字節都是字母類 ASCII 字符并且序列非空則返回真值，否則返回假值。字母類 ASCII 字符就是字節值包含在序列 `b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'` 中的字符。例如: ``` >>> b'ABCabc'.isalpha() True >>> b'ABCabc1'.isalpha() False ``` `bytes.``isascii`()`bytearray.``isascii`()如果序列為空或序列中所有字節都是 ASCII 字節則返回真值，否則返回假值。 ASCII 字節的取值范圍是 0-0x7F。 3\.7 新版功能. `bytes.``isdigit`()`bytearray.``isdigit`()如果序列中所有字節都是 ASCII 十進制數碼并且序列非空則返回真值，否則返回假值。 ASCII 十進制數碼就是字節值包含在序列 `b'0123456789'` 中的字符。例如: ``` >>> b'1234'.isdigit() True >>> b'1.23'.isdigit() False ``` `bytes.``islower`()`bytearray.``islower`()如果序列中至少有一個小寫 ASCII 字符并且沒有大寫 ASCII 字符則返回真值，否則返回假值。例如: ``` >>> b'hello world'.islower() True >>> b'Hello world'.islower() False ``` 小寫 ASCII 字符就是字節值包含在序列 `b'abcdefghijklmnopqrstuvwxyz'` 中的字符。大寫 ASCII 字符就是字節值包含在序列 `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` 中的字符。 `bytes.``isspace`()`bytearray.``isspace`()如果序列中所有字節都是 ASCII 空白符并且序列非空則返回真值，否則返回假值。 ASCII 空白符就是字節值包含在序列 `b' \t\n\r\x0b\f'` (空格, 制表, 換行, 回車, 垂直制表, 換頁) 中的字符。 `bytes.``istitle`()`bytearray.``istitle`()如果序列為 ASCII 標題形式并且序列非空則返回真值，否則返回假值。請參閱 [`bytes.title()`](#bytes.title "bytes.title") 了解有關“標題形式”的詳細定義。例如: ``` >>> b'Hello World'.istitle() True >>> b'Hello world'.istitle() False ``` `bytes.``isupper`()`bytearray.``isupper`()如果序列中至少有一個大寫字母 ASCII 字符并且沒有小寫 ASCII 字符則返回真值，否則返回假值。例如: ``` >>> b'HELLO WORLD'.isupper() True >>> b'Hello world'.isupper() False ``` 小寫 ASCII 字符就是字節值包含在序列 `b'abcdefghijklmnopqrstuvwxyz'` 中的字符。大寫 ASCII 字符就是字節值包含在序列 `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` 中的字符。 `bytes.``lower`()`bytearray.``lower`()返回原序列的副本，其所有大寫 ASCII 字符均轉換為對應的小寫形式。例如: ``` >>> b'Hello World'.lower() b'hello world' ``` 小寫 ASCII 字符就是字節值包含在序列 `b'abcdefghijklmnopqrstuvwxyz'` 中的字符。大寫 ASCII 字符就是字節值包含在序列 `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` 中的字符。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``splitlines`(*keepends=False*)`bytearray.``splitlines`(*keepends=False*)返回由原二進制序列中各行組成的列表，在 ASCII 行邊界符的位置拆分。此方法使用 [universal newlines](../glossary.xhtml#term-universal-newlines) 方式來分行。結果列表中不包含換行符，除非給出了 *keepends* 且為真值。例如: ``` >>> b'ab c\n\nde fg\rkl\r\n'.splitlines() [b'ab c', b'', b'de fg', b'kl'] >>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True) [b'ab c\n', b'\n', b'de fg\r', b'kl\r\n'] ``` 不同于 [`split()`](#bytes.split "bytes.split")，當給出了分隔符 *sep* 時，對于空字符串此方法將返回一個空列表，而末尾的換行不會令結果中增加額外的行: ``` >>> b"".split(b'\n'), b"Two lines\n".split(b'\n') ([b''], [b'Two lines', b'']) >>> b"".splitlines(), b"One line\n".splitlines() ([], [b'One line']) ``` `bytes.``swapcase`()`bytearray.``swapcase`()返回原序列的副本，其所有小寫 ASCII 字符均轉換為對應的大寫形式，反之亦反。例如: ``` >>> b'Hello World'.swapcase() b'hELLO wORLD' ``` 小寫 ASCII 字符就是字節值包含在序列 `b'abcdefghijklmnopqrstuvwxyz'` 中的字符。大寫 ASCII 字符就是字節值包含在序列 `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` 中的字符。不同于 [`str.swapcase()`](#str.swapcase "str.swapcase")，在些二進制版本下 `bin.swapcase().swapcase() == bin` 總是成立。大小寫轉換在 ASCII 中是對稱的，即使其對于任意 Unicode 碼位來說并不總是成立。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``title`()`bytearray.``title`()返回原二進制序列的標題版本，其中每個單詞以一個大寫 ASCII 字符為開頭，其余字母為小寫。不區別大小寫的字節值將保持原樣不變。例如: ``` >>> b'Hello world'.title() b'Hello World' ``` 小寫 ASCII 字符就是字節值包含在序列 `b'abcdefghijklmnopqrstuvwxyz'` 中的字符。大寫 ASCII 字符就是字節值包含在序列 `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` 中的字符。所有其他字節值都不區分大小寫。該算法使用一種簡單的與語言無關的定義，將連續的字母組合視為單詞。該定義在多數情況下都很有效，但它也意味著代表縮寫形式與所有格的撇號也會成為單詞邊界，這可能導致不希望的結果: ``` >>> b"they're bill's friends from the UK".title() b"They'Re Bill'S Friends From The Uk" ``` 可以使用正則表達式來構建針對撇號的特別處理: ``` >>> import re >>> def titlecase(s): ... return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?", ... lambda mo: mo.group(0)[0:1].upper() + ... mo.group(0)[1:].lower(), ... s) ... >>> titlecase(b"they're bill's friends.") b"They're Bill's Friends." ``` 注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``upper`()`bytearray.``upper`()返回原序列的副本，其所有小寫 ASCII 字符均轉換為對應的大寫形式。例如: ``` >>> b'Hello World'.upper() b'HELLO WORLD' ``` 小寫 ASCII 字符就是字節值包含在序列 `b'abcdefghijklmnopqrstuvwxyz'` 中的字符。大寫 ASCII 字符就是字節值包含在序列 `b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` 中的字符。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 `bytes.``zfill`(*width*)`bytearray.``zfill`(*width*)返回原序列的副本，在左邊填充 `b'0'` 數碼使序列長度為 *width*。正負值前綴 (`b'+'`/ `b'-'`) 的處理方式是在正負符號 *之后* 填充而非在之前。對于 [`bytes`](#bytes "bytes") 對象，如果 *width* 小于等于 `len(seq)` 則返回原序列。例如: ``` >>> b"42".zfill(5) b'00042' >>> b"-42".zfill(5) b'-0042' ``` 注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。 ### `printf` 風格的字節串格式化注解此處介紹的格式化操作具有多種怪異特性，可能導致許多常見錯誤（例如無法正確顯示元組和字典）。如果要打印的值可能為元組或字典，請將其放入一個元組中。字節串對象 (`bytes`/`bytearray`) 具有一種特殊的內置操作：使用 `%` (取模) 運算符。這也被稱為字節串的 *格式化* 或 *插值* 運算符。對于 `format % values` (其中 *format* 為一個字節串對象)，在 *format* 中的 `%` 轉換標記符將被替換為零個或多個 *values* 條目。其效果類似于在 C 語言中使用 `sprintf()`。如果 *format* 要求一個單獨參數，則 *values* 可以為一個非元組對象。 [5](#id16) 否則的話，*values* 必須或是是一個包含項數與格式字節串對象中指定的轉換符項數相同的元組，或者是一個單獨的映射對象（例如元組）。轉換標記符包含兩個或更多字符并具有以下組成，且必須遵循此處規定的順序： 1. `'%'` 字符，用于標記轉換符的起始。 2. 映射鍵（可選），由加圓括號的字符序列組成 (例如 `(somename)`)。 3. 轉換旗標（可選），用于影響某些轉換類型的結果。 4. 最小字段寬度（可選）。如果指定為 `'*'` (星號)，則實際寬度會從 *values* 元組的下一元素中讀取，要轉換的對象則為最小字段寬度和可選的精度之后的元素。 5. 精度（可選），以在 `'.'` (點號) 之后加精度值的形式給出。如果指定為 `'*'` (星號)，則實際精度會從 *values* 元組的下一元素中讀取，要轉換的對象則為精度之后的元素。 6. 長度修飾符（可選）。 7. 轉換類型。當右邊的參數為一個字典（或其他映射類型）時，字節串對象中的格式 *必須* 包含加圓括號的映射鍵，對應 `'%'` 字符之后字典中的每一項。映射鍵將從映射中選取要格式化的值。例如： ``` >>> print(b'%(language)s has %(number)03d quote types.' % ... {b'language': b"Python", b"number": 2}) b'Python has 002 quote types.' ``` 在此情況下格式中不能出現 `*` 標記符（因其需要一個序列類的參數列表）。轉換旗標為：標志含義 `'#'` 值的轉換將使用“替代形式”（具體定義見下文）。 `'0'` 轉換將為數字值填充零字符。 `'-'` 轉換值將靠左對齊（如果同時給出 `'0'` 轉換，則會覆蓋后者）。 `' '` (空格) 符號位轉換產生的正數（或空字符串）前將留出一個空格。 `'+'` 符號字符 (`'+'` 或 `'-'`) 將顯示于轉換結果的開頭（會覆蓋 "空格" 旗標）。可以給出長度修飾符 (`h`, `l` 或 `L`)，但會被忽略，因為對 Python 來說沒有必要 -- 所以 `%ld` 等價于 `%d`。轉換類型為：轉換符含義注釋 `'d'` 有符號十進制整數。 `'i'` 有符號十進制整數。 `'o'` 有符號八進制數。 (1) `'u'` 過時類型 -- 等價于 `'d'`。 (8) `'x'` 有符號十六進制數（小寫）。 (2) `'X'` 有符號十六進制數（大寫）。 (2) `'e'` 浮點指數格式（小寫）。 (3) `'E'` 浮點指數格式（大寫）。 (3) `'f'` 浮點十進制格式。 (3) `'F'` 浮點十進制格式。 (3) `'g'` 浮點格式。如果指數小于 -4 或不小于精度則使用小寫指數格式，否則使用十進制格式。 (4) `'G'` 浮點格式。如果指數小于 -4 或不小于精度則使用大寫指數格式，否則使用十進制格式。 (4) `'c'` 單個字節（接受整數或單個字節對象）。 `'b'` 字節串（任何遵循 [緩沖區協議](../c-api/buffer.xhtml#bufferobjects) 或是具有 [`__bytes__()`](../reference/datamodel.xhtml#object.__bytes__ "object.__bytes__") 的對象）。 (5) `'s'` `'s'` 是 `'b'` 的一個別名，只應當在基于 Python2/3 的代碼中使用。 (6) `'a'` 字節串（使用 `repr(obj).encode('ascii','backslashreplace)` 轉換任何 Python 對象）。 (5) `'r'` `'r'` 是 `'a'` 的一個別名，只應當在基于 Python2/3 的代碼中使用。 (7) `'%'` 不轉換參數，在結果中輸出一個 `'%'` 字符。注釋: 1. 此替代形式會在第一個數碼之前插入標示八進制數的前綴 (`'0o'`)。 2. 此替代形式會在第一個數碼之前插入 `'0x'` 或 `'0X'` 前綴（取決于是使用 `'x'` 還是 `'X'` 格式）。 3. 此替代形式總是會在結果中包含一個小數點，即使其后并沒有數碼。小數點后的數碼位數由精度決定，默認為 6。 4. 此替代形式總是會在結果中包含一個小數點，末尾各位的零不會如其他情況下那樣被移除。小數點前后的有效數碼位數由精度決定，默認為 6。 5. 如果精度為 `N`，輸出將截短為 `N` 個字符。 6. `b'%s'` 已棄用，但在 3.x 系列中將不會被移除。 7. `b'%r'` 已棄用，但在 3.x 系列中將不會被移除。 8. 參見 [**PEP 237**](https://www.python.org/dev/peps/pep-0237) \[https://www.python.org/dev/peps/pep-0237\]。注解此方法的 bytearray 版本 *并非* 原地操作 —— 它總是產生一個新對象，即便沒有做任何改變。參見 [**PEP 461**](https://www.python.org/dev/peps/pep-0461) \[https://www.python.org/dev/peps/pep-0461\] - 為 bytes 和 bytearray 添加 % 格式化 3\.5 新版功能. ### 內存視圖 [`memoryview`](#memoryview "memoryview") 對象允許 Python 代碼訪問一個對象的內部數據，只要該對象支持 [緩沖區協議](../c-api/buffer.xhtml#bufferobjects) 而無需進行拷貝。 *class* `memoryview`(*obj*)創建一個引用 *obj* 的 [`memoryview`](#memoryview "memoryview")。 *obj* 必須支持緩沖區協議。支持緩沖區協議的內置對象包括 [`bytes`](#bytes "bytes") 和 [`bytearray`](#bytearray "bytearray")。 [`memoryview`](#memoryview "memoryview") 具有 *元素* 的概念，即由原始對象 *obj* 所處理的基本內存單元。對于許多簡單類型例如 [`bytes`](#bytes "bytes") 和 [`bytearray`](#bytearray "bytearray") 來說，一個元素就是一個字節，但是其他的類型例如 [`array.array`](array.xhtml#array.array "array.array") 可能有更大的元素。 `len(view)` 與 [`tolist`](#memoryview.tolist "memoryview.tolist") 的長度相等。如果 `view.ndim = 0`，則其長度為 1。如果 `view.ndim = 1`，則其長度等于 view 中元素的數量。對于更高的維度，其長度等于表示 view 的嵌套列表的長度。 [`itemsize`](#memoryview.itemsize "memoryview.itemsize") 屬性可向你給出單個元素所占的字節數。 [`memoryview`](#memoryview "memoryview") 支持通過切片和索引訪問其元素。一維切片的結果將是一個子視圖: ``` >>> v = memoryview(b'abcefg') >>> v[1] 98 >>> v[-1] 103 >>> v[1:4] <memory at 0x7f3ddc9f4350> >>> bytes(v[1:4]) b'bce' ``` 如果 [`format`](#memoryview.format "memoryview.format") 是一個來自于 [`struct`](struct.xhtml#module-struct "struct: Interpret bytes as packed binary data.") 模塊的原生格式說明符，則也支持使用整數或由整數構成的元組進行索引，并返回具有正確類型的單個 *元素*。一維內存視圖可以使用一個整數或由一個整數構成的元組進行索引。多維內存視圖可以使用由恰好 *ndim* 個整數構成的元素進行索引，*ndim* 即其維度。零維內存視圖可以使用空元組進行索引。這里是一個使用非字節格式的例子: ``` >>> import array >>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444]) >>> m = memoryview(a) >>> m[0] -11111111 >>> m[-1] 44444444 >>> m[::2].tolist() [-11111111, -33333333] ``` 如果下層對象是可寫的，則內存視圖支持一維切片賦值。改變大小則不被允許: ``` >>> data = bytearray(b'abcefg') >>> v = memoryview(data) >>> v.readonly False >>> v[0] = ord(b'z') >>> data bytearray(b'zbcefg') >>> v[1:4] = b'123' >>> data bytearray(b'z123fg') >>> v[2:3] = b'spam' Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: memoryview assignment: lvalue and rvalue have different structures >>> v[2:6] = b'spam' >>> data bytearray(b'z1spam') ``` 由帶有格式符號 'B', 'b' 或 'c' 的可哈希（只讀）類型構成的一維內存視圖同樣是可哈希的。哈希定義為 `hash(m) == hash(m.tobytes())`: ``` >>> v = memoryview(b'abcefg') >>> hash(v) == hash(b'abcefg') True >>> hash(v[2:4]) == hash(b'ce') True >>> hash(v[::-2]) == hash(b'abcefg'[::-2]) True ``` 在 3.3 版更改: 一維內存視圖現在可以被切片。帶有格式符號 'B', 'b' 或 'c' 的一維內存視圖現在是可哈希的。在 3.4 版更改: 內存視圖現在會自動注冊為 [`collections.abc.Sequence`](collections.abc.xhtml#collections.abc.Sequence "collections.abc.Sequence") 在 3.5 版更改: 內存視圖現在可使用整數元組進行索引。 [`memoryview`](#memoryview "memoryview") 具有以下一些方法： `__eq__`(*exporter*)memoryview 與 [**PEP 3118**](https://www.python.org/dev/peps/pep-3118) \[https://www.python.org/dev/peps/pep-3118\] 中的導出器這兩者如果形狀相同，并且如果當使用 [`struct`](struct.xhtml#module-struct "struct: Interpret bytes as packed binary data.") 語法解讀操作數的相應格式代碼時所有對應值都相同，則它們就是等價的。對于 [`tolist()`](#memoryview.tolist "memoryview.tolist") 當前所支持的 [`struct`](struct.xhtml#module-struct "struct: Interpret bytes as packed binary data.") 格式字符串子集，如果 `v.tolist() == w.tolist()` 則 `v` 和 `w` 相等: ``` >>> import array >>> a = array.array('I', [1, 2, 3, 4, 5]) >>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0]) >>> c = array.array('b', [5, 3, 1]) >>> x = memoryview(a) >>> y = memoryview(b) >>> x == a == y == b True >>> x.tolist() == a.tolist() == y.tolist() == b.tolist() True >>> z = y[::-2] >>> z == c True >>> z.tolist() == c.tolist() True ``` 如果兩邊的格式字符串都不被 [`struct`](struct.xhtml#module-struct "struct: Interpret bytes as packed binary data.") 模塊所支持，則兩對象比較結果總是不相等（即使格式字符串和緩沖區內容相同）: ``` >>> from ctypes import BigEndianStructure, c_long >>> class BEPoint(BigEndianStructure): ... _fields_ = [("x", c_long), ("y", c_long)] ... >>> point = BEPoint(100, 200) >>> a = memoryview(point) >>> b = memoryview(point) >>> a == point False >>> a == b False ``` 請注意，與浮點數的情況一樣，對于內存視圖對象來說，`v is w` 也 *并不* 意味著 `v == w`。在 3.3 版更改: 之前的版本比較原始內存時會忽略條目的格式與邏輯數組結構。 `tobytes`()將緩沖區中的數據作為字節串返回。這相當于在內存視圖上調用 [`bytes`](#bytes "bytes") 構造器。 ``` >>> m = memoryview(b"abc") >>> m.tobytes() b'abc' >>> bytes(m) b'abc' ``` 對于非連續數組，結果等于平面化表示的列表，其中所有元素都轉換為字節串。 [`tobytes()`](#memoryview.tobytes "memoryview.tobytes") 支持所有格式字符串，不符合 [`struct`](struct.xhtml#module-struct "struct: Interpret bytes as packed binary data.") 模塊語法的那些也包括在內。 `hex`()返回一個字符串對象，其中分別以兩個十六進制數碼表示緩沖區里的每個字節。 ``` >>> m = memoryview(b"abc") >>> m.hex() '616263' ``` 3\.5 新版功能. `tolist`()將緩沖區內的數據以一個元素列表的形式返回。 ``` >>> memoryview(b'abc').tolist() [97, 98, 99] >>> import array >>> a = array.array('d', [1.1, 2.2, 3.3]) >>> m = memoryview(a) >>> m.tolist() [1.1, 2.2, 3.3] ``` 在 3.3 版更改: [`tolist()`](#memoryview.tolist "memoryview.tolist") 現在支持 [`struct`](struct.xhtml#module-struct "struct: Interpret bytes as packed binary data.") 模塊語法中的所有單字符原生格式以及多維表示形式。 `release`()釋放由內存視圖對象所公開的底層緩沖區。許多對象在被視圖所獲取時都會采取特殊動作（例如，[`bytearray`](#bytearray "bytearray") 將會暫時禁止調整大小）；因此，調用 release() 可以方便地盡早去除這些限制（并釋放任何多余的資源）。在此方法被調用后，任何對視圖的進一步操作將引發 [`ValueError`](exceptions.xhtml#ValueError "ValueError") ([`release()`](#memoryview.release "memoryview.release") 本身除外，它可以被多次調用): ``` >>> m = memoryview(b'abc') >>> m.release() >>> m[0] Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: operation forbidden on released memoryview object ``` 使用 `with` 語句，可以通過上下文管理協議達到類似的效果: ``` >>> with memoryview(b'abc') as m: ... m[0] ... 97 >>> m[0] Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: operation forbidden on released memoryview object ``` 3\.2 新版功能. `cast`(*format*\[, *shape*\])將內存視圖轉化為新的格式或形狀。 *shape* 默認為 `[byte_length//new_itemsize]`，這意味著結果視圖將是一維的。返回值是一個新的內存視圖，但緩沖區本身不會被復制。支持的轉化有 1D -> C-[contiguous](../glossary.xhtml#term-contiguous) 和 C-contiguous -> 1D。目標格式僅限于 [`struct`](struct.xhtml#module-struct "struct: Interpret bytes as packed binary data.") 語法中的單一元素原生格式。其中一種格式必須為字節格式 ('B', 'b' 或 'c')。結果的字節長度必須與原始長度相同。將 1D/long 轉換為 1D/unsigned bytes: ``` >>> import array >>> a = array.array('l', [1,2,3]) >>> x = memoryview(a) >>> x.format 'l' >>> x.itemsize 8 >>> len(x) 3 >>> x.nbytes 24 >>> y = x.cast('B') >>> y.format 'B' >>> y.itemsize 1 >>> len(y) 24 >>> y.nbytes 24 ``` 將 1D/unsigned bytes 轉換為 1D/char: ``` >>> b = bytearray(b'zyz') >>> x = memoryview(b) >>> x[0] = b'a' Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: memoryview: invalid value for format "B" >>> y = x.cast('c') >>> y[0] = b'a' >>> b bytearray(b'ayz') ``` 將 1D/bytes 轉換為 3D/ints 再轉換為 1D/signed char: ``` >>> import struct >>> buf = struct.pack("i"*12, *list(range(12))) >>> x = memoryview(buf) >>> y = x.cast('i', shape=[2,2,3]) >>> y.tolist() [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]] >>> y.format 'i' >>> y.itemsize 4 >>> len(y) 2 >>> y.nbytes 48 >>> z = y.cast('b') >>> z.format 'b' >>> z.itemsize 1 >>> len(z) 48 >>> z.nbytes 48 ``` 將 1D/unsigned char 轉換為 2D/unsigned long: ``` >>> buf = struct.pack("L"*6, *list(range(6))) >>> x = memoryview(buf) >>> y = x.cast('L', shape=[2,3]) >>> len(y) 2 >>> y.nbytes 48 >>> y.tolist() [[0, 1, 2], [3, 4, 5]] ``` 3\.3 新版功能. 在 3.5 版更改: 當轉換為字節視圖時，源格式將不再受限。還存在一些可用的只讀屬性： `obj`內存視圖的下層對象: ``` >>> b = bytearray(b'xyz') >>> m = memoryview(b) >>> m.obj is b True ``` 3\.3 新版功能. `nbytes``nbytes == product(shape) * itemsize == len(m.tobytes())`。這是數組在連續表示時將會占用的空間總字節數。它不一定等于 `len(m)`: ``` >>> import array >>> a = array.array('i', [1,2,3,4,5]) >>> m = memoryview(a) >>> len(m) 5 >>> m.nbytes 20 >>> y = m[::2] >>> len(y) 3 >>> y.nbytes 12 >>> len(y.tobytes()) 12 ``` 多維數組: ``` >>> import struct >>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)]) >>> x = memoryview(buf) >>> y = x.cast('d', shape=[3,4]) >>> y.tolist() [[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]] >>> len(y) 3 >>> y.nbytes 96 ``` 3\.3 新版功能. `readonly`一個表明內存是否只讀的布爾值。 `format`一個字符串，包含視圖中每個元素的格式（表示為 [`struct`](struct.xhtml#module-struct "struct: Interpret bytes as packed binary data.") 模塊樣式）。內存視圖可以從具有任意格式字符串的導出器創建，但某些方法 (例如 [`tolist()`](#memoryview.tolist "memoryview.tolist")) 僅限于原生的單元素格式。在 3.3 版更改: 格式 `'B'` 現在會按照 struct 模塊語法來處理。這意味著 `memoryview(b'abc')[0] == b'abc'[0] == 97`。 `itemsize`memoryview 中每個元素以字節表示的大小: ``` >>> import array, struct >>> m = memoryview(array.array('H', [32000, 32001, 32002])) >>> m.itemsize 2 >>> m[0] 32000 >>> struct.calcsize('H') == m.itemsize True ``` `ndim`一個整數，表示內存所代表的多維數組具有多少個維度。 `shape`一個整數元組，通過 [`ndim`](#memoryview.ndim "memoryview.ndim") 的長度值給出內存所代表的 N 維數組的形狀。在 3.3 版更改: 當 ndim = 0 時值為空元組而不再為 `None`。 `strides`一個整數元組，通過 [`ndim`](#memoryview.ndim "memoryview.ndim") 的長度給出以字節表示的大小，以便訪問數組中每個維度上的每個元素。在 3.3 版更改: 當 ndim = 0 時值為空元組而不再為 `None`。 `suboffsets`供 PIL 風格的數組內部使用。該值僅作為參考信息。 `c_contiguous`一個表明內存是否為 C-[contiguous](../glossary.xhtml#term-contiguous) 的布爾值。 3\.3 新版功能. `f_contiguous`一個表明內存是否為 Fortran [contiguous](../glossary.xhtml#term-contiguous) 的布爾值。 3\.3 新版功能. `contiguous`一個表明內存是否為 [contiguous](../glossary.xhtml#term-contiguous) 的布爾值。 3\.3 新版功能. ## 集合類型 --- [`set`](#set "set"), [`frozenset`](#frozenset "frozenset") *set* 對象是由具有唯一性的 [hashable](../glossary.xhtml#term-hashable) 對象所組成的無序多項集。常見的用途包括成員檢測、從序列中去除重復項以及數學中的集合類計算，例如交集、并集、差集與對稱差集等等。（關于其他容器對象請參看 [`dict`](#dict "dict"), [`list`](#list "list") 與 [`tuple`](#tuple "tuple") 等內置類，以及 [`collections`](collections.xhtml#module-collections "collections: Container datatypes") 模塊。）與其他多項集一樣，集合也支持 `x in set`, `len(set)` 和 `for x in set`。作為一種無序的多項集，集合并不記錄元素位置或插入順序。相應地，集合不支持索引、切片或其他序列類的操作。目前有兩種內置集合類型，[`set`](#set "set") 和 [`frozenset`](#frozenset "frozenset")。 [`set`](#set "set") 類型是可變的 --- 其內容可以使用 `add()` 和 `remove()` 這樣的方法來改變。由于是可變類型，它沒有哈希值，且不能被用作字典的鍵或其他集合的元素。 [`frozenset`](#frozenset "frozenset") 類型是不可變并且為 [hashable](../glossary.xhtml#term-hashable) --- 其內容在被創建后不能再改變；因此它可以被用作字典的鍵或其他集合的元素。除了可以使用 [`set`](#set "set") 構造器，非空的 set (不是 frozenset) 還可以通過將以逗號分隔的元素列表包含于花括號之內來創建，例如: `{'jack', 'sjoerd'}`。兩個類的構造器具有相同的作用方式： *class* `set`(\[*iterable*\])*class* `frozenset`(\[*iterable*\])返回一個新的 set 或 frozenset 對象，其元素來自于 *iterable*。集合的元素必須為 [hashable](../glossary.xhtml#term-hashable)。要表示由集合對象構成的集合，所有的內層集合必須為 [`frozenset`](#frozenset "frozenset") 對象。如果未指定 *iterable*，則將返回一個新的空集合。 [`set`](#set "set") 和 [`frozenset`](#frozenset "frozenset") 的實例提供以下操作： `len(s)`返回集合 *s* 中的元素數量（即 *s* 的基數）。 `x in s`檢測 *x* 是否為 *s* 中的成員。 `x not in s`檢測 *x* 是否非 *s* 中的成員。 `isdisjoint`(*other*)如果集合中沒有與 *other* 共有的元素則返回 `True`。當且僅當兩個集合的交集為空集合時，兩者為不相交集合。 `issubset`(*other*)`set <= other`檢測是否集合中的每個元素都在 *other* 之中。 `set < other`檢測集合是否為 *other* 的真子集，即 `set <= other and set != other`。 `issuperset`(*other*)`set >= other`檢測是否 *other* 中的每個元素都在集合之中。 `set > other`檢測集合是否為 *other* 的真超集，即 `set >= other and set != other`。 `union`(*\*others*)`set | other | ...`返回一個新集合，其中包含來自原集合以及 others 指定的所有集合中的元素。 `intersection`(*\*others*)`set & other & ...`返回一個新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。 `difference`(*\*others*)`set - other - ...`返回一個新集合，其中包含原集合中在 others 指定的其他集合中不存在的元素。 `symmetric_difference`(*other*)`set ^ other`返回一個新集合，其中的元素或屬于原集合或屬于 *other* 指定的其他集合，但不能同時屬于兩者。 `copy`()返回原集合的淺拷貝。請注意，非運算符版本的 [`union()`](#frozenset.union "frozenset.union"), [`intersection()`](#frozenset.intersection "frozenset.intersection"), [`difference()`](#frozenset.difference "frozenset.difference")，以及 [`symmetric_difference()`](#frozenset.symmetric_difference "frozenset.symmetric_difference"), [`issubset()`](#frozenset.issubset "frozenset.issubset") 和 [`issuperset()`](#frozenset.issuperset "frozenset.issuperset") 方法會接受任意可迭代對象作為參數。相比之下，它們所對應的運算符版本則要求其參數為集合。這就排除了容易出錯的構造形式例如 `set('abc') & 'cbs'`，而推薦可讀性更強的 `set('abc').intersection('cbs')`。 [`set`](#set "set") 和 [`frozenset`](#frozenset "frozenset") 均支持集合與集合的比較。兩個集合當且僅當每個集合中的每個元素均包含于另一個集合之內（即各為對方的子集）時則相等。一個集合當且僅當其為另一個集合的真子集（即為后者的子集但兩者不相等）時則小于另一個集合。一個集合當且僅當其為另一個集合的真超集（即為后者的超集但兩者不相等）時則大于另一個集合。 [`set`](#set "set") 的實例與 [`frozenset`](#frozenset "frozenset") 的實例之間基于它們的成員進行比較。例如 `set('abc') == frozenset('abc')` 返回 `True`，`set('abc') in set([frozenset('abc')])` 也一樣。子集與相等比較并不能推廣為完全排序函數。例如，任意兩個非空且不相交的集合不相等且互不為對方的子集，因此以下 *所有* 比較均返回 `False`: `a<b`, `a==b`, or `a>b`。由于集合僅定義了部分排序（子集關系），因此由集合構成的列表 [`list.sort()`](#list.sort "list.sort") 方法的輸出并無定義。集合的元素，與字典的鍵類似，必須為 [hashable](../glossary.xhtml#term-hashable)。混合了 [`set`](#set "set") 實例與 [`frozenset`](#frozenset "frozenset") 的二進制位運算將返回與第一個操作數相同的類型。例如: `frozenset('ab') | set('bc')` 將返回 [`frozenset`](#frozenset "frozenset") 的實例。下表列出了可用于 [`set`](#set "set") 而不能用于不可變的 [`frozenset`](#frozenset "frozenset") 實例的操作： `update`(*\*others*)`set |= other | ...`更新集合，添加來自 others 中的所有元素。 `intersection_update`(*\*others*)`set &= other & ...`更新集合，只保留其中在所有 others 中也存在的元素。 `difference_update`(*\*others*)`set -= other | ...`更新集合，移除其中也存在于 others 中的元素。 `symmetric_difference_update`(*other*)`set ^= other`更新集合，只保留存在于集合的一方而非共同存在的元素。 `add`(*elem*)將元素 *elem* 添加到集合中。 `remove`(*elem*)從集合中移除元素 *elem*。如果 *elem* 不存在于集合中則會引發 [`KeyError`](exceptions.xhtml#KeyError "KeyError")。 `discard`(*elem*)如果元素 *elem* 存在于集合中則將其移除。 `pop`()從集合中移除并返回任意一個元素。如果集合為空則會引發 [`KeyError`](exceptions.xhtml#KeyError "KeyError")。 `clear`()從集合中移除所有元素。請注意，非運算符版本的 [`update()`](#frozenset.update "frozenset.update"), [`intersection_update()`](#frozenset.intersection_update "frozenset.intersection_update"), [`difference_update()`](#frozenset.difference_update "frozenset.difference_update") 和 [`symmetric_difference_update()`](#frozenset.symmetric_difference_update "frozenset.symmetric_difference_update") 方法將接受任意可迭代對象作為參數。請注意，[`__contains__()`](../reference/datamodel.xhtml#object.__contains__ "object.__contains__"), [`remove()`](#frozenset.remove "frozenset.remove") 和 [`discard()`](#frozenset.discard "frozenset.discard") 方法的 *elem* 參數可能是一個 set。為支持對一個等價的 frozenset 進行搜索，會根據 *elem* 臨時創建一個該類型對象。 ## 映射類型 --- [`dict`](#dict "dict") [mapping](../glossary.xhtml#term-mapping) 對象會將 [hashable](../glossary.xhtml#term-hashable) 值映射到任意對象。映射屬于可變對象。目前僅有一種標準映射類型 *字典*。（關于其他容器對象請參看 [`list`](#list "list"), [`set`](#set "set") 與 [`tuple`](#tuple "tuple") 等內置類，以及 [`collections`](collections.xhtml#module-collections "collections: Container datatypes") 模塊。）字典的鍵 *幾乎* 可以是任何值。非 [hashable](../glossary.xhtml#term-hashable) 的值，即包含列表、字典或其他可變類型的值（此類對象基于值而非對象標識進行比較）不可用作鍵。數字類型用作鍵時遵循數字比較的一般規則：如果兩個數值相等 (例如 `1` 和 `1.0`) 則兩者可以被用來索引同一字典條目。（但是請注意，由于計算機對于浮點數存儲的只是近似值，因此將其用作字典鍵是不明智的。）字典可以通過將以逗號分隔的 `鍵: 值` 對列表包含于花括號之內來創建，例如: `{'jack': 4098, 'sjoerd': 4127}` 或 `{4098: 'jack', 4127: 'sjoerd'}`，也可以通過 [`dict`](#dict "dict") 構造器來創建。 *class* `dict`(*\*\*kwarg*)*class* `dict`(*mapping*, *\*\*kwarg*)*class* `dict`(*iterable*, *\*\*kwarg*)返回一個新的字典，基于可選的位置參數和可能為空的關鍵字參數集來初始化。如果沒有給出位置參數，將創建一個空字典。如果給出一個位置參數并且其屬于映射對象，將創建一個具有與映射對象相同鍵值對的字典。否則的話，位置參數必須為一個 [iterable](../glossary.xhtml#term-iterable) 對象。該可迭代對象中的每一項本身必須為一個剛好包含兩個元素的可迭代對象。每一項中的第一個對象將成為新字典的一個鍵，第二個對象將成為其對應的值。如果一個鍵出現一次以上，該鍵的最后一個值將成為其在新字典中對應的值。如果給出了關鍵字參數，則關鍵字參數及其值會被加入到基于位置參數創建的字典。如果要加入的鍵已存在，來自關鍵字參數的值將替代來自位置參數的值。作為演示，以下示例返回的字典均等于 `{"one": 1, "two": 2, "three": 3}`: ``` >>> a = dict(one=1, two=2, three=3) >>> b = {'one': 1, 'two': 2, 'three': 3} >>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3])) >>> d = dict([('two', 2), ('one', 1), ('three', 3)]) >>> e = dict({'three': 3, 'one': 1, 'two': 2}) >>> a == b == c == d == e True ``` 像第一個例子那樣提供關鍵字參數的方式只能使用有效的 Python 標識符作為鍵。其他方式則可使用任何有效的鍵。這些是字典所支持的操作（因而自定義的映射類型也應當支持）： `len(d)`返回字典 *d* 中的項數。 `d[key]`返回 *d* 中以 *key* 為鍵的項。如果映射中不存在 *key* 則會引發 [`KeyError`](exceptions.xhtml#KeyError "KeyError")。如果字典的子類定義了方法 [`__missing__()`](../reference/datamodel.xhtml#object.__missing__ "object.__missing__") 并且 *key* 不存在，則 `d[key]` 操作將調用該方法并附帶鍵 *key* 作為參數。 `d[key]` 隨后將返回或引發 `__missing__(key)` 調用所返回或引發的任何對象或異常。沒有其他操作或方法會發起調用 [`__missing__()`](../reference/datamodel.xhtml#object.__missing__ "object.__missing__")。如果未定義 [`__missing__()`](../reference/datamodel.xhtml#object.__missing__ "object.__missing__")，則會引發 [`KeyError`](exceptions.xhtml#KeyError "KeyError")。 [`__missing__()`](../reference/datamodel.xhtml#object.__missing__ "object.__missing__") 必須是一個方法；它不能是一個實例變量: ``` >>> class Counter(dict): ... def __missing__(self, key): ... return 0 >>> c = Counter() >>> c['red'] 0 >>> c['red'] += 1 >>> c['red'] 1 ``` 上面的例子顯示了 [`collections.Counter`](collections.xhtml#collections.Counter "collections.Counter") 實現的部分代碼。還有另一個不同的 `__missing__` 方法是由 [`collections.defaultdict`](collections.xhtml#collections.defaultdict "collections.defaultdict") 所使用的。 `d[key] = value`將 `d[key]` 設為 *value*。 `del d[key]`將 `d[key]` 從 *d* 中移除。如果映射中不存在 *key* 則會引發 [`KeyError`](exceptions.xhtml#KeyError "KeyError")。 `key in d`如果 *d* 中存在鍵 *key* 則返回 `True`，否則返回 `False`。 `key not in d`等價于 `not key in d`。 `iter(d)`返回以字典的鍵為元素的迭代器。這是 `iter(d.keys())` 的快捷方式。 `clear`()移除字典中的所有元素。 `copy`()返回原字典的淺拷貝。 *classmethod* `fromkeys`(*iterable*\[, *value*\])使用來自 *iterable* 的鍵創建一個新字典，并將鍵值設為 *value*。 [`fromkeys()`](#dict.fromkeys "dict.fromkeys") 屬于類方法，會返回一個新字典。 *value* 默認為 `None`。 `get`(*key*\[, *default*\])如果 *key* 存在于字典中則返回 *key* 的值，否則返回 *default*。如果 *default* 未給出則默認為 `None`，因而此方法絕不會引發 [`KeyError`](exceptions.xhtml#KeyError "KeyError")。 `items`()返回由字典項 (`(鍵, 值)` 對) 組成的一個新視圖。參見 [視圖對象文檔](#dict-views)。 `keys`()返回由字典鍵組成的一個新視圖。參見 [視圖對象文檔](#dict-views)。 `pop`(*key*\[, *default*\])如果 *key* 存在于字典中則將其移除并返回其值，否則返回 *default*。如果 *default* 未給出且 *key* 不存在于字典中，則會引發 [`KeyError`](exceptions.xhtml#KeyError "KeyError")。 `popitem`()從字典中移除并返回一個 `(鍵, 值)` 對。鍵值對會按 LIFO 的順序被返回。 [`popitem()`](#dict.popitem "dict.popitem") 適用于對字典進行消耗性的迭代，這在集合算法中經常被使用。如果字典為空，調用 [`popitem()`](#dict.popitem "dict.popitem") 將引發 [`KeyError`](exceptions.xhtml#KeyError "KeyError")。在 3.7 版更改: 現在會確保采用 LIFO 順序。在之前的版本中，[`popitem()`](#dict.popitem "dict.popitem") 會返回一個任意的鍵/值對。 `setdefault`(*key*\[, *default*\])如果字典存在鍵 *key* ，返回它的值。如果不存在，插入值為 *default* 的鍵 *key* ，并返回 *default* 。 *default* 默認為 `None`。 `update`(\[*other*\])使用來自 *other* 的鍵/值對更新字典，覆蓋原有的鍵。返回 `None`。 [`update()`](#dict.update "dict.update") 接受另一個字典對象，或者一個包含鍵/值對（以長度為二的元組或其他可迭代對象表示）的可迭代對象。如果給出了關鍵字參數，則會以其所指定的鍵/值對更新字典: `d.update(red=1, blue=2)`。 `values`()返回由字典值組成的一個新視圖。參見 [視圖對象文檔](#dict-views)。兩個字典的比較當且僅當具有相同的 `(鍵, 值)` 對時才會相等。順序比較 ('<', '<=', '>=', '>') 會引發 [`TypeError`](exceptions.xhtml#TypeError "TypeError")。字典會保留插入時的順序。請注意對鍵的更新不會影響順序。刪除并再次添加的鍵將被插入到末尾。 ``` >>> d = {"one": 1, "two": 2, "three": 3, "four": 4} >>> d {'one': 1, 'two': 2, 'three': 3, 'four': 4} >>> list(d) ['one', 'two', 'three', 'four'] >>> list(d.values()) [1, 2, 3, 4] >>> d["one"] = 42 >>> d {'one': 42, 'two': 2, 'three': 3, 'four': 4} >>> del d["two"] >>> d["two"] = None >>> d {'one': 42, 'three': 3, 'four': 4, 'two': None} ``` 在 3.7 版更改: 字典順序會確保為插入順序。此行為是自 3.6 版開始的 CPython 實現細節。參見 [`types.MappingProxyType`](types.xhtml#types.MappingProxyType "types.MappingProxyType") 可被用來創建一個 [`dict`](#dict "dict") 的只讀視圖。 ### 字典視圖對象由 [`dict.keys()`](#dict.keys "dict.keys"), [`dict.values()`](#dict.values "dict.values") 和 [`dict.items()`](#dict.items "dict.items") 所返回的對象是 *視圖對象*。該對象提供字典條目的一個動態視圖，這意味著當字典改變時，視圖也會相應改變。字典視圖可以被迭代以產生與其對應的數據，并支持成員檢測： `len(dictview)`返回字典中的條目數。 `iter(dictview)`返回字典中的鍵、值或項（以 `(鍵, 值)` 為元素的元組表示）的迭代器。鍵和值是按插入時的順序進行迭代的。這樣就允許使用 [`zip()`](functions.xhtml#zip "zip") 來創建 `(值, 鍵)` 對: `pairs = zip(d.values(), d.keys())`。另一個創建相同列表的方式是 `pairs = [(v, k) for (k, v) in d.items()]`. 在添加或刪除字典中的條目期間對視圖進行迭代可能引發 [`RuntimeError`](exceptions.xhtml#RuntimeError "RuntimeError") 或者無法完全迭代所有條目。在 3.7 版更改: 字典順序會確保為插入順序。 `x in dictview`如果 *x* 是對應字典中存在的鍵、值或項（在最后一種情況下 *x* 應為一個 `(鍵, 值)` 元組）則返回 `True`。鍵視圖類似于集合，因為其條目不重復且可哈希。如果所有值都是可哈希的，即 `(鍵, 值)` 對也是不重復且可哈希的，那么條目視圖也會類似于集合。（值視圖則不被視為類似于集合，因其條目通常都是有重復的。）對于類似于集合的視圖，為抽象基類 [`collections.abc.Set`](collections.abc.xhtml#collections.abc.Set "collections.abc.Set") 所定義的全部操作都是有效的 (例如 `==`, `<` 或 `^`)。一個使用字典視圖的示例: ``` >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500} >>> keys = dishes.keys() >>> values = dishes.values() >>> # iteration >>> n = 0 >>> for val in values: ... n += val >>> print(n) 504 >>> # keys and values are iterated over in the same order (insertion order) >>> list(keys) ['eggs', 'sausage', 'bacon', 'spam'] >>> list(values) [2, 1, 1, 500] >>> # view objects are dynamic and reflect dict changes >>> del dishes['eggs'] >>> del dishes['sausage'] >>> list(keys) ['bacon', 'spam'] >>> # set operations >>> keys & {'eggs', 'bacon', 'salad'} {'bacon'} >>> keys ^ {'sausage', 'juice'} {'juice', 'sausage', 'bacon', 'spam'} ``` ## 上下文管理器類型 Python 的 [`with`](../reference/compound_stmts.xhtml#with) 語句支持通過上下文管理器所定義的運行時上下文這一概念。此對象的實現使用了一對專門方法，允許用戶自定義類來定義運行時上下文，在語句體被執行前進入該上下文，并在語句執行完畢時退出該上下文： `contextmanager.``__enter__`()進入運行時上下文并返回此對象或關聯到該運行時上下文的其他對象。此方法的返回值會綁定到使用此上下文管理器的 [`with`](../reference/compound_stmts.xhtml#with) 語句的 `as` 子句中的標識符。一個返回其自身的上下文管理器的例子是 [file object](../glossary.xhtml#term-file-object)。文件對象會從 \_\_enter\_\_() 返回其自身，以允許 [`open()`](functions.xhtml#open "open") 被用作 [`with`](../reference/compound_stmts.xhtml#with) 語句中的上下文表達式。一個返回關聯對象的上下文管理器的例子是 [`decimal.localcontext()`](decimal.xhtml#decimal.localcontext "decimal.localcontext") 所返回的對象。此種管理器會將活動的 decimal 上下文設為原始 decimal 上下文的一個副本并返回該副本。這允許對 [`with`](../reference/compound_stmts.xhtml#with) 語句的語句體中的當前 decimal 上下文進行更改，而不會影響 `with` 語句以外的代碼。 `contextmanager.``__exit__`(*exc\_type*, *exc\_val*, *exc\_tb*)退出運行時上下文并返回一個布爾值旗標來表明所發生的任何異常是否應當被屏蔽。如果在執行 [`with`](../reference/compound_stmts.xhtml#with) 語句的語句體期間發生了異常，則參數會包含異常的類型、值以及回溯信息。在其他情況下三個參數均為 `None`。自此方法返回一個真值將導致 [`with`](../reference/compound_stmts.xhtml#with) 語句屏蔽異常并繼續執行緊隨在 `with` 語句之后的語句。否則異常將在此方法結束執行后繼續傳播。在此方法執行期間發生的異常將會取代 `with` 語句的語句體中發生的任何異常。傳入的異常絕對不應當被顯式地重新引發 —— 相反地，此方法應當返回一個假值以表明方法已成功完成并且不希望屏蔽被引發的異常。這允許上下文管理代碼方便地檢測 [`__exit__()`](#contextmanager.__exit__ "contextmanager.__exit__") 方法是否確實已失敗。 Python 定義了一些上下文管理器來支持簡易的線程同步、文件或其他對象的快速關閉，以及更方便地操作活動的十進制算術上下文。除了實現上下文管理協議以外，不同類型不會被特殊處理。請參閱 [`contextlib`](contextlib.xhtml#module-contextlib "contextlib: Utilities for with-statement contexts.") 模塊查看相關的示例。 Python 的 [generator](../glossary.xhtml#term-generator) 和 [`contextlib.contextmanager`](contextlib.xhtml#contextlib.contextmanager "contextlib.contextmanager") 裝飾器提供了實現這些協議的便捷方式。如果使用 [`contextlib.contextmanager`](contextlib.xhtml#contextlib.contextmanager "contextlib.contextmanager") 裝飾器來裝飾一個生成器函數，它將返回一個實現了必要的 [`__enter__()`](../reference/datamodel.xhtml#object.__enter__ "object.__enter__") and [`__exit__()`](../reference/datamodel.xhtml#object.__exit__ "object.__exit__") 方法的上下文管理器，而不再是由未經裝飾的生成器函數所產生的迭代器。請注意，Python/C API 中 Python 對象的類型結構中并沒有針對這些方法的專門槽位。想要定義這些方法的擴展類型必須將它們作為普通的 Python 可訪問方法來提供。與設置運行時上下文的開銷相比，單個類字典查找的開銷可以忽略不計。 ## 其他內置類型解釋器支持一些其他種類的對象。這些對象大都僅支持一兩種操作。 ### 模塊模塊唯一的特殊操作是屬性訪問: `m.name`，這里 *m* 為一個模塊而 *name* 訪問定義在 *m* 的符號表中的一個名稱。模塊屬性可以被賦值。（請注意 [`import`](../reference/simple_stmts.xhtml#import) 語句嚴格來說也是對模塊對象的一種操作；`import foo` 不要求存在一個名為 *foo* 的模塊對象，而是要求存在一個對于名為 *foo* 的模塊的 (永久性) *定義*。）每個模塊都有一個特殊屬性 [`__dict__`](#object.__dict__ "object.__dict__")。這是包含模塊的符號表的字典。修改此字典將實際改變模塊的符號表，但是無法直接對 [`__dict__`](#object.__dict__ "object.__dict__") 賦值 (你可以寫 `m.__dict__['a'] = 1`，這會將 `m.a` 定義為 `1`，但是你不能寫 `m.__dict__ = {}`)。不建議直接修改 [`__dict__`](#object.__dict__ "object.__dict__")。內置于解釋器中的模塊會寫成這樣: `<module 'sys' (built-in)>`。如果是從一個文件加載，則會寫成 `<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>`。 ### 類與類實例關于這些類型請參閱 [對象、值與類型](../reference/datamodel.xhtml#objects) 和 [類定義](../reference/compound_stmts.xhtml#class)。 ### 函數函數對象是通過函數定義創建的。對函數對象的唯一操作是調用它: `func(argument-list)`。實際上存在兩種不同的函數對象：內置函數和用戶自定義函數。兩者支持同樣的操作（調用函數），但實現方式不同，因此對象類型也不同。更多信息請參閱 [函數定義](../reference/compound_stmts.xhtml#function)。 ### 方法方法是使用屬性表示法來調用的函數。存在兩種形式：內置方法（例如列表的 `append()` 方法）和類實例方法。內置方法由支持它們的類型來描述。如果你通過一個實例來訪問方法（即定義在類命名空間內的函數），你會得到一個特殊對象: *綁定方法* (或稱 *實例方法*) 對象。當被調用時，它會將 `self` 參數添加到參數列表。綁定方法具有兩個特殊的只讀屬性: `m.__self__` 操作該方法的對象，而 `m.__func__` 是實現該方法的函數。調用 `m(arg-1, arg-2, ..., arg-n)` 完全等價于調用 `m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)`。與函數對象類似，綁定方法對象也支持獲取任意屬性。但是，由于方法屬性實際上保存于下層的函數對象中 (`meth.__func__`)，因此不允許設置綁定方法的方法屬性。嘗試設置方法的屬性將會導致引發 [`AttributeError`](exceptions.xhtml#AttributeError "AttributeError")。想要設置方法屬性，你必須在下層的函數對象中顯式地對其進行設置: ``` >>> class C: ... def method(self): ... pass ... >>> c = C() >>> c.method.whoami = 'my name is method' # can't set on the method Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'method' object has no attribute 'whoami' >>> c.method.__func__.whoami = 'my name is method' >>> c.method.whoami 'my name is method' ``` 更多信息請參閱 [標準類型層級結構](../reference/datamodel.xhtml#types)。 ### 代碼對象代碼對象被具體實現用來表示“偽編譯”的可執行 Python 代碼，例如一個函數體。它們不同于函數對象，因為它們不包含對其全局執行環境的引用。代碼對象由內置的 [`compile()`](functions.xhtml#compile "compile") 函數返回，并可通過從函數對象的 `__code__` 屬性從中提取。另請參閱 [`code`](code.xhtml#module-code "code: Facilities to implement read-eval-print loops.") 模塊。可以通過將代碼對象（而非源碼字符串）傳給 [`exec()`](functions.xhtml#exec "exec") 或 [`eval()`](functions.xhtml#eval "eval") 內置函數來執行或求值。更多信息請參閱 [標準類型層級結構](../reference/datamodel.xhtml#types)。 ### 類型對象類型對象表示各種對象類型。對象的類型可通過內置函數 [`type()`](functions.xhtml#type "type") 來獲取。類型沒有特殊的操作。標準庫模塊 [`types`](types.xhtml#module-types "types: Names for built-in types.") 定義了所有標準內置類型的名稱。類型以這樣的寫法來表示: `<class 'int'>`。 ### 空對象此對象會由不顯式地返回值的函數所返回。它不支持任何特殊的操作。空對象只有一種值 `None` (這是個內置名稱)。 `type(None)()` 會生成同一個單例。該對象的寫法為 `None`。 ### 省略符對象此對象常被用于切片 (參見 [切片](../reference/expressions.xhtml#slicings))。它不支持任何特殊的操作。省略符對象只有一種值 [`Ellipsis`](constants.xhtml#Ellipsis "Ellipsis") (這是個內置名稱)。 `type(Ellipsis)()` 會生成 [`Ellipsis`](constants.xhtml#Ellipsis "Ellipsis") 單例。該對象的寫法為 `Ellipsis` 或 `...`。 ### 未實現對象此對象會被作為比較和二元運算被應用于它們所不支持的類型時的返回值。請參閱 [比較運算](../reference/expressions.xhtml#comparisons) 了解更多信息。未實現對象只有一種值 `NotImplemented`。 `type(NotImplemented)()` 會生成這個單例。該對象的寫法為 `NotImplemented`。 ### 布爾值布爾值是兩個常量對象 `False` 和 `True`。它們被用來表示邏輯上的真假（不過其他值也可被當作真值或假值）。在數字類的上下文中（例如被用作算術運算符的參數時），它們的行為分別類似于整數 0 和 1。內置函數 [`bool()`](functions.xhtml#bool "bool") 可被用來將任意值轉換為布爾值，只要該值可被解析為一個邏輯值（參見之前的 [邏輯值檢測](#truth) 部分）。該對象的寫法分別為 `False` 和 `True`。 ### 內部對象有關此對象的信息請參閱 [標準類型層級結構](../reference/datamodel.xhtml#types)。其中描述了棧幀對象、回溯對象以及切片對象等等。 ## 特殊屬性語言實現為部分對象類型添加了一些特殊的只讀屬性，它們具有各自的作用。其中一些并不會被 [`dir()`](functions.xhtml#dir "dir") 內置函數所列出。 `object.``__dict__`一個字典或其他類型的映射對象，用于存儲對象的（可寫）屬性。 `instance.``__class__`類實例所屬的類。 `class.``__bases__`由類對象的基類所組成的元組。 `definition.``__name__`類、函數、方法、描述器或生成器實例的名稱。 `definition.``__qualname__`類、函數、方法、描述器或生成器實例的 [qualified name](../glossary.xhtml#term-qualified-name)。 3\.3 新版功能. `class.``__mro__`此屬性是由類組成的元組，在方法解析期間會基于它來查找基類。 `class.``mro`()此方法可被一個元類來重載，以為其實例定制方法解析順序。它會在類實例化時被調用，其結果存儲于 [`__mro__`](#class.__mro__ "class.__mro__") 之中。 `class.``__subclasses__`()每個類會保存由對其直接子類的弱引用組成的列表。此方法將返回一個由仍然存在的所有此類引用組成的列表。例如: ``` >>> int.__subclasses__() [<class 'bool'>] ``` 腳注 [1](#id1)有關這些特殊方法的額外信息可參看 Python 參考指南 ([基本定制](../reference/datamodel.xhtml#customization))。 [2](#id2)作為結果，列表 `[1, 2]` 與 `[1.0, 2.0]` 是相等的，元組的情況也類似。 [3](#id4)它們必須如此，因為解析器無法區分這些操作數的類型。 4([1](#id6),[2](#id7),[3](#id8),[4](#id9))區分大小寫的字符是指所屬一般類別屬性為 "Lu" (Letter, uppercase), "Ll" (Letter, lowercase) 或 "Lt" (Letter, titlecase) 之一的字符。 5([1](#id10),[2](#id11))要格式化單獨一個元組，那么你應當提供一個單例元組，其唯一的元素就是要被格式化的元組。 ### 導航 - [索引](../genindex.xhtml "總目錄") - [模塊](../py-modindex.xhtml "Python 模塊索引") | - [下一頁](exceptions.xhtml "內置異常") | - [上一頁](constants.xhtml "內置常量") | - ![](https://box.kancloud.cn/a721fc7ec672275e257bbbfde49a4d4e_16x16.png) - [Python](https://www.python.org/) ? - zh\_CN 3.7.3 [文檔](../index.xhtml) ? - [Python 標準庫](index.xhtml) ? - $('.inline-search').show(0); | ? [版權所有](../copyright.xhtml) 2001-2019, Python Software Foundation. Python 軟件基金會是一個非盈利組織。 [請捐助。](https://www.python.org/psf/donations/) 最后更新于 5月 21, 2019. [發現了問題](../bugs.xhtml)？使用[Sphinx](http://sphinx.pocoo.org/)1.8.4 創建。