Python中的字符串常用方法整理概述

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

在上面的例子中，我们先定义了一个字符串 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() 方法。

以上就是Python中的字符串常用方法整理概述的详细内容，更多关于Python字符串常用方法的资料请关注脚本之家其它相关文章！