字符串内置函数
#***********总体实例********************
# 方法 描述
# capitalize() 把首字符转换为大写。
# 定义和用法:
# capitalize() 方法返回一个字符串，其中第一个字符为大写。
# 语法: string.capitalize()
# 参数值: 无参数
# txt = "hello, and welcome to my world."
# x = txt.capitalize()
# print (x)
# casefold() 把字符串转换为小写。
#定义和用法:
# casefold() 方法返回一个字符串，其中所有字符均为小写。
# 此方法与 Lower() 方法相似，但是 casefold() 方法更强大，更具攻击性，这意味着它将更多字符转换为小写字母，
# 并且在比较两个用 casefold() 方法转换的字符串时会找到更多匹配项。
#语法: string.casefold()
# 参数值: 无参数
# txt = "Hello, And Welcome To My World!"
# x = txt.casefold()
# print(x)
# center() 返回居中的字符串。
# 定义和用法:
# center() 方法将使用指定的字符（默认为空格）作为填充字符使字符串居中对齐。
# 语法:string.center(length, character)
# 参数值
# 参数 描述
# length 必需。所返回字符串的长度。
# character 可选。填补两侧缺失空间的字符。默认是 " "（空格）。
# 使用字母 "O" 作为填充字符：
# txt = "banana"
# x = txt.center(20, "O")
# print(x)
# count() 返回指定值在字符串中出现的次数。
# 定义和用法:
# count() 方法返回指定值在字符串中出现的次数。
# 语法:string.count(value, start, end)
# 参数值
# 参数 描述
# value 必需。字符串。要检索的字符串。
# start 可选。整数。开始检索的位置。默认是 0。
# end 可选。整数。结束检索的位置。默认是字符串的结尾。
# 实例1
# 从位置 10 到 24 进行检索：
# txt = "I love apples, apple are my favorite fruit"
# x = txt.count("apple", 10, 24)
# print(x)
# 实例2
# 返回值 "apple" 在字符串中出现的次数：
# txt = "I love apples, apple are my favorite fruit"
# x = txt.count("apple")
# print(x)
# encode() 返回字符串的编码版本。
# 定义和用法:
# encode() 方法使用指定的编码对字符串进行编码。如果未指定编码，则将使用 UTF-8。
# 语法: string.encode(encoding=encoding, errors=errors)
# 参数值
# 参数 描述
# encoding 可选。字符串。规定要使用的编码。默认是 UTF-8。
# errors 可选。字符串。规定错误方法。合法值是： 'backslashreplace' 使用反斜杠代替无法编码的字符
# 'ignore' 忽略无法编码的字符 'namereplace'用解释字符的文本替换字符 'strict'默认值，
# 失败时引发错误 'replace'用问号替换字符 'xmlcharrefreplace'用 xml 字符替换字符
# 实例1
# 对字符串进行 UTF-8 编码：
# txt = "My name is Ståle"
# x = txt.encode()
# print(x)
# 实例2
# txt = "My name is Ståle"
# print(txt.encode(encoding="ascii",errors="backslashreplace"))
# print(txt.encode(encoding="ascii",errors="ignore"))
# print(txt.encode(encoding="ascii",errors="namereplace"))
# print(txt.encode(encoding="ascii",errors="replace"))
# print(txt.encode(encoding="ascii",errors="xmlcharrefreplace"))
# print(txt.encode(encoding="ascii",errors="strict"))
# endswith() 如果字符串以指定值结尾，则返回 true。
# 定义和用法:
# 如果字符串以指定值结尾，则 endswith() 方法返回 True，否则返回 False。
# 语法: string.endswith(value, start, end)
# 参数值
# 参数 描述
# value 必需。检查字符串是否以之结尾的值。
# start 可选。整数。规定从哪个位置开始检索。
# end 可选。整数。规定从哪个位置结束检索。
# 实例1 :检查字符串是否以标点符号 (.) 结尾
# txt = "Hello, welcome to my world."
# x = txt.endswith(".")
# print(x)
# 实例2 :检查字符串是否以短语 "my world." 结尾
# txt = "Hello, welcome to my world."
# x = txt.endswith("my world.")
# print(x)
# 实例3 :检查位置 5 至 11 是否以短语 "my world." 结尾：
# txt = "Hello, welcome to my world."
# x = txt.endswith("my world.", 5, 11)
# print(x)
# expandtabs() 设置字符串的 tab 尺寸。
# 定义和用法:
# expandtabs() 方法将制表符的大小设置为指定的空格数。
# 语法:string.exandtabs(tabsize)
# 参数值
# 参数 描述
# tabsize 可选。规定制表符大小的数字。默认的 tabsize 是 8。
# 实例1 :将制表符大小设置为 2 个空格：
# txt = "H\te\tl\tl\to"
# x = txt.expandtabs(2)
# print(x)
# 实例2 :看看不同制表符大小的结果：
# txt = "H\te\tl\tl\to"
# print(txt)
# print(txt.expandtabs())
# print(txt.expandtabs(2))
# print(txt.expandtabs(4))
# print(txt.expandtabs(10))
# find() 在字符串中搜索指定的值并返回它被找到的位置。
# 定义和用法:
# find() 方法查找指定值的首次出现。
# 如果找不到该值，则 find() 方法返回 -1。
# find() 方法与 index() 方法几乎相同，唯一的区别是，如果找不到该值，index() 方法将引发异常。（请看下面的例子）
# 语法: string.find(value, start, end)
# 参数值
# 参数 描述
# value 必需。要检索的值。
# start 可选。开始检索的位置。默认是 0。
# end 可选。结束检索的位置。默认是字符串的结尾。
# 实例1: 单词 "welcome" 在文本中的什么位置？
# txt = "Hello, welcome to my world."
# x = txt.find("welcome")
# print(x)
# 实例2: 字母 "e" 在文本总首次出现的位置：
# txt = "Hello, welcome to my world."
# x = txt.find("e")
# print(x)
# 实例3: 如果只搜索位置 5 到 10 时，字母 "e" 在文本总首次出现的位置：
# txt = "Hello, welcome to my world."
# x = txt.find("e", 5, 10)
# print(x)
# 实例4:如果找不到该值，则 find() 方法返回 -1，但是 index() 方法将引发异常：
# txt = "Hello, welcome to my world."
# print(txt.find("q"))
# print(txt.index("q"))
# format() 格式化字符串中的指定值。
# 定义和用法
# format() 方法格式化指定的值，并将其插入字符串的占位符内。
# 占位符使用大括号 {} 定义。请在下面的“占位符”部分中了解有关占位符的更多信息。
# format() 方法返回格式化的字符串。
# 语法: string.format(value1, value2...)
# 参数值
# 参数 描述
# value1, value2... 必需。一个或多个应该格式化并插入字符串的值。值可以是数字，用于指定要删除的元素的位置。
# 这些值可以是用逗号分隔的值列表、键=值列表，或两者的组合。
# 这些值可以是任何数据类型。
# 占位符
# 可以使用命名索引 {price}、编号索引{0}、甚至空的占位符 {} 来标识占位符。
# 实例1:将价格插入占位符内，价格应为定点，两位十进制格式：
# txt = "For only {price:.2f} dollars!"
# print(txt.format(price = 49))
# 实例2: 使用不同的占位符值：
# txt1 = "My name is {fname}, I'am {age}".format(fname = "Bill", age = 64)
# txt2 = "My name is {0}, I'am {1}".format("Bill",64)
# txt3 = "My name is {}, I'am {}".format("Bill",64)
# 实例3: 格式化类型在占位符内，您可以添加格式化类型以格式化结果:
# 就做一个实例@!!!
# txt = "We have {:<8} chickens."
# print(txt.format(49))
#
# :< 左对齐结果（在可用空间内）
# :> 右对齐结果（在可用空间内）
# :^ 居中对齐结果（在可用空间内）
# := 将标志放置在最左侧
# :+ 使用加号指示结果是正数还是负数
# :- 负号仅用于负值
# : 使用空格在正数之前插入一个多余的空格（在负数之前使用减号）
# :, 使用逗号作为千位分隔符
# :_ 使用下划线作为千位分隔符
# :b 二进制格式
# :c 将值转换为相应的 unicode 字符
# :d 十进制格式
# :e 科学格式，带有小写字母 E
# :E 科学格式，带有大写字母 E
# :f 定点数字格式
# :F 定点数字格式，以大写形式显示（将 inf 和 nan 显示为 INF 和 NAN）
# :g 通用格式
# :G 通用格式（将大写 E 用作科学计数法）
# :o 八进制格式
# :x 十六进制格式，小写
# :X 十六进制格式，大写
# :n 数字格式
# :% 百分比格式
# format_map() 格式化字符串中的指定值。
# index() 在字符串中搜索指定的值并返回它被找到的位置。
# 定义和用法
# index() 方法查找指定值的首次出现。
# 如果找不到该值，index() 方法将引发异常。
# index() 方法与 find() 方法几乎相同，唯一的区别是，如果找不到该值，则 find() 方法将返回 -1。（请看下面的例子）
# 语法: string.index(value, start, end)
# 参数值:
# 参数 描述
# value 必需。要检索的值。
# start 可选。在哪里开始检索。默认是 0。
# end 可选。在哪里结束检索。默认是字符串的末尾。
# 实例1: 文字中 "welcome" 一词在哪里？
# txt = "Hello, welcome to my world."
# x = txt.index("welcome")
# print(x)
# 实例2: 字母 "e" 在文本中首次出现在哪里？
# txt = "Hello, welcome to my world."
# x = txt.index("e")
# print(x)
# 实例3: 如果只在位置 5 和 10 之间搜索时，字母 "e"首次首先在哪里？
# txt = "Hello, welcome to my world."
# x = txt.index("e", 5, 10)
# print(x)
# 实例4: 如果找不到该值，则 find() 方法返回 -1，但是 index() 方法将引发异常：
# txt = "Hello, welcome to my world."
# print(txt.find("q"))
# print(txt.index("q"))
# isalnum() 如果字符串中的所有字符都是字母数字，则返回 True。
# 定义和用法
# 如果所有字符均为字母数字，即字母（a-z）和数字（0-9），则 isalnum() 方法返回 True。
# 非字母数字的例子：(space)!#%&? 等等。
# 语法: string.isalnum()
# 参数值:无参数.
# 实例1: 检查文本中的所有字符是否都是字母数字：
# txt = "Company12"
# x = txt.isalnum()
# print(x)
# 实例2: 检查文本中的所有字符是否都是字母数字：
# txt = "Company 12"
# x = txt.isalnum()
# print(x)
# isalpha() 如果字符串中的所有字符都在字母表中，则返回 True。
# 定义和用法
# 如果所有字符都是字母（a-z），则 isalpha() 方法将返回 True。
# 非字母的字符例子：(space)!#%&? 等等。
# 语法: string.isalpha()
# 参数值: 无参数.
# 实例1:检查文本中的所有字符是否都是字母：
# txt = "CompanyX"
# x = txt.isalpha()
# print(x)
# 实例2:检查文本中的所有字符是否都是字母：
# txt = "Company10"
# x = txt.isalpha()
# print(x)
# isdecimal() 如果字符串中的所有字符都是小数，则返回 True。
# 定义和用法
# 如果所有字符均为小数（0-9），则 isdecimal() 方法将返回 True。
# 此方法用于 unicode 对象。
# 语法: string.isdecimal()
# 参数值: 无参数.
# 实例1: 检查 unicode 对象中的所有字符是否都是小数：
# txt = "\u0033" #unicode for 3
# x = txt.isdecimal()
# print(x)
# 实例2:检查 unicode 中的所有字符是否都是小数：
# a = "\u0030" #unicode for 0
# b = "\u0047" #unicode for G
# print(a.isdecimal())
# print(b.isdecimal())
# isdigit() 如果字符串中的所有字符都是数字，则返回 True。
# 定义和用法
# 如果所有字符都是数字，则 isdigit() 方法将返回 True，否则返回 False。
# 指数（例如²）也被视作数字。
# 语法: string.isdigit()
# 参数值: 无参数.
# 实例1:检查文本中的所有字符是否都是数字：
# txt = "50800"
# x = txt.isdigit()
# print(x)
# 实例2:检查文本中的所有字符是否都是字母：
# a = "\u0030" #unicode for 0
# b = "\u00B2" #unicode for ²
# print(a.isdigit())
# print(b.isdigit())
# isidentifier()如果字符串是标识符，则返回 True。
# 定义和用法
# 如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。
# 如果字符串仅包含字母数字字母（a-z）和（0-9）或下划线（_），则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格。
# 语法:string.isidentifier()
# 参数值:无参数.
# 实例1:检查字符串是否是有效标识符
# txt="Demo"
# x=txt.ididentifier ()
# print(x)
# 实例2:检查字符串是否为有效标识符：
# a = "MyFolder"
# b = "Demo002"
# c = "2bring"
# d = "my demo"
# print(a.isidentifier())
# print(b.isidentifier())
# print(c.isidentifier())
# print(d.isidentifier())
# islower() 如果字符串中的所有字符都是小写，则返回 True。
# 定义和用法
# 如果所有字符均为小写，则 islower() 方法返回 True，否则返回 False。
# 不检查数字、符号和空格，仅检查字母字符。
# 语法: string.islower()
# 参数值: 无参数.
# 实例1:检查文本中所有字符是否都小写：
# txt = "hello world!"
# x = txt.islower()
# print(x)
# 实例2:检查文本中所有字符是否都小写：
# a = "Hello world!"
# b = "hello 123"
# c = "mynameisPeter"
# print(a.islower())
# print(b.islower())
# print(c.islower())
# isnumeric() 如果字符串中的所有字符都是数，则返回 True。
# 定义和用法
# 如果所有字符均为数字（0-9），则 isumeric() 方法返回 True，否则返回 False。
# 指数（比如 ² 和 ¾）也被视为数字值。
# 语法: string.isnumeric()
# 参数值: 无参数.
# 实例1:检查文本中的所有字符是否都是数字：
# txt = "565543"
# x = txt.isnumeric()
# print(x)
# 实例2:检查字符是否为数字：
# a = "\u0030" #unicode for 0
# b = "\u00B2" #unicode for ²
# c = "10km2"
# print(a.isnumeric())
# print(b.isnumeric())
# print(c.isnumeric())
# isprintable() 如果字符串中的所有字符都是可打印的，则返回 True。
# 定义和用法
# 如果所有字符都是可打印的，则 isprintable() 方法返回 True，否则返回 False。
# 不可打印的字符可以是回车和换行符。
# 语法: string.isprintable()
# 参数值:无参数.
# 实例1:检查文本中的所有字符是否可打印：
# txt = "Hello! Are you #1?"
# x = txt.isprintable()
# print(x)
# 实例2: 检查文本中的所有字符是否可打印：
# txt = "Hello!\nAre you #1?"
# x = txt.isprintable()
# print(x)
# isspace() 如果字符串中的所有字符都是空白字符，则返回 True。
# 定义和用法
# 如果字符串中的所有字符都是空格，则 isspace() 方法将返回 True，否则返回 False。
# 语法: string.isspace()
# 参数值: 无参数.
# 实例1:检查文本中的所有字符是否都是空格：
# txt = " "
# x = txt.isspace()
# print(x)
# 实例2: 检查文本中的所有字符是否都是空格：
# txt = " s "
# x = txt.isspace()
# print(x)
#
# istitle() 如果字符串遵循标题规则，则返回 True。
# 定义和用法
# 如果文本中的所有单词均以大写字母开头，而单词的其余部分均为小写字母，则 istitle() 方法返回 True。否则返回 False。
# 符号和数字将被忽略。
# 语法:string.istitle()
# 参数值: 无参数.
# 实例1:检查每个单词是否以大写字母开头：
# txt = "Hello, And Welcome To My World!"
# x = txt.istitle()
# print(x)
# 实例2: 检查每个单词是否以大写字母开头：
# a = "HELLO, AND WELCOME TO MY WORLD"
# b = "Hello"
# c = "22 Names"
# d = "This Is %'!?"
# print(a.istitle())
# print(b.istitle())
# print(c.istitle())
# print(d.istitle())
# isupper() 如果字符串中的所有字符都是大写，则返回 True。
# 定义和用法
# 如果所有字符均大写，则 isupper() 方法返回 True，否则返回 False。
# 不检查数字、符号和空格，仅检查字母字符。
# 语法: string.isupper()
# 参数值: 无参数.
# 实例1: 检查文本中的所有字符是否都大写：
# txt = "THIS IS NOW!"
# x = txt.isupper()
# print(x)
# 实例2: 检查文本中的所有字符是否都大写：
# a = "Hello World!"
# b = "hello 123"
# c = "MY NAME IS BILL"
# print(a.isupper())
# print(b.isupper())
# print(c.isupper())
# join() 把可迭代对象的元素连接到字符串的末尾。
# 定义和用法
# join() 方法获取可迭代对象中的所有项目，并将它们连接为一个字符串。
# 必须将字符串指定为分隔符。
# 语法: string.join(iterable)
# 参数值
# 参数 描 述
# iterable 必需。所有返回值均为字符串的任何可迭代对象。
# 实例1: 使用哈希字符作为分隔符，将元组中的所有项目连接到字符串中：
# myTuple = ("Bill", "Steve", "Elon")
# x = "#".join(myTuple)
# print(x)
# 实例2:使用单词 "TEST" 作为分隔符，将字典中的所有项目连接成一个字符串：
# myDict = {"name": "Bill", "country": "USA"}
# mySeparator = "TEST"
# x = mySeparator.join(myDict)
# print(x)
# 注释：在使用字典作为迭代器时，返回的值是键，而不是值。
# ljust() 返回字符串的左对齐版本。
# 定义和用法
# ljust() 方法将使用指定的字符（默认为空格）作为填充字符使字符串左对齐。
# 语法: string.ljust(length, character)
# 参数值:
# 参数 描述
# length 必需。所返回字符串的长度。
# character 可选。用于填充缺少空间（在字符串的右侧）的字符。默认值为 " "（空格）。
# 实例1:返回 20 个字符长的 "banana" 一词的左对齐版本：
# txt = "banana"
# x = txt.ljust(20)
# print(x, "is my favorite fruit.")
# 注释：结果是，"banana" 一词的右边实际上有 14 个空格。
# 实例2: 使用字母 "O" 作为填充字符：
# txt = "banana"
# x = txt.ljust(20, "O")
# print(x)
# lower() 把字符串转换为小写。
# 定义和用法
# lower() 方法返回一个字符串，其中所有字符均为小写。
# 符号和数字将被忽略。
# 语法: string.lower()
# 参数值: 无参数
# 实例1:小写字符串：
# txt = "Hello my FRIENDS"
# x = txt.lower()
# print(x)
# lstrip() 返回字符串的左修剪版本。
# 定义和用法
# lstrip() 方法删除所有前导字符（空格是要删除的默认前导字符）。
# 语法: string.lstrip(characters)
# 参数值
# 参数 描述
# characters 可选。一组作为前导字符要删除的字符。
# 实例1:删除字符串左侧的空格：
# txt = " banana "
# x = txt.lstrip()
# print("of all fruits", x, "is my favorite")
# 实例2: 删除前导字符：
# txt = ",,,,,ssaaww.....banana"
# x = txt.lstrip(",.asw")
# print(x)
# maketrans() 返回在转换中使用的转换表。
# partition() 返回元组，其中的字符串被分为三部分。
# 定义和用法
# partition() 方法搜索指定的字符串，并将该字符串拆分为包含三个元素的元组。
# 第一个元素包含指定字符串之前的部分。
# 第二个元素包含指定的字符串。
# 第三个元素包含字符串后面的部分。
# 注释：此方法搜索指定字符串的第一个匹配项。
# 语法: string.partition(value)
# 参数值
# 参数 描述
# value 必需。要检索的字符串。
# 实例1:搜索单词 "bananas"，并返回包含三个元素的元组：
# 1 - “匹配”之前的所有内容 2 - “匹配” 3 - “匹配”之后的所有内容
# txt = "I could eat bananas all day"
# x = txt.partition("bananas")
# print(x)
# 实例2:如果找不到指定的值，则 partition() 方法将返回一个元组，其中包含：1 - 整个字符串，2 - 空字符串，3 - 空字符串：
# txt = "I could eat bananas all day"
# x = txt.partition("apples")
# print(x)
# replace() 返回字符串，其中指定的值被替换为指定的值。
# 定义和用法
# replace() 方法用另一个指定的短语替换一个指定的短语。
# 注释：如果未指定其他内容，则将替换所有出现的指定短语。
# 语法: string.replace(oldvalue, newvalue, count)
# 参数值
# 参数 描述
# oldvalue 必需。要检索的字符串。
# newvalue 必需。替换旧值的字符串。
# count 可选。数字，指定要替换的旧值出现次数。默认为所有的出现。
# 实例1:替换单词 "bananas"：
# txt = "I like bananas"
# x = txt.replace("bananas", "apples")
# print(x)
# 实例2:替换所有出现的单词 "one"：
# txt = "one one was a race horse, two two was one too."
# x = txt.replace("one", "three")
# print(x)
# 实例3:替换前两次出现的单词 "one"：
# txt = "one one was a race horse, two two was one too."
# x = txt.replace("one", "three", 2)
# print(x)
# rfind() 在字符串中搜索指定的值，并返回它被找到的最后位置。
# 定义和用法
# rfind() 方法查找指定值的最后一次出现。
# 如果找不到该值，则 rfind() 方法将返回 -1。
# rfind() 方法与 rindex() 方法几乎相同。请看下面的例子。
# 语法:string.rfind(value, start, end)
# 参数值
# 参数 描述
# value 必需。要检索的值。
# start 可选。从何处开始检索。默认是 0。
# end 可选。在何处结束检索。默认是到字符串的末尾。
# 实例1:文本中最后一次出现字符串 "China" 的位置：
# txt = "China is a great country. I love China."
# x = txt.rfind("casa")
# print(x)
# 实例2:在哪里最后出现文本中的字母 "e"？
# txt = "Hello, welcome to my world."
# x = txt.rfind("e")
# print(x)
# 实例3:如果只在位置 5 和位置 10 之间搜索，文本中最后出现的字母 "e" 在何处？
# txt = "Hello, welcome to my world."
# x = txt.rfind("e", 5, 10)
# print(x)
# 实例4:如果找不到该值，则 rfind() 方法返回 -1，但是 rindex() 方法将引发异常：
# txt = "Hello, welcome to my world."
# print(txt.rfind("q"))
# print(txt.rindex("q"))
# rindex() 在字符串中搜索指定的值，并返回它被找到的最后位置。
# 定义和用法
# rindex() 方法查找指定值的最后一次出现。
# 如果找不到该值，则 rindex() 方法将引发异常。
# rindex() 方法与 rfind() 方法几乎相同。请看下面的例子。
# 语法:string.rindex(value, start, end)
# 参数值
# 参数 描述
# value 必需。要检索的值。
# start 可选。从何处开始检索。默认是 0。
# end 可选。在何处结束检索。默认是到字符串的末尾。
# 实例1:文本中最后一次出现字符串 "China" 的位置：
# txt = "China is a great country. I love China."
# x = txt.rindex("casa")
# print(x)
# 实例2:在哪里最后出现文本中的字母 "e"
# txt = "Hello, welcome to my world."
# x = txt.rindex("e")
# print(x)
# 实例3:如果只在位置 5 和位置 10 之间搜索，文本中最后出现的字母 "e" 在何处？
# txt = "Hello, welcome to my world."
# x = txt.rindex("e", 5, 10)
# print(x)
# 实例4:如果找不到该值，则 rfind() 方法返回 -1，但是 rindex() 方法将引发异常：
# txt = "Hello, welcome to my world."
# print(txt.rfind("q"))
# print(txt.rindex("q"))
# rjust() 返回字符串的右对齐版本。
# 定义和用法
# rjust() 方法将使用指定的字符（默认为空格）作为填充字符，将字符串右对齐。
# 语法: string.rjust(length, character)
# 参数值
# 参数 描述
# length 必需。所返回字符串的长度。
# character 可选。用于填充缺失空间（在字符串的左侧）字符。默认值为 " "（空格）。
# 实例1:返回单词 "banana" 的 20 个字符长的右对齐版本：
# txt = "banana"
# x = txt.rjust(20)
# print(x, "is my favorite fruit.")
# 实例2:使用字母 "O" 作为填充字符：
# txt = "banana"
# x = txt.rjust(20, "O")
# print(x)
# rpartition() 返回元组，其中字符串分为三部分。
# 定义和用法
# rpartition() 方法搜索指定字符串的最后一次出现，并将该字符串拆分为包含三个元素的元组。
# 第一个元素包含指定字符串之前的部分。
# 第二个元素包含指定的字符串。
# 第三个元素包含字符串之后的部分。
# 语法:string.rpartition(value)
# 参数值
# 参数 描述
# value 必需。要检索的字符串。
# 实例1:搜索单词 "bananas" 的最后一次出现，并返回包含三个元素的元组：
# 1 - “匹配”之前的所有内容 2 - “匹配” 3 - “匹配”之后的所有内容
# txt = "I could eat bananas all day, bananas are my favorite fruit"
# x = txt.rpartition("bananas")
# print(x)
# 实例2:如果找不到指定的值，则 rpartition() 方法将返回一个元组，其中包含：1 - 整个字符串，2 - 一个空字符串，3 - 一个空字符串：
# txt = "I could eat bananas all day, bananas are my favorite fruit"
# x = txt.rpartition("apples")
# print(x)
# rsplit() 在指定的分隔符处拆分字符串，并返回列表。
# 定义和用法
# rsplit() 方法从右侧开始将字符串拆分为列表。
# 如果未指定 "max"，则此方法将返回与 split() 方法相同的结果。
# 注释：若指定 max，列表将包含指定数量加一的元素。
# 语法: string.rsplit(separator, max)
# 参数值
# 参数 描述
# separator 可选。规定分割字符串时要使用的分隔符。默认值为空白。
# max 可选。指定要执行的拆分数。默认值为 -1，即“所有出现次数”。
# 实例1:使用后跟空格的逗号作为分隔符，将字符串拆分为列表：
# txt = "apple, banana, cherry"
# x = txt.rsplit(", ")
# print(x)
# 实例2:将字符串拆分为最多 2 个项目的列表：
# txt = "apple, banana, cherry" #将max 参数设置为 1，将返回包含 2 个元素的列表！
# x = txt.rsplit(", ", 1)
# print(x)
# rstrip() 返回字符串的右边修剪版本。
# 定义和用法
# rstrip() 方法删除所有结尾字符（字符串末尾的字符），空格是要删除的默认结尾字符。
# 语法: string.rstrip(characters)
# 参数值
# 参数 描述
# characters 可选。一组作为结尾字符要删除的字符。
# 实例1:删除字符串右边的空格：
# txt = " banana "
# x = txt.rstrip()
# print("of all fruits", x, "is my favorite")
# 实例2:删除结尾字符：
# txt = "banana,,,,,ssaaww....."
# x = txt.rstrip(",.asw")
# print(x)
# split() 在指定的分隔符处拆分字符串，并返回列表。
# 定义和用法
# split() 方法将字符串拆分为列表。
# 您可以指定分隔符，默认分隔符是任何空白字符。
# 注释：若指定 max，列表将包含指定数量加一的元素。
# 语法: string.split(separator, max)
# 参数值
# 参数 描述
# separator 可选。规定分割字符串时要使用的分隔符。默认值为空白字符。
# max 可选。规定要执行的拆分数。默认值为 -1，即“所有出现次数”。
# 实例1:将字符串拆分成一个列表，其中每个单词都是一个列表项：
# txt = "welcome to China"
# x = txt.split()
# print(x)
# 实例2:使用逗号后跟空格作为分隔符，分割字符串：
# txt = "hello, my name is Bill, I am 63 years old"
# x = txt.split(", ")
# print(x)
# 实例3:使用井号字符作为分隔符：
# txt = "apple#banana#cherry#orange"
# x = txt.split("#")
# print(x)
# 实例4:将字符串拆分为最多 2 个项目的列表：
# txt = "apple#banana#cherry#orange"
# x = txt.split("#", 1) # 将 max 参数设置为 1，将返回包含 2 个元素的列表！
# print(x)
# splitlines() 在换行符处拆分字符串并返回列表。
# 定义和用法
# splitlines() 方法将字符串拆分为列表。拆分在换行符处完成。
# 语法: string.splitlines(keeplinebreaks)
# 参数值
# 参数 描述
# keeplinebreaks 可选。规定是否应包含换行符（True）或不包含（False）。默认值不包含（False）。
# 实例1: 将字符串拆分为一个列表，其中每一行都是一个列表项：
# txt = "Thank you for your visiting\nWelcome to China"
# x = txt.splitlines()
# print(x)
# 实例2: 拆分字符串，但保留换行符：
# txt = "Thank you for your visiting\nWelcome to China"
# x = txt.splitlines(True)
# print(x)
# startswith() 如果以指定值开头的字符串，则返回 true。
# 定义和用法
# 如果字符串以指定的值开头，则 startswith() 方法返回 True，否则返回 False。
# 语法: string.startswith(value, start, end)
# 参数值
# 参数 描述
# value 必需。检查字符串是否以其开头的值。
# start 可选。整数，规定从哪个位置开始搜索。
# end 可选。整数，规定结束搜索的位置。
# 实例1:检查字符串是否以 "Hello" 开头：
# txt = "Hello, welcome to my world."
# x = txt.startswith("Hello")
# print(x)
# 实例2:检查位置 7 到 20 是否以字符 "wel" 开头：
# txt = "Hello, welcome to my world."
# x = txt.startswith("wel", 7, 20)
# print(x)
# strip() 返回字符串的剪裁版本。
# 定义和用法
# strip() 方法删除任何前导（开头的空格）和尾随（结尾的空格）字符（空格是要删除的默认前导字符）。
# 语法: string.strip(characters)
# 参数值
# 参数 描述
# characters 可选。一组字符，要删除的前导/尾随字符的字符。
# 实例1:删除字符串开头和结尾的空格：
# txt = " banana "
# x = txt.strip()
# print("of all fruits", x, "is my favorite")
# 实例2:删除前导和尾随字符：
# txt = ",,,,,rrttgg.....banana....rrr"
# x = txt.strip(",.grt")
# print(x)
# swapcase() 切换大小写，小写成为大写，反之亦然。
# 定义和用法
# swapcase() 方法返回一个字符串，其中所有大写字母均成为小写字母，反之亦然。
# 语法:string.swapcase()
# 参数值: 无参数.
# 实例1:将小写字母大写，大写字母小写：
# txt = "Hello My Name Is Elon"
# x = txt.swapcase()
# print(x)
# title() 把每个单词的首字符转换为大写。
# 定义和用法
# title() 方法返回一个字符串，其中每个单词的第一个字符均为大写。比如标题。
# 如果单词包含数字或符号，则其后的第一个字母将转换为大写字母。
# 语法: string.title()
# 参数值: 无参数.
# 实例1:将每个单词的首字母大写：
txt = "Welcome to my 2nd world"
x = txt.title()
print(x)
# 实例2: ，非字母字母之后的第一个字母将转换为大写字母
# txt = "hello d2d2d2 and 5g5g5g"
# x = txt.title()
# print(x)
# translate() 返回被转换的字符串。
# upper() 把字符串转换为大写。
# 定义和用法
# upper() 方法返回一个字符串，其中所有字符均大写。
# 符号和数字将被忽略。
# 语法: string.upper()
# 参数值: 无参数
# 实例1: 大写字符串：
# txt = "Hello my friends"
# x = txt.upper()
# print(x)
# zfill() 在字符串的开头填充指定数量的 0 值。
# 定义和用法
# zfill() 方法在字符串的开头添加零（0），直到达到指定的长度。
# 如果 len 参数的值小于字符串的长度，则不执行填充。
# 语法: string.zfill(len)
# 参数值
# 参数 描述
# len 必需。数字，规定要删除的元素的位置。
# 实例 1:用零填充字符串，直到它们长为 10 个字符：
# a = "hello"
# b = "welcome to my world"
# c = "10.000"
# print(a.zfill(10))
# print(b.zfill(10))
# print(c.zfill(10))
# 注释：所有字符串方法都返回新值。它们不会更改原始字符串。
