Python標準庫---1三、內置類型：二進制序列類型 ( bytes, bytearray)

上一篇文章： Python標準庫---十二、內置類型:文本序列類型（str）
下一篇文章：

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

操做二進制數據的核心內置類型是 bytes 和 bytearray。 它們由 memoryview 提供支持，該對象使用 緩衝區協議 來訪問其餘二進制對象所在內存，不須要建立對象的副本。

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

bytes 對象

bytes 對象是由單個字節構成的不可變序列。 因爲許多主要二進制協議都基於 ASCII 文本編碼，所以 bytes 對象提供了一些僅在處理 ASCII 兼容數據時可用，而且在許多特性上與字符串對象緊密相關的方法。

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

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

    單引號: b'一樣容許嵌入 "雙" 引號'。

    雙引號: b"一樣容許嵌入 '單' 引號"。

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

bytes 字面值中只容許 ASCII 字符（不管源代碼聲明的編碼爲什麼）。 任何超出 127 的二進制值必須使用相應的轉義序列形式加入 bytes 字面值。

像字符串字面值同樣，bytes 字面值也可使用 r 前綴來禁用轉義序列處理。 請參閱 字符串和字節串字面值 瞭解有關各類 bytes 字面值形式的詳情，包括所支持的轉義序列。

雖然 bytes 字面值和表示法是基於 ASCII 文本的，但 bytes 對象的行爲實際上更像是不可變的整數序列，序列中的每一個值的大小被限制爲 0 <= x < 256 (若是違反此限制將引起 ValueError)。 這種限制是有意設計用以強調如下事實，雖然許多二進制格式都包含基於 ASCII 的元素，能夠經過某些面向文本的算法進行有用的操做，但狀況對於任意二進制數據來講一般卻並不是如此（盲目地將文本處理算法應用於不兼容 ASCII 的二進制數據格式每每將致使數據損壞）。

除了字面值形式，bytes 對象還能夠經過其餘幾種方式來建立：

• 指定長度的以零值填充的 bytes 對象: bytes(10)
• 經過由整數組成的可迭代對象: bytes(range(20))

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

  另請參閱 bytes 內置類型。

  因爲兩個十六進制數碼精確對應一個字節，所以十六進制數是描述二進制數據的經常使用格式。 相應地，bytes 類型具備今後種格式讀取數據的附加類方法：

classmethod fromhex(string)

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

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

    在 3.7 版更改: bytes.fromhex() 如今會忽略全部 ASCII 空白符而不僅是空格符。

存在一個反向轉換函數，能夠將 bytes 對象轉換爲對應的十六進制表示。

hex()

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

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

    3.5 新版功能.

因爲 bytes 對象是由整數構成的序列（相似於元組），所以對於一個 bytes 對象 b，b[0] 將爲一個整數，而 b[0:1] 將爲一個長度爲 1 的 bytes 對象。 （這與文本字符串不一樣，索引和切片所產生的將都是一個長度爲 1 的字符串）。

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

註解

針對 Python 2.x 用戶的說明：在 Python 2.x 系列中，容許 8 位字符串（ 2.x 所提供的最接近內置二進制數據類型的對象）與 Unicode 字符串進行各類隱式轉換。 這是爲了實現向下兼容的變通作法，以適應 Python 最初只支持 8 位文本而 Unicode 文本是後來才被加入這一事實。 在 Python 3.x 中，這些隱式轉換已被取消 —— 8 位二進制數據與 Unicode 文本間的轉換必須顯式地進行，bytes 與字符串對象的比較結果將老是不相等。

bytearray 對象

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

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

bytearray 對象沒有專屬的字面值語法，它們老是經過調用構造器來建立：

• 建立一個空實例: bytearray()
• 建立一個指定長度的以零值填充的實例: bytearray(10)
• 經過由整數組成的可迭代對象: bytearray(range(20))
• 經過緩衝區協議複製現有的二進制數據: bytearray(b'Hi!')

  因爲 bytearray 對象是可變的，該對象除了 bytes 和 bytearray 操做 中所描述的 bytes 和 bytearray 共有操做以外，還支持 可變 序列操做。

  另請參見 bytearray 內置類型。

  因爲兩個十六進制數碼精確對應一個字節，所以十六進制數是描述二進制數據的經常使用格式。 相應地，bytearray 類型具備今後種格式讀取數據的附加類方法：

classmethod fromhex(string)

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

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

在 3.7 版更改: bytearray.fromhex() 如今會忽略全部 ASCII 空白符而不僅是空格符。

存在一個反向轉換函數，能夠將 bytearray 對象轉換爲對應的十六進制表示。

hex()

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

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

3.5 新版功能.

因爲 bytearray 對象是由整數構成的序列（相似於列表），所以對於一個 bytearray 對象 b，b[0] 將爲一個整數，而 b[0:1] 將爲一個長度爲 1 的 bytearray 對象。 （這與文本字符串不一樣，索引和切片所產生的將都是一個長度爲 1 的字符串）。

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

bytes 和 bytearray 操做

bytes 和 bytearray 對象都支持 通用 序列操做。 它們不只能與相同類型的操做數，也能與任何 bytes-like object 進行互操做。 因爲這樣的靈活性，它們能夠在操做中自由地混合而不會致使錯誤。 可是，操做結果的返回值類型可能取決於操做數的順序。

註解

bytes 和 bytearray 對象的方法不接受字符串做爲其參數，就像字符串的方法不接受 bytes 對象做爲其參數同樣。 例如，你必須使用如下寫法:

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

和:

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

某些 bytes 和 bytearray 操做假定使用兼容 ASCII 的二進制格式，所以在處理任意二進數數據時應當避免使用。 這些限制會在下文中說明。

註解

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

bytes 和 bytearray 對象的下列方法能夠用於任意二進制數據。

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

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

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

要搜索的子序列能夠是任意 bytes-like object 或是 0 至 255 範圍內的整數。

在 3.3 版更改: 也接受 0 至 255 範圍內的整數做爲子序列。

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

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

返回從給定 bytes 解碼出來的字符串。 默認編碼爲 'utf-8'。 能夠給出 errors 來設置不一樣的錯誤處理方案。 errors 的默認值爲 'strict'，表示編碼錯誤會引起 UnicodeError。 其餘可用的值爲 'ignore', 'replace' 以及任何其餘經過 codecs.register_error() 註冊的名稱，請參閱 Error Handlers 小節。 要查看可用的編碼列表，請參閱 標準編碼 小節。

註解

將 encoding 參數傳給 str 容許直接解碼任何 bytes-like object，無須建立臨時的 bytes 或 bytearray 對象。

在 3.1 版更改: 加入了對關鍵字參數的支持。

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

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

若是二進制數據以指定的 suffix 結束則返回 True，不然返回 False。 suffix 也能夠爲由多個供查找的後綴構成的元組。 若是有可選項 start，將從所指定位置開始檢查。 若是有可選項 end，將在所指定位置中止比較。

要搜索的後綴能夠是任意 bytes-like object。

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

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

返回子序列 sub 在數據中被找到的最小索引，sub 包含於切片 s[start:end] 以內。 可選參數 start 與 end 會被解讀爲切片表示法。 若是 sub 未被找到則返回 -1。

要搜索的子序列能夠是任意 bytes-like object 或是 0 至 255 範圍內的整數。

註解

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

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

在 3.3 版更改: 也接受 0 至 255 範圍內的整數做爲子序列。

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

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

相似於 find()，但在找不到子序列時會引起 ValueError。

要搜索的子序列能夠是任意 bytes-like object 或是 0 至 255 範圍內的整數。

在 3.3 版更改: 也接受 0 至 255 範圍內的整數做爲子序列。

bytes.join(iterable)

bytearray.join(iterable)

返回一個由 iterable 中的二進制數據序列拼接而成的 bytes 或 bytearray 對象。 若是 iterable 中存在任何非 字節類對象 包括存在 str 對象值則會引起 TypeError。 提供該方法的 bytes 或 bytearray 對象的內容將做爲元素之間的分隔。

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

此靜態方法返回一個可用於 bytes.translate() 的轉換對照表，它將把 from 中的每一個字符映射爲 to 中相同位置上的字符；from 與 to 必須都是 字節類對象 而且具備相同的長度。

3.1 新版功能.

bytes.partition(sep)

bytearray.partition(sep)

在 sep 首次出現的位置拆分序列，返回一個 3 元組，其中包含分隔符以前的部分、分隔符自己或其 bytearray 副本，以及分隔符以後的部分。 若是分隔符未找到，則返回的 3 元組中包含原序列以及兩個空的 bytes 或 bytearray 對象。

要搜索的分隔符能夠是任意 bytes-like object。

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

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

返回序列的副本，其中出現的全部子序列 old 都將被替換爲 new。 若是給出了可選參數 count，則只替換前 count 次出現。

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

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

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

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

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

要搜索的子序列能夠是任意 bytes-like object 或是 0 至 255 範圍內的整數。

在 3.3 版更改: 也接受 0 至 255 範圍內的整數做爲子序列。

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

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

相似於 rfind()，但在子序列 sub 未找到時會引起 ValueError。

要搜索的子序列能夠是任意 bytes-like object 或是 0 至 255 範圍內的整數。

在 3.3 版更改: 也接受 0 至 255 範圍內的整數做爲子序列。

bytes.rpartition(sep)

bytearray.rpartition(sep)

在 sep 最後一次出現的位置拆分序列，返回一個 3 元組，其中包含分隔符以前的部分，分隔符自己或其 bytearray 副本，以及分隔符以後的部分。 若是分隔符未找到，則返回的 3 元組中包含兩個空的 bytes 或 bytearray 對象以及原序列的副本。

要搜索的分隔符能夠是任意 bytes-like object。

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

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

若是二進制數據以指定的 prefix 開頭則返回 True，不然返回 False。 prefix 也能夠爲由多個供查找的前綴構成的元組。 若是有可選項 start，將從所指定位置開始檢查。 若是有可選項 end，將在所指定位置中止比較。

要搜索的前綴能夠是任意 bytes-like object。

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

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

返回原 bytes 或 bytearray 對象的副本，移除其中全部在可選參數 delete 中出現的 bytes，其他 bytes 將經過給定的轉換表進行映射，該轉換表必須是長度爲 256 的 bytes 對象。

你可使用 bytes.maketrans() 方法來建立轉換表。

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

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

在 3.6 版更改: 如今支持將 delete 做爲關鍵字參數。

如下 bytes 和 bytearray 對象的方法的默認行爲會假定使用兼容 ASCII 的二進制格式，但經過傳入適當的參數仍然可用於任意二進制數據。 請注意本小節中全部的 bytearray 方法都 不是 原地執行操做，而是會產生新的對象。

bytes.center(width[, fillbyte])

bytearray.center(width[, fillbyte])

返回原對象的副本，在長度爲 width 的序列內居中，使用指定的 fillbyte 填充兩邊的空位（默認使用 ASCII 空格符）。 對於 bytes 對象，若是 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 參數爲指定要移除字節值集合的二進制序列 —— 這個名稱代表此方法一般是用於 ASCII 字符。 若是省略或爲 None，則 chars 參數默認移除 ASCII 空白符。 chars 參數並不是指定單個前綴；而是會移除參數值的全部組合:

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

要移除的字節值二進制序列能夠是任意 bytes-like object。

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

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 空白符的子序列都會被做爲分隔符。 除了從右邊開始拆分，rsplit() 的其餘行爲都相似於下文所述的 split()。

bytes.rstrip([chars])

bytearray.rstrip([chars])

返回原序列的副本，移除指定的末尾字節。 chars 參數爲指定要移除字節值集合的二進制序列 —— 這個名稱代表此方法一般是用於 ASCII 字符。 若是省略或爲 None，則 chars 參數默認移除 ASCII 空白符。 chars 參數並不是指定單個後綴；而是會移除參數值的全部組合:

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

要移除的字節值二進制序列能夠是任意 bytes-like object。

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

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

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

將二進制序列拆分爲相同類型的子序列，使用 sep 做爲分隔符。 若是給出了 maxsplit 且非負值，則最多進行 maxsplit 次拆分（所以，列表最多會有 maxsplit+1 個元素）。 若是 maxsplit 未指定或爲 -1，則不限制拆分次數（進行全部可能的拆分）。

若是給出了 sep，則連續的分隔符不會被組合在一塊兒而是被視爲分隔空子序列 (例如 b'1,,2'.split(b',') 將返回 [b'1', b'', b'2'])。 sep 參數可能爲一個多字節序列 (例如 b'1<>2<>3'.split(b'<>') 將返回 [b'1', b'2', b'3'])。 使用指定的分隔符拆分空序列將返回 [b''] 或 [bytearray(b'')]，具體取決於被拆分對象的類型。 sep 參數能夠是任意 bytes-like object。

例如:

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

若是 sep 未指定或爲 None，則會應用另外一種拆分算法：連續的 ASCII 空白符會被視爲單個分隔符，其結果將不包含序列開頭或末尾的空白符。 所以，在不指定分隔符的狀況下對空序列或僅包含 ASCII 空白符的序列進行拆分將返回 []。

例如:

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

bytes.strip([chars])

bytearray.strip([chars])

返回原序列的副本，移除指定的開頭和末尾字節。 chars 參數爲指定要移除字節值集合的二進制序列 —— 這個名稱代表此方法一般是用於 ASCII 字符。 若是省略或爲 None，則 chars 參數默認移除 ASCII 空白符。 chars 參數並不是指定單個前綴或後綴；而是會移除參數值的全部組合:

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

要移除的字節值二進制序列能夠是任意 bytes-like object。

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

如下 bytes 和 bytearray 對象的方法會假定使用兼容 ASCII 的二進制格式，不該當被應用於任意二進制數據。 請注意本小節中全部的 bytearray 方法都 不是 原地執行操做，而是會產生新的對象。

bytes.capitalize()

bytearray.capitalize()

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

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

返回序列的副本，其中全部的 ASCII 製表符會由一個或多個 ASCII 空格替換，具體取決於當前列位置和給定的製表符寬度。 每 tabsize 個字節設爲一個製表位（默認值 8 時設定的製表位在列 0, 8, 16 依次類推）。 要展開序列，當前列位置將被設爲零並逐一檢查序列中的每一個字節。 若是字節爲 ASCII 製表符 (b'\t')，則並在結果中插入一個或多個空格符，直到當前列等於下一個製表位。 （製表符自己不會被複制。） 若是當前字節爲 ASCII 換行符 (b'\n') 或回車符 (b'\r')，它會被複制並將當前列重設爲零。 任何其餘字節會被不加修改地複製並將當前列加一，不論該字節值在被打印時會如何顯示:

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

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

bytes.isalnum()

bytearray.isalnum()

若是序列中全部字節都是字母類 ASCII 字符或 ASCII 十進制數碼而且序列非空則返回真值，不然返回假值。 字母類 ASCII 字符就是字節值包含在序列 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。 ASCII 十進制數碼就是字節值包含在序列 b'0123456789' 中的字符。

例如:

>>> b'ABCabc1'.isalnum()
    True
    >>> b'ABC abc1'.isalnum()
    False

bytes.isalpha()

bytearray.isalpha()

若是序列中全部字節都是字母類 ASCII 字符而且序列非空則返回真值，不然返回假值。 字母類 ASCII 字符就是字節值包含在序列 b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。

例如:

>>> b'ABCabc'.isalpha()
    True
    >>> b'ABCabc1'.isalpha()
    False

bytes.isascii()

bytearray.isascii()

若是序列爲空或序列中全部字節都是 ASCII 字節則返回真值，不然返回假值。 ASCII 字節的取值範圍是 0-0x7F。

3.7 新版功能.

bytes.isdigit()

bytearray.isdigit()

若是序列中全部字節都是 ASCII 十進制數碼而且序列非空則返回真值，不然返回假值。 ASCII 十進制數碼就是字節值包含在序列 b'0123456789' 中的字符。

例如:

>>> b'1234'.isdigit()
    True
    >>> b'1.23'.isdigit()
    False

bytes.islower()

bytearray.islower()

若是序列中至少有一個小寫 ASCII 字符而且沒有大寫 ASCII 字符則返回真值，不然返回假值。

例如:

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

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

bytes.isspace()

bytearray.isspace()

若是序列中全部字節都是 ASCII 空白符而且序列非空則返回真值，不然返回假值。 ASCII 空白符就是字節值包含在序列 b' \t\n\r\x0b\f' (空格, 製表, 換行, 回車, 垂直製表, 換頁) 中的字符。

bytes.istitle()

bytearray.istitle()

若是序列爲 ASCII 標題形式而且序列非空則返回真值，不然返回假值。 請參閱 bytes.title() 瞭解有關「標題形式」的詳細定義。

例如:

>>> b'Hello World'.istitle()
    True
    >>> b'Hello world'.istitle()
    False

bytes.isupper()

bytearray.isupper()

若是序列中至少有一個大寫字母 ASCII 字符而且沒有小寫 ASCII 字符則返回真值，不然返回假值。

例如:

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

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

bytes.lower()

bytearray.lower()

返回原序列的副本，其全部大寫 ASCII 字符均轉換爲對應的小寫形式。

例如:

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

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

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

返回由原二進制序列中各行組成的列表，在 ASCII 行邊界符的位置拆分。 此方法使用 universal newlines 方式來分行。 結果列表中不包含換行符，除非給出了 keepends 且爲真值。

例如:

>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
    [b'ab c', b'', b'de fg', b'kl']
    >>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
    [b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

不一樣於 split()，當給出了分隔符 sep 時，對於空字符串此方法將返回一個空列表，而末尾的換行不會令結果中增長額外的行:

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
    ([b''], [b'Two lines', b''])
    >>> b"".splitlines(), b"One line\n".splitlines()
    ([], [b'One line'])

bytes.swapcase()

bytearray.swapcase()

返回原序列的副本，其全部小寫 ASCII 字符均轉換爲對應的大寫形式，反之亦反。

例如:

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

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

不一樣於 str.swapcase()，在些二進制版本下 bin.swapcase().swapcase() == bin 老是成立。 大小寫轉換在 ASCII 中是對稱的，即便其對於任意 Unicode 碼位來講並不老是成立。

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

bytes.title()

bytearray.title()

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

例如:

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

小寫 ASCII 字符就是字節值包含在序列 b'abcdefghijklmnopqrstuvwxyz' 中的字符。 大寫 ASCII 字符就是字節值包含在序列 b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 中的字符。 全部其餘字節值都不區分大小寫。

該算法使用一種簡單的與語言無關的定義，將連續的字母組合視爲單詞。 該定義在多數狀況下都頗有效，但它也意味着表明縮寫形式與全部格的撇號也會成爲單詞邊界，這可能致使不但願的結果:

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

可使用正則表達式來構建針對撇號的特別處理:

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

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

bytes.upper()

bytearray.upper()

返回原序列的副本，其全部小寫 ASCII 字符均轉換爲對應的大寫形式。

例如:

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

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

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

bytes.zfill(width)

bytearray.zfill(width)

返回原序列的副本，在左邊填充 b'0' 數碼使序列長度爲 width。 正負值前綴 (b'+'/ b'-') 的處理方式是在正負符號 以後 填充而非在以前。 對於 bytes 對象，若是 width 小於等於 len(seq) 則返回原序列。

例如:

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

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

printf 風格的字節串格式化

註解

此處介紹的格式化操做具備多種怪異特性，可能致使許多常見錯誤（例如沒法正確顯示元組和字典）。 若是要打印的值可能爲元組或字典，請將其放入一個元組中。

字節串對象 (bytes/bytearray) 具備一種特殊的內置操做：使用 % (取模) 運算符。 這也被稱爲字節串的 格式化 或 插值 運算符。 對於 format % values (其中 format 爲一個字節串對象)，在 format 中的 % 轉換標記符將被替換爲零個或多個 values 條目。 其效果相似於在 C 語言中使用 sprintf()。

若是 format 要求一個單獨參數，則 values 能夠爲一個非元組對象。 5 不然的話，values 必須或是是一個包含項數與格式字節串對象中指定的轉換符項數相同的元組，或者是一個單獨的映射對象（例如元組）。

轉換標記符包含兩個或更多字符並具備如下組成，且必須遵循此處規定的順序：

1. '%' 字符，用於標記轉換符的起始。
2. 映射鍵（可選），由加圓括號的字符序列組成 (例如 (somename))。
3. 轉換旗標（可選），用於影響某些轉換類型的結果。
4. 最小字段寬度（可選）。 若是指定爲 '*' (星號)，則實際寬度會從 values 元組的下一元素中讀取，要轉換的對象則爲最小字段寬度和可選的精度以後的元素。
5. 精度（可選），以在 '.' (點號) 以後加精度值的形式給出。 若是指定爲 '*' (星號)，則實際精度會從 values 元組的下一元素中讀取，要轉換的對象則爲精度以後的元素。
6. 長度修飾符（可選）。
7. 轉換類型。

當右邊的參數爲一個字典（或其餘映射類型）時，字節串對象中的格式 必須 包含加圓括號的映射鍵，對應 '%' 字符以後字典中的每一項。 映射鍵將從映射中選取要格式化的值。 例如：

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

在此狀況下格式中不能出現 * 標記符（因其須要一個序列類的參數列表）。

轉換旗標爲：

能夠給出長度修飾符 (h, l 或 L)，但會被忽略，由於對 Python 來講沒有必要 -- 因此 %ld 等價於 %d。

轉換類型爲：

註釋:

1. 此替代形式會在第一個數碼以前插入標示八進制數的前綴 ('0o')。
2. 此替代形式會在第一個數碼以前插入 '0x' 或 '0X' 前綴（取決因而使用 'x' 仍是 'X' 格式）。
3. 此替代形式老是會在結果中包含一個小數點，即便其後並無數碼。

   小數點後的數碼位數由精度決定，默認爲 6。

4. 此替代形式老是會在結果中包含一個小數點，末尾各位的零不會如其餘狀況下那樣被移除。

   小數點先後的有效數碼位數由精度決定，默認爲 6。

5. 若是精度爲 N，輸出將截短爲 N 個字符。
6. b'%s' 已棄用，但在 3.x 系列中將不會被移除。
7. b'%r' 已棄用，但在 3.x 系列中將不會被移除。
8. 參見 PEP 237。

註解

此方法的 bytearray 版本 並不是 原地操做 —— 它老是產生一個新對象，即使沒有作任何改變。

參見

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

3.5 新版功能.

上一篇文章： Python標準庫---十二、內置類型:文本序列類型（str） 下一篇文章：