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

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

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

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

可以使用加號（+）或者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中常用的字符串方法之一，它把字符串序列中的元素以指定的分隔符連接成一個新的字符串。 join() 方法需要一個可迭代對象（例如列表、元組等）作為參數(shù)，并返回一個新的字符串，其中序列中的元素被以指定的分隔符連接起來。 以下是一個簡單的示例，用逗號將列表中的字符串連接起來：

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

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

2 字符串格式化

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

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

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

在使用format()函數(shù)進(jìn)行字符串格式化時，我們需要在字符串中使用一對花括號（{}）作為占位符，然后使用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)行字符串格式化。在字符串中，我們使用花括號作為占位符，并使用format()函數(shù)提供的參數(shù)來替換這些占位符。最終的輸出為字符串"My name is Tom, and I'm 20 years old."。

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

除了使用format()函數(shù)進(jìn)行字符串格式化外，我們還可以使用百分號（%）操作符來進(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.

在上面的例子中，我們使用百分號（%）操作符來進(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）。

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

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!（每隔一個字符取一個字符）

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5.1 index 方法

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

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

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

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

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

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

在上面的例子中，我們首先創(chuàng)建了一個字符串 "Hello, World!"，然后使用 index() 方法查找子字符串 "World" 在該字符串中的位置。由于 "World" 存在于該字符串中，因此 index() 方法返回子字符串的起始位置 7。最后，我們將這個位置值賦值給變量 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)查找到字符串末尾。

以下是一個例子，展示如何使用 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)查找到字符串末尾。

以下是一個例子，展示如何使用 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() 方法。如果子字符串不存在，則該方法會拋出 ValueError 異常。

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

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

replace() 方法的語法如下：

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

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

下面是一個簡單的例子：

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

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

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

6.1 translate 方法

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

str.translate(table)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

7.1 rsplit()

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

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

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

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

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

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

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

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

7.2 partition()

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

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

str.partition(sep)

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

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

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

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

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

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

7.3 rpartition()

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

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

str.rpartition(sep)

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

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

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

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

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() 方法可以將一個字符串轉(zhuǎn)換為大寫字母形式，并返回轉(zhuǎn)換后的新字符串，原始字符串不會被改變。該方法的語法如下：

str.upper()

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

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

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

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

8.1 Python字符串lower()

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

str.lower()

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

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

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

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

8.2 Python字符串capitalize()

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

str.capitalize()

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

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

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

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

8.3 Python字符串swapcase() 方法

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

str.swapcase()

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

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

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

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

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

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

str.strip([chars])

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

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

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

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

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

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

9.1 Python字符串lstrip()方法

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

str.lstrip([chars])

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

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

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

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

9.2 Python字符串rstrip()方法

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

str.rstrip([chars])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

10.1 Python字符串isalnum()

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

str.isalnum()

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

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

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

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

10.2 Python字符串isalpha()

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

str.isalpha()

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

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

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

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

10.3 Python字符串isdigit()

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

str.isdigit()

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

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

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

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

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

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

str.islower()
str.isupper()

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

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

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

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

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

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

最新評論