Python字符串处理全攻略（合集篇）：常用内置方法轻松掌握

2023-12-28 04:19:29

引言

欢迎来到Python的世界！字符串是Python中最基本的数据类型之一，它们就像是文本的小盒子，可以帮我们存储和处理各种各样的文本数据。

Python非常贴心地为我们提供了许多内置方法来处理这些字符串。这些方法就像是魔法工具，可以帮助我们完成各种神奇的文本操作和转换。

今天，我们探索常用的Python字符串内置方法。我会用最简单的语言，通过具体的示例代码，详细解释每个方法的使用方法和应用场景。让我们一起开始这个有趣的Python字符串之旅吧！

Python字符串常用内置方法

str.capitalize()

str.capitalize() 方法是一个非常实用的字符串方法，可以帮助你将字符串的首字母转换为大写字母，同时保持其他字母的小写形式。这在很多文本处理任务中都非常有用，例如在处理用户输入或格式化文本时。

语法

str.capitalize()

示例

s1 = "hello world"
print(s1.capitalize())  # 输出 "Hello world" (将字符串的首字母转换为大写字母)

s2 = "HELLO WORLD"
print(s2.capitalize())  # 输出 "HELLO WORLD"（除首字母外，其他字母转换为小写字母）

s3 = "12345"
print(s3.capitalize())  # 输出 "12345"（数字和标点符号不转换）  

s4 = " hello!"
print(s4.capitalize())  # 输出 " hello!"（如果字符串的第一个字符是数字/标点符号/空格字符，则该方法不会做任何转换）

运行结果

在这里插入图片描述

注意事项

如果字符串的第一个字符是数字或标点符号或空格字符，则该方法不会做任何转换。
如果字符串只包含非字母字符，则该方法返回原始字符串。
如果字符串全是大写，则该方法除首字母外，其他字母转换为小写字母。
该方法返回一个新的字符串，原始字符串不会被修改。

str.upper()

str.upper()方法可以帮助你将字符串中的所有小写字母转换为大写字母。

语法

str.upper()

示例

基本使用

s = "Hello, World!"
print(s.upper())  # 输出: HELLO, WORLD!

非字符串类型的情况

s = 42
print(s.upper())  # 输出: AttributeError: 'int' object has no attribute 'upper'

空字符串的情况

s = ""
print(s.upper())  # 输出: ''

注意事项

upper()方法返回字符串的全体大写形式。对于英文字符，这通常是将所有小写字母转换为大写字母。对于非英文字符，情况就比较复杂，因为这些字符可能没有对应的大写形式。例如，一些语言中的特殊字符在转换为大写后可能会失去一些语义信息。
upper()方法只能用于字符串类型的变量。如果尝试在非字符串类型的变量（如整数或浮点数）上使用upper()方法，将会引发TypeError。
对于空字符串，upper()方法返回的仍然是空字符串。这是因为空字符串没有大写形式。
在某些情况下，可能需要使用其他字符串方法（如capitalize()）来获得期望的文本转换效果。这些方法可以更精细地控制文本的转换方式。

str.lower()

str.lower()方法可以帮助你将字符串中的所有大写字母转换为小写字母。这在很多文本处理任务中都非常有用，例如在比较两个字符串是否相等、将用户输入统一格式化等场景中。由于它不会删除大小写差异，因此在需要保留原始大小写格式的场景中，应使用str.lower()方法。

语法

str.lower()

示例

s = "Hello World"
print(s.lower())  # 输出 "hello world"

注意事项

str.lower()方法只将大写字母转换为小写字母，不会删除任何字符或空格。
与str.casefold()方法相比，str.lower()方法更简单、更快速，因为它不删除大小写差异。
str.lower()方法返回一个新的字符串，原始字符串不会被修改。

str.center()

str.center() 方法用于将字符串居中，并使用空格或其他字符进行填充。它常用于格式化输出，使字符串在指定的宽度内居中对齐。在使用该方法时，需要注意 width 和 fillchar 参数的使用，以确保得到正确的结果。

语法

str.center(width, fillchar=None)

语法说明：

str.center(width)：将字符串居中，使用空格填充到指定的宽度。如果字符串的长度已经超过了指定的宽度，则返回原始字符串。
str.center(width, fillchar)：将字符串居中，使用指定的字符填充到指定的宽度。如果字符串的长度已经超过了指定的宽度，则返回原始字符串。

示例

s = "Hello, World!"
print(s.center(20))       
print(s.center(20, '-'))
print(s.center(20, '0'))

运行结果：
在这里插入图片描述

注意事项

width 参数必须是一个非负整数，表示要填充的宽度。
fillchar 参数是可选的，默认为 None。如果提供了该参数，则使用指定的字符进行填充。如果未提供该参数，则使用空格进行填充。
如果字符串的长度已经超过了指定的宽度，则返回原始字符串。
该方法返回一个新的字符串，原始字符串不会被修改。

str.count()

str.count()方法可以用于计算字符串中某个子字符串的出现次数，也可以用于计算字符串中某个子字符串在指定范围内的出现次数。

语法

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

示例

计算字符串中某个子字符串的出现次数：

s = "Hello, world! This is a test string."
count = s.count("world")
print(count)  # 输出 1

计算字符串中某个子字符串在指定范围内的出现次数：

s = "Hello, world! This is a test string."
count = s.count("world", 10, 20)
print(s[10:20])
print(count)  # 输出 0，因为"world"在[10, 20)范围内没有出现
count = s.count("world", 0, 15)
print(s[:15])
print(count)  # 输出 1，因为"world"在[0,15)范围内出现过

运行结果：

在这里插入图片描述

计算字符串中所有字符的出现次数：

s = "Hello, world!"
count = s.count(s)
print(count)  # 输出 1，因为s中只有一个"s"字符出现一次

计算字符串中多个子字符串的出现次数：

s = "Hello, world! This is a test string."
count1 = s.count("Hello")
count2 = s.count("world")
count3 = s.count("test")
print(count1, count2, count3)  # 输出 1 1 1，因为"Hello"、"world"和"test"各出现一次

注意事项

如果子字符串不存在于字符串中，则返回0。
如果start或end参数超出字符串范围或未指定，则默认为0和字符串的长度。
如果start或end参数为负数，则将其视为从字符串末尾开始的偏移量。
str.count()方法不会修改原始字符串。
在使用str.count()方法时，应注意与其他方法结合使用以获得更好的效果。例如，可以使用str.find()方法查找子字符串的位置，然后使用str.count()方法计算子字符串的出现次数。

str.endswith()

str.endswith()方法检查字符串是否以指定的后缀结尾，如果是则返回True，否则返回False。

语法

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

示例

不指定起始和结束索引

s = "Hello, World!"
print(s.endswith("World!"))  # 输出: True

指定起始和结束索引

s = "Hello, World!"
print(s.endswith("World!", 7, 13))  # 输出: True

不匹配的情况

s = "Hello, World!"
print(s.endswith("Python"))  # 输出: False

空字符串的情况

s = "Hello, World!"
print(s.endswith(""))  # 输出: True，因为任何字符串都以空字符串结尾

非字符串类型的情况

s = "Hello, World!"
print(s.endswith(42))  # 报错，因为endswith只接受字符串类型的参数

报错如下
在这里插入图片描述

注意事项

endswith()方法只检查字符串的结尾，所以它从字符串的末尾开始比较。
如果要检查的子串不在字符串的末尾，该方法返回False。
endswith()方法对大小写敏感，所以"Hello"和"hello"是不同的。
如果提供了start和end参数，那么比较将在指定的范围内进行。这意味着，例如，对于字符串"Hello, World!"，s.endswith("World!", 7, 13)将返回True，而s.endswith("World!", 0, 5)将返回False。
endswith()方法不能接受非字符串类型的参数。尝试这样做将引发TypeError。
空字符串""是任何字符串的结尾，所以s.endswith("")将返回True。

str.find()

str.find()方法返回子字符串在字符串中第一次出现的索引位置，如果没有找到则返回-1。

语法

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

示例

查找子串的位置

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

子串不存在的情况

s = "Hello, World!"
print(s.find("Python"))  # 输出: -1

使用起始和结束索引

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

查找子串并获取子串

s = "Hello, World!"
result = s.find("World")
print(result, s[result:result+5])  # 输出: 7 World

子串为空字符串的情况

s = "Hello, World!"
print(s.find(""))  # 输出: 0，因为空字符串是任何字符串的子串，并且其位置为0

注意事项

find()方法返回子串在字符串中第一次出现的位置。如果没有找到子串，则返回-1。
start和end参数是可选的，用于指定搜索的子串范围。如果不指定这些参数，则默认在整个字符串中进行搜索。
如果子串为空字符串，则它在任何字符串中都存在，并且其位置为0。
find()方法对大小写敏感，所以"Hello"和"hello"是不同的。但是，可以使用lower()或casefold()方法进行大小写不敏感的搜索。
find()方法不支持正则表达式。如果需要使用正则表达式进行搜索，可以使用re模块中的search()或findall()方法。
在使用start和end参数时，请确保指定的范围是有效的，否则可能会引发ValueError。

str.title()

str.title() 方法是一个非常实用的字符串方法，可以将字符串中每个单词的首字母转换为大写，其余部分转换为小写。

语法

str.title()

示例

字符串中的每个单词首字母大写

s = "hello world, this is a test"
print(s.title())  # 输出: Hello World, This Is A Test

非英文字符的处理

s = "你好，世界！"
print(s.title())  # 输出: 你好，世界！，不会进行大小写转换，仅将每个单词的首字母转换为大写。

与split()结合使用

s = "heLLo woRLd"
print(" ".join(s.split()).title())  # 输出: Hello World

运行结果：

在这里插入图片描述

处理特殊字符

s = "hello-world"
print(s.title())  # 输出: Hello-World，特殊字符保持不变。

注意事项

title()方法会将字符串中每个单词的首字母转换为大写，其余部分转换为小写。对于英文字符，这通常是将每个单词的首字母转换为大写。对于非英文字符，情况就比较复杂，因为这些字符可能没有对应的大写形式。例如，一些语言中的特殊字符在转换为大写后可能会失去一些语义信息。
title()方法只作用于空格分隔的单词。它不会对标点符号或其他特殊字符进行任何处理。因此，如果字符串中包含标点符号或其他特殊字符，它们将保持不变。
title()方法不会删除字符串中的空格或其他空白字符。如果需要删除这些字符，可以使用strip()方法或replace()方法来处理。
title()方法不会修改原始字符串。它会返回一个新的字符串，其中每个单词的首字母都已转换为大写。原始字符串保持不变。

str.replace()

str.replace() 是 Python 中字符串对象的一个方法，用于在字符串中替换指定的子串。这个方法接受两个参数：要被替换的子串（old）和用来替换的新子串（new）。

语法

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

old：需要被替换的子串。
new：用来替换的新子串。
count：可选参数，指定替换的次数。如果不指定，将替换所有匹配项。如果指定了某个数值，则只替换前count个匹配项。

示例

常规操作

s = "Hello, World!"
print(s.replace("World", "Python"))  # 输出: "Hello, Python!"

指定count参数，将","替换两次

s = "apple,banana,cherry"
print(s.replace(",", ";", 2))  # 输出: "apple;banana;cherry" <--- 替换两次

若不指定count参数，默认替换所有匹配项

s = "apple,banana,cherry"
print(s.replace("a", "o"))  # 输出: "opple,bonono,cherry"

用其它字符替换空字符串

s = "apple,banana,cherry"
print(s.replace("", "X"))  # 输出: "XaXpXpXlXeX,XbXaXnXaXnXaX,XcXhXeXrXrXyX"

替换部分字符为空字符串

s = "apple,,cherry"
print(s.replace(",", ""))  # 输出: "applecherry"

注意事项

replace()方法返回一个新的字符串，原始字符串不会被修改。
如果old参数为空字符串，则字符串每个字符之间都会添加new参数指定的字符串（示例4）。
如果new参数为空字符串，则匹配到的子串会被删除（示例5）。

str.join()

str.join() 用于将一个可迭代对象（如列表或元组）中的所有元素连接成一个新的字符串。

语法

str.join(iterable[, separator])

iterable：可迭代对象，如列表或元组。
separator：可选参数，指定连接元素之间的分隔符。如果不指定，默认为空字符串。

示例

常规操作

以空格字符作为分隔符，拼接字符串"Hello"和"world"

words = ["Hello", "world"]
print(" ".join(words))  # 输出: "Hello world"

使用自定义分隔符

以逗号+空格字符作为分隔符：

words = ["apple", "banana", "cherry"]
print(", ".join(words))  # 输出: "apple, banana, cherry"

注意事项

str.join()方法返回一个新的字符串，原始的可迭代对象不会被修改。
如果可迭代对象中的元素不是字符串类型，将会引发TypeError。因此，在使用str.join()方法之前需要确保可迭代对象中的元素都是字符串类型。
如果不指定分隔符，则默认使用空字符串作为分隔符。这意味着所有元素将会被连接成一个连续的字符串。

str.split()

str.split() 可用于将字符串按照指定的分隔符进行切割，返回一个列表。

语法

str.split(separator, maxsplit)

separator：可选参数，指定分隔符。可以是任意字符串，默认为 None。如果没有指定分隔符，则默认按照空格进行切割
maxsplit：可选参数，指定最大分割次数。如果指定了该参数，则最多会按照 maxsplit 次分隔符进行切割。

示例

常规操作

用空格作为分隔符分割字符串s

s = "Hello, World!"
print(s.split())  # 输出: ['Hello,', 'World!']

指定","作为分隔符

s = "apple,banana,cherry"
print(s.split(","))  # 输出: ['apple', 'banana', 'cherry']

指定最大分割次数为2

s = "apple,banana,cherry,orange"
print(s.split(",", 2))  # 输出: ['apple', 'banana', 'cherry,orange']

注意事项

str.split() 方法返回一个列表，列表中的每个元素是原字符串根据分隔符分割后的子串。
如果省略了 separator 参数，则默认按照空格进行切割。但是，如果字符串中有连续的空格，则它们也会被视为分隔符。
maxsplit 参数是可选的，如果不指定，则默认会分割所有可能的子串。如果指定了该参数，则最多会按照 maxsplit 次分隔符进行切割。需要注意的是，如果 maxsplit 的值大于实际分隔符的数量，则只会分割出有限个子串。

str.strip()

str.strip() 可用于删除字符串两端的空白字符（包括空格、换行符、制表符等）。

语法

str.strip([chars])

chars：可选参数，指定要删除的字符。如果不指定，将删除所有空白字符。

示例

常规操作

s = "   Hello, World!   "
print(s.strip())  # 输出: "Hello, World!"

指定要删除的字符

s = "#$# Hello, World! #$#"
print(s.strip("#$"))  # 输出: "Hello, World!"

不指定字符，删除所有空白字符

s = " \n \t Hello, World! \n \t "
print(s.strip())  # 输出: "Hello, World!"

注意事项

strip()方法返回一个新的字符串，原始字符串不会被修改。
如果不指定chars参数，strip()方法将删除所有空白字符（包括空格、换行符、制表符等）。如果指定了chars参数，它将删除指定的字符。如果chars参数为空字符串，则不会删除任何字符。

str.zfill()

str.zfill() 可用于在字符串的左侧填充零，以达到指定的宽度。这个方法接受一个参数，即要填充的宽度。

语法

str.zfill(width)

width：指定填充后的字符串总宽度。

示例

常规操作

s = "111"
print(s.zfill(5))  # 输出: "00111"

填充宽度大于字符串长度的情况

s = "111"
print(s.zfill(10))  # 输出: "000000111"

填充宽度小于字符串长度的情况

s = "111111"
print(s.zfill(3))  # 输出: "111111"

处理特殊字符的情况

s = "-11"
print(s.zfill(5))

s = "+11"
print(s.zfill(5))

s = "#11"
print(s.zfill(5))

s = "%11"
print(s.zfill(5))

运行结果：

在这里插入图片描述

使用负数作为宽度参数的情况

s = "11"
print(s.zfill(-5))  # 输出: "11"

注意事项

zfill()方法返回一个新的字符串，原始字符串不会被修改。
如果指定的宽度大于原始字符串的长度，则会在原始字符串的左侧填充零，直到达到指定的宽度。
如果指定的宽度小于原始字符串的长度，则返回原始字符串，不会进行任何修改。

str.index()

功能介绍

index() 可用于查找子字符串在字符串中首次出现的位置。如果找不到子字符串，则会引发一个 ValueError 异常。

语法

str.index(sub, start=0, end=len(string))

sub：要查找的子字符串。
start 和 end：可选参数，指定查找的子字符串的起始和结束位置。

示例：

使用起始和结束位置：

s = "hello world, how are you?"
print(s[6:15])  # world, ho
print(s.index("world", 6, 15))  # 输出: 6

s = "hello world, how are you?"
print(s[8:15])  # rld, ho
print(s.index("world", 8, 15))  # 输出: ValueError: substring not found

查找不存在的子字符串：

s = "hello world"
try:
    print(s.index("python"))  # 会引发 ValueError 异常
except ValueError as e:
    print(e)  # 输出: 'substring not found'

使用负数索引：

s = "hello world"
print(s.index("r", -5, -2))  # 输出: 8 (从倒数第5个字符开始，到倒数第3个字符为止，找到第一个 'r')

s = "hello world"
print(s.index("l", -5, -2))  # 输出: ValueError: substring not found (从倒数第5个字符开始，到倒数第3个字符为止，找到第一个 'l')

注意事项

当使用 index() 方法时，应确保要查找的子字符串确实存在于原始字符串中，否则会引发异常。为了避免异常，可以使用 find() 方法代替，它在找不到子字符串时会返回 -1 而不是引发异常。
使用负数索引时，注意索引的有效范围。在 Python 中，-1 表示最后一个字符，-2 表示倒数第二个字符，以此类推。
当使用起始和结束位置参数时，应确保这些参数的有效性，即它们不应该超出字符串的长度或为负数。否则，ValueError 异常会被引发。
如果查找的子字符串有多个相同的实例，index() 方法只会返回第一个实例的位置。如果需要找到所有实例的位置，可以考虑使用其他方法或自己编写循环来遍历并查找。
注意大小写敏感性。默认情况下，index() 方法是大小写敏感的，所以 “Hello” 和 “hello” 是不同的字符串。如果要进行大小写不敏感的比较，可以先将字符串转换为全部小写或全部大写。

总结

index() 方法是一个非常实用的字符串方法，用于查找子字符串在字符串中的位置。但使用时需要注意可能引发的异常和索引的有效范围。与 find() 方法相比，index() 方法更为严格，要求子字符串必须存在。在实际应用中，可以根据需求选择使用 index() 或 find() 方法。

str.startswith()

功能介绍

startswith() 可用于检查字符串是否以指定的前缀开始。如果字符串以给定的前缀开始，则返回 True，否则返回 False。

语法

str.startswith(prefix, start=0, end=len(string))

prefix：要检查的前缀。
start 和 end：可选参数，表示在字符串的哪个范围内进行前缀检查。

示例

常规操作

s = "hello world"
print(s.startswith("hello"))  # 输出: True
print(s.startswith("world"))  # 输出: False

使用 start 和 end 参数：

s = "hello world"
print(s[3:])
print(s.startswith("lo", 3))  # 输出: True
print(s[2:6])
print(s.startswith("lo", 2, 6))  # 输出: False

运行结果：

在这里插入图片描述

注意事项

startswith() 是大小写敏感的，所以 “Hello” 和 “hello” 被视为不同的前缀。
如果要忽略大小写，可以先将字符串转换为全小写或全大写，然后再使用 startswith()。
注意 start 和 end 参数是可选的，默认情况下它们分别为 0 和字符串的长度。这表示整个字符串都会被检查。
如果提供的 prefix 是空字符串，则任何字符串都会返回 True，因为任何非空字符串都以空字符串开始。

str.expandtabs()

功能介绍

expandtabs() 可用于将字符串中的制表符（\t）转换为一定数量的空格。该方法默认将制表符转换为 8 个空格，但也可以通过提供一个可选参数来指定不同的空格数量。

语法

str.expandtabs(tabsize=8)

tabsize：可选参数，指定转换后的制表符应占用的空格数量。默认值为 8。

示例

常规操作

s = "hello\tworld"
print(s.expandtabs())  # 输出: 'hello    world'（其中 \t 被替换为 8 个空格）

指定不同的 tabsize：

s = "a\tb\tc\td"
print(s.expandtabs(2))  # 输出: 'a b c d'（每个 \t 被替换为 2 个空格）

在字符串中有多个制表符：

s = "a\tb\tc\td"
print(s.expandtabs(2))  # 输出: 'a       b       c       d'（每个 \t 被替换为 8 个空格）

tabsize 为 0 的情况：

s = "h\te\tl\tl\to\tworld"
print(s.expandtabs(0))  # 输出: 'helloworld'（\t 被完全删除）

使用 expandtabs() 处理多行(字符串含有\n)字符串：

s = "line1\tcol2\nline2\tcol2"
print(s.expandtabs(2))  # 输出:（每一行的 \t 都被替换为 2 个空格）
# line1 col2
# line2 col2

注意事项

expandtabs() 方法返回一个新的字符串，原始字符串不会被修改（因为字符串在 Python 中是不可变的）。
如果 tabsize 参数小于 1，该方法将制表符视为零宽度，从而删除它们。
如果一个字符串中有多个制表符，它们都将被转换为相同数量的空格。
该方法在处理多行文本时特别有用，因为它可以确保文本在具有固定宽度字体的编辑器或控制台中正确对齐。

总结

expandtabs() 方法提供了一种简单的方式来处理字符串中的制表符，使它们可以被转换为一定数量的空格。这对于格式化文本、确保文本对齐或在处理从其他来源获取的包含制表符的文本时非常有用。通过调整 tabsize 参数，你可以控制转换后的空格数量，以适应不同的格式需求。

str.splitlines()

功能介绍

splitlines() 可用于根据行边界符来拆分字符串。该方法返回一个列表，其中每个元素都是原始字符串的一行。默认情况下，splitlines() 会考虑所有常见的行边界符，如换行符 \n、回车符 \r 以及回车加换行 \r\n。

语法

str.splitlines(keepends=False)

keepends：可选参数。默认为 False，意味着返回的行不包括行边界符。如果设为 True，则返回的行会保留行边界符。

示例

常规操作

text = "Hello\nWorld\n"
lines = text.splitlines()
print(lines)  # 输出: ['Hello', 'World']

使用 keepends=True：

text = "Hello\nWorld\n"
lines = text.splitlines(keepends=True)
print(lines)  # 输出: ['Hello\n', 'World\n']

处理混合的行边界符：

text = "Hello\r\nWorld\nPython"
lines = text.splitlines()
print(lines)  # 输出: ['Hello', 'World', 'Python']

空字符串和只有一个行边界符的字符串：

text1 = ""
text2 = "\n"
print(text1.splitlines())  # 输出: []
print(text2.splitlines())  # 输出: [''] 或（如果 keepends=True）['\n']

使用非常见的行边界符：

text = "Hello\vWorld"  # \v 是垂直制表符，也可以作为行边界符
lines = text.splitlines()
print(lines)  # 输出: ['Hello', 'World']

注意事项

splitlines() 方法不会改变原始字符串。
如果字符串为空或只包含行边界符，那么返回的列表可能为空或只包含空字符串。具体取决于 keepends 参数的设置。
该方法对于处理文本文件或需要按行操作的文本数据非常有用。
不同的操作系统可能使用不同的行边界符 ? 使用 splitlines() 可以确保跨平台的兼容性。
splitlines() 只考虑行边界符，不会根据其他字符（如空格或制表符）来拆分字符串。

总结

splitlines() 是一个在处理文本数据时非常有用的方法，特别是当你需要按行操作或解析文本文件时。它提供了一个简单的方式来拆分字符串成行，并允许你选择是否保留行边界符。

str.swapcase()

功能介绍

swapcase() 可用于将字符串中的所有大写字母转换为小写字母，所有小写字母转换为大写字母。

语法

str.swapcase()

示例

常规操作

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

处理全大写或全小写的字符串：

s1 = "HELLO"
print(s1.swapcase())  # 输出: hello
s2 = "world"
print(s2.swapcase())  # 输出: WORLD

注意事项

swapcase() 方法不会改变原始字符串。它会返回一个新的字符串，该字符串是原始字符串的大小写转换版本。原始字符串保持不变。
该方法不会考虑非字母字符的大小写状态，只转换字母部分。非字母字符保持不变。
在处理多个字符的字符串时，要确保正确处理字符串中的每个字符。大小写转换可能会影响字符串的语义和格式。
在处理用户输入或来自不可靠源的字符串时，要格外小心，因为大小写转换可能会导致意外的结果或安全问题（例如，将敏感信息从大写转换为小写）。

切片

功能介绍

Python 字符串的切片方法允许我们提取字符串的子串。通过切片，我们可以指定起始索引、结束索引以及步长来提取字符串的一部分。这种方法非常灵活，使得在字符串处理和文本分析时非常方便。

语法

substring = string[start:end:step]

string：要进行切片的原始字符串。
start：起始索引，包含该索引对应的字符。如果省略，默认为 0。
end：结束索引，不包含该索引对应的字符。如果省略，默认为字符串的长度。
step：步长，表示每隔多少个字符提取一个字符。如果省略，默认为 1。

示例

常规操作

string = "Hello, World!"
substring = string[0:5]  # 提取从索引 0 到 4 的子串
print(substring)  # 输出: Hello

省略起始索引

string = "Hello, World!"
substring = string[:5]  # 省略起始索引，相当于从索引 0 开始提取
print(substring)  # 输出: Hello

省略结束索引：

string = "Hello, World!"
substring = string[7:]  # 省略结束索引，提取从索引 7 到字符串末尾的子串
print(substring)  # 输出: World!

使用负索引：

string = "Hello, World!"
substring = string[-6:]  # 使用负索引，从倒数第 6 个字符开始提取到字符串末尾
print(substring)  # 输出: World!

使用步长：

string = "Hello, World!"
substring = string[::3]  # 使用步长为 3，提取每隔两个字符的子串
print(substring)  # 输出: Hl r!

注意事项

切片方法不会修改原始字符串，而是返回一个新的字符串。
切片方法的索引可以是负数，表示从字符串末尾开始计数。例如，-1 表示最后一个字符，-2 表示倒数第二个字符，以此类推。
如果起始索引大于结束索引，或者步长为负数时起始索引小于结束索引，那么切片方法将返回一个空字符串。
步长可以为负数，表示从后向前提取字符。此时，起始索引应该大于结束索引。
如果省略了起始索引、结束索引或步长中的任何一个参数，切片方法将使用默认值。默认值分别为 0、字符串长度和 1。

str.isalpha()

功能介绍

isalpha() 可用于检查字符串中的所有字符是否都是字母。如果字符串中的所有字符都是字母并且字符串不为空，则返回 True，否则返回 False。

语法

string.isalpha()

string：要检查的字符串。

示例

# 检查纯字母字符串
s = "Hello"
print(s.isalpha())  # 输出: True

# 检查包含非字母字符的字符串
s = "Hello123"
print(s.isalpha())  # 输出: False

# 检查空字符串
s = ""
print(s.isalpha())  # 输出: False

# 检查包含特殊字符的字符串
s = "HelloWorld!!!"
print(s.isalpha())  # 输出: False

运行结果：

在这里插入图片描述

注意事项

isalpha() 方法是区分大小写的，因此大写和小写字母都被认为是字母。
如果字符串中包含任何非字母字符（如数字、标点符号、空格等），isalpha() 方法将返回 False。
空字符串也会使 isalpha() 方法返回 False。
isalpha() 方法不会改变原始字符串。它只是进行检查并返回结果。
在使用 isalpha() 方法之前，最好确保字符串已经被正确初始化，以避免出现错误或异常。

str.isdigit()

功能介绍

isdigit()可用于检查字符串是否只包含数字字符。如果字符串中的所有字符都是数字，则返回 True，否则返回 False。

语法

string.isdigit()

string：要检查的字符串。

示例

# 检查纯数字字符串
s = "1235"
print(s.isdigit())  # 输出: True

# 检查包含非数字字符的字符串
s = "123abc"
print(s.isdigit())  # 输出: False

# 检查空字符串
s = ""
print(s.isdigit())  # 输出: False

# 检查包含特殊字符的字符串
s = "12345!!!"
print(s.isdigit())  # 输出: False

运行结果：

在这里插入图片描述

注意事项

isdigit() 方法只检查字符串是否只包含数字字符，对于其他字符（如字母、特殊字符等）会返回 False。
如果字符串中包含非数字字符，即使大部分字符是数字，该方法也会返回 False。
如果字符串为空，该方法返回 False。
如果需要同时检查多个条件（例如，检查字符串是否只包含字母和数字），可以结合使用其他字符串方法。
在使用 isdigit() 方法之前，最好确保字符串已经被正确初始化，以避免出现错误或异常。

总结

isdigit() 方法允许我们快速检查一个字符串是否只包含数字字符。这在数据清洗、格式验证或输入处理等场景中非常有用。通过结合使用其他字符串方法，我们可以更灵活地处理和分析文本数据。

str.isalnum()

功能介绍

isalnum() 可用于检查字符串中的所有字符是否都是字母或数字。如果字符串中的所有字符都是字母或数字，并且字符串不为空，则返回 True，否则返回 False。

语法

string.isalnum()

string：要检查的字符串。

示例

# 检查纯字母和数字字符串
s = "Hello123456"
print(s.isalnum())  # 输出: True

# 检查包含特殊字符的字符串
s = "Hello#World"
print(s.isalnum())  # 输出: False

# 检查空字符串
s = ""
print(s.isalnum())  # 输出: False

注意事项

isalnum() 方法是区分大小写的，因此大写和小写字母都被认为是字母，数字包括0-9。
如果字符串中包含任何非字母或数字字符（如标点符号、空格等），isalnum() 方法将返回 False。
空字符串也会使 isalnum() 方法返回 False。
isalnum() 方法不会改变原始字符串。它只是进行检查并返回结果。
在使用 isalnum() 方法之前，最好确保字符串已经被正确初始化，以避免出现错误或异常。

总结

isalnum() 方法允许我们快速检查一个字符串是否只包含字母或数字。这在验证用户输入、处理文本数据或进行字符串分析时非常有用。通过结合使用其他字符串方法，我们可以更灵活地处理和分析文本数据。

str.isupper()

功能介绍

isupper() 可用于检查字符串中的所有字符是否都是大写字母。如果字符串中的所有字符都是大写字母并且字符串不为空，则返回 True，否则返回 False。

语法

string.isupper()

string：要检查的字符串。

示例

# 检查全大写字母的字符串
s = "HELLO"
print(s.isupper())  # 输出: True

# 检查包含大写和小写字母的字符串
s = "Hello"
print(s.isupper())  # 输出: False

# 检查全小写字母的字符串
s = "hello"
print(s.isupper())  # 输出: False

# 检查空字符串
s = ""
print(s.isupper())  # 输出: False

# 检查包含数字和特殊字符的字符串
s = "HELLO123!"
print(s.isupper())  # 输出: True

注意事项

isupper() 方法是区分大小写的，因此大写和小写字母的处理方式是不同的。
如果字符串中除了大写字母外，还包含非字母字符，如数字、标点符号等，isupper() 方法将返回 True。
空字符串会使 isupper() 方法返回 False。
isupper() 方法不会改变原始字符串。它只是进行检查并返回结果。
在使用 isupper() 方法之前，最好确保字符串已经被正确初始化，以避免出现错误或异常。
如果需要同时检查多个条件（例如，检查字符串是否只包含大写字母和数字），可以结合使用其他字符串方法（如 isalnum()）。

str.islower()

功能介绍

islower() 可用于检查字符串中的所有字母是否都是小写。如果字符串中的所有字母都是小写字母，则返回 True，否则返回 False。

语法

string.islower()

string：要检查的字符串。

示例

# 检查全小写字母的字符串
s = "hello"
print(s.islower())  # 输出: True

# 检查包含大写字母的字符串
s = "Hello"
print(s.islower())  # 输出: False

# 检查包含数字和小写字母的字符串
s = "123hello"
print(s.islower())  # 输出: True

# 检查空字符串
s = ""
print(s.islower())  # 输出: False

注意事项

islower() 方法是区分大小写的，因此只有小写字母才会被视为有效的字母。数字、标点符号或其他非字母字符都不会影响该方法的返回值。
如果字符串为空，islower() 方法将返回 False
在使用 islower() 方法之前，应确保字符串已经被正确初始化，以避免出现错误或异常。
如果你需要同时检查多个条件（例如，检查字符串是否只包含小写字母和数字），可以结合使用其他字符串方法（如 isalnum()）。

str.isspace()

功能介绍

isspace() 可用于检查字符串中的所有字符是否都是空白字符。空白字符包括空格、制表符、换行符等。如果字符串中的所有字符都是空白字符，则返回 True，否则返回 False。

语法

string.isspace()

string：要检查的字符串。

示例

# 检查全空白字符的字符串
s = " \t\n"
print(s.isspace())  # 输出: True

# 检查包含非空白字符的字符串
s = " hello"
print(s.isspace())  # 输出: False

# 检查只包含空格的字符串
s = "  "
print(s.isspace())  # 输出: True

# 检查空字符串
s = ""
print(s.isspace())  # 输出: False

运行结果

在这里插入图片描述

注意事项

isspace() 方法只检查空白字符，包括空格、制表符、换行符等，但不包括其他特殊字符。因此，如果字符串中包含非空白字符，该方法将返回 False;
如果字符串为空，isspace() 方法将返回 False;
在使用 isspace() 方法之前，应确保字符串已经被正确初始化，以避免出现错误或异常。

总结

isspace() 方法是一个非常有用的工具，用于检查字符串中的字符是否全部为空白字符。在处理文本数据、验证用户输入或进行其他与字符串相关的操作时，该方法非常实用。通过结合其他字符串方法，可以更灵活地处理和分析文本数据。

str.rfind()

功能介绍

str.rfind() 可用于在字符串中从右向左查找子串，并返回子串的最高索引位置。如果未找到子串，则返回 -1。

语法

string.rfind(substring, start=0, end=len(string))

string：要查找的原始字符串。
substring：要查找的子串。
start（可选）：开始查找的位置，默认为 0。
end（可选）：结束查找的位置，默认为字符串的长度。

示例

# 查找子串并返回索引
s = "Hello, World!"
index = s.rfind("World")  # 从右向左查找 "World" 子串
print(index)  # 输出: 7

# 查找子串并返回最高索引
s = "Hello, World!"
index = s.rfind("o")  # 从右向左查找查找第一个 "o" 子串
print(index)  # 输出: 8

# 在指定范围内查找子串
s = "Hello, World!"
index = s.rfind("o", 2, 3)  # 在索引 2 到 3 之间查找 "o" 子串
print(index)  # 输出: -1（未找到）

index = s.rfind("o", 2, 5)  # 在索引 2 到 5 之间查找 "o" 子串
print(index)  # 输出: 4

# 使用负索引进行查找
s = "Hello, World!"
index = s.rfind("o", -5, -1)  # 从倒数第 5 个字符开始到字符串末尾查找 "o" 子串
print(index)  # 输出: 8

注意事项

str.rfind() 方法从右向左查找子串，因此需要指定开始和结束的索引范围。如果不指定范围，将从字符串的开头开始查找。
如果未找到子串，该方法将返回 -1。因此，在处理返回值时，应确保进行适当的检查，以避免出现异常或错误。
与其他字符串方法一样，应确保在调用 str.rfind() 方法之前，字符串已经被正确初始化。
在使用负索引时，应确保索引的有效性，以避免出现意外的结果。负索引表示从字符串的末尾开始计数的位置。

总结

str.rfind() 方法可用于从右向左查找子串并返回其最高索引位置。通过指定开始和结束的索引范围，可以更灵活地控制查找操作。在处理文本数据、解析字符串或进行其他与字符串相关的操作时，该方法非常有用。

str.rindex()

功能介绍

str.rindex() 可用于从字符串的末尾开始搜索指定的子串，并返回其最大的索引位置。如果找不到子串，将抛出 ValueError 异常。

语法

string.rindex(sub, start=0, end=len(string))

string：要搜索的字符串。
sub：要查找的子串。
start（可选）：开始搜索的位置，默认为 0。
end（可选）：结束搜索的位置，默认为字符串的长度。

示例

# 在字符串中找到指定子串的最大索引位置
s = "hello world"
index = s.rindex("o")  # 从末尾开始搜索 "o" 的位置
print(index)  # 输出: 7

# 使用可选的 start 和 end 参数进行子串搜索
s = "hello world"
index = s.rindex("o", 2, 6)  # 在 [2, 6) 范围内从末尾开始搜索 "o" 的位置
print(index)  # 输出: 4

# 在字符串中找不到指定子串时抛出 ValueError 异常
s = "hello world"
try:
    index = s.rindex("x")  # 在末尾开始搜索 "x" 的位置，但找不到
    print("1111", index)  # 这行代码不会执行，因为会抛出异常
except ValueError as e:
    print(e)  # 输出: substring not found

运行结果：

在这里插入图片描述

注意事项

str.rindex() 方法从字符串的末尾开始搜索子串，因此返回的是子串在字符串中最大的索引位置。如果需要从字符串的开头开始搜索子串，可以使用 str.index() 方法。
如果未找到指定的子串，str.rindex() 方法将抛出 ValueError 异常。因此，在实际应用中，最好使用 try-except 块来捕获该异常，并进行相应的处理。
需要注意的是，str.rindex() 方法的参数 start 和 end 是可选的，它们的默认值分别为 0 和字符串的长度。这意味着如果不指定这些参数，搜索将在整个字符串中进行。

总结

str.rindex() 方法是一个非常实用的字符串方法，用于从字符串的末尾开始搜索指定的子串，并返回其最大的索引位置。在实际应用中，它可以帮助我们快速找到子串在字符串中的位置，特别是在需要从末尾开始搜索的场景中。然而，我们需要注意处理未找到子串的情况，以避免抛出异常。

str.format()

功能介绍

str.format() 允许我们根据指定的格式插入和格式化字符串中的值。使用 str.format()，我们可以灵活地控制字符串的输出格式，包括数字、日期、字符串等。

语法

"{}".format(value)
"{:format_specifier}".format(value)

{}：表示将要插入的值的占位符。
format_specifier：一个可选的格式说明符，用于指定值的格式。例如，{:d} 用于整数，{:.2f} 用于保留两位小数的浮点数等。

示例

# 插入一个字符串
name = "Gsxg"
print("Hello, {}!".format(name))  # 输出: Hello, Gsxg!

# 插入一个整数
age = 18
print("I am {} years old.".format(age))  # 输出: I am 18 years old.

# 插入一个浮点数并指定小数位数
price = 99.99
print("The price is ${:.2f}".format(price))  # 输出: The price is $99.99

# 使用位置参数
name = "Gsxg"
age = 18
print("My name is {0} and I am {1} years old.".format(name, age))  # 输出: My name is Gsxg and I am 18 years old.

运行结果

在这里插入图片描述

注意事项

使用 str.format() 时，占位符 {} 可以根据需要包含一个或多个参数，这些参数将按照顺序被后面的 .format() 方法中的值替换。也可以使用位置参数（如 {0}、{1} 等）来指定参数的位置。
格式说明符（如 {:d}、{:.2f} 等）用于进一步指定值的格式，可以根据需要组合使用。例如，使用不同的数字格式、指定日期格式等。如果不指定格式说明符，将使用默认的格式。
在使用 str.format() 时，需要注意占位符和格式说明符的正确使用，以避免出现格式错误或意外的输出结果。同时，也要注意处理可能出现的异常情况，如参数数量不匹配等。

总结

str.format() 方法是 Python 中用于字符串格式化的一个强大工具。通过使用占位符和格式说明符，我们可以灵活地插入和格式化字符串中的值，从而实现各种复杂的字符串处理和输出需求。同时，使用 f-string 可以更方便地进行字符串格式化。掌握 str.format() 方法对于提高 Python 编程技能和解决实际问题是很有帮助的。

str.format_map()

功能介绍

str.format_map() 可用于将一个映射对象（如字典）作为参数，并将其内容格式化为字符串。该方法使用字典的键作为占位符，并将字典的值插入到字符串中相应的位置。

语法

str.format_map(mapping)

str: 字符串对象。
mapping: 一个字典对象，用于提供格式化所需的数据。

示例

# 基本用法
s = "Hello, {name}!"
d = {"name": "Gsxg"}
result = s.format_map(d)
print(result)  # 输出: Hello, Gsxg!

# 使用多个占位符
s = "My name is {name}, age {age} years."
d = {"name": "Gsxg", "age": 20}
result = s.format_map(d)
print(result)  # 输出: My name is Gsxg, age 20 years.

# 占位符嵌套字典
s = "I live in {address[city]} {address[street]}."
d = {"address": {"city": "New York", "street": "street1"}}
result = s.format_map(d)
print(result)  # 输出: I live in New York street1.

# 格式化浮点数
s = "The price is ￥{price} per item."
d = {"price": 99.99}
result = s.format_map(d)
print(result)  # 输出: The price is ￥99.99 per item.

运行结果：

在这里插入图片描述

注意事项

确保传递给 format_map() 的字典包含与字符串中占位符匹配的键。否则，会导致 KeyError。
对于数字格式化，可以使用格式化字符串（如 "${price:.2f}"）来控制浮点数的显示方式。但在使用之前，需要确保字典中的相应键包含数字值。否则，可能会导致类型错误或格式化错误。

str.isidentifier()

功能介绍

str.isidentifier() 可用于检查字符串是否是一个有效的 Python 标识符。有效的 Python 标识符由字母、数字和下划线组成，但不能以数字开头。

语法

string.isidentifier()

string：要检查的字符串。

示例

# 常规操作
s = "my_identifier"
print(s.isidentifier())  # 输出: True

s = "123adv"
print(s.isidentifier())  # 输出: False，因为标识符不能以数字开头。

s = "my-identifier"
print(s.isidentifier())  # 输出: False，特殊字符（如连字符）不是有效的标识符字符。

s = "my identifier"
print(s.isidentifier())  # 输出: False，标识符中不能包含空格。

s = ""
print(s.isidentifier())  # 输出: False，空字符串不是有效的标识符。

运行结果：

在这里插入图片描述

注意事项

str.isidentifier() 方法仅检查字符串是否符合 Python 的标识符规则，并不会验证该标识符是否已经存在于当前命名空间中。也就是说，即使一个字符串是一个有效的 Python 标识符，也不意味着它在当前作用域内是可用的或未被使用。
由于这个方法只是简单地检查字符串是否符合 Python 标识符的语法规则，对于其他一些潜在的问题（如名称冲突或命名规范等），你可能需要编写更复杂的逻辑来处理。
在使用 str.isidentifier() 方法之前，应确保传入的字符串已经正确地初始化，以避免出现意外的错误或异常。同时，也要注意处理可能出现的异常情况，例如当传入的字符串不符合预期格式时。
如果需要对字符串进行更复杂的检查或验证，可能需要使用正则表达式或编写自定义的验证函数。这样可以提供更灵活和强大的验证能力，以满足特定的需求。

总结

str.isidentifier() 方法提供了一种简便的方式来检查字符串是否符合 Python 标识符的规则。它可以帮助你验证变量名、函数名等是否符合命名规范，但在实际应用中，你可能还需要考虑其他因素（如命名规范、命名冲突等）来确保代码的可读性和可维护性。

str.ljust()

功能介绍

str.ljust() 可用于将字符串填充至指定的长度，使其在右侧用空格填充，以保持原始字符串的宽度。如果原始字符串的长度已经超过指定长度，则该方法不会对字符串进行任何修改。

语法

string.ljust(width[, fillchar])

string：要填充的字符串。
width：返回字符串的最大宽度。
fillchar（可选）：用于填充的字符，默认为空格。

示例：

# 填充空格字符至指定宽度
s = "hello"
result = s.ljust(10)
print(result)  # 输出: "hello     "

# 使用自定义填充字符
s = "hello"
result = s.ljust(10, "*")
print(result)  # 输出: "hello*****"

# 原始字符串长度大于指定宽度
s = "hello"
result = s.ljust(4)
print(result)  # 输出: "hello"

注意事项

如果指定的宽度小于原始字符串的长度，则该方法不会对字符串进行任何修改。因此，在调用 str.ljust() 方法时，应确保指定的宽度足够大，以避免不必要的字符串修改。
默认的填充字符为空格，也可以通过传递参数 fillchar 来指定其他字符进行填充。需要注意的是，如果指定的填充字符为非打印字符或特殊字符，可能会导致输出的字符串难以阅读或解析。因此，在实际应用中，建议使用空格或其他可见字符作为填充字符。
由于 Python 的字符串是不可变的，因此 str.ljust() 方法实际上是创建了一个新的字符串对象，而不是修改原始字符串。这意味着对于大量数据的操作可能会占用额外的内存，需要注意性能问题。如果需要在循环中进行大量的字符串操作，可以考虑使用其他方式来提高性能。
虽然 str.ljust() 方法可以方便地填充字符串，但在某些情况下，使用其他方法（如 str.zfill()）可能更加简洁或适合特定的需求。因此，在选择字符串填充方法时，应根据具体的应用场景和需求进行选择。

总结

str.ljust() 方法是一个非常实用的字符串操作方法，它允许我们通过填充空格或其他字符来调整字符串的长度。这个方法在需要对齐文本、调整显示效果或生成固定长度的字符串时非常有用。通过自定义填充字符，我们还可以实现更多的格式化需求。

然而，需要注意的是，由于 Python 的字符串是不可变的，str.ljust() 方法实际上是创建了一个新的字符串对象，而不是修改原始字符串。这意味着对于大量数据的操作可能会占用额外的内存，需要注意性能问题。

总的来说，str.ljust() 方法是一个强大且灵活的工具，可以方便地处理字符串的填充和格式化需求。在使用时，我们应考虑到其性能影响，并注意处理可能出现的特殊情况，如指定的宽度小于原始字符串的长度等。

str.rjust()

功能介绍

str.rjust() 可用于将字符串右对齐并填充指定的字符到指定宽度。如果字符串的长度已经超过指定的宽度，则该方法不会进行任何操作。

语法

str.rjust(width[, fillchar])

width: 一个整数，指定对齐的字符串总宽度。
fillchar: 一个可选字符，用于在字符串的左侧填充。默认为空格。

示例

# 填充空格字符至指定宽度
s = "hello"
result = s.rjust(10)
print(result)  

# 使用自定义填充字符
s = "hello"
result = s.rjust(10, "*")
print(result) 

# 原始字符串长度大于指定宽度
s = "hello"
result = s.rjust(4)
print(result)

运行结果：

在这里插入图片描述

注意事项

宽度参数：width 参数是一个整数，表示整个字符串的预期宽度。如果提供的宽度小于字符串的长度，那么 rjust() 方法不会对字符串进行任何修改。
填充字符：fillchar 参数是可选的，默认为空格。你可以使用任何字符作为填充字符，包括空格、标点符号、数字等。
空字符串：对于空字符串，rjust() 方法会根据提供的宽度参数返回相应数量的填充字符，因此返回的字符串将只包含填充字符。
非字母数字字符：如果填充字符不是字母数字字符，可能会导致不预期的结果。比如使用中文字符进行填充，可能会对输出效果产生影响。

结束语

亲爱的读者，感谢您花时间阅读我们的博客。我们非常重视您的反馈和意见，因此在这里鼓励您对我们的博客进行评论。
您的建议和看法对我们来说非常重要，这有助于我们更好地了解您的需求，并提供更高质量的内容和服务。
无论您是喜欢我们的博客还是对其有任何疑问或建议，我们都非常期待您的留言。让我们一起互动，共同进步！谢谢您的支持和参与！
我会坚持不懈地创作，并持续优化博文质量，为您提供更好的阅读体验。
谢谢您的阅读！

文章来源:https://blog.csdn.net/qq_41813454/article/details/135248849
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！

Python字符串处理全攻略（合集篇）：常用内置方法轻松掌握

引言

相关链接

Python字符串常用内置方法

str.capitalize()

语法

示例

运行结果

注意事项

str.upper()

语法

示例

注意事项

str.lower()

语法

示例

注意事项

str.center()

语法

示例

注意事项

str.count()

语法

示例

注意事项

str.endswith()

语法

示例

注意事项

str.find()

语法

示例

注意事项

str.title()

语法

示例

注意事项

str.replace()

语法

示例

注意事项

str.join()

语法

示例

注意事项

str.split()

语法

示例

注意事项

str.strip()

语法

示例

注意事项

str.zfill()

语法

示例

注意事项

str.index()

功能介绍

语法

注意事项

总结

str.startswith()

功能介绍

语法

示例

注意事项

str.expandtabs()

功能介绍

语法

示例

注意事项

总结

str.splitlines()

功能介绍

语法

示例

注意事项

总结

str.swapcase()