整數類(lèi)型的按位運算?

按位運算只對整數有意義。 計算按位運算的結果，就相當于使用無(wú)窮多個(gè)二進(jìn)制符號位對二的補碼執行操作。

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

此表格是以?xún)?yōu)先級升序排序的按位運算列表:

注釋?zhuān)?/p>

1. 負的移位數是非法的，會(huì )導致引發(fā) ValueError。

2. 左移 n 位等價(jià)于乘以 pow(2, n) 。

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

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

整數類(lèi)型的附加方法?

int 類(lèi)型實(shí)現了 numbers.Integral abstract base class。 此外，它還提供了其他幾個(gè)方法:

int.bit_length()?

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

>>>

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

更準確地說(shuō)，如果 x 非零，則 x.bit_length() 是使得 2**(k-1) <= abs(x) < 2**k 的唯一正整數 k。 同樣地，當 abs(x) 小到足以具有正確的舍入對數時(shí)，則 k = 1 + int(log(abs(x), 2))。 如果 x 為零，則 x.bit_length() 返回 0。

等價(jià)于:

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.bit_count()?

返回整數的絕對值的二進(jìn)制表示中 1 的個(gè)數。也被稱(chēng)為 population count。示例:

>>>

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3

等價(jià)于:

def bit_count(self):
    return bin(self).count("1")

3.10 新版功能.

int.to_bytes(length=1, byteorder='big', *, signed=False)?

返回表示一個(gè)整數的字節數組。

>>>

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

The integer is represented using length bytes, and defaults to 1. An OverflowError is raised if the integer is not representable with the given number of bytes.

The byteorder argument determines the byte order used to represent the integer, and defaults to "big". If byteorder is "big", the most significant byte is at the beginning of the byte array. If byteorder is "little", the most significant byte is at the end of the byte array.

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

The default values can be used to conveniently turn an integer into a single byte object. However, when using the default arguments, don't try to convert a value greater than 255 or you'll get an OverflowError:

>>>

>>> (65).to_bytes()
b'A'

等價(jià)于:

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)

3.2 新版功能.

在 3.11 版更改: Added default argument values for length and byteorder.

classmethod int.from_bytes(bytes, byteorder='big', *, 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 參數必須為一個(gè) bytes-like object 或是生成字節的可迭代對象。

The byteorder argument determines the byte order used to represent the integer, and defaults to "big". If byteorder is "big", the most significant byte is at the beginning of the byte array. If byteorder is "little", the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value.

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

等價(jià)于:

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n

3.2 新版功能.

在 3.11 版更改: Added default argument value for byteorder.

int.as_integer_ratio()?

返回一對整數，其比率正好等于原整數并且分母為正數。 整數的比率總是用這個(gè)整數本身作為分子，1 作為分母。

3.8 新版功能.

浮點(diǎn)類(lèi)型的附加方法?

float 類(lèi)型實(shí)現了 numbers.Real abstract base class。 float 還具有以下附加方法。

float.as_integer_ratio()?

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

float.is_integer()?

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

>>>

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

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

float.hex()?

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

classmethod float.fromhex(s)?

返回以十六進(jìn)制字符串 s 表示的浮點(diǎn)數的類(lèi)方法。 字符串 s 可以帶有前導和尾隨的空格。

請注意 float.hex() 是實(shí)例方法，而 float.fromhex() 是類(lèi)方法。

十六進(jìn)制字符串采用的形式為:

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

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

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

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

對 3740.0 應用反向轉換會(huì )得到另一個(gè)代表相同數值的十六進(jìn)制數字符串:

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

數字類(lèi)型的哈希運算?

For numbers x and y, possibly of different types, it's a requirement that hash(x) == hash(y) whenever x == y (see the __hash__() method documentation for more details). For ease of implementation and efficiency across a variety of numeric types (including int, float, decimal.Decimal and fractions.Fraction) Python's hash for numeric types is based on a single mathematical function that's defined for any rational number, and hence applies to all instances of int and fractions.Fraction, and all finite instances of float and decimal.Decimal. Essentially, this function is given by reduction modulo P for a fixed prime P. The value of P is made available to Python as the modulus attribute of sys.hash_info.

詳細規則如下所述:

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

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

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

• 特殊值 sys.hash_info.inf 和 -sys.hash_info.inf 分別用于正無(wú)窮或負無(wú)窮的哈希值。

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

為了闡明上述規則，這里有一些等價(jià)于內置哈希算法的 Python 代碼示例，可用于計算有理數、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 object.__hash__(x)
    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

生成器類(lèi)型?

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

通用序列操作?

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

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

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

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

Forward and reversed iterators over mutable sequences access values using an index. That index will continue to march forward (or backward) even if the underlying sequence is mutated. The iterator terminates only when an IndexError or a StopIteration is encountered (or when the index drops below zero).

注釋?zhuān)?/p>

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

   >>>

   >>> "gg" in "eggs"
   True
   

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

   >>>

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

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

   >>>

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

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

3. 如果 i 或 j 為負值，則索引順序是相對于序列 s 的末尾: 索引號會(huì )被替換為 len(s) + i 或 len(s) + j。 但要注意 -0 仍然為 0。

4. s 從 i 到 j 的切片被定義為所有滿(mǎn)足 i <= k < j 的索引號 k 的項組成的序列。 如果 i 或 j 大于 len(s)，則使用 len(s)。 如果 i 被省略或為 None，則使用 0。 如果 j 被省略或為 None，則使用 len(s)。 如果 i 大于等于 j，則切片為空。

5. s 從 i 到 j 步長(cháng)為 k 的切片被定義為所有滿(mǎn)足 0 <= n < (j-i)/k 的索引號 x = i + n*k 的項組成的序列。 換句話(huà)說(shuō)，索引號為 i, i+k, i+2*k, i+3*k，以此類(lèi)推，當達到 j 時(shí)停止 (但一定不包括 j)。 當 k 為正值時(shí)，i 和 j 會(huì )被減至不大于 len(s)。 當 k 為負值時(shí)，i 和 j 會(huì )被減至不大于 len(s) - 1。 如果 i 或 j 被省略或為 None，它們會(huì )成為“終止”值 (是哪一端的終止值則取決于 k 的符號)。 請注意，k 不可為零。 如果 k 為 None，則當作 1 處理。

6. 拼接不可變序列總是會(huì )生成新的對象。 這意味著(zhù)通過(guò)重復拼接來(lái)構建序列的運行時(shí)開(kāi)銷(xiāo)將會(huì )基于序列總長(cháng)度的乘方。 想要獲得線(xiàn)性的運行時(shí)開(kāi)銷(xiāo)，你必須改用下列替代方案之一：

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

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

   • 如果拼接 tuple 對象，請改為擴展 list 類(lèi)

   • 對于其它類(lèi)型，請查看相應的文檔

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

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

不可變序列類(lèi)型?

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

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

嘗試對包含有不可哈希值的不可變序列進(jìn)行哈希運算將會(huì )導致 TypeError。

可變序列類(lèi)型?

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

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

注釋?zhuān)?/p>

1. t 必須與它所替換的切片具有相同的長(cháng)度。

2. 可選參數 i 默認為 -1，因此在默認情況下會(huì )移除并返回最后一項。

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

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

5. 包括 clear() 和 copy() 是為了與不支持切片操作的可變容器 (例如 dict 和 set) 的接口保持一致。 copy() 不是 collections.abc.MutableSequence ABC 的一部分，但大多數具體的可變序列類(lèi)都提供了它。

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

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

列表?

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

class list([iterable])?

可以用多種方式構建列表：

• 使用一對方括號來(lái)表示空列表: []

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

• 使用列表推導式: [x for x in iterable]

• 使用類(lèi)型的構造器: list() 或 list(iterable)

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

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

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

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

此方法會(huì )對列表進(jìn)行原地排序，只使用 < 來(lái)進(jìn)行各項間比較。 異常不會(huì )被屏蔽 —— 如果有任何比較操作失敗，整個(gè)排序操作將失?。ǘ斜砜赡軙?huì )處于被部分修改的狀態(tài)）。

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

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

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

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

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

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

有關(guān)排序示例和簡(jiǎn)要排序教程，請參閱 排序指南 。

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

元組?

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

class tuple([iterable])?

可以用多種方式構建元組：

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

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

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

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

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

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

元組實(shí)現了所有 一般 序列的操作。

對于通過(guò)名稱(chēng)訪(fǎng)問(wèn)相比通過(guò)索引訪(fǎng)問(wèn)更清晰的異構數據多項集，collections.namedtuple() 可能是比簡(jiǎn)單元組對象更為合適的選擇。

range 對象?

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

class range(stop)?

class range(start, stop[, step])

The arguments to the range constructor must be integers (either built-in int or any object that implements the __index__() special method). If the step argument is omitted, it defaults to 1. If the start argument is omitted, it defaults to 0. If step is zero, ValueError is raised.

如果 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 對象確實(shí)支持負索引，但是會(huì )將其解讀為從正索引所確定的序列的末尾開(kāi)始索引。

元素絕對值大于 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 對象實(shí)現了 一般 序列的所有操作，但拼接和重復除外（這是由于 range 對象只能表示符合嚴格模式的序列，而重復和拼接通常都會(huì )違反這樣的模式）。

start?

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

stop?

stop 形參的值

step?

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

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

range 對象實(shí)現了 collections.abc.Sequence ABC，提供如包含檢測、元素索引查找、切片等特性，并支持負索引 (參見(jiàn) 序列類(lèi)型 --- 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 對象是否相等是將其作為序列來(lái)比較。 也就是說(shuō)，如果兩個(gè) range 對象表示相同的值序列就認為它們是相等的。 （請注意比較結果相等的兩個(gè) range 對象可能會(huì )具有不同的 start, stop 和 step 屬性，例如 range(0) == range(2, 1, 3) 而 range(0, 3, 2) == range(0, 4, 2)。）

字符串的方法?

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

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

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

str.capitalize()?

返回原字符串的副本，其首個(gè)字符大寫(xiě)，其余為小寫(xiě)。

在 3.8 版更改: 第一個(gè)字符現在被放入了 titlecase 而不是 uppercase。 這意味著(zhù)復合字母類(lèi)字符將只有首個(gè)字母改為大寫(xiě)，而再不是全部字符大寫(xiě)。

str.casefold()?

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

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

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

3.3 新版功能.

str.center(width[, fillchar])?

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

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

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

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

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

默認情況下，為了獲得最佳性能，不會(huì )檢測 errors 參數，而只在首次編碼錯誤時(shí)用到它。若要檢測 errors ，請啟用 Python開(kāi)發(fā)模式 或用 調試版本 。

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

在 3.9 版更改: 現在，僅在開(kāi)發(fā)模式和 調試模式 下才會(huì )檢測 errors。

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

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

str.expandtabs(tabsize=8)?

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

>>>

>>> '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 會(huì )被解讀為切片表示法。 如果 sub 未被找到則返回 -1。

備注

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

>>>

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)?

執行字符串格式化操作。 調用此方法的字符串可以包含字符串字面值或者以花括號 {} 括起來(lái)的替換域。 每個(gè)替換域可以包含一個(gè)位置參數的數字索引，或者一個(gè)關(guān)鍵字參數的名稱(chēng)。 返回的字符串副本中每個(gè)替換域都會(huì )被替換為對應參數的字符串值。

>>>

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

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

備注

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

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

str.format_map(mapping)?

類(lèi)似于 str.format(**mapping)，不同之處在于 mapping 會(huì )被直接使用而不是復制到一個(gè) dict。 適宜使用此方法的一個(gè)例子是當 mapping 為 dict 的子類(lèi)的情況：

>>>

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

類(lèi)似于 find()，但在找不到子字符串時(shí)會(huì )引發(fā) ValueError。

str.isalnum()?

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

str.isalpha()?

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

str.isascii()?

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

3.7 新版功能.

str.isdecimal()?

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

str.isdigit()?

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

str.isidentifier()?

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

調用 keyword.iskeyword() 來(lái)檢測字符串 s 是否為保留標識符，例如 def 和 class。

示例：

>>>

>>> from keyword import iskeyword

>>> 'hello'.isidentifier(), iskeyword('hello')
(True, False)
>>> 'def'.isidentifier(), iskeyword('def')
(True, True)

str.islower()?

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

str.isnumeric()?

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

str.isprintable()?

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

str.isspace()?

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

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

str.istitle()?

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

str.isupper()?

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

>>>

>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
False

str.join(iterable)?

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

str.ljust(width[, fillchar])?

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

str.lower()?

返回原字符串的副本，其所有區分大小寫(xiě)的字符 4 均轉換為小寫(xiě)。

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

str.lstrip([chars])?

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

>>>

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

參見(jiàn) str.removeprefix() ，該方法將刪除單個(gè)前綴字符串，而不是全部給定集合中的字符。 例如:

>>>

>>> 'Arthur: three!'.lstrip('Arthur: ')
'ee!'
>>> 'Arthur: three!'.removeprefix('Arthur: ')
'three!'

static str.maketrans(x[, y[, z]])?

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

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

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

str.partition(sep)?

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

str.removeprefix(prefix, /)?

如果字符串以 前綴 字符串開(kāi)頭，返回 string[len(prefix):] 。否則，返回原始字符串的副本：

>>>

>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

3.9 新版功能.

str.removesuffix(suffix, /)?

如果字符串以 后綴 字符串結尾，并且 后綴 非空，返回 string[:-len(suffix)] 。否則，返回原始字符串的副本：

>>>

>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'

3.9 新版功能.

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

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

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

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

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

類(lèi)似于 rfind()，但在子字符串 sub 未找到時(shí)會(huì )引發(fā) ValueError。

str.rjust(width[, fillchar])?

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

str.rpartition(sep)?

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

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

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

str.rstrip([chars])?

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

>>>

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

要刪除單個(gè)后綴字符串，而不是全部給定集合中的字符，請參見(jiàn) str.removesuffix() 方法。 例如:

>>>

>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'

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

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

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

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

此方法會(huì )以下列行邊界進(jìn)行拆分。 特別地，行邊界是 universal newlines 的一個(gè)超集。

表示符	描述
\n	換行
\r	回車(chē)
\r\n	回車(chē) + 換行
\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 時(shí)，對于空字符串此方法將返回一個(gè)空列表，而末尾的換行不會(huì )令結果中增加額外的行:

>>>

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

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

>>>

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

str.startswith(prefix[, start[, end]])?

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

str.strip([chars])?

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

>>>

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

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

>>>

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

str.swapcase()?

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

str.title()?

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

例如：

>>>

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

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

>>>

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

The string.capwords() function does not have this problem, as it splits words on spaces only.

Alternatively, a workaround for apostrophes can be constructed using regular expressions:

>>>

>>> import re
>>> def titlecase(s):
...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0).capitalize(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

str.translate(table)?

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

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

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

str.upper()?

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

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

str.zfill(width)?

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

例如：

>>>

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

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

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

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

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

1. '%' 字符，用于標記轉換符的起始。

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

3. 轉換旗標（可選），用于影響某些轉換類(lèi)型的結果。

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

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

6. 長(cháng)度修飾符（可選）。

7. 轉換類(lèi)型。

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

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

在此情況下格式中不能出現 * 標記符（因其需要一個(gè)序列類(lèi)的參數列表）。

轉換旗標為：

可以給出長(cháng)度修飾符 (h, l 或 L)，但會(huì )被忽略，因為對 Python 來(lái)說(shuō)沒(méi)有必要 -- 所以 %ld 等價(jià)于 %d。

轉換類(lèi)型為：

注釋?zhuān)?/p>

1. 此替代形式會(huì )在第一個(gè)數碼之前插入標示八進(jìn)制數的前綴 ('0o')。

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

3. 此替代形式總是會(huì )在結果中包含一個(gè)小數點(diǎn)，即使其后并沒(méi)有數碼。

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

4. 此替代形式總是會(huì )在結果中包含一個(gè)小數點(diǎn)，末尾各位的零不會(huì )如其他情況下那樣被移除。

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

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

6. 參見(jiàn) PEP 237。

由于 Python 字符串顯式指明長(cháng)度，%s 轉換不會(huì )將 '\0' 視為字符串的結束。

bytes 對象?

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

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

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

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

• Double quotes: b"still allows embedded 'single' quotes"

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

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

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

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

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

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

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

• 通過(guò)緩沖區協(xié)議復制現有的二進(jìn)制數據: bytes(obj)

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

由于兩個(gè)十六進(jìn)制數碼精確對應一個(gè)字節，因此十六進(jìn)制數是描述二進(jìn)制數據的常用格式。 相應地，bytes 類(lèi)型具有從此種格式讀取數據的附加類(lèi)方法：

classmethod fromhex(string)?

此 bytes 類(lèi)方法返回一個(gè)解碼給定字符串的 bytes 對象。 字符串必須由表示每個(gè)字節的兩個(gè)十六進(jìn)制數碼構成，其中的 ASCII 空白符會(huì )被忽略。

>>>

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

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

存在一個(gè)反向轉換函數，可以將 bytes 對象轉換為對應的十六進(jìn)制表示。

hex([sep[, bytes_per_sep]])?

返回一個(gè)字符串對象，該對象包含實(shí)例中每個(gè)字節的兩個(gè)十六進(jìn)制數字。

>>>

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

如果你希望令十六進(jìn)制數字符串更易讀，你可以指定單個(gè)字符分隔符作為 sep 形參包含于輸出中。 默認會(huì )放在每個(gè)字節之間。 第二個(gè)可選的 bytes_per_sep 形參控制間距。 正值會(huì )從右開(kāi)始計算分隔符的位置，負值則是從左開(kāi)始。

>>>

>>> value = b'\xf0\xf1\xf2'
>>> value.hex('-')
'f0-f1-f2'
>>> value.hex('_', 2)
'f0_f1f2'
>>> b'UUDDLRLRAB'.hex(' ', -4)
'55554444 4c524c52 4142'

3.5 新版功能.

在 3.8 版更改: bytes.hex() 現在支持可選的 sep 和 bytes_per_sep 形參以在十六進(jìn)制輸出的字節之間插入分隔符。

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

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

bytearray 對象?

bytearray 對象是 bytes 對象的可變對應物。

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

bytearray 對象沒(méi)有專(zhuān)屬的字面值語(yǔ)法，它們總是通過(guò)調用構造器來(lái)創(chuàng )建：

• 創(chuàng )建一個(gè)空實(shí)例: bytearray()

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

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

• 通過(guò)緩沖區協(xié)議復制現有的二進(jìn)制數據: bytearray(b'Hi!')

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

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

由于兩個(gè)十六進(jìn)制數碼精確對應一個(gè)字節，因此十六進(jìn)制數是描述二進(jìn)制數據的常用格式。 相應地，bytearray 類(lèi)型具有從此種格式讀取數據的附加類(lèi)方法：

classmethod fromhex(string)?

bytearray 類(lèi)方法返回一個(gè)解碼給定字符串的 bytearray 對象。 字符串必須由表示每個(gè)字節的兩個(gè)十六進(jìn)制數碼構成，其中的 ASCII 空白符會(huì )被忽略。

>>>

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

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

存在一個(gè)反向轉換函數，可以將 bytearray 對象轉換為對應的十六進(jìn)制表示。

hex([sep[, bytes_per_sep]])?

返回一個(gè)字符串對象，該對象包含實(shí)例中每個(gè)字節的兩個(gè)十六進(jìn)制數字。

>>>

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

3.5 新版功能.

在 3.8 版更改: 與 bytes.hex() 相似， bytearray.hex() 現在支持可選的 sep 和 bytes_per_sep 參數以在十六進(jìn)制輸出的字節之間插入分隔符。

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

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

bytes 和 bytearray 操作?

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

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

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

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

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

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

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

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

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內的整數。

在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。

bytes.removeprefix(prefix, /)?

bytearray.removeprefix(prefix, /)?

如果二進(jìn)制數據以 前綴 字符串開(kāi)頭，返回 bytes[len(prefix):] 。否則，返回原始二進(jìn)制數據的副本：

>>>

>>> b'TestHook'.removeprefix(b'Test')
b'Hook'
>>> b'BaseTestCase'.removeprefix(b'Test')
b'BaseTestCase'

前綴可以是任意 bytes-like object。

備注

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

3.9 新版功能.

bytes.removesuffix(suffix, /)?

bytearray.removesuffix(suffix, /)?

如果二進(jìn)制數據以 后綴 字符串結尾，并且 后綴 非空，返回 bytes[:-len(suffix)] 。否則，返回原始二進(jìn)制數據的副本：

>>>

>>> b'MiscTests'.removesuffix(b'Tests')
b'Misc'
>>> b'TmpDirMixin'.removesuffix(b'Tests')
b'TmpDirMixin'

后綴可以是任意 bytes-like object。

備注

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

3.9 新版功能.

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

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

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

默認情況下，為了獲得最佳性能，不會(huì )檢測 errors 參數，而只在首次編碼錯誤時(shí)用到它。若要檢測 errors ，請啟用 Python開(kāi)發(fā)模式 或用 調試版本 。

備注

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

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

在 3.9 版更改: 現在，僅在開(kāi)發(fā)模式和 調試模式 下才會(huì )檢測 errors。

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

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

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

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

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

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

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

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內的整數。

備注

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

>>>

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

在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。

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

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

類(lèi)似于 find()，但在找不到子序列時(shí)會(huì )引發(fā) ValueError。

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內的整數。

在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。

bytes.join(iterable)?

bytearray.join(iterable)?

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

static bytes.maketrans(from, to)?

static bytearray.maketrans(from, to)?

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

3.1 新版功能.

bytes.partition(sep)?

bytearray.partition(sep)?

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

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

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

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

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

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

備注

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

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

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

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

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內的整數。

在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。

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

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

類(lèi)似于 rfind()，但在子序列 sub 未找到時(shí)會(huì )引發(fā) ValueError。

要搜索的子序列可以是任意 bytes-like object 或是 0 至 255 范圍內的整數。

在 3.3 版更改: 也接受 0 至 255 范圍內的整數作為子序列。

bytes.rpartition(sep)?

bytearray.rpartition(sep)?

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

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

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

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

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

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

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

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

返回原 bytes 或 bytearray 對象的副本，移除其中所有在可選參數 delete 中出現的 bytes，其余 bytes 將通過(guò)給定的轉換表進(jìn)行映射，該轉換表必須是長(cháng)度為 256 的 bytes 對象。

你可以使用 bytes.maketrans() 方法來(lái)創(chuàng )建轉換表。

對于僅需移除字符的轉換，請將 table 參數設為 None:

>>>

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

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

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

bytes.center(width[, fillbyte])?

bytearray.center(width[, fillbyte])?

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

備注

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

bytes.ljust(width[, fillbyte])?

bytearray.ljust(width[, fillbyte])?

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

備注

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

bytes.lstrip([chars])?

bytearray.lstrip([chars])?

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

>>>

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

要移除的二進(jìn)制序列可以是任意 bytes-like object 。 要刪除單個(gè)前綴字符串，而不是全部給定集合中的字符，請參見(jiàn) str.removeprefix() 方法。 例如:

>>>

>>> b'Arthur: three!'.lstrip(b'Arthur: ')
b'ee!'
>>> b'Arthur: three!'.removeprefix(b'Arthur: ')
b'three!'

備注

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

bytes.rjust(width[, fillbyte])?

bytearray.rjust(width[, fillbyte])?

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

備注

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

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

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

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

bytes.rstrip([chars])?

bytearray.rstrip([chars])?

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

>>>

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

要移除的二進(jìn)制序列可以是任意 bytes-like object 。 要刪除單個(gè)后綴字符串，而不是全部給定集合中的字符，請參見(jiàn) str.removesuffix() 方法。 例如:

>>>

>>> b'Monty Python'.rstrip(b' Python')
b'M'
>>> b'Monty Python'.removesuffix(b' Python')
b'Monty'

備注

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

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

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

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

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

例如：

>>>

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