Python必備技巧之字元資料操作詳解

2022-03-23 13:00:57

字串操作

字串 + 運運算元

+運運算元用於連線字串，返回一個由連線在一起的運算元組成的字串。

>>> s = 'a'
>>> t = 'b'
>>> u = 'c'

>>> s + t
'ab'
>>> s + t + u
'abc'

>>> print('Go' + '!!!')
Go!!!

字串 * 運運算元

* 運運算元建立字串的多個副本。如果s是字串並且n是整數，則以下任一表示式都會返回由的n連線副本組成的字串s。

>>> s = 'f.'

>>> s * 4
'f.f.f.f.'
>>> 4 * s
'f.f.f.f.'

乘數運算元n必須是正整數。

>>> 'f' * -8
''

字串 in 運運算元

Python 還提供了一個可以與字串一起使用的成員運運算元。如果第一個運算元包含在第二個運算元中，則in運運算元返回 True 否則返回 False 。

>>> s = 'foo'

>>> s in 'That's food for thought.'
True
>>> s in 'That's good for now.'
False

用於相反的處理操作 not in 運運算元。

>>> 'z' not in 'abc'
True
>>> 'z' not in 'xyz'
False

內建字串函數

Python 提供了許多內建於直譯器並且始終可用的函數。

功能	描述
chr()	將整數轉換為字元
ord()	將字元轉換為整數
len()	返回字串的長度
str()	返回物件的字串表示形式

# ord(c)
# 計算機將所有資訊儲存為數位,使用了一種將每個字元對映到其代表數位的轉換方案
# 常用方案稱為ASCII。它涵蓋了您可能最習慣使用的常見拉丁字元
# ord(c)返回 character 的 ASCII 值
>>> ord('a')
97
>>> ord('#')
35

# chr(n)
# chr()做的是ord()相反的事情，給定一個數值n，chr(n)返回一個字串
# 處理Unicode 字元
>>> chr(97)
'a'
>>> chr(35)
'#'
>>> chr(8364)
'€'
>>> chr(8721)
'∑'


# len(s)
# 返回字串的長度。
>>> s = 'I am a string.'
>>> len(s)
14

# str(obj)
# 返回物件的字串表示形式
# Python 中的任何物件都可以呈現為字串
>>> str(49.2)
'49.2'
>>> str(3+4j)
'(3+4j)'
>>> str(3 + 29)
'32'
>>> str('foo')
'foo'

字串索引

在 Python 中，字串是字元資料的有序序列，因此可以通過這種方式進行索引。可以通過指定字串名稱後跟方括號 ( []) 中的數位來存取字串中的各個字元。

Python 中的字串索引是從零開始的：字串中的第一個字元具有 index 0，下一個字元具有 index 1，依此類推。最後一個字元的索引將是字串的長度減1。

>>> s = 'foobar'

# 正索引
>>> s[0]
'f'
>>> s[1]
'o'
>>> s[3]
'b'
>>> len(s)
6
>>> s[len(s)-1]
'r'

# 負索引
>>> s[-1]
'r'
>>> s[-2]
'a'
>>> len(s)
6
>>> s[-len(s)]
'f'

嘗試超出字串末尾的索引會導致錯誤。

# 正索引
>>> s[6]
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    s[6]
IndexError: string index out of range

# 負索引
>>> s[-7]
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    s[-7]
IndexError: string index out of range

字串切片

Python 還允許一種從字串中提取子字串的索引語法形式，稱為字串切片。如果s是字串，則形式的表示式返回以 position 開頭 s[m:n] 的部分。

>>> s = 'foobar'
>>> s[2:5]
'oba'

省略第一個索引，則切片從字串的開頭開始。因此s[:m]和s[0:m]是等價的。

>>> s = 'foobar'

>>> s[:4]
'foob'
>>> s[0:4]
'foob'

省略第二個索引s[n:]，則切片從第一個索引延伸到字串的末尾。

>>> s = 'foobar'

>>> s[2:]
'obar'
>>> s[2:len(s)]
'obar'

對於任何字串s和任何整數n( 0 ≤ n ≤ len(s))，s[:n] + s[n:]將等於s。

>>> s = 'foobar'

>>> s[:4] + s[4:]
'foobar'
>>> s[:4] + s[4:] == s
True

省略兩個索引會返回完整的原始字串。

>>> s = 'foobar'
>>> t = s[:]
>>> id(s)
59598496
>>> id(t)
59598496
>>> s is t
True

字串切片中的步幅

對於 string ‘foobar’，切片0:6:2從第一個字元開始，到最後一個字元（整個字串）結束，並且每隔一個字元被跳過。

1:6:2指定從第二個字元（索引1）開始並以最後一個字元結束的切片，並且步幅值再次2導致每隔一個字元被跳過。

>>> s = 'foobar'

>>> s[0:6:2]
'foa'

>>> s[1:6:2]
'obr'

第一個和第二個索引可以省略，並分別預設為第一個和最後一個字元。

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'

也可以指定一個負的步幅值，Python 會向後遍歷字串，開始/第一個索引應該大於結束/第二個索引。

>>> s = 'foobar'
>>> s[5:0:-2]
'rbo'

第一個索引預設為字串的末尾，第二個索引預設為開頭。

>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::-5]
'55555'

將變數插入字串

f-strings 提供的格式化功能非常廣泛，後面還有一個關於格式化輸出的教學。

顯示算術計算的結果。可以用一個簡單的 print() 語句來做到這一點，用逗號分隔數值和字串文字。

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print('The product of', n, 'and', m, 'is', prod)
The product of 20 and 25 is 500

使用 f-string 重鑄，上面的範例看起來更清晰。

>>> n = 20
>>> m = 25
>>> prod = n * m
>>> print(f'The product of {n} and {m} is {prod}')
The product of 20 and 25 is 500

Python 的三種參照機制中的任何一種都可用於定義 f 字串。

>>> var = 'Bark'

>>> print(f'A dog says {var}!')
A dog says Bark!
>>> print(f"A dog says {var}!")
A dog says Bark!
>>> print(f'''A dog says {var}!''')
A dog says Bark!

修改字串

字串是 Python 認為不可變的資料型別之一，修改會導致錯誤。

>>> s = 'foobar'
>>> s[3] = 'x'
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    s[3] = 'x'
TypeError: 'str' object does not support item assignment

可以通過生成具有所需更改的原始字串的副本來輕鬆完成所需的操作。

>>> s = s[:3] + 'x' + s[4:]
>>> s
'fooxar'

可以使用內建的字串方法完成修改操作。

>>> s = 'foobar'
>>> s = s.replace('b', 'x')
>>> s
'fooxar'

內建字串方法

Python 程式中的每一項資料都是一個物件。

dir會返回一個內建方法與屬性列表。

>>> dir('a,b,cdefg')
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

方法類似於函數。方法是與物件緊密關聯的一種特殊型別的可呼叫過程。像函數一樣，呼叫方法來執行不同的任務，但它是在特定物件上呼叫的，並且在執行期間知道其目標物件。

目標字串執行大小寫轉換應用舉例

s.capitalize() 將目標字串大寫

# 返回第一個字元轉換為大寫，所有其他字元轉換為小寫的副本
>>> s = 'foO BaR BAZ quX'
>>> s.capitalize()
'Foo bar baz qux'
# 非字母字元不變
>>> s = 'foo123#BAR#.'
>>> s.capitalize()
'Foo123#bar#.'

s.lower() 將字母字元轉換為小寫

# 返回所有字母字元都轉換為小寫的副本
>>> 'FOO Bar 123 baz qUX'.lower()
'foo bar 123 baz qux'

s.swapcase() 交換字母字元的大小寫

# 返回將大寫字母字元轉換為小寫字母的副本，s反之亦然
>>> 'FOO Bar 123 baz qUX'.swapcase()
'foo bAR 123 BAZ Qux'

**s.title() 將目標字串轉換為標題大小寫 **

# 返回一個副本，s其中每個單詞的第一個字母轉換為大寫，其餘字母為小寫
>>> 'the sun also rises'.title()
'The Sun Also Rises'

s.upper() 將字母字元轉換為大寫

# 返回所有字母字元都轉換為大寫的副本
>>> 'FOO Bar 123 baz qUX'.upper()
'FOO BAR 123 BAZ QUX'

查詢和替換方法應用舉例

s.count(,[<start>,<end>]) 計算目標字串中子字串的出現次數

# 返回字串中非重疊出現的<sub>次數
>>> 'foo goo moo'.count('oo')
3
# 指定切片位置
>>> 'foo goo moo'.count('oo', 0, 8)
2

s.endswith(<suffix>,[<start>,<end>]) 確定目標字串是否以給定的子字串結尾

# s.endswith(<suffix>)如果s以指定的結尾則返回True，否則返回False
>>> 'foobar'.endswith('bar')
True
>>> 'foobar'.endswith('baz')
False
# 指定切片位置
>>> 'foobar'.endswith('oob', 0, 4)
True
>>> 'foobar'.endswith('oob', 2, 4)
False

s.find(,[<start>,<end>]) 在目標字串中搜尋給定的子字串

# 返回找到子字串s.find(<sub>)的索引
>>> 'foo bar foo baz foo qux'.find('foo')
0
# 如果未找到指定的子字串，則此方法返回-1
>>> 'foo bar foo baz foo qux'.find('grault')
-1
# 指定切片位置
>>> 'foo bar foo baz foo qux'.find('foo', 4)
8
>>> 'foo bar foo baz foo qux'.find('foo', 4, 7)
-1

s.index(,[<start>,<end>]) 在目標字串中搜尋給定的子字串

# 和find相同，但是未找到會引發異常
>>> 'foo bar foo baz foo qux'.index('grault')
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    'foo bar foo baz foo qux'.index('grault')
ValueError: substring not found

s.rfind(,[<start>,<end>]) 從末尾開始搜尋給定子字串的目標字串

# 返回找到子字串的最高索引
>>> 'foo bar foo baz foo qux'.rfind('foo')
16
# 未找到子字串則返回-1
>>> 'foo bar foo baz foo qux'.rfind('grault')
-1
# 指定切片位置
>>> 'foo bar foo baz foo qux'.rfind('foo', 0, 14)
8
>>> 'foo bar foo baz foo qux'.rfind('foo', 10, 14)
-1

s.rindex(,[<start>,<end>]) 從末尾開始搜尋給定子字串的目標字串

# 和rfind相同，但是未找到會引發異常
>>> 'foo bar foo baz foo qux'.rindex('grault')
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    'foo bar foo baz foo qux'.rindex('grault')
ValueError: substring not found

s.startswith(<prefix>,[<start>,<end>]) 確定目標字串是否以給定的子字串開頭

# 返回判斷是否以字串<suffix>開頭的結果
>>> 'foobar'.startswith('foo')
True
>>> 'foobar'.startswith('bar')
False
# 指定切片位置
>>> 'foobar'.startswith('bar', 3)
True
>>> 'foobar'.startswith('bar', 3, 2)
False

字元分類方法應用舉例

s.isalnum() 確定目標字串是否由字母數位字元組成

# 如果s為非空且其所有字元都是字母數位（字母或數位）返回True
>>> 'abc123'.isalnum()
True
>>> 'abc$123'.isalnum()
False
>>> ''.isalnum()
False

s.isalpha() 確定目標字串是否由字母字元組成

# s為非空且其所有字元都是字母則返回True
>>> 'ABCabc'.isalpha()
True
>>> 'abc123'.isalpha()
False

s.isdigit() 確定目標字串是否由數位字元組成

# 如果為非空且其所有字元都是數位則返回True
>>> '123'.isdigit()
True
>>> '123abc'.isdigit()
False

s.isidentifier() 確定目標字串是否是有效的 Python 識別符號

# 有效的 Python 識別符號返回True
>>> 'foo32'.isidentifier()
True
>>> '32foo'.isidentifier()
False
>>> 'foo$32'.isidentifier()
False

s.islower() 確定目標字串的字母字元是否為小寫

# 非空並且它包含的所有字母字元都是小寫則返回True
>>> 'abc'.islower()
True
>>> 'abc1$d'.islower()
True
>>> 'Abc1$D'.islower()
False

s.isprintable() 確定目標字串是否完全由可列印字元組成

# 為空或包含的所有字母字元都是可列印的則返回True
>>> 'atb'.isprintable()
False
>>> 'a b'.isprintable()
True
>>> ''.isprintable()
True
>>> 'anb'.isprintable()
False

s.isspace() 確定目標字串是否由空白字元組成

# 為非空且所有字元都是空白字元則返回True
>>> ' t n '.isspace()
True
>>> '   a   '.isspace()
False
#  ASCII 字元可以作為空格
>>> 'fu2005r'.isspace()
True

s.istitle() 確定目標字串是否為標題大小寫

# 則返回每個單詞的第一個字母字元為大寫，並且每個單詞中的所有其他字母字元均為小寫為True
>>> 'This Is A Title'.istitle()
True
>>> 'This is a title'.istitle()
False
>>> 'Give Me The #$#@ Ball!'.istitle()
True

s.isupper() 確定目標字串的字母字元是否為大寫

# 為非空並且它包含的所有字母字元都是大寫則返回True
>>> 'ABC'.isupper()
True
>>> 'ABC1$D'.isupper()
True
>>> 'Abc1$D'.isupper()
False

字串格式方法應用舉例

s.center(<width>,[<fill>]) 使欄位中的字串居中

# 返回一個由以寬度為中心的欄位組成的字串<width>
>>> 'foo'.center(10)
'   foo    '
# 指定填充字元
>>> 'bar'.center(10, '-')
'---bar----'
# 字元長度小於指定返回原字元
>>> 'foo'.center(2)
'foo'

s.expandtabs(tabsize=8) 展開字串中的製表符

# 將每個製表符 ( 't') 替換為空格
>>> 'atbtc'.expandtabs()
'a       b       c'
>>> 'aaatbbbtc'.expandtabs()
'aaa     bbb     c'
# tabsize指定備用製表位列
>>> 'atbtc'.expandtabs(4)
'a   b   c'
>>> 'aaatbbbtc'.expandtabs(tabsize=4)
'aaa bbb c'

s.ljust(,[<fill>]) 左對齊欄位中的字串

# 返回一個由寬度為左對齊的欄位組成的字串<width>
>>> 'foo'.ljust(10)
'foo       '
# 指定填充字元
>>> 'foo'.ljust(10, '-')
'foo-------'
# 字元長度小於指定返回原字元
>>> 'foo'.ljust(2)
'foo'

s.lstrip([<chars>]) 修剪字串中的前導字元

# 返回從左端刪除任何空白字元的副本
>>> '   foo bar baz   '.lstrip()
'foo bar baz   '
>>> 'tnfootnbartnbaz'.lstrip()
'footnbartnbaz'

s.replace(<old>, <new>[, <count>]) 替換字串中出現的子字串

# 返回所有出現的子字串替換為s.replace(<old>, <new>)的副本
>>> 'foo bar foo baz foo qux'.replace('foo', 'grault')
'grault bar grault baz grault qux'
# <count>引數指定替換數
>>> 'foo bar foo baz foo qux'.replace('foo', 'grault', 2)
'grault bar grault baz foo qux'

s.rjust(<width>, [<fill>]) 右對齊欄位中的字串

# 返回一個由寬度欄位右對齊組成的字串<width>
>>> 'foo'.rjust(10)
'       foo'
# 指定填充字元
>>> 'foo'.rjust(10, '-')
'-------foo'
# 字元長度小於指定返回原字元
>>> 'foo'.rjust(2)
'foo'

s.rstrip([<chars>]) 修剪字串中的尾隨字元

# 返回從右端刪除任何空白字元的副本
>>> '   foo bar baz   '.rstrip()
'   foo bar baz'
>>> 'footnbartnbaztn'.rstrip()
'footnbartnbaz'
# 指定刪除字元集
>>> 'foo.$$$;'.rstrip(';$.')
'foo'

s.strip([<chars>]) 從字串的左右兩端去除字元

# 同時呼叫s.lstrip()和s.rstrip()
>>> s = '   foo bar bazttt'
>>> s = s.lstrip()
>>> s = s.rstrip()
>>> s
'foo bar baz'
# 指定刪除字元集
>>> 'www.realpython.com'.strip('w.moc')
'realpython'

s.zfill(<width>) 用零填充左側的字串

# 將左填充'0'字元的副本返回到指定的<width>
>>> '42'.zfill(5)
'00042'
# 如果包含符號仍保留
>>> '+42'.zfill(8)
'+0000042'
>>> '-42'.zfill(8)
'-0000042'
# 字元長度小於指定返回原字元
>>> '-42'.zfill(3)
'-42'

順序集合 iterables 字串和列表之間的轉換方法應用舉例

s.join(<iterable>) 連線來自可迭代物件的字串

# 返回由分隔的物件連線得到的字串
>>> ', '.join(['foo', 'bar', 'baz', 'qux'])
'foo, bar, baz, qux'
# 字串的操作
>>> list('corge')
['c', 'o', 'r', 'g', 'e']
>>> ':'.join('corge')
'c:o:r:g:e'
# list中的資料必須是字串
>>> '---'.join(['foo', 23, 'bar'])
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    '---'.join(['foo', 23, 'bar'])
TypeError: sequence item 1: expected str instance, int found
>>> '---'.join(['foo', str(23), 'bar'])
'foo---23---bar'

s.partition(<sep>) 根據分隔符劃分字串

# 返回值是一個由三部分組成的元組:<sep>前、<sep>本身、<sep>後
>>> 'foo.bar'.partition('.')
('foo', '.', 'bar')
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')
# 如果未找到則返回2個空字元
>>> 'foo.bar'.partition('@@')
('foo.bar', '', '')

s.rpartition(<sep>) 根據分隔符劃分字串

# 與s.partition(<sep>)相同，用於指定最後一次拆分符
>>> 'foo@@bar@@baz'.partition('@@')
('foo', '@@', 'bar@@baz')
>>> 'foo@@bar@@baz'.rpartition('@@')
('foo@@bar', '@@', 'baz')

s.rsplit(sep=None, maxsplit=-1) 將字串拆分為子字串列表

# 返回拆分為由任何空格序列分隔的子字串，並將子字串作為列表
>>> 'foo bar baz qux'.rsplit()
['foo', 'bar', 'baz', 'qux']
>>> 'foontbar   bazrfqux'.rsplit()
['foo', 'bar', 'baz', 'qux']
# 指定拆分符
>>> 'foo.bar.baz.qux'.rsplit(sep='.')
['foo', 'bar', 'baz', 'qux']
# 指定最多拆分次數
>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=1)
['www.realpython', 'com']
>>> 'www.realpython.com'.rsplit(sep='.', maxsplit=-1)
['www', 'realpython', 'com']
>>> 'www.realpython.com'.rsplit(sep='.')
['www', 'realpython', 'com']

s.split(sep=None, maxsplit=-1) 將字串拆分為子字串列表

# 與s.rsplit()一樣，指定<maxsplit>則從左端而不是右端計算拆分
>>> 'www.realpython.com'.split('.', maxsplit=1)
['www', 'realpython.com']
>>> 'www.realpython.com'.rsplit('.', maxsplit=1)
['www.realpython', 'com']

s.splitlines([<keepends>]) 在行邊界處斷開字串

# 返回換行符切分的列表，其中包含n、r、rn、v or x0b、f or x0c、x1c、x1d、x1e、x85、u2028、u2029
>>> 'foonbarrnbazfquxu2028quux'.splitlines()
['foo', 'bar', 'baz', 'qux', 'quux']
# 同時存在多個空白行
>>> 'foofffbar'.splitlines()
['foo', '', '', 'bar']
# 也可以保留行邊界符號
>>> 'foonbarnbaznqux'.splitlines(True)
['foon', 'barn', 'bazn', 'qux']
>>> 'foonbarnbaznqux'.splitlines(1)
['foon', 'barn', 'bazn', 'qux']

bytes物件

物件是操作二進位制資料的bytes核心內建型別之一。bytes物件是不可變的單位元組值序列。

定義文字bytes物件

文字的bytes定義方式與新增’b’字首的字串文字相同。

>>> b = b'foo bar baz'
>>> b
b'foo bar baz'
>>> type(b)
<class 'bytes'>

可以使用任何單引號、雙引號或三引號機制。

>>> b'Contains embedded "double" quotes'
b'Contains embedded "double" quotes'

>>> b"Contains embedded 'single' quotes"
b"Contains embedded 'single' quotes"

>>> b'''Contains embedded "double" and 'single' quotes'''
b'Contains embedded "double" and 'single' quotes'

>>> b"""Contains embedded "double" and 'single' quotes"""
b'Contains embedded "double" and 'single' quotes'

'r’字首可以用在文字上以禁用跳脫序列的bytes處理。

>>> b = rb'fooxddbar'
>>> b
b'foo\xddbar'
>>> b[3]
92
>>> chr(92)
'\'

bytes使用內建bytes()函數定義物件

bytes()函數還建立一個bytes物件。返回什麼樣的bytes物件取決於傳遞給函數的引數。

bytes(<s>, <encoding>) bytes從字串建立物件

# 根據指定的使用將字串轉換<s>為bytes物件
>>> b = bytes('foo.bar', 'utf8')
>>> b
b'foo.bar'
>>> type(b)
<class 'bytes'>

bytes(<size>) 建立一個bytes由 null ( 0x00) 位元組組成的物件

# 定義bytes指定的物件<size>必須是一個正整數。
>>> b = bytes(8)
>>> b
b'x00x00x00x00x00x00x00x00'
>>> type(b)
<class 'bytes'>

bytes() bytes從可迭代物件建立物件

# 生成的整數序列中定義一個物件<iterable> n0 ≤ n ≤ 255
>>> b = bytes([100, 102, 104, 106, 108])
>>> b
b'dfhjl'
>>> type(b)
<class 'bytes'>
>>> b[2]
104

bytes物件操作，操作參考字串。

運運算元 in 和 not in

>>> b = b'abcde'
>>> b'cd' in b
True
>>> b'foo' not in b
True

*連線 ( +) 和複製 ( ) 運運算元

>>> b = b'abcde'
>>> b + b'fghi'
b'abcdefghi'
>>> b * 3
b'abcdeabcdeabcde'

索引和切片

>>> b = b'abcde'
>>> b[2]
99
>>> b[1:3]
b'bc'

內建功能

>>> b = b'foo,bar,foo,baz,foo,qux'
>>> len(b)
23
>>> min(b)
44
>>> max(b)
122
>>> b = b'foo,bar,foo,baz,foo,qux'
>>> b.count(b'foo')
3
>>> b.endswith(b'qux')
True
>>> b.find(b'baz')
12
>>> b.split(sep=b',')
[b'foo', b'bar', b'foo', b'baz', b'foo', b'qux']
>>> b.center(30, b'-')
b'---foo,bar,foo,baz,foo,qux----'
>>> b[2:3]
b'o'
>>> list(b)
[102, 111, 111, 44, 98, 97, 114, 44, 102, 111, 111, 44, 98, 97, 122, 44, 102, 111, 111, 44, 113, 117, 120]

bytes.fromhex(<s>) 返回bytes從一串十六進位制值構造的物件

# 返回bytes將每對十六進位制數位轉換<s>為相應位元組值的物件
>>> b = bytes.fromhex(' aa 68 4682cc ')
>>> b
b'xaahFx82xcc'
>>> list(b)
[170, 104, 70, 130, 204]

b.hex() bytes從物件返回一串十六進位制值

# 將bytes物件b轉換為十六進位制數位對字串的結果,與.fromhex()相反
>>> b = bytes.fromhex(' aa 68 4682cc ')
>>> b
b'xaahFx82xcc'

>>> b.hex()
'aa684682cc'
>>> type(b.hex())
<class 'str'>

bytearray物件，Python 支援的另一種二進位制序列型別

bytearray始終使用內建函數建立物件bytearray()

>>> ba = bytearray('foo.bar.baz', 'UTF-8')
>>> ba
bytearray(b'foo.bar.baz')
>>> bytearray(6)
bytearray(b'x00x00x00x00x00x00')
>>> bytearray([100, 102, 104, 106, 108])
bytearray(b'dfhjl')

bytearray物件是可變的，可以使用索引和切片修改物件的內容

>>> ba = bytearray('foo.bar.baz', 'UTF-8')
>>> ba
bytearray(b'foo.bar.baz')
>>> ba[5] = 0xee
>>> ba
bytearray(b'foo.bxeer.baz')
>>> ba[8:11] = b'qux'
>>> ba
bytearray(b'foo.bxeer.qux')

bytearray物件也可以直接從物件構造bytes

>>> ba = bytearray(b'foo')
>>> ba
bytearray(b'foo')

以上就是Python必備技巧之字元資料操作詳解的詳細內容，更多關於Python字元資料操作的資料請關注it145.com其它相關文章！