Python 中的字符串是一種不可變的序列類型，使用單引號(hào)（'）或雙引號(hào)（"）括起來。

在Python 3中，字符串默認(rèn)使用Unicode編碼，支持各種語言的字符集，包括中文、日文、韓文等。同時(shí)，Python 3中的字符串是不可變的，避免了傳統(tǒng)編程中的一些常見問題。

1. Python 字符串拼接：使用“+”或者“+=”進(jìn)行字符串的拼接。

字符串拼接是將兩個(gè)或多個(gè)字符串合并為一個(gè)字符串的過程。在Python中，可以使用“+”或者“+=”運(yùn)算符來進(jìn)行字符串拼接。

可以使用加號(hào)（+）或者join()方法來進(jìn)行字符串拼接

例如：

a = "hello"
b = " world"
c = a + "  " + b
print(c)  # 輸出：hello world

d = "good"
d += " bye"
print(d)  # 輸出：good bye

也可以使用*運(yùn)算符或者乘法操作符對字符串進(jìn)行復(fù)制。

例如，以下代碼可以將字符串a(chǎn)重復(fù)3次，并將結(jié)果賦值給字符串b：

a = "hello"
b = a * 3
print(b)  # 輸出：hellohellohello

join() 方法是Python中常用的字符串方法之一，它把字符串序列中的元素以指定的分隔符連接成一個(gè)新的字符串。 join() 方法需要一個(gè)可迭代對象（例如列表、元組等）作為參數(shù)，并返回一個(gè)新的字符串，其中序列中的元素被以指定的分隔符連接起來。 以下是一個(gè)簡單的示例，用逗號(hào)將列表中的字符串連接起來：

my_list = ['apple', 'banana', 'orange']
result = ','.join(my_list)
print(result)  # 輸出：apple,banana,orange

在上面的示例中，我們使用join()方法將列表元素連接起來，用逗號(hào)作為連接符，并將結(jié)果賦值給變量result。 最終的輸出為字符串'apple,banana,orange'。

2 字符串格式化

Python中字符串格式化是一種用于將變量插入到字符串中的方法。它允許我們創(chuàng)建一些帶有占位符的字符串，然后使用實(shí)際的值來替換這些占位符。

Python中有許多種字符串格式化的方式，其中最常用的方式是使用format()函數(shù)和百分號(hào)（%）操作符。

2.1 使用format()函數(shù)進(jìn)行字符串格式化

在使用format()函數(shù)進(jìn)行字符串格式化時(shí)，我們需要在字符串中使用一對花括號(hào)（{}）作為占位符，然后使用format()函數(shù)提供的參數(shù)來替換這些占位符。例如，以下代碼可以將變量name和age插入到字符串中：

name = "Tom"
age = 20
result = "My name is {}, and I'm {} years old.".format(name, age)
print(result)  # 輸出：My name is Tom, and I'm 20 years old.
  

在上面的例子中，我們使用format()函數(shù)來進(jìn)行字符串格式化。在字符串中，我們使用花括號(hào)作為占位符，并使用format()函數(shù)提供的參數(shù)來替換這些占位符。最終的輸出為字符串"My name is Tom, and I'm 20 years old."。

2.2 使用百分號(hào)（%）操作符進(jìn)行字符串格式化

除了使用format()函數(shù)進(jìn)行字符串格式化外，我們還可以使用百分號(hào)（%）操作符來進(jìn)行字符串格式化。

在這種方式中，我們需要指定占位符的類型（例如%s表示字符串，%d表示整數(shù)）以及實(shí)際的值。例如，以下代碼可以將變量name和age插入到字符串中：

name = "Tom"
age = 20
result = "My name is %s, and I'm %d years old." % (name, age)
print(result)  # 輸出：My name is Tom, and I'm 20 years old.

在上面的例子中，我們使用百分號(hào)（%）操作符來進(jìn)行字符串格式化。在字符串中，使用%s表示字符串占位符，使用%d表示整數(shù)占位符，并使用%運(yùn)算符后面的元組來提供實(shí)際的值。最終的輸出與上面使用format()函數(shù)進(jìn)行字符串格式化的輸出結(jié)果相同。

3 字符串切片：使用[]和[:]對字符串進(jìn)行切片操作。

在Python中，可以使用切片（slice）操作符來獲取字符串的一部分。

切片操作符的語法是 [start:stop:step]，其中start表示起始位置（默認(rèn)為0），stop表示結(jié)束位置（默認(rèn)為字符串的長度），step表示步長（默認(rèn)為1）。

以下是一個(gè)簡單的示例，展示如何使用切片操作符來獲取字符串的一部分：

s = "Hello, World!"
print(s[0:5])    # 輸出：Hello
print(s[7:12])   # 輸出：World
print(s[:5])     # 輸出：Hello（等同于s[0:5]）
print(s[7:])     # 輸出：World!（等同于s[7:len(s)]）
print(s[::2])    # 輸出：Hlo ol!（每隔一個(gè)字符取一個(gè)字符）

在上面的示例中，我們使用切片操作符來獲取字符串的一部分。 例如，s[0:5]表示從第0個(gè)字符開始（即第一個(gè)字符），取到第5個(gè)字符（不包括第5個(gè)字符），因此輸出的結(jié)果是字符串“Hello”。

s[7:12]則表示從第7個(gè)字符開始（即第8個(gè)字符），取到第12個(gè)字符（不包括第12個(gè)字符），因此輸出的結(jié)果是字符串“World”。

s[:5]表示從第0個(gè)字符開始（即第一個(gè)字符），取到第5個(gè)字符（不包括第5個(gè)字符），因此輸出的結(jié)果仍然是字符串“Hello”。

s[7:]表示從第7個(gè)字符開始（即第8個(gè)字符），一直取到字符串的最后一個(gè)字符，因此輸出的結(jié)果是字符串“World!”。

s[::2] 表示從第0個(gè)字符開始（即第一個(gè)字符），每隔一個(gè)字符（即步長為2）取一個(gè)字符，因此輸出的結(jié)果是字符串“Hlo ol!”。

4 字符串長度：使用len()函數(shù)獲取字符串的長度。

在 Python 中，可以使用 len() 函數(shù)來獲取字符串的長度。例如：

s = "Hello, World!"
length = len(s)
print(length)  # 輸出：13

在上面的例子中，我們首先創(chuàng)建了一個(gè)字符串 "Hello, World!"，然后使用 len() 函數(shù)獲取了它的長度，并將結(jié)果賦值給變量 length。最后，我們使用 print() 函數(shù)將長度輸出到控制臺(tái)中。注意，len() 函數(shù)返回的是字符串中的字符數(shù)，包括空格和標(biāo)點(diǎn)符號(hào)等。

5 字符串查找：使用find()、index()、rfind()、rindex()等方法來查找字符串中的子串。

在 Python 中，可以使用字符串的 find() 方法來查找子字符串在另一個(gè)字符串中第一次出現(xiàn)的位置。如果子字符串不存在，則 find() 方法將返回 -1。find() 方法的語法如下：

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

其中，str 是要查找的字符串，sub 是子字符串，start 和 end 是可選參數(shù)，表示查找的起始和結(jié)束位置。如果省略這些參數(shù)，則默認(rèn)從頭開始查找。

以下是一個(gè)簡單的示例，展示如何使用 find() 方法查找子字符串：

s = "Hello, World!"
index = s.find("World")
print(index)  # 輸出：7

在上面的例子中，我們首先創(chuàng)建了一個(gè)字符串 "Hello, World!"，然后使用 find() 方法查找子字符串 "World" 在該字符串中的位置。由于 "World" 存在于該字符串中，因此 find() 方法返回子字符串的起始位置 7。最后，我們將這個(gè)位置值賦值給變量 index 并輸出。如果子字符串不存在，find() 方法將返回 -1。

5.1 index 方法

在 Python 中，與 find() 方法相似，還有一個(gè) index() 方法可以用來查找子字符串在另一個(gè)字符串中第一次出現(xiàn)的位置。

與 find() 方法不同的是，如果子字符串不存在，index() 方法會(huì)觸發(fā) ValueError 異常。index() 方法的語法如下：

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

其中，str 是要查找的字符串，sub 是子字符串，start 和 end 是可選參數(shù)，表示查找的起始和結(jié)束位置。如果省略這些參數(shù)，則默認(rèn)從頭開始查找。

以下是一個(gè)簡單的示例，展示如何使用 index() 方法查找子字符串：

s = "Hello, World!"
index = s.index("World")
print(index)  # 輸出：7

在上面的例子中，我們首先創(chuàng)建了一個(gè)字符串 "Hello, World!"，然后使用 index() 方法查找子字符串 "World" 在該字符串中的位置。由于 "World" 存在于該字符串中，因此 index() 方法返回子字符串的起始位置 7。最后，我們將這個(gè)位置值賦值給變量 index 并輸出。如果子字符串不存在，index() 方法將觸發(fā) ValueError 異常。

5.2 rfind 方法

在 Python 中，字符串類型的 rfind() 方法可以用于返回子字符串在字符串中最后一次出現(xiàn)的位置。如果子字符串不在原字符串中，則返回 -1。rfind() 方法的語法如下：

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

其中，str 表示要進(jìn)行查找的字符串，sub 表示要查找的子字符串，start 和 end 表示查找起始位置和結(jié)束位置，都是可選的。如果不指定 start，默認(rèn)從 0 開始查找；如果不指定 end，默認(rèn)查找到字符串末尾。

以下是一個(gè)例子，展示如何使用 rfind() 方法查找子字符串：

s = "Hello, World!"
index = s.rfind("o")
print(index) # 輸出：7

在上面的例子中，我們使用 rfind() 方法查找子字符串 "o" 在字符串 "Hello, World!" 中最后一次出現(xiàn)的位置，可以看到該方法返回值為 7，表示子字符串最后一次出現(xiàn)的位置在原字符串中的索引為 7。

需要注意的是，rfind() 方法只返回子字符串在原字符串中最后一次出現(xiàn)的位置，如果要查找子字符串在字符串中第一次出現(xiàn)的位置，可以使用 find() 方法。

5.3 rindex 方法

在 Python 中，字符串類型的 rindex() 方法可以用于返回子字符串在字符串中最后一次出現(xiàn)的位置。如果子字符串不在原字符串中，則返回 ValueError 異常。rindex() 方法的語法如下：

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

其中，str 表示要進(jìn)行查找的字符串，sub 表示要查找的子字符串，start 和 end 表示查找起始位置和結(jié)束位置，都是可選的。如果不指定 start，默認(rèn)從 0 開始查找；如果不指定 end，默認(rèn)查找到字符串末尾。

以下是一個(gè)例子，展示如何使用 rindex() 方法查找子字符串：

s = "Hello, World!"
index = s.rindex("o")
print(index) # 輸出：7

在上面的例子中，我們使用 rindex() 方法查找子字符串 "o" 在字符串 "Hello, World!" 中最后一次出現(xiàn)的位置，可以看到該方法返回值為 7，表示子字符串最后一次出現(xiàn)的位置在原字符串中的索引為 7。

需要注意的是，rindex() 方法只返回子字符串在原字符串中最后一次出現(xiàn)的位置，如果要查找子字符串在字符串中第一次出現(xiàn)的位置，可以使用 index() 方法。如果子字符串不存在，則該方法會(huì)拋出 ValueError 異常。

6 字符串替換：使用replace()、translate()等方法來實(shí)現(xiàn)字符串的替換操作。

在 Python 中，字符串類型的 replace() 方法可以用于將字符串中的指定子串替換為另一個(gè)字符串。該方法返回一個(gè)新字符串，原字符串不會(huì)被修改。

replace() 方法的語法如下：

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

其中，str 表示要進(jìn)行操作的字符串；old 表示要被替換的子串；new 表示替換 old 的新串；count 可選，表示最多替換的次數(shù)。

下面是一個(gè)簡單的例子：

s = "Hello, World!"
new_s = s.replace("World", "Python")
print(new_s)  # 輸出：Hello, Python!

在上面的例子中，我們先定義了一個(gè)字符串 s，然后使用 replace() 方法將其中的 "World" 替換為 "Python"。該方法返回一個(gè)新的字符串，我們將其保存到 new_s 變量中。最后輸出 new_s 的值，它將是修改后的字符串："Hello, Python!"。

需要注意的是，replace() 方法并不會(huì)修改原始字符串，而是返回新的字符串，原始字符串仍然保持不變。此外，如果 old 子串不存在，replace() 方法并不會(huì)引發(fā)錯(cuò)誤，而是直接返回原始字符串。

6.1 translate 方法

在 Python 中，字符串類型的 translate() 方法可以用于將字符串中的指定字符替換為另一個(gè)字符。該方法返回一個(gè)新字符串，原字符串不會(huì)被修改。translate() 方法的語法如下：

str.translate(table)

其中，str 表示要進(jìn)行操作的字符串，table 表示轉(zhuǎn)換表。轉(zhuǎn)換表是一個(gè)字典，其中鍵表示要被替換的字符，值表示要替換為的字符。

需要注意的是，轉(zhuǎn)換表可以使用 str.maketrans() 方法創(chuàng)建，該方法的語法如下：

str.maketrans(x[, y[, z]])

其中，x 表示要被替換的字符，y 表示替換為的字符，z 表示要從字符串中刪除的字符。如果只提供了一個(gè)參數(shù) x，那么表示刪除 x 中指定的字符。如果提供了兩個(gè)參數(shù) x 和 y，那么將 x 中的字符替換為 y 中對應(yīng)的字符。 下面是一個(gè)簡單的例子：

s = "Hello, World!"
table = s.maketrans("o", "e")
new_s = s.translate(table)
print(new_s)  # 輸出：Helle, Werld!

在上面的例子中，我們先定義了一個(gè)字符串 s，然后使用 maketrans() 方法創(chuàng)建了一個(gè)轉(zhuǎn)換表 table，指定要將 "o" 替換為 "e"。然后使用 translate() 方法將 s 中的 "o" 替換為 "e"，最終得到新的字符串 new_s，其值為 "Helle, Werld!"。

需要注意的是，translate() 方法并不會(huì)修改原始字符串，而是返回新的字符串，原始字符串仍然保持不變。同時(shí)，如果給定的字符在轉(zhuǎn)換表中不存在，則不會(huì)進(jìn)行替換，直接保留原樣。

7 字符串分割：使用split()、rsplit()、partition()、rpartition()等方法來進(jìn)字符串的分割操作。

在 Python 中，字符串類型的 split() 方法可以用于將一個(gè)字符串按照指定分隔符分割成多個(gè)子字符串，并存儲(chǔ)在一個(gè)列表中。該方法返回一個(gè)列表，列表中包含了分割后的子字符串。split() 方法的語法如下：

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

其中，str 表示要進(jìn)行操作的字符串；sep 表示分隔符，如果不指定分隔符，則使用空格作為默認(rèn)值；maxsplit 表示最大分割次數(shù)，如果指定了該參數(shù)，則最多只會(huì)分割 maxsplit 次。

需要注意的是，如果分隔符在字符串中不存在，則 split() 方法將返回包含原字符串的列表。 下面是一個(gè)簡單的例子：

s = "apple,banana,orange"
lst = s.split(",")
print(lst)  # 輸出：['apple', 'banana', 'orange']

在上面的例子中，我們先定義了一個(gè)字符串 s，使用 split() 方法按照逗號(hào)分隔符將其分割成多個(gè)子字符串，并將分割后的結(jié)果保存到列表 lst 中。最終輸出 lst 的值，可以看到該列表包含了分割后的子字符串。

需要注意的是，split() 方法返回的列表中并不包含分隔符本身。如果想要保留分隔符的話，可以使用字符串類型的 splitlines() 方法。

如果希望將一個(gè)字符串分割成多個(gè)子字符串并將其存儲(chǔ)在一個(gè)元組中，可以使用元組解包的方式，如下所示：

s = "apple,banana,orange"
t = tuple(s.split(","))
print(t)  # 輸出：('apple', 'banana', 'orange')

7.1 rsplit()

在 Python 中，字符串類型的 rsplit() 方法與 split() 方法類似，都是用來將一個(gè)字符串分割成多個(gè)子字符串并存儲(chǔ)在一個(gè)列表中。

不同之處在于，rsplit() 方法是從字符串的右側(cè)開始分割而非從左側(cè)開始。該方法返回一個(gè)列表，其中包含分割后的子字符串。rsplit() 方法的語法如下：

str.rsplit(sep=None, maxsplit=-1)

其中，str 表示要進(jìn)行操作的字符串；sep 表示分隔符，如果不指定分隔符，則使用空格作為默認(rèn)值；maxsplit 表示最大分割次數(shù)，如果指定了該參數(shù)，則最多只會(huì)分割 maxsplit 次。 下面是一個(gè)簡單的例子：

s = "apple,banana,orange"
lst = s.rsplit(",", 1)
print(lst)  # 輸出：['apple,banana', 'orange']

在上面的例子中，我們先定義了一個(gè)字符串 s，使用 rsplit() 方法按照逗號(hào)分隔符將其從右側(cè)開始分割成多個(gè)子字符串，并將分割后的結(jié)果保存到列表 lst 中。在指定了分割次數(shù)為 1 的情況下，分割方法只會(huì)分割一次，將字符串分成兩個(gè)子字符串，一個(gè)是 "apple,banana"，另一個(gè)是 "orange"。

需要注意的是，rsplit() 方法返回的列表中并不包含分隔符本身，與 split() 方法相同。另外，如果希望將一個(gè)字符串分割成多個(gè)子字符串并將其存儲(chǔ)在一個(gè)元組中，可以使用元組解包的方式，如下所示：

s = "apple,banana,orange"
t = tuple(s.rsplit(",", 1))
print(t)  # 輸出：('apple,banana', 'orange')

7.2 partition()

在 Python 中，字符串類型的 partition() 方法可以用于將一個(gè)字符串按照指定分隔符分成三部分（分隔符左側(cè)部分、分隔符本身和分隔符右側(cè)部分），并存儲(chǔ)在一個(gè)元組中。

該方法返回一個(gè)元組，元組中包含分隔符左側(cè)部分、分隔符本身和分隔符右側(cè)部分三個(gè)元素。partition() 方法的語法如下：

str.partition(sep)

其中，str 表示要進(jìn)行操作的字符串；sep 表示分隔符。 下面是一個(gè)簡單的例子：

s = "apple,banana,orange"
t = s.partition(",")
print(t)  # 輸出：('apple', ',', 'banana,orange')

在上面的例子中，我們先定義了一個(gè)字符串 s，使用 partition() 方法按照逗號(hào)分隔符將其分成三部分并存儲(chǔ)到元組 t 中。最終輸出 t 的值，可以看到該元組包含了分隔符左側(cè)部分、分隔符本身和分隔符右側(cè)部分三個(gè)元素。

需要注意的是，如果分隔符在字符串中不存在，則 partition() 方法將返回一個(gè)包含原字符串和兩個(gè)空字符串的元組。如果要忽略掉分隔符本身，可以使用 split() 方法。

另外，如果希望將一個(gè)字符串分成三部分并將其存儲(chǔ)在一個(gè)列表中，可以使用列表解包的方式，如下所示：

s = "apple,banana,orange"
lst = list(s.partition(","))
print(lst)  # 輸出：['apple', ',', 'banana,orange']

7.3 rpartition()

在 Python 中，字符串類型的 rpartition() 方法和 partition() 方法類似，不同之處在于 rpartition() 方法是從字符串的右側(cè)開始分隔而非從左側(cè)開始。

rpartition() 方法同樣可以用于將一個(gè)字符串按照指定分隔符分成三部分（分隔符左側(cè)部分、分隔符本身和分隔符右側(cè)部分），并存儲(chǔ)在一個(gè)元組中。該方法返回一個(gè)元組，元組中包含分隔符左側(cè)部分、分隔符本身和分隔符右側(cè)部分三個(gè)元素。rpartition() 方法的語法如下：

str.rpartition(sep)

其中，str 表示要進(jìn)行操作的字符串；sep 表示分隔符。 下面是一個(gè)簡單的例子：

s = "apple,banana,orange"
t = s.rpartition(",")
print(t)  # 輸出：('apple,banana', ',', 'orange')

在上面的例子中，我們先定義了一個(gè)字符串 s，使用 rpartition() 方法按照逗號(hào)分隔符將其從右側(cè)開始分成三部分并存儲(chǔ)到元組 t 中。最終輸出 t 的值，可以看到該元組包含了分隔符左側(cè)部分、分隔符本身和分隔符右側(cè)部分三個(gè)元素。

需要注意的是，如果分隔符在字符串中不存在，則 rpartition() 方法將返回一個(gè)包含兩個(gè)空字符串和原字符串的元組。如果要忽略掉分隔符本身，可以使用 split() 方法。另外，如果希望將一個(gè)字符串分成三部分并將其存儲(chǔ)在一個(gè)列表中，可以使用列表解包的方式，如下所示：

s = "apple,banana,orange"
lst = list(s.rpartition(","))
print(lst)  # 輸出：['apple,banana', ',', 'orange']

8 字符串大小寫轉(zhuǎn)換：使用 upper()、lower()、capitalize()、swapcase()等方法來進(jìn)行字符串的大小寫轉(zhuǎn)換。

在 Python 中，字符串類型的 upper() 方法可以將一個(gè)字符串轉(zhuǎn)換為大寫字母形式，并返回轉(zhuǎn)換后的新字符串，原始字符串不會(huì)被改變。該方法的語法如下：

str.upper()

其中，str 表示要進(jìn)行操作的字符串。 下面是一個(gè)簡單的例子：

s = "hello world"
t = s.upper()
print(t)  # 輸出：HELLO WORLD
print(s)  # 輸出：hello world

在上面的例子中，我們先定義了一個(gè)字符串 s，使用 upper() 方法將其轉(zhuǎn)換為大寫字母形式，并將轉(zhuǎn)換后的新字符串賦值給變量 t。最終輸出 t 的值，可以看到該字符串已被轉(zhuǎn)換為大寫字母形式，而原始字符串 s 的值未發(fā)生改變。

需要注意的是，upper() 方法只會(huì)將字符串中的小寫字母轉(zhuǎn)換為大寫字母，對于其他字符，如數(shù)字、標(biāo)點(diǎn)符號(hào)和大寫字母等，不會(huì)有任何影響。如果要將一個(gè)字符串轉(zhuǎn)換為小寫字母形式，則可以使用 lower() 方法。

8.1 Python字符串lower()

在 Python 中，字符串類型的 lower() 方法可以將一個(gè)字符串轉(zhuǎn)換為小寫字母形式，并返回轉(zhuǎn)換后的新字符串，原始字符串不會(huì)被改變。該方法的語法如下：

str.lower()

其中，str 表示要進(jìn)行操作的字符串。 下面是一個(gè)簡單的例子：

s = "HELLO WORLD"
t = s.lower()
print(t)  # 輸出：hello world
print(s)  # 輸出：HELLO WORLD

在上面的例子中，我們先定義了一個(gè)字符串 s，使用 lower() 方法將其轉(zhuǎn)換為小寫字母形式，并將轉(zhuǎn)換后的新字符串賦值給變量 t。最終輸出 t 的值，可以看到該字符串已被轉(zhuǎn)換為小寫字母形式，而原始字符串 s 的值未發(fā)生改變。

需要注意的是，lower() 方法只會(huì)將字符串中的大寫字母轉(zhuǎn)換為小寫字母，對于其他字符，如數(shù)字、標(biāo)點(diǎn)符號(hào)和小寫字母等，不會(huì)有任何影響。如果要將一個(gè)字符串轉(zhuǎn)換為大寫字母形式，則可以使用 upper() 方法。

8.2 Python字符串capitalize()

在 Python 中，字符串類型的 capitalize() 方法可以將一個(gè)字符串的首字母轉(zhuǎn)換為大寫，并返回轉(zhuǎn)換后的新字符串，原始字符串不會(huì)被改變。該方法的語法如下：

str.capitalize()

其中，str 表示要進(jìn)行操作的字符串。 下面是一個(gè)簡單的例子：

s = "hello world"
t = s.capitalize()
print(t)  # 輸出：Hello world
print(s)  # 輸出：hello world

在上面的例子中，我們先定義了一個(gè)字符串 s，使用 capitalize() 方法將其首字母轉(zhuǎn)換為大寫，并將轉(zhuǎn)換后的新字符串賦值給變量 t。最終輸出 t 的值，可以看到該字符串的首字母已經(jīng)被轉(zhuǎn)換為大寫，而原始字符串 s 的值未發(fā)生改變。

需要注意的是，capitalize() 方法只會(huì)將字符串的第一個(gè)字符轉(zhuǎn)換為大寫字母，對于其他字符，如數(shù)字、標(biāo)點(diǎn)符號(hào)和小寫字母等，不會(huì)有任何影響。如果要將一個(gè)字符串中的所有單詞的首字母都轉(zhuǎn)換為大寫字母，則可以使用 title() 方法。

8.3 Python字符串swapcase() 方法

在 Python 中，字符串類型的 swapcase() 方法可以將一個(gè)字符串中的大寫字母轉(zhuǎn)換為小寫字母，同時(shí)將小寫字母轉(zhuǎn)換為大寫字母，并返回轉(zhuǎn)換后的新字符串，原始字符串不會(huì)被改變。該方法的語法如下：

str.swapcase()

其中，str 表示要進(jìn)行操作的字符串。 下面是一個(gè)簡單的例子：

s = "Hello World"
t = s.swapcase()
print(t)  # 輸出：hELLO wORLD
print(s)  # 輸出：Hello World

在上面的例子中，我們先定義了一個(gè)字符串 s，使用 swapcase() 方法將其中的大寫字母轉(zhuǎn)換為小寫字母，同時(shí)將小寫字母轉(zhuǎn)換為大寫字母，并將轉(zhuǎn)換后的新字符串賦值給變量 t。最終輸出 t 的值，可以看到該字符串中的所有字母的大小寫都發(fā)生了反轉(zhuǎn)，而原始字符串 s 的值未發(fā)生改變。

需要注意的是，swapcase() 方法只會(huì)將字符串中的字母的大小寫進(jìn)行反轉(zhuǎn)，對于其他字符，如數(shù)字、標(biāo)點(diǎn)符號(hào)等，不會(huì)有任何影響。

9 Python字符串去除空格：使用strip()、lstrip()、rstrip()等方法來去除字符串中的空格。

在 Python 中，字符串類型的 strip() 方法可以用于去除一個(gè)字符串開頭或結(jié)尾的指定字符（默認(rèn)為空格符），并返回去除指定字符后的新字符串，原始字符串不會(huì)被改變。該方法的語法如下：

str.strip([chars])

其中，str 表示要進(jìn)行操作的字符串；chars 表示要去除的字符，默認(rèn)為空格符。 下面是一個(gè)簡單的例子：

s = "  hello world  "
t = s.strip()
print(t)  # 輸出：hello world
print(s)  # 輸出：  hello world  

在上面的例子中，我們先定義了一個(gè)字符串 s，其中包含了開頭和結(jié)尾的空格符，使用 strip() 方法將其去除空格符，并將去除空格符后的新字符串賦值給變量 t。最終輸出 t 的值，可以看到該字符串開頭和結(jié)尾的空格符已被去除，而原始字符串 s 的值未發(fā)生改變。

如果要去除指定的字符，可以在 strip() 方法中指定要去除的字符。例如，下面的例子將去除字符串開頭和結(jié)尾的逗號(hào)（,）：

s = ",hello,world,"
t = s.strip(",")
print(t)  # 輸出：hello,world

需要注意的是，strip() 方法只會(huì)去除字符串開頭和結(jié)尾的指定字符，在字符串中間的指定字符不會(huì)被去除。如果要去除字符串中間的指定字符，可以使用 replace() 方法進(jìn)行替換。

9.1 Python字符串lstrip()方法

在 Python 中，字符串類型的 lstrip() 方法可以用于去除一個(gè)字符串開頭的指定字符（默認(rèn)為空格符），并返回去除指定字符后的新字符串，原始字符串不會(huì)被改變。該方法的語法如下：

str.lstrip([chars])

在上面的例子中，我們先定義了一個(gè)字符串 s，其中包含了開頭的空格符，使用 lstrip() 方法將其去除空格符，并將去除空格符后的新字符串賦值給變量 t。最終輸出 t 的值，可以看到該字符串開頭的空格符已被去除，而原始字符串 s 的值未發(fā)生改變。

如果要去除指定的字符，可以在 lstrip() 方法中指定要去除的字符。例如，下面的例子將去除字符串開頭的逗號(hào)（,）：

s = ",hello,world,"
t = s.lstrip(",")
print(t)  # 輸出：hello,world,

需要注意的是，lstrip() 方法只會(huì)去除字符串開頭的指定字符，在字符串結(jié)尾和中間的指定字符不會(huì)被去除。如果要去除字符串結(jié)尾和中間的指定字符，可以使用 rstrip() 和 replace() 方法進(jìn)行替換。

9.2 Python字符串rstrip()方法

在 Python 中，字符串類型的 rstrip() 方法可以用于去除一個(gè)字符串結(jié)尾的指定字符（默認(rèn)為空格符），并返回去除指定字符后的新字符串，原始字符串不會(huì)被改變。該方法的語法如下：

str.rstrip([chars])

其中，str 表示要進(jìn)行操作的字符串；chars 表示要去除的字符，默認(rèn)為空格符。 下面是一個(gè)簡單的例子：

s = "  hello world  "
t = s.rstrip()
print(t)  # 輸出：  hello world
print(s)  # 輸出：  hello world  

在上面的例子中，我們先定義了一個(gè)字符串 s，其中包含了結(jié)尾的空格符，使用 rstrip() 方法將其去除空格符，并將去除空格符后的新字符串賦值給變量 t。最終輸出 t 的值，可以看到該字符串結(jié)尾的空格符已被去除，而原始字符串 s 的值未發(fā)生改變。

如果要去除指定的字符，可以在 rstrip() 方法中指定要去除的字符。例如，下面的例子將去除字符串結(jié)尾的逗號(hào)（,）：

s = ",hello,world,"
t = s.rstrip(",")
print(t)  # 輸出：,hello,world

需要注意的是，rstrip() 方法只會(huì)去除字符串結(jié)尾的指定字符，在字符串開頭和中間的指定字符不會(huì)被去除。如果要去除字符串開頭和中間的指定字符，可以使用 lstrip()、strip() 和 replace() 方法進(jìn)行替換。

10 Python字符串判斷：使用startswith()、endswith()、isalnum()、isalpha()、isdigit()、islower()、isupper()等方法來判斷字符串的特定屬性。

在 Python 中，字符串類型的 startswith() 和 endswith() 方法用于檢查一個(gè)字符串是否以指定的前綴和后綴開頭和結(jié)束，返回一個(gè)布爾值 True 或者 False。這兩個(gè)方法都有兩個(gè)參數(shù)，第一個(gè)參數(shù)是要檢查的前綴或后綴字符串，第二個(gè)參數(shù)是可選的，表示要檢查的字符串起始和結(jié)束位置的索引范圍。 startswith() 方法的語法如下：

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

其中，str 表示要進(jìn)行操作的字符串；prefix 表示要檢查的前綴字符串；start 和 end 表示要檢查的字符串起始和結(jié)束位置的索引范圍，可以省略不填，默認(rèn)為整個(gè)字符串的起始和結(jié)束位置。 endswith() 方法的語法如下：

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

其中，str 表示要進(jìn)行操作的字符串；suffix 表示要檢查的后綴字符串；start 和 end 表示要檢查的字符串起始和結(jié)束位置的索引范圍，可以省略不填，默認(rèn)為整個(gè)字符串的起始和結(jié)束位置。 下面是兩個(gè)簡單的例子：

s = "hello world"
print(s.startswith("hello"))  # 輸出：True
print(s.endswith("world"))  # 輸出：True

t = "python is a great language"
print(t.startswith("python", 0, 6))  # 輸出：True
print(t.endswith("language", 16))  # 輸出：True

在上面的例子中，我們先定義了兩個(gè)字符串 s 和 t，然后使用 startswith() 和 endswith() 方法檢查它們是否以指定的前綴和后綴開頭和結(jié)束，最終輸出檢查結(jié)果?？梢钥吹?，當(dāng)字符串以指定的前綴和后綴開頭和結(jié)束時(shí)，這兩個(gè)方法都會(huì)返回 True，否則返回 False。

需要注意的是，startswith() 和 endswith() 方法都區(qū)分大小寫，如果要忽略大小寫進(jìn)行檢查，則可以使用 lower() 或 upper() 方法將字符串轉(zhuǎn)換為小寫或大寫形式后再進(jìn)行檢查。

10.1 Python字符串isalnum()

在 Python 中，字符串類型的 isalnum() 方法用于檢測一個(gè)字符串是否只由字母和數(shù)字組成，返回一個(gè)布爾值 True 或者 False。該方法沒有任何參數(shù)，直接在字符串上調(diào)用即可，語法格式如下：

str.isalnum()

其中，str 表示要進(jìn)行操作的字符串。 下面是一個(gè)簡單的例子：

s = "hello123"
t = "hello world"
print(s.isalnum())  # 輸出：True
print(t.isalnum())  # 輸出：False

在上面的例子中，我們先定義了兩個(gè)字符串 s 和 t，分別使用 isalnum() 方法檢測它們是否只由字母和數(shù)字組成，最終輸出檢測結(jié)果?？梢钥吹?，當(dāng)一個(gè)字符串只由字母和數(shù)字組成時(shí)，isalnum() 方法返回 True，否則返回 False。

需要注意的是，isalnum() 方法只能檢測字符串中是否只由字母和數(shù)字組成，對于其他字符，如標(biāo)點(diǎn)符號(hào)、空格、換行符等，則不做任何處理。如果要檢查字符串中是否只包含字母，則可以使用 isalpha() 方法；如果要檢查字符串中是否只包含數(shù)字，則可以使用 isdigit() 方法。

10.2 Python字符串isalpha()

在 Python 中，字符串類型的 isalpha() 方法用于檢測一個(gè)字符串是否只由字母組成，返回一個(gè)布爾值 True 或者 False。該方法沒有任何參數(shù)，直接在字符串上調(diào)用即可，語法格式如下：

str.isalpha()

其中，str 表示要進(jìn)行操作的字符串。 下面是一個(gè)簡單的例子：

s = "hello"
t = "hello123"
print(s.isalpha())  # 輸出：True
print(t.isalpha())  # 輸出：False

在上面的例子中，我們先定義了兩個(gè)字符串 s 和 t，分別使用 isalpha() 方法檢測它們是否只由字母組成，最終輸出檢測結(jié)果?？梢钥吹?，當(dāng)一個(gè)字符串只由字母組成時(shí)，isalpha() 方法返回 True，否則返回 False。

需要注意的是，isalpha() 方法只能檢測字符串中是否只由字母組成，對于其他字符，如數(shù)字、標(biāo)點(diǎn)符號(hào)、空格、換行符等，則不做任何處理。如果要檢查字符串中是否只包含字母和數(shù)字，則可以使用 isalnum() 方法；如果要檢查字符串中是否只包含數(shù)字，則可以使用 isdigit() 方法。

10.3 Python字符串isdigit()

在 Python 中，字符串類型的 isdigit() 方法用于檢測一個(gè)字符串是否只由數(shù)字組成，返回一個(gè)布爾值 True 或者 False。該方法沒有任何參數(shù)，直接在字符串上調(diào)用即可，語法格式如下：

str.isdigit()

其中，str 表示要進(jìn)行操作的字符串。 下面是一個(gè)簡單的例子：

s = "123"
t = "hello123"
print(s.isdigit())  # 輸出：True
print(t.isdigit())  # 輸出：False

在上面的例子中，我們先定義了兩個(gè)字符串 s 和 t，分別使用 isdigit() 方法檢測它們是否只由數(shù)字組成，最終輸出檢測結(jié)果?？梢钥吹?，當(dāng)一個(gè)字符串只由數(shù)字組成時(shí)，isdigit() 方法返回 True，否則返回 False。

需要注意的是，isdigit() 方法只能檢測字符串中是否只由數(shù)字組成，對于其他字符，如字母、標(biāo)點(diǎn)符號(hào)、空格、換行符等，則不做任何處理。如果要檢查字符串中是否只包含數(shù)字和字母，則可以使用 isalnum() 方法；如果要檢查字符串中是否只包含字母，則可以使用 isalpha() 方法。

10.4 Python字符串islower()、isupper()

在 Python 中，字符串類型有 islower() 和 isupper() 方法，用于檢測一個(gè)字符串是否全是小寫或全是大寫字母，返回一個(gè)布爾值 True 或 False。這兩個(gè)方法都沒有參數(shù)，直接在字符串上調(diào)用即可，語法格式如下：

str.islower()
str.isupper()

其中，str 表示要進(jìn)行操作的字符串。 下面是一個(gè)簡單的例子：

s = "hello world"
t = "HELLO WORLD"
print(s.islower())  # 輸出：True
print(t.islower())  # 輸出：False
print(t.isupper())  # 輸出：True
print(s.isupper())  # 輸出：False

在上面的例子中，我們先定義了兩個(gè)字符串 s 和 t，分別使用 islower() 和 isupper() 方法檢測它們是否全是小寫或全是大寫字母，最終輸出檢測結(jié)果。

可以看到，當(dāng)一個(gè)字符串全是小寫字母時(shí)，islower() 方法返回 True；全是大寫字母時(shí)，isupper() 方法返回 True；否則均返回 False。

需要注意的是，這兩個(gè)方法只會(huì)檢測字符串中的字母是否全是小寫或全是大寫，對于其他字符不做任何處理。如果要檢查字符串中的字母是否為首字母大寫，可以使用 istitle() 方法。

以上就是Python中的字符串常用方法整理概述的詳細(xì)內(nèi)容，更多關(guān)于Python字符串常用方法的資料請關(guān)注腳本之家其它相關(guān)文章！