字符串篇（四）

文章目录

1.26 ljust()函数
1.27 lower()函数
1.28 lstrip()函数
1.29 maketrans()函数
1.30 partition()函数
1.31 replace()函数
1.32 rfind()函数
1.33 rindex()函数

1.26 ljust()函数

ljust() 是 Python 中字符串（str）对象的一个方法，用于将字符串左对齐，并使用指定的填充字符（默认为空格）将其填充到指定的宽度。如果指定的宽度小于或等于字符串的长度，则字符串将保持不变。如果指定的宽度大于字符串的长度，则会在字符串的右侧添加填充字符，直到达到指定的宽度。

下面是 ljust() 方法的语法：

str.ljust(width[, fillchar])

width：指定填充后字符串的总宽度。
fillchar：可选参数，指定用于填充的字符，默认为空格。

下面是如何使用 ljust() 方法的例子：

# 创建一个字符串
s = "hello"# 使用空格将字符串填充到宽度为10
padded_s = s.ljust(10)
print(padded_s)  # 输出: 'hello     '# 使用特定字符将字符串填充到宽度为10
padded_s_with_dash = s.ljust(10, '-')
print(padded_s_with_dash)  # 输出: 'hello-----'# 如果指定的宽度小于或等于字符串的长度，字符串将保持不变
s_unchanged = s.ljust(4)
print(s_unchanged)  # 输出: 'hello'

在上面的例子中，ljust() 方法被用来将字符串 “hello” 左对齐，并使用空格或指定的字符（在这个例子中是短横线 ‘-’）将其填充到指定的宽度。第一个例子中，字符串被填充到宽度为 10，使用空格作为填充字符。第二个例子中，同样填充到宽度为 10，但使用短横线作为填充字符。最后一个例子中，由于指定的宽度小于字符串的长度，所以字符串保持不变。

这个方法在处理需要格式化文本输出的场景时非常有用，比如创建表格、对齐文本列等。

1.27 lower()函数

lower() 是 Python 中字符串（str）对象的一个方法，用于将字符串中的所有大写字母转换为小写字母。这个方法返回一个新的字符串，其中所有的大写字母都被转换为对应的小写字母，而原字符串本身不会被修改。

下面是如何使用 lower() 方法的例子：

# 创建一个包含大写和小写字母的字符串
s = "Hello, World!"# 使用 lower() 方法将字符串转换为全小写
lowercase_s = s.lower()print(lowercase_s)  # 输出: 'hello, world!'# 原字符串不会被修改
print(s)  # 输出: 'Hello, World!'# 对于只包含小写字母的字符串，lower() 方法不会产生变化
s_already_lower = "already lowercase"
print(s_already_lower.lower())  # 输出: 'already lowercase'# 对于包含非字母字符的字符串，lower() 只转换字母
s_with_numbers = "Hello123"
print(s_with_numbers.lower())  # 输出: 'hello123'

lower() 方法在处理文本数据，特别是需要进行不区分大小写的比较或搜索时，非常有用。例如，当你想检查一个字符串是否包含特定的子串，而不关心子串的大小写时，可以先将两个字符串都转换为小写（或大写），然后再进行比较。

这个方法在处理文本文件、用户输入或从网络接收的数据时尤其有用，因为这些数据可能包含不同的大小写格式。使用 lower() 方法可以确保数据在比较或处理时具有一致的大小写格式。

1.28 lstrip()函数

lstrip() 是 Python 中字符串（str）对象的一个方法，用于移除字符串左侧（开头）的空白字符（包括空格、制表符、换行符等）或指定的其他字符。如果字符串左侧没有需要移除的字符，则字符串保持不变。

下面是 lstrip() 方法的语法：

str.lstrip([chars])

chars：可选参数，指定一个字符集合。如果提供了这个参数，lstrip() 将移除字符串开头所有在 chars 集合中的字符，直到遇到不在 chars 中的字符为止。

如果不提供 chars 参数，lstrip() 默认移除所有空白字符。

下面是如何使用 lstrip() 方法的例子：

# 创建一个带有前导空格的字符串
s = "   Hello, World!   "# 移除字符串左侧的空格
stripped_s = s.lstrip()
print(stripped_s)  # 输出: 'Hello, World!   '# 创建一个带有特定前导字符的字符串
s_with_chars = "abcHello, World!"# 移除字符串左侧的 'abc' 字符
stripped_s_with_chars = s_with_chars.lstrip('abc')
print(stripped_s_with_chars)  # 输出: 'Hello, World!'# 尝试移除不在字符串开头的字符
s_no_change = "Hello, World!xyz"
stripped_s_no_change = s_no_change.lstrip('xyz')
print(stripped_s_no_change)  # 输出: 'Hello, World!xyz'（没有变化）

在上面的例子中，lstrip() 方法被用来移除字符串左侧的空格或指定的字符。第一个例子中，字符串左侧的空格被移除了。第二个例子中，字符串左侧的 ‘abc’ 字符被移除了。最后一个例子中，尝试移除不在字符串开头的 ‘xyz’ 字符，因此字符串保持不变。

这个方法在处理用户输入、清理文本数据或在进行字符串比较时非常有用，因为它可以帮助确保字符串以期望的方式进行处理或比较。

1.29 maketrans()函数

maketrans() 是 Python 的 str 模块中的一个静态方法，用于创建一个字符到字符的映射转换表，通常与字符串的 translate() 方法一起使用。maketrans() 方法接受两个等长的字符串参数，分别表示原始字符和要替换的字符。此外，还可以接受一个可选的第三个参数，它是一个字符串，包含了要删除的字符。

下面是 maketrans() 方法的语法：

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

x：一个字符串，包含了要替换的原始字符。
y：一个字符串，包含了要替换成的字符，与 x 中的字符一一对应。
z（可选）：一个字符串，包含了要删除的字符。

maketrans() 方法返回一个转换表，这个表之后可以被 translate() 方法使用来进行字符替换和删除。

下面是如何使用 maketrans() 和 translate() 方法的例子：

# 导入 str 模块以使用 maketrans()
from string import maketrans# 原始字符串
s = "hello world"# 创建转换表，将 'h' 替换为 'H'，'e' 替换为 'E'，并删除 'o'
trans = maketrans('heo', 'HE-', 'o')# 使用 translate() 方法应用转换表
translated_s = s.translate(trans)print(translated_s)  # 输出: "Hll wrd"

在上面的例子中，我们首先导入了 string 模块中的 maketrans() 函数。然后，我们创建了一个转换表，将 ‘h’ 替换为 ‘H’，‘e’ 替换为 ‘E’，并删除了所有的 ‘o’ 字符。最后，我们使用 translate() 方法将转换表应用到原始字符串 s 上，得到了替换和删除字符后的新字符串。

maketrans() 和 translate() 通常用于执行复杂的字符替换和删除操作，它们比简单的 str.replace() 方法更灵活和高效。

1.30 partition()函数

partition() 是 Python 中字符串（str）对象的一个方法，用于将字符串根据指定的分隔符分割成三个部分：分隔符之前的部分、分隔符本身以及分隔符之后的部分。如果字符串中不包含指定的分隔符，则整个字符串将作为第一部分返回，而第二部分和第三部分将为空字符串。

partition() 方法的语法如下：

str.partition(sep)

sep：分隔符，即用于分割字符串的字符或子字符串。

partition() 方法返回一个包含三个字符串的元组：(before_sep, sep, after_sep)。其中 before_sep 是分隔符之前的部分，sep 是分隔符本身，after_sep 是分隔符之后的部分。

下面是如何使用 partition() 方法的例子：

# 创建一个字符串
s = "Hello, World!"# 使用逗号作为分隔符来分割字符串
before, sep, after = s.partition(',')print(before)  # 输出: 'Hello'
print(sep)     # 输出: ','
print(after)   # 输出: ' World!'# 如果分隔符不在字符串中，整个字符串将作为第一部分返回
s_no_sep = "NoSeparatorHere"
before_no_sep, sep_no_sep, after_no_sep = s_no_sep.partition(',')print(before_no_sep)  # 输出: 'NoSeparatorHere'
print(sep_no_sep)     # 输出: ''
print(after_no_sep)   # 输出: ''

partition() 方法在处理需要分割字符串但只关心第一个分隔符出现的位置时非常有用。如果你想继续分割分隔符之后的部分，可以使用 rpartition() 方法，它会从字符串的末尾开始搜索分隔符。

需要注意的是，partition() 方法不会修改原字符串，而是返回一个新的元组。

1.31 replace()函数

replace() 是 Python 中字符串（str）对象的一个方法，用于将字符串中所有出现的某个子串替换为另一个子串。这个方法返回一个新的字符串，其中所有的旧子串都已被新子串替换，而原始字符串保持不变。

下面是 replace() 方法的语法：

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

old：需要被替换的子串。
new：用于替换 old 的新子串。
count（可选）：一个整数，指定替换的最大次数。如果省略或设置为负数，将替换所有出现的 old 子串。

replace() 方法非常灵活，可以用于简单的文本替换，也可以用于复杂的文本处理任务。

下面是如何使用 replace() 方法的例子：

# 创建一个字符串
s = "Hello, World!"# 替换子串
new_s = s.replace("World", "Python")
print(new_s)  # 输出: "Hello, Python!"# 替换子串，只替换前两次出现
limited_replacement = s.replace("o", "0", 2)
print(limited_replacement)  # 输出: "Hell0, W0rld!"# 替换多个不同的子串
replaced_multiple = s.replace("Hello", "Hi").replace("World", "Universe")
print(replaced_multiple)  # 输出: "Hi, Universe!"

在上面的例子中，replace() 方法被用来替换字符串中的子串。第一个例子将 “World” 替换为 “Python”。第二个例子演示了如何使用 count 参数限制替换的次数。最后一个例子展示了如何链式调用 replace() 方法来替换多个不同的子串。

需要注意的是，replace() 方法不会修改原始字符串，而是返回一个新的字符串。原始字符串在 Python 中是不可变的，因此所有的字符串方法都会返回新的字符串对象。

1.32 rfind()函数

rfind() 是 Python 中字符串（str）对象的一个方法，用于从字符串的末尾开始搜索子串，并返回子串最后一次出现的起始索引。如果子串不在字符串中，则返回 -1。

rfind() 方法的语法如下：

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

sub：要搜索的子串。
start（可选）：开始搜索的起始索引。如果是负数，则从字符串末尾开始算起。默认为 -1，即从字符串末尾开始搜索。
end（可选）：结束搜索的索引。如果是负数，则从字符串末尾开始算起。默认为字符串的长度，即搜索整个字符串。

rfind() 方法返回子串最后一次出现的起始索引，如果子串不在字符串中，则返回 -1。

下面是如何使用 rfind() 方法的例子：

# 创建一个字符串
s = "Hello, World! World is beautiful."# 查找子串 "World" 最后一次出现的索引
index = s.rfind("World")
print(index)  # 输出: 14# 从索引 5 开始查找子串 "World" 最后一次出现的索引
index_from_5 = s.rfind("World", 5)
print(index_from_5)  # 输出: 14# 查找子串 "Beautiful" 最后一次出现的索引
index_beautiful = s.rfind("Beautiful")
print(index_beautiful)  # 输出: 23# 查找不在字符串中的子串
index_not_found = s.rfind("Python")
print(index_not_found)  # 输出: -1# 从字符串末尾开始向前搜索子串 "World"
index_from_end = s.rfind("World", -20, -1)
print(index_from_end)  # 输出: 14

在上面的例子中，rfind() 方法被用来查找子串在字符串中最后一次出现的索引。注意，索引是从 0 开始计数的，所以索引 14 实际上指的是字符串中第 15 个字符的位置。如果子串不在字符串中，rfind() 方法将返回 -1。

rfind() 方法在处理需要从字符串末尾开始搜索的场景时非常有用，特别是当需要找到子串最后一次出现的位置时。

1.33 rindex()函数

rindex() 是 Python 中字符串（str）对象的一个方法，它与 rfind() 方法类似，都是用于从字符串中搜索子串的索引。不过，rindex() 和 rfind() 在处理未找到子串时的行为是不同的。

rindex() 方法从字符串的末尾开始搜索子串，并返回子串最后一次出现的起始索引。如果子串不在字符串中，rindex() 会引发一个 ValueError 异常，而不是返回 -1。

rindex() 方法的语法如下：

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

sub：要搜索的子串。
start（可选）：开始搜索的起始索引。如果是负数，则从字符串末尾开始算起。默认为 -1，即从字符串末尾开始搜索。
end（可选）：结束搜索的索引。如果是负数，则从字符串末尾开始算起。默认为字符串的长度，即搜索整个字符串。

下面是 rindex() 方法的使用例子：

# 创建一个字符串
s = "Hello, World! World is beautiful."# 查找子串 "World" 最后一次出现的索引
index = s.rindex("World")
print(index)  # 输出: 14# 尝试查找不在字符串中的子串
try:index_not_found = s.rindex("Python")print(index_not_found)
except ValueError as e:print(e)  # 输出: substring not found# 从索引 5 开始查找子串 "World" 最后一次出现的索引
index_from_5 = s.rindex("World", 5)
print(index_from_5)  # 输出: 14# 从字符串末尾开始向前搜索子串 "World"
index_from_end = s.rindex("World", -20, -1)
print(index_from_end)  # 输出: 14