Python 字符串深度總結(jié)
今天我們來學(xué)習(xí)字符串?dāng)?shù)據(jù)類型相關(guān)知識，將討論如何聲明字符串?dāng)?shù)據(jù)類型，字符串?dāng)?shù)據(jù)類型與 ASCII 表的關(guān)系，字符串?dāng)?shù)據(jù)類型的屬性，以及一些重要的字符串方法和操作，超級干貨，不容錯過！
什么是 Python 字符串
字符串是包含一系列字符的對象。字符是長度為 1 的字符串。在 Python 中，單個字符也是字符串。但是比較有意思的是，Python 編程語言中是沒有字符數(shù)據(jù)類型的，不過在 C、Kotlin 和 Java 等其他編程語言中是存在字符數(shù)據(jù)類型的。
我們可以使用單引號、雙引號、三引號或 str() 函數(shù)來聲明 Python 字符串。下面的代碼片段展示了如何在 Python 中聲明一個字符串：
# A single quote string
single_quote = 'a' # This is an example of a character in other programming languages. It is a string in Python
# Another single quote string
another_single_quote = 'Programming teaches you patience.'
# A double quote string
double_quote = "aa"
# Another double-quote string
another_double_quote = "It is impossible until it is done!"
# A triple quote string
triple_quote = '''aaa'''
# Also a triple quote string
another_triple_quote = """Welcome to the Python programming language. Ready, 1, 2, 3, Go!"""
# Using the str() function
string_function = str(123.45) # str() converts float data type to string data type
# Another str() function
another_string_function = str(True) # str() converts a boolean data type to string data type
# An empty string
empty_string = ''
# Also an empty string
second_empty_string = ""
# We are not done yet
third_empty_string = """""" # This is also an empty string: ''''''在 Python 中獲取字符串的另一種方法是使用 input() 函數(shù)。input() 函數(shù)允許我們使用鍵盤將輸入的值插入到程序中。插入的值被讀取為字符串，但我們可以將它們轉(zhuǎn)換為其他數(shù)據(jù)類型：
# Inputs into a Python program
input_float = input() # Type in: 3.142
input_boolean = input() # Type in: True
# Convert inputs into other data types
convert_float = float(input_float) # converts the string data type to a float
convert_boolean = bool(input_boolean) # converts the string data type to a bool我們使用 type() 函數(shù)來確定 Python 中對象的數(shù)據(jù)類型，它返回對象的類。當(dāng)對象是字符串時，它返回 str 類。同樣，當(dāng)對象是字典、整數(shù)、浮點(diǎn)數(shù)、元組或布爾值時，它分別返回 dict、int、float、tuple、bool 類?，F(xiàn)在讓我們使用 type() 函數(shù)來確定前面代碼片段中聲明的變量的數(shù)據(jù)類型：
# Data types/ classes with type()
print(type(single_quote))
print(type(another_triple_quote))
print(type(empty_string))
print(type(input_float))
print(type(input_boolean))
print(type(convert_float))
print(type(convert_boolean))ASCII 表與 Python 字符串字符
美國信息交換標(biāo)準(zhǔn)代碼 (ASCII) 旨在幫助我們將字符或文本映射到數(shù)字，因?yàn)閿?shù)字集比文本更容易存儲在計算機(jī)內(nèi)存中。ASCII 主要用英語對 128 個字符進(jìn)行編碼，用于處理計算機(jī)和編程中的信息。ASCII 編碼的英文字符包括小寫字母（a-z）、大寫字母（A-Z）、數(shù)字（0-9）以及標(biāo)點(diǎn)符號等符號
ord() 函數(shù)將長度為 1（一個字符）的 Python 字符串轉(zhuǎn)換為其在 ASCII 表上的十進(jìn)制表示，而 chr() 函數(shù)將十進(jìn)制表示轉(zhuǎn)換回字符串。例如：
import string
# Convert uppercase characters to their ASCII decimal numbers
ascii_upper_case = string.ascii_uppercase # Output: ABCDEFGHIJKLMNOPQRSTUVWXYZ
for one_letter in ascii_upper_case[:5]: # Loop through ABCDE
print(ord(one_letter))Output:
65
66
67
68
69# Convert digit characters to their ASCII decimal numbers
ascii_digits = string.digits # Output: 0123456789
for one_digit in ascii_digits[:5]: # Loop through 01234
print(ord(one_digit))Output:
48
49
50
51
52在上面的代碼片段中，我們遍歷字符串 ABCDE 和 01234，并將每個字符轉(zhuǎn)換為它們在 ASCII 表中的十進(jìn)制表示。我們還可以使用 chr() 函數(shù)執(zhí)行反向操作，從而將 ASCII 表上的十進(jìn)制數(shù)字轉(zhuǎn)換為它們的 Python 字符串字符。例如：
decimal_rep_ascii = [37, 44, 63, 82, 100]
for one_decimal in decimal_rep_ascii:
print(chr(one_decimal))Output:
%
,
?
R
d在 ASCII 表中，上述程序輸出中的字符串字符映射到它們各自的十進(jìn)制數(shù)
字符串屬性
零索引： 字符串中的第一個元素的索引為零，而最后一個元素的索引為 len(string) - 1。例如：
immutable_string = "Accountability"
print(len(immutable_string))
print(immutable_string.index('A'))
print(immutable_string.index('y'))Output:
14
0
13不變性： 這意味著我們不能更新字符串中的字符。例如我們不能從字符串中刪除一個元素或嘗試在其任何索引位置分配一個新元素。如果我們嘗試更新字符串，它會拋出 TypeError：
immutable_string = "Accountability"
# Assign a new element at index 0
immutable_string[0] = 'B'Output:
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_11336/2351953155.py in
2
3 # Assign a new element at index 0
----> 4 immutable_string[0] = 'B'
TypeError: 'str' object does not support item assignment但是我們可以將字符串重新分配給 immutable_string 變量，不過我們應(yīng)該注意它們不是同一個字符串，因?yàn)樗鼈儾恢赶騼?nèi)存中的同一個對象。Python 不會更新舊的字符串對象；它創(chuàng)建了一個新的，正如我們通過 ids 看到的那樣：
immutable_string = "Accountability"
print(id(immutable_string))
immutable_string = "Bccountability"
print(id(immutable_string)
test_immutable = immutable_string
print(id(test_immutable))Output:
2693751670576
2693751671024
2693751671024上述兩個 id 在同一臺計算機(jī)上也不相同，這意味著兩個 immutable_string 變量都指向內(nèi)存中的不同地址。我們將最后一個 immutable_string 變量分配給 test_immutable 變量?？梢钥吹?test_immutable 變量和最后一個 immutable_string 變量指向同一個地址
連接： 將兩個或多個字符串連接在一起以獲得帶有 + 符號的新字符串。例如：
first_string = "Zhou"
second_string = "luobo"
third_string = "Learn Python"
fourth_string = first_string + second_string
print(fourth_string)
fifth_string = fourth_string + " " + third_string
print(fifth_string)Output:
Zhouluobo
Zhouluobo Learn Python重復(fù)： 字符串可以用 * 符號重復(fù)。例如：
print("Ha" * 3)Output:
HaHaHa索引和切片： 我們已經(jīng)確定字符串是從零開始索引的，我們可以使用其索引值訪問字符串中的任何元素。我們還可以通過在兩個索引值之間進(jìn)行切片來獲取字符串的子集。例如：
main_string = "I learned English and Python with ZHouluobo. You can do it too!"
# Index 0
print(main_string[0])
# Index 1
print(main_string[1])
# Check if Index 1 is whitespace
print(main_string[1].isspace())
# Slicing 1
print(main_string[0:11])
# Slicing 2:
print(main_string[-18:])
# Slicing and concatenation
print(main_string[0:11] + ". " + main_string[-18:])Output:
I
True
I learned English
You can do it too!
I learned English. You can do it too!字符串方法
str.split(sep=None, maxsplit=-1)： 字符串拆分方法包含兩個屬性：sep 和 maxsplit。當(dāng)使用其默認(rèn)值調(diào)用此方法時，它會在任何有空格的地方拆分字符串。此方法返回字符串列表：
string = "Apple, Banana, Orange, Blueberry"
print(string.split())Output:
['Apple,', 'Banana,', 'Orange,', 'Blueberry']我們可以看到字符串沒有很好地拆分，因?yàn)椴鸱值淖址?nbsp;,。我們可以使用 sep=',' 在有 , 的地方進(jìn)行拆分：
print(string.split(sep=','))Output:
['Apple', ' Banana', ' Orange', ' Blueberry']這比之前的拆分要好，但是我們可以在一些拆分字符串之前看到空格。可以使用 (sep=', ') 刪除它：
# Notice the whitespace after the comma
print(string.split(sep=', '))Output:
['Apple', 'Banana', 'Orange', 'Blueberry']現(xiàn)在字符串被很好地分割了。有時我們不想分割最大次數(shù)，我們可以使用 maxsplit 屬性來指定我們打算拆分的次數(shù)：
print(string.split(sep=', ', maxsplit=1))
print(string.split(sep=', ', maxsplit=2))Output:
['Apple', 'Banana, Orange, Blueberry']
['Apple', 'Banana', 'Orange, Blueberry']str.splitlines(keepends=False)： 有時我們想處理一個在邊界處具有不同換行符（'\n'、\n\n'、'\r'、'\r\n'）的語料庫。我們要拆分成句子，而不是單個單詞?？梢允褂?splitline 方法來執(zhí)行此操作。當(dāng) keepends=True 時，文本中包含換行符；否則它們被排除在外
import nltk # You may have to `pip install nltk` to use this library.
macbeth = nltk.corpus.gutenberg.raw('shakespeare-macbeth.txt')
print(macbeth.splitlines(keepends=True)[:5])Output:
['[The Tragedie of Macbeth by William Shakespeare 1603]\n', '\n', '\n', 'Actus Primus. Scoena Prima.\n', '\n']str.strip([chars])： 我們使用 strip 方法從字符串的兩側(cè)刪除尾隨空格或字符。例如：
string = " Apple Apple Apple no apple in the box apple apple "
stripped_string = string.strip()
print(stripped_string)
left_stripped_string = (
stripped_string
.lstrip('Apple')
.lstrip()
.lstrip('Apple')
.lstrip()
.lstrip('Apple')
.lstrip()
)
print(left_stripped_string)
capitalized_string = left_stripped_string.capitalize()
print(capitalized_string)
right_stripped_string = (
capitalized_string
.rstrip('apple')
.rstrip()
.rstrip('apple')
.rstrip()
)
print(right_stripped_string)Output:
Apple Apple Apple no apple in the box apple apple
no apple in the box apple apple
No apple in the box apple apple
No apple in the box在上面的代碼片段中，我們使用了 lstrip 和 rstrip 方法，它們分別從字符串的左側(cè)和右側(cè)刪除尾隨空格或字符。我們還使用了 capitalize 方法，它將字符串轉(zhuǎn)換為句子大小寫str.zfill(width)： zfill 方法用 0 前綴填充字符串以獲得指定的寬度。例如：
example = "0.8" # len(example) is 3
example_zfill = example.zfill(5) # len(example_zfill) is 5
print(example_zfill)Output:
000.8str.isalpha()： 如果字符串中的所有字符都是字母，該方法返回True；否則返回 False：
# Alphabet string
alphabet_one = "Learning"
print(alphabet_one.isalpha())
# Contains whitspace
alphabet_two = "Learning Python"
print(alphabet_two.isalpha())
# Contains comma symbols
alphabet_three = "Learning,"
print(alphabet_three.isalpha())Output:
True
False
False如果字符串字符是字母數(shù)字，str.isalnum() 返回 True；如果字符串字符是十進(jìn)制，str.isdecimal() 返回 True；如果字符串字符是數(shù)字，str.isdigit() 返回 True；如果字符串字符是數(shù)字，則 str.isnumeric() 返回 True
如果字符串中的所有字符都是小寫，str.islower() 返回 True；如果字符串中的所有字符都是大寫，str.isupper() 返回 True；如果每個單詞的首字母大寫，str.istitle() 返回 True：
# islower() example
string_one = "Artificial Neural Network"
print(string_one.islower())
string_two = string_one.lower() # converts string to lowercase
print(string_two.islower())
# isupper() example
string_three = string_one.upper() # converts string to uppercase
print(string_three.isupper())
# istitle() example
print(string_one.istitle())Output:
False
True
True
Truestr.endswith(suffix) 返回 True 是以指定后綴結(jié)尾的字符串。如果字符串以指定的前綴開頭，str.startswith(prefix) 返回 True：
sentences = ['Time to master data science', 'I love statistical computing', 'Eat, sleep, code']
# endswith() example
for one_sentence in sentences:
print(one_sentence.endswith(('science', 'computing', 'Code')))Output:
True
True
False# startswith() example
for one_sentence in sentences:
print(one_sentence.startswith(('Time', 'I ', 'Ea')))Output:
True
True
Truestr.find(substring) 如果子字符串存在于字符串中，則返回最低索引；否則它返回 -1。str.rfind(substring) 返回最高索引。如果找到，str.index(substring) 和 str.rindex(substring) 也分別返回子字符串的最低和最高索引。如果字符串中不存在子字符串，則會引發(fā) ValueError
string = "programming"
# find() and rfind() examples
print(string.find('m'))
print(string.find('pro'))
print(string.rfind('m'))
print(string.rfind('game'))
# index() and rindex() examples
print(string.index('m'))
print(string.index('pro'))
print(string.rindex('m'))
print(string.rindex('game'))Output:
6
0
7
-1
6
0
7
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_11336/3954098241.py in
11 print(string.index('pro')) # Output: 0
12 print(string.rindex('m')) # Output: 7
---> 13 print(string.rindex('game')) # Output: ValueError: substring not found
ValueError: substring not foundstr.maketrans(dict_map) 從字典映射創(chuàng)建一個翻譯表，str.translate(maketrans) 用它們的新值替換翻譯中的元素。例如：
example = "abcde"
mapped = {'a':'1', 'b':'2', 'c':'3', 'd':'4', 'e':'5'}
print(example.translate(example.maketrans(mapped)))Output:
12345字符串操作
循環(huán)遍歷一個字符串
字符串是可迭代的，因此它們支持使用 for 循環(huán)和枚舉的循環(huán)操作：
# For-loop example
word = "bank"
for letter in word:
print(letter)Output:
b
a
n
k# Enumerate example
for idx, value in enumerate(word):
print(idx, value)Output:
0 b
1 a
2 n
3 k字符串和關(guān)系運(yùn)算符
當(dāng)使用關(guān)系運(yùn)算符（>、<、== 等）比較兩個字符串時，兩個字符串的元素按其 ASCII 十進(jìn)制數(shù)字逐個索引進(jìn)行比較。例如：
print('a' > 'b')
print('abc' > 'b')Output:
False
False在這兩種情況下，輸出都是 False。關(guān)系運(yùn)算符首先比較兩個字符串的索引 0 上元素的 ASCII 十進(jìn)制數(shù)。由于 b 大于 a，因此返回 False；在這種情況下，其他元素的 ASCII 十進(jìn)制數(shù)字和字符串的長度無關(guān)緊要
當(dāng)字符串長度相同時，它比較從索引 0 開始的每個元素的 ASCII 十進(jìn)制數(shù)，直到找到具有不同 ASCII 十進(jìn)制數(shù)的元素。例如：
print('abd' > 'abc')Output:
True檢查字符串的成員資格
in 運(yùn)算符用于檢查子字符串是否是字符串的成員：
print('data' in 'dataquest')
print('gram' in 'programming')Output:
True
True檢查字符串成員資格、替換子字符串或匹配模式的另一種方法是使用正則表達(dá)式
import re
substring = 'gram'
string = 'programming'
replacement = '1234'
# Check membership
print(re.search(substring, string))
# Replace string
print(re.sub(substring, replacement, string))Output:
pro1234ming字符串格式
f-string 和 str.format() 方法用于格式化字符串。兩者都使用大括號 {} 占位符。例如：
monday, tuesday, wednesday = "Monday", "Tuesday", "Wednesday"
format_string_one = "{} {} {}".format(monday, tuesday, wednesday)
print(format_string_one)
format_string_two = "{2} {1} {0}".format(monday, tuesday, wednesday)
print(format_string_two)
format_string_three = "{one} {two} {three}".format(one=tuesday, two=wednesday, three=monday)
print(format_string_three)
format_string_four = f"{monday} {tuesday} {wednesday}"
print(format_string_four)Output:
Monday Tuesday Wednesday
Wednesday Tuesday Monday
Tuesday Wednesday Monday
Monday Tuesday Wednesdayf-strings 更具可讀性，并且它們比 str.format() 方法實(shí)現(xiàn)得更快。因此，f-string 是字符串格式化的首選方法
處理引號和撇號
撇號 (') 在 Python 中表示一個字符串。為了讓 Python 知道我們不是在處理字符串，我們必須使用 Python 轉(zhuǎn)義字符 ()。因此撇號在 Python 中表示為 '。與處理撇號不同，Python 中有很多處理引號的方法。它們包括以下內(nèi)容：
# 1. Represent string with single quote (`""`) and quoted statement with double quote (`""`)
quotes_one = '"Friends don\'t let friends use minibatches larger than 32" - Yann LeCun'
print(quotes_one)
# 2. Represent string with double quote `("")` and quoted statement with escape and double quote `(\"statement\")`
quotes_two = "\"Friends don\'t let friends use minibatches larger than 32\" - Yann LeCun"
print(quotes_two)
# 3. Represent string with triple quote `("""""")` and quoted statment with double quote ("")
quote_three = """"Friends don\'t let friends use minibatches larger than 32" - Yann LeCun"""
print(quote_three)Output:
"Friends don't let friends use minibatches larger than 32" - Yann LeCun
"Friends don't let friends use minibatches larger than 32" - Yann LeCun
"Friends don't let friends use minibatches larger than 32" - Yann LeCun
