Python 字串總結,建議收藏!

語言: CN / TW / HK

什麼是 Python 字串

字串是包含一系列字元的物件。字元是長度為 1 的字串。在 Python 中,單個字元也是字串。但是比較有意思的是,Python 程式語言中是沒有字元資料型別的,不過在 C、Kotlin 和 Java 等其他程式語言中是存在字元資料型別的

我們可以使用單引號、雙引號、三引號或 str() 函式來宣告 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() 函式。input() 函式允許我們使用鍵盤將輸入的值插入到程式中。插入的值被讀取為字串,但我們可以將它們轉換為其他資料型別:

# 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() 函式來確定 Python 中物件的資料型別,它返回物件的類。當物件是字串時,它返回 str 類。同樣,當物件是字典、整數、浮點數、元組或布林值時,它分別返回 dict、int、float、tuple、bool 類。現在讓我們使用 type() 函式來確定前面程式碼片段中宣告的變數的資料型別:

# 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 字串字元

美國資訊交換標準程式碼 (ASCII) 旨在幫助我們將字元或文字對映到數字,因為數字集比文字更容易儲存在計算機記憶體中。ASCII 主要用英語對 128 個字元進行編碼,用於處理計算機和程式設計中的資訊。ASCII 編碼的英文字元包括小寫字母(a-z)、大寫字母(A-Z)、數字(0-9)以及標點符號等符號

ord() 函式將長度為 1(一個字元)的 Python 字串轉換為其在 ASCII 表上的十進位制表示,而 chr() 函式將十進位制表示轉換回字串。例如:

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:

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

在上面的程式碼片段中,我們遍歷字串 ABCDE 和 01234,並將每個字元轉換為它們在 ASCII 表中的十進位制表示。我們還可以使用 chr() 函式執行反向操作,從而將 ASCII 表上的十進位制數字轉換為它們的 Python 字串字元。例如:

decimal_rep_ascii = [37, 44, 63, 82, 100]
for one_decimal in decimal_rep_ascii:
    print(chr(one_decimal))

Output:

%
,
?
R
d

在 ASCII 表中,上述程式輸出中的字串字元對映到它們各自的十進位制數

字串屬性

零索引: 字串中的第一個元素的索引為零,而最後一個元素的索引為 len(string) - 1。例如:

immutable_string = "Accountability"
print(len(immutable_string))
print(immutable_string.index('A'))
print(immutable_string.index('y'))

Output:

不變性: 這意味著我們不能更新字串中的字元。例如我們不能從字串中刪除一個元素或嘗試在其任何索引位置分配一個新元素。如果我們嘗試更新字串,它會丟擲 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 變數,不過我們應該注意它們不是同一個字串,因為它們不指向記憶體中的同一個物件。Python 不會更新舊的字串物件;它建立了一個新的,正如我們通過 ids 看到的那樣:

immutable_string = "Accountability"
print(id(immutable_string))
immutable_string = "Bccountability"
print(id(immutable_string)
test_immutable = immutable_string
print(id(test_immutable))

Output:

上述兩個 id 在同一臺計算機上也不相同,這意味著兩個 immutable_string 變數都指向記憶體中的不同地址。我們將最後一個 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

重複: 字串可以用 * 符號重複。例如:

print("Ha" * 3)

Output:

HaHaHa

索引和切片: 我們已經確定字串是從零開始索引的,我們可以使用其索引值訪問字串中的任何元素。我們還可以通過在兩個索引值之間進行切片來獲取字串的子集。例如:

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。當使用其預設值呼叫此方法時,它會在任何有空格的地方拆分字串。此方法返回字串列表:

string = "Apple, Banana, Orange, Blueberry"
print(string.split())

Output:

['Apple,', 'Banana,', 'Orange,', 'Blueberry']

我們可以看到字串沒有很好地拆分,因為拆分的字串包含 ,。我們可以使用 sep=',' 在有 , 的地方進行拆分:

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

現在字串被很好地分割了。有時我們不想分割最大次數,我們可以使用 maxsplit 屬性來指定我們打算拆分的次數:

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 方法來執行此操作。當 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 方法從字串的兩側刪除尾隨空格或字元。例如:

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 方法,它們分別從字串的左側和右側刪除尾隨空格或字元。我們還使用了 capitalize 方法,它將字串轉換為句子大小寫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.8

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

如果字串字元是字母數字,str.isalnum() 返回 True;如果字串字元是十進位制,str.isdecimal() 返回 True;如果字串字元是數字,str.isdigit() 返回 True;如果字串字元是數字,則 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
True

str.endswith(suffix) 返回 True 是以指定字尾結尾的字串。如果字串以指定的字首開頭,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
True

str.find(substring) 如果子字串存在於字串中,則返回最低索引;否則它返回 -1。str.rfind(substring) 返回最高索引。如果找到,str.index(substring) 和 str.rindex(substring) 也分別返回子字串的最低和最高索引。如果字串中不存在子字串,則會引發 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 found

str.maketrans(dict_map) 從字典對映建立一個翻譯表,str.translate(maketrans) 用它們的新值替換翻譯中的元素。例如:

example = "abcde"
mapped = {'a':'1', 'b':'2', 'c':'3', 'd':'4', 'e':'5'}
print(example.translate(example.maketrans(mapped)))

Output:

字串操作

迴圈遍歷一個字串

字串是可迭代的,因此它們支援使用 for 迴圈和列舉的迴圈操作:

# 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

字串和關係運算符

當使用關係運算符(>、<、== 等)比較兩個字串時,兩個字串的元素按其 ASCII 十進位制數字逐個索引進行比較。例如:

print('a' > 'b')
print('abc' > 'b')

Output:

False
False

在這兩種情況下,輸出都是 False。關係運算符首先比較兩個字串的索引 0 上元素的 ASCII 十進位制數。由於 b 大於 a,因此返回 False;在這種情況下,其他元素的 ASCII 十進位制數字和字串的長度無關緊要

當字串長度相同時,它比較從索引 0 開始的每個元素的 ASCII 十進位制數,直到找到具有不同 ASCII 十進位制數的元素。例如:

print('abd' > 'abc')

Output:

True

檢查字串的成員資格

in 運算子用於檢查子字串是否是字串的成員:

print('data' in 'dataquest')
print('gram' in 'programming')

Output:

True
True

檢查字串成員資格、替換子字串或匹配模式的另一種方法是使用正則表示式

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 Wednesday

f-strings 更具可讀性,並且它們比 str.format() 方法實現得更快。因此,f-string 是字串格式化的首選方法

處理引號和撇號

撇號 (') 在 Python 中表示一個字串。為了讓 Python 知道我們不是在處理字串,我們必須使用 Python 轉義字元 ()。因此撇號在 Python 中表示為 '。與處理撇號不同,Python 中有很多處理引號的方法。它們包括以下內容:

# 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

寫在最後

字串作為程式語言當中最為常見的資料型別,熟練而靈活的掌握其各種屬性和方法,實在是太重要了,小夥伴們千萬要實時溫習,處處留心哦!

好了,這就是今天分享的內容,如果喜歡就點個贊吧~