目录
7-1 join
7-2 lower, upper, capitalize, title, swapcase)
7-3 islower, isupper, istitle
7-4 isdecimal, isdigit, isnumeric
7-5 isascii, isalpha, isalnum
7-6 ind, rfind, index, rindex
7-7 count
7-8 split, splitlines
7-9 strip
7-10 replace
7-11 ljust, center, rjust, zfill
7-1 join
这一节主要讲解何使用一种方法，该方法将存储在列表中的元素和元组等可迭代对象中的多个字符串，用指定的分隔符连接起来，并将它们作为新字符串获取。
join 方法通过将作为元素存储在可迭代对象（例如列表或元组）中的多个字符串与指定的分隔符连接起来，返回一个新字符串。用法如下。
str.join(iterable)用分隔符来连接指定为参数的可迭代对象中包含的多个字符串。
实际使用方法如下。
print("".join(["Apple", "Orange", "Lemon"]))
>> AppleOrangeLemon
print(",".join(("Blue", "Red", "Green")))
>> Blue,Red,Green第一个示例连接列表中包含的多个字符串。由于我们指定了一个空字符串作为分隔符，因此我们得到了一个新字符串，其中的字符串在没有分隔符的情况下连接在一起。
第二个示例连接元组中包含的多个字符串。由于您将逗号 (,) 指定为分隔符，因此您将获得一个新字符串，其中字符串由逗号分隔并连接。
如果列表等元素包含任何非字符串的内容（例如数字），则会发生 TypeError 错误。
print("".join(["Apple", 12, "Lemon"]))
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> TypeError: sequence item 1: expected str instance, int found有关如何使用“+”运算符而不是 join 方法连接字符串的信息，请参阅 “连接和重复字符串 ”。
7-2 lower, upper, capitalize, title, swapcase)
在字符串提供的方法中，我们将解释如何将字符串从大写转换为小写的方法，从小写转换成大写。
将所有字母转为小写(lower)
lower 方法返回一个新字符串，该字符串中的所有字符都转换为小写。用法如下。
str.lower()实际使用方法如下。
print("Hello".lower())
>> hello
print("APPLE".lower())
>> apple只要是区分大小写的字符，您甚至可以转换双字节字符。
print("Ｈｅｌｌｏ".lower())
>> ｈｅｌｌｏ
print("ＡＰＰＬＥ".lower())
>> ａｐｐｌｅ我能够得到一个新字符串，其中目标字符串中的所有字符都转换为小写。
将所有字母转换为大写(upper)
实际使用方法如下。
str.upper()実際の使い方は次の通りです。
print("Hello".upper())
>> HELLO
print("apple".upper())
>> APPLE只要是区分大小写的字符，您甚至可以转换双字节字符。
print("Ｈｅｌｌｏ".upper())
>> ＨＥＬＬＯ
print("ａｐｐｌｅ".upper())
>> ＡＰＰＬＥ我能够得到一个新字符串，其中目标字符串中的所有字符都转换为大写。
将首字母转为大写，其余转为小写(capitalize)
capitalize 方法返回一个新字符串，首字母大写，后面的字母转换为小写。用法如下。
str.capitalize()实际使用方法如下。
print("hello python".capitalize())
>> Hello python
print("MY FAVORITE THINGS".capitalize())
>> My favorite things只要是区分大小写的字符，您甚至可以转换双字节字符。
print("ｈｅｌｌｏ ｐｙｔｈｏｎ".capitalize())
>> Ｈｅｌｌｏ ｐｙｔｈｏｎ
print("ＭＹ ＦＡＶＯＲＩＴＥ ＴＨＩＮＧＳ".capitalize())
>> Ｍｙ ｆａｖｏｒｉｔｅ ｔｈｉｎｇｓ通过将目标字符串的开头大写并将其余字符转换为小写，我能够获得一个新字符串。
将字符串中每个单词的第一个字母转换为大写，其余字母转换为小写(title)
title 方法返回一个新的字符串，字符串中每个单词的首字母转换为大写，其余转换为小写。用法如下。
str.title()实际使用方法如下。
print("hello python".title())
>> Hello Python
print("MY FAVORITE BOOK".title())
>> My Favorite Book只要是区分大小写的字符，您甚至可以转换双字节字符。
print("ｈｅｌｌｏ ｐｙｔｈｏｎ".title())
>> Ｈｅｌｌｏ Ｐｙｔｈｏｎ
print("ＭＹ ＦＡＶＯＲＩＴＥ ＴＨＩＮＧＳ".title())
>> Ｍｙ Ｆａｖｏｒｉｔｅ Ｔｈｉｎｇｓ对于字符串中的每个单词，我们能够得到一个新字符串，其中第一个字母大写，其余字母转换为小写。
大写小写字母的互相转换(swapcase)
swapcase 方法返回一个新字符串，该字符串将大写字母转换为小写字母，将小写字母转换为大写字母。用法如下。
str.swapcase()实际使用方法如下。
print("Hello".swapcase())
>> hELLO
print("apple".swapcase())
>> APPLE只要是区分大小写的字符，您甚至可以转换双字节字符。
print("Ｈｅｌｌｏ".swapcase())
>> ｈＥＬＬＯ
print("ａｐｐｌｅ".swapcase())
>> ＡＰＰＬＥ在这一节课中，我们讲解了如何将一个字符串，转换为小写或者大写。
7-3 islower, isupper, istitle
在字符串提供的方法中，我们将解释如何使用可用于判断字符串中包含的字符是大写还是小写的方法。
判断字符是否全部为小写(islower)
如果字符串中至少有一个区分大小写的字符并且全部为小写，则 islower 方法返回 true。用法如下。
str.islower()实际使用方法如下。
print("apple".islower())
>> True
print("Hello".islower())
>> False在此示例中，所有字母都区分大小写。在这种情况下，如果所有字符都是小写，则返回 true。
忽略不区分大小写的字符，例如数字和汉语字符。
print("apple100".islower())
>> True
print("max値".islower())
>> True即使是双字节字符，也可以判断是不是字母表等能够区分大小写字母的字符。
print("ｈｅｌｌｏ".islower())
>> True
print("Ａｐｐｌｅ".islower())
>> False如果不包含区分大小写的字符，则为 False。
print("2019".islower())
>> False
print("青岛市".islower())
>> False判断字符是否全部大写(isupper)
如果字符串中至少有一个区分大小写的字符并且全部为大写，则 isupper 方法返回 true。用法如下。
str.isupper()实际使用方法如下。
print("APPLE".isupper())
>> True
print("Hello".isupper())
>> False
在此示例中，所有字母都区分大小写。在这种情况下，如果所有字符都是大写，则返回 true。
忽略不区分大小写的字符，例如数字和日语字符。
print("ORANGE100%".isupper())
>> True
print("MAX値".isupper())
>> True即使是双字节字符，也可以判断是不是字母表等能够区分大小写字母的字符。
print("ＡＰＰＬＥ".isupper())
>> True
print("Ｏｒａｎｇｅ".isupper())
>> False如果不包含区分大小写的字符，则为 False。
print("2023".isupper())
>> False
print("你好".isupper())
>> False判断字符串中每个单词首字母是否大写，其余均为小写(istitle)
如果字符串中的每个单词都由大写字母和小写字母组成，则 istitle 方法返回 true。大写字母前面可以有不区分大小写的字母，但是小写字母前面有不区分大小写的字母是错误的。用法如下。
str.istitle()实际使用方法如下。
print("Music Video".istitle())
>> True
print("THE Movie".istitle())
>> False在此示例中，所有字母都区分大小写。在这种情况下，对于字符串中的每个单词，如果首字母大写且其余字母小写，则返回 true。
只有跟在大写字母后面的小写字母才为真。如果小写字母前面有不区分大小写的字母（例如数字或日文字母），则为 False。
print("7Color Border".istitle())
>> True
print("Best100 Songs".istitle())
>> True
print("Pixel7a Xl".istitle())
>> False如果不包含区分大小写的字符，则为 False。
在这一节中我们讲解了如何判断字符串中包含的字符是大写还是小写的方法。
7-4 isdecimal, isdigit, isnumeric
这一节中，我们将说明如何判断字符串中包含的字符是否为表示数字的字符的方法。
判断所有字符是否为十进制字符(isdecimal)
如果字符串中的所有字符都是十进制字符并且至少有一个字符，则 isdecimal 方法返回 true。用法如下。
str.isdecimal()实际使用方法如下。
print("75120".isdecimal())
>> True
print("75F2".isdecimal())
>> False十进制字符在官方网站上被解释为“包含在 Unicode 通用类别“Nd”中的字符”。请注意，它不仅包括主要在中国本使用的数字 0 到 9，还包括用于表示世界各地十进制数字的字符。
即使是双字节字符，只要是表示十进制数字的数字字符，也可以判断。
print("０９８２".isdecimal())
>> True
print("７５ａ０".isdecimal())
>> False如果它包含逗号 (,)、连字符 (-) 或点 (.)，则为 False。
print("-8052".isdecimal())
>> False
print("3.14".isdecimal())
>> False
print("7,524".isdecimal())
>> False汉字数字是假的。
print("七五三".isdecimal())
>> False空字符串返回 false。
print("".isdecimal())
>> False判断所有字符是否为数字字符(isdigit)
如果字符串中的所有字符都是数字字符并且至少有一个字符，则 isdigit 方法返回 true。用法如下。
str.isdigit()实际使用方法如下。
print("85120".isdigit())
>> True
print("75F2".isdigit())
>> False数字中使用的字符在官方网站上解释为“数字是具有属性值 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符”。请注意，它包含比 isdecimal 方法更多的数字字符。
如果 isdigit 方法包含逗号 (,)、连字符 (-) 或点 (.)，它也会返回 false。
print("-8052".isdigit())
>> False
print("3.14".isdigit())
>> False
print("7,524".isdigit())
>> False即使是双字节字符，只要是数字字符也可以判断。
print("３７８５".isdigit())
>> True
print("４ｐ９０".isdigit())
>> False但是，中文数字是错误的。
print("七五三".isdigit())
>> False⑤⑥⑦等字符也被isdigit方法判断为真，作为归类为Numeric_Type=Digit的数值。
print("⑤⑥⑦".isdecimal())
>> False
print("⑤⑥⑦".isdigit())
>> True空字符串返回 false。
print("".isdigit())
>> False判断所有字符是否为数字字符(isnumeric)
如果字符串中的每个字符都是数字字符并且至少有一个字符，则 isnumeric 方法返回 true。用法如下。
str.isnumeric()实际使用方法如下。
print("9852".isnumeric())
>> True
print("87E2".isnumeric())
>> False数字中使用的字符在官网解释为“表示数字的字符具有属性值Numeric_Type=Digit、Numeric_Type=Decimal或Numeric_Type=Numeric”。请注意，它包含比 isdigit 方法更多的数字字符。
如果 isnumeric 方法包含逗号 (,)、连字符 (-) 或点 (.)，它也会返回 false。
print("-8052".isnumeric())
>> False
print("3.14".isnumeric())
>> False
print("7,524".isnumeric())
>> False在isnumeric方法中，除了双字节字符值，中文数字也是如此。
print("３７８５".isnumeric())
>> True
print("七五三".isnumeric())
>> True
print("拾伍".isnumeric())
>> True空字符串返回 false。
print("".isnumeric())
>> False在这一节课中，我们解释了如何确定字符串中包含的字符是否是表示数字的字符。
7-5 isascii, isalpha, isalnum
在字符串提供的方法中，我们将解释如何使用可用于判断字符串中包含的字符是否代表字母字符的方法。
判断所有字符是否都是ASCII字符(isascii)
如果字符串中的所有字符都是 ASCII 字符或者字符串为空，则 isascii 方法返回 true。用法如下。
str.isascii()实际使用方法如下。
print("Hello".isascii())
>> True
print("5123".isascii())
>> True
print("胶东半岛".isascii())
>> FalseASCII 码还包括逗号 (,)、连字符 (-) 和点 (.)，因此即使包含这些字符也是如此。
print("-5123".isascii())
>> True
print("-3.1415".isascii())
>> True
print("2,634,300".isascii())
>> True
isascii 方法也适用于空字符串。
print("".isascii())
>> True判断所有字符是否都是字母字符(isalpha)
如果字符串中的所有字符都是字母并且至少有一个字符，则 isalpha 方法返回 true。用法如下。
str.isalpha()实际使用方法如下。
print("Hello".isalpha())
>> True
print("3345".isalpha())
>> False官网说字母字符是Unicode字符数据库中定义为“Letter”的字符，即通用类别属性“Lm”、“Lt”、“Lu”、“Ll”、“Lo”的字符。它有两者之一，这与 Unicode 标准中定义的“字母”属性不同。包括半角字母字符，但如果包括半角数字，则结果为假。
此外，虽然在谈到英文字母时有字母表的图像，但全角字符也包括在内。但是，即使是双字节字符，表示数字的字符也为假（汉字数字为真）。
print("青岛".isalpha())
>> True
print("Ａｐｐｌｅ".isalpha())
>> True
print("７６５".isalpha())
>> False
print("七五三".isalpha())
>> True空字符串返回 false。
print("".isalpha())
>> False判断是否所有字符都是字母数字字符(isalnum)
如果字符串中的所有字符都是字母数字字符并且至少有一个字符，则 isalnum 方法返回 true。用法如下。
str.isalnum()实际使用方法如下。
print("100years".isalnum())
>> True
print("青岛市".isalnum())
>> True
print("Ｏｒａｎｇｅ8".isalnum())
>> True字符是否为字母数字是前面解释的 isalpha 方法、isdecimal 方法、isdigit 方法和 isnumeric 方法中的任何一个返回 true 的字符。
空字符串返回 false。
print("".isalnum())
>> False在这一节课中我们解释了如何确定字符串中包含的字符是否是表示字母字符的字符。
7-6 ind, rfind, index, rindex
我将说明如何使用字符串提供的方法中可用于获取指定字符串在字符串中的位置的方法。
获取指定字符串最先出现的索引(find)
find 方法获取指定字符串在字符串中第一次出现的索引。用法如下。
返回参数中指定的字符串 (sub) 在字符串 str 中第一次出现的索引。指定范围的开始和结束是可选的。我稍后会解释这个。
实际使用方法如下。
print("dictionary".find("io"))
>> 4
print("Good School".find("oo"))
>> 1
print("Goooood".find("oo"))
>> 1
print("Orange".find("aa"))
>> -1在第一个示例中，find 方法返回 4，因为字符串“io”在“dictionary”中第一次出现的索引是 4。
d i c t i o n a r y
0 1 2 3 4 5 6 7 8 9 在第二个示例中，字符串“oo”在“Good School”中出现了两次，但 find 方法返回 1，因为第一次出现在索引 1 处。
G o o d S c h o o l
0 1 2 3 4 5 6 7 8 9 10在第三个示例中，字符串“oo”在“Goooood”中出现了 4 次，但 find 方法返回 1，因为第一次出现在索引 1 处。
G o o o o o d
0 1 2 3 4 5 6通过在 find 方法中指定第二个和第三个参数，可以指定搜索指定字符串的范围。
str.find(sub[, start[, end]])返回目标字符串 (str) 从开始到结束的索引范围内参数中指定的字符串 (sub) 第一次出现的索引。
实际使用方法如下。
print("Good School".find("oo"))
>> 1
print("Good School".find("oo", 3, 10))
>> 8
print("Good School".find("oo", 3))
>> 8在第二个示例中，find 方法返回 8，因为字符串“oo”在索引 3 和 10 之间的“Good School”中第一次出现是 8。
d S c h o o l
3 4 5 6 7 8 9 10如果像第三个示例那样省略了 end，则将其视为指定了字符串的结尾。
获取指定字符串的第一次出现的索引(index)
index 方法的用途与 find 方法几乎相同，但如果未找到参数中指定的字符串，则返回 ValueError 错误而不是 -1。用法如下。
str.index(sub[, start[, end]])实际使用方法如下。
print("dictionary".index("io"))
>> 4
print("Good School".index("oo"))
>> 1
print("Good School".index("oo", 3))
>> 8
print("Orange".index("aa"))
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> ValueError: substring not found注意基本用法和find方法是一样的，只是找不到就返回错误。
获取指定字符串最后出现的索引(rfind)
rfind 方法获取指定字符串在字符串中最后一次出现的索引。用法如下。
str.rfind(sub[, start[, end]])返回参数中指定的字符串 (sub) 在字符串 str 中最后一次出现的索引。指定范围的开始和结束是可选的。我稍后会解释这个。
实际使用方法如下。
print("dictionary".rfind("io"))
>> 4
print("Good School".rfind("oo"))
>> 8
print("Goooood".rfind("oo"))
>> 4
print("Orange".rfind("aa"))
>> -1在第一个示例中，rfind 方法返回 4，因为字符串“io”在“字典”中最后一次出现的索引是 4。
d i c t i o n a r y
0 1 2 3 4 5 6 7 8 9 在第二个示例中，字符串“oo”在“Good School”中出现了两次，但最后一次出现在索引 8 处，因此 rfind 方法返回 8。
G o o d S c h o o l
0 1 2 3 4 5 6 7 8 9 10在第三个示例中，字符串“oo”在“Goooood”中出现了 4 次，但 rfind 方法返回 4，因为最后一次出现的索引为 4。
G o o o o o d
0 1 2 3 4 5 6如果在第四个示例中没有找到指定的字符串，则返回 -1。
通过在 rfind 方法中指定第二个和第三个参数，可以指定搜索指定字符串的范围。
str.rfind(sub[, start[, end]])返回目标字符串 (str) 从开始到结束的索引范围内参数中指定的字符串 (sub) 第一次出现的索引。
我会用一个简单的例子来尝试。
print("Good School".rfind("oo"))
>> 8
print("Good School".rfind("oo", 0, 6))
>> 1
print("Good School".rfind("oo", 3))
>> 8在第二个示例中，rfind 方法返回 1，因为字符串“oo”在“Good School”中索引 0 到 6 范围内的最后一次出现是 1。
G o o d S c
0 1 2 3 4 5 6 如果像第三个示例那样省略了 end，则将其视为指定了字符串的结尾。
获取指定字符串的最后一个索引(rindex)
rindex 方法的用途几乎与 rfind 方法相同，但如果未找到参数中指定的字符串，则返回 ValueError 错误而不是 -1。用法如下。
str.rindex(sub[, start[, end]])
我会用一个简单的例子来尝试。
print("dictionary".rindex("io"))
>> 4
print("Good School".rindex("oo"))
>> 8
print("Good School".rindex("oo", 0, 6))
>> 1
print("Orange".rindex("aa"))
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> ValueError: substring not found注意基本用法和rfind方法一样，只是没有找到会返回错误。
— —
在这节课中，我们说明了如何获取指定字符串在字符串中包含的位置的方法。
7-7 count
在字符串提供的方法中，我们将说明如何使用可用于获取指定字符串在字符串中包含多少次而不重复的方法。
获取指定字符串被包含了多少次(count)
count 方法获取指定字符串在字符串中唯一出现的次数。用法如下。。
str.count(sub[, start[, end]])返回指定字符串 ( sub ) 在字符串 str 中无重复出现的次数。指定范围的开始和结束是可选的。我稍后再试试这个。
实际使用方法如下。
print("dictionary".count("io"))
>> 1
print("Good School".count("oo"))
>> 2
print("Goooood".count("oo"))
>> 2
print("Orange".count("aa"))
>> 0在第一个示例中，count 方法返回 0，因为字符串“io”在“字典”中出现了 1 次。
在第二个示例中，count 方法返回 2，因为字符串“oo”在“Good School”中出现了两次。
在第三个示例中，字符串“oo”在“Goooood”中出现了 4 次，但计数方法返回 2，因为有 2 次不同的出现。
G o o o o o d
--- ---
1 2如果没有找到指定的字符串，则返回 0，如第四个示例所示。
通过在 count 方法中指定第二个和第三个参数，可以指定搜索指定字符串的范围。
str.count(sub[, start[, end]])返回指定为参数的字符串 ( sub ) 在目标字符串 ( str ) 开始到结束的索引范围内的非重复出现次数。
实际使用方法如下。
print("Good School".count("oo"))
>> 2
print("Good School".count("oo", 3, 10))
>> 1
print("Good School".count("oo", 3))
>> 1在第二个示例中，count 方法返回 1，因为字符串“oo”在“Good School”中索引 3 和 10 之间的唯一出现次数为 1。
d S c h o o l
3 4 5 6 7 8 9 10如果像第三个示例那样省略了 end，则将其视为指定了字符串的结尾。
— —
在这一节课中，我们解释了如何获取指定字符串在字符串中包含多少次而不重复的方法。
7-8 split, splitlines
在字符串提供的方法中，我们将说明如何使用可以使用指定分隔符分割字符串并将其作为列表获取的方法。
以指定的分隔符拆分，并获取为列表(split)
split 方法将字符串以指定的分隔符进行分割，得到一个列表，每个分割后的字符串作为一个元素。用法如下。
str.split(sep=None, maxsplit=-1)使用第一个参数中指定的分隔符 (sep) 拆分字符串 (str)，并获得一个以每个字符串作为元素的列表。如果省略定界符，它将在空格字符处拆分。另外，在第二个参数中指定最大分割数。如果省略，则最大分割数不受限制。
首先尝试省略分隔符。如果省略，则使用空格和制表符作为分隔符。
print("My First Album".split())
>> ['My', 'First', 'Album']
print(" Next Page ".split())
>> ['Next', 'Page']
print("Apple\tOrange\tLemon".split())
>> ['Apple', 'Orange', 'Lemon']第一个示例使用空格作为分隔符拆分“My First Album”，以获取包含三个字符串“My”、“First”、“Album”作为元素的列表。
第二个示例使用空格作为分隔符拆分“下一页”，但如果您在拆分方法中未指定分隔符，则连续的空格将合并为一个空格。此外，如果字符串的开头或结尾有空格，则会将其排除并拆分。因此，“Next Page”被视为“Next Page”，所以我得到了一个包含两个字符串“Next”和“Page”作为元素的列表。
第三个示例使用制表符 (\t) 作为分隔符而不是空格来拆分“Apple\tOrange\tLemon”，以获取包含三个字符串“Apple”“Orange”“Lemon”作为元素的列表。做了。
如果您随后指定一个分隔符。分隔符可以是单个字符或字符串。
print("Orange,Lemon,Apple".split(","))
>> ['Orange', 'Lemon', 'Apple']
print("Red*-*Blue*-*Green".split("*-*"))
>> ['Red', 'Blue', 'Green']
print(" Next Page ".split(" "))
>> ['', '', 'Next', '', 'Page', '', '']第一个示例使用逗号 (,) 作为分隔符。第二个示例还指定了三字符字符串“*-*”作为分隔符。
第三个示例明确指定一个空格字符作为“下一页”的分隔符。如果你像这样省略分隔符，如果你明确指定“”，结果会不同。如果明确指定，则不会折叠连续空格。空格被分开，就好像它们之间有一个空字符一样。此外，字符串开头和结尾的空格不会被删除，并且字符串会被拆分，就好像开头或结尾有空字符一样。
当明确指定空白时，我尝试了各种模式。
print("Next Page".split(" "))
>> ['Next', 'Page']
print("Next Page".split(" "))
>> ['Next', '', 'Page']
print("Next Page".split(" "))
>> ['Next', '', '', 'Page']
print(" Next Page ".split(" "))
>> ['', 'Next', 'Page', '']接下来是指定最大分割数的情况。在第二个参数中指定最大拆分数。例如，如果您指定 2，则字符串最多会被拆分 2 次，从而产生 3 个字符串。
print("A B C D E".split(" "))
>> ['A', 'B', 'C', 'D', 'E']
print("A B C D E".split(" ", 1))
>> ['A', 'B C D E']
print("A B C D E".split(" ", 2))
>> ['A', 'B', 'C D E']
print("A B C D E".split(" ", 3))
>> ['A', 'B', 'C', 'D E']
print("A B C D E".split(" ", 4))
>> ['A', 'B', 'C', 'D', 'E']
print("A B C D E".split(" ", 8))
>> ['A', 'B', 'C', 'D', 'E']如果省略最大分割数，则没有限制。此外，即使您指定的分隔符数量大于指定数量，也不会有额外的分隔符。
通过分隔符拆分换行符并获取它作为列表(splitlines)
splitlines 方法在换行符处拆分字符串，并获得一个列表，每个拆分字符串作为一个元素。用法如下。
str.splitlines([keepends])被识别为定界符的换行符包括：
\n 换行符
\r 回车
\r\n 换行 + 回车
\v 或 \x0b 垂直制表符
\f 或 \x0c 新页面
\x1c 文件分隔符
\x1d 组分隔符
\x1e 记录分隔符
\x85 换行符（C1 控制代码）
\u2028 行分隔符
\u2029 分段符如果省略该参数，则用于拆分的换行符不包含在拆分后的字符串中。如果要包含分隔符，请为第一个参数 keepends 指定 True。
让我们用一个简单的例子来尝试一下。
str1 = "Orange\nLemon\nApple"
print(str1)
>> Orange
>> Lemon
>> Apple
print(str1.splitlines())
>> ['Orange', 'Lemon', 'Apple']str2 = """\
Hello
My name is Yamada
Thank you"""
print(str2)
>> Hello
>> My name is Yamada
>> Thank you
print(str2.splitlines())
>> ['Hello', 'My name is Yamada', 'Thank you']我试过将 \n 作为换行符放在字符串中并使用三引号。结果是一样的。
接下来，通过将 True 指定为 splitlines 方法的参数，尝试在拆分字符串中包含换行符。
str1 = "Orange\nLemon\nApple"
print(str1)
>> Orange
>> Lemon
>> Apple
print(str1.splitlines(True))
>> ['Orange\n', 'Lemon\n', 'Apple']拆分字符串现在包含换行符。
— —
在这一节课，我们解释了如何用分隔符拆分字符串的方法。
7-9 strip
在字符串提供的方法中，我们将解释如何使用可用于从字符串的开头或结尾删除所有指定字符的方法。
从字符串的开头和结尾删除指定字符(strip)
split 方法返回一个新字符串，其中从字符串的开头和结尾删除了指定的字符。用法如下。
str.strip([chars])指定一个包含要删除的字符的字符串作为第一个参数。例如，如果要删除所有字母“a”、“b”和“c”，请指定“abc”。如果省略参数，它会去除空白。
首先尝试省略参数的情况。
print(" Hello ".strip())
>> Hello
print(" My First Diary ".strip())
>> My First Diary去除任何前导和尾随空格。如果出现非空白字符，它会在那里结束，因此不会删除字符串之间的空白。
我将尝试使用以下参数：
print("...Hello...".strip("."))
>> Hello
print("www.example.com".strip("wcmo."))
>> example第一个示例仅指定要删除一个字符，第二个示例指定要删除五个字符。如果指定字符以外的字符出现在字符串的开头或结尾，则它在那里结束。
从字符串末尾移除指定字符（rstrip)
rstrip 方法返回一个新字符串，其中从字符串末尾删除了指定的字符。用法如下。
str.rstrip([chars])
与strip基本相同。rstrip 方法仅从末尾删除指定的字符。
具体写如下。
print("...Hello...".rstrip("."))
>> ...Hello从字符串开头移除指定字符(lstrip)
lstrip 方法返回一个新字符串，其中从字符串的开头删除了指定的字符。用法如下。
str.lstrip([chars])与strip基本相同。lstrip 方法仅从开头删除指定的字符。
具体写如下。
print("...Hello...".lstrip("."))
>> Hello...在这一节课中，我们解释了如何在字符串删除字符串的开头或结尾中所有指定的字符。
7-10 replace
在字符串提供的方法中，我将解释如何使用将字符串中包含的指定字符串替换为另一个字符串的方法
用另一个字符串替换指定的字符串（replace)
replace 方法返回一个新字符串，该字符串将字符串中的指定字符串替换为另一个字符串。用法如下。
str.replace(old, new[, count])用新字符串 (new) 替换第一个参数中指定的字符串 (old)。如果字符串中有多个字符串，则全部替换。可选的第三个参数允许您指定要进行的最大替换次数。我稍后再试试这个。
实际使用方法如下。
print("Copyright 2018".replace("2018", "2019"))
>> Copyright 2019
print("box width 100, box height 50".replace("box", "div"))
>> div width 100, div height 50
print("Apple".replace("PP", "oo"))
>> Apple如第二个例子，在字符串中发现多个待替换字符串，则全部替换。另外，如果像第三个例子一样没有找到要替换的字符串，则原样返回原始字符串。
接下来，让我们将最大替换次数指定为第三个参数。
print("AA BB AA CC AA DD AA EE".replace("AA", "aa"))
>> aa BB aa CC aa DD aa EE
print("AA BB AA CC AA DD AA EE".replace("AA", "aa", 2))
>> aa BB aa CC AA DD AA EE由于这次指定了2次为最大次数，所以从字符串的开头最多进行2次替换，其余的不进行替换。
在这一节课中，我们了解了如何替换字符串中指定字符串的方法。
7-11 ljust, center, rjust, zfill
解释了在字符串提供的方法中如何使用获取指定字符填充的新字符串的方法将字符串按指定长度对齐，左对齐/居中/右对齐。
左对齐/居中/右对齐字符串(ljust, center, rjust)
ljust、center 和 rjust 方法返回指定长度的新字符串，分别用指定的字符填充以左对齐、居中对齐或右对齐。用法如下。
str.rjust(width[, fillchar])
str.center(width[, fillchar])
str.ljust(width[, fillchar])扩展到第一个参数中指定的字符串的长度 ( width )，分别为左对齐 ( ljust )、居中 ( center ) 或右对齐 ( rjust )。用空格填充字符串到指定的长度。如果指定一个字符作为可选的第二个参数，则用该字符将字符串填充到指定的长度。我稍后再试试这个。
实际使用方法如下。
print("[" + "Apple".ljust(8) + "]")
>> [Apple ]
print("[" + "Apple".center(8) + "]")
>> [ Apple ]
print("[" + "Apple".rjust(8) + "]")
>> [ Apple]每个方法获取一个新字符串，该字符串左对齐、居中、右对齐，并用空格填充到指定长度。
如果要用非空白字符填充，请在第二个参数中指定字符。指定的字符必须是一个字符，指定两个或多个将导致 TypeError 错误。
print("Apple".ljust(8, "_"))
>> Apple___
print("Apple".center(8, "p"))
>> pApplepp
print("Apple".rjust(8, "+"))
>> +++Apple
print("Apple".rjust(8, "*+"))
>> Traceback (most recent call last):
>> File "<stdin>", line 1, in <module>
>> TypeError: The fill character must be exactly one character long使用指定的字符将字符串填充到指定的长度。
如果指定的长度小于原始字符串的长度，则返回原始字符串不变。
print("Apple".ljust(3))
>> Apple
print("Apple".center(3))
>> Apple
print("Apple".rjust(3))
>> Apple将字符串右对齐，考虑符号用0填充到指定长度(zfill)
每个 zfill 方法返回一个指定长度的新字符串，用“0”填充以便右对齐。用法如下。
str.zfill(width)将第一个参数中指定的字符串扩展到长度 ( width ) 并将其右对齐 ( rjust )。用“0”填充字符串到指定长度。它类似于在rjust方法中指定“0”作为第二个参数，但是在zfill方法的情况下，如果字符串的第一个字符是表示“+”或“-”符号的字符，则符号从末尾用“0”填充。
实际使用方法如下。
print("89".zfill(5))
>> 00089
print("abc".zfill(6))
>> 000abc
print("-123".zfill(8))
>> -0000123
print("+975".zfill(8))
>> +0000975如果像第二种和第三种情况一样，字符串的开头是“+”或“-”，则符号用“0”填充到指定的长度。注意，目标字符串不限于表示数值的字符串。
如果指定的长度小于原始字符串的长度，则返回原始字符串不变。
print("12345".zfill(3))
>> 12345
