字符串

一、 字符串的定义

- Python 中字符串被定义为引号之间的字符集合。

- Python 支持使用成对的 单引号 或 双引号。

【例子】

t1 = 'i love Python!'
print(t1, type(t1))
# i love Python! <class 'str'>

t2 = "I love Python!"
print(t2, type(t2))
# I love Python! <class 'str'>

print(5 + 8)  # 13
print('5' + '8')  # 58

以上代码演示了在 Python 中字符串和数字的不同处理方式。

首先，t1 = 'i love Python!' 定义了一个字符串变量 t1，其值为 'i love Python!'。通过 print(t1, type(t1)) 打印出变量 t1 的值和类型，结果为：

i love Python! <class 'str'>

表示变量 t1 的值为 'i love Python!'，类型为字符串（str）。

接着，t2 = "I love Python!" 定义了另一个字符串变量 t2，其值为 "I love Python!"。通过 print(t2, type(t2)) 打印出变量 t2 的值和类型，结果为：

I love Python! <class 'str'>

表示变量 t2 的值为 "I love Python!"，类型为字符串（str）。注意，Python 中可以使用单引号或双引号来定义字符串，二者的效果是相同的。

接下来，print(5 + 8) 打印了数字 5 和 8 的相加结果，即 13。

最后，print('5' + '8') 打印了两个字符串 '5' 和 '8' 的拼接结果，即 '58'。在字符串中，加号 + 表示字符串的拼接操作，将两个字符串连接在一起形成新的字符串。

总结：在 Python 中，字符串可以使用单引号或双引号来定义，通过加号 + 来进行拼接。而数字可以直接进行数值运算，如加法运算。需要注意的是，字符串和数字的类型是不同的，因此在处理时要注意类型的匹配。

- Python 的常用转义字符

如果字符串中需要出现单引号或双引号，可以使用转义符号\对字符串中的符号进行转义。

【例子】

print('let\'s go')  # let's go
print("let's go")  # let's go
print('C:\\now')  # C:\now
print("C:\\Program Files\\Intel\\Wifi\\Help")
# C:\Program Files\Intel\Wifi\Help

以上代码演示了在字符串中使用转义字符的方法。

在 Python 中，使用反斜杠 \ 作为转义字符来表示一些特殊字符或者在字符串中插入引号。

例如，print('let\'s go') 中的反斜杠 \ 表示对紧随其后的单引号进行转义，使其不被解释为字符串的结束符，从而输出 let's go。

同样地，print("let's go") 中的双引号可以避免转义问题，因为在双引号中的单引号不会被解释为字符串的结束符，输出结果与上述相同。

在路径字符串中，如果我们希望显示反斜杠本身，可以使用两个连续的反斜杠 \\ 来表示。例如，print('C:\\now') 输出 C:\now。

当需要显示包含多个反斜杠的路径时，也可以使用双引号来简化转义的书写，例如 print("C:\\Program Files\\Intel\\Wifi\\Help") 输出 C:\Program Files\Intel\Wifi\Help。

通过使用转义字符，我们可以在字符串中正确地表示包含引号或者反斜杠的内容。

原始字符串只需要在字符串前边加一个英文字母 r 即可。

【例子】

print(r'C:\Program Files\Intel\Wifi\Help')  
# C:\Program Files\Intel\Wifi\Help

在Python中，我们可以使用原始字符串（Raw String）来表示不进行转义的字符串。

原始字符串以 r 开头，它会将字符串中的转义字符视为普通字符，而不进行转义。这意味着反斜杠 \ 将被当作普通字符而不是转义字符。

在你的例子中，r'C:\Program Files\Intel\Wifi\Help' 是一个原始字符串，其中的反斜杠不会被解释为转义字符。因此，print(r'C:\Program Files\Intel\Wifi\Help') 输出的结果为 C:\Program Files\Intel\Wifi\Help。

使用原始字符串可以方便地表示包含反斜杠的路径，避免了需要双斜杠或双引号来转义的繁琐写法。

三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

【例子】

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB (    )。
# 也可以使用换行符 [
#  ]。

para_str = '''这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
'''
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB (      )。
# 也可以使用换行符 [ 
#  ]。

在Python中，我们可以使用三个引号（单引号或双引号）来创建多行字符串。

在你的示例中，para_str 是一个使用三个双引号创建的多行字符串。你可以在其中使用制表符 \t 来表示TAB，并使用换行符 \n 来表示换行。通过 print(para_str) 打印 para_str ，输出结果如下：

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (     )。
也可以使用换行符 [
]。

同样地，你也可以使用三个单引号来创建多行字符串，例如：

para_str = '''这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
'''
print(para_str)

输出结果与使用三个双引号相同。

使用多行字符串可以更方便地表示包含换行和制表符的文本内容，而无需在字符串中使用转义字符。

二、 字符串的切片与拼接

- 类似于元组具有不可修改性

- 从 0 开始 (和 Java 一样)

- 切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。

- 索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。

【例子】
在你的代码中，你展示了一些字符串切片的操作。让我逐个解释：

str1 = 'I Love LsgoGroup'
print(str1[:6])  # I Love

这里使用切片 [:6] 来获取字符串 str1 中索引位置 0 到 5（不包括 6）的子串，即 'I Love'。

print(str1[5])  # e

这里使用索引操作 str1[5] 来获取字符串 str1 中索引位置为 5 的字符，即 'e'。

print(str1[:6] + " 插入的字符串 " + str1[6:])  
# I Love 插入的字符串  LsgoGroup

这里使用切片和字符串拼接操作将字符串 str1 分成两部分，并在中间插入了一个新的字符串 " 插入的字符串 "。

s = 'Python'
print(s)  # Python
print(s[2:4])  # th
print(s[-5:-2])  # yth
print(s[2])  # t
print(s[-1])  # n

这里展示了对字符串 s 的一系列索引和切片操作。s[2:4] 获取的是索引位置 2 到 3（不包括 4）的子串 'th'；s[-5:-2] 获取的是索引位置 -5 到 -3（不包括 -2）的子串 'yth'；s[2] 获取的是索引位置为 2 的字符 't'；s[-1] 获取的是索引位置为 -1 的字符 'n'。

字符串的切片操作允许你从一个字符串中获取子串，通过指定开始和结束的索引位置（不包括结束位置），你可以灵活地截取字符串的一部分。通过这些操作，你可以方便地操作和处理字符串中的子串。

三、 字符串的常用内置方法

- capitalize() 将字符串的第一个字符转换为大写。

【例子】

str2 = 'xiaoxie'
print(str2.capitalize())  # Xiaoxie

capitalize() 方法将字符串的第一个字符转换为大写，并返回转换后的新字符串。在这里，str2.capitalize() 将 'xiaoxie' 中的首字母 'x' 转换为大写 'X'，并返回转换后的字符串 'Xiaoxie'。

这可以用于将字符串中的第一个单词或句子首字母大写。请注意，该方法只会修改第一个字符，不会影响其他字符的大小写。

- lower() 转换字符串中所有大写字符为小写。

- upper() 转换字符串中的小写字母为大写。

- swapcase() 将字符串中大写转换为小写，小写转换为大写。

【例子】

str2 = "DAXIExiaoxie"
print(str2.lower())  # daxiexiaoxie
print(str2.upper())  # DAXIEXIAOXIE
print(str2.swapcase())  # daxieXIAOXIE

以上代码中，使用了字符串的一些方法进行大小写转换操作。

str2 = "DAXIExiaoxie"
print(str2.lower())  # daxiexiaoxie

在这里，lower() 方法将字符串中所有的字符转换为小写，并返回转换后的新字符串。结果是 'daxiexiaoxie'。

print(str2.upper())  # DAXIEXIAOXIE

upper() 方法将字符串中所有的字符转换为大写，并返回转换后的新字符串。结果是 'DAXIEXIAOXIE'。

print(str2.swapcase())  # daxieXIAOXIE

swapcase() 方法将字符串中的大写字母转换为小写字母，将小写字母转换为大写字母，并返回转换后的新字符串。结果是 'daxieXIAOXIE'。

这些方法提供了将字符串的大小写转换为所需格式的便捷方式，可以根据需要使用它们来处理字符串。

- count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数。

【例子】

str2 = "DAXIExiaoxie"
print(str2.count('xi'))  # 2

count('xi') 方法会统计字符串 'xi' 在 str2 中出现的次数，并返回结果。在这里，'xi' 出现了两次，所以输出结果为 2。

count() 方法可以用于统计任何子串在字符串中出现的次数。它可以帮助你快速统计特定子串的出现频率。

- endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。

- startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。

【例子】

str2 = "DAXIExiaoxie"
print(str2.endswith('ie'))  # True
print(str2.endswith('xi'))  # False
print(str2.startswith('Da'))  # False
print(str2.startswith('DA'))  # True

以上代码中，使用了字符串的 endswith() 和 startswith() 方法来检查字符串是否以指定的子串结尾或开头。

str2 = "DAXIExiaoxie"
print(str2.endswith('ie'))  # True

endswith('ie') 方法会检查字符串 str2 是否以 'ie' 结尾，并返回布尔值结果。在这里，str2 以 'ie' 结尾，所以输出结果为 True。

print(str2.endswith('xi'))  # False

endswith('xi') 方法同样会检查字符串 str2 是否以 'xi' 结尾。在这里，str2 不以 'xi' 结尾，所以输出结果为 False。

print(str2.startswith('Da'))  # False

startswith('Da') 方法会检查字符串 str2 是否以 'Da' 开头。在这里，str2 不以 'Da' 开头，所以输出结果为 False。

print(str2.startswith('DA'))  # True

startswith('DA') 方法同样会检查字符串 str2 是否以 'DA' 开头。在这里，str2 以 'DA' 开头，所以输出结果为 True。

这些方法可以帮助你快速判断字符串是否以指定的子串开头或结尾，从而进行相应的逻辑判断和处理。

- find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。

- rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找。

【例子】

str2 = "DAXIExiaoxie"
print(str2.find('xi'))  # 5
print(str2.find('ix'))  # -1
print(str2.rfind('xi'))  # 9

在以上代码中，使用了字符串的 find() 和 rfind() 方法来查找子串在字符串中的位置。

str2 = "DAXIExiaoxie"
print(str2.find('xi'))  # 5

find('xi') 方法会在字符串 str2 中查找子串 'xi'，并返回第一个匹配到的子串的起始位置。在这里，'xi' 是从索引位置 5 开始的子串，所以输出结果为 5。

print(str2.find('ix'))  # -1

find('ix') 方法同样会在字符串 str2 中查找子串 'ix'。如果子串不存在，则返回 -1。在这里，'ix' 并不是 str2 中的子串，所以输出结果为 -1。

print(str2.rfind('xi'))  # 9

rfind('xi') 方法会从右边开始在字符串 str2 中查找子串 'xi'，并返回最后一个匹配到的子串的起始位置。在这里，最后一个 'xi' 是从索引位置 9 开始的子串，所以输出结果为 9。

这些方法可以用于查找子串在字符串中的位置。find() 方法从左往右查找，rfind() 方法从右往左查找。如果找到了匹配的子串，则返回其起始位置；否则返回 -1。

- isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。

【例子】

str3 = '12345'
print(str3.isnumeric())  # True
str3 += 'a'
print(str3.isnumeric())  # False

在以上代码中，使用了字符串的 isnumeric() 方法来检查字符串是否只包含数字字符。

str3 = '12345'
print(str3.isnumeric())  # True

isnumeric() 方法会检查字符串 str3 是否只包含数字字符。在这里，str3 只包含数字字符 '1', '2', '3', '4', '5'，所以输出结果为 True。

str3 += 'a'
print(str3.isnumeric())  # False

在这里，我们将字符 'a' 追加到字符串 str3 的末尾。现在，str3 不再只包含数字字符，而是包含了非数字字符 'a'，所以输出结果为 False。

isnumeric() 方法可以用于判断字符串是否只包含数字字符。如果字符串只包含数字字符，则返回 True；否则返回 False。

- ljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。

- rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串。

【例子】

str4 = '1101'
print(str4.ljust(8, '0'))  # 11010000
print(str4.rjust(8, '0'))  # 00001101

在以上代码中，使用了字符串的 ljust() 和 rjust() 方法来对字符串进行左对齐和右对齐，并用指定字符填充空白位置。

str4 = '1101'
print(str4.ljust(8, '0'))  # 11010000

ljust(8, '0') 方法会将字符串 str4 进行左对齐，并在右侧用字符 '0' 填充空白位置，使字符串总长度为 8。在这里，str4 的长度为 4，所以在右侧添加了 4 个 '0'，得到结果 '11010000'。

print(str4.rjust(8, '0'))  # 00001101

rjust(8, '0') 方法会将字符串 str4 进行右对齐，并在左侧用字符 '0' 填充空白位置，使字符串总长度为 8。在这里，str4 的长度为 4，所以在左侧添加了 4 个 '0'，得到结果 '00001101'。

这些方法可以用于对字符串进行对齐操作，并用指定的字符填充空白位置。ljust() 方法是左对齐，rjust() 方法是右对齐。第一个参数是总长度，第二个参数是填充字符。如果字符串长度小于总长度，则会根据对齐方式在相应位置添加填充字符。

- lstrip([chars]) 截掉字符串左边的空格或指定字符。

- rstrip([chars]) 删除字符串末尾的空格或指定字符。

- strip([chars]) 在字符串上执行lstrip()和rstrip()。

【例子】

str5 = ' I Love LsgoGroup '
print(str5.lstrip())  # 'I Love LsgoGroup '
print(str5.lstrip().strip('I'))  # ' Love LsgoGroup '
print(str5.rstrip())  # ' I Love LsgoGroup'
print(str5.strip())  # 'I Love LsgoGroup'
print(str5.strip().strip('p'))  # 'I Love LsgoGrou'

在以上代码中，使用了字符串的 lstrip()、rstrip() 和 strip() 方法来删除字符串开头和末尾的空格或指定字符。

str5 = ' I Love LsgoGroup '
print(str5.lstrip())  # 'I Love LsgoGroup '

lstrip() 方法会删除字符串 str5 开头的所有空格（或空白字符）。在这里，str5 开头有一个空格，所以该空格被删除，得到结果 'I Love LsgoGroup '。

print(str5.lstrip().strip('I'))  # ' Love LsgoGroup '

首先，lstrip() 方法删除了字符串 str5 开头的空格，得到 'I Love LsgoGroup '。然后，strip('I') 方法删除了开头的字符 'I'，得到结果 ' Love LsgoGroup '。

print(str5.rstrip())  # ' I Love LsgoGroup'

rstrip() 方法会删除字符串 str5 末尾的所有空格（或空白字符）。在这里，str5 末尾有一个空格，所以该空格被删除，得到结果 ' I Love LsgoGroup'。

print(str5.strip())  # 'I Love LsgoGroup'

strip() 方法会删除字符串 str5 开头和末尾的所有空格（或空白字符）。在这里，开头和末尾的空格都被删除，得到结果 'I Love LsgoGroup'。

print(str5.strip().strip('p'))  # 'I Love LsgoGrou'

首先，strip() 方法删除了字符串 str5 开头和末尾的空格，得到 'I Love LsgoGroup'。然后，strip('p') 方法删除了末尾的字符 'p'，得到结果 'I Love LsgoGrou'。

这些方法可以用于删除字符串开头和末尾的空格或指定字符。lstrip() 方法删除开头的空格或指定字符，rstrip() 方法删除末尾的空格或指定字符，strip() 方法删除开头和末尾的空格或指定字符。

- partition(sub) 找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','')。

- rpartition(sub)类似于partition()方法，不过是从右边开始查找。

【例子】

str5 = ' I Love LsgoGroup '
print(str5.strip().partition('o'))  # ('I L', 'o', 've LsgoGroup')
print(str5.strip().partition('m'))  # ('I Love LsgoGroup', '', '')
print(str5.strip().rpartition('o'))  # ('I Love LsgoGr', 'o', 'up')

在以上代码中，使用了字符串的 partition() 和 rpartition() 方法来根据指定的分隔符将字符串分割成三部分。

str5 = ' I Love LsgoGroup '
print(str5.strip().partition('o'))  # ('I L', 'o', 've LsgoGroup')

strip() 方法用于删除字符串开头和末尾的空格。在这里，str5 开头和末尾都有空格，所以调用 strip() 方法后得到 'I Love LsgoGroup'。然后，partition('o') 方法会将字符串按照第一个出现的 'o' 分隔成三部分，得到结果 ('I L', 'o', 've LsgoGroup')。

print(str5.strip().partition('m'))  # ('I Love LsgoGroup', '', '')

同样地，在调用 strip() 方法后得到 'I Love LsgoGroup'。然后，由于字符串中没有出现字符 'm'，所以 partition('') 方法返回的结果是原字符串作为第一部分，空字符串作为第二和第三部分，得到 ('I Love LsgoGroup', '', '')。

print(str5.strip().rpartition('o'))  # ('I Love LsgoGr', 'o', 'up')

rpartition('o') 方法会将字符串按照最后一个出现的 'o' 分隔成三部分，得到结果 ('I Love LsgoGr', 'o', 'up')。由于字符串末尾有一个空格被 strip() 方法去掉了，所以最后一部分是 'up' 而不是 'up '。

这些方法可以用于将字符串按照指定的分隔符分割成三部分，并返回一个包含三个元素的元组，元组的第一个元素是分隔符之前的部分，第二个元素是分隔符本身，第三个元素是分隔符之后的部分。其中，partition() 方法从左往右查找分隔符，而 rpartition() 方法从右往左查找分隔符。如果字符串中不存在分隔符，则分隔结果为原字符串及两个空字符串。

- replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次。

【例子】

str5 = ' I Love LsgoGroup '
print(str5.strip().replace('I', 'We'))  # We Love LsgoGroup

在以上代码中，使用了字符串的 strip() 和 replace() 方法来删除字符串开头和末尾的空格，并将字符串中的 'I' 替换为 'We'。

str5 = ' I Love LsgoGroup '
print(str5.strip().replace('I', 'We'))  # We Love LsgoGroup

首先，str5.strip() 方法会删除字符串 str5 开头和末尾的所有空格。在这里，str5 开头和末尾都有空格，所以调用 strip() 方法后得到 'I Love LsgoGroup'。然后，replace('I', 'We') 方法会将字符串中的所有 'I' 替换为 'We'，得到结果 'We Love LsgoGroup'。

这段代码的最终输出是 'We Love LsgoGroup'，其中开头的空格被删除，而 'I' 被替换为 'We'。

- split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。

【例子】

str5 = ' I Love LsgoGroup '
print(str5.strip().split())  # ['I', 'Love', 'LsgoGroup']
print(str5.strip().split('o'))  # ['I L', 've Lsg', 'Gr', 'up']

在以上代码中，使用了字符串的 strip() 和 split() 方法来删除字符串开头和末尾的空格，并根据指定的分隔符将字符串拆分成列表。

str5 = ' I Love LsgoGroup '
print(str5.strip().split())  # ['I', 'Love', 'LsgoGroup']

首先，str5.strip() 方法会删除字符串 str5 开头和末尾的所有空格。在这里，str5 开头和末尾都有空格，所以调用 strip() 方法后得到 'I Love LsgoGroup'。然后，split() 方法被用于将字符串按照空格进行分割，得到一个包含多个子字符串的列表。由于没有指定分隔符，所以默认使用空格作为分隔符。最终输出为 ['I', 'Love', 'LsgoGroup']，即按空格拆分后的字符串列表。

print(str5.strip().split('o'))  # ['I L', 've Lsg', 'Gr', 'up']

同样地，在调用 strip() 方法后得到 'I Love LsgoGroup'。然后，split('o') 方法会根据字符 'o' 将字符串进行分割，并返回一个列表。最终输出为 ['I L', 've Lsg', 'Gr', 'up']，即按字符 'o' 拆分后的字符串列表。

这些方法可以用于将字符串按照指定的分隔符进行拆分，并返回一个包含拆分后的子字符串的列表。如果没有指定分隔符，则默认使用空格作为分隔符。

【例子】

u = "www.baidu.com.cn"
# 使用默认分隔符
print(u.split())  # ['www.baidu.com.cn']

# 以"."为分隔符
print((u.split('.')))  # ['www', 'baidu', 'com', 'cn']

# 分割0次
print((u.split(".", 0)))  # ['www.baidu.com.cn']

# 分割一次
print((u.split(".", 1)))  # ['www', 'baidu.com.cn']

# 分割两次
print(u.split(".", 2))  # ['www', 'baidu', 'com.cn']

# 分割两次，并取序列为1的项
print((u.split(".", 2)[1]))  # baidu

# 分割两次，并把分割后的三个部分保存到三个变量
u1, u2, u3 = u.split(".", 2)
print(u1)  # www
print(u2)  # baidu
print(u3)  # com.cn

去掉换行符

【例子】

c = '''say
hello
baby'''

print(c)
# say
# hello
# baby

print(c.split('\n'))  # ['say', 'hello', 'baby']

在以上代码中，创建了一个多行字符串 c，然后使用 split('\n') 方法将其按照换行符 \n 进行拆分。

c = '''say
hello
baby'''

print(c)
# say
# hello
# baby

print(c.split('\n'))  # ['say', 'hello', 'baby']

首先，你使用三个引号 ''' 创建了一个包含换行符的多行字符串 c。该字符串具有三行内容，每行之间使用换行符进行分隔。

然后，你使用 print(c) 将字符串 c 输出到控制台，结果是按原始的格式打印出字符串的内容，即：

say
hello
baby

最后，你使用 split('\n') 方法对字符串 c 进行拆分，其中分隔符为换行符 \n。这将返回一个包含拆分后的子字符串的列表。在这里，拆分后的结果是 ['say', 'hello', 'baby']，即每行作为一个元素存储在列表中。

因此，print(c.split('\n')) 的输出结果为 ['say', 'hello', 'baby']。

【例子】

string = "hello boy<[www.baidu.com]>byebye"
print(string.split('[')[1].split(']')[0])  # www.baidu.com
print(string.split('[')[1].split(']')[0].split('.'))  # ['www', 'baidu', 'com']

在以上代码中，在字符串 string中，你使用了多个 split() 方法来提取其中的子字符串。

string = "hello boy<[www.baidu.com]>byebye"
print(string.split('[')[1].split(']')[0])  # www.baidu.com

首先，你使用 split('[') 方法将字符串 string 按照字符 '[' 进行拆分，并获取拆分后的第二部分（索引为 [1]），得到 'www.baidu.com]'。然后，你再次使用 split(']') 方法将这个结果按照字符 ']' 进行拆分，并获取拆分后的第一部分（索引为 [0]），得到 'www.baidu.com'。最终输出为 'www.baidu.com'。

print(string.split('[')[1].split(']')[0].split('.'))
# ['www', 'baidu', 'com']

在这段代码中，我们在前面的基础上通过 split('.') 方法对 'www.baidu.com' 进行拆分，按照 . 字符作为分隔符，得到一个列表 ['www', 'baidu', 'com']。该列表包含了按照 . 分隔后的子字符串。

因此，print(string.split('[')[1].split(']')[0].split('.')) 的输出结果是 ['www', 'baidu', 'com']。

- splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。

【例子】

str6 = 'I \n Love \n LsgoGroup'
print(str6.splitlines())  # ['I ', ' Love ', ' LsgoGroup']
print(str6.splitlines(True))  # ['I \n', ' Love \n', ' LsgoGroup']

在以上代码中，在字符串 str6中，你使用了 splitlines() 方法来将字符串拆分成多行。

str6 = 'I \n Love \n LsgoGroup'
print(str6.splitlines())  # ['I ', ' Love ', ' LsgoGroup']

在这里，你使用 splitlines() 方法将字符串 str6 按照行进行拆分，并返回一个列表。该方法会自动识别不同的换行符，并将字符串拆分成多行。

由于 str6 中包含了换行符 \n，splitlines() 方法会以换行符为依据将字符串拆分成多行。因此，拆分后的结果是 ['I ', ' Love ', ' LsgoGroup']，即每一行作为一个元素存储在列表中。

print(str6.splitlines(True))  # ['I \n', ' Love \n', ' LsgoGroup']

当你使用 splitlines(True) 时，它会保留每行的换行符。在这个例子中，输出结果是 ['I \n', ' Love \n', ' LsgoGroup']，即每一行包括换行符在内作为一个元素存储在列表中。

所以，print(str6.splitlines()) 的输出结果是 ['I ', ' Love ', ' LsgoGroup']，print(str6.splitlines(True)) 的输出结果是 ['I \n', ' Love \n', ' LsgoGroup']。

- maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

- translate(table, deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。

【例子】

str7 = 'this is string example....wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str7.maketrans(intab, outtab)
print(trantab)  # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}
print(str7.translate(trantab))  # th3s 3s str3ng 2x1mpl2....w4w!!!

在以上代码中，创建了一个字符串 str7，并使用 maketrans() 方法创建了一个转换表 trantab，然后使用 translate() 方法应用这个转换表来对字符串进行转换。

str7 = 'this is string example....wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str7.maketrans(intab, outtab)
print(trantab)  # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}

在这里，maketrans() 方法用于创建一个转换表，它接受两个参数，分别是需要替换的字符和它们对应的替换字符。在这个例子中，intab 包含了需要被替换的字符集合，而 outtab 包含了相应的替换字符集合。maketrans() 方法将根据这两个参数创建一个转换表，并将其赋值给变量 trantab。

输出结果 {97: 49, 111: 52, 117: 53, 101: 50, 105: 51} 是一个字典，它表示每个需要替换的字符在 ASCII 码中的值作为键，其对应的替换字符在 ASCII 码中的值作为值。

print(str7.translate(trantab))  # th3s 3s str3ng 2x1mpl2....w4w!!!

在这里，你使用 translate() 方法来应用转换表 trantab 对字符串 str7 进行字符替换。这个方法将根据转换表中的映射关系对字符串进行替换，并返回替换后的结果。

输出结果 th3s 3s str3ng 2x1mpl2....w4w!!! 是经过字符替换后的字符串，其中每个需要替换的字符都被其对应的替换字符所代替。

因此，print(trantab) 的输出结果是 {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}，print(str7.translate(trantab)) 的输出结果是 th3s 3s str3ng 2x1mpl2....w4w!!!。

四、 字符串格式化

- format 格式化函数

【例子】

str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置参数
print(str8)  # I Love Lsgogroup

str8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 关键字参数
print(str8)  # I Love Lsgogroup

str8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置参数要在关键字参数之前
print(str8)  # I Love Lsgogroup

str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位
print(str8)  # 27.66GB

在以上代码中，使用了字符串的 format() 方法来格式化字符串。这个方法允许你将变量、常量和表达式插入到一个字符串中。

首先，让我们看下位置参数的例子：

str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置参数
print(str8)  # I Love Lsgogroup

在这里，{0} 和 {1} 是占位符，它们分别表示第一个和第二个位置参数。通过 format() 方法，我们将 'I' 和 'Lsgogroup' 作为位置参数传递进去，然后将它们插入到字符串中。

输出结果是 I Love Lsgogroup，即字符串中的占位符被相应的参数值替换。

接下来，让我们看关键字参数的例子：

str8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 关键字参数
print(str8)  # I Love Lsgogroup

在这里，我们使用了关键字参数来传递值。a='I' 和 b='Lsgogroup' 表示将 'I' 分配给关键字参数 a，'Lsgogroup' 分配给关键字参数 b。

输出结果同样是 I Love Lsgogroup，即关键字参数的值被插入到字符串中。

在下一个例子中，我们将位置参数和关键字参数一起使用：

str8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置参数要在关键字参数之前
print(str8)  # I Love Lsgogroup

在这里，我们将 'I' 作为第一个位置参数传递给 {0}，将 'Lsgogroup' 作为关键字参数传递给 {b}。

输出结果仍然是 I Love Lsgogroup，因为位置参数要在关键字参数之前。

最后，让我们看一个格式化数字的例子：

str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位
print(str8)  # 27.66GB

在这里，{0:.2f} 表示第一个位置参数是一个浮点数，且保留两位小数。{1} 表示第二个位置参数。

输出结果是 27.66GB，即浮点数被格式化为保留两位小数，并与字符串 'GB' 拼接在一起。

- Python 字符串格式化符号

【例子】

print('%c' % 97)  # a
print('%c %c %c' % (97, 98, 99))  # a b c
print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10))  # 我叫 小明 今年 10 岁!
print('%o' % 10)  # 12
print('%x' % 10)  # a
print('%X' % 10)  # A
print('%f' % 27.658)  # 27.658000
print('%e' % 27.658)  # 2.765800e+01
print('%E' % 27.658)  # 2.765800E+01
print('%g' % 27.658)  # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text)  # I said: I am 22 years old..
print("I said: %r." % text)  # I said: 'I am 22 years old.'

print('%c' % 97)

这里使用了格式化操作符 % 来将整数 97 转换成相应的 ASCII 字符。%c 是字符类型的占位符，它将整数按照 ASCII 码表转换为对应的字符。

print('%c %c %c' % (97, 98, 99))

这里使用了三个位置参数并指定了三个占位符 %c，分别将整数 97、98 和 99 转换成对应的 ASCII 字符。输出结果是 'a b c'。

print('%d + %d = %d' % (4, 5, 9))

这里使用了三个位置参数并指定了三个占位符 %d，分别将整数 4、5 和 9 插入到字符串中。输出结果是 '4 + 5 = 9'。

print("我叫 %s 今年 %d 岁!" % ('小明', 10))

这里使用了一个字符串占位符 %s 和一个整数占位符 %d。通过将 '小明' 和整数 10 作为参数传递给 format() 方法，将其插入到字符串中。输出结果是 '我叫 小明 今年 10 岁!'。

print('%o' % 10)

这里使用了一个整数占位符 %o，它将整数 10 转换为八进制数。输出结果是 '12'。

print('%x' % 10)

这里使用了一个整数占位符 %x，它将整数 10 转换为十六进制数（小写字母）。输出结果是 'a'。

print('%X' % 10)

这里使用了一个整数占位符 %X，它将整数 10 转换为十六进制数（大写字母）。输出结果是 'A'。

print('%f' % 27.658)

这里使用了一个浮点数占位符 %f，它将浮点数 27.658 格式化为十进制的字符串，并保留6位小数。输出结果是 '27.658000'。

print('%e' % 27.658)

这里使用了一个浮点数占位符 %e，它将浮点数 27.658 格式化为科学计数法字符串。输出结果是 '2.765800e+01'。

print('%E' % 27.658)

这里使用了一个浮点数占位符 %E，它将浮点数 27.658 格式化为科学计数法字符串（大写字母）。输出结果是 '2.765800E+01'。

print('%g' % 27.658)

这里使用了一个浮点数占位符 %g，它根据实际情况选择使用 %f 或 %e 来格式化。输出结果是 '27.658'。

text = "I am %d years old." % 22
print("I said: %s." % text)

这里使用了一个字符串占位符 %s 和一个整数占位符 %d。"%d years old" 是一个子字符串，它将整数 22 插入到字符串中。最后的输出结果是 'I said: I am 22 years old..'。

print("I said: %r." % text)

这里使用了一个原始字符串占位符 %r，它将字符串 text 插入到字符串中，并用引号括起来。最后的输出结果是 'I said: 'I am 22 years old.'.'。

- 格式化操作符辅助指令

【例子】

print('%5.1f' % 27.658)  # ' 27.7'
print('%.2e' % 27.658)  # 2.77e+01
print('%10d' % 10)  # '        10'
print('%-10d' % 10)  # '10        '
print('%+d' % 10)  # +10
print('%#o' % 10)  # 0o12
print('%#x' % 108)  # 0x6c
print('%010d' % 5)  # 0000000005

print('%5.1f' % 27.658)

这里使用了一个浮点数占位符 %f 和格式化指示符 .1。%5.1f 表示总宽度为5个字符，其中1个用于小数点后面的数字。由于27.658有3位整数和3位小数，所以会在前面填充一个空格，输出结果是 ' 27.7'。

print('%.2e' % 27.658)

这里使用了一个浮点数占位符 %e 和格式化指示符 .2。%.2e 表示输出科学计数法，小数点后面保留2位有效数字。输出结果是 '2.77e+01'。

print('%10d' % 10)

这里使用了一个整数占位符 %d 和格式化指示符 10。%10d 表示总宽度为10个字符，由于整数 10 只有2位，所以在前面填充了8个空格，输出结果是 ' 10'。

print('%-10d' % 10)

这里使用了一个整数占位符 %d 和格式化指示符 -10。%-10d 表示总宽度为10个字符，并左对齐填充，由于整数 10 只有2位，所以在后面填充了8个空格，输出结果是 '10 '。

print('%+d' % 10)

这里使用了一个整数占位符 %d 和格式化指示符 +。%+d 表示正数前面加上 + 号。由于整数 10 是正数，所以输出结果是 '+10'。

print('%#o' % 10)

这里使用了一个整数占位符 %o 和格式化指示符 #。%#o 表示输出八进制数，并在前面加上 0o 前缀。整数 10 转换成八进制是 12，所以输出结果是 '0o12'。

print('%#x' % 108)

这里使用了一个整数占位符 %x 和格式化指示符 #。%#x 表示输出十六进制数，并在前面加上 0x 前缀。整数 108 转换成十六进制是 6c，所以输出结果是 '0x6c'。

print('%010d' % 5)

这里使用了一个整数占位符 %d 和格式化指示符 010。%010d 表示总宽度为10个字符，并在前面填充0。由于整数 5 只有1位，所以在前面填充了9个0，输出结果是 '0000000005'。

如有错误欢迎指正，谢谢！