Python標準庫（3）

3.內置常量

少量的常量存在於內置的命名空間中。他們是：

False

bool類型的錯誤值。分配False 是非法的，並提出一個SyntaxError。

True

bool類型的真正價值。分配True 是非法的，並提出一個SyntaxError。

None

類型的唯一值NoneType。 None經常用來表示沒有值，因為默認參數沒有傳遞給函數。分配

None是非法的，並提出一個SyntaxError。

NotImplemented

這應該由二進制特殊的方法被返回（如特殊的值 __eq__() ， __lt__() ， __add__() ，

__rsub__()，等等），以指示該操作不相對於另一種類型的實施; 可通過就地二進制特殊的

方法（例如被返回__imul__()，__iand__()為了相同的目的，等等）。它的真實價值是真

實的。

注意: 當二進制（或in-place）方法返回NotImplemented解釋器時，將嘗試對另一個類型

（ 或 其 他 某 個 後 備 ， 取 決 於 操 作 符 ） 的 反 射 操 作 。 如 果 所 有 嘗 試 都 返 回

NotImplemented，則解釋器會提出適當的例外。錯誤地返回NotImplemented將導致錯誤

的錯誤消息或NotImplemented返回到Python代碼的值。

有關示例，請參閱實現算術運算。

注意: NotImplementedError和NotImplemented不能互換，即使他們有相似的名稱和用

途。請參閱NotImplementedError有關何時使用它的詳細信息。

Ellipsis

和...。一樣。特別值與用戶定義的容器數據類型的擴展切片語法結合使用。

__debug__

如果Python沒有使用-O選項啟動，這個常量是正確的。另見assert聲明。

注意: 名稱None，False，True並且__debug__ 不能被重新分配（分配給他們，甚至作為一

個屬性名稱，提高 SyntaxError），因此它們可以被認為是“真正的”常數。

3.1。site模塊添加的常量

該site模塊（在啟動過程中自動導入，除非-S給出了命令行選項）將幾個常量添加到內置命名

空間。它們對交互式解釋器外殼非常有用，不應在程序中使用。

quit（code = None ）exit（code = None ）

當打印時，打印一條消息，如“使用退出（）或Ctrl-D（即EOF）退出”，並在調用時

SystemExit使用指定的退出代碼進行提升。

copyright

credits

在打印或調用時分別打印版權或信用文本的對象。

license

當打印時，打印消息“輸入license（）以查看完整的許可證文本”，當被調用時，以類似於

尋呼機的方式（一次一個屏幕）顯示完整的許可證文本。4.內置類型

以下部分描述了內置到解釋器中的標準類型。

主要的內置類型是數字，序列，映射，類，實例和異常。

一些集合類是可變的。那些添加，減少或重新排列其成員的方法，並且不返回特定項目，但永遠不會返

回集合實例本身None。

一些操作由幾種對象類型支持; 特別是，實際上所有對象都可以進行比較，測試真值，並將其轉換為字

符串（使用repr()函數或稍微不同的 str()函數）。當函數寫入對象時，隱式使用後者print()函數。

4.1。真值測試

任何對象都可以測試真值，以用於下面的布爾運算的a if或 while條件或操作數。

默認情況下，一個對象被認為是真的，除非它的類定義了一個 __bool__()返回False的__len__()方法

或者一個方法返回零，當被對象調用時。[1] 以下是大多數被認為是錯誤的內置對象：

定義為false的常量：None和False。

任何數值類型的零：0，0.0，0j，Decimal(0)， Fraction(0, 1)

空序列和集合：''，()，[]，{}，set()， range(0)

除非另有說明，否則具有布爾結果的操作和內置函數總是返回0 或False為false 1或True為true。（重

要的例外：布爾操作or並and始終返回其操作數之一。）

4.2。布爾運算- ，，and ornot

這些是布爾操作，按優先級升序排列：

手術

結果

筆記

x or y

如果x是假的，那麼y，否則 x

（1）

x and y

如果x是假的，那麼x，否則 y

（2）

not x

如果x是假的，那麼True，否則False （3）

筆記：

1. 這是一個短路運算符，因此如果第一個參數為假，它只會計算第二個參數。

2. 這是一個短路操作符，所以如果第一個參數為真，它只會計算第二個參數。

3. not具有比非布爾運算符更低的優先級，因此被解釋為，並且是語法錯誤。not a == b not (a ==

b) a == not b

4.3。比較

Python中有八個比較操作。它們都具有相同的優先級（這比布爾操作的優先級高）。比較可以任意鏈

接; 例如等同於，除了y只被評估一次（但是在兩種情況下，當z被發現為假時根本不被評估）。x < y

<= z x < y and y <= z x < y

本表總結了比較操作：

手術

含義手術

含義

<

嚴格小於

<=

小於或等於

>

嚴格大於

>=

大於或等於

==

等於

!=

不等於

is

對象身份

is not 否定對象身份

除了不同的數字類型，不同類型的對象永遠不會相等。此外，某些類型（例如函數對象）僅支持簡單的

比較概念，即任何兩種類型的對象都不相等。的和>=運營商將提出一個TypeError比較複雜

的數字時異常另一個內置數字型，當對象是不同的類型，而且不能比擬的，或在其他情況下，沒有定義

排序的。

除非類定義__eq__()方法，否則通常將類的不同實例比較為不相等。

一個類的實例不能相對於同一類的其他實例，或其他類型的對象進行排序，除非類定義了足夠的方法

__lt__()，__le__()，__gt__()，和__ge__()（在一般情況下，__lt__()並__eq__()有足夠的，如果你

想要的傳統含義比較運算符）。

is和運營商的行為不能定製; 它們也可以應用於任何兩個對象，並且不會引發異常。is not

具有相同優先級的語法兩個操作，in並且 ，只能通過序列類型（下）的支持。not in

4.4。數字類型- ，，int floatcomplex

有三種不同的數字類型：整數，浮點數和複數。另外，布爾是一個整數的子類型。整數具有無限精度。

浮點數通常 double 在C中實現; 有關運行程序的機器的浮點數的精度和內部表示的信息可在

sys.float_info。複數有一個實部和虛部，每個部分都是一個浮點數。要從複數z中提取這些零件，請

使用z.real和z.imag。（標準庫包含額外的數字類型，fractions用於保存有理數據和decimal 這些浮

點數用用戶可定義的精度保存。）

數字由數字文字或內置函數和運算符的結果創建。未經修飾的整數文字（包括十六進制，八進制和二進

制數字）將產生整數。包含小數點或指數符號的數字文字會生成浮點數字。追加'j'或'J'數字文字會

產生一個虛數（一個具有零實數部分的複數），您可以將其添加到整數或浮點數以獲得具有實部和虛部

的複數。

Python完全支持混合算術：當二進制算術運算符的操作數具有不同的數值類型時，“窄”類型的操作數會

擴展到另一個操作數，其中整數比浮點窄，比浮點窄。混合類型的數字之間的比較使用相同的規則。

[2]的構造int()，float()以及 complex()可以用來產生特定類型的號碼。

所有數字類型（除複數）都支持以下操作，按優先級升序排列（所有數字操作的優先級均高於比較操

作）：

手術

結果

筆記

完整的文檔

x + y

x和y之和

x - y

x和y的差異

x * y

x和y的乘積

x / y

x和y的商數手術

結果

筆記

完整的文檔

x // y

x和 y的商數

（1）

x % y

剩下的 x / y

（2）

-x

x否定

+x

x不變

abs(x)

絕對值或x的大小

abs()

int(x)

x轉換為整數

（

（

3

6

）

）

int()

float(x)

x轉換為浮點

（

（4

6

）

）

float()

complex(re, im)

複數與實部 重，虛部IM。 我默認為

零。

（6）

complex()

c.conjugate()

複數c的共軛

divmod(x, y)

這對 (x // y, x % y)

（2）

divmod()

pow(x, y)

x到權力y

（5）

pow()

x ** y

x到權力y

（5）

筆記：

1. 也被稱為整數除法。結果值是一個整數，雖然結果的類型不一定是int。結果總是朝著負無窮的方

向變化：1//2是0，(-1)//2是 -1，1//(-2)是-1，(-1)//(-2)是0。

2. 不適用於複雜的數字。相反，轉換為浮動使用abs()。

3. 從C中浮點到整數的轉換可能會舍入或截斷; 查看功能math.floor()和math.ceil()定義明確的轉

換。

4. 對於非數字（NaN）和正或負無窮，float還接受帶有可選前綴“+”或“ - ”的字符串“nan”和“inf”。

5. Python定義和將會像編程語言一樣常見。pow(0, 0) 0 ** 0 1

6. 接受的數字文字包括數字0到9或任何Unicode當量（與代碼點Nd屬性）。

請參閱http://www.unicode.org/Public/9.0.0/ucd/extracted/DerivedNumericType.txt 以獲取具有該

Nd屬性的代碼點的完整列表。

所有numbers.Real類型（int和float）還包括以下操作：

手術

結果

math.trunc(x)

x截斷為Integral

round(x[, n])

x四捨五入為n位數，四捨五入為偶數。如果省略n，則默認為

0

。

math.floor(x)

最大的

Integral <= x

math.ceil(x)

至少Integral> = x

有關其他數字操作，請參閱math和cmath 模塊。

4.4.1。整數類型的按位運算

按位運算只對整數有意義。負數被視為它們的2的補碼值（假定有足夠的位數以便在操作期間不發生溢

出）。

二進制按位運算的優先級均低於數值運算並高於比較; 一元運算~與其他一元運算（+和-）具有相同的

優先級。此表列出按升序優先級排序的按位運算：

手術

結果

筆記

x | y

按位或的X和 ÿ

x ^ y

按位異或的 X和ÿ

x & y

按位和的X和 ÿ

x << n

x左移n位

（

（1

2

）

）

x >> n

x右移n位

（

（

1

3

）

）

~x

x的位反轉

筆記：

1. 負轉移次數是非法的，並導致a ValueError被提出。

2. 左移n位相當於 沒有溢出檢查的乘法。pow(2, n)

3. 右移n位相當於沒有溢出檢查的除法。pow(2, n)

4.4.2。整數類型的其他方法

int類型實現抽象基類。另外，它還提供了更多的方法：numbers.Integral

int.bit_length（）

返回表示二進制整數所需的位數，不包括符號和前導零：

更確切地說，如果x不為零，則x.bit_length()是唯一的正整數k這樣。等價地，當小到足以得到正

確 的 舍 入 對 數 時 ， 則 。 如 果 是 零 ， 則 返 回 。 2**(k-1) <= abs(x) < 2**k abs(x) k = 1 +

int(log(abs(x), 2)) x x.bit_length() 0

相當於：

版本3.1中的新功能。

int.to_bytes（長度，字節順序，*，signed = False ）

返回表示整數的字節數組。

>>> n = -37

>>> bin(n)

'-0b100101'

>>> n.bit_length()

6

>>>

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

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

>>>整數用長度字節表示。OverflowError 如果整數不能用給定的字節數來表示，則會引發An 。

的字節順序參數確定用於表示整數的字節順序。如果字節序是"big"，則最重要的字節在字節數組

的開始處。如果字節序是"little"，則最重要的字節在字節數組的末尾。要請求主機系統的本地字

節順序，請使用sys.byteorder字節順序值。

帶符號的參數確定是否使用二進制補碼錶示整數。如果signed是False且給出了一個負整數，則會

產生一個OverflowError。signed的默認值 是False。

3.2版本中的新功能

classmethod int.from_bytes（bytes，byteorder，*，signed = False ）

返回給定字節數組所表示的整數。

參數字節必須是類似字節的對象或可迭代的生成字節。

的字節順序參數確定用於表示整數的字節順序。如果字節序是"big"，則最重要的字節在字節數組

的開始處。如果字節序是"little"，則最重要的字節在字節數組的末尾。要請求主機系統的本地字

節順序，請使用sys.byteorder字節順序值。

帶符號的參數指示是否使用二進制補碼錶示整數。

3.2版本中的新功能

4.4.3。浮點附加方法

浮點類型實現抽象基類。float還有以下附加方法。numbers.Real

float.as_integer_ratio（）

返回一對整數，其比例與原始浮點數完全相等，並帶有一個正的分母。提高 OverflowError無窮大

和ValueErrorNaNs。

float.is_integer（）

返回True如果浮子實例是有限的與積分值，並False以其他方式：

兩種方法支持與十六進制字符串的轉換。由於Python的浮點數在內部存儲為二進制數，因此將浮點數

轉換為十進制字符串或從十進制字符串轉換浮點數 通常會導致一個小的舍入誤差 相反，十六進制字符

串允許精確表示和指定浮點數。這在調試和數值工作時非常有用。

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

>>>

>>> (-2.0).is_integer()

True

>>> (3.2).is_integer()

False

>>>float.hex（）

將浮點數的表示形式返回為十六進制字符串。對於有限的浮點數，這種表示將總是包括前導0x和尾

隨p以及指數。

classmethod float.fromhex（s ）

Class方法返回由十六進制字符串s表示的float 。字符串s可能有前導和尾隨空白。

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

十六進制字符串採用以下形式：

其中可選sign可以是+或者-，integer 並且fraction是十六進制數字的字符串，並且exponent 是具有

可選前導符號的十進制整數。大小寫不重要，整數或小數中至少有一個十六進制數字。此語法與C99標

準的6.4.4.2節中指定的語法類似，也與Java 1.5之後的語法類似。特別是，輸出 float.hex()可用作C

或Java代碼中的十六進制浮點字面值，並且由C的 %a 格式字符或Java 產生的十六進制字符串

Double.toHexString被接受 float.fromhex()。

請注意，指數是用十進制而不是十六進制編寫的，它給出了乘以係數的2的冪。例如，十六進制字符串

0x3.a7p10表示浮點數，或者 ：(3 + 10./16 + 7./16**2) * 2.0**10 3740.0

將反向轉換應用於3740.0給出代表相同數字的不同十六進制字符串：

4.4.4。數字類型的散列

對於數字x和y可能是不同類型的數據，每當需要時（請參閱 方法文檔以獲取更多詳細信息）。為了便

於實施和效率在各種的數字類型的（包括， ，和）Python的數字類型的散列是基於對於任何合理的數

目來定義，因此，一個單一的數學函數將應用於的所有實例 和所有的有限的情況下，和中 和。本質

上，這個函數是通過對一個固定素數進行減模求得的。Python 的值可用作屬性 。hash(x) == hash(y) x

==

y __hash__() int float decimal.Decimal fractions.Fraction int fractions.Fraction float decimal.Decimal

P P P modulus sys.hash_info

CPython實現細節：目前，主要使用的是32位C長的機器和64位C長的機器。P = 2**31 - 1 P = 2**61

- 1

詳細規則如下：

如果是一個非負的有理數，並且不能被整除，定義為，其中給出了模的倒數。 x = m /

n n P hash(x) m * invmod(n, P) % P invmod(n, P) n P

如果是一個非負的有理數，並且可以被整除（但不是），那麼沒有逆模，並且上面的規則不適用;

在這種情況下定義 為常數值。x = m / n n P m n P hash(x) sys.hash_info.inf

如果是負數有理數定義 為。如果生成的散列是，替換它 。x = m / n hash(x) -hash(-x) -1 -2

特定的值sys.hash_info.inf，-sys.hash_info.inf 並且sys.hash_info.nan被用作正無窮大，負

無窮大或nans（分別）的散列值。（所有可散列的nans具有相同的散列值。）

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

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

3740.0

>>>

>>> float.hex(3740.0)

'0x1.d380000000000p+11'

>>>對於一個complex數字z，實部和虛部的散列值通過計算結合起來，減少模數 以使其位於中 。再

次 ， 如 果 結 果 是 ， 它 被 替 換 。 hash(z.real) + sys.hash_info.imag *

hash(z.imag) 2**sys.hash_info.width range(-2**(sys.hash_info.width

-

1),

2**

(sys.hash_info.width - 1)) -1 -2

為了澄清上述規則，下面是一些Python代碼示例，等同於內置哈希，用於計算有理數的散列float，或

complex：

4.5。迭代器類型

Python支持對容器進行迭代的概念。這是使用兩種不同的方法實現的; 這些用於允許用戶定義的類支持

迭代。下面更詳細地描述的序列總是支持迭代方法。

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需要為容器對象定義一個方法來提供迭代支持：

container.__iter__（）

返回一個迭代器對象。該對象需要支持下面描述的迭代器協議。如果一個容器支持不同類型的迭

代，可以提供額外的方法來專門為這些迭代類型請求迭代器。（支持多種形式迭代的對象的一個

例

子是支持廣度優先和深度優先遍歷的樹結構。）此方法對應tp_iter於Python / C API中Python對象

的類型結構的 槽。

迭代器對象本身需要支持以下兩種方法，它們一起構成迭代器協議：

iterator.__iter__（）

返回迭代器對象本身。這是允許容器和迭代器與for和in語句一起使用所必需的。此方法對應

tp_iter於Python / C API中Python對象的類型結構的插槽。

iterator.__next__（）

從容器中返回下一個項目。如果沒有其他項目，請舉例說明 StopIteration 。此方法對應

tp_iternext於Python / C API中Python對象的類型結構的 插槽。

Python定義了幾個迭代器對象來支持對通用和特定序列類型，字典以及其他更專用的形式的迭代。除

了迭代器協議的實現之外，特定類型並不重要。

一旦迭代器的__next__()方法提出 StopIteration，它必須繼續在後續調用中這樣做。不遵守這一財產

的實施被視為破產。

4.5.1。發電機類型

Python的生成器提供了一種實現迭代器協議的便捷方式。如果容器對象的__iter__()方法作為生成器

實現，它將自動返回提供__iter__()和__next__() 方法的迭代器對象（技術上講，生成器對象）。有

關生成器的更多信息可以在yield表達式的文檔中找到。

4.6。序列類型- ，，list tuplerange

有三種基本的序列類型：列表，元組和範圍對象。在專用章節中描述了為處理二進制數據和文本字符串

而量身定製的其他序列類型 。

4.6.1。常見序列操作

大多數序列類型都支持下表中的操作，它們都是可變的和不可變的。在collections.abc.Sequence美國

廣播公司提供，使其更容易正確地執行自定義序列類型這些操作。

此表列出按升序優先級排序的序列操作。在表中，s和t是相同類型的序列，n，i，j和k是整數，x是滿足

由s施加的任何類型和值限制的任意對象。

在in和操作具有比較操作相同的優先級。的（串聯）和（重複）操作具有相同的優先級對應的數字操

作。[3]not in + *

手術

結果

筆記

x in s

True如果一個s的項等於x，否則False

（1）

x not in s

False如果一個s的項等於x，否則True

（1）

s + t

s和 t的連接

（6）（7）手術

結果

筆記

s * n 要麼 n * s

相當於增加小號到本身Ñ倍

（2）（7）

s[i]

我的個項小號，原點0

（3）

s[i:j]

的切片小號從我到Ĵ

（3）（4）

s[i:j:k]

的切片小號從我到Ĵ 與步驟ķ

（3）（5）

len(s)

s的長度

min(s)

s的最小項

max(s)

最大的項目小號

s.index(x[, i[, j]])

的第一次出現的指數X在小號（在或索引後我

和指數前Ĵ）

（8）

s.count(x)

出現的總次數 X在小號

相同類型的序列也支持比較。具體來說，元組和列表通過比較相應的元素按字典順序進行比較。這意味

著為了比較相等，每個元素必須相等並且兩個序列必須是相同類型並具有相同長度。（有關完整的詳細

信息，請參閱語言參考中的比較。）

筆記：

1. 雖然in和操作僅用於簡單容納測試在一般情況下，一些專門的序列（如，和）也將它們用於序列

檢測：not in str bytes bytearray

2. 小於n的值0被視為0（其產生與s相同類型的空序列）。請注意，序列中的 項目不會被複制; 它們

被多次引用。這經常困擾著新的Python程序員; 考慮：

發生了什麼[[]]是一個包含一個空列表的單元素列表，因此所有三個元素都是對這個單個空列表

的引用。修改任何修改此單個列表的元素。您可以通過以下方式創建不同列表的列表：[[]] *

3 lists

進一步的解釋可以在FAQ條目中找到 如何創建多維列表？。

3. 如果i或j是負數，則該索引是相對於序列s的末尾： 或被替換。但請注意，依然如此。len(s) +

i len(s) + j -0 0

4. 的切片小號從我到Ĵ被定義為物品的具有索引序列 ķ使得。如果我或j大於，請使用 。如果我被省

略或者使用。如果省略了j，或者 使用。如果我大於或等於j，則切片為空。 i <= k <

>>> "gg" in "eggs"

True

>>>

>>> lists = [[]] * 3

>>> lists

[[], [], []]

>>> lists[0].append(3)

>>> lists

[[3], [3], [3]]

>>>

>>> lists = [[] for i in range(3)]

>>> lists[0].append(3)

>>> lists[1].append(5)

>>> lists[2].append(7)

>>> lists

[[3], [5], [7]]

>>>j len(s) len(s) None 0 None len(s)

5. 步驟k中從i到j的s片段被定義為具有這樣的索引的項目序列 。換句話說，在指數，，，等等，停

車時 Ĵ達到（但絕不包括Ĵ）。當k是正數時，如果它們更大，則 i和j會減少。當k是負數時，如果i

和 j 更 大 ， 則 i 和 j 減 小 。 如 果 我 或 j 被 省 略 或 x = i + n*k 0 <= n < (j-

i)/k i i+k i+2*k i+3*k len(s) len(s) - 1 None，它們變成了“終點”值（終點取決於k的符號）。請注

意，k不能為零。如果k是None，它被視為像1。

6. 串聯不可變序列總是會產生一個新對象。這意味著通過重複串聯構建序列在總序列長度中將具有

二次運行成本。要獲得線性運行時成本，您必須切換到以下選項之一：

如果連接str對象，則可以創建列表並str.join()在最後使用 ，或者寫入io.StringIO 實例

並在完成時檢索其值

如果連接bytes對象，則可以同樣使用 bytes.join()或io.BytesIO，或者可以在bytearray

對象中進行就地連接。 bytearray 對象是可變的並且具有有效的分配機制

如果級聯tuple對象，擴展list代替

對於其他類型，請查看相關的類文檔

7. 某些序列類型（例如range）僅支持遵循特定模式的項目序列，因此不支持序列連接或重複。

8. index ValueError當在s中找不到x時引發。並非所有實現都支持傳遞附加參數i和j。這些參數允許

有效地搜索序列的子部分。傳遞額外的參數大致相當於使用，只是不復制任何數據，並且返回的

索引是相對於序列的開始而不是片段的開始。s[i:j].index(x)

4.6.2。不可變序列類型

不可變序列類型通常實現的唯一操作也不能通過可變序列類型實現，這是對hash() 內置的支持。

這種支持允許不可改變的序列，如tuple實例中，以用作dict密鑰，並存儲在set和frozenset 實例。

嘗試散列包含不可取值的不可變序列將導致TypeError。

4.6.3。可變序列類型

下表中的操作定義在可變序列類型上。在collections.abc.MutableSequence美國廣播公司提供，使其

更容易正確地執行自定義序列類型這些操作。

在表中，s是可變序列類型的一個實例，t是任何可迭代對象，x是滿足由s施加的任何類型和值限制的任

意對象（例如，bytearray只接受滿足值限制的整數）。0 <= x <= 255

手術

結果

筆記

s[i] = x

項我的小號被替換為 X

s[i:j] = t

的切片小號從我到Ĵ 由迭代的內容替

換噸

del s[i:j]

與...一樣 s[i:j] = []

s[i:j:k] = t

元素s[i:j:k] 被替換為t的元素

（1）

del s[i:j:k]

s[i:j:k]從列表中刪除元素

s.append(x)

將x附加到序列的末尾（與之相同 ）

s[len(s):len(s)] = [x]

s.clear()

刪除所有項目s （與之相同）del

s[:]

（5）

s.copy()

創建一個淺的副本s （與之相同

s[:]）

（5）手術

結果

筆記

s.extend(t) 要麼 s += t

用t的內容擴展s（大部分相同 ）

s[len(s):len(s)] = t

s *= n

更新小號其內容重複ñ次

（6）

s.insert(i, x)

插入X成小號由下式給出的指數在我

（同）s[i:i] = [x]

s.pop([i])

在i處檢索項目並將其從s中移除

（2）

s.remove(x)

從取出的第一個項目小號 哪裡s[i]

== x

（3）

s.reverse()

反轉s的項目到位

（4）

筆記：

1. t必須與它正在替換的切片具有相同的長度。

2. 可選參數我默認為-1，以便默認情況下最後一項被刪除並返回。

3. remove ValueError當在s中找不到x時引發。

4. 該reverse()方法在倒轉大序列時修改用於空間經濟的序列。要提醒用戶它是以副作用方式運行

的，它不會返回相反的順序。

5. clear()並且copy()包含它們是為了與不支持切片操作的可變容器（例如dict和set）的接口一

致，

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

6. 值n是一個整數或實現的對象 __index__()。n的零和負值清除序列。序列中的項目不會被複制; 它

們被多次引用，正如在Common Sequence Operations下所解釋的那樣。s * n

4.6.4。列表

列表是可變序列，通常用於存儲同類項目的集合（其中精確的相似度因應用程序而異）。

class list（[ iterable ] ）

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

用一對方括號表示空列表： []

使用方括號，用逗號分隔項目：[a]，[a, b, c]

使用列表理解： [x for x in iterable]

使用類型構造函數：list()或list(iterable)

構造函數構建一個列表，其項目與iterable的項目相同並且順序相同。 可迭代可以是序列，支持迭

代的容器或迭代器對象。如果可迭代 已經是一個列表，則複製將被創建並返回，類似於

iterable[:]。例如，list('abc')退貨和 退貨。如果沒有給出參數，構造函數會創建一個新的空列

表。['a', 'b', 'c'] list( (1, 2, 3) ) [1, 2, 3] []

許多其他操作也會生成列表，包括sorted() 內置的。

列出所有常見和 可變順序操作。列表還提供了以下附加方法：

sort（*，key = None，reverse = False ）此方法就地對列表進行排序，僅使用

失敗，整個排序操作將失敗（並且列表可能會保留在部分修改狀態）。

sort()接受只能通過關鍵字傳遞的兩個參數（僅關鍵字參數）：

key 指 定 一 個 參 數 的 函 數 ， 該 參 數 用 於 從 每 個 列 表 元 素 中 提 取 比 較 鍵 （ 例 如 ，

key=str.lower）。與列表中的每個項目相對應的鍵將被計算一次，然後用於整個排序過程。

默認值None 意味著列表項直接排序而不需要計算單獨的鍵值。

該functools.cmp_to_key()實用程序可用於將2.x樣式的cmp函數轉換為關鍵函數。

reverse是一個布爾值。如果設置為True，則列表元素按照每個比較被顛倒的順序進行排序。

這種方法在排序大序列時修改空間經濟的序列。為了提醒用戶它是以副作用方式運行的，它不

會返回已排序的序列（用於sorted()顯式請求一個新的已排序列表實例）。

該sort()方法保證穩定。如果確保不會更改比較相等的元素的相對順序，則排序是穩定的 - 這

對於多次排序（例如，按部門排序，然後按薪級）進行排序很有幫助。

CPython實現細節：列表正在排序時，嘗試對列表進行更改或甚至檢查的影響是未定義的。

Python的C實現使得列表在持續時間內顯示為空，並且ValueError如果它能夠檢測列表在排序

過程中發生了變異，就會引發該列表。

4.6.5。元組

元組是不可變的序列，通常用於存儲異構數據的集合（例如由enumerate() 內置生成的2元組）。元組

也用於需要不變序列的同類數據的情況（例如允許存儲在一個set或 一個dict實例中）。

class tuple（[ iterable ] ）

元組可以通過多種方式構建：

使用一對括號來表示空元組： ()

使用單個元組的尾部逗號：a,或(a,)

用逗號分隔項目：或a, b, c (a, b, c)

使用tuple()內置的：tuple()或tuple(iterable)

構造函數構建一個元組，其元素與iterable的元素相同且順序相同。 可迭代可以是序列，支持迭代

的容器或迭代器對象。如果可迭代 已經是一個元組，它將不會被返回。例如， tuple('abc')退貨

和 退貨。如果沒有給出參數，構造函數將創建一個新的空元組，。('a', 'b', 'c') tuple( [1, 2,

3] ) (1, 2, 3) ()

請注意，它實際上是製作元組的逗號，而不是括號。括號是可選的，除了在空元組情況下，或者當

需要避免句法歧義時。例如， 是具有三個參數的函數調用，而具有三元 組作為唯一參數的函數調

用。f(a, b, c) f((a, b, c))

元組實現了所有常見的序列操作。

對於按名稱訪問比按索引訪問更清晰的異構數據集合，collections.namedtuple()可能是比簡單元組對

象更合適的選擇。

4.6.6。範圍

該range類型表示一個不可變的數字序列，通常用於在循環中循環特定的次數for 。class range（stop ）

類range（開始，停止[，步驟] ）

範圍構造函數的參數必須是整數（內置 int或實現__index__特殊方法的任何對象）。如果省略

step參數，則默認為1。如果省略start參數，則默認為0。如果步長為零，ValueError則升起。

對於積極的步驟，範圍的內容r由公式where 和 確定。r[i] = start + step*i i >= 0 r[i] < stop

對於負步驟，該範圍的內容仍然由公式確定，但約束 和。r[i] = start + step*i i >= 0 r[i] >

stop

如果r[0]不符合值約束，範圍對象將為空。範圍確實支持負指數，但這些被解釋為從正指數確定的

序列末尾開始的索引。

包含的絕對值大於sys.maxsize允許的範圍，但某些功能（如len()）可能會提高 OverflowError。

範圍示例：

範圍實現除串聯和重複以外的所有常見序列操作（由於範圍對象只能表示遵循嚴格模式的序列，重

復和串聯通常會違反該模式）。

start

起始參數的值（或者0如果參數未提供）

stop

停止參數的值

step

step參數的值（或者1如果參數未提供）

所述的優點range類型通過常規list或 tuple是一個range對象將始終以相同的內存（小）數量，無論它

代表的範圍內的大小（因為它僅存儲start，stop和step值，計算各個項目和子範圍需要）。

Range對象實現collections.abc.SequenceABC，並提供諸如包含測試，元素索引查找，切片和負指數

支持等功能（請參見序列類型 - 列表，元組，範圍）：

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

[]

>>>

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

測試對象範圍與平等==和!=比較它們作為序列。也就是說，如果兩個範圍對象表示相同的值序列，則

它們被認為是相等的。（請注意，比較相等的兩個範圍的對象可能有不同的start， stop和step屬性，

例如 或）。range(0) == range(2, 1, 3) range(0, 3, 2) == range(0, 4, 2)

在版本3.2中更改：實現序列ABC。支持切片和負指數。int以恆定時間測試對象的對象，而不是迭代所

有項目。

在版本3.3中更改：定義'=='和'！='以根據它們定義的值序列比較範圍對象（而不是根據對象標識進行比

較）。

新的3.3版：的start，stop和step 屬性。

也可以看看:

該linspace配方 展示瞭如何實現一個懶惰的版本範圍的適用於浮點應用程序。

4.7。文本序列類型 - str

Python中的文本數據由str對象或字符串處理。字符串是Unicode代碼點的不可變 序列。字符串文字用

各種方式書寫：

單引號： 'allows embedded "double" quotes'

雙引號：。"allows embedded 'single' quotes"

三重引用：，'''Three single quotes''' """Three double quotes"""

三重引用的字符串可能會跨越多行 - 所有關聯的空白都將包含在字符串文字中。

作為單個表達式的一部分並且只有空白字符串的字符串將被隱式轉換為單個字符串文字。那就是，。

("spam " "eggs") == "spam eggs"

有關字符串文字的各種形式（包括支持的轉義序列）和r禁用大多數轉義序列處理的（“raw”）前綴，請

參閱字符串和字節文字。

字符串也可以使用str 構造函數從其他對象創建。

由於沒有單獨的“字符”類型，索引的字符串產生一個長度1。也就是說，對於一個非空字符串的字符串

小號，。s[0] == s[0:1]

也沒有可變的字符串類型，但str.join()還是 io.StringIO可以用來有效地構造從多個片段字符串。

版本3.3中更改：為了向後兼容Python 2系列，u字符串文字再次允許前綴。它對字符串文字的含義沒有

影響，不能與r前綴結合使用。

class str（object ='' ）

class str（object = b''，encoding ='utf-8'，errors ='strict' ）返回一個字符串版本的對象。如果沒有提供對象，則返回空字符串。否則，行為str() 取決於是否

給出編碼或錯誤，如下所示。

如果既沒有編碼也不錯誤給出，str(object)返回 object.__str__()，這是“非正規”或很好的可打

印字符串表示對象。對於字符串對象，這是字符串本身。如果對象沒有__str__() 方法，則str()

返回返回 repr(object)。

如果至少給出了編碼或錯誤之一，則對象應該是類似 字節的對象（例如bytes或bytearray）。在

這種情況下，如果對象是bytes（或bytearray）對象，則等同於 。否則，在調用之前獲取緩衝區

對象下的字節對象 。有關緩衝區對象的信息，請參閱二進制序列類型 - 字節，字節陣列，內存視圖

和 緩衝區協議。str(bytes, encoding, errors) bytes.decode(encoding, errors) bytes.decode()

傳遞一個沒有編碼 或錯誤參數的bytes對象屬於返回非正則字符串表示形式的第一種情況（另請參

閱Python 的命令行選項）。例如：str() -b

有關str該類及其方法的更多信息，請參見下面的 文本序列類型 - str和字符串方法部分。要輸出格

式化字符串，請參閱格式化字符串文字和格式字符串語法 部分。另外，請參閱文本處理服務部

分。

4.7.1 字符串方法

字符串實現所有常見的序列操作，以及下面描述的其他方法。

字符串還支持兩種類型的字符串格式化的，一個提供了很大程度的靈活性和定製（見str.format()，

格式化字符串的語法和自定義字符串格式化）和其他基於C printf風格的格式，處理範圍較窄的類型，

是稍硬使用正確，但它可以處理的情況通常更快（printf樣式的字符串格式）。

標準庫的文本處理服務部分涵蓋了許多其他提供各種文本相關實用程序（包括re模塊中的正則表達式

支持）的模塊。

str.capitalize（）

返回字符串的一個副本，其首字母大寫，其餘的小寫。

str.casefold（）

返回字符串的casefolded副本。可摺疊的字符串可用於無外殼匹配。

Casefolding與lowercasing類似，但更具侵略性，因為它旨在刪除字符串中的所有大小寫區別。例

如，德文小寫字母'ß'相當於"ss"。既然已經小寫了，lower()什麼都不會做'ß'; casefold() 將其

轉換為"ss"。

Unicode標準的第3.13節描述了casefolding算法。

3.3版本的新功能

str.center（width [，fillchar ] ）

返回以一個長度寬度的字符串為中心。填充是使用指定的fillchar完成的（默認是ASCII空間）。如

果寬度小於或等於，則返回原始字符串len(s)。

str.count（sub [，start [，end ] ] ）

返回[ start，end ] 範圍內子串sub的非重疊次數。可選參數開始和結束被解釋為切片符號。

>>> str(b'Zoot!')

"b'Zoot!'"

>>>str.encode（encoding =“utf-8”，errors =“strict” ）

以字節對象的形式返回字符串的編碼版本。默認編碼是'utf-8'。可能會給出錯誤來設置不同的錯

誤處理方案。錯誤的默認值是'strict'，這意味著編碼錯誤會引發一個錯誤UnicodeError。其他可

能的值'ignore'，'replace'，'xmlcharrefreplace'， 'backslashreplace'和其他任何名義通過掛

號 codecs.register_error()，見錯誤處理程序。有關可能的編碼列表，請參見標準編碼部分。

在版本3.1中進行了更改：添加了對關鍵字參數的支持。

str.endswith（後綴[，start [，end ] ] ）

返回True字符串是否與指定的結束後綴，否則返回 False。 後綴也可以是後綴的元組來查找。隨著

可選 啟動，測試開始在那個位置。選擇結束時，停止在該位置進行比較。

str.expandtabs（tabsize = 8 ）

返回字符串的副本，其中所有制表符由一個或多個空格替換，具體取決於當前列和給定製表符大

小。選項卡位置出現在每個製表符大小字符中（默認值為8，在列0,8,16等處提供製表位置）。要

擴展字符串，當前列設置為零，字符串逐個檢查。如果該字符是一個製表符（\\t），則結果中會插

入一個或多個空格字符，直到當前列等於下一個製表符位置。（製表符本身不被複制。）如果該字

符是換行符（\\n）或返回（\\r），它被複制並且當前列被重置為零。任何其他字符都將被不變地

複製，而當前列增加1，無論打印時字符如何表示。

str.find（sub [，start [，end ] ] ）

返回切片中找到substring 子字符串的最低索引s[start:end]。可選參數開始和結束被解釋為切片

符號。-1如果未找到子項，則返回。

注意: find()只有在您需要知道sub的位置時才應該使用該方法。要檢查sub是否是子字符串，

請使用 in運算符：

str.format（* args，** kwargs ）

執行字符串格式化操作。調用此方法的字符串可以包含由大括號分隔的文本文本或替換字段 {}。

每個替換字段包含位置參數的數字索引或關鍵字參數的名稱。返回字符串的副本，其中每個替換字

段將替換為相應參數的字符串值。

請參閱格式字符串語法以獲取可在格式字符串中指定的各種格式選項的說明。

注意: 當格式化數（int，float，float 與和亞類）n類型（例如：'{:n}'.format(1234)），功

能暫時設定LC_CTYPE的區域設置到LC_NUMERIC 區域解碼decimal_point和thousands_sep 領域

localeconv()如果它們是非ASCII或長於1個字節，而 LC_NUMERIC區域設置為比不同在LC_CTYPE

語言環境。此臨時更改影響其他線程。

>>> '01\\t012\\t0123\\t01234'.expandtabs()

'01 012 0123 01234'

>>> '01\\t012\\t0123\\t01234'.expandtabs(4)

'01 012 0123 01234'

>>>

>>> 'Py' in 'Python'

True

>>>

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

'The sum of 1 + 2 is 3'

>>>在版本3.6.5中進行了更改：在使用 n 類型格式化數字時，函數會在某些情況下 LC_CTYPE 將

LC_NUMERIC語言環境臨時設置為語言環境。

str.format_map（映射）

類似於str.format(**mapping)，除了mapping直接使用和不復制到一個dict。例如，如果mapping

是字典子類，這很有用：

3.2版本中的新功能

str.index（sub [，start [，end ] ] ）

喜歡find()，但ValueError在沒有找到子字符串時引發。

str.isalnum（）

如果字符串中的所有字符都是字母數字並且至少有一個字符，則返回true，否則返回false。字符c

是字母數字，如果下面的返回之一 True ： c.isalpha() ， c.isdecimal() ， c.isdigit() ， 或

c.isnumeric()。

str.isalpha（）

如果字符串中的所有字符都是字母並且至少有一個字符，則返回true，否則返回false。字母字符是

在 Unicode 字 符 數 據 庫 中 定 義 為 “Letter” 的 那 些 字 符 ， 即 具 有 通 用 類 別 屬 性

為“Lm”，“Lt”，“Lu”，“Ll”或“Lo”之一的那些字符。請注意，這與Unicode標準中定義的“字母”屬性不

同。

str.isdecimal（）

如果字符串中的所有字符都是十進制字符並且至少有一個字符，則返回true，否則返回false。十進

制字符是可以用來形成10位數字的那些字符，例如U + 0660，ARABIC-INDIC DIGIT ZERO。形式

上，十進制字符是Unicode常規類別“Nd”中的字符。

str.isdigit（）

如果字符串中的所有字符都是數字並且至少有一個字符，則返回true，否則返回false。數字包含需

要特殊處理的十進制字符和數字，例如兼容性上標數字。這包括不能用於形成基數為10的數字，如

Kharosthi數字。形式上，數字是具有屬性值Numeric_Type = Digit或Numeric_Type = Decimal的字

符。

str.isidentifier（）

根據語言定義標識符和關鍵字部分，如果字符串是有效標識符，則返回true 。

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

str.islower（）

如果字符串中的所有套用字符[4]都是小寫，並且至少有一個套用字符，則返回true，否則返回

false。

str.isnumeric（）

>>> class Default(dict):

... def __missing__(self, key):

... return key

...

>>> '{name} was born in {country}'.format_map(Default(name='Guido'))

'Guido was born in country'

>>>如果字符串中的所有字符都是數字字符，並且至少有一個字符，則返回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）被認為是可打印

的。（請注意，在這個上下文中的可打印字符repr()是在字符串上調用時不應該轉義 的字符，它

與寫入sys.stdout或的字符串的處理無關sys.stderr。

str.isspace（）

如果字符串中只有空格字符，並且至少有一個字符，則返回true，否則返回false。空格字符是在

Unicode字符數據庫中定義為“其他”或“分隔符”的那些字符，以及具有“WS”，“B”或“S”之一的雙向屬

性的那些字符。

str.istitle（）

如果字符串是一個標題字符串並且至少有一個字符，則返回true，例如，大寫字符只能跟在未寫入

的字符之後，而小寫字母只能在已封裝的字符之後。否則返回false。

str.isupper（）

如果字符串中的所有套用字符[4]都是大寫且至少有一個套用字符，則返回true，否則返回false。

str.join（可迭代）

返回一個字符串，它是可迭代的字符串的串聯。TypeError如果迭代中包含任何非字符串值（包括

bytes對象），則會引發 A. 元素之間的分隔符是提供此方法的字符串。

str.ljust（width [，fillchar ] ）

以長度寬度的字符串返回左對齊的字符串。填充是使用指定的fillchar完成的（默認是ASCII空

間）。如果寬度小於或等於，則返回原始字符串len(s)。

str.lower（）

返回字符串的一個副本，並將所有裝入字符的字符[4]轉換為小寫字母。

Unicode標準的第3.13節描述了使用的低級算法。

str.lstrip（[ chars ] ）

返回刪除前導字符的字符串的副本。的字符 參數是要除去的字符串指定的字符集。如果省略或者

None，chars參數默認刪除空格。該字符 參數不是前綴; 相反，其值的所有組合都被剝離：

static str.maketrans（x [，y [，z ] ] ）

這個靜態方法返回一個可用於的翻譯表str.translate()。

如果只有一個參數，它必須是一個將Unicode序號（整數）或字符（長度為1的字符串）映射到

Unicode序號，字符串（任意長度）或者字典的字典None。字符鍵將被轉換為序號。

>>> ' spacious '.lstrip()

'spacious '

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

'example.com'

>>>如果有兩個參數，它們必須是等長的字符串，並且在結果字典中，x中的每個字符將映射到y中相同

位置的字符。如果有第三個參數，它必須是一個字符串，其字符將被映射到None結果中。

str.partition（sep ）

在sep第一次出現時拆分字符串，並返回包含分隔符之前的部分，分隔符本身和分隔符之後的部分

的三元組。如果未找到分隔符，則返回包含該字符串本身的三元組，然後返回兩個空字符串。

str.replace（舊的，新的[，count ] ）

返回所有出現的舊字符串替換為 新字符串的副本。如果給出可選的參數計數，則僅 替換第一個計

數事件。

str.rfind（sub [，start [，end ] ] ）

返回找到substring 子字符串的最高索引，這樣sub就包含在其中s[start:end]。可選參數開始 和結

束被解釋為切片符號。返回-1失敗。

str.rindex（sub [，start [，end ] ] ）

像rfind()但ValueError子字符串子未找到時引發。

str.rjust（width [，fillchar ] ）

以字符串長度寬度返回右對齊的字符串。填充是使用指定的fillchar完成的（默認是ASCII空間）。

如果寬度小於或等於，則返回原始字符串len(s)。

str.rpartition（sep ）

在最後出現的sep處拆分字符串，並返回包含分隔符之前的部分，分隔符本身和分隔符之後的部分

的三元組。如果未找到分隔符，則返回包含兩個空字符串的三元組，然後返回字符串本身。

str.rsplit（sep = None，maxsplit = -1 ）

使用sep作為分隔符字符串，返回字符串中單詞的列表。如果給出maxsplit，則最多maxsplit分裂，

最右邊 的分裂。如果沒有指定sep或者None任何空格字符串是分隔符。除了從右邊分開外，

rsplit()其行為 split()如下所述。

str.rstrip（[ chars ] ）

返回刪除了尾隨字符的字符串副本。的字符 參數是要除去的字符串指定的字符集。如果省略或者

None，chars參數默認刪除空格。該字符 參數不是後綴; 相反，其值的所有組合都被剝離：

str.split（sep = None，maxsplit = -1 ）

使用sep作為分隔符字符串，返回字符串中單詞的列表。如果給出maxsplit，最多可以完成maxsplit

分割（因此，列表最多隻有maxsplit+1元素）。如果未指定maxsplit或者-1，則分割數量沒有限制

（所有可能的分割）。

如 果 給 出 了 sep ， 則 連 續 分 隔 符 不 會 分 組 在 一 起 ， 並 被 視 為 分 隔 空 字 符 串 （ 例

如，'1,,2'.split(',')返回 ）。該月的參數可以由多個字符（例如，返回）。用指定的分隔符分

割空字符串返回。['1', '', '2'] '1<>2<>3'.split('<>') ['1', '2', '3'] ['']

例如：

>>> ' spacious '.rstrip()

' spacious'

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

'mississ'

>>>如果未指定sep或is None，則應用不同的分割算法：將連續空白的運行視為單個分隔符，並且如果

字符串具有前導或尾隨空白，則結果的開始或結束將不包含空字符串。因此，用None分隔符分隔一

個空字符串或一個只包含空格的字符串會返回[]。

例如：

str.splitlines（[ keepends ] ）

返回字符串中行的列表，在行邊界處突破。除非換行符不包括在結果列表中keepends，並給出正

確的。

此方法分割在以下行邊界上。特別是，邊界是通用換行符的超集。

表示

\\n

換行

\\r

回車

\\r\\n

回車+換行

\\v 要麼 \\\\x0b

線條製表

\\f 要麼 \\\\x0c

換頁

\\\\x1c

文件分隔符

\\\\x1d

組分隔符

\\\\x1e

記錄分隔符

\\\\x85

下一行（C1控制代碼）

線分隔符

段落分隔符

在版本3.2中更改：\\v並\\f添加到行邊界列表中。

例如：

與給定split()分隔符字符串sep時不同，此方法返回空字符串的空列表，並且終端行分隔符不會導

致多餘的行：

>>> '1,2,3'.split(',')

['1', '2', '3']

>>> '1,2,3'.split(',', maxsplit=1)

['1', '2,3']

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

>>>

>>> '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('\\n')給出：

str.startswith（prefix [，start [，end ] ] ）

返回True字符串是否與開始前綴，否則返回False。 前綴也可以是要查找的前綴元組。使用可選啟

動，測試字符串從該位置開始。使用可選結束時，停止在該位置比較字符串。

str.strip（[ chars ] ）

返回刪除前導字符和尾隨字符的字符串副本。的字符參數是要除去的字符串指定的字符集。如果省

略或者None，chars參數默認刪除空格。該字符參數不是前綴或後綴; 相反，其值的所有組合都被剝

離：

從字符串中剝離最外部的前導字符和結尾字符參數值。字符從前端刪除，直到達到未包含在集字符

的字符串文字字符。尾端發生類似的行為。例如：

str.swapcase（）

返 回 大 寫 字 符 轉 換 為 小 寫 字 符 串 的 副 本 ， 反 之 亦 然 。 請 注 意 ， 這 不 一 定 是 真 的 。

s.swapcase().swapcase() == s

str.title（）

返回字符串的字幕版本，其中字以大寫字符開頭，其餘字符為小寫字母。

例如：

該算法使用簡單的與語言無關的單詞作為連續字母組的定義。該定義在許多情況下都有效，但這意

味著收縮和佔有者中的撇號會形成單詞邊界，這可能不是理想的結果：

可以使用正則表達式構造撇號的解決方法：

>>> "".splitlines()

[]

>>> "One line\\n".splitlines()

['One line']

>>>

>>> ''.split('\\n')

['']

>>> 'Two lines\\n'.split('\\n')

['Two lines', '']

>>>

>>> ' spacious '.strip()

'spacious'

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

'example'

>>>

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'

>>> comment_string.strip('.#! ')

'Section 3.2.1 Issue #32'

>>>

>>> 'Hello world'.title()

'Hello World'

>>>

>>> "they're bill's friends from the UK".title()

"They'Re Bill'S Friends From The Uk"

>>>str.translate（表）

返回通過給定轉換表映射每個字符的字符串的副本。該表必須是實現索引的對象__getitem__()，

通常是映射或 序列。當通過Unicode序數（整數）索引時，表對象可以執行以下任何操作：返回

Unicode序號或字符串，將字符映射為一個或多個其他字符; 返回 None，從返回字符串中刪除字符;

或者引發 LookupError異常，將角色映射到自身。

您可以使用str.maketrans()不同格式的字符到字符映射來創建翻譯地圖。

另請參閱codecs模塊，以獲得更靈活的自定義字符映射方法。

str.upper（）

返 回 字 符 串 的 一 個 副 本 ， 並 將 所 有 裝 入 字 符 的 字 符 [4] 轉 換 為 大 寫 字 符 。 請 注 意 ，

str.upper().isupper() 可能是 False 如果 s 包含無套管的字符或如果所得到的字符（縣）的

Unicode類別不是“呂氏春秋”（字母，大寫），但如“LT”（字母，首字母大寫）。

Unicode標準的第3.13節描述了使用的大寫算法。

str.zfill（寬度）

返回左側填充有ASCII '0'數字的字符串的副本，以生成一個長度寬度的字符串。前導符號前綴

（'+'/ '-'）是通過在符號字符之後插入填充而不是之前處理的。如果寬度小於或等於，則返回原

始字符串len(s)。

例如：

4.7.2。printf風格的字符串格式

注意:

元組和字典）。使用新的格式化字符串文字或str.format()界面有助於避免這些錯誤。這些替代方案

還為格式化文本提供了更強大，靈活和可擴展的方法。

字符串對象有一個獨特的內置操作：%操作符（模）。這也被稱為字符串格式化或插值運算符。鑑於

（其中格式是字符串），格式中的轉換規範將替換為零個或多個值元素。其效果與在C語言中使用類

似。format % values % sprintf()

如果格式需要單個參數，則值可能是單個非元組對象。[5] 否則，值必須是具有由格式字符串或單個映

射對象（例如字典）指定的項目數量的元組。

轉換說明符包含兩個或多個字符，並具有以下組件，它們必須按以下順序出現：

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

>>>

>>> "42".zfill(5)

'00042'

>>> "-42".zfill(5)

'-0042'

>>>1. 該'%'字符表示說明符的開始。

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

3. 轉換標誌（可選），影響某些轉換類型的結果。

4. 最小字段寬度（可選）。如果指定為'*'（星號），則將從元組的下一個元素值中讀取實際寬

度，並且要轉換的對象位於最小字段寬度和可選精度之後。

5. 精度（可選），以'.'（點）形式給出，然後是精度。如果指定為'*'（星號），則實際精度將從

元組的下一個元素的值中讀取，並且要轉換的值位於精度之後。

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

7. 轉換類型。

當正確的參數是一個字典（或其他映射類型）時，字符串中的格式必須在字符後面插入一個帶括號的映

射關鍵字'%'。映射鍵從映射中選擇要格式化的值。例如：

在這種情況下*，格式中不會出現說明符（因為它們需要一個連續的參數列表）。

轉換標誌字符是：

旗

含義

'#'

值轉換將使用“替代形式”（下面定義）。

'0'

轉換將為數字值填充零。

'-'

轉換後的值是左側調整的（'0' 如果兩者都給出，則覆蓋轉換）。

' '

（一個空格）在由正確的數字（或空字符串）產生的一個空白應該留下一個有符號的轉

換。

'+'

符號字符（'+'或'-'）將在轉換之前（覆蓋“空格”標誌）。

長度修飾符（h，l或L）可能存在，但會被忽略，因為它對於Python不是必需的 - 例如與之%ld相

同%d。

轉換類型是：

轉變

含義

筆記

'd'

帶符號的整數小數。

'i'

帶符號的整數小數。

'o'

簽署八進制值。

（1）

'u'

已過時的類型 - 與之相同'd'。

（6）

'x'

簽名的十六進制（小寫）。

（2）

'X'

簽名的十六進制（大寫）。

（2）

'e'

浮點指數格式（小寫）。

（3）

'E'

浮點指數格式（大寫）。

（3）

'f'

浮點十進制格式。

（3）

'F'

浮點十進制格式。

（3）

'g'

浮點格式。

小數格式。

如果指數小於-4或小於精度，則使用小寫指數格式，否則使用

（4）

'G'

浮點格式。

使用小數格式。如果指數小於-4或者不小於精度，則使用大寫指數格式，否則

（4）

'c'

單個字符（接受整數或單個字符串）。

'r'

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

（5）

's'

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

（5）

'a'

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

（5）

'%'

沒有參數被轉換，導致結果中的'%' 字符。

>>> print('%(language)s has %(number)03d quote types.' %

... {'language': "Python", "number": 2})

Python has 002 quote types.

>>>筆記：

1. 替代形式導致'0o'在第一個數字之前插入前導八進制說明符（）。

2. 替代形式會導致在第一個數字之前插入'0x'或'0X'取決於是否使用了'x'或'X'格式。

3. 替代形式會導致結果始終包含小數點，即使沒有數字跟著它。

精度決定小數點後的位數，默認為6。

4. 替代形式導致結果始終包含小數點，並且尾部零不會像原本那樣被刪除。

精度決定小數點前後的有效位數，默認值為6。

5. 如果精度是N，則輸出被截斷為N字符。

6. 看到 PEP 237。

由於Python字符串具有明確的長度，因此%s轉換不會假定'\\0'字符串的末尾。

在版本3.1中進行了更改：%f絕對值超過1e50的數字的%g轉換不再被轉換取代。

4.8。二進制序列類型- ，，bytes bytearraymemoryview

操作二進制數據的核心內置類型是bytesand bytearray。它們受到支持，memoryview它使用緩衝區協議

來訪問其他二進制對象的內存而無需進行復制。

該array模塊支持基本數據類型（如32位整數和IEEE754雙精度浮點值）的高效存儲。

4.8.1。字節對象

字節對象是單個字節的不可變序列。由於許多主要的二進制協議都基於ASCII文本編碼，因此字節對象

提供了幾種方法，這些方法僅在使用ASCII兼容數據時有效，並且以各種其他方式與字符串對象密切相

關。

class bytes（[ source [，encoding [，errors ] ] ] ）

首先，字節文字的語法與字符串文字的語法基本相同，只是b添加了前綴：

單引號： b'still allows embedded "double" quotes'

雙引號：。b"still allows embedded 'single' quotes"

三重引用：，b'''3 single quotes''' b"""3 double quotes"""

只允許以字節為單位的ASCII字符（不管聲明的源代碼編碼如何）。必須使用適當的轉義序列將

127以上的任何二進制值輸入字節文字。

與字符串文字一樣，字節文字也可以使用r前綴來禁用轉義序列的處理。請參閱字符串和字節文字

以獲取有關各種形式字節文字的更多信息，包括支持的轉義序列。

儘管字節文字和表示是基於ASCII文本的，但字節對象實際上表現得像不可變的整數序列一樣，序

列中的每個值都受到限制，以致（違反此限制的嘗試將觸發。這是故意強調的，儘管許多二進制格

式包括基於ASCII的元素，並且可以用一些面向文本的算法進行有效的操作，但對於任意二進制數

據通常不會這樣（將文本處理算法盲目地應用於不兼容ASCII的二進制數據格式通常會導致數據損

壞）。0 <= x < 256 ValueError除了文字形式之外，字節對象還可以通過其他方式創建：

指定長度的零填充字節對象： bytes(10)

從可重複的整數： bytes(range(20))

通過緩衝區協議複製現有的二進制數據： bytes(obj)

另請參閱內置的字節。

由於2個十六進制數字精確對應於單個字節，因此十六進制數字是描述二進制數據的常用格式。因

此，字節類型具有額外的類方法來讀取該格式的數據：

classmethod fromhex（string ）

這個bytes類方法返回一個字節對象，解碼給定的字符串對象。該字符串必須包含每個字節兩

個十六進制數字，並且忽略ASCII空格。

存在反向轉換函數將字節對象轉換為其十六進制表示形式。

hex（）

返回包含實例中每個字節的兩個十六進制數字的字符串對象。

3.5版本中的新功能。

由於字節對象是整數序列（類似於一個元組），對於一個字節對象b，b[0]它將是一個整數，而b[0:1]

它將是一個長度為1的字節對象。（這與文本字符串形成對比，其中索引和切片都會產生一個長度為1

的字符串）

字節對象的表示使用字面格式（b'...'），因為它通常比例如更有用。您始終可以使用一個字節對象轉

換為一個整數列表。bytes([46, 46, 46]) list(b)

注意: 對於Python 2.x用戶：在Python 2.x系列中，允許在8位字符串（最接近的2.x提供給內置二進

制數據類型）和Unicode字符串之間進行各種隱式轉換。這是一個向後兼容的解決方法，以說明

Python最初只支持8位文本，而Unicode文本是後來的補充。在Python 3.x中，這些隱式轉換消失了 -

8位二進制數據和Unicode文本之間的轉換必須是明確的，而字節和字符串對象總是會比較不等。

4.8.2。ByteArray的對象

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

class bytearray（[ source [，encoding [，errors ] ] ] ）

bytearray對象沒有專門的文字語法，而是始終通過調用構造函數來創建它們：

創建一個空實例： bytearray()

創建一個給定長度的零填充實例： bytearray(10)

從可重複的整數： bytearray(range(20))

通過緩衝區協議複製現有的二進制數據： bytearray(b'Hi!')

由於bytearray對象是可變的，除了Bytes和Bytearray操作中描述的常見字節和字節陣列操作外，它

們還支持 可變序列操作。

>>> bytes.fromhex('2Ef0 F1f2 ')

b'.\\\\xf0\\\\xf1\\\\xf2'

>>>

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

'f0f1f2'

>>>另請參閱內置的bytearray。

由於2個十六進制數字精確對應於單個字節，因此十六進制數字是描述二進制數據的常用格式。因

此，bytearray類型有一個額外的類方法來讀取該格式的數據：

classmethod fromhex（string ）

這個bytearray類方法返回bytearray對象，解碼給定的字符串對象。該字符串必須包含每個字

節兩個十六進制數字，並且忽略ASCII空格。

存在一個逆轉換函數來將一個bytearray對象轉換為其十六進制表示。

hex（）

返回包含實例中每個字節的兩個十六進制數字的字符串對象。

3.5版本中的新功能。

由於bytearray對象是整數序列（類似於列表），對於bytearray對象b，b[0]它將是一個整數，而b[0:1]

它將是長度為1的bytearray對象。（與文本字符串形成對比，其中索引和切片都會生成長度為1的字符

串）

bytearray對象的表示使用bytes literal格式（bytearray(b'...')），因為它通常比eg更有用 。您始終可

以使用一個bytearray對象轉換為一個整數列表。bytearray([46, 46, 46]) list(b)

4.8.3。字節和Bytearray操作

字節和bytearray對象都支持常見的 序列操作。它們不僅與相同類型的操作數交互操作，而且還與任何

類似字節的對象交互操作。由於這種靈活性，它們可以在操作中自由混合而不會造成錯誤。但是，結果

的返回類型可能取決於操作數的順序。

注意: 字節和bytearray對象上的方法不接受字符串作為它們的參數，就像字符串上的方法不接受字

節作為它們的參數一樣。例如，你必須寫：

和：

某些字節和字節陣列操作假定使用ASCII兼容的二進制格式，因此在處理任意二進制數據時應該避免使

用。這些限制如下。

注意: 使用這些基於ASCII的操作來處理未以ASCII格式存儲的二進制數據可能會導致數據損壞。

字節和字節數組對象的以下方法可以與任意二進制數據一起使用。

>>> bytearray.fromhex('2Ef0 F1f2 ')

bytearray(b'.\\\\xf0\\\\xf1\\\\xf2')

>>>

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

'f0f1f2'

>>>

a = "abc"

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

a = b"abc"

b = a.replace(b"a", b"f")bytes.count（sub [，start [，end ] ] ）

bytearray.count（sub [，start [，end ] ] ）

返回範圍[ start，end ] 中的子序列子的不重疊次數。可選參數開始和結束被解釋為切片符號。

要搜索的子序列可以是任何類似字節的對象或0到255範圍內的整數。

版本3.3中更改：還接受範圍為0到255的整數作為子序列。

bytes.decode（encoding =“utf-8”，errors =“strict” ）

bytearray.decode（encoding =“utf-8”，errors =“strict” ）

返回從給定字節解碼的字符串。默認編碼是 'utf-8'。可能會給出錯誤來設置不同的錯誤處理方

案。錯誤的默認值是'strict'，這意味著編碼錯誤會引發一個錯誤UnicodeError。其他可能的值

'ignore'，'replace'並通過註冊的任何其他名稱 codecs.register_error()，請參見錯誤處理程

序。有關可能的編碼列表，請參見標準編碼部分。

注意: 將編碼參數傳遞給str允許直接解碼任何 類似字節的對象，而不需要創建臨時字節或字節

數組對象。

在版本3.1中進行了更改：添加了對關鍵字參數的支持。

bytes.endswith（後綴[，start [，end ] ] ）

bytearray.endswith（後綴[，start [，end ] ] ）

返回True如果二進制數據與指定的結束後綴，否則返回False。 後綴也可以是後綴的元組來查找。

隨著可選啟動，測試開始在那個位置。選擇結束時，停止在該位置進行比較。

搜索的後綴可以是任何類似字節的對象。

bytes.find（sub [，start [，end ] ] ）

bytearray.find（sub [，start [，end ] ] ）

返回找到子序列子數據的最低索引，這樣sub就包含在切片中s[start:end]。可選參數開始和結束

被解釋為切片符號。-1如果未找到子項，則返回 。

要搜索的子序列可以是任何類似字節的對象或0到255範圍內的整數。

注意: find()只有在您需要知道sub的位置時才應該使用該方法。要檢查sub是否是子字符串，

請使用 in運算符：

版本3.3中更改：還接受範圍為0到255的整數作為子序列。

bytes.index（sub [，start [，end ] ] ）

bytearray.index（sub [，start [，end ] ] ）

喜歡find()，但ValueError在沒有找到子序列時引發。

要搜索的子序列可以是任何類似字節的對象或0到255範圍內的整數。

版本3.3中更改：還接受範圍為0到255的整數作為子序列。

bytes.join（可迭代）

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

True

>>>bytearray.join（可迭代）

返回一個字節或bytearray對象，它是可迭代的二進制數據序列的串聯。TypeError如果迭代中有任

何不是類字節對象（包括str對象）的值，則會引發A。元素之間的分隔符是提供此方法的字節或

bytearray對象的內容。

靜態bytes.maketrans（從，到）

靜態bytearray.maketrans（從，到）

此靜態方法返回一個轉換表可用於 bytes.translate()將每個字符映射在從成在相同位置處的字符

到 ; 從和到必須都是 類似字節的對象，並具有相同的長度。

版本3.1中的新功能。

bytes.partition（sep ）

bytearray.partition（sep ）

在sep第一次出現時拆分序列，並在分隔符，分隔符本身或其字節陣列副本以及分隔符之後返回包

含該部分的3元組。如果找不到分隔符，則返回包含原始序列副本的3元組，然後返回兩個空字節或

bytearray對象。

要搜索的分隔符可以是任何類似字節的對象。

bytes.replace（舊的，新的[，count ] ）

bytearray.replace（舊的，新的[，count ] ）

返回序列的一個副本，其中所有出現的舊子序列都 被new替換。如果給出可選的參數計數，則僅替

換第一個計數事件。

搜索和替換的子序列可以是任何 類似字節的對象。

注意: 該方法的bytearray版本不適用 - 即使沒有更改，它總是會生成一個新對象。

bytes.rfind（sub [，start [，end ] ] ）

bytearray.rfind（sub [，start [，end ] ] ）

返回找到子序列子序列的最高索引，使子包含在其中s[start:end]。可選參數開始和結束被解釋為

切片符號。返回 -1失敗。

要搜索的子序列可以是任何類似字節的對象或0到255範圍內的整數。

版本3.3中更改：還接受範圍為0到255的整數作為子序列。

bytes.rindex（sub [，start [，end ] ] ）

bytearray.rindex（sub [，start [，end ] ] ）

像rfind()但ValueError在子序列子未找到時引發。

要搜索的子序列可以是任何類似字節的對象或0到255範圍內的整數。

版本3.3中更改：還接受範圍為0到255的整數作為子序列。

bytes.rpartition（sep ）

bytearray.rpartition（sep ）

在最後出現的sep處拆分序列，並在分隔符，分隔符本身或其字節陣列副本以及分隔符之後返回包

含該部分的3元組。如果找不到分隔符，則返回包含原始序列副本的3元組，然後返回兩個空字節或

bytearray對象。要搜索的分隔符可以是任何類似字節的對象。

bytes.startswith（prefix [，start [，end ] ] ）

bytearray.startswith（prefix [，start [，end ] ] ）

返回True如果二進制數據與指定的開始前綴，否則返回False。 前綴也可以是要查找的前綴元組。

隨著可選啟動，測試開始在那個位置。選擇結束時，停止在該位置進行比較。

要搜索的前綴可以是任何類似字節的對象。

bytes.translate（table，delete = b'' ）

bytearray.translate（table，delete = b'' ）

返回字節或bytearray對象的副本，其中刪除了可選參數delete中出現的所有字節，其餘字節已通過

給定轉換表映射，該轉換表必須是長度為256的字節對象。

您可以使用該bytes.maketrans()方法創建轉換表。

將表格參數設置None為僅用於刪除字符的翻譯：

在版本3.6中更改：現在支持將delete作為關鍵字參數。

字節和字節數組對象的以下方法具有假定使用ASCII兼容二進制格式的默認行為，但仍可通過傳遞適當

的參數與任意二進制數據一起使用。請注意，本節中的所有bytearray方法都不適用，而是產產生新的對

象。

bytes.center（width [，fillbyte ] ）

bytearray.center（width [，fillbyte ] ）

返回以長度寬度序列為中心的對象的副本。填充是使用指定的填充字節完成的（默認是ASCII空

間）。對於bytes對象，如果寬度小於或等於，則返回原始序列 len(s)。

注意: 該方法的bytearray版本不適用 - 即使沒有更改，它總是會生成一個新對象。

bytes.ljust（width [，fillbyte ] ）

bytearray.ljust（width [，fillbyte ] ）

以長度寬度的順序返回左對齊的對象的副本。填充是使用指定的填充字節完成的（默認是ASCII空

間）。對於bytes對象，如果寬度小於或等於，則返回原始序列 len(s)。

注意: 該方法的bytearray版本不適用 - 即使沒有更改，它總是會生成一個新對象。

bytes.lstrip（[ chars ] ）

bytearray.lstrip（[ chars ] ）

返回刪除指定前導字節的序列副本。的 字符參數是指定一組字節值的二進制序列被除去-名稱指的

是這種方法通常是用ASCII字符使用的事實。如果省略或者None，chars參數默認為刪除ASCII空

格。該字符參數不是前綴; 相反，其值的所有組合都被剝離：

>>> b'read this short text'.translate(None, b'aeiou')

b'rd ths shrt txt'

>>>

>>> b' spacious '.lstrip()

b'spacious '

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

b'example.com'

>>>要移除的字節值的二進制序列可以是任何 類似字節的對象。

注意: 該方法的bytearray版本不適用 - 即使沒有更改，它總是會生成一個新對象。

bytes.rjust（width [，fillbyte ] ）

bytearray.rjust（width [，fillbyte ] ）

以長度寬度的順序返回右對齊的對象的副本。填充是使用指定的填充字節完成的（默認是ASCII空

間）。對於bytes對象，如果寬度小於或等於，則返回原始序列 len(s)。

注意: 該方法的bytearray版本不適用 - 即使沒有更改，它總是會生成一個新對象。

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

返回刪除指定尾隨字節的序列副本。的 字符參數是指定一組字節值的二進制序列被除去-名稱指的

是這種方法通常是用ASCII字符使用的事實。如果省略或者None，chars參數默認為刪除ASCII空

格。該字符參數不是後綴; 相反，其值的所有組合都被剝離：

要移除的字節值的二進制序列可以是任何 類似字節的對象。

閱讀更多 寶貝學習中 的文章

關鍵字: 常量 內置 命名