字符串内置函数

字符串内置函数
#***********总体实例********************
# 方法             描述
# 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	e	l	l	o"
# x =  txt.expandtabs(2)
# print(x)

# 实例2 :看看不同制表符大小的结果：
# txt = "H	e	l	l	o"
# 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!
Are 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
Welcome to China"
# x = txt.splitlines()
# print(x)

# 实例2: 拆分字符串，但保留换行符：
# txt = "Thank you for your visiting
Welcome 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))


# 注释：所有字符串方法都返回新值。它们不会更改原始字符串。