內(nèi)置類型?

以下部分描述了解釋器中內(nèi)置的標準類型。

主要內(nèi)置類型有數(shù)字、序列、映射、類、實例和異常。

有些多項集類是可變的。 它們用于添加、移除或重排其成員的方法將原地執(zhí)行，并不返回特定的項，絕對不會返回多項集實例自身而是返回 None。

有些操作受多種對象類型的支持；特別地，實際上所有對象都可以被比較、檢測邏輯值，以及轉(zhuǎn)換為字符串（使用 repr() 函數(shù)或略有差異的 str() 函數(shù)）。 后一個函數(shù)是在對象由 print() 函數(shù)輸出時被隱式地調(diào)用的。

邏輯值檢測?

任何對象都可以進行邏輯值的檢測，以便在 if 或 while 作為條件或是作為下文所述布爾運算的操作數(shù)來使用。

一個對象在默認情況下均被視為真值，除非當該對象被調(diào)用時其所屬類定義了 __bool__() 方法且返回 False 或是定義了 __len__() 方法且返回零。 1 下面基本完整地列出了會被視為假值的內(nèi)置對象:

  • 被定義為假值的常量: None 和 False。

  • 任何數(shù)值類型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

  • 空的序列和多項集: '', (), [], {}, set(), range(0)

產(chǎn)生布爾值結(jié)果的運算和內(nèi)置函數(shù)總是返回 0 或 False 作為假值，1 或 True 作為真值，除非另行說明。 （重要例外：布爾運算 or 和 and 總是返回其中一個操作數(shù)。）

布爾運算 --- and, or, not?

這些屬于布爾運算，按優(yōu)先級升序排列:

運算

結(jié)果：

注釋

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. 這是個短路運算符，因此只有在第一個參數(shù)為假值時才會對第二個參數(shù)求值。

  2. 這是個短路運算符，因此只有在第一個參數(shù)為真值時才會對第二個參數(shù)求值。

  3. not 的優(yōu)先級比非布爾運算符低，因此 not a == b 會被解讀為 not (a == b) 而 a == not b 會引發(fā)語法錯誤。

比較運算?

在 Python 中有八種比較運算符。 它們的優(yōu)先級相同（比布爾運算的優(yōu)先級高）。 比較運算可以任意串連；例如，x < y <= z 等價于 x < y and y <= z，前者的不同之處在于 y 只被求值一次（但在兩種情況下當 x < y 結(jié)果為假值時 z 都不會被求值）。

此表格匯總了比較運算:

運算

含義

<

嚴格小于

<=

小于或等于

>

嚴格大于

>=

大于或等于

==

等于

!=

不等于

is

對象標識

is not

否定的對象標識

除了不同數(shù)字類型以外，不同類型的對象比較時絕對不會相等。 而且，某些類型（例如函數(shù)對象）僅支持簡化比較形式，即任何兩個該種類型的對象必定不相等。 <, <=, > 和 >= 運算符在以下情況中將引發(fā) TypeError 異常：當比較復(fù)數(shù)與另一個內(nèi)置數(shù)字類型時，當兩個對象具有無法被比較的不同類型時，或在未定義次序的其他情況時。

具有不同標識的類的實例比較結(jié)果通常為不相等，除非類定義了 __eq__() 方法。

一個類實例不能與相同類或的其他實例或其他類型的對象進行排序，除非該類定義了足夠多的方法，包括 __lt__(), __le__(), __gt__() 以及 __ge__() (而如果你想實現(xiàn)常規(guī)意義上的比較操作，通常只要有 __lt__() 和 __eq__() 就可以了)。

is 和 is not 運算符無法自定義；并且它們可以被應(yīng)用于任意兩個對象而不會引發(fā)異常。

還有兩種具有相同語法優(yōu)先級的運算 in 和 not in，它們被 iterable 或?qū)崿F(xiàn)了 __contains__() 方法的類型所支持。

數(shù)字類型 --- int, float, complex?

存在三種不同的數(shù)字類型: 整數(shù), 浮點數(shù) 和 復(fù)數(shù)。 此外，布爾值屬于整數(shù)的子類型。 整數(shù)具有無限的精度。 浮點數(shù)通常使用 C 中的 double 來實現(xiàn)；有關(guān)你的程序運行所在機器上浮點數(shù)的精度和內(nèi)部表示法可在 sys.float_info 中查看。 復(fù)數(shù)包含實部和虛部，分別以一個浮點數(shù)表示。 要從一個復(fù)數(shù) z 中提取這兩個部分，可使用 z.real 和 z.imag。 （標準庫包含附加的數(shù)字類型，如表示有理數(shù)的 fractions 以及以用戶定制精度表示浮點數(shù)的 decimal。）

數(shù)字是由數(shù)字字面值或內(nèi)置函數(shù)與運算符的結(jié)果來創(chuàng)建的。 不帶修飾的整數(shù)字面值（包括十六進制、八進制和二進制數(shù)）會生成整數(shù)。 包含小數(shù)點或冪運算符的數(shù)字字面值會生成浮點數(shù)。 在數(shù)字字面值末尾加上 'j' 或 'J' 會生成虛數(shù)（實部為零的復(fù)數(shù)），你可以將其與整數(shù)或浮點數(shù)相加來得到具有實部和虛部的復(fù)數(shù)。

Python 完全支持混合運算：當一個二元算術(shù)運算符的操作數(shù)有不同數(shù)值類型時，"較窄"類型的操作數(shù)會拓寬到另一個操作數(shù)的類型，其中整數(shù)比浮點數(shù)窄，浮點數(shù)比復(fù)數(shù)窄。不同類型的數(shù)字之間的比較，同比較這些數(shù)字的精確值一樣。2

構(gòu)造函數(shù) int()、 float() 和 complex() 可以用來構(gòu)造特定類型的數(shù)字。

所有數(shù)字類型（復(fù)數(shù)除外）都支持下列運算（有關(guān)運算優(yōu)先級，請參閱：運算符優(yōu)先級）:

運算

結(jié)果：

注釋

完整文檔

x + y

x 和 y 的和

x - y

x 和 y 的差

x * y

x 和 y 的乘積

x / y

x 和 y 的商

x // y

x 和 y 的商數(shù)

(1)

x % y

x / y 的余數(shù)

(2)

-x

x 取反

+x

x 不變

abs(x)

x 的絕對值或大小

abs()

int(x)

將 x 轉(zhuǎn)換為整數(shù)

(3)(6)

int()

float(x)

將 x 轉(zhuǎn)換為浮點數(shù)

(4)(6)

float()

complex(re, im)

一個帶有實部 re 和虛部 im 的復(fù)數(shù)。im 默認為0。

(6)

complex()

c.conjugate()

復(fù)數(shù) c 的共軛

divmod(x, y)

(x // y, x % y)

(2)

divmod()

pow(x, y)

x 的 y 次冪

(5)

pow()

x ** y

x 的 y 次冪

(5)

注釋:

  1. 也稱為整數(shù)除法。 結(jié)果值是一個整數(shù)，但結(jié)果的類型不一定是 int。 運算結(jié)果總是向負無窮的方向舍入: 1//2 為 0, (-1)//2 為 -1, 1//(-2) 為 -1 而 (-1)//(-2) 為 0。

  2. 不可用于復(fù)數(shù)。 而應(yīng)在適當條件下使用 abs() 轉(zhuǎn)換為浮點數(shù)。

  3. 從浮點數(shù)轉(zhuǎn)換為整數(shù)會被舍入或是像在 C 語言中一樣被截斷；請參閱 math.floor() 和 math.ceil() 函數(shù)查看轉(zhuǎn)換的完整定義。

  4. float 也接受字符串 "nan" 和附帶可選前綴 "+" 或 "-" 的 "inf" 分別表示非數(shù)字 (NaN) 以及正或負無窮。

  5. Python 將 pow(0, 0) 和 0 ** 0 定義為 1，這是編程語言的普遍做法。

  6. 接受的數(shù)字字面值包括數(shù)碼 0 到 9 或任何等效的 Unicode 字符（具有 Nd 特征屬性的代碼點）。

    請參閱 http://www.unicode.org/Public/10.0.0/ucd/extracted/DerivedNumericType.txt 查看具有 Nd 特征屬性的代碼點的完整列表。

所有 numbers.Real 類型 (int 和 float) 還包括下列運算:

運算

結(jié)果：

math.trunc(x)

x 截斷為 Integral

round(x[, n])

x 舍入到 n 位小數(shù)，半數(shù)值會舍入到偶數(shù)。 如果省略 n，則默認為 0。

math.floor(x)

<= x 的最大 Integral

math.ceil(x)

>= x 的最小 Integral

有關(guān)更多的數(shù)字運算請參閱 math 和 cmath 模塊。

整數(shù)類型的按位運算?

按位運算只對整數(shù)有意義。 計算按位運算的結(jié)果，就相當于使用無窮多個二進制符號位對二的補碼執(zhí)行操作。

二進制按位運算的優(yōu)先級全都低于數(shù)字運算，但又高于比較運算；一元運算 ~ 具有與其他一元算術(shù)運算 (+ and -) 相同的優(yōu)先級。

此表格是以優(yōu)先級升序排序的按位運算列表:

運算

結(jié)果：

注釋

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. 負的移位數(shù)是非法的，會導(dǎo)致引發(fā) ValueError。

  2. 左移 n 位等價于不帶溢出檢測地乘以 pow(2, n) 。

  3. 右移 n 位等價于除以 pow(2, n) ，作向下取整除法。

  4. 使用帶有至少一個額外符號擴展位的有限個二進制補碼表示（有效位寬度為 1 + max(x.bit_length(), y.bit_length()) 或以上）執(zhí)行這些計算就足以獲得相當于有無數(shù)個符號位時的同樣結(jié)果。

整數(shù)類型的附加方法?

int 類型實現(xiàn)了 numbers.Integral abstract base class。 此外，它還提供了其他幾個方法:

int.bit_length()?

返回以二進制表示一個整數(shù)所需要的位數(shù)，不包括符號位和前面的零:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

更準確地說，如果 x 非零，則 x.bit_length() 是使得 2**(k-1) <= abs(x) < 2**k 的唯一正整數(shù) k。 同樣地，當 abs(x) 小到足以具有正確的舍入對數(shù)時，則 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)?

返回表示一個整數(shù)的字節(jié)數(shù)組。

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

整數(shù)會使用 length 個字節(jié)來表示。 如果整數(shù)不能用給定的字節(jié)數(shù)來表示則會引發(fā) OverflowError。

byteorder 參數(shù)確定用于表示整數(shù)的字節(jié)順序。 如果 byteorder 為 "big"，則最高位字節(jié)放在字節(jié)數(shù)組的開頭。 如果 byteorder 為 "little"，則最高位字節(jié)放在字節(jié)數(shù)組的末尾。 要請求主機系統(tǒng)上的原生字節(jié)順序，請使用 sys.byteorder 作為字節(jié)順序值。

signed 參數(shù)確定是否使用二的補碼來表示整數(shù)。 如果 signed 為 False 并且給出的是負整數(shù)，則會引發(fā) OverflowError。 signed 的默認值為 False。

3.2 新版功能.

classmethod int.from_bytes(bytes, byteorder, *, signed=False)?

返回由給定字節(jié)數(shù)組所表示的整數(shù)。

>>> 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 參數(shù)必須為一個 bytes-like object 或是生成字節(jié)的可迭代對象。

byteorder 參數(shù)確定用于表示整數(shù)的字節(jié)順序。 如果 byteorder 為 "big"，則最高位字節(jié)放在字節(jié)數(shù)組的開頭。 如果 byteorder 為 "little"，則最高位字節(jié)放在字節(jié)數(shù)組的末尾。 要請求主機系統(tǒng)上的原生字節(jié)順序，請使用 sys.byteorder 作為字節(jié)順序值。

signed 參數(shù)指明是否使用二的補碼來表示整數(shù)。

3.2 新版功能.

浮點類型的附加方法?

float 類型實現(xiàn)了 numbers.Real abstract base class。 float 還具有以下附加方法。

float.as_integer_ratio()?

返回一對整數(shù)，其比率正好等于原浮點數(shù)并且分母為正數(shù)。 無窮大會引發(fā) OverflowError 而 NaN 則會引發(fā) ValueError。

float.is_integer()?

如果 float 實例可用有限位整數(shù)表示則返回 True，否則返回 False:

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

兩個方法均支持與十六進制數(shù)字符串之間的轉(zhuǎn)換。 由于 Python 浮點數(shù)在內(nèi)部存儲為二進制數(shù)，因此浮點數(shù)與 十進制數(shù) 字符串之間的轉(zhuǎn)換往往會導(dǎo)致微小的舍入錯誤。 而十六進制數(shù)字符串卻允許精確地表示和描述浮點數(shù)。 這在進行調(diào)試和數(shù)值工作時非常有用。

float.hex()?

以十六進制字符串的形式返回一個浮點數(shù)表示。 對于有限浮點數(shù)，這種表示法將總是包含前導(dǎo)的 0x 和尾隨的 p 加指數(shù)。

classmethod float.fromhex(s)?

返回以十六進制字符串 s 表示的浮點數(shù)的類方法。 字符串 s 可以帶有前導(dǎo)和尾隨的空格。

請注意 float.hex() 是實例方法，而 float.fromhex() 是類方法。

十六進制字符串采用的形式為:

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

可選的 sign 可以是 + 或 -，integer 和 fraction 是十六進制數(shù)碼組成的字符串，exponent 是帶有可選前導(dǎo)符的十進制整數(shù)。 大小寫沒有影響，在 integer 或 fraction 中必須至少有一個十六進制數(shù)碼。 此語法類似于 C99 標準的 6.4.4.2 小節(jié)中所描述的語法，也是 Java 1.5 以上所使用的語法。 特別地，float.hex() 的輸出可以用作 C 或 Java 代碼中的十六進制浮點數(shù)字面值，而由 C 的 %a 格式字符或 Java 的 Double.toHexString 所生成的十六進制數(shù)字符串由為 float.fromhex() 所接受。

請注意 exponent 是十進制數(shù)而非十六進制數(shù)，它給出要與系數(shù)相乘的 2 的冪次。 例如，十六進制數(shù)字符串 0x3.a7p10 表示浮點數(shù) (3 + 10./16 + 7./16**2) * 2.0**10 即 3740.0:

>>> float.fromhex('0x3.a7p10')
3740.0

對 3740.0 應(yīng)用反向轉(zhuǎn)換會得到另一個代表相同數(shù)值的十六進制數(shù)字符串:

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

數(shù)字類型的哈希運算?

對于可能為不同類型的數(shù)字 x 和 y，要求 x == y 時必定 hash(x) == hash(y) (詳情參見 __hash__() 方法的文檔)。 為了便于在各種數(shù)字類型 (包括 int, float, decimal.Decimal 和 fractions.Fraction) 上實現(xiàn)并保證效率，Python 對數(shù)字類型的哈希運算是基于為任意有理數(shù)定義統(tǒng)一的數(shù)學(xué)函數(shù)，因此該運算對 int 和 fractions.Fraction 的全部實例，以及 float 和 decimal.Decimal 的全部有限實例均可用。 從本質(zhì)上說，此函數(shù)是通過以一個固定質(zhì)數(shù) P 進行 P 降模給出的。 P 的值在 Python 中可以 sys.hash_info 的 modulus 屬性的形式被訪問。

CPython implementation detail: 目前所用的質(zhì)數(shù)設(shè)定，在 C long 為 32 位的機器上 P = 2**31 - 1 而在 C long 為 64 位的機器上 P = 2**61 - 1。

詳細規(guī)則如下所述:

  • 如果 x = m / n 是一個非負的有理數(shù)且 n 不可被 P 整除，則定義 hash(x) 為 m * invmod(n, P) % P，其中 invmod(n, P) 是對 n 模 P 取反。

  • 如果 x = m / n 是一個非負的有理數(shù)且 n 可被 P 整除（但 m 不能）則 n 不能對 P 降模，以上規(guī)則不適用；在此情況下則定義 hash(x) 為常數(shù)值 sys.hash_info.inf。

  • 如果 x = m / n 是一個負的有理數(shù)則定義 hash(x) 為 -hash(-x)。 如果結(jié)果哈希值為 -1 則將其替換為 -2。

  • 特定值 sys.hash_info.inf, -sys.hash_info.inf 和 sys.hash_info.nan 被用作正無窮、負無窮和空值（所分別對應(yīng)的）哈希值。 （所有可哈希的空值都具有相同的哈希值。）

  • 對于一個 complex 值 z，會通過計算 hash(z.real) + sys.hash_info.imag * hash(z.imag) 將實部和虛部的哈希值結(jié)合起來，并進行降模 2**sys.hash_info.width 以使其處于 range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)) 范圍之內(nèi)。 同樣地，如果結(jié)果為 -1 則將其替換為 -2。

為了闡明上述規(guī)則，這里有一些等價于內(nèi)置哈希算法的 Python 代碼示例，可用于計算有理數(shù)、float 或 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 支持在容器中進行迭代的概念。 這是通過使用兩個單獨方法來實現(xiàn)的；它們被用于允許用戶自定義類對迭代的支持。 將在下文中詳細描述的序列總是支持迭代方法。

容器對象要提供迭代支持，必須定義一個方法:

container.__iter__()?

返回一個迭代器對象。 該對象需要支持下文所述的迭代器協(xié)議。 如果容器支持不同的迭代類型，則可以提供額外的方法來專門地請求不同迭代類型的迭代器。 （支持多種迭代形式的對象的例子有同時支持廣度優(yōu)先和深度優(yōu)先遍歷的樹結(jié)構(gòu)。） 此方法對應(yīng)于 Python/C API 中 Python 對象類型結(jié)構(gòu)體的 tp_iter 槽位。

迭代器對象自身需要支持以下兩個方法，它們共同組成了 迭代器協(xié)議:

iterator.__iter__()?

返回迭代器對象本身。 這是同時允許容器和迭代器配合 for 和 in 語句使用所必須的。 此方法對應(yīng)于 Python/C API 中 Python 對象類型結(jié)構(gòu)體的 tp_iter 槽位。

iterator.__next__()?

從容器中返回下一項。 如果已經(jīng)沒有項可返回，則會引發(fā) StopIteration 異常。 此方法對應(yīng)于 Python/C API 中 Python 對象類型結(jié)構(gòu)體的 tp_iternext 槽位。

Python 定義了幾種迭代器對象以支持對一般和特定序列類型、字典和其他更特別的形式進行迭代。 除了迭代器協(xié)議的實現(xiàn)，特定類型的其他性質(zhì)對迭代操作來說都不重要。

一旦迭代器的 __next__() 方法引發(fā)了 StopIteration，它必須一直對后續(xù)調(diào)用引發(fā)同樣的異常。 不遵循此行為特性的實現(xiàn)將無法正常使用。

生成器類型?

Python 的 generator 提供了一種實現(xiàn)迭代器協(xié)議的便捷方式。 如果容器對象 __iter__() 方法被實現(xiàn)為一個生成器，它將自動返回一個迭代器對象（從技術(shù)上說是一個生成器對象），該對象提供 __iter__() 和 __next__() 方法。 有關(guān)生成器的更多信息可以參閱 yield 表達式的文檔。

序列類型 --- list, tuple, range?

有三種基本序列類型：list, tuple 和 range 對象。 為處理 二進制數(shù)據(jù) 和 文本字符串 而特別定制的附加序列類型會在專門的小節(jié)中描述。

通用序列操作?

大多數(shù)序列類型，包括可變類型和不可變類型都支持下表中的操作。 collections.abc.Sequence ABC 被提供用來更容易地在自定義序列類型上正確地實現(xiàn)這些操作。

此表按優(yōu)先級升序列出了序列操作。 在表格中，s 和 t 是具有相同類型的序列，n, i, j 和 k 是整數(shù)而 x 是任何滿足 s 所規(guī)定的類型和值限制的任意對象。

in 和 not in 操作具有與比較操作相同的優(yōu)先級。 + (拼接) 和 * (重復(fù)) 操作具有與對應(yīng)數(shù)值運算相同的優(yōu)先級。 3

運算

結(jié)果：

注釋

x in s

如果 s 中的某項等于 x 則結(jié)果為 True，否則為 False

(1)

x not in s

如果 s 中的某項等于 x 則結(jié)果為 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 中首次出現(xiàn)項的索引號（索引號在 i 或其后且在 j 之前）

(8)

s.count(x)

x 在 s 中出現(xiàn)的總次數(shù)

相同類型的序列也支持比較。 特別地，tuple 和 list 的比較是通過比較對應(yīng)元素的字典順序。 這意味著想要比較結(jié)果相等，則每個元素比較結(jié)果都必須相等，并且兩個序列長度必須相同。 （完整細節(jié)請參閱語言參考的 比較運算 部分。）

注釋:

  1. 雖然 in 和 not in 操作在通常情況下僅被用于簡單的成員檢測，某些專門化序列 (例如 str, bytes 和 bytearray) 也使用它們進行子序列檢測:

    >>> "gg" in "eggs"
True

  2. 小于 0 的 n 值會被當作 0 來處理 (生成一個與 s 同類型的空序列)。 請注意序列 s 中的項并不會被拷貝；它們會被多次引用。 這一點經(jīng)常會令 Python 編程新手感到困擾；例如:

    >>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]

    具體的原因在于 [[]] 是一個包含了一個空列表的單元素列表，所以 [[]] * 3 結(jié)果中的三個元素都是對這一個空列表的引用。 修改 lists 中的任何一個元素實際上都是對這一個空列表的修改。 你可以用以下方式創(chuàng)建以不同列表為元素的列表:

    >>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]

    進一步的解釋可以在 FAQ 條目 如何創(chuàng)建多維列表？ 中查看。

  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. 拼接不可變序列總是會生成新的對象。 這意味著通過重復(fù)拼接來構(gòu)建序列的運行時開銷將會基于序列總長度的乘方。 想要獲得線性的運行時開銷，你必須改用下列替代方案之一：

    • 如果拼接 str 對象，你可以構(gòu)建一個列表并在最后使用 str.join() 或是寫入一個 io.StringIO 實例并在結(jié)束時獲取它的值

    • 如果拼接 bytes 對象，你可以類似地使用 bytes.join() 或 io.BytesIO，或者你也可以使用 bytearray 對象進行原地拼接。 bytearray 對象是可變的，并且具有高效的重分配機制

    • 如果拼接 tuple 對象，請改為擴展 list 類

    • 對于其它類型，請查看相應(yīng)的文檔

  7. 某些序列類型 (例如 range) 僅支持遵循特定模式的項序列，因此并不支持序列拼接或重復(fù)。

  8. 當 x 在 s 中找不到時 index 會引發(fā) ValueError。 不是所有實現(xiàn)都支持傳入額外參數(shù) i 和 j。 這兩個參數(shù)允許高效地搜索序列的子序列。 傳入這兩個額外參數(shù)大致相當于使用 s[i:j].index(x)，但是不會復(fù)制任何數(shù)據(jù)，并且返回的索引是相對于序列的開頭而非切片的開頭。

不可變序列類型?

不可變序列類型普遍實現(xiàn)而可變序列類型未實現(xiàn)的唯一操作就是對 hash() 內(nèi)置函數(shù)的支持。

這種支持允許不可變類型，例如 tuple 實例被用作 dict 鍵，以及存儲在 set 和 frozenset 實例中。

嘗試對包含有不可哈希值的不可變序列進行哈希運算將會導(dǎo)致 TypeError。

可變序列類型?

以下表格中的操作是在可變序列類型上定義的。 collections.abc.MutableSequence ABC 被提供用來更容易地在自定義序列類型上正確實現(xiàn)這些操作。

表格中的 s 是可變序列類型的實例，t 是任意可迭代對象，而 x 是符合對 s 所規(guī)定類型與值限制的任何對象 (例如，bytearray 僅接受滿足 0 <= x <= 255 值限制的整數(shù))。

運算

結(jié)果：

注釋

s[i] = x

將 s 的第 i 項替換為 x

s[i:j] = t

將 s 從 i 到 j 的切片替換為可迭代對象 t 的內(nèi)容

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

創(chuàng)建 s 的淺拷貝 (等同于 s[:])

(5)

s.extend(t) 或 s += t

用 t 的內(nèi)容擴展 s (基本上等同于 s[len(s):len(s)] = t)

s *= n

使用 s 的內(nèi)容重復(fù) 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. 可選參數(shù) i 默認為 -1，因此在默認情況下會移除并返回最后一項。

  3. 當在 s 中找不到 x 時 remove 操作會引發(fā) ValueError。

  4. 當反轉(zhuǎn)大尺寸序列時 reverse() 方法會原地修改該序列以保證空間經(jīng)濟性。 為提醒用戶此操作是通過間接影響進行的，它并不會返回反轉(zhuǎn)后的序列。

  5. 包括 clear() 和 copy() 是為了與不支持切片操作的可變?nèi)萜?(例如 dict 和 set) 的接口保持一致

    3.3 新版功能: clear() 和 copy() 方法。

  6. n 值為一個整數(shù)，或是一個實現(xiàn)了 __index__() 的對象。 n 值為零或負數(shù)將清空序列。 序列中的項不會被拷貝；它們會被多次引用，正如 通用序列操作 中有關(guān) s * n 的說明。

列表?

列表是可變序列，通常用于存放同類項目的集合（其中精確的相似程度將根據(jù)應(yīng)用而變化）。

class list([iterable])?

可以用多種方式構(gòu)建列表：

  • 使用一對方括號來表示空列表: []

  • 使用方括號，其中的項以逗號分隔: [a], [a, b, c]

  • 使用列表推導(dǎo)式: [x for x in iterable]

  • 使用類型的構(gòu)造器: list() 或 list(iterable)

構(gòu)造器將構(gòu)造一個列表，其中的項與 iterable 中的項具有相同的的值與順序。 iterable 可以是序列、支持迭代的容器或其它可迭代對象。 如果 iterable 已經(jīng)是一個列表，將創(chuàng)建并返回其副本，類似于 iterable[:]。 例如，list('abc') 返回 ['a', 'b', 'c'] 而 list( (1, 2, 3) ) 返回 [1, 2, 3]。 如果沒有給出參數(shù)，構(gòu)造器將創(chuàng)建一個空列表 []。

其它許多操作也會產(chǎn)生列表，包括 sorted() 內(nèi)置函數(shù)。

列表實現(xiàn)了所有 一般 和 可變 序列的操作。 列表還額外提供了以下方法：

sort(*, key=None, reverse=False)?

此方法會對列表進行原地排序，只使用 < 來進行各項間比較。 異常不會被屏蔽 —— 如果有任何比較操作失敗，整個排序操作將失?。ǘ斜砜赡軙幱诒徊糠中薷牡臓顟B(tài)）。

sort() 接受兩個僅限以關(guān)鍵字形式傳入的參數(shù) (僅限關(guān)鍵字參數(shù)):

key 指定帶有一個參數(shù)的函數(shù)，用于從每個列表元素中提取比較鍵 (例如 key=str.lower)。 對應(yīng)于列表中每一項的鍵會被計算一次，然后在整個排序過程中使用。 默認值 None 表示直接對列表項排序而不計算一個單獨的鍵值。

可以使用 functools.cmp_to_key() 將 2.x 風(fēng)格的 cmp 函數(shù)轉(zhuǎn)換為 key 函數(shù)。

reverse 為一個布爾值。 如果設(shè)為 True，則每個列表元素將按反向順序比較進行排序。

當順序大尺寸序列時此方法會原地修改該序列以保證空間經(jīng)濟性。 為提醒用戶此操作是通過間接影響進行的，它并不會返回排序后的序列（請使用 sorted() 顯示地請求一個新的已排序列表實例）。

sort() 方法確保是穩(wěn)定的。 如果一個排序確保不會改變比較結(jié)果相等的元素的相對順序就稱其為穩(wěn)定的 --- 這有利于進行多重排序（例如先按部門、再接薪級排序）。

CPython implementation detail: 在一個列表被排序期間，嘗試改變甚至進行檢測也會造成未定義的影響。 Python 的 C 實現(xiàn)會在排序期間將列表顯示為空，如果發(fā)現(xiàn)列表在排序期間被改變將會引發(fā) ValueError。

元組?

元組是不可變序列，通常用于儲存異構(gòu)數(shù)據(jù)的多項集（例如由 enumerate() 內(nèi)置函數(shù)所產(chǎn)生的二元組）。 元組也被用于需要同構(gòu)數(shù)據(jù)的不可變序列的情況（例如允許存儲到 set 或 dict 的實例）。

class tuple([iterable])?

可以用多種方式構(gòu)建元組：

  • 使用一對圓括號來表示空元組: ()

  • 使用一個后綴的逗號來表示單元組: a, 或 (a,)

  • 使用以逗號分隔的多個項: a, b, c or (a, b, c)

  • 使用內(nèi)置的 tuple(): tuple() 或 tuple(iterable)

構(gòu)造器將構(gòu)造一個元組，其中的項與 iterable 中的項具有相同的值與順序。 iterable 可以是序列、支持迭代的容器或其他可迭代對象。 如果 iterable 已經(jīng)是一個元組，會不加改變地將其返回。 例如，tuple('abc') 返回 ('a', 'b', 'c') 而 tuple( [1, 2, 3] ) 返回 (1, 2, 3)。 如果沒有給出參數(shù)，構(gòu)造器將創(chuàng)建一個空元組 ()。

請注意決定生成元組的其實是逗號而不是圓括號。 圓括號只是可選的，生成空元組或需要避免語法歧義的情況除外。 例如，f(a, b, c) 是在調(diào)用函數(shù)時附帶三個參數(shù)，而 f((a, b, c)) 則是在調(diào)用函數(shù)時附帶一個三元組。

元組實現(xiàn)了所有 一般 序列的操作。

對于通過名稱訪問相比通過索引訪問更清晰的異構(gòu)數(shù)據(jù)多項集，collections.namedtuple() 可能是比簡單元組對象更為合適的選擇。

range 對象?

range 類型表示不可變的數(shù)字序列，通常用于在 for 循環(huán)中循環(huán)指定的次數(shù)。

class range(stop)?
class range(start, stop[, step])

range 構(gòu)造器的參數(shù)必須為整數(shù)（可以是內(nèi)置的 int 或任何實現(xiàn)了 __index__ 特殊方法的對象）。 如果省略 step 參數(shù)，其默認值為 1。 如果省略 start 參數(shù)，其默認值為 0，如果 step 為零則會引發(fā) ValueError。

如果 step 為正值，確定 range r 內(nèi)容的公式為 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。

如果 step 為負值，確定 range 內(nèi)容的公式仍然為 r[i] = start + step*i，但限制條件改為 i >= 0 且 r[i] > stop.

如果 r[0] 不符合值的限制條件，則該 range 對象為空。 range 對象確實支持負索引，但是會將其解讀為從正索引所確定的序列的末尾開始索引。

元素絕對值大于 sys.maxsize 的 range 對象是被允許的，但某些特性 (例如 len()) 可能引發(fā) 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 對象實現(xiàn)了 一般 序列的所有操作，但拼接和重復(fù)除外（這是由于 range 對象只能表示符合嚴格模式的序列，而重復(fù)和拼接通常都會違反這樣的模式）。

start?

start 形參的值 (如果該形參未提供則為 0)

stop?

stop 形參的值

step?

step 形參的值 (如果該形參未提供則為 1)

range 類型相比常規(guī) list 或 tuple 的優(yōu)勢在于一個 range 對象總是占用固定數(shù)量的（較?。﹥?nèi)存，不論其所表示的范圍有多大（因為它只保存了 start, stop 和 step 值，并會根據(jù)需要計算具體單項或子范圍的值）。

range 對象實現(xiàn)了 collections.abc.Sequence ABC，提供如包含檢測、元素索引查找、切片等特性，并支持負索引 (參見 序列類型 --- list, tuple, range):

>>> 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 對象表示相同的值序列就認為它們是相等的。 （請注意比較結(jié)果相等的兩個 range 對象可能會具有不同的 start, stop 和 step 屬性，例如 range(0) == range(2, 1, 3) 而 range(0, 3, 2) == range(0, 4, 2)。）

在 3.2 版更改: 實現(xiàn) Sequence ABC。 支持切片和負數(shù)索引。 使用 int 對象在固定時間內(nèi)進行成員檢測，而不是逐一迭代所有項。

在 3.3 版更改: 定義 '==' 和 '!=' 以根據(jù) range 對象所定義的值序列來進行比較（而不是根據(jù)對象的標識）。

3.3 新版功能: start, stop 和 step 屬性。

參見

  • linspace recipe 演示了如何實現(xiàn)一個延遲求值版本的適合浮點數(shù)應(yīng)用的 range 對象。

文本序列類型 --- str?

在 Python 中處理文本數(shù)據(jù)是使用 str 對象，也稱為 字符串。 字符串是由 Unicode 碼位構(gòu)成的不可變 序列。 字符串字面值有多種不同的寫法：

  • 單引號: '允許包含有 "雙" 引號'

  • 雙引號: "允許包含有 '單' 引號"。

  • 三重引號: '''三重單引號''', """三重雙引號"""

使用三重引號的字符串可以跨越多行 —— 其中所有的空白字符都將包含在該字符串字面值中。

作為單一表達式組成部分，之間只由空格分隔的多個字符串字面值會被隱式地轉(zhuǎn)換為單個字符串字面值。 也就是說，("spam " "eggs") == "spam eggs"。

請參閱 字符串和字節(jié)串字面值 有解有關(guān)不同字符串字面值的更多信息，包括所支持的轉(zhuǎn)義序列，以及使用 r ("raw") 前綴來禁用大多數(shù)轉(zhuǎn)義序列的處理。

字符串也可以通過使用 str 構(gòu)造器從其他對象創(chuàng)建。

由于不存在單獨的“字符”類型，對字符串做索引操作將產(chǎn)生一個長度為 1 的字符串。 也就是說，對于一個非空字符串 s, s[0] == s[0:1]。

不存在可變的字符串類型，但是 str.join() 或 io.StringIO 可以被被用來根據(jù)多個片段高效率地構(gòu)建字符串。

在 3.3 版更改: 為了與 Python 2 系列的向下兼容，再次允許字符串字面值使用 u 前綴。 它對字符串字面值的含義沒有影響，并且不能與 r 前綴同時出現(xiàn)。

class str(object='')?
class str(object=b'', encoding='utf-8', errors='strict')

返回 object 的 字符串 版本。 如果未提供 object 則返回空字符串。 在其他情況下 str() 的行為取決于 encoding 或 errors 是否有給出，具體見下。

如果 encoding 或 errors 均未給出，str(object) 返回 object.__str__()，這是 object 的“非正式”或格式良好的字符串表示。 對于字符串對象，這是該字符串本身。 如果 object 沒有 __str__() 方法，則 str() 將回退為返回 repr(object)。

如果 encoding 或 errors 至少給出其中之一，則 object 應(yīng)該是一個 bytes-like object (例如 bytes 或 bytearray)。 在此情況下，如果 object 是一個 bytes (或 bytearray) 對象，則 str(bytes, encoding, errors) 等價于 bytes.decode(encoding, errors)。 否則的話，會在調(diào)用 bytes.decode() 之前獲取緩沖區(qū)對象下層的 bytes 對象。 請參閱 二進制序列類型 --- bytes, bytearray, memoryview 與 緩沖協(xié)議 了解有關(guān)緩沖區(qū)對象的信息。

將一個 bytes 對象傳入 str() 而不給出 encoding 或 errors 參數(shù)的操作屬于第一種情況， 將返回非正式的字符串表示（另請參閱 Python 的 -b 命令行選項）。 例如:

>>> str(b'Zoot!')
"b'Zoot!'"

有關(guān) str 類及其方法的更多信息，請參閱下面的 文本序列類型 --- str 和 字符串的方法 小節(jié)。 要輸出格式化字符串，請參閱 格式化字符串字面值 和 格式字符串語法 小節(jié)。 此外還可以參閱 文本處理服務(wù) 小節(jié)。

字符串的方法?

字符串實現(xiàn)了所有 一般 序列的操作，還額外提供了以下列出的一些附加方法。

字符串還支持兩種字符串格式化樣式，一種提供了很大程度的靈活性和可定制性 (參閱 str.format(), 格式字符串語法 和 自定義字符串格式化) 而另一種是基于 C printf 樣式的格式化，它可處理的類型范圍較窄，并且更難以正確使用，但對于它可處理的情況往往會更為快速 (printf 風(fēng)格的字符串格式化)。

標準庫的 文本處理服務(wù) 部分涵蓋了許多其他模塊，提供各種文本相關(guān)工具（例如包含于 re 模塊中的正則表達式支持）。

str.capitalize()?

返回原字符串的副本，其首個字符大寫，其余為小寫。

str.casefold()?

返回原字符串消除大小寫的副本。 消除大小寫的字符串可用于忽略大小寫的匹配。

消除大小寫類似于轉(zhuǎn)為小寫，但是更加徹底一些，因為它會移除字符串中的所有大小寫變化形式。 例如，德語小寫字母 '?' 相當于 "ss"。 由于它已經(jīng)是小寫了，lower() 不會對 '?' 做任何改變；而 casefold() 則會將其轉(zhuǎn)換為 "ss"。

消除大小寫算法的描述請參見 Unicode 標準的 3.13 節(jié)。

3.3 新版功能.

str.center(width[, fillchar])?

返回長度為 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充兩邊的空位（默認使用 ASCII 空格符）。 如果 width 小于等于 len(s) 則返回原字符串的副本。

str.count(sub[, start[, end]])?

返回子字符串 sub 在 [start, end] 范圍內(nèi)非重疊出現(xiàn)的次數(shù)。 可選參數(shù) start 與 end 會被解讀為切片表示法。

str.encode(encoding="utf-8", errors="strict")?

返回原字符串編碼為字節(jié)串對象的版本。 默認編碼為 'utf-8'。 可以給出 errors 來設(shè)置不同的錯誤處理方案。 errors 的默認值為 'strict'，表示編碼錯誤會引發(fā) UnicodeError。 其他可用的值為 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及任何其他通過 codecs.register_error() 注冊的值，請參閱 錯誤處理方案 小節(jié)。 要查看可用的編碼列表，請參閱 標準編碼 小節(jié)。

在 3.1 版更改: 加入了對關(guān)鍵字參數(shù)的支持。

str.endswith(suffix[, start[, end]])?

如果字符串以指定的 suffix 結(jié)束返回 True，否則返回 False。 suffix 也可以為由多個供查找的后綴構(gòu)成的元組。 如果有可選項 start，將從所指定位置開始檢查。 如果有可選項 end，將在所指定位置停止比較。

str.expandtabs(tabsize=8)?

返回字符串的副本，其中所有的制表符會由一個或多個空格替換，具體取決于當前列位置和給定的制表符寬度。 每 tabsize 個字符設(shè)為一個制表位（默認值 8 時設(shè)定的制表位在列 0, 8, 16 依次類推）。 要展開字符串，當前列將被設(shè)為零并逐一檢查字符串中的每個字符。 如果字符為制表符 (\t)，則會在結(jié)果中插入一個或多個空格符，直到當前列等于下一個制表位。 （制表符本身不會被復(fù)制。） 如果字符為換行符 (\n) 或回車符 (\r)，它會被復(fù)制并將當前列重設(shè)為零。 任何其他字符會被不加修改地復(fù)制并將當前列加一，不論該字符在被打印時會如何顯示。

>>> '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] 切片內(nèi)被找到的最小索引。 可選參數(shù) start 與 end 會被解讀為切片表示法。 如果 sub 未被找到則返回 -1。

注解

find() 方法應(yīng)該只在你需要知道 sub 所在位置時使用。 要檢查 sub 是否為子字符串，請使用 in 操作符:

>>> 'Py' in 'Python'
True
str.format(*args, **kwargs)?

執(zhí)行字符串格式化操作。 調(diào)用此方法的字符串可以包含字符串字面值或者以花括號 {} 括起來的替換域。 每個替換域可以包含一個位置參數(shù)的數(shù)字索引，或者一個關(guān)鍵字參數(shù)的名稱。 返回的字符串副本中每個替換域都會被替換為對應(yīng)參數(shù)的字符串值。

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

請參閱 格式字符串語法 了解有關(guān)可以在格式字符串中指定的各種格式選項的說明。

注解

當使用 n 類型 (例如: '{:n}'.format(1234)) 來格式化數(shù)字 (int, float, complex, decimal.Decimal 及其子類) 的時候，該函數(shù)會臨時性地將 LC_CTYPE 區(qū)域設(shè)置為 LC_NUMERIC 區(qū)域以解碼 localeconv() 的 decimal_point 和 thousands_sep 字段，如果它們是非 ASCII 字符或長度超過 1 字節(jié)的話，并且 LC_NUMERIC 區(qū)域會與 LC_CTYPE 區(qū)域不一致。 這個臨時更改會影響其他線程。

在 3.7 版更改: 當使用 n 類型格式化數(shù)字時，該函數(shù)在某些情況下會臨時性地將 LC_CTYPE 區(qū)域設(shè)置為 LC_NUMERIC 區(qū)域。

str.format_map(mapping)?

類似于 str.format(**mapping)，不同之處在于 mapping 會被直接使用而不是復(fù)制到一個 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()，但在找不到子類時會引發(fā) ValueError。

str.isalnum()?

如果字符串中的所有字符都是字母或數(shù)字且至少有一個字符，則返回 True ， 否則返回 False 。 如果 c.isalpha() ， c.isdecimal() ， c.isdigit() ，或 c.isnumeric() 之中有一個返回 True ，則字符``c``是字母或數(shù)字。

str.isalpha()?

如果字符串中的所有字符都是字母，并且至少有一個字符，返回 True ，否則返回 False 。字母字符是指那些在 Unicode 字符數(shù)據(jù)庫中定義為 "Letter" 的字符，即那些具有 "Lm"、"Lt"、"Lu"、"Ll" 或 "Lo" 之一的通用類別屬性的字符。 注意，這與 Unicode 標準中定義的"字母"屬性不同。

str.isascii()?

如果字符串為空或字符串中的所有字符都是 ASCII ，返回 True ，否則返回 False 。ASCII 字符的碼點范圍是 U+0000-U+007F 。

3.7 新版功能.

str.isdecimal()?

如果字符串中的所有字符都是十進制字符且該字符串至少有一個字符，則返回 True ， 否則返回 False 。十進制字符指那些可以用來組成10進制數(shù)字的字符，例如 U+0660 ，即阿拉伯字母數(shù)字0 。 嚴格地講，十進制字符是 Unicode 通用類別 "Nd" 中的一個字符。

str.isdigit()?

如果字符串中的所有字符都是數(shù)字，并且至少有一個字符，返回 True ，否則返回 False 。 數(shù)字包括十進制字符和需要特殊處理的數(shù)字，如兼容性上標數(shù)字。這包括了不能用來組成十進制數(shù)的數(shù)字，如 Kharosthi 數(shù)。 嚴格地講，數(shù)字是指屬性值為 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。

str.isidentifier()?

如果字符串是有效的標識符，返回 True ，依據(jù)語言定義， 標識符和關(guān)鍵字 節(jié)。

請使用 keyword.iskeyword() 來檢測保留標識符，例如 def 和 class。

str.islower()?

如果字符串中至少有一個區(qū)分大小寫的字符 4 且此類字符均為小寫則返回 True ，否則返回 False 。

str.isnumeric()?

如果字符串中至少有一個字符且所有字符均為數(shù)值字符則返回 True ，否則返回 False 。 數(shù)值字符包括數(shù)字字符，以及所有在 Unicode 中設(shè)置了數(shù)值特性屬性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定義為：數(shù)值字符就是具有特征屬性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。

str.isprintable()?

如果字符串中所有字符均為可打印字符或字符串為空則返回 True ，否則返回 False 。 不可打印字符是在 Unicode 字符數(shù)據(jù)庫中被定義為 "Other" 或 "Separator" 的字符，例外情況是 ASCII 空格字符 (0x20) 被視作可打印字符。 （請注意在此語境下可打印字符是指當對一個字符串發(fā)起調(diào)用 repr() 時不必被轉(zhuǎn)義的字符。 它們與字符串寫入 sys.stdout 或 sys.stderr 時所需的處理無關(guān)。）

str.isspace()?

如果字符串中只有空白字符且至少有一個字符則返回 True ，否則返回 False 。

空白 字符是指在 Unicode 字符數(shù)據(jù)庫 (參見 unicodedata) 中主要類別為 Zs ("Separator, space") 或所屬雙向類為 WS, B 或 S 的字符。

str.istitle()?

如果字符串中至少有一個字符且為標題字符串則返回 True ，例如大寫字符之后只能帶非大寫字符而小寫字符必須有大寫字符打頭。 否則返回 False 。

str.isupper()?

如果字符串中至少有一個區(qū)分大小寫的字符 4 且此類字符均為大寫則返回 True ，否則返回 False 。

str.join(iterable)?

返回一個由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 對象則會引發(fā) TypeError。 調(diào)用該方法的字符串將作為元素之間的分隔。

str.ljust(width[, fillchar])?

返回長度為 width 的字符串，原字符串在其中靠左對齊。 使用指定的 fillchar 填充空位 (默認使用 ASCII 空格符)。 如果 width 小于等于 len(s) 則返回原字符串的副本。

str.lower()?

返回原字符串的副本，其所有區(qū)分大小寫的字符 4 均轉(zhuǎn)換為小寫。

所用轉(zhuǎn)換小寫算法的描述請參見 Unicode 標準的 3.13 節(jié)。

str.lstrip([chars])?

返回原字符串的副本，移除其中的前導(dǎo)字符。 chars 參數(shù)為指定要移除字符的字符串。 如果省略或為 None，則 chars 參數(shù)默認移除空白符。 實際上 chars 參數(shù)并非指定單個前綴；而是會移除參數(shù)值的所有組合:

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'
static str.maketrans(x[, y[, z]])?

此靜態(tài)方法返回一個可供 str.translate() 使用的轉(zhuǎn)換對照表。

如果只有一個參數(shù)，則它必須是一個將 Unicode 碼位序號（整數(shù)）或字符（長度為 1 的字符串）映射到 Unicode 碼位序號、（任意長度的）字符串或 None 的字典。 字符鍵將會被轉(zhuǎn)換為碼位序號。

如果有兩個參數(shù)，則它們必須是兩個長度相等的字符串，并且在結(jié)果字典中，x 中每個字符將被映射到 y 中相同位置的字符。 如果有第三個參數(shù)，它必須是一個字符串，其中的字符將在結(jié)果中被映射到 None。

str.partition(sep)?

在 sep 首次出現(xiàn)的位置拆分字符串，返回一個 3 元組，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，則返回的 3 元組中包含字符本身以及兩個空字符串。

str.replace(old, new[, count])?

返回字符串的副本，其中出現(xiàn)的所有子字符串 old 都將被替換為 new。 如果給出了可選參數(shù) count，則只替換前 count 次出現(xiàn)。

str.rfind(sub[, start[, end]])?

返回子字符串 sub 在字符串內(nèi)被找到的最大（最右）索引，這樣 sub 將包含在 s[start:end] 當中。 可選參數(shù) start 與 end 會被解讀為切片表示法。 如果未找到則返回 -1。

str.rindex(sub[, start[, end]])?

類似于 rfind()，但在子字符串 sub 未找到時會引發(fā) ValueError。

str.rjust(width[, fillchar])?

返回長度為 width 的字符串，原字符串在其中靠右對齊。 使用指定的 fillchar 填充空位 (默認使用 ASCII 空格符)。 如果 width 小于等于 len(s) 則返回原字符串的副本。

str.rpartition(sep)?

在 sep 最后一次出現(xiàn)的位置拆分字符串，返回一個 3 元組，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，則返回的 3 元組中包含兩個空字符串以及字符串本身。

str.rsplit(sep=None, maxsplit=-1)?

返回一個由字符串內(nèi)單詞組成的列表，使用 sep 作為分隔字符串。 如果給出了 maxsplit，則最多進行 maxsplit 次拆分，從 最右邊 開始。 如果 sep 未指定或為 None，任何空白字符串都會被作為分隔符。 除了從右邊開始拆分，rsplit() 的其他行為都類似于下文所述的 split()。

str.rstrip([chars])?

返回原字符串的副本，移除其中的末尾字符。 chars 參數(shù)為指定要移除字符的字符串。 如果省略或為 None，則 chars 參數(shù)默認移除空白符。 實際上 chars 參數(shù)并非指定單個后綴；而是會移除參數(shù)值的所有組合:

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'
str.split(sep=None, maxsplit=-1)?

返回一個由字符串內(nèi)單詞組成的列表，使用 sep 作為分隔字符串。 如果給出了 maxsplit，則最多進行 maxsplit 次拆分（因此，列表最多會有 maxsplit+1 個元素）。 如果 maxsplit 未指定或為 -1，則不限制拆分次數(shù)（進行所有可能的拆分）。

如果給出了 sep，則連續(xù)的分隔符不會被組合在一起而是被視為分隔空字符串 (例如 '1,,2'.split(',') 將返回 ['1', '', '2'])。 sep 參數(shù)可能由多個字符組成 (例如 '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，則會應(yīng)用另一種拆分算法：連續(xù)的空格會被視為單個分隔符，其結(jié)果將不包含開頭或末尾的空字符串，如果字符串包含前綴或后綴空格的話。 因此，使用 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])?

返回由原字符串中各行組成的列表，在行邊界的位置拆分。 結(jié)果列表中不包含行邊界，除非給出了 keepends 且為真值。

此方法會以下列行邊界進行拆分。 特別地，行邊界是 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()，當給出了分隔字符串 sep 時，對于空字符串此方法將返回一個空列表，而末尾的換行不會令結(jié)果中增加額外的行:

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

作為比較，split('\n') 的結(jié)果為:

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']
str.startswith(prefix[, start[, end]])?

如果字符串以指定的 prefix 開始則返回 True，否則返回 False。 prefix 也可以為由多個供查找的前綴構(gòu)成的元組。 如果有可選項 start，將從所指定位置開始檢查。 如果有可選項 end，將在所指定位置停止比較。

str.strip([chars])?

返回原字符串的副本，移除其中的前導(dǎo)和末尾字符。 chars 參數(shù)為指定要移除字符的字符串。 如果省略或為 None，則 chars 參數(shù)默認移除空白符。 實際上 chars 參數(shù)并非指定單個前綴或后綴；而是會移除參數(shù)值的所有組合:

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

最外側(cè)的前導(dǎo)和末尾 chars 參數(shù)值將從字符串中移除。 開頭端的字符的移除將在遇到一個未包含于 chars 所指定字符集的字符時停止。 類似的操作也將在結(jié)尾端發(fā)生。 例如:

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'
str.swapcase()?

返回原字符串的副本，其中大寫字符轉(zhuǎn)換為小寫，反之亦然。 請注意 s.swapcase().swapcase() == s 并不一定為真值。

str.title()?

返回原字符串的標題版本，其中每個單詞第一個字母為大寫，其余字母為小寫。

例如

>>> 'Hello world'.title()
'Hello World'

該算法使用一種簡單的與語言無關(guān)的定義，將連續(xù)的字母組合視為單詞。 該定義在多數(shù)情況下都很有效，但它也意味著代表縮寫形式與所有格的撇號也會成為單詞邊界，這可能導(dǎo)致不希望的結(jié)果:

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

可以使用正則表達式來構(gòu)建針對撇號的特別處理:

>>> 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)?

返回原字符串的副本，其中每個字符按給定的轉(zhuǎn)換表進行映射。 轉(zhuǎn)換表必須是一個使用 __getitem__() 來實現(xiàn)索引操作的對象，通常為 mapping 或 sequence。 當以 Unicode 碼位序號（整數(shù)）為索引時，轉(zhuǎn)換表對象可以做以下任何一種操作：返回 Unicode 序號或字符串，將字符映射為一個或多個字符；返回 None，將字符從結(jié)果字符串中刪除；或引發(fā) LookupError 異常，將字符映射為其自身。

你可以使用 str.maketrans() 基于不同格式的字符到字符映射來創(chuàng)建一個轉(zhuǎn)換映射表。

另請參閱 codecs 模塊以了解定制字符映射的更靈活方式。

str.upper()?

返回原字符串的副本，其中所有區(qū)分大小寫的字符 4 均轉(zhuǎn)換為大寫。 請注意如果 s 包含不區(qū)分大小寫的字符或者如果結(jié)果字符的 Unicode 類別不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 則 s.upper().isupper() 有可能為 False。

所用轉(zhuǎn)換大寫算法的描述請參見 Unicode 標準的 3.13 節(jié)。

str.zfill(width)?

返回原字符串的副本，在左邊填充 ASCII '0' 數(shù)碼使其長度變?yōu)?width。 正負值前綴 ('+'/'-') 的處理方式是在正負符號 之后 填充而非在之前。 如果 width 小于等于 len(s) 則返回原字符串的副本。

例如

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

printf 風(fēng)格的字符串格式化?

注解

此處介紹的格式化操作具有多種怪異特性，可能導(dǎo)致許多常見錯誤（例如無法正確顯示元組和字典）。 使用較新的 格式化字符串字面值，str.format() 接口或 模板字符串 有助于避免這樣的錯誤。 這些替代方案中的每一種都更好地權(quán)衡并提供了簡單、靈活以及可擴展性優(yōu)勢。

字符串具有一種特殊的內(nèi)置操作：使用 % (取模) 運算符。 這也被稱為字符串的 格式化 或 插值 運算符。 對于 format % values (其中 format 為一個字符串)，在 format 中的 % 轉(zhuǎn)換標記符將被替換為零個或多個 values 條目。 其效果類似于在 C 語言中使用 sprintf()。

如果 format 要求一個單獨參數(shù)，則 values 可以為一個非元組對象。 5 否則的話，values 必須或者是一個包含項數(shù)與格式字符串中指定的轉(zhuǎn)換符項數(shù)相同的元組，或者是一個單獨映射對象（例如字典）。

轉(zhuǎn)換標記符包含兩個或更多字符并具有以下組成，且必須遵循此處規(guī)定的順序：

  1. '%' 字符，用于標記轉(zhuǎn)換符的起始。

  2. 映射鍵（可選），由加圓括號的字符序列組成 (例如 (somename))。

  3. 轉(zhuǎn)換旗標（可選），用于影響某些轉(zhuǎn)換類型的結(jié)果。

  4. 最小字段寬度（可選）。 如果指定為 '*' (星號)，則實際寬度會從 values 元組的下一元素中讀取，要轉(zhuǎn)換的對象則為最小字段寬度和可選的精度之后的元素。

  5. 精度（可選），以在 '.' (點號) 之后加精度值的形式給出。 如果指定為 '*' (星號)，則實際精度會從 values 元組的下一元素中讀取，要轉(zhuǎn)換的對象則為精度之后的元素。

  6. 長度修飾符（可選）。

  7. 轉(zhuǎn)換類型。

當右邊的參數(shù)為一個字典（或其他映射類型）時，字符串中的格式 必須 包含加圓括號的映射鍵，對應(yīng) '%' 字符之后字典中的每一項。 映射鍵將從映射中選取要格式化的值。 例如：

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

在此情況下格式中不能出現(xiàn) * 標記符（因其需要一個序列類的參數(shù)列表）。

轉(zhuǎn)換旗標為：

標志

含義

'#'

值的轉(zhuǎn)換將使用“替代形式”（具體定義見下文）。

'0'

轉(zhuǎn)換將為數(shù)字值填充零字符。

'-'

轉(zhuǎn)換值將靠左對齊（如果同時給出 '0' 轉(zhuǎn)換，則會覆蓋后者）。

' '

(空格) 符號位轉(zhuǎn)換產(chǎn)生的正數(shù)（或空字符串）前將留出一個空格。

'+'

符號字符 ('+' 或 '-') 將顯示于轉(zhuǎn)換結(jié)果的開頭（會覆蓋 "空格" 旗標）。

可以給出長度修飾符 (h, l 或 L)，但會被忽略，因為對 Python 來說沒有必要 -- 所以 %ld 等價于 %d。

轉(zhuǎn)換類型為：

轉(zhuǎn)換符

含義

注釋

'd'

有符號十進制整數(shù)。

'i'

有符號十進制整數(shù)。

'o'

有符號八進制數(shù)。

(1)

'u'

過時類型 -- 等價于 'd'。

(6)

'x'

有符號十六進制數(shù)（小寫）。

(2)

'X'

有符號十六進制數(shù)（大寫）。

(2)

'e'

浮點指數(shù)格式（小寫）。

(3)

'E'

浮點指數(shù)格式（大寫）。

(3)

'f'

浮點十進制格式。

(3)

'F'

浮點十進制格式。

(3)

'g'

浮點格式。 如果指數(shù)小于 -4 或不小于精度則使用小寫指數(shù)格式，否則使用十進制格式。

(4)

'G'

浮點格式。 如果指數(shù)小于 -4 或不小于精度則使用大寫指數(shù)格式，否則使用十進制格式。

(4)

'c'

單個字符（接受整數(shù)或單個字符的字符串）。

'r'

字符串（使用 repr() 轉(zhuǎn)換任何 Python 對象）。

(5)

's'

字符串（使用 str() 轉(zhuǎn)換任何 Python 對象）。

(5)

'a'

字符串（使用 ascii() 轉(zhuǎn)換任何 Python 對象）。

(5)

'%'

不轉(zhuǎn)換參數(shù)，在結(jié)果中輸出一個 '%' 字符。

注釋:

  1. 此替代形式會在第一個數(shù)碼之前插入標示八進制數(shù)的前綴 ('0o')。

  2. 此替代形式會在第一個數(shù)碼之前插入 '0x' 或 '0X' 前綴（取決于是使用 'x' 還是 'X' 格式）。

  3. 此替代形式總是會在結(jié)果中包含一個小數(shù)點，即使其后并沒有數(shù)碼。

    小數(shù)點后的數(shù)碼位數(shù)由精度決定，默認為 6。

  4. 此替代形式總是會在結(jié)果中包含一個小數(shù)點，末尾各位的零不會如其他情況下那樣被移除。

    小數(shù)點前后的有效數(shù)碼位數(shù)由精度決定，默認為 6。

  5. 如果精度為 N，輸出將截短為 N 個字符。

  6. 參見 PEP 237。

由于 Python 字符串顯式指明長度，%s 轉(zhuǎn)換不會將 '\0' 視為字符串的結(jié)束。

在 3.1 版更改: 絕對值超過 1e50 的 %f 轉(zhuǎn)換不會再被替換為 %g 轉(zhuǎn)換。

二進制序列類型 --- bytes, bytearray, memoryview?

操作二進制數(shù)據(jù)的核心內(nèi)置類型是 bytes 和 bytearray。 它們由 memoryview 提供支持，該對象使用 緩沖區(qū)協(xié)議 來訪問其他二進制對象所在內(nèi)存，不需要創(chuàng)建對象的副本。

array 模塊支持高效地存儲基本數(shù)據(jù)類型，例如 32 位整數(shù)和 IEEE754 雙精度浮點值。

bytes 對象?

bytes 對象是由單個字節(jié)構(gòu)成的不可變序列。 由于許多主要二進制協(xié)議都基于 ASCII 文本編碼，因此 bytes 對象提供了一些僅在處理 ASCII 兼容數(shù)據(jù)時可用，并且在許多特性上與字符串對象緊密相關(guān)的方法。

class bytes([source[, encoding[, errors]]])?

首先，表示 bytes 字面值的語法與字符串字面值的大致相同，只是添加了一個 b 前綴：

  • 單引號: b'同樣允許嵌入 "雙" 引號'。

  • 雙引號: b"同樣允許嵌入 '單' 引號"。

  • 三重引號: b'''三重單引號''', b"""三重雙引號"""

bytes 字面值中只允許 ASCII 字符（無論源代碼聲明的編碼為何）。 任何超出 127 的二進制值必須使用相應(yīng)的轉(zhuǎn)義序列形式加入 bytes 字面值。

像字符串字面值一樣，bytes 字面值也可以使用 r 前綴來禁用轉(zhuǎn)義序列處理。 請參閱 字符串和字節(jié)串字面值 了解有關(guān)各種 bytes 字面值形式的詳情，包括所支持的轉(zhuǎn)義序列。

雖然 bytes 字面值和表示法是基于 ASCII 文本的，但 bytes 對象的行為實際上更像是不可變的整數(shù)序列，序列中的每個值的大小被限制為 0 <= x < 256 (如果違反此限制將引發(fā) ValueError)。 這種限制是有意設(shè)計用以強調(diào)以下事實，雖然許多二進制格式都包含基于 ASCII 的元素，可以通過某些面向文本的算法進行有用的操作，但情況對于任意二進制數(shù)據(jù)來說通常卻并非如此（盲目地將文本處理算法應(yīng)用于不兼容 ASCII 的二進制數(shù)據(jù)格式往往將導(dǎo)致數(shù)據(jù)損壞）。

除了字面值形式，bytes 對象還可以通過其他幾種方式來創(chuàng)建：

  • 指定長度的以零值填充的 bytes 對象: bytes(10)

  • 通過由整數(shù)組成的可迭代對象: bytes(range(20))

  • 通過緩沖區(qū)協(xié)議復(fù)制現(xiàn)有的二進制數(shù)據(jù): bytes(obj)

另請參閱 bytes 內(nèi)置類型。

由于兩個十六進制數(shù)碼精確對應(yīng)一個字節(jié)，因此十六進制數(shù)是描述二進制數(shù)據(jù)的常用格式。 相應(yīng)地，bytes 類型具有從此種格式讀取數(shù)據(jù)的附加類方法：

classmethod fromhex(string)?

此 bytes 類方法返回一個解碼給定字符串的 bytes 對象。 字符串必須由表示每個字節(jié)的兩個十六進制數(shù)碼構(gòu)成，其中的 ASCII 空白符會被忽略。

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

在 3.7 版更改: bytes.fromhex() 現(xiàn)在會忽略所有 ASCII 空白符而不只是空格符。

存在一個反向轉(zhuǎn)換函數(shù)，可以將 bytes 對象轉(zhuǎn)換為對應(yīng)的十六進制表示。

hex()?

返回一個字符串對象，該對象包含實例中每個字節(jié)的兩個十六進制數(shù)字。

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

3.5 新版功能.

由于 bytes 對象是由整數(shù)構(gòu)成的序列（類似于元組），因此對于一個 bytes 對象 b，b[0] 將為一個整數(shù)，而 b[0:1] 將為一個長度為 1 的 bytes 對象。 （這與文本字符串不同，索引和切片所產(chǎn)生的將都是一個長度為 1 的字符串）。

bytes 對象的表示使用字面值格式 (b'...')，因為它通常都要比像 bytes([46, 46, 46]) 這樣的格式更好用。 你總是可以使用 list(b) 將 bytes 對象轉(zhuǎn)換為一個由整數(shù)構(gòu)成的列表。

注解

針對 Python 2.x 用戶的說明：在 Python 2.x 系列中，允許 8 位字符串（ 2.x 所提供的最接近內(nèi)置二進制數(shù)據(jù)類型的對象）與 Unicode 字符串進行各種隱式轉(zhuǎn)換。 這是為了實現(xiàn)向下兼容的變通做法，以適應(yīng) Python 最初只支持 8 位文本而 Unicode 文本是后來才被加入這一事實。 在 Python 3.x 中，這些隱式轉(zhuǎn)換已被取消 —— 8 位二進制數(shù)據(jù)與 Unicode 文本間的轉(zhuǎn)換必須顯式地進行，bytes 與字符串對象的比較結(jié)果將總是不相等。

bytearray 對象?

bytearray 對象是 bytes 對象的可變對應(yīng)物。

class bytearray([source[, encoding[, errors]]])?

bytearray 對象沒有專屬的字面值語法，它們總是通過調(diào)用構(gòu)造器來創(chuàng)建：

  • 創(chuàng)建一個空實例: bytearray()

  • 創(chuàng)建一個指定長度的以零值填充的實例: bytearray(10)

  • 通過由整數(shù)組成的可迭代對象: bytearray(range(20))

  • 通過緩沖區(qū)協(xié)議復(fù)制現(xiàn)有的二進制數(shù)據(jù): bytearray(b'Hi!')

由于 bytearray 對象是可變的，該對象除了 bytes 和 bytearray 操作 中所描述的 bytes 和 bytearray 共有操作之外，還支持 可變 序列操作。

另請參見 bytearray 內(nèi)置類型。

由于兩個十六進制數(shù)碼精確對應(yīng)一個字節(jié)，因此十六進制數(shù)是描述二進制數(shù)據(jù)的常用格式。 相應(yīng)地，bytearray 類型具有從此種格式讀取數(shù)據(jù)的附加類方法：

classmethod fromhex(string)?

bytearray 類方法返回一個解碼給定字符串的 bytearray 對象。 字符串必須由表示每個字節(jié)的兩個十六進制數(shù)碼構(gòu)成，其中的 ASCII 空白符會被忽略。

>>> bytearray.fromhex('2Ef0 F1f2  ')
bytearray(b'.\xf0\xf1\xf2')

在 3.7 版更改: bytearray.fromhex() 現(xiàn)在會忽略所有 ASCII 空白符而不只是空格符。

存在一個反向轉(zhuǎn)換函數(shù)，可以將 bytearray 對象轉(zhuǎn)換為對應(yīng)的十六進制表示。

hex()?

返回一個字符串對象，該對象包含實例中每個字節(jié)的兩個十六進制數(shù)字。

>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'

3.5 新版功能.

由于 bytearray 對象是由整數(shù)構(gòu)成的序列（類似于列表），因此對于一個 bytearray 對象 b，b[0] 將為一個整數(shù)，而 b[0:1] 將為一個長度為 1 的 bytearray 對象。 （這與文本字符串不同，索引和切片所產(chǎn)生的將都是一個長度為 1 的字符串）。

bytearray 對象的表示使用 bytes 對象字面值格式 (bytearray(b'...'))，因為它通常都要比 bytearray([46, 46, 46]) 這樣的格式更好用。 你總是可以使用 list(b) 將 bytearray 對象轉(zhuǎn)換為一個由整數(shù)構(gòu)成的列表。

bytes 和 bytearray 操作?

bytes 和 bytearray 對象都支持 通用 序列操作。 它們不僅能與相同類型的操作數(shù)，也能與任何 bytes-like object 進行互操作。 由于這樣的靈活性，它們可以在操作中自由地混合而不會導(dǎo)致錯誤。 但是，操作結(jié)果的返回值類型可能取決于操作數(shù)的順序。

注解

bytes 和 bytearray 對象的方法不接受字符串作為其參數(shù)，就像字符串的方法不接受 bytes 對象作為其參數(shù)一樣。 例如，你必須使用以下寫法:

a = "abc"
b = a.replace("a", "f")

和:

a = b"abc"
b = a.replace(b"a", b"f")

某些 bytes 和 bytearray 操作假定使用兼容 ASCII 的二進制格式，因此在處理任意二進數(shù)數(shù)據(jù)時應(yīng)當避免使用。 這些限制會在下文中說明。

注解

使用這些基于 ASCII 的操作來處理未以基于 ASCII 的格式存儲的二進制數(shù)據(jù)可能會導(dǎo)致數(shù)據(jù)損壞。

bytes 和 bytearray 對象的下列方法可以用于任意二進制數(shù)據(jù)。

bytes.count(sub[, start[, end]])?
bytearray.count(sub[, start[, end]])?

返回子序列 sub 在 [start, end] 范圍內(nèi)非重疊出現(xiàn)的次數(shù)。 可選參數(shù) start 與 end 會被解讀為切片表示法。

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內(nèi)的整數(shù)。

在 3.3 版更改: 也接受 0 至 255 范圍內(nèi)的整數(shù)作為子序列。

bytes.decode(encoding="utf-8", errors="strict")?
bytearray.decode(encoding="utf-8", errors="strict")?

返回從給定 bytes 解碼出來的字符串。 默認編碼為 'utf-8'。 可以給出 errors 來設(shè)置不同的錯誤處理方案。 errors 的默認值為 'strict'，表示編碼錯誤會引發(fā) UnicodeError。 其他可用的值為 'ignore', 'replace' 以及任何其他通過 codecs.register_error() 注冊的名稱，請參閱 錯誤處理方案 小節(jié)。 要查看可用的編碼列表，請參閱 標準編碼 小節(jié)。

注解

將 encoding 參數(shù)傳給 str 允許直接解碼任何 bytes-like object，無須創(chuàng)建臨時的 bytes 或 bytearray 對象。

在 3.1 版更改: 加入了對關(guān)鍵字參數(shù)的支持。

bytes.endswith(suffix[, start[, end]])?
bytearray.endswith(suffix[, start[, end]])?

如果二進制數(shù)據(jù)以指定的 suffix 結(jié)束則返回 True，否則返回 False。 suffix 也可以為由多個供查找的后綴構(gòu)成的元組。 如果有可選項 start，將從所指定位置開始檢查。 如果有可選項 end，將在所指定位置停止比較。

要搜索的后綴可以是任意 bytes-like object。

bytes.find(sub[, start[, end]])?
bytearray.find(sub[, start[, end]])?

返回子序列 sub 在數(shù)據(jù)中被找到的最小索引，sub 包含于切片 s[start:end] 之內(nèi)。 可選參數(shù) start 與 end 會被解讀為切片表示法。 如果 sub 未被找到則返回 -1。

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內(nèi)的整數(shù)。

注解

find() 方法應(yīng)該只在你需要知道 sub 所在位置時使用。 要檢查 sub 是否為子串，請使用 in 操作符:

>>> b'Py' in b'Python'
True

在 3.3 版更改: 也接受 0 至 255 范圍內(nèi)的整數(shù)作為子序列。

bytes.index(sub[, start[, end]])?
bytearray.index(sub[, start[, end]])?

類似于 find()，但在找不到子序列時會引發(fā) ValueError。

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內(nèi)的整數(shù)。

在 3.3 版更改: 也接受 0 至 255 范圍內(nèi)的整數(shù)作為子序列。

bytes.join(iterable)?
bytearray.join(iterable)?

返回一個由 iterable 中的二進制數(shù)據(jù)序列拼接而成的 bytes 或 bytearray 對象。 如果 iterable 中存在任何非 字節(jié)類對象 包括存在 str 對象值則會引發(fā) TypeError。 提供該方法的 bytes 或 bytearray 對象的內(nèi)容將作為元素之間的分隔。

static bytes.maketrans(from, to)?
static bytearray.maketrans(from, to)?

此靜態(tài)方法返回一個可用于 bytes.translate() 的轉(zhuǎn)換對照表，它將把 from 中的每個字符映射為 to 中相同位置上的字符；from 與 to 必須都是 字節(jié)類對象 并且具有相同的長度。

3.1 新版功能.

bytes.partition(sep)?
bytearray.partition(sep)?

在 sep 首次出現(xiàn)的位置拆分序列，返回一個 3 元組，其中包含分隔符之前的部分、分隔符本身或其 bytearray 副本，以及分隔符之后的部分。 如果分隔符未找到，則返回的 3 元組中包含原序列以及兩個空的 bytes 或 bytearray 對象。

要搜索的分隔符可以是任意 bytes-like object。

bytes.replace(old, new[, count])?
bytearray.replace(old, new[, count])?

返回序列的副本，其中出現(xiàn)的所有子序列 old 都將被替換為 new。 如果給出了可選參數(shù) count，則只替換前 count 次出現(xiàn)。

要搜索的子序列及其替換序列可以是任意 bytes-like object。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.rfind(sub[, start[, end]])?
bytearray.rfind(sub[, start[, end]])?

返回子序列 sub 在序列內(nèi)被找到的最大（最右）索引，這樣 sub 將包含在 s[start:end] 當中。 可選參數(shù) start 與 end 會被解讀為切片表示法。 如果未找到則返回 -1。

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內(nèi)的整數(shù)。

在 3.3 版更改: 也接受 0 至 255 范圍內(nèi)的整數(shù)作為子序列。

bytes.rindex(sub[, start[, end]])?
bytearray.rindex(sub[, start[, end]])?

類似于 rfind()，但在子序列 sub 未找到時會引發(fā) ValueError。

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內(nèi)的整數(shù)。

在 3.3 版更改: 也接受 0 至 255 范圍內(nèi)的整數(shù)作為子序列。

bytes.rpartition(sep)?
bytearray.rpartition(sep)?

在 sep 最后一次出現(xiàn)的位置拆分序列，返回一個 3 元組，其中包含分隔符之前的部分，分隔符本身或其 bytearray 副本，以及分隔符之后的部分。 如果分隔符未找到，則返回的 3 元組中包含兩個空的 bytes 或 bytearray 對象以及原序列的副本。

要搜索的分隔符可以是任意 bytes-like object。

bytes.startswith(prefix[, start[, end]])?
bytearray.startswith(prefix[, start[, end]])?

如果二進制數(shù)據(jù)以指定的 prefix 開頭則返回 True，否則返回 False。 prefix 也可以為由多個供查找的前綴構(gòu)成的元組。 如果有可選項 start，將從所指定位置開始檢查。 如果有可選項 end，將在所指定位置停止比較。

要搜索的前綴可以是任意 bytes-like object。

bytes.translate(table, delete=b'')?
bytearray.translate(table, delete=b'')?

返回原 bytes 或 bytearray 對象的副本，移除其中所有在可選參數(shù) delete 中出現(xiàn)的 bytes，其余 bytes 將通過給定的轉(zhuǎn)換表進行映射，該轉(zhuǎn)換表必須是長度為 256 的 bytes 對象。

你可以使用 bytes.maketrans() 方法來創(chuàng)建轉(zhuǎn)換表。

對于僅需移除字符的轉(zhuǎn)換，請將 table 參數(shù)設(shè)為 None:

>>> b'read this short text'.translate(None, b'aeiou')
b'rd ths shrt txt'

在 3.6 版更改: 現(xiàn)在支持將 delete 作為關(guān)鍵字參數(shù)。

以下 bytes 和 bytearray 對象的方法的默認行為會假定使用兼容 ASCII 的二進制格式，但通過傳入適當?shù)膮?shù)仍然可用于任意二進制數(shù)據(jù)。 請注意本小節(jié)中所有的 bytearray 方法都 不是 原地執(zhí)行操作，而是會產(chǎn)生新的對象。

bytes.center(width[, fillbyte])?
bytearray.center(width[, fillbyte])?

返回原對象的副本，在長度為 width 的序列內(nèi)居中，使用指定的 fillbyte 填充兩邊的空位（默認使用 ASCII 空格符）。 對于 bytes 對象，如果 width 小于等于 len(s) 則返回原序列的副本。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.ljust(width[, fillbyte])?
bytearray.ljust(width[, fillbyte])?

返回原對象的副本，在長度為 width 的序列中靠左對齊。 使用指定的 fillbyte 填充空位（默認使用 ASCII 空格符）。 對于 bytes 對象，如果 width 小于等于 len(s) 則返回原序列的副本。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.lstrip([chars])?
bytearray.lstrip([chars])?

返回原序列的副本，移除指定的前導(dǎo)字節(jié)。 chars 參數(shù)為指定要移除字節(jié)值集合的二進制序列 —— 這個名稱表明此方法通常是用于 ASCII 字符。 如果省略或為 None，則 chars 參數(shù)默認移除 ASCII 空白符。 chars 參數(shù)并非指定單個前綴；而是會移除參數(shù)值的所有組合:

>>> b'   spacious   '.lstrip()
b'spacious   '
>>> b'www.example.com'.lstrip(b'cmowz.')
b'example.com'

要移除的字節(jié)值二進制序列可以是任意 bytes-like object。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.rjust(width[, fillbyte])?
bytearray.rjust(width[, fillbyte])?

返回原對象的副本，在長度為 width 的序列中靠右對齊。 使用指定的 fillbyte 填充空位（默認使用 ASCII 空格符）。 對于 bytes 對象，如果 width 小于等于 len(s) 則返回原序列的副本。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.rsplit(sep=None, maxsplit=-1)?
bytearray.rsplit(sep=None, maxsplit=-1)?

將二進制序列拆分為相同類型的子序列，使用 sep 作為分隔符。 如果給出了 maxsplit，則最多進行 maxsplit 次拆分，從 最右邊 開始。 如果 sep 未指定或為 None，任何只包含 ASCII 空白符的子序列都會被作為分隔符。 除了從右邊開始拆分，rsplit() 的其他行為都類似于下文所述的 split()。

bytes.rstrip([chars])?
bytearray.rstrip([chars])?

返回原序列的副本，移除指定的末尾字節(jié)。 chars 參數(shù)為指定要移除字節(jié)值集合的二進制序列 —— 這個名稱表明此方法通常是用于 ASCII 字符。 如果省略或為 None，則 chars 參數(shù)默認移除 ASCII 空白符。 chars 參數(shù)并非指定單個后綴；而是會移除參數(shù)值的所有組合:

>>> b'   spacious   '.rstrip()
b'   spacious'
>>> b'mississippi'.rstrip(b'ipz')
b'mississ'

要移除的字節(jié)值二進制序列可以是任意 bytes-like object。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.split(sep=None, maxsplit=-1)?
bytearray.split(sep=None, maxsplit=-1)?

將二進制序列拆分為相同類型的子序列，使用 sep 作為分隔符。 如果給出了 maxsplit 且非負值，則最多進行 maxsplit 次拆分（因此，列表最多會有 maxsplit+1 個元素）。 如果 maxsplit 未指定或為 -1，則不限制拆分次數(shù)（進行所有可能的拆分）。

如果給出了 sep，則連續(xù)的分隔符不會被組合在一起而是被視為分隔空子序列 (例如 b'1,,2'.split(b',') 將返回 [b'1', b'', b'2'])。 sep 參數(shù)可能為一個多字節(jié)序列 (例如 b'1<>2<>3'.split(b'<>') 將返回 [b'1', b'2', b'3'])。 使用指定的分隔符拆分空序列將返回 [b''] 或 [bytearray(b'')]，具體取決于被拆分對象的類型。 sep 參數(shù)可以是任意 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，則會應(yīng)用另一種拆分算法：連續(xù)的 ASCII 空白符會被視為單個分隔符，其結(jié)果將不包含序列開頭或末尾的空白符。 因此，在不指定分隔符的情況下對空序列或僅包含 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])?

返回原序列的副本，移除指定的開頭和末尾字節(jié)。 chars 參數(shù)為指定要移除字節(jié)值集合的二進制序列 —— 這個名稱表明此方法通常是用于 ASCII 字符。 如果省略或為 None，則 chars 參數(shù)默認移除 ASCII 空白符。 chars 參數(shù)并非指定單個前綴或后綴；而是會移除參數(shù)值的所有組合:

>>> b'   spacious   '.strip()
b'spacious'
>>> b'www.example.com'.strip(b'cmowz.')
b'example'

要移除的字節(jié)值二進制序列可以是任意 bytes-like object。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

以下 bytes 和 bytearray 對象的方法會假定使用兼容 ASCII 的二進制格式，不應(yīng)當被應(yīng)用于任意二進制數(shù)據(jù)。 請注意本小節(jié)中所有的 bytearray 方法都 不是 原地執(zhí)行操作，而是會產(chǎn)生新的對象。

bytes.capitalize()?
bytearray.capitalize()?

返回原序列的副本，其中每個字節(jié)將都將被解讀為一個 ASCII 字符，并且第一個字節(jié)的字符大寫而其余的小寫。 非 ASCII 字節(jié)值將保持原樣不變。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.expandtabs(tabsize=8)?
bytearray.expandtabs(tabsize=8)?

返回序列的副本，其中所有的 ASCII 制表符會由一個或多個 ASCII 空格替換，具體取決于當前列位置和給定的制表符寬度。 每 tabsize 個字節(jié)設(shè)為一個制表位（默認值 8 時設(shè)定的制表位在列 0, 8, 16 依次類推）。 要展開序列，當前列位置將被設(shè)為零并逐一檢查序列中的每個字節(jié)。 如果字節(jié)為 ASCII 制表符 (b'\t')，則并在結(jié)果中插入一個或多個空格符，直到當前列等于下一個制表位。 （制表符本身不會被復(fù)制。） 如果當前字節(jié)為 ASCII 換行符 (b'\n') 或回車符 (b'\r')，它會被復(fù)制并將當前列重設(shè)為零。 任何其他字節(jié)會被不加修改地復(fù)制并將當前列加一，不論該字節(jié)值在被打印時會如何顯示:

>>> b'01\t012\t0123\t01234'.expandtabs()
b'01      012     0123    01234'
>>> b'01\t012\t0123\t01234'.expandtabs(4)
b'01  012 0123    01234'

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.isalnum()?
bytearray.isalnum()?

如果序列中所有字節(jié)都是字母類 ASCII 字符或 ASCII 十進制數(shù)碼并且序列非空則返回 Ture ，否則返回 False 。 字母類 ASCII 字符就是字節(jié)值包含在序列 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。 ASCII 十進制數(shù)碼就是字節(jié)值包含在序列 b'0123456789' 中的字符。

例如

>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False
bytes.isalpha()?
bytearray.isalpha()?

如果序列中所有字節(jié)都是字母類 ASCII 字符并且序列不非空則返回 True ，否則返回 False 。 字母類 ASCII 字符就是字節(jié)值包含在序列 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

例如

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False
bytes.isascii()?
bytearray.isascii()?

如果序列為空或序列中所有字節(jié)都是 ASCII 字節(jié)則返回 True ，否則返回 False 。 ASCII 字節(jié)的取值范圍是 0-0x7F。

3.7 新版功能.

bytes.isdigit()?
bytearray.isdigit()?

如果序列中所有字節(jié)都是 ASCII 十進制數(shù)碼并且序列非空則返回 True ，否則返回 False 。 ASCII 十進制數(shù)碼就是字節(jié)值包含在序列 b'0123456789' 中的字符。

例如

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False
bytes.islower()?
bytearray.islower()?

如果序列中至少有一個小寫的 ASCII 字符并且沒有大寫的 ASCII 字符則返回 True ，否則返回 False 。

例如

>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False

小寫 ASCII 字符就是字節(jié)值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大寫 ASCII 字符就是字節(jié)值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

bytes.isspace()?
bytearray.isspace()?

如果序列中所有字節(jié)都是 ASCII 空白符并且序列非空則返回 True ，否則返回 False 。 ASCII 空白符就是字節(jié)值包含在序列 b' \t\n\r\x0b\f' (空格, 制表, 換行, 回車, 垂直制表, 進紙) 中的字符。

bytes.istitle()?
bytearray.istitle()?

如果序列為 ASCII 標題大小寫形式并且序列非空則返回 True ，否則返回 False 。 請參閱 bytes.title() 了解有關(guān)“標題大小寫”的詳細定義。

例如

>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False
bytes.isupper()?
bytearray.isupper()?

如果序列中至少有一個大寫字母 ASCII 字符并且沒有小寫 ASCII 字符則返回 True ，否則返回 False 。

例如

>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False

小寫 ASCII 字符就是字節(jié)值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大寫 ASCII 字符就是字節(jié)值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

bytes.lower()?
bytearray.lower()?

返回原序列的副本，其所有大寫 ASCII 字符均轉(zhuǎn)換為對應(yīng)的小寫形式。

例如

>>> b'Hello World'.lower()
b'hello world'

小寫 ASCII 字符就是字節(jié)值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大寫 ASCII 字符就是字節(jié)值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.splitlines(keepends=False)?
bytearray.splitlines(keepends=False)?

返回由原二進制序列中各行組成的列表，在 ASCII 行邊界符的位置拆分。 此方法使用 universal newlines 方式來分行。 結(jié)果列表中不包含換行符，除非給出了 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()，當給出了分隔符 sep 時，對于空字符串此方法將返回一個空列表，而末尾的換行不會令結(jié)果中增加額外的行:

>>> 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 字符均轉(zhuǎn)換為對應(yīng)的大寫形式，反之亦反。

例如

>>> b'Hello World'.swapcase()
b'hELLO wORLD'

小寫 ASCII 字符就是字節(jié)值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大寫 ASCII 字符就是字節(jié)值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

不同于 str.swapcase()，在些二進制版本下 bin.swapcase().swapcase() == bin 總是成立。 大小寫轉(zhuǎn)換在 ASCII 中是對稱的，即使其對于任意 Unicode 碼位來說并不總是成立。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.title()?
bytearray.title()?

返回原二進制序列的標題版本，其中每個單詞以一個大寫 ASCII 字符為開頭，其余字母為小寫。 不區(qū)別大小寫的字節(jié)值將保持原樣不變。

例如

>>> b'Hello world'.title()
b'Hello World'

小寫 ASCII 字符就是字節(jié)值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大寫 ASCII 字符就是字節(jié)值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。 所有其他字節(jié)值都不區(qū)分大小寫。

該算法使用一種簡單的與語言無關(guān)的定義，將連續(xù)的字母組合視為單詞。 該定義在多數(shù)情況下都很有效，但它也意味著代表縮寫形式與所有格的撇號也會成為單詞邊界，這可能導(dǎo)致不希望的結(jié)果:

>>> b"they're bill's friends from the UK".title()
b"They'Re Bill'S Friends From The Uk"

可以使用正則表達式來構(gòu)建針對撇號的特別處理:

>>> 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 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.upper()?
bytearray.upper()?

返回原序列的副本，其所有小寫 ASCII 字符均轉(zhuǎn)換為對應(yīng)的大寫形式。

例如

>>> b'Hello World'.upper()
b'HELLO WORLD'

小寫 ASCII 字符就是字節(jié)值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大寫 ASCII 字符就是字節(jié)值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

bytes.zfill(width)?
bytearray.zfill(width)?

返回原序列的副本，在左邊填充 b'0' 數(shù)碼使序列長度為 width。 正負值前綴 (b'+'/ b'-') 的處理方式是在正負符號 之后 填充而非在之前。 對于 bytes 對象，如果 width 小于等于 len(seq) 則返回原序列。

例如

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

printf 風(fēng)格的字節(jié)串格式化?

注解

此處介紹的格式化操作具有多種怪異特性，可能導(dǎo)致許多常見錯誤（例如無法正確顯示元組和字典）。 如果要打印的值可能為元組或字典，請將其放入一個元組中。

字節(jié)串對象 (bytes/bytearray) 具有一種特殊的內(nèi)置操作：使用 % (取模) 運算符。 這也被稱為字節(jié)串的 格式化 或 插值 運算符。 對于 format % values (其中 format 為一個字節(jié)串對象)，在 format 中的 % 轉(zhuǎn)換標記符將被替換為零個或多個 values 條目。 其效果類似于在 C 語言中使用 sprintf()。

如果 format 要求一個單獨參數(shù)，則 values 可以為一個非元組對象。 5 否則的話，values 必須或是是一個包含項數(shù)與格式字節(jié)串對象中指定的轉(zhuǎn)換符項數(shù)相同的元組，或者是一個單獨的映射對象（例如元組）。

轉(zhuǎn)換標記符包含兩個或更多字符并具有以下組成，且必須遵循此處規(guī)定的順序：

  1. '%' 字符，用于標記轉(zhuǎn)換符的起始。

  2. 映射鍵（可選），由加圓括號的字符序列組成 (例如 (somename))。

  3. 轉(zhuǎn)換旗標（可選），用于影響某些轉(zhuǎn)換類型的結(jié)果。

  4. 最小字段寬度（可選）。 如果指定為 '*' (星號)，則實際寬度會從 values 元組的下一元素中讀取，要轉(zhuǎn)換的對象則為最小字段寬度和可選的精度之后的元素。

  5. 精度（可選），以在 '.' (點號) 之后加精度值的形式給出。 如果指定為 '*' (星號)，則實際精度會從 values 元組的下一元素中讀取，要轉(zhuǎn)換的對象則為精度之后的元素。

  6. 長度修飾符（可選）。

  7. 轉(zhuǎn)換類型。

當右邊的參數(shù)為一個字典（或其他映射類型）時，字節(jié)串對象中的格式 必須 包含加圓括號的映射鍵，對應(yīng) '%' 字符之后字典中的每一項。 映射鍵將從映射中選取要格式化的值。 例如：

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

在此情況下格式中不能出現(xiàn) * 標記符（因其需要一個序列類的參數(shù)列表）。

轉(zhuǎn)換旗標為：

標志

含義

'#'

值的轉(zhuǎn)換將使用“替代形式”（具體定義見下文）。

'0'

轉(zhuǎn)換將為數(shù)字值填充零字符。

'-'

轉(zhuǎn)換值將靠左對齊（如果同時給出 '0' 轉(zhuǎn)換，則會覆蓋后者）。

' '

(空格) 符號位轉(zhuǎn)換產(chǎn)生的正數(shù)（或空字符串）前將留出一個空格。

'+'

符號字符 ('+' 或 '-') 將顯示于轉(zhuǎn)換結(jié)果的開頭（會覆蓋 "空格" 旗標）。

可以給出長度修飾符 (h, l 或 L)，但會被忽略，因為對 Python 來說沒有必要 -- 所以 %ld 等價于 %d。

轉(zhuǎn)換類型為：

轉(zhuǎn)換符

含義

注釋

'd'

有符號十進制整數(shù)。

'i'

有符號十進制整數(shù)。

'o'

有符號八進制數(shù)。

(1)

'u'

過時類型 -- 等價于 'd'。

(8)

'x'

有符號十六進制數(shù)（小寫）。

(2)

'X'

有符號十六進制數(shù)（大寫）。

(2)

'e'

浮點指數(shù)格式（小寫）。

(3)

'E'

浮點指數(shù)格式（大寫）。

(3)

'f'

浮點十進制格式。

(3)

'F'

浮點十進制格式。

(3)

'g'

浮點格式。 如果指數(shù)小于 -4 或不小于精度則使用小寫指數(shù)格式，否則使用十進制格式。

(4)

'G'

浮點格式。 如果指數(shù)小于 -4 或不小于精度則使用大寫指數(shù)格式，否則使用十進制格式。

(4)

'c'

單個字節(jié)（接受整數(shù)或單個字節(jié)對象）。

'b'

字節(jié)串（任何遵循 緩沖區(qū)協(xié)議 或是具有 __bytes__() 的對象）。

(5)

's'

's' 是 'b' 的一個別名，只應(yīng)當在基于 Python2/3 的代碼中使用。

(6)

'a'

字節(jié)串（使用 repr(obj).encode('ascii','backslashreplace) 轉(zhuǎn)換任何 Python 對象）。

(5)

'r'

'r' 是 'a' 的一個別名，只應(yīng)當在基于 Python2/3 的代碼中使用。

(7)

'%'

不轉(zhuǎn)換參數(shù)，在結(jié)果中輸出一個 '%' 字符。

注釋:

  1. 此替代形式會在第一個數(shù)碼之前插入標示八進制數(shù)的前綴 ('0o')。

  2. 此替代形式會在第一個數(shù)碼之前插入 '0x' 或 '0X' 前綴（取決于是使用 'x' 還是 'X' 格式）。

  3. 此替代形式總是會在結(jié)果中包含一個小數(shù)點，即使其后并沒有數(shù)碼。

    小數(shù)點后的數(shù)碼位數(shù)由精度決定，默認為 6。

  4. 此替代形式總是會在結(jié)果中包含一個小數(shù)點，末尾各位的零不會如其他情況下那樣被移除。

    小數(shù)點前后的有效數(shù)碼位數(shù)由精度決定，默認為 6。

  5. 如果精度為 N，輸出將截短為 N 個字符。

  6. b'%s' 已棄用，但在 3.x 系列中將不會被移除。

  7. b'%r' 已棄用，但在 3.x 系列中將不會被移除。

  8. 參見 PEP 237。

注解

此方法的 bytearray 版本 并非 原地操作 —— 它總是產(chǎn)生一個新對象，即便沒有做任何改變。

參見

PEP 461 - 為 bytes 和 bytearray 添加 % 格式化

3.5 新版功能.

內(nèi)存視圖?

memoryview 對象允許 Python 代碼訪問一個對象的內(nèi)部數(shù)據(jù)，只要該對象支持 緩沖區(qū)協(xié)議 而無需進行拷貝。

class memoryview(obj)?

創(chuàng)建一個引用 obj 的 memoryview。 obj 必須支持緩沖區(qū)協(xié)議。 支持緩沖區(qū)協(xié)議的內(nèi)置對象包括 bytes 和 bytearray。

memoryview 具有 元素 的概念，即由原始對象 obj 所處理的基本內(nèi)存單元。 對于許多簡單類型例如 bytes 和 bytearray 來說，一個元素就是一個字節(jié)，但是其他的類型例如 array.array 可能有更大的元素。

len(view) 與 tolist 的長度相等。 如果 view.ndim = 0，則其長度為 1。 如果 view.ndim = 1，則其長度等于 view 中元素的數(shù)量。 對于更高的維度，其長度等于表示 view 的嵌套列表的長度。 itemsize 屬性可向你給出單個元素所占的字節(jié)數(shù)。

memoryview 支持通過切片和索引訪問其元素。 一維切片的結(jié)果將是一個子視圖:

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

如果 format 是一個來自于 struct 模塊的原生格式說明符，則也支持使用整數(shù)或由整數(shù)構(gòu)成的元組進行索引，并返回具有正確類型的單個 元素。 一維內(nèi)存視圖可以使用一個整數(shù)或由一個整數(shù)構(gòu)成的元組進行索引。 多維內(nèi)存視圖可以使用由恰好 ndim 個整數(shù)構(gòu)成的元素進行索引，ndim 即其維度。 零維內(nèi)存視圖可以使用空元組進行索引。

這里是一個使用非字節(jié)格式的例子:

>>> import array
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = memoryview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]

如果下層對象是可寫的，則內(nèi)存視圖支持一維切片賦值。 改變大小則不被允許:

>>> 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' 的可哈希（只讀）類型構(gòu)成的一維內(nèi)存視圖同樣是可哈希的。 哈希定義為 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 版更改: 一維內(nèi)存視圖現(xiàn)在可以被切片。 帶有格式符號 'B', 'b' 或 'c' 的一維內(nèi)存視圖現(xiàn)在是可哈希的。

在 3.4 版更改: 內(nèi)存視圖現(xiàn)在會自動注冊為 collections.abc.Sequence

在 3.5 版更改: 內(nèi)存視圖現(xiàn)在可使用整數(shù)元組進行索引。

memoryview 具有以下一些方法：

__eq__(exporter)?

memoryview 與 PEP 3118 中的導(dǎo)出器這兩者如果形狀相同，并且如果當使用 struct 語法解讀操作數(shù)的相應(yīng)格式代碼時所有對應(yīng)值都相同，則它們就是等價的。

對于 tolist() 當前所支持的 struct 格式字符串子集，如果 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 模塊所支持，則兩對象比較結(jié)果總是不相等（即使格式字符串和緩沖區(qū)內(nèi)容相同）:

>>> 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

請注意，與浮點數(shù)的情況一樣，對于內(nèi)存視圖對象來說，v is w 也 并不 意味著 v == w。

在 3.3 版更改: 之前的版本比較原始內(nèi)存時會忽略條目的格式與邏輯數(shù)組結(jié)構(gòu)。

tobytes()?

將緩沖區(qū)中的數(shù)據(jù)作為字節(jié)串返回。 這相當于在內(nèi)存視圖上調(diào)用 bytes 構(gòu)造器。

>>> m = memoryview(b"abc")
>>> m.tobytes()
b'abc'
>>> bytes(m)
b'abc'

對于非連續(xù)數(shù)組，結(jié)果等于平面化表示的列表，其中所有元素都轉(zhuǎn)換為字節(jié)串。 tobytes() 支持所有格式字符串，不符合 struct 模塊語法的那些也包括在內(nèi)。

hex()?

返回一個字符串對象，其中分別以兩個十六進制數(shù)碼表示緩沖區(qū)里的每個字節(jié)。

>>> m = memoryview(b"abc")
>>> m.hex()
'616263'

3.5 新版功能.

tolist()?

將緩沖區(qū)內(nèi)的數(shù)據(jù)以一個元素列表的形式返回。

>>> 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() 現(xiàn)在支持 struct 模塊語法中的所有單字符原生格式以及多維表示形式。

release()?

釋放由內(nèi)存視圖對象所公開的底層緩沖區(qū)。 許多對象在被視圖所獲取時都會采取特殊動作（例如，bytearray 將會暫時禁止調(diào)整大小）；因此，調(diào)用 release() 可以方便地盡早去除這些限制（并釋放任何多余的資源）。

在此方法被調(diào)用后，任何對視圖的進一步操作將引發(fā) ValueError (release() 本身除外，它可以被多次調(diào)用):

>>> 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 語句，可以通過上下文管理協(xié)議達到類似的效果:

>>> 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])?

將內(nèi)存視圖轉(zhuǎn)化為新的格式或形狀。 shape 默認為 [byte_length//new_itemsize]，這意味著結(jié)果視圖將是一維的。 返回值是一個新的內(nèi)存視圖，但緩沖區(qū)本身不會被復(fù)制。 支持的轉(zhuǎn)化有 1D -> C-contiguous 和 C-contiguous -> 1D。

目標格式僅限于 struct 語法中的單一元素原生格式。 其中一種格式必須為字節(jié)格式 ('B', 'b' 或 'c')。 結(jié)果的字節(jié)長度必須與原始長度相同。

將 1D/long 轉(zhuǎn)換為 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 轉(zhuǎn)換為 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 轉(zhuǎn)換為 3D/ints 再轉(zhuǎn)換為 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 long 轉(zhuǎn)換為 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 版更改: 當轉(zhuǎn)換為字節(jié)視圖時，源格式將不再受限。

還存在一些可用的只讀屬性：

obj?

內(nèi)存視圖的下層對象:

>>> b  = bytearray(b'xyz')
>>> m = memoryview(b)
>>> m.obj is b
True

3.3 新版功能.

nbytes?

nbytes == product(shape) * itemsize == len(m.tobytes())。 這是數(shù)組在連續(xù)表示時將會占用的空間總字節(jié)數(shù)。 它不一定等于 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

多維數(shù)組:

>>> 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?

一個表明內(nèi)存是否只讀的布爾值。

format?

一個字符串，包含視圖中每個元素的格式（表示為 struct 模塊樣式）。 內(nèi)存視圖可以從具有任意格式字符串的導(dǎo)出器創(chuàng)建，但某些方法 (例如 tolist()) 僅限于原生的單元素格式。

在 3.3 版更改: 格式 'B' 現(xiàn)在會按照 struct 模塊語法來處理。 這意味著 memoryview(b'abc')[0] == b'abc'[0] == 97。

itemsize?

memoryview 中每個元素以字節(jié)表示的大小:

>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True
ndim?

一個整數(shù)，表示內(nèi)存所代表的多維數(shù)組具有多少個維度。

shape?

一個整數(shù)元組，通過 ndim 的長度值給出內(nèi)存所代表的 N 維數(shù)組的形狀。

在 3.3 版更改: 當 ndim = 0 時值為空元組而不再為 None。

strides?

一個整數(shù)元組，通過 ndim 的長度給出以字節(jié)表示的大小，以便訪問數(shù)組中每個維度上的每個元素。

在 3.3 版更改: 當 ndim = 0 時值為空元組而不再為 None。

suboffsets?

供 PIL 風(fēng)格的數(shù)組內(nèi)部使用。 該值僅作為參考信息。

c_contiguous?

一個表明內(nèi)存是否為 C-contiguous 的布爾值。

3.3 新版功能.

f_contiguous?

一個表明內(nèi)存是否為 Fortran contiguous 的布爾值。

3.3 新版功能.

contiguous?

一個表明內(nèi)存是否為 contiguous 的布爾值。

3.3 新版功能.

集合類型 --- set, frozenset?

set 對象是由具有唯一性的 hashable 對象所組成的無序多項集。 常見的用途包括成員檢測、從序列中去除重復(fù)項以及數(shù)學(xué)中的集合類計算，例如交集、并集、差集與對稱差集等等。 （關(guān)于其他容器對象請參看 dict, list 與 tuple 等內(nèi)置類，以及 collections 模塊。）

與其他多項集一樣，集合也支持 x in set, len(set) 和 for x in set。 作為一種無序的多項集，集合并不記錄元素位置或插入順序。 相應(yīng)地，集合不支持索引、切片或其他序列類的操作。

目前有兩種內(nèi)置集合類型，set 和 frozenset。 set 類型是可變的 --- 其內(nèi)容可以使用 add() 和 remove() 這樣的方法來改變。 由于是可變類型，它沒有哈希值，且不能被用作字典的鍵或其他集合的元素。 frozenset 類型是不可變并且為 hashable --- 其內(nèi)容在被創(chuàng)建后不能再改變；因此它可以被用作字典的鍵或其他集合的元素。

除了可以使用 set 構(gòu)造器，非空的 set (不是 frozenset) 還可以通過將以逗號分隔的元素列表包含于花括號之內(nèi)來創(chuàng)建，例如: {'jack', 'sjoerd'}。

兩個類的構(gòu)造器具有相同的作用方式：

class set([iterable])?
class frozenset([iterable])?

返回一個新的 set 或 frozenset 對象，其元素來自于 iterable。 集合的元素必須為 hashable。 要表示由集合對象構(gòu)成的集合，所有的內(nèi)層集合必須為 frozenset 對象。 如果未指定 iterable，則將返回一個新的空集合。

set 和 frozenset 的實例提供以下操作：

len(s)

返回集合 s 中的元素數(shù)量（即 s 的基數(shù)）。

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

返回一個新集合，其中的元素或?qū)儆谠匣驅(qū)儆?other 指定的其他集合，但不能同時屬于兩者。

copy()?

返回原集合的淺拷貝。

請注意，非運算符版本的 union(), intersection(), difference()，以及 symmetric_difference(), issubset() 和 issuperset() 方法會接受任意可迭代對象作為參數(shù)。 相比之下，它們所對應(yīng)的運算符版本則要求其參數(shù)為集合。 這就排除了容易出錯的構(gòu)造形式例如 set('abc') & 'cbs'，而推薦可讀性更強的 set('abc').intersection('cbs')。

set 和 frozenset 均支持集合與集合的比較。 兩個集合當且僅當每個集合中的每個元素均包含于另一個集合之內(nèi)（即各為對方的子集）時則相等。 一個集合當且僅當其為另一個集合的真子集（即為后者的子集但兩者不相等）時則小于另一個集合。 一個集合當且僅當其為另一個集合的真超集（即為后者的超集但兩者不相等）時則大于另一個集合。

set 的實例與 frozenset 的實例之間基于它們的成員進行比較。 例如 set('abc') == frozenset('abc') 返回 True，set('abc') in set([frozenset('abc')]) 也一樣。

子集與相等比較并不能推廣為完全排序函數(shù)。 例如，任意兩個非空且不相交的集合不相等且互不為對方的子集，因此以下 所有 比較均返回 False: a<b, a==b, or a>b。

由于集合僅定義了部分排序（子集關(guān)系），因此由集合構(gòu)成的列表 list.sort() 方法的輸出并無定義。

集合的元素，與字典的鍵類似，必須為 hashable。

混合了 set 實例與 frozenset 的二進制位運算將返回與第一個操作數(shù)相同的類型。例如: frozenset('ab') | set('bc') 將返回 frozenset 的實例。

下表列出了可用于 set 而不能用于不可變的 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 不存在于集合中則會引發(fā) KeyError。

discard(elem)?

如果元素 elem 存在于集合中則將其移除。

pop()?

從集合中移除并返回任意一個元素。 如果集合為空則會引發(fā) KeyError。

clear()?

從集合中移除所有元素。

請注意，非運算符版本的 update(), intersection_update(), difference_update() 和 symmetric_difference_update() 方法將接受任意可迭代對象作為參數(shù)。

請注意，__contains__(), remove() 和 discard() 方法的 elem 參數(shù)可能是一個 set。 為支持對一個等價的 frozenset 進行搜索，會根據(jù) elem 臨時創(chuàng)建一個該類型對象。

映射類型 --- dict?

mapping 對象會將 hashable 值映射到任意對象。 映射屬于可變對象。 目前僅有一種標準映射類型 字典。 （關(guān)于其他容器對象請參看 list, set 與 tuple 等內(nèi)置類，以及 collections 模塊。）

字典的鍵 幾乎 可以是任何值。 非 hashable 的值，即包含列表、字典或其他可變類型的值（此類對象基于值而非對象標識進行比較）不可用作鍵。 數(shù)字類型用作鍵時遵循數(shù)字比較的一般規(guī)則：如果兩個數(shù)值相等 (例如 1 和 1.0) 則兩者可以被用來索引同一字典條目。 （但是請注意，由于計算機對于浮點數(shù)存儲的只是近似值，因此將其用作字典鍵是不明智的。）

字典可以通過將以逗號分隔的 鍵: 值 對列表包含于花括號之內(nèi)來創(chuàng)建，例如: {'jack': 4098, 'sjoerd': 4127} 或 {4098: 'jack', 4127: 'sjoerd'}，也可以通過 dict 構(gòu)造器來創(chuàng)建。

class dict(**kwarg)?
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

返回一個新的字典，基于可選的位置參數(shù)和可能為空的關(guān)鍵字參數(shù)集來初始化。

如果沒有給出位置參數(shù)，將創(chuàng)建一個空字典。 如果給出一個位置參數(shù)并且其屬于映射對象，將創(chuàng)建一個具有與映射對象相同鍵值對的字典。 否則的話，位置參數(shù)必須為一個 iterable 對象。 該可迭代對象中的每一項本身必須為一個剛好包含兩個元素的可迭代對象。 每一項中的第一個對象將成為新字典的一個鍵，第二個對象將成為其對應(yīng)的值。 如果一個鍵出現(xiàn)一次以上，該鍵的最后一個值將成為其在新字典中對應(yīng)的值。

如果給出了關(guān)鍵字參數(shù)，則關(guān)鍵字參數(shù)及其值會被加入到基于位置參數(shù)創(chuàng)建的字典。 如果要加入的鍵已存在，來自關(guān)鍵字參數(shù)的值將替代來自位置參數(shù)的值。

作為演示，以下示例返回的字典均等于 {"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

像第一個例子那樣提供關(guān)鍵字參數(shù)的方式只能使用有效的 Python 標識符作為鍵。 其他方式則可使用任何有效的鍵。

這些是字典所支持的操作（因而自定義的映射類型也應(yīng)當支持）：

list(d)

返回字典 d 中使用的所有鍵的列表。

len(d)

返回字典 d 中的項數(shù)。

d[key]

返回 d 中以 key 為鍵的項。 如果映射中不存在 key 則會引發(fā) KeyError。

如果字典的子類定義了方法 __missing__() 并且 key 不存在，則 d[key] 操作將調(diào)用該方法并附帶鍵 key 作為參數(shù)。 d[key] 隨后將返回或引發(fā) __missing__(key) 調(diào)用所返回或引發(fā)的任何對象或異常。 沒有其他操作或方法會發(fā)起調(diào)用 __missing__()。 如果未定義 __missing__()，則會引發(fā) KeyError。 __missing__() 必須是一個方法；它不能是一個實例變量:

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

上面的例子顯示了 collections.Counter 實現(xiàn)的部分代碼。 還有另一個不同的 __missing__ 方法是由 collections.defaultdict 所使用的。

d[key] = value

將 d[key] 設(shè)為 value。

del d[key]

將 d[key] 從 d 中移除。 如果映射中不存在 key 則會引發(fā) 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 的鍵創(chuàng)建一個新字典，并將鍵值設(shè)為 value。

fromkeys() 屬于類方法，會返回一個新字典。 value 默認為 None。

get(key[, default])?

如果 key 存在于字典中則返回 key 的值，否則返回 default。 如果 default 未給出則默認為 None，因而此方法絕不會引發(fā) KeyError。

items()?

返回由字典項 ((鍵, 值) 對) 組成的一個新視圖。 參見 視圖對象文檔。

keys()?

返回由字典鍵組成的一個新視圖。 參見 視圖對象文檔。

pop(key[, default])?

如果 key 存在于字典中則將其移除并返回其值，否則返回 default。 如果 default 未給出且 key 不存在于字典中，則會引發(fā) KeyError。

popitem()?

從字典中移除并返回一個 (鍵, 值) 對。 鍵值對會按 LIFO 的順序被返回。

popitem() 適用于對字典進行消耗性的迭代，這在集合算法中經(jīng)常被使用。 如果字典為空，調(diào)用 popitem() 將引發(fā) KeyError。

在 3.7 版更改: 現(xiàn)在會確保采用 LIFO 順序。 在之前的版本中，popitem() 會返回一個任意的鍵/值對。

setdefault(key[, default])?

如果字典存在鍵 key ，返回它的值。如果不存在，插入值為 default 的鍵 key ，并返回 default 。 default 默認為 None。

update([other])?

使用來自 other 的鍵/值對更新字典，覆蓋原有的鍵。 返回 None。

update() 接受另一個字典對象，或者一個包含鍵/值對（以長度為二的元組或其他可迭代對象表示）的可迭代對象。 如果給出了關(guān)鍵字參數(shù)，則會以其所指定的鍵/值對更新字典: d.update(red=1, blue=2)。

values()?

返回由字典值組成的一個新視圖。 參見 視圖對象文檔。

兩個 dict.values() 視圖之間的相等性比較將總是返回 False。 這在 dict.values() 與其自身比較時也同樣適用:

>>> d = {'a': 1}
>>> d.values() == d.values()
False

兩個字典的比較當且僅當它們具有相同的 (鍵, 值) 對時才會相等（不考慮順序）。 排序比較 ('<', '<=', '>=', '>') 會引發(fā) 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 實現(xiàn)細節(jié)。

參見

types.MappingProxyType 可被用來創(chuàng)建一個 dict 的只讀視圖。

字典視圖對象?

由 dict.keys(), dict.values() 和 dict.items() 所返回的對象是 視圖對象。 該對象提供字典條目的一個動態(tài)視圖，這意味著當字典改變時，視圖也會相應(yīng)改變。

字典視圖可以被迭代以產(chǎn)生與其對應(yīng)的數(shù)據(jù)，并支持成員檢測：

len(dictview)

返回字典中的條目數(shù)。

iter(dictview)

返回字典中的鍵、值或項（以 (鍵, 值) 為元素的元組表示）的迭代器。

鍵和值是按插入時的順序進行迭代的。 這樣就允許使用 zip() 來創(chuàng)建 (值, 鍵) 對: pairs = zip(d.values(), d.keys())。 另一個創(chuàng)建相同列表的方式是 pairs = [(v, k) for (k, v) in d.items()].

在添加或刪除字典中的條目期間對視圖進行迭代可能引發(fā) RuntimeError 或者無法完全迭代所有條目。

在 3.7 版更改: 字典順序會確保為插入順序。

x in dictview

如果 x 是對應(yīng)字典中存在的鍵、值或項（在最后一種情況下 x 應(yīng)為一個 (鍵, 值) 元組） 則返回 True。

鍵視圖類似于集合，因為其條目不重復(fù)且可哈希。 如果所有值都是可哈希的，即 (鍵, 值) 對也是不重復(fù)且可哈希的，那么條目視圖也會類似于集合。 （值視圖則不被視為類似于集合，因其條目通常都是有重復(fù)的。） 對于類似于集合的視圖，為抽象基類 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 語句支持通過上下文管理器所定義的運行時上下文這一概念。 此對象的實現(xiàn)使用了一對專門方法，允許用戶自定義類來定義運行時上下文，在語句體被執(zhí)行前進入該上下文，并在語句執(zhí)行完畢時退出該上下文：

contextmanager.__enter__()?

進入運行時上下文并返回此對象或關(guān)聯(lián)到該運行時上下文的其他對象。 此方法的返回值會綁定到使用此上下文管理器的 with 語句的 as 子句中的標識符。

一個返回其自身的上下文管理器的例子是 file object。 文件對象會從 __enter__() 返回其自身，以允許 open() 被用作 with 語句中的上下文表達式。

一個返回關(guān)聯(lián)對象的上下文管理器的例子是 decimal.localcontext() 所返回的對象。 此種管理器會將活動的 decimal 上下文設(shè)為原始 decimal 上下文的一個副本并返回該副本。 這允許對 with 語句的語句體中的當前 decimal 上下文進行更改，而不會影響 with 語句以外的代碼。

contextmanager.__exit__(exc_type, exc_val, exc_tb)?

退出運行時上下文并返回一個布爾值旗標來表明所發(fā)生的任何異常是否應(yīng)當被屏蔽。 如果在執(zhí)行 with 語句的語句體期間發(fā)生了異常，則參數(shù)會包含異常的類型、值以及回溯信息。 在其他情況下三個參數(shù)均為 None。

自此方法返回一個真值將導(dǎo)致 with 語句屏蔽異常并繼續(xù)執(zhí)行緊隨在 with 語句之后的語句。 否則異常將在此方法結(jié)束執(zhí)行后繼續(xù)傳播。 在此方法執(zhí)行期間發(fā)生的異常將會取代 with 語句的語句體中發(fā)生的任何異常。

傳入的異常絕對不應(yīng)當被顯式地重新引發(fā) —— 相反地，此方法應(yīng)當返回一個假值以表明方法已成功完成并且不希望屏蔽被引發(fā)的異常。 這允許上下文管理代碼方便地檢測 __exit__() 方法是否確實已失敗。

Python 定義了一些上下文管理器來支持簡易的線程同步、文件或其他對象的快速關(guān)閉，以及更方便地操作活動的十進制算術(shù)上下文。 除了實現(xiàn)上下文管理協(xié)議以外，不同類型不會被特殊處理。 請參閱 contextlib 模塊查看相關(guān)的示例。

Python 的 generator 和 contextlib.contextmanager 裝飾器提供了實現(xiàn)這些協(xié)議的便捷方式。 如果使用 contextlib.contextmanager 裝飾器來裝飾一個生成器函數(shù)，它將返回一個實現(xiàn)了必要的 __enter__() and __exit__() 方法的上下文管理器，而不再是由未經(jīng)裝飾的生成器函數(shù)所產(chǎn)生的迭代器。

請注意，Python/C API 中 Python 對象的類型結(jié)構(gòu)中并沒有針對這些方法的專門槽位。 想要定義這些方法的擴展類型必須將它們作為普通的 Python 可訪問方法來提供。 與設(shè)置運行時上下文的開銷相比，單個類字典查找的開銷可以忽略不計。

其他內(nèi)置類型?

解釋器支持一些其他種類的對象。 這些對象大都僅支持一兩種操作。

模塊?

模塊唯一的特殊操作是屬性訪問: m.name，這里 m 為一個模塊而 name 訪問定義在 m 的符號表中的一個名稱。 模塊屬性可以被賦值。 （請注意 import 語句嚴格來說也是對模塊對象的一種操作；import foo 不要求存在一個名為 foo 的模塊對象，而是要求存在一個對于名為 foo 的模塊的 (永久性) 定義。）

每個模塊都有一個特殊屬性 __dict__。 這是包含模塊的符號表的字典。 修改此字典將實際改變模塊的符號表，但是無法直接對 __dict__ 賦值 (你可以寫 m.__dict__['a'] = 1，這會將 m.a 定義為 1，但是你不能寫 m.__dict__ = {})。 不建議直接修改 __dict__。

內(nèi)置于解釋器中的模塊會寫成這樣: <module 'sys' (built-in)>。 如果是從一個文件加載，則會寫成 <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>。

類與類實例?

關(guān)于這些類型請參閱 對象、值與類型 和 類定義。

函數(shù)?

函數(shù)對象是通過函數(shù)定義創(chuàng)建的。 對函數(shù)對象的唯一操作是調(diào)用它: func(argument-list)。

實際上存在兩種不同的函數(shù)對象：內(nèi)置函數(shù)和用戶自定義函數(shù)。 兩者支持同樣的操作（調(diào)用函數(shù)），但實現(xiàn)方式不同，因此對象類型也不同。

更多信息請參閱 函數(shù)定義。

方法?

方法是使用屬性表示法來調(diào)用的函數(shù)。 存在兩種形式：內(nèi)置方法（例如列表的 append() 方法）和類實例方法。 內(nèi)置方法由支持它們的類型來描述。

如果你通過一個實例來訪問方法（即定義在類命名空間內(nèi)的函數(shù)），你會得到一個特殊對象: 綁定方法 (或稱 實例方法) 對象。 當被調(diào)用時，它會將 self 參數(shù)添加到參數(shù)列表。 綁定方法具有兩個特殊的只讀屬性: m.__self__ 操作該方法的對象，而 m.__func__ 是實現(xiàn)該方法的函數(shù)。 調(diào)用 m(arg-1, arg-2, ..., arg-n) 完全等價于調(diào)用 m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)。

與函數(shù)對象類似，綁定方法對象也支持獲取任意屬性。 但是，由于方法屬性實際上保存于下層的函數(shù)對象中 (meth.__func__)，因此不允許設(shè)置綁定方法的方法屬性。 嘗試設(shè)置方法的屬性將會導(dǎo)致引發(fā) AttributeError。 想要設(shè)置方法屬性，你必須在下層的函數(shù)對象中顯式地對其進行設(shè)置:

>>> 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'

更多信息請參閱 標準類型層級結(jié)構(gòu)。

代碼對象?

代碼對象被具體實現(xiàn)用來表示“偽編譯”的可執(zhí)行 Python 代碼，例如一個函數(shù)體。 它們不同于函數(shù)對象，因為它們不包含對其全局執(zhí)行環(huán)境的引用。 代碼對象由內(nèi)置的 compile() 函數(shù)返回，并可通過從函數(shù)對象的 __code__ 屬性從中提取。 另請參閱 code 模塊。

可以通過將代碼對象（而非源碼字符串）傳給 exec() 或 eval() 內(nèi)置函數(shù)來執(zhí)行或求值。

更多信息請參閱 標準類型層級結(jié)構(gòu)。

類型對象?

類型對象表示各種對象類型。 對象的類型可通過內(nèi)置函數(shù) type() 來獲取。 類型沒有特殊的操作。 標準庫模塊 types 定義了所有標準內(nèi)置類型的名稱。

類型以這樣的寫法來表示: <class 'int'>。

空對象?

此對象會由不顯式地返回值的函數(shù)所返回。 它不支持任何特殊的操作。 空對象只有一種值 None (這是個內(nèi)置名稱)。 type(None)() 會生成同一個單例。

該對象的寫法為 None。

省略符對象?

此對象常被用于切片 (參見 切片)。 它不支持任何特殊的操作。 省略符對象只有一種值 Ellipsis (這是個內(nèi)置名稱)。 type(Ellipsis)() 會生成 Ellipsis 單例。

該對象的寫法為 Ellipsis 或 ...。

未實現(xiàn)對象?

此對象會被作為比較和二元運算被應(yīng)用于它們所不支持的類型時的返回值。 請參閱 比較運算 了解更多信息。 未實現(xiàn)對象只有一種值 NotImplemented。 type(NotImplemented)() 會生成這個單例。

該對象的寫法為 NotImplemented。

布爾值?

布爾值是兩個常量對象 False 和 True。 它們被用來表示邏輯上的真假（不過其他值也可被當作真值或假值）。 在數(shù)字類的上下文中（例如被用作算術(shù)運算符的參數(shù)時），它們的行為分別類似于整數(shù) 0 和 1。 內(nèi)置函數(shù) bool() 可被用來將任意值轉(zhuǎn)換為布爾值，只要該值可被解析為一個邏輯值（參見之前的 邏輯值檢測 部分）。

該對象的寫法分別為 False 和 True。

內(nèi)部對象?

有關(guān)此對象的信息請參閱 標準類型層級結(jié)構(gòu)。 其中描述了棧幀對象、回溯對象以及切片對象等等。

特殊屬性?

語言實現(xiàn)為部分對象類型添加了一些特殊的只讀屬性，它們具有各自的作用。 其中一些并不會被 dir() 內(nèi)置函數(shù)所列出。

object.__dict__?

一個字典或其他類型的映射對象，用于存儲對象的（可寫）屬性。

instance.__class__?

類實例所屬的類。

class.__bases__?

由類對象的基類所組成的元組。

definition.__name__?

類、函數(shù)、方法、描述器或生成器實例的名稱。

definition.__qualname__?

類、函數(shù)、方法、描述器或生成器實例的 qualified name。

3.3 新版功能.

class.__mro__?

此屬性是由類組成的元組，在方法解析期間會基于它來查找基類。

class.mro()?

此方法可被一個元類來重載，以為其實例定制方法解析順序。 它會在類實例化時被調(diào)用，其結(jié)果存儲于 __mro__ 之中。

class.__subclasses__()?

每個類會保存由對其直接子類的弱引用組成的列表。 此方法將返回一個由仍然存在的所有此類引用組成的列表。 例如:

>>> int.__subclasses__()
[<class 'bool'>]

備注

1

有關(guān)這些特殊方法的額外信息可參看 Python 參考指南 (基本定制)。

2

作為結(jié)果，列表 [1, 2] 與 [1.0, 2.0] 是相等的，元組的情況也類似。

3

它們必須如此，因為解析器無法區(qū)分這些操作數(shù)的類型。

4(1,2,3,4)

區(qū)分大小寫的字符是指所屬一般類別屬性為 "Lu" (Letter, uppercase), "Ll" (Letter, lowercase) 或 "Lt" (Letter, titlecase) 之一的字符。

5(1,2)

要格式化單獨一個元組，那么你應(yīng)當提供一個單例元組，其唯一的元素就是要被格式化的元組。