Python 中的字符串是一种不可变的序列类型，运用单引号（’）或双引号（”）括起来。

在Python 3中，字符串默许运用Unicode编码，支撑各种语言的字符集，包括中文、日文、韩文等。一起，Python 3中的字符串是不可变的，避免了传统编程中的一些常见问题。

1. Python 字符串拼接：运用“+”或许“+=”进行字符串的拼接。

字符串拼接是将两个或多个字符串合并为一个字符串的进程。在Python中，能够运用“+”或许“+=”运算符来进行字符串拼接。

能够运用加号（+）或许join()办法来进行字符串拼接,例如：

a = "hello"
b = " world"
c = a + "  " + b
print(c)  # 输出：hello world
d = "good"
d += " bye"
print(d)  # 输出：good bye

也能够运用*运算符或许乘法操作符对字符串进行仿制。

例如，以下代码能够将字符串a重复3次，并将成果赋值给字符串b：

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

join() 办法是Python中常用的字符串办法之一，它把字符串序列中的元素以指定的分隔符连接成一个新的字符串。 join() 办法需求一个可迭代目标（例如列表、元组等）作为参数，并回来一个新的字符串，其间序列中的元素被以指定的分隔符连接起来。 以下是一个简略的示例，用逗号将列表中的字符串连接起来：

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

在上面的示例中，咱们运用join()办法将列表元素连接起来，用逗号作为连接符，并将成果赋值给变量result。 终究的输出为字符串’apple,banana,orange’。

2 字符串格局化

Python中字符串格局化是一种用于将变量插入到字符串中的办法。它答应咱们创建一些带有占位符的字符串，然后运用实际的值来替换这些占位符。

Python中有许多种字符串格局化的办法，其间最常用的办法是运用format()函数和百分号（%）操作符。

2.1 运用format()函数进行字符串格局化

在运用format()函数进行字符串格局化时，咱们需求在字符串中运用一对花括号（{}）作为占位符，然后运用format()函数供给的参数来替换这些占位符。例如，以下代码能够将变量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()函数来进行字符串格局化。在字符串中，咱们运用花括号作为占位符，并运用format()函数供给的参数来替换这些占位符。终究的输出为字符串”My name is Tom, and I’m 20 years old.”。

2.2 运用百分号（%）操作符进行字符串格局化

除了运用format()函数进行字符串格局化外，咱们还能够运用百分号（%）操作符来进行字符串格局化。

在这种办法中，咱们需求指定占位符的类型（例如%s表明字符串，%d表明整数）以及实际的值。例如，以下代码能够将变量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.

在上面的比如中，咱们运用百分号（%）操作符来进行字符串格局化。在字符串中，运用%s表明字符串占位符，运用%d表明整数占位符，并运用%运算符后面的元组来供给实际的值。终究的输出与上面运用format()函数进行字符串格局化的输出成果相同。

3 字符串切片：运用[]和[:]对字符串进行切片操作。

在Python中，能够运用切片（slice）操作符来获取字符串的一部分。

切片操作符的语法是 [start:stop:step]，其间start表明开端方位（默许为0），stop表明完毕方位（默许为字符串的长度），step表明步长（默许为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个字符），因而输出的成果是字符串“Hello”。

s[7:12]则表明从第7个字符开端（即第8个字符），取到第12个字符（不包括第12个字符），因而输出的成果是字符串“World”。

s[:5]表明从第0个字符开端（即榜首个字符），取到第5个字符（不包括第5个字符），因而输出的成果仍然是字符串“Hello”。

s[7:]表明从第7个字符开端（即第8个字符），一向取到字符串的终究一个字符，因而输出的成果是字符串“World!”。

s[::2] 表明从第0个字符开端（即榜首个字符），每隔一个字符（即步长为2）取一个字符，因而输出的成果是字符串“Hlo ol!”。

4 字符串长度：运用len()函数获取字符串的长度。

在 Python 中，能够运用 len() 函数来获取字符串的长度。例如：

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

在上面的比如中，咱们首要创建了一个字符串 “Hello, World!”，然后运用 len() 函数获取了它的长度，并将成果赋值给变量 length。终究，咱们运用 print() 函数将长度输出到操控台中。留意，len() 函数回来的是字符串中的字符数，包括空格和标点符号等。

5 字符串查找：运用find()、index()、rfind()、rindex()等办法来查找字符串中的子串。

在 Python 中，能够运用字符串的 find() 办法来查找子字符串在另一个字符串中榜首次呈现的方位。假如子字符串不存在，则 find() 办法将回来 -1。find() 办法的语法如下：

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

其间，str 是要查找的字符串，sub 是子字符串，start 和 end 是可选参数，表明查找的开端和完毕方位。假如省略这些参数，则默许从头开端查找。

以下是一个简略的示例，展现怎么运用 find() 办法查找子字符串：

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

在上面的比如中，咱们首要创建了一个字符串 “Hello, World!”，然后运用 find() 办法查找子字符串 “World” 在该字符串中的方位。由于 “World” 存在于该字符串中，因而 find() 办法回来子字符串的开端方位 7。终究，咱们将这个方位值赋值给变量 index 并输出。假如子字符串不存在，find() 办法将回来 -1。

5.1 index 办法

在 Python 中，与 find() 办法相似，还有一个 index() 办法能够用来查找子字符串在另一个字符串中榜首次呈现的方位。

与 find() 办法不同的是，假如子字符串不存在，index() 办法会触发 ValueError 反常。index() 办法的语法如下：

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

其间，str 是要查找的字符串，sub 是子字符串，start 和 end 是可选参数，表明查找的开端和完毕方位。假如省略这些参数，则默许从头开端查找。

以下是一个简略的示例，展现怎么运用 index() 办法查找子字符串：

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

在上面的比如中，咱们首要创建了一个字符串 “Hello, World!”，然后运用 index() 办法查找子字符串 “World” 在该字符串中的方位。由于 “World” 存在于该字符串中，因而 index() 办法回来子字符串的开端方位 7。终究，咱们将这个方位值赋值给变量 index 并输出。假如子字符串不存在，index() 办法将触发 ValueError 反常。

5.2 rfind 办法

在 Python 中，字符串类型的 rfind() 办法能够用于回来子字符串在字符串中终究一次呈现的方位。假如子字符串不在原字符串中，则回来 -1。rfind() 办法的语法如下：

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

其间，str 表明要进行查找的字符串，sub 表明要查找的子字符串，start 和 end 表明查找开端方位和完毕方位，都是可选的。假如不指定 start，默许从 0 开端查找；假如不指定 end，默许查找到字符串末尾。

以下是一个比如，展现怎么运用 rfind() 办法查找子字符串：

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

在上面的比如中，咱们运用 rfind() 办法查找子字符串 “o” 在字符串 “Hello, World!” 中终究一次呈现的方位，能够看到该办法回来值为 7，表明子字符串终究一次呈现的方位在原字符串中的索引为 7。

需求留意的是，rfind() 办法只回来子字符串在原字符串中终究一次呈现的方位，假如要查找子字符串在字符串中榜首次呈现的方位，能够运用 find() 办法。

5.3 rindex 办法

在 Python 中，字符串类型的 rindex() 办法能够用于回来子字符串在字符串中终究一次呈现的方位。假如子字符串不在原字符串中，则回来 ValueError 反常。rindex() 办法的语法如下：

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

其间，str 表明要进行查找的字符串，sub 表明要查找的子字符串，start 和 end 表明查找开端方位和完毕方位，都是可选的。假如不指定 start，默许从 0 开端查找；假如不指定 end，默许查找到字符串末尾。

以下是一个比如，展现怎么运用 rindex() 办法查找子字符串：

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

在上面的比如中，咱们运用 rindex() 办法查找子字符串 “o” 在字符串 “Hello, World!” 中终究一次呈现的方位，能够看到该办法回来值为 7，表明子字符串终究一次呈现的方位在原字符串中的索引为 7。

需求留意的是，rindex() 办法只回来子字符串在原字符串中终究一次呈现的方位，假如要查找子字符串在字符串中榜首次呈现的方位，能够运用 index() 办法。假如子字符串不存在，则该办法会抛出 ValueError 反常。

6 字符串替换：运用replace()、translate()等办法来完成字符串的替换操作。

在 Python 中，字符串类型的 replace() 办法能够用于将字符串中的指定子串替换为另一个字符串。该办法回来一个新字符串，原字符串不会被修改。

replace() 办法的语法如下：

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

其间，str 表明要进行操作的字符串；old 表明要被替换的子串；new 表明替换 old 的新串；count 可选，表明最多替换的次数。

下面是一个简略的比如：

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() 办法并不会引发过错，而是直接回来原始字符串。

6.1 translate 办法

在 Python 中，字符串类型的 translate() 办法能够用于将字符串中的指定字符替换为另一个字符。该办法回来一个新字符串，原字符串不会被修改。translate() 办法的语法如下：

str.translate(table)

其间，str 表明要进行操作的字符串，table 表明转化表。转化表是一个字典，其间键表明要被替换的字符，值表明要替换为的字符。

需求留意的是，转化表能够运用 str.maketrans() 办法创建，该办法的语法如下：

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

其间，x 表明要被替换的字符，y 表明替换为的字符，z 表明要从字符串中删去的字符。假如只供给了一个参数 x，那么表明删去 x 中指定的字符。假如供给了两个参数 x 和 y，那么将 x 中的字符替换为 y 中对应的字符。
下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，然后运用 maketrans() 办法创建了一个转化表 table，指定要将 “o” 替换为 “e”。然后运用 translate() 办法将 s 中的 “o” 替换为 “e”，终究得到新的字符串 new_s，其值为 “Helle, Werld!”。

需求留意的是，translate() 办法并不会修改原始字符串，而是回来新的字符串，原始字符串仍然坚持不变。一起，假如给定的字符在转化表中不存在，则不会进行替换，直接保留原样。

7 字符串切割：运用split()、rsplit()、partition()、rpartition()等办法来进字符串的切割操作。

在 Python 中，字符串类型的 split() 办法能够用于将一个字符串依照指定分隔符切割成多个子字符串，并存储在一个列表中。该办法回来一个列表，列表中包括了切割后的子字符串。split() 办法的语法如下：

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

其间，str 表明要进行操作的字符串；sep 表明分隔符，假如不指定分隔符，则运用空格作为默许值；maxsplit 表明最大切割次数，假如指定了该参数，则最多只会切割 maxsplit 次。

需求留意的是，假如分隔符在字符串中不存在，则 split() 办法将回来包括原字符串的列表。
下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，运用 split() 办法依照逗号分隔符将其切割成多个子字符串，并将切割后的成果保存到列表 lst 中。终究输出 lst 的值，能够看到该列表包括了切割后的子字符串。

需求留意的是，split() 办法回来的列表中并不包括分隔符自身。假如想要保留分隔符的话，能够运用字符串类型的 splitlines() 办法。

假如期望将一个字符串切割成多个子字符串并将其存储在一个元组中，能够运用元组解包的办法，如下所示：

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

在 Python 中，字符串类型的 rsplit() 办法与 split() 办法相似，都是用来将一个字符串切割成多个子字符串并存储在一个列表中。

不同之处在于，rsplit() 办法是从字符串的右侧开端切割而非从左边开端。该办法回来一个列表，其间包括切割后的子字符串。rsplit() 办法的语法如下：

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

其间，str 表明要进行操作的字符串；sep 表明分隔符，假如不指定分隔符，则运用空格作为默许值；maxsplit 表明最大切割次数，假如指定了该参数，则最多只会切割 maxsplit 次。
下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，运用 rsplit() 办法依照逗号分隔符将其从右侧开端切割成多个子字符串，并将切割后的成果保存到列表 lst 中。在指定了切割次数为 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() 办法能够用于将一个字符串依照指定分隔符分红三部分（分隔符左边部分、分隔符自身和分隔符右侧部分），并存储在一个元组中。

该办法回来一个元组，元组中包括分隔符左边部分、分隔符自身和分隔符右侧部分三个元素。partition() 办法的语法如下：

str.partition(sep)

其间，str 表明要进行操作的字符串；sep 表明分隔符。
下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，运用 partition() 办法依照逗号分隔符将其分红三部分并存储到元组 t 中。终究输出 t 的值，能够看到该元组包括了分隔符左边部分、分隔符自身和分隔符右侧部分三个元素。

需求留意的是，假如分隔符在字符串中不存在，则 partition() 办法将回来一个包括原字符串和两个空字符串的元组。假如要疏忽掉分隔符自身，能够运用 split() 办法。

别的，假如期望将一个字符串分红三部分并将其存储在一个列表中，能够运用列表解包的办法，如下所示：

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

在 Python 中，字符串类型的 rpartition() 办法和 partition() 办法相似，不同之处在于 rpartition() 办法是从字符串的右侧开端分隔而非从左边开端。

rpartition() 办法同样能够用于将一个字符串依照指定分隔符分红三部分（分隔符左边部分、分隔符自身和分隔符右侧部分），并存储在一个元组中。该办法回来一个元组，元组中包括分隔符左边部分、分隔符自身和分隔符右侧部分三个元素。rpartition() 办法的语法如下：

str.rpartition(sep)

其间，str 表明要进行操作的字符串；sep 表明分隔符。
下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，运用 rpartition() 办法依照逗号分隔符将其从右侧开端分红三部分并存储到元组 t 中。终究输出 t 的值，能够看到该元组包括了分隔符左边部分、分隔符自身和分隔符右侧部分三个元素。

需求留意的是，假如分隔符在字符串中不存在，则 rpartition() 办法将回来一个包括两个空字符串和原字符串的元组。假如要疏忽掉分隔符自身，能够运用 split() 办法。别的，假如期望将一个字符串分红三部分并将其存储在一个列表中，能够运用列表解包的办法，如下所示：

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

8 字符串大小写转化：运用 upper()、lower()、capitalize()、swapcase()等办法来进行字符串的大小写转化。

在 Python 中，字符串类型的 upper() 办法能够将一个字符串转化为大写字母方式，并回来转化后的新字符串，原始字符串不会被改动。该办法的语法如下：

str.upper()

其间，str 表明要进行操作的字符串。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，运用 upper() 办法将其转化为大写字母方式，并将转化后的新字符串赋值给变量 t。终究输出 t 的值，能够看到该字符串已被转化为大写字母方式，而原始字符串 s 的值未产生改动。

需求留意的是，upper() 办法只会将字符串中的小写字母转化为大写字母，关于其他字符，如数字、标点符号和大写字母等，不会有任何影响。假如要将一个字符串转化为小写字母方式，则能够运用 lower() 办法。

8.1 Python字符串lower()

在 Python 中，字符串类型的 lower() 办法能够将一个字符串转化为小写字母方式，并回来转化后的新字符串，原始字符串不会被改动。该办法的语法如下：

str.lower()

其间，str 表明要进行操作的字符串。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，运用 lower() 办法将其转化为小写字母方式，并将转化后的新字符串赋值给变量 t。终究输出 t 的值，能够看到该字符串已被转化为小写字母方式，而原始字符串 s 的值未产生改动。

需求留意的是，lower() 办法只会将字符串中的大写字母转化为小写字母，关于其他字符，如数字、标点符号和小写字母等，不会有任何影响。假如要将一个字符串转化为大写字母方式，则能够运用 upper() 办法。

8.2 Python字符串capitalize()

在 Python 中，字符串类型的 capitalize() 办法能够将一个字符串的首字母转化为大写，并回来转化后的新字符串，原始字符串不会被改动。该办法的语法如下：

str.capitalize()

其间，str 表明要进行操作的字符串。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，运用 capitalize() 办法将其首字母转化为大写，并将转化后的新字符串赋值给变量 t。终究输出 t 的值，能够看到该字符串的首字母已经被转化为大写，而原始字符串 s 的值未产生改动。

需求留意的是，capitalize() 办法只会将字符串的榜首个字符转化为大写字母，关于其他字符，如数字、标点符号和小写字母等，不会有任何影响。假如要将一个字符串中的一切单词的首字母都转化为大写字母，则能够运用 title() 办法。

8.3 Python字符串swapcase() 办法

在 Python 中，字符串类型的 swapcase() 办法能够将一个字符串中的大写字母转化为小写字母，一起将小写字母转化为大写字母，并回来转化后的新字符串，原始字符串不会被改动。该办法的语法如下：

str.swapcase()

其间，str 表明要进行操作的字符串。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，运用 swapcase() 办法将其间的大写字母转化为小写字母，一起将小写字母转化为大写字母，并将转化后的新字符串赋值给变量 t。终究输出 t 的值，能够看到该字符串中的一切字母的大小写都产生了反转，而原始字符串 s 的值未产生改动。

需求留意的是，swapcase() 办法只会将字符串中的字母的大小写进行反转，关于其他字符，如数字、标点符号等，不会有任何影响。

9 Python字符串去除空格：运用strip()、lstrip()、rstrip()等办法来去除字符串中的空格。

在 Python 中，字符串类型的 strip() 办法能够用于去除一个字符串最初或完毕的指定字符（默许为空格符），并回来去除指定字符后的新字符串，原始字符串不会被改动。该办法的语法如下：

str.strip([chars])

其间，str 表明要进行操作的字符串；chars 表明要去除的字符，默许为空格符。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，其间包括了最初和完毕的空格符，运用 strip() 办法将其去除空格符，并将去除空格符后的新字符串赋值给变量 t。终究输出 t 的值，能够看到该字符串最初和完毕的空格符已被去除，而原始字符串 s 的值未产生改动。

假如要去除指定的字符，能够在 strip() 办法中指定要去除的字符。例如，下面的比如将去除字符串最初和完毕的逗号（,）：

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

需求留意的是，strip() 办法只会去除字符串最初和完毕的指定字符，在字符串中心的指定字符不会被去除。假如要去除字符串中心的指定字符，能够运用 replace() 办法进行替换。

9.1 Python字符串lstrip()办法

在 Python 中，字符串类型的 lstrip() 办法能够用于去除一个字符串最初的指定字符（默许为空格符），并回来去除指定字符后的新字符串，原始字符串不会被改动。该办法的语法如下：

str.lstrip([chars])

其间，str 表明要进行操作的字符串；chars 表明要去除的字符，默许为空格符。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，其间包括了最初的空格符，运用 lstrip() 办法将其去除空格符，并将去除空格符后的新字符串赋值给变量 t。终究输出 t 的值，能够看到该字符串最初的空格符已被去除，而原始字符串 s 的值未产生改动。

假如要去除指定的字符，能够在 lstrip() 办法中指定要去除的字符。例如，下面的比如将去除字符串最初的逗号（,）：

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

需求留意的是，lstrip() 办法只会去除字符串最初的指定字符，在字符串完毕和中心的指定字符不会被去除。假如要去除字符串完毕和中心的指定字符，能够运用 rstrip() 和 replace() 办法进行替换。

9.2 Python字符串rstrip()办法

在 Python 中，字符串类型的 rstrip() 办法能够用于去除一个字符串完毕的指定字符（默许为空格符），并回来去除指定字符后的新字符串，原始字符串不会被改动。该办法的语法如下：

str.rstrip([chars])

其间，str 表明要进行操作的字符串；chars 表明要去除的字符，默许为空格符。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了一个字符串 s，其间包括了完毕的空格符，运用 rstrip() 办法将其去除空格符，并将去除空格符后的新字符串赋值给变量 t。终究输出 t 的值，能够看到该字符串完毕的空格符已被去除，而原始字符串 s 的值未产生改动。

假如要去除指定的字符，能够在 rstrip() 办法中指定要去除的字符。例如，下面的比如将去除字符串完毕的逗号（,）：

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

需求留意的是，rstrip() 办法只会去除字符串完毕的指定字符，在字符串最初和中心的指定字符不会被去除。假如要去除字符串最初和中心的指定字符，能够运用 lstrip()、strip() 和 replace() 办法进行替换。

10 Python字符串判别：运用startswith()、endswith()、isalnum()、isalpha()、isdigit()、islower()、isupper()等办法来判别字符串的特定属性。

在 Python 中，字符串类型的 startswith() 和 endswith() 办法用于查看一个字符串是否以指定的前缀和后缀最初和完毕，回来一个布尔值 True 或许 False。这两个办法都有两个参数，榜首个参数是要查看的前缀或后缀字符串，第二个参数是可选的，表明要查看的字符串开端和完毕方位的索引规模。 startswith() 办法的语法如下：

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

其间，str 表明要进行操作的字符串；prefix 表明要查看的前缀字符串；start 和 end 表明要查看的字符串开端和完毕方位的索引规模，能够省略不填，默许为整个字符串的开端和完毕方位。 endswith() 办法的语法如下：

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

其间，str 表明要进行操作的字符串；suffix 表明要查看的后缀字符串；start 和 end 表明要查看的字符串开端和完毕方位的索引规模，能够省略不填，默许为整个字符串的开端和完毕方位。 下面是两个简略的比如：

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() 办法查看它们是否以指定的前缀和后缀最初和完毕，终究输出查看成果。能够看到，当字符串以指定的前缀和后缀最初和完毕时，这两个办法都会回来 True，不然回来 False。

需求留意的是，startswith() 和 endswith() 办法都区分大小写，假如要疏忽大小写进行查看，则能够运用 lower() 或 upper() 办法将字符串转化为小写或大写方式后再进行查看。

10.1 Python字符串isalnum()

在 Python 中，字符串类型的 isalnum() 办法用于检测一个字符串是否只由字母和数字组成，回来一个布尔值 True 或许 False。该办法没有任何参数，直接在字符串上调用即可，语法格局如下：

str.isalnum()

其间，str 表明要进行操作的字符串。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了两个字符串 s 和 t，别离运用 isalnum() 办法检测它们是否只由字母和数字组成，终究输出检测成果。能够看到，当一个字符串只由字母和数字组成时，isalnum() 办法回来 True，不然回来 False。

需求留意的是，isalnum() 办法只能检测字符串中是否只由字母和数字组成，关于其他字符，如标点符号、空格、换行符等，则不做任何处理。假如要查看字符串中是否只包括字母，则能够运用 isalpha() 办法；假如要查看字符串中是否只包括数字，则能够运用 isdigit() 办法。

10.2 Python字符串isalpha()

在 Python 中，字符串类型的 isalpha() 办法用于检测一个字符串是否只由字母组成，回来一个布尔值 True 或许 False。该办法没有任何参数，直接在字符串上调用即可，语法格局如下：

str.isalpha()

其间，str 表明要进行操作的字符串。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了两个字符串 s 和 t，别离运用 isalpha() 办法检测它们是否只由字母组成，终究输出检测成果。能够看到，当一个字符串只由字母组成时，isalpha() 办法回来 True，不然回来 False。

需求留意的是，isalpha() 办法只能检测字符串中是否只由字母组成，关于其他字符，如数字、标点符号、空格、换行符等，则不做任何处理。假如要查看字符串中是否只包括字母和数字，则能够运用 isalnum() 办法；假如要查看字符串中是否只包括数字，则能够运用 isdigit() 办法。

10.3 Python字符串isdigit()

在 Python 中，字符串类型的 isdigit() 办法用于检测一个字符串是否只由数字组成，回来一个布尔值 True 或许 False。该办法没有任何参数，直接在字符串上调用即可，语法格局如下：

str.isdigit()

其间，str 表明要进行操作的字符串。 下面是一个简略的比如：

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

在上面的比如中，咱们先界说了两个字符串 s 和 t，别离运用 isdigit() 办法检测它们是否只由数字组成，终究输出检测成果。能够看到，当一个字符串只由数字组成时，isdigit() 办法回来 True，不然回来 False。

需求留意的是，isdigit() 办法只能检测字符串中是否只由数字组成，关于其他字符，如字母、标点符号、空格、换行符等，则不做任何处理。假如要查看字符串中是否只包括数字和字母，则能够运用 isalnum() 办法；假如要查看字符串中是否只包括字母，则能够运用 isalpha() 办法。

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

在 Python 中，字符串类型有 islower() 和 isupper() 办法，用于检测一个字符串是否满是小写或满是大写字母，回来一个布尔值 True 或 False。这两个办法都没有参数，直接在字符串上调用即可，语法格局如下：

str.islower()
str.isupper()

其间，str 表明要进行操作的字符串。 下面是一个简略的比如：

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() 办法检测它们是否满是小写或满是大写字母，终究输出检测成果。

能够看到，当一个字符串满是小写字母时，islower() 办法回来 True；满是大写字母时，isupper() 办法回来 True；不然均回来 False。

需求留意的是，这两个办法只会检测字符串中的字母是否满是小写或满是大写，关于其他字符不做任何处理。假如要查看字符串中的字母是否为首字母大写，能够运用 istitle() 办法。

假如你有爱好，能够重视一下我的综合公众号：biglead

完毕