文章編寫借鑒於內置類型 — Python 3.7.3 文檔，主要用於自己學習和記錄
python主要內置類型包括數字、序列、映射、類、實例和異常
有些多項集類是可變的。它們用於添加、移除或重排其成員的方法，將原地執行，並不返回特定的項，絕對不會返回多項集實例自身而是返回 None。
實際上所有對象都可以被比較、檢測邏輯值，以及轉換為字符串（使用 repr() 函數或略有差異的 str() 函數）。 后一個函數是在對象由 print() 函數輸出時被隱式地調用的。
邏輯值檢測
任何對象都可以進行邏輯值的檢測，以便在 if 或 while 作為條件或是作為下文所述 布爾運算 的操作數來使用。
一個對象在默認情況下均被視為真值，除非當該對象被調用時其所屬類定義了 __bool__() 方法且返回 False 或是定義了 __len__() 方法且返回零。
- 被定義為假值的常量: None 和 False。
- 任何數值類型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)。
- 空的序列和多項集: '', (), [], {}, set(), range(0)。
產生布爾值結果的運算和內置函數總是返回 0 或 False 作為假值，1 或 True 作為真值。（重要例外：布爾運算 or 和 and 總是返回其中一個操作數。）
布爾運算（and,or,not）
按優先級排序，表格如下：
| 運算 | 結果 | 注釋 |
|---|---|---|
| x or y | if x is false, then y, else x | 1 |
| x and y | if x is false, then x, else y | 2 |
| not x | if x is false, then True, else False | 3 |
注釋：
- 為短路運算符，因此只有第一個參數為 假 時才會對第二個參數求值
- 為短路運算符，第一個參數為 真 時才會對第二個參數求值
- not 的優先級比非布爾運算符 低 ，因此 not a == b 會被解讀為 not (a == b) 而 a == not b 會引發語法錯誤。
比較
在 Python 中有八種比較運算符。它們的優先級相同（比布爾運算的優先級高）。比較運算可以任意串連。
例如，x < y <= z 等價於 x < y and y <= z，前者的不同之處在於 y 只被求值一次（但在兩種情況下當 x < y 結果為假值時 z 都不會被求值）。
以下表格列出了此八種比較運算符
| 運算 | 含義 |
|---|---|
| < | 嚴格小於 |
| <= | 小於或等於 |
| > | 嚴格大於 |
| >= | 大於或等於 |
| == | 等於 |
| != | 不等於 |
| is | 對象標識 |
| is not | 否定的對象標識 |
注意
<, <=, > 和 >= 運算符在以下情況中將引發 TypeError 異常：當比較復數與另一個內置數字類型時，當兩個對象具有無法被比較的不同類型時，或在未定義次序的其他情況時。
具有不同標識的類的實例比較結果通常為不相等，除非類定義了 __eq__() 方法。
一個類實例不能與相同類或的其他實例或其他類型的對象進行排序，除非該類定義了足夠多的方法，包括 __lt__(), __le__(), __gt__() 以及 __ge__()
is 和 is not 運算符無法自定義；並且它們可以被應用於任意兩個對象而不會引發異常。
數字類型( int, float, complex)
具有三種不同的數字類型：整數, 浮點數和復數。此外，布爾值屬於整數的子類型，整數具有無限的精度，浮點數通常使用 C 中的 double 來實現，復數包含實部和虛部，分別以一個浮點數表示。要從一個復數中提取這兩個部分，可使用 z.real 和 z.imag。
所有數字類型(復數除外)都支持下列運算，按優先級升序排序(所有數字運算的優先級都高於比較運算)
| 運算 | 結果 | 注釋 |
|---|---|---|
| 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 的絕對值 | |
| int(x) | 將 x 轉化為整數 | 3,6 |
| float(x) | 將 x 轉化為浮點數 | 4,6 |
| complex(re, im) | 一個帶有實部 re 和虛部 im 的復數，im默認為0 | 6 |
| c.conjugate() | 復數 c 的共軛復數 | |
| divmod(x, y) | (x // y, x % y) | 2 |
| pow(x) | x 的 y 次冪 | 5 |
| x ** y | x 的 y 次冪 | 5 |
注釋：
- 結果值是一個整數 ，但結果的類型不一定是 int。 運算結果總是向負無窮的方向舍入,例如：1//2 為 0，(-1)//2 為 -1，1//(-2) 為 -1 而 (-1)//(-2) 為 0
- 不可用於復數。
- 將浮點數轉換為整數會被舍入
- float 也接受字符串 "nan" 和附帶可選前綴 "+" 或 "-" 的 "inf" 分別表示非數字 (NaN) 以及正或負無窮。
- Python 將 pow(0, 0) 和 0 ** 0 定義為 1
- 接受的數字字面值包括數碼 0 到 9 或任何等效的 Unicode 字符
所有 int 和 float 類型還包括下列運算
| 運算 | 結果 | 示例 |
|---|---|---|
| math.trunc(x) | 將 x 截斷為int | math.trunc(3.14) 為 3 |
| round(x[, n]) | x 舍入到 n 位小數 | round(3.14159, 3) 為 3.142 |
| math.floor(x) | 小於等於 x 的最大 int | math.floor(3.14) 為 3 |
| math.ceil(x) | 大於等於 x 的最小 int | math.ceil(3.14) 為 4 |
整數類型的按位運算
按位運算只對 整數 有意義。
計算按位運算的結果，就相當於使用無窮多個二進制符號位對二的補碼執行操作。
二進制按位運算的優先級全都低於數字運算，但又高於比較運算；一元運算 ~ 具有與其他一元算術運算 (+ and -) 相同 的優先級。
以下表格是以優先級升序排序的按位運算：
| 運算 | 結果 | 注釋 |
|---|---|---|
| x | y | x 和 y 按位 或 | 4 |
| x ^ y | x 和 y 按位 異或 | 4 |
| x & y | x 和 y 按位 與 | 4 |
| x << n | x 左移 n 位 | 1,2 |
| x >> n | x 右移 n 位 | 1,3 |
| ~x | x 逐位取反 |
注釋：
- 負 的移位數是非法的，會導致引發 ValueError。
- 左移 n 位等價於不帶 溢出檢測 (避免造成緩沖區溢出問題)地乘以 pow(2, n)。
- 右移 n 位等價於不帶 溢出檢測 (避免造成緩沖區溢出問題)地除以 pow(2, n)。
- 使用帶有至少一個額外符號擴展位的有限個二進制補碼表示（有效位寬度為 1 + max(x.bit_length(), y.bit_length()) 或以上）執行這些計算就足以獲得相當於有無數個符號位時的同樣結果。
整數類型的附加方法
int.bit_length()
返回以二進制表示一個整數所需要的位數，不包括符號位和前面的零:
>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6 # 即表示的是（100101）的長度
更准確地說，如果 x 非零，則 x.bit_length() 是使得 2**(k-1) <= abs(x) < 2**k 的唯一正整數 k。如果 x 為零，則 x.bit_length() 返回 0。
int.to_bytes(length, byteorder, *, signed=False)
返回表示一個整數的字節數組。
>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'
整數會使用參數 length 個字節來表示。 如果整數不能用給定的字節數來表示則會引發 OverflowError。
byteorder 參數用於表示整數的字節順序.如果 byteorder 為 "big"，則最高位字節放在字節數組的開頭。 如果 byteorder 為 "little"，則最高位字節放在字節數組的末尾。 要請求主機系統上的原生字節順序，使用 sys.byteorder 作為字節順序值。
signed 參數確定是否使用二的補碼來表示整數。如果 signed 為 False 並且給出的是負整數，則會引發 OverflowError。 signed 的默認值為 False。
classmethod int.from_bytes(bytes, byteorder, *, signed=False)
返回由給定字節數組所表示的整數。
>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680
bytes 參數必須為一個 bytes-like object 或是生成字節的可迭代對象。
byteorder 參數與to_bytes()函數的此參數一致
signed 參數指明是否使用二的補碼來表示整數。
浮點類型的附加方法
float.as_integer_ratio()
返回一對整數，其比率正好等於原浮點數並且分母為正數。 無窮大會引發 OverflowError 而 NaN 則會引發 ValueError:
>>> (3.14).as_integer_ratio()
(7070651414971679, 2251799813685248)
>>> (0.00).as_integer_ratio()
(0, 1)
float.is_integer()
如果 float 實例可用有限位整數表示則返回 True，否則返回 False:
>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False
float.hex()
以十六進制字符串的形式返回一個浮點數表示。 對於有限浮點數，這種表示法將總是包含前導的 0x 和尾隨的 p 加指數。
>>> (3.14159).hex()
'0x1.921f9f01b866ep+1'
classmethod float.fromhex(s)
返回以十六進制字符串 s 表示的浮點數的類方法。 字符串 s 可以帶有前導和尾隨的空格。
注意
- float.hex() 是實例方法，而float.fromhex(s) 是類方法
十六進制字符串采用的方式是：(與float.hex()函數返回的結果表示形式一致)
[sign] ['0x'] integer ['.' fraction] ['p' exponent]
- sign 可選，可以是 + 或 - ,integer 和 fraction 是十六進制數碼組成的字符串，exponent 是帶有可選前導符的十進制整數。
- 在 integer 或 fraction 中必須至少有一個十六進制數碼。
- exponent 是十進制數而非十六進制數，它給出要與系數相乘的 2 的冪次。
>>> float.fromhex('0x3.a7p10')
3740.0
>>> float.hex(3740.0)
'0x1.d380000000000p+11'
數字類型的哈希運算
對於可能為不同類型的數字 x 和 y，要求 x == y 時 必定 hash(x) == hash(y)
迭代器類型
Python 支持在容器中進行迭代的概念。
容器對象要提供迭代支持，必須定義一個方法:
- container.__iter__() 返回一個迭代器對象
迭代器對象自身需要支持以下兩個方法，它們共同組成了 迭代器協議:
- iterator.__iter__() 返回迭代器對象本身。 這是同時允許容器和迭代器配合 for 和 in 語句使用所必須的。
- iterator.__next__() 從容器中返回下一項。 如果已經沒有項可返回，則會引發 StopIteration 異常。
一旦迭代器的 __next__() 方法引發了 StopIteration，它必須一直對后續調用引發同樣的異常。 不遵循此行為特性的實現將無法正常使用。
生成器類型
Python 的 generator 提供了一種實現迭代器協議的便捷方式。如果容器對象 __iter__() 方法被實現為一個生成器，它將自動返回一個迭代器對象（從技術上說是一個生成器對象），該對象提供 __iter__() 和 __next__() 方法。
序列類型 --- list, tuple, range
有三種基本序列類型：list, tuple 和 range 對象。
通用序列操作
大多數序列類型，包括可變類型和不可變類型都支持下表中的操作。
以下表格按優先級升序列出了序列操作。（表格中s 和 t 是具有相同類型的序列，n, i, j 和 k 是整數而 x 是任何滿足 s 所規定的類型和值限制的任意對象。）
- in 和 not in 操作具有與比較操作相同的優先級。
- + (拼接) 和 * (重復) 操作具有與對應數值運算相同的優先級。
| 運算 | 結果 | 注釋 |
|---|---|---|
| x in s | 如果 s 中的某項等於 x 則結果為 True，否則為 False | (1) |
| x not in s | 如果 s 中的某項等於 x 則結果為 False，否則為 True | (1) |
| s + t | s 與 t 相拼接 | (6)(7) |
| s * n 或 n * s | 相當於 s 與自身進行 n 次拼接 | (2)(7) |
| s[i] | s 的第 i 項，起始為 0 | (3) |
| s[i:j] | s 從 i 到 j 的切片 | (3)(4) |
| s[i:j:k] | s 從 i 到 j 步長為 k 的切片 | (3)(5) |
| len(s) | s 的長度 | |
| min(s) | s 的最小項 | |
| max(s) | s 的最大項 | |
| s.index(x[, i[, j]]) | x 在 s 中首次出現項的索引號（索引號在 i 或其后且在 j 之前） | (8) |
| s.count(x) | s.count(x) |
相同類型的序列也支持比較。 特別地，tuple 和 list 的比較是通過比較對應元素的字典順序。 這就表示着想要比較結果相等，則每個元素比較結果都必須相等，並且兩個序列長度必須相同。
注釋：
- 雖然 in 和 not in 操作在通常情況下僅被用於簡單的成員檢測，但對於某些專門化序列 (例如 str, bytes 和 bytearray) 也使用它們進行子序列檢測:
>>> "gg" in "eggs"
True
- 小於 0 的 n 值會被當作 0 來處理 (生成一個與 s 同類型的空序列)。需要注意的是序列 s 中的項並不會被拷貝；它們會被多次引用，例如：
>>> lists = [[]] * 3 # [[]] 是一個包含了一個空列表的單元素列表，所以 [[]] * 3 結果中的三個元素都是對這一個空列表的引用。
>>> lists
[[], [], []]
>>> lists[0].append(3) # 修改 lists 中的任何一個元素實際上都是對這一個空列表的修改。
>>> 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]]
-
如果 i 或 j 為負值，則索引順序是相對於序列 s 的末尾: 索引號會被替換為 len(s) + i 或 len(s) + j。 但要注意 -0 仍然為 0。
-
s 從 i 到 j的切片被定義為所有滿足 i <= k < j 的索引號 k 的項組成的序列。 如果 i 或 j 大於 len(s)，則使用 len(s).
如果 i 被省略或為 None，則使用 0。 如果 j 被省略或為 None，則使用 len(s)。 如果 i 大於等於 j，則切片為空。 -
s 從 i 到 j 步長為 k 的切片被定義為所有滿足 0 <= n < (j-i)/k 的索引號 x = i + nk 的項組成的序列。換句話說，索引號為 i, i+k, i+2k, i+3*k，以此類推，當達到 j 時停止 (但一定不包括 j)。請注意，k 不可為零。 如果 k 為 None，則當作 1 處理。
-
拼接不可變序列會生成新的對象。這意味着通過重復拼接來構建序列的運行時開銷將會基於序列總長度的乘方。可以改用以下方法代替:
- 如果拼接 str 對象，你可以構建一個列表並在最后使用 str.join()
- 如果拼接 bytes 對象，你可以類似地使用 bytes.join(), 或者你也可以使用 bytearray 對象進行原地拼接。 bytearray 對象是可變的，並且具有高效的重分配機制
- 如果拼接 tuple 對象，請改為擴展 list 類
-
某些序列類型 (例如 range) 僅支持遵循特定模式的項序列，因此並不支持序列拼接或重復。
-
當 x 在 s 中找不到時 index 會引發 ValueError。
不可變序列類型
支持對內置函數hash()的支持，嘗試對包含有不可哈希值的不可變序列進行哈希運算將會導致 TypeError。
可變序列類型
以下表格中的操作是在可變序列類型上定義的。表格中的 s 是可變序列類型的實例，t 是任意可迭代對象，而 x 是符合對 s 所規定類型與值限制的任何對象
| 運算 | 結果 | 注釋 |
|---|---|---|
| s[i] = x | 將 s 的第 i 項替換為 x | |
| s[i:j] = t | 將 s 從 i 到 j 的切片替換為可迭代對象 t 的內容 | |
| del s[i:j] | 刪除 s 中的從 i 到 j 項等同於 s[i:j] = [] | |
| s[i:j:k] = t | 將 s[i:j:k] 的元素替換為 t 的元素 | 1 |
| del s[i:j:k] | 從列表中移除 s[i:j:k] 的元素 | |
| s.append(x) | 將 x 添加到序列的末尾 等同於 s[len(s):len(s)] = [x] | |
| s.clear() | 從 s 中移除所有項 (等同於 del s[:]) | 5 |
| s.copy() | 創建 s 的淺拷貝 (等同於 s[:]) | 5 |
| s.extend(t) 或 s += t | 用 t 的內容擴展 s (基本上等同於 s[len(s):len(s)] = t) | |
| s *= n | 使用 s 的內容重復 n 次來對其進行更新 | 6 |
| s.insert(i, x) | 在由 i 給出的索引位置將 x 插入 s (等同於 s[i:i] = [x]) | |
| s.pop([i]) | 提取在 i 位置上的項，並將其從 s 中移除 | 2 |
| s.remove(x) | 刪除 s 中第一個 s[i] 等於 x 的項目。 | 3 |
| s.reverse() | 就地將列表中的元素逆序 | 4 |
注釋：
- t 必須與它所替換的切片具有相同的長度
- 可選參數 i 默認為 -1，因此在默認情況下會移除並返回最后一項。
- 當在 s 中找不到 x 時 remove 操作會引發 ValueError
- 當反轉大尺寸序列時 reverse() 方法會原地修改該序列以保證空間經濟性
- 包含 clear() 和 copy() 函數是為了與不支持切片操作的可變容器的接口保持一致
- n 值為一個整數，或是一個實現了 __index__() 的對象。n 值為零或負數將清空序列,序列中的項不會被拷貝,它們會被多次引用。
列表
列表是可變序列，通常用於存放同類項目的集合
class list([iterable])
可以用以下多種方式構建列表：
- 使用一對方括號來表示空列表: []
- 使用方括號，其中的項以逗號分隔: [a], [a, b, c]
- 使用列表推導式: [x for x in iterable]
- 使用類型的構造器: list() 或 list(iterable)
構造器將構造一個列表，其中的項與 iterable 中的項具有相同的的值與順序。
iterable 可以是序列、支持迭代的容器或其它可迭代對象。
如果 iterable 已經是一個列表，將創建並返回其副本，類似於 iterable[:]。
>>> list('abc')
['a', 'b', 'c']
>>> list((1, 2, 3))
[1, 2, 3]
>>> list()
[]
列表實現了所有 一般 和 可變 序列的操作。 列表還額外提供了以下方法：
sort(*, key=None, reverse=False)
此方法會對列表進行原地排序
key參數 指定帶有一個參數的函數，用於從每個列表元素中提取比較鍵 (例如 key=str.lower)。默認值 None 表示直接對列表項排序而不計算一個單獨的鍵值。
reverse參數 為一個布爾值。 如果設為 True，則每個列表元素將按反向順序比較進行排序。
當排序大尺寸序列時此方法會原地修改該序列以保證空間經濟性。
元祖
元組是不可變序列，通常用於儲存異構數據的多項集
class tuple([iterable])
可以用以下多種方式構建元組：
- 使用一對圓括號來表示空元組: ()
- 使用一個后綴的逗號來表示單元組: a, 或 (a,) 但不能僅表示為(a)
- 使用以逗號分隔的多個項: a, b, c or (a, b, c)
- 使用內置的 tuple(): tuple() 或 tuple(iterable)
構造器將構造一個元組，其中的項與 iterable 中的項具有相同的值與順序。
元組實現了所有 一般 序列的操作。
iterable 可以是序列、支持迭代的容器或其它可迭代對象。
如果 iterable 已經是一個元組，會不加改變地將其返回。
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple( [1, 2, 3] )
(1, 2, 3)
>>> tuple()
()
需要注意的是決定生成元組的其實是逗號而不是圓括號。 圓括號只是可選的，生成空元組或需要避免語法歧義的情況除外。
range 對象
range 類型表示不可變的數字序列，通常用於在 for 循環中循環指定的次數
class range(stop)
class range(start, stop[, step])
range 構造器的參數必須為整數（可以是內置的 int 或任何實現了 __index__ 特殊方法的對象）
如果省略 step 參數，其默認值為 1。 如果省略 start 參數，其默認值為 0，如果 step 為零則會引發 ValueError。
一些 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 對象實現了 一般 序列的所有操作，但拼接和重復除外
range 類型相比常規 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 對象表示相同的值序列就認為它們是相等的。
例如：
>>> range(0) == range(2, 1, 3)
True
>>> range(0, 3, 2) == range(0, 4, 2)
True
文本序列類型 --- str
在 Python 中處理文本數據是使用 str 對象，也稱為 字符串。字符串 是由 Unicode 碼位構成的不可變序列。字符串 字面值有以下多種不同的寫法：
- 單引號 : '允許包含有 "雙" 引號'
- 雙引號 : "允許包含有 '單' 引號"
- 三重引號 : '''三重單引號''', """三重雙引號"""(使用三重引號的字符串可以跨越多行 —— 其中所有的空白字符都將包含在該字符串字面值中。)
只由空格分隔的多個字符串字面值會被隱式地轉換為單個字符串字面值。
>>> ("spam " "eggs") == "spam eggs"
True
字符串 也可以通過使用 str 構造器從其他對象創建。
由於不存在單獨的“字符”類型，對 字符串 做 索引操作 將產生一個長度為 1 的 字符串。 也就是說，對於一個非空字符串 s, s[0] == s[0:1]。
不存在可變的字符串類型，但是 str.join() 或 io.StringIO 可以被被用來根據多個片段高效率地構建字符串。
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
返回 object 的 字符串 版本。 如果未提供 object 則返回空字符串。
如果 encoding參數 或 errors參數 均未給出，str(object) 返回 object.__str__()。對於字符串對象，這是該字符串本身。 如果 object 沒有 __str__() 方法，則 str() 將回退為返回 repr(object)。
如果 encoding參數 或 errors參數 至少給出其中之一，則 object 應該是一個 bytes-like object (例如 bytes 或 bytearray)。如果 object 是一個 bytes (或 bytearray) 對象，則 str(bytes, encoding, errors) 等價於 bytes.decode(encoding, errors)。
將一個 bytes 對象傳入 str() 而不給出 encoding參數 或 errors參數 的操作屬於第一種情況， 將返回非正式 的字符串 表示,例如：
>>> str(b'Zoot!')
"b'Zoot!'"
字符串的方法
字符串實現了所有 一般 序列的操作，還額外提供了以下列出的一些附加方法。
str.capitalize()
返回原字符串的副本，其首個字符大寫，其余為小寫。
>>> ('jack').capitalize()
'Jack'
str.casefold()
返回原字符串消除大小寫的副本。 消除大小寫的字符串可用於忽略大小寫的匹配。
>>> ('Jack').casefold()
'jack'
str.center(width[, fillchar])
返回長度為 width參數 的字符串，原字符串在其正中。使用指定的 fillchar 填充兩邊的空位
如果 width參數 小於等於 len(s) 則返回原字符串的副本。
>>> ('Jack').center(10, "*")
'***Jack***'
>>> ('Jack').center(3)
'Jack'
str.count(sub[, start[, end]])
返回子字符串 sub參數 在 [start, end] 范圍內非重疊出現的次數。 可選參數 start 與 end 會被解讀為切片表示法。
>>> ('Jaccck').count("c")
3
>>> ('Jaccck').count("c", 0, 4)
2
str.encode(encoding="utf-8", errors="strict")
返回原字符串編碼為字節串對象的版本。 默認編碼為 'utf-8'。
可以給出 errors參數 來設置不同的錯誤處理方案。 errors 的默認值為 'strict'，表示編碼錯誤會引發 UnicodeError。
>>> ('Jack').encode()
b'Jack'
str.endswith(suffix[, start[, end]])
如果字符串以指定的 suffix參數 結束返回 True，否則返回 False。
suffix參數 也可以為由多個供查找的后綴構成的元組。
如果有可選項 start，將從指定位置開始檢查。 如果有可選項 end，將在所指定位置停止比較。
>>> ('Jack').endswith('k')
True
>>> ('Jack').endswith(('w', 's', 'm', 'a'))
False
>>> ('Jack').endswith(('w', 's', 'm', 'a'), 0, 2) # 元祖里面包含尾字符
True
str.expandtabs(tabsize=8)
返回字符串的副本，其中所有的制表符會由一個或多個空格替換，具體取決於當前列位置和給定的制表符寬度。每 tabsize參數 個字符設為一個制表位，用空格補充（默認值 8 時設定的制表位在列 0, 8, 16 依次類推）
>>> '01\t012\t0123\t01234'.expandtabs()
'01 012 0123 01234' # 默認參數為8，首位為0，8，16...其余用空格替換
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01 012 0123 01234' # 設置參數為4，首位為0，4，8...其余用空格替代
str.find(sub[, start[, end]])
返回子字符串 sub參數 在 s[start:end] 切片內被找到的最小索引。 可選參數 start 與 end 會被解讀為切片表示法。
str.format(*args, **kwargs)
執行字符串格式化操作。調用此方法的字符串可以包含字符串字面值和以花括號 {} 括起來的替換域。每個替換域可以包含一個位置參數的數字索引，或者一個關鍵字參數的名稱。
>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'
str.format_map(mapping)
類似於 str.format(**mapping)，不同之處在於 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'
>>> a = {'name': 'Jack', 'age': '22'}
>>> ('{name} is {age} years old').format_map(a)
'Jack is 22 years old'
str.index(sub[, start[, end]])
類似於 find()，但在找不到子類時會引發 ValueError。
>>> ('Jaccck').index('c')
2
>>> ('Jaccck').index('c', 4, )
4
>>> ('Jaccck').index('c', 5, -1)
ValueError: substring not found
str.isalnum()
如果字符串中至少有一個字符且所有字符均為字母或數字則返回真值，否則返回假值。
>>> ('123wearefamily').isalnum()
True
>>> ('123 we are family').isalnum() # 包含空格
False
str.isalpha()
如果字符串中至少有一個字符且所有字符均為字母則返回真值，否則返回假值。
>>> ('123wearefamily').isalpha()
False
>>> ('wearefamily').isalpha()
True
str.isascii()
如果字符串為空或所有字符均為 ASCII 字符則返回真值，否則返回假值。需要注意的是，此函數是3.7的新版功能，之前版本會報錯
str.isdecimal()
如果字符串中至少有一個字符且所有字符均為十進制數字符則返回真值，否則返回假值。
>>> ('123wearefamily').isdecimal()
False
>>> ('123').isdecimal()
True
str.isdigit()
如果字符串中至少有一個字符且所有字符均為數字字符則返回真值，否則返回假值。數字字符包括十進制數字符和需要特別處理的數字。用法與 isascii() 類似。
str.isidentifier()
如果字符串根據語言定義屬於有效的標識符則返回真值，否則返回假值。
>>> ('if').isidentifier()
True
>>> ('def').isidentifier()
True
>>> ('123bala').isidentifier()
False
str.islower()
檢測字符串是否都為小寫
如果字符串中至少有一個區分大小寫的字符且此類字符均為小寫則返回真值，否則返回假值。
>>> ('Petter').islower()
False
>>> ('i have a letter' ).islower()
True
str.isnumeric()
如果字符串中至少有一個字符且所有字符均為數值字符則返回真值，否則返回假值。數值字符包括數字字符，以及所有在 Unicode 中設置了數值特性屬性的字符
對於 Unicode 數字、全角數字（雙字節）、羅馬數字和漢字數字會返回 True ，其他會返回 False
定義一個字符串為Unicode，只需要在字符串前添加 'u' 前綴即可
>>> (u"wearefamily").isnumeric()
False
>>> ("21243").isnumeric()
True
>>> ("一二三").isnumeric()
True
str.isprintable()
如果字符串中所有字符均為可打印字符或字符串為空則返回真值，否則返回假值。
>>> ('123\t456').isprintable()
False
>>> ('').isprintable()
True
>>> ('123456').isprintable()
True
str.isspace()
如果字符串中至少有一個字符且所有字符均為空白字符則返回真值，否則返回假值。
>>> (' ').isspace()
True
>>> ('This is string example').isspace()
False
str.istitle()
如果字符串中至少有一個字符且為標題字符串則返回真值。
>>> ('This').istitle()
True
>>> ('this').istitle()
False
>>> ('THIS').istitle()
False
str.isupper()
檢測字符串中所有的字母是否都為大寫
如果字符串中至少有一個區分大小寫的字符且此類字符均為大寫則返回真值，否則返回假值。
>>> ('This is string example').isupper()
False
>>> ('THIS IS STRING EXAMPLE').isupper()
True
str.join(iterable)
返回一個由 iterable 中的字符串元素以指定字符拼接而成的字符串。如果 iterable 存在非字符串值則會引發 TypeError
>>> ('-').join(("father", "mother", "son", "grandfather", "grandmother"))
'father-mother-son-grandfather-grandmother'
str.ljust(width[, fillchar])
返回長度為 width參數 的字符串，原字符串在其中靠左對齊
使用指定的 fillchar參數 填充空位 (默認使用 ASCII 空格符)
如果 width參數 小於等於 len(s) 則返回原字符串的副本。
>>> ('Jack').ljust(12, '-')
'Jack--------'
str.lower()
返回原字符串的副本，其所有區分大小寫的字符均轉換為小寫。
>>> ("Jack").lower()
'jack'
str.lstrip([chars])
返回原字符串的副本，移除其中的前導字符。
chars 參數為指定要移除字符的字符串。 如果省略或為 None，則 chars 參數默認移除空格符。
>>> ' spacious '.lstrip()
'spacious '
>>> 'www.example.com'.lstrip('cmowz.') # 指定需要移除的字符串的集合
'example.com'
static str.maketrans(x[, y[, z]])
此靜態方法返回一個可供 str.translate() 使用的轉換對照表。
如果只給出一個參數，則必須為一個字典
如果給出兩個參數，則必須是長度一致的字符串，並且 x 中的每個字符都被映射為 y 中相同位置的字符
如果給出三個參數，則第三個參數表示需要刪除的字符串
>>> trans = ("Jack").maketrans({'a':'2'})
>>> ("Jack").translate(trans)
'J2ck'
trans = ('Jack').maketrans('ac', 'ca')
>>> ("Jack").translate(trans)
'Jcak'
>>> trans = ('Jack').maketrans('ac', 'ca', 'k')
>>> ("Jack").translate(trans)
'Jca'
str.partition(sep)
在 sep 首次出現的位置拆分字符串，返回一個 3 個元組，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。
如果分隔符未找到，則返回的 3 個元組中包含字符本身以及兩個空字符串。
>>> 'Jcaaak'.partition('a')
('Jc', 'a', 'aak')
str.replace(old, new[, count])
返回字符串的副本，其中出現的所有子字符串 old 都將被替換為 new。 如果給出了可選參數 count，則只替換前 count 次出現。
>>> 'Jcaaak'.replace('a', '0', 2)
'Jc00ak'
str.rfind(sub[, start[, end]])
返回子字符串 sub 在字符串內被找到的最大索引
sub 將包含在 s[start:end] 當中
如果未找到 sub 則返回 -1。
>>> 'Jcaaak'.rfind('a', 0, -1) # 返回最后一個的索引
4
str.rindex(sub[, start[, end]])
類似於 rfind()，但在子字符串 sub 未找到時會引發 </font color=red>ValueError。
>>> 'Jcaaak'.rindex('a', 0, -1)
4
>>> 'Jcaaak'.rindex('b', 0, -1)
ValueError: substring not found
str.rjust(width[, fillchar])
返回長度為 width 的字符串，原字符串在其中</font color=red>靠右對齊。 使用指定的 fillchar 填充</font color=red>空位 (默認使用 ASCII 空格符)。 如果 width 小於等於 len(s) 則返回原字符串的副本。
>>> ('lucky').rjust(15, '+')
'++++++++++lucky'
str.rpartition(sep)
在 sep 最后一次出現的位置拆分字符串，返回一個 3 個元組，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。
如果分隔符未找到，則返回的 3 個元組中包含兩個空字符串以及字符串本身。
>>> 'Jcaaak'.rpartition('a')
('Jcaa', 'a', 'k')
str.rsplit(sep=None, maxsplit=-1)
返回一個由字符串內單詞組成的列表，使用 sep 作為分隔字符串，類似於 split() 函數，只不過是從最右端開始分割。
如果 sep 未指定或為 None，任何空白字符串都會被作為分隔符。
如果給出了 maxsplit，則最多進行 maxsplit 次拆分
>>> '1,2,3,4,5'.rsplit(',', 3)
['1,2', '3', '4', '5']
>>> '1,2,3,4,5'.split(',', 3)
['1', '2', '3', '4,5']
str.rstrip([chars])
返回原字符串的副本，移除其中的末尾字符。chars參數 為指定要移除字符的字符串。 如果省略或為 None，則 chars參數 默認移除空格符。
>>> ' spacious '.rstrip()
' spacious'
>>> 'mississippi'.rstrip('ipz') # chars參數表示一個集合，以它中的任意一個結尾的都會給被移除
'mississ'
str.split(sep=None, maxsplit=-1)
返回一個由字符串內單詞組成的列表，使用 sep 作為分隔字符串。
如果給出了 maxsplit，則最多進行 maxsplit 次拆分（因此，列表最多會有 maxsplit+1 個元素）
如果給出了 maxsplit，則最多進行
>>> '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()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> ' 1 2 3 '.split()
['1', '2', '3']
str.splitlines([keepends])
返回由原字符串中各行組成的列表，在行邊界的位置拆分。
結果列表中不包含行邊界，除非給出了 keepends 且為真值。
此方法會以下列表格行邊界進行拆分。
| 標識符 | 描述 |
|---|---|
| \n | 換行 |
| \r | 回車 |
| \r\n | 回車 + 換行 |
| \v 或 \x0b | 行制表符 |
| \f 或 \x0c | 換表單 |
| \x1c | 文件分隔符 |
| \x1d | 組分隔符 |
| \x1e | 記錄分隔符 |
| \x85 | 下一行 (C1 控制碼) |
| \u2028 | 行分隔符 |
| \u2029 | 段分隔符 |
>>> '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']
>>> "".splitlines() # 空字符串返回一個空列表
[]
>>> "One line\n".splitlines() # 末尾的換行不會增加新的行
['One line']
>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']
str.startswith(prefix[, start[, end]])
如果字符串以指定的 prefix 開始則返回 True，否則返回 False。
prefix 也可以為由多個供查找的前綴構成的元組
如果有可選項 start，將從所指定位置開始檢查。 如果有可選項 end，將在所指定位置停止比較。
>>> ('Jack').startswith('J')
True
>>> ('Jack').startswith(('J', 'e', 'r'), 1, -1)
False
str.strip([chars])
返回原字符串的副本，移除其中的前導和末尾字符。
chars參數 為指定要移除字符的字符串。如果省略或為 None，則 chars參數 默認移除空格符
>>> ' spacious '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.') # chars不只表示單個前綴和后綴，也表示一個集合
'example'
>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32' # 開頭或者結尾的字符在遇到未包含在內的字符串時停止
str.swapcase()
返回原字符串的副本，其中大寫字符轉換為小寫，小寫字符轉換為大寫
>>> ('Jack').swapcase()
'jACK'
str.title()
返回原字符串的標題版本，其中每個單詞第一個字母為大寫，其余字母為小寫。
>>> 'jACK'.title()
'Jack'
>>> "they're bill's friends from the UK".title() # 連續的字母組合同樣被視為單詞
"They'Re Bill'S Friends From The Uk"
str.translate(table)
返回原字符串的副本，其中每個字符按給定的轉換表進行映射。
你可以使用 str.maketrans() 基於不同格式的字符到字符映射來創建一個轉換映射表。
>>> trans = ('We are family!').maketrans('abcde', '12345')
>>> ('We are family!').translate(trans)
'W5 1r5 f1mily!'
str.upper()
返回原字符串的副本，其中所有區分大小寫的字符均轉換為大寫。
>>> ('we are family!').upper()
'WE ARE FAMILY!'
str.zfill(width)
返回原字符串的副本，在左邊填充 ASCII '0' 數碼使其長度變為 width。
如果 width 小於等於 len(s) 則返回原字符串的副本。
正負值前綴 ('+'/'-') 的處理方式是在 正負符號 之后 填充而非在之前。
>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'
二進制序列類型 --- bytes, bytearray, memoryview
操作二進制數據的核心內置類型是 bytes 和 bytearray。
它們由 memoryview 提供支持，該對象使用 緩沖區協議 來訪問其他二進制對象所在內存，不需要創建對象的副本。
bytes 對象
bytes 對象是由單個字節構成的不可變序列。
class bytes([source[, encoding[, errors]]])
表示 bytes 字面值的語法與字符串字面值的大致相同，只是添加了一個 b 前綴：
- 單引號: b'同樣允許嵌入 "雙" 引號'。
- 雙引號: b"同樣允許嵌入 '單' 引號"。
- 三重引號: b'''三重單引號''', b"""三重雙引號"""
bytes 字面值中只允許 ASCII 字符，任何超出 127 的二進制值必須使用相應的轉義序列形式加入 bytes 字面值。
像字符串字面值一樣，bytes 字面值也可以使用 r 前綴來禁用轉義序列處理。
除了字面值形式，bytes 對象還可以通過其他幾種方式來創建：
- 指定長度的以零值填充的 bytes 對象: bytes(10)
- 通過由整數組成的可迭代對象: bytes(range(20))
- 通過緩沖區協議復制現有的二進制數據: bytes(obj)
由於兩個十六進制數碼精確對應一個字節，因此十六進制數是描述二進制數據的常用格式。
相應地，bytes 類型具有從此種格式讀取數據的附加類方法：
classmethod fromhex(string)
此 bytes 類方法返回一個解碼給定字符串的 bytes 對象。
字符串必須由表示每個字節的兩個十六進制數構成，其中的 ASCII 空白符會被忽略。
>>> bytes.fromhex('2Ef0 F1f2 ')
b'.\xf0\xf1\xf2'
存在一個反向轉換函數，可以將 bytes 對象轉換為對應的十六進制表示。
hex()
返回一個字符串對象，該對象包含實例中每個字節的兩個十六進制數字。
>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'
由於 bytes 對象是由整數構成的序列（類似於元組），因此對於一個 bytes 對象 b，b[0] 將為一個整數，而 b[0:1] 將為一個長度為 1 的 bytes 對象。
bytearray 對象
bytearray 對象是 bytes 對象的可變對應物。
class bytearray([source[, encoding[, errors]]])
bytearray 對象沒有專屬的字面值語法，它們總是通過調用構造器來創建：
- 創建一個空實例: bytearray()
- 創建一個指定長度的以零值填充的實例: bytearray(10)
- 通過由整數組成的可迭代對象: bytearray(range(20))
- 通過緩沖區協議復制現有的二進制數據: bytearray(b'Hi!')
由於 bytearray 對象是可變的，該對象除了 bytes 和 bytearray 操作 中所描述的 bytes 和 bytearray 共有操作之外，還支持 可變 序列操作。
classmethod fromhex(string)
bytearray 類方法返回一個解碼給定字符串的 bytearray 對象。
字符串必須由表示每個字節的兩個十六進制數構成，其中的 ASCII 空白符會被忽略。
在 3.7 版更改: bytearray.fromhex() 現在會忽略所有 ASCII 空白符而不只是空格符。
>>> bytearray.fromhex('2Ef0 F1f2 ')
bytearray(b'.\xf0\xf1\xf2')
存在一個反向轉換函數，可以將 bytearray 對象轉換為對應的十六進制表示。
hex()
返回一個字符串對象，該對象包含實例中每個字節的兩個十六進制數字。
>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'
bytes 和 bytearray 操作
bytes 和 bytearray 對象都支持 通用 序列操作。
bytes 和 bytearray 對象的下列方法可以用於任意二進制數據。
bytes.count(sub[, start[, end]])
bytearray.count(sub[, start[, end]])
返回子序列 sub 在 [start, end] 范圍內非重疊出現的次數。
bytes.decode(encoding="utf-8", errors="strict")
bytearray.decode(encoding="utf-8", errors="strict")
返回從給定 bytes 解碼出來的字符串。 默認編碼為 'utf-8'。
可以給出 errors參數 來設置不同的錯誤處理方案。 errors 的默認值為 'strict'，表示編碼錯誤會引發 UnicodeError。
bytes.endswith(suffix[, start[, end]])
bytearray.endswith(suffix[, start[, end]])
如果二進制數據以指定的 suffix 結尾則返回 True，否則返回 False。
suffix參數 也可以為由多個供查找的后綴構成的元組。
如果有可選項 start，將從所指定位置開始檢查。 如果有可選項 end，將在所指定位置停止比較。
bytes.find(sub[, start[, end]])
bytearray.find(sub[, start[, end]])
返回子序列 sub 在數據中被找到的最小索引，sub 包含於切片 s[start:end] 之內。
如果 sub 未被找到則返回 -1。
bytes.index(sub[, start[, end]])
bytearray.index(sub[, start[, end]])
類似於 find()，但在找不到子序列時會引發 ValueError。
bytes.join(iterable)
bytearray.join(iterable)
返回一個由 iterable 中的二進制數據序列經 bytes 或 bytearray 拼接而成的 bytes 或 bytearray 對象。
提供該方法的 bytes 或 bytearray 對象的內容將作為元素之間的分隔。
static bytes.maketrans(from, to)
static bytearray.maketrans(from, to)
此靜態方法返回一個可用於 bytes.translate() 的轉換對照表，它將把 from 中的每個字符映射為 to 中相同位置上的字符，from 與 to 必須都是 字節類對象 並且具有相同的長度。
bytes.partition(sep)
bytearray.partition(sep)
在 sep 首次出現的位置拆分序列，返回一個 3 元組，其中包含分隔符之前的部分、分隔符本身或其 bytearray 副本，以及分隔符之后的部分。
如果分隔符未找到，則返回的 3 元組中包含原序列以及兩個空的 bytes 或 bytearray 對象。
bytes.replace(old, new[, count])
bytearray.replace(old, new[, count])
返回序列的副本，其中出現的所有子序列 old 都將被替換為 new。 如果給出了可選參數 count，則只替換前 count 次出現。
bytes.rfind(sub[, start[, end]])
bytearray.rfind(sub[, start[, end]])
返回子序列 sub 在序列內被找到的最大的索引，sub 將包含在 s[start:end] 當中。
如果未找到則返回 -1。
bytes.rindex(sub[, start[, end]])
bytearray.rindex(sub[, start[, end]])
類似於 rfind()，但在子序列 sub 未找到時會引發 ValueError。
bytes.rpartition(sep)
bytearray.rpartition(sep)
在 sep 最后一次出現的位置拆分序列，返回一個 3 元組，其中包含分隔符之前的部分，分隔符本身或其 bytearray 副本，以及分隔符之后的部分。
如果分隔符未找到，則返回的 3 元組中包含兩個空的 bytes 或 bytearray 對象以及原序列的副本。
bytes.startswith(prefix[, start[, end]])
bytearray.startswith(prefix[, start[, end]])
如果二進制數據以指定的 prefix 開頭則返回 True，否則返回 False。
(prefix) 也可以為由多個供查找的前綴構成的元組。
bytes.translate(table, delete=b'')
bytearray.translate(table, delete=b'')
返回原 bytes 或 bytearray 對象的副本，移除其中所有在可選參數 delete 中出現的 bytes，其余 bytes 將通過給定的轉換表進行映射。
在 3.6 版更改: 支持將 delete 作為關鍵字參數
可以使用 bytes.maketrans() 方法來創建轉換表
>>> b'read this short text'.translate(None, b'aeiou') # 對於僅需移除字符的轉換，可以將table設置為None
b'rd ths shrt txt'
bytes.center(width[, fillbyte])
bytearray.center(width[, fillbyte])
返回原對象的副本，在長度為 width 的序列內居中，使用指定的 fillbyte 填充兩邊的空位（默認使用 ASCII 空格符）。
對於 bytes 對象，如果 width 小於等於 len(s) 則返回原序列的副本。
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
bytes.ljust(width[, fillbyte])
bytearray.ljust(width[, fillbyte])
返回原對象的副本，在長度為 width 的序列中靠左對齊，使用指定的 fillbyte 填充空位（默認使用 ASCII 空格符）
對於 bytes 對象，如果 width 小於等於 len(s) 則返回原序列的副本
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
bytes.lstrip([chars])
bytearray.lstrip([chars])
返回原序列的副本，移除指定的前導字節。
(chars) 參數為指定要移除字節值集合的二進制序列，如果省略或為 None，則 chars 參數默認移除 ASCII 空白符。
(chars) 參數並非指定單個前綴；而是會移除參數值的所有組合
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
>>> b' spacious '.lstrip()
b'spacious '
>>> b'www.example.com'.lstrip(b'cmowz.')
b'example.com'
bytes.rjust(width[, fillbyte])
bytearray.rjust(width[, fillbyte])
返回原對象的副本，在長度為 width 的序列中靠右對齊。
使用指定的 fillbyte 填充空位（默認使用 ASCII 空格符）
對於 bytes 對象，如果 width 小於等於 len(s) 則返回原序列的副本。
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
bytes.rsplit(sep=None, maxsplit=-1)
bytearray.rsplit(sep=None, maxsplit=-1)
將二進制序列拆分為相同類型的子序列，使用 sep 作為分隔符。
如果給出了 maxsplit參數，則最多進行 maxsplit 次拆分，從 最右邊 開始。
如果 sep 未指定或為 None，任何只包含 ASCII 空白符的子序列都會被作為分隔符。
bytes.rstrip([chars])
bytearray.rstrip([chars])
返回原序列的副本，移除指定的末尾字節。
(chars) 參數為指定要移除字節值集合的二進制序列，如果省略或為 None，則 chars 參數默認移除 ASCII 空白符。
(chars) 參數並非指定單個后綴；而是會移除參數值的所有組合
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
>>> b' spacious '.rstrip()
b' spacious'
>>> b'mississippi'.rstrip(b'ipz')
b'mississ'
bytes.split(sep=None, maxsplit=-1)
bytearray.split(sep=None, maxsplit=-1)
將二進制序列拆分為相同類型的子序列，使用 sep 作為分隔符。
如果給出了 maxsplit 且非負值，則最多進行 maxsplit 次拆分（因此，列表最多會有 maxsplit+1 個元素）。如果 maxsplit 未指定或為 -1，則不限制拆分次數（進行所有可能的拆分）
# sep指定時
>>> 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未指定時
>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b' 1 2 3 '.split()
[b'1', b'2', b'3']
bytes.strip([chars])
bytearray.strip([chars])
返回原序列的副本，移除指定的開頭和末尾字節。
(chars) 參數為指定要移除字節值集合的二進制序列,如果省略或為 None，則 chars 參數默認移除 ASCII 空白符。
(chars) 參數並非指定單個前綴或后綴；而是會移除參數值的所有組合
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
>>> b' spacious '.strip()
b'spacious'
>>> b'www.example.com'.strip(b'cmowz.')
b'example'
bytes.capitalize()
bytearray.capitalize()
返回原序列的副本，其中每個字節將都將被解讀為一個 ASCII 字符，並且第一個字節的字符大寫而其余的小寫。 非 ASCII 字節值將保持原樣不變。
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
bytes.expandtabs(tabsize=8)
bytearray.expandtabs(tabsize=8)
返回序列的副本，其中所有的 ASCII 制表符會由一個或多個 ASCII 空格替換，具體取決於當前列位置和給定的制表符寬度。
與上文中str.expandtabs(tabsize=8) 類似，可參照對比使用
>>> b'01\t012\t0123\t01234'.expandtabs()
b'01 012 0123 01234'
>>> b'01\t012\t0123\t01234'.expandtabs(4)
b'01 012 0123 01234'
bytes.isalnum()
bytearray.isalnum()
如果序列中所有字節都是字母類 ASCII 字符或 ASCII 十進制數碼並且序列非空則返回真值，否則返回假值。
>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False
bytes.isalpha()
bytearray.isalpha()
如果序列中所有字節都是字母類 ASCII 字符並且序列非空則返回真值，否則返回假值。
>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False
bytes.isascii()
bytearray.isascii()
如果序列為空或序列中所有字節都是 ASCII 字節則返回真值，否則返回假值。
bytes.isdigit()
bytearray.isdigit()
如果序列中所有字節都是 ASCII 十進制數碼並且序列非空則返回真值，否則返回假值。
>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False
bytes.islower()
bytearray.islower()
如果序列中至少有一個小寫 ASCII 字符並且沒有大寫 ASCII 字符則返回真值，否則返回假值。
>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False
bytes.isspace()
bytearray.isspace()
如果序列中所有字節都是 ASCII 空白符並且序列非空則返回真值，否則返回假值。
(ASCII 空白符)就是字節值包含在序列 b' \t\n\r\x0b\f' (空格, 制表, 換行, 回車, 垂直制表, 換頁) 中的字符。
bytes.istitle()
bytearray.istitle()
如果序列為 ASCII 標題形式並且序列非空則返回真值，否則返回假值。
>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False
bytes.isupper()
bytearray.isupper()
如果序列中至少有一個大寫字母 ASCII 字符並且沒有小寫 ASCII 字符則返回真值，否則返回假值。
>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False
bytes.lower()
bytearray.lower()
返回原序列的副本，其所有大寫 ASCII 字符均轉換為對應的小寫形式。
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
>>> b'Hello World'.lower()
b'hello world'
bytes.splitlines(keepends=False)
bytearray.splitlines(keepends=False)
返回由原二進制序列中各行組成的列表，在 ASCII 行邊界符的位置拆分。
結果列表中不包含換行符，除非給出了 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']
>>> b"".split(b'\n'), b"Two lines\n".split(b'\n') #當給出 sep參數時，空字符串此方法返回一個空列表
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])
bytes.swapcase()
bytearray.swapcase()
返回原序列的副本，其所有小寫 ASCII 字符均轉換為對應的大寫形式，反之亦反。
不同於 str.swapcase()，在些二進制版本下 bin.swapcase().swapcase() == bin 總是成立。
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
>>> b'Hello World'.swapcase()
b'hELLO wORLD'
bytes.title()
bytearray.title()
返回原二進制序列的標題版本，其中每個單詞以一個大寫 ASCII 字符為開頭，其余字母為小寫。 不區別大小寫的字節值將保持原樣不變。
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
>>> b'Hello world'.title()
b'Hello World'
bytes.upper()
bytearray.upper()
返回原序列的副本，其所有小寫 ASCII 字符均轉換為對應的大寫形式。
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
>>> b'Hello World'.upper()
b'HELLO WORLD'
bytes.zfill(width)
bytearray.zfill(width)
返回原序列的副本，在左邊填充 b'0' 數碼使序列長度為 width。
對於 bytes 對象，如果 width 小於等於 len(seq) 則返回原序列。
此方法的 bytearray 並非 原地操作，即便沒有做任何改變也會產生一個新對象。
>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'
集合類型 --- set, frozenset
set 對象是由具有唯一性的 hashable 對象所組成的無序多項集。
常見的用途包括成員檢測、從序列中去除重復項以及數學中的集合類計算
作為一種無序的多項集，集合並不記錄元素位置或插入順序。 相應地，集合不支持索引、切片或其他序列類的操作。
目前有兩種內置集合類型，set 和 frozenset。
set 類型是可變的 --- 其內容可以使用 add() 和 remove() 這樣的方法來改變。 由於是可變類型，它沒有哈希值，且不能被用作字典的鍵或其他集合的元素。
frozenset 類型是不可變並且具有哈希值 --- 其內容在被創建后不能再改變；因此它可以被用作字典的鍵或其他集合的元素。
class set([iterable])
class frozenset([iterable])
返回一個新的 set 或 frozenset 對象，其元素是一個可迭代對象。
要表示由集合對象構成的集合，所有的內層集合必須為 frozenset 對象。
如果未指定 iterable，則將返回一個新的空集合。
set 和 frozenset 的實例提供以下操作:
len(s)
返回集合 s 中的元素數量。
x in s
檢測 x 是否為 s 中的成員。
x not in s
檢測 x 是否非 s 中的成員。
isdisjoint(other)
如果集合中沒有與 other 共有的元素則返回 True。 當且僅當兩個集合的交集為空集合時，兩者為不相交集合。
issubset(other)
set <= other
檢測是否集合中的每個元素都在 other 之中
set < other
檢測集合是否為 other 的真子集，即 set <= other and set != other
issuperset(other)
set >= other
檢測是否 other 中的每個元素都在集合之中。
set > other
檢測集合是否為 other 的真超集，即 set >= other and set != other。
union(*others)
set | other | ...
返回一個新集合，其中包含來自原集合以及 others 指定的所有集合中的元素。
intersection(*others)
set & other & ...
返回一個新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。
difference(*others)
set - other - ...
返回一個新集合，其中包含原集合中在 others 指定的其他集合中不存在的元素。
symmetric_difference(other)
set ^ other
返回一個新集合，其中的元素或屬於原集合或屬於 other 指定的其他集合，但不能同時屬於兩者。
copy()
返回原集合的淺拷貝。
下面列出了不應用於 frozenset 而僅運用於 set 的操作
update(*others)
set |= other | ...
更新集合，添加來自所有 others 的元素。
intersection_update(*others)
set &= other & ...
更新集合，只保留其中找到的元素和 others。
difference_update(*others)
set -= other | ...
更新集合，刪除在 others 中找到的元素。
symmetric_difference_update(other)
set ^= other
更新集合，只保留在兩個集合中都找到的元素
add(elem)
向集合中添加元素 elem。
remove(elem)
從集合中移除元素 elem。如果集合中不包含 elem，則引發 KeyError。
discard(elem)
如果存在元素 elem，則從集合中刪除它。
pop()
從集合中移除並返回某一元素。如果集合為空，則引發 KeyError。
clear()
從集合中刪除所有元素。
映射類型 --- dict
映射對象將具有hash的值映射到任意對象。映射是可變的對象。目前只有一種標准映射，即dictionary。
字典的鍵幾乎是任意值，也就是說，包含列表、字典或其他可變類型的值。
字典可以通過在大括號中放置以逗號分隔的key: value對列來創建，例如:{'jack': 4098， 'sjoerd': 4127}或{4098:'jack'， 4127: 'sjoerd'}，也可以通過dict構造函數創建。
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
返回一個由可選位置參數和可能空的關鍵字參數集初始化的新字典。
如果沒有提供位置參數，則創建一個空字典。如果給定了一個位置參數，並且它是一個映射對象，則使用與映射對象相同的鍵值對創建一個字典。否則，位置參數必須是一個可迭代的對象。iterable中的每個項本身必須是一個具有兩個對象的iterable。
如果一個鍵出現多次，該鍵的最后一個值將成為新字典中對應的值。
如果給定關鍵字參數，則將關鍵字參數及其值添加到由位置參數創建的字典中。如果添加的鍵已經存在，關鍵字參數的值將替換位置參數的值。
>>> 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
以下是字典支持的操作：
len(d)
返回字典d中的項數。
d[key]
返回 d 中鍵為 key 的值。如果 key 不在映射中，則引發 KeyError
如果dict的子類定義了一個方法__missing__()，而 key 不存在，那么d[key]操作將以 key 作為參數調用該方法。如果沒有定義__missing__()，則會引發KeyError。
>>> class Counter(dict):
... def __missing__(self, key):
... return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1
d[key] = value
設置 d[key] 為 value
del d[key]
從d中刪除d[key]。如果key不在映射中，則引發KeyError。
key in d
如果 d 中有鍵 key 則返回 True 否則返回False
key not in d
自己理解
iter(d)
返回字典鍵上的迭代器。這是iter(d.keys())的快捷方式。
clear()
從字典中刪除所有項
copy()
返回字典的淺拷貝。
classmethod fromkeys(iterable[, value])
創建一個新字典，使用 iterable 中的鍵和設置為 value 的值。
(fromkeys()) 是一個返回新字典的類方法。值默認為 None。
get(key[, default])
如果 key 在字典中，則返回 key 的值，否則為 default。如果沒有提供 default，則默認為 None，因此此方法不會引發 KeyError。
items()
返回字典項((鍵，值)對)的新視圖
keys()
返回字典鍵的新視圖。
pop(key[, default])
如果 key 在字典中，刪除它並返回它的值，否則返回 default。如果沒有給出 default，並且 key 不在字典中，則會引發 KeyError。
popitem()
從字典中刪除並返回一個(鍵，值)對。此對按后進先出順序返回。如果字典是空的，調用popitem()將引發一個KeyError。
setdefault(key[, default])
如果字典存在鍵 key ，返回它的值。如果不存在，插入值為 default 的鍵 key ，並返回 default 。 default 默認為 None。
update([other])
使用其他鍵/值對更新字典，覆蓋現有鍵。返回None。
values()
返回字典值的新視圖。
>>> 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}
模塊
模塊上唯一的特殊操作是屬性訪問: m.name，其中 m 是模塊，name 訪問 m 的符號表中定義的名稱。模塊屬性可以分配。(注意 <font color=orangeimport 語句嚴格來說不是對模塊對象的操作;import foo 不需要一個名為foo 的模塊對象，而是需要一個名為foo的模塊的(外部)定義。
每個模塊的一個特殊屬性是__dict__。這是包含模塊符號表的字典。修改這個字典實際上會改變模塊的符號表，但是不能直接賦值給__dict__屬性(您可以編寫m.__dict__['a'] = 1，這定義了m.a等於1，但是你不能寫m.__dict__ = {})。不建議直接修改__dict__。
函數
函數對象由函數定義創建。函數對象上的唯一操作是調用此函數:func(argument-list)。
函數對象實際上有兩種類型:內置函數和用戶定義函數。兩者都支持相同的操作(調用函數)，但是實現不同，因此對象類型也不同。
方法
方法是使用屬性符號調用的函數。有兩種方法:內置方法(如列表上的append())和類實例方法。
>>> 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'
Type 對象
Type 對象表示各種對象類型。對象的 Type 由內置函數 type() 訪問。對於類型沒有特殊的操作。標准模塊類型為所有標准內置類型定義了名稱。
Type 的編寫方式為：<class 'int'>
Null 對象
此對象由不顯式返回值的函數返回。它不支持任何特殊操作。只有一個空對象，名為None(一個內置名稱)。type(None)()生成相同的單例。
Ellipsis 對象
這個對象是常用的切片。它不支持任何特殊操作。只有一個名為 Ellipsis (一個內置名稱)的省略號對象。類型(Ellipsis)()生成 Ellipsis 單例。
它被寫為：Ellipsis 或者 ....。
特殊屬性
object.__dict__
字典或其他映射對象，用於存儲對象的(可寫的)屬性
instance.__class__
返回類實例所屬的類。
class.__bases__
類對象的基類的元組。
definition.__name__
類、函數、方法、描述符或生成器實例的名稱。
definition.__qualname__
類、函數、方法、描述符或生成器實例的限定名。
class.__mro__
此屬性是一個類元組，在方法解析期間查找基類時將考慮這些類。
class.mro()
元類可以覆蓋此方法，以自定義其實例的方法解析順序。它在類實例化時調用，其結果存儲在_mro__中。
class.__subclasses__()
每個類都保存對其直接子類的弱引用列表，此方法返回所有仍然存在的引用的列表。例如：
>>> int.__subclasses__()
[<class 'bool'>]