python基础总结（七）-字符串

# 创建时间：2023/6/11
# 创建目的：学习python
# coding:utf-8
"""
字符串:
    .在python中字符串是基本数据类型，是一个不可变的字符序列
    .字符串驻留机制：
     仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，python的驻留机制对相同的字符串只保留一份拷贝，
     后续创建相同字符串时，不会开辟新空间，而是把字符串的地址赋给新建的变量
     驻留机制的几种情况：
      .字符串的长度为0或1时
      .符合标识符的字符串
      .字符串只在编译时进行驻留，而非运行时
      .[-5，256]之间的整数
     .sys中的intern方法强制2个字符串指向同一个对象
    .字符串驻留机制的优缺点
     当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的
     在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比“+”效率高
    .创建字符串
        .使用 ’ ’ 或 " " 创建字符串
         创建字符串很简单，我们可以使用引号（’ ’ 或 " "）来创建字符串，只需为变量分配一个值即可。
        .使用 str()函数 转换为字符串
    .访问字符串:既可以使用下标索引访问字符串中的某个元素（得到是一个字符），也可以使用切片访问字符串中的一组元素（得到是子字符串）
        .下标索引访问
         下标索引访问字符串分为两大类，即正向索引和反向索引，格式为 str_name[i] ，其中，str_name 表示字符串名，i表示索引值，i可以是正数（正向索引）也可以是负数（反向索引）。
         str_name[0]表示字符串的第一个字符，str_name[-1]则表示字符串的最后一个字符
         正向索引：从第一个（下标0）开始、第二个（下标1）…
         反向索引：从倒数第一个（下标-1）、倒数第二个（下标-2）…
        . 切片访问
         使用切片访问字符串的格式为 str_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。
         截取字符串的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。
        .for循环遍历字符串
         使用 for 循环遍历字符串时，将会输出字符串中的每一个字符。
        .检查元素是否存在
         如果我们需要确定在一个字符串中，是否存在相同的字符或者子字符串，可以使用成员运算符中的 in 和 not in 关键字。
    .字符串基础知识:
        . 字符串更新
         我们可以截取字符串的一部分并与其他字段拼接
        .字符串连接(合并)/复制(重复)
         同列表和元组一样，字符串之间可以使用 + 号和 * 号分别实现字符串的连接（合并）和复制（重复），这意味着它们可以生成一个新的字符串。
        .转义字符
        . 格式字符串
         Python支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
        .f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。之前我们习惯用百分号 (%):
         f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去
    .内置函数
        .打印输出 print()
        .确定字符串长度 len()
        .返回变量类型 type()
        . 转换为字符串 str()
        .字符串最大/小字符 max()、min()
        .删除字符串 del
    .内置方法
        . 字符(串)转换 capitalize()、casefold()、lower()、upper()、title()、swapcase()
             capitalize() 将字符串的第一个字母变成大写，其他字母变小写。
            casefold() 方法返回一个字符串，其中所有字符均为小写。
                此方法与 lower() 方法相似，但是 casefold() 方法更强大，更具攻击性，这意味着它将更多字符转换为小写字母，并且在比较两个用 casefold() 方法转换的字符串时会找到更多匹配项。
            lower() 方法转换字符串中所有大写字符为小写（符号和数字将被忽略）
            upper() 方法将字符串中的小写字母转为大写字母（符号和数字将被忽略）。
            title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写。
            swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。
        .判断大小写 islower()、isupper()、istitle()
            islower() 方法检测字符串是否由小写字母组成。
                如果所有字符均为小写，则 islower() 方法返回 True，否则返回 False。不检查数字、符号和空格，仅检查字母字符。
            isupper() 方法检测字符串中所有的字母是否都为大写。
                如果所有字符均大写，则 isupper() 方法返回 True，否则返回 False。不检查数字、符号和空格，仅检查字母字符。
            istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
                如果文本中的所有单词均以大写字母开头，而单词的其余部分均为小写字母，则 istitle() 方法返回 True。否则返回 False。符号和数字将被忽略。
        .返回出现次数 count()
            count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
        .count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
            find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回 -1。
            index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 find() 方法一样，只不过如果str不在 string中会报一个异常。
            find() 方法与 index() 方法几乎相同，唯一的区别是，如果找不到该值，index() 方法将引发异常，则 find() 方法将返回 -1。
        . 从右搜索并返回 rfind()、rindex()
            rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1 。
            rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
            rfind() 和 rindex() 都是查找指定值的最后一次出现。如果找不到该值，则 rfind() 方法将返回 -1，而 rindex() 方法将引发异常。
        . 以 str 开头/结束 startswith()、endswith()
            startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
            如果字符串以指定的值开头，则 startswith() 方法返回 True，否则返回 False。
            endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 “start” 与 “end” 为检索字符串的开始与结束位置。
            如果字符串以指定值结尾，则 endswith() 方法返回 True，否则返回 False。
        .编/解码 encode()、decode()
            encode() 方法以指定的编码格式编码字符串，decode() 方法以指定的解码格式解码字符串。
                errors参数可以指定不同的错误处理方案。
        .填充对齐 center()、ljust()、rjust()、zfill()
            center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
            ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
            rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
            zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
                zfill() 方法在字符串的开头添加零（0），直到达到指定的长度。如果 len 参数的值小于字符串的长度，则不执行填充。
        . 删除左/右指定字符 lstrip()、rstrip()、strip()
            lstrip() 方法用于截掉字符串左边的空格或指定字符。
            rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。
            strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。
        . 判断字符(串)
            .空白字符 isspace()
                isspace() 方法检测字符串是否只由空白字符组成。
                如果字符串中的所有字符都是空格，则 isspace() 方法将返回 True，否则返回 False。
            .可打印 isprintable()
                isprintable() 方法检查文本中的所有字符是否可打印。
                如果所有字符都是可打印的，则 isprintable() 方法返回 True，否则返回 False。不可打印的字符可以是回车和换行符。
            .标识符 isidentifier()
                isidentifier() 方法检查字符串是否是有效标识符。
                如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。
                如果字符串仅包含字母数字字母（a-z）和（0-9）或下划线（_），则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格。
            .字母/数字 isalnum()
                isalnum() 方法检测字符串是否由字母和数字组成。
                如果所有字符均为字母数字，即字母（a-z）和数字（0-9），则 isalnum() 方法返回 True。
                非字母数字的例子：(space)!#%&? 等等。
            . 字母/中文 isalpha()
                isalpha() 方法检测字符串是否只由字母或文字组成。
                如果所有字符都是字母（a-z），则 isalpha() 方法将返回 True。
                非字母的字符例子：(space)!#%&? 等等。
            .数字 isdigit()、isnumeric()、isdecimal()
                isdigit() 方法检测字符串是否只由数字组成。
                    如果所有字符都是数字，则 isdigit() 方法将返回 True，否则返回 False。
                    指数（例如²）也被视作数字。
                isnumeric() 方法检测字符串是否只由数字组成，数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。
                    指数类似 ² 与分数类似 ½ 也属于数字。
                    如果所有字符均为数字（0-9），则 isumeric() 方法返回 True，否则返回 False。
                    指数（比如 ² 和 ¾）也被视为数字值。
                isdecimal() 方法检查 unicode 对象中的所有字符是否都是小数
                    如果所有字符均为小数（0-9），则 isdecimal() 方法将返回 True。
                    此方法用于 unicode 对象。
        .格式字符串中指定值 format()、format_map()
            format() 方法格式化指定的值，并将其插入字符串的占位符内，占位符使用大括号 {} 定义。
            format_map() 方法格式化字符串中的指定值。
        .拆分/截取字符串 split()、rsplit()、splitlines()
            split() 通过指定分隔符从左侧对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
                split() 方法将字符串拆分为列表。
                您可以指定分隔符，默认分隔符是任何空白字符。
                注释：**若指定 max，列表将包含指定数量加一的元素。
            rsplit() 通过指定分隔符从右侧对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
                rsplit() 方法从右侧开始将字符串拆分为列表。
                如果未指定 “max”，则此方法将返回与 split() 方法相同的结果。
                注释： 若指定 max，列表将包含指定数量加一的元素。
            splitlines() 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
        .拆分字符串(返回元组) partition()、rpartition()
            partition() 方法搜索指定的字符串，并将该字符串拆分为包含三个元素的元组。
            第一个元素包含指定字符串之前的部分，第二个元素包含指定的字符串，第三个元素包含字符串后面的部分。
            注释：此方法搜索指定字符串的第一个匹配项。
        .rpartition() 方法搜索指定字符串的最后一次出现，并将该字符串拆分为包含三个元素的元组。
            第一个元素包含指定字符串之前的部分，第二个元素包含指定的字符串，第三个元素包含字符串之后的部分。
        .字符串转换 maketrans()、translate()
            maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
            两个字符串的长度必须相同，为一一对应的关系。
            translate() 返回被转换的字符串。
        .元组项目连接到字符串 join()
            join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
        .字符串替换 replace()
            replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
        .字符串 Tab 转换 expandtabs()
            expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16…等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。

"""

# python驻留机制
a = "python"
b = 'python'
c = '''python'''
print(id(a))  # 2220403862448
print(id(b))  # 2220403862448
print(id(c))  # 2220403862448
# 字符串的长度为0或1时
s1 = ""
s2 = ""
print(s1 is s2)  # True
# 符合标识符的字符串
s3 = "abc%"
s4 = "abc%"
print(s3 == s4)  # True
print(s3 is s4)  # True   pycharm对字符串进行了优化处理才使得两者地址一样，在交互式界面上不一样为Flase
print(id(s3))  # 2158436769712
print(id(s4))  # 2158436769712
s1 = "abcx"
s2 = "abcx"
print(s1 == s2)  # True
print(s1 is s2)  # True
# 字符串只在编译时进行驻留，而非运行时
a = "abc"
b = "ab" + "c"
c = "".join(["ab", "c"])
print(a is b)  # True
print(a is c)  # False
print(c)  # abc
print(type(c))  # <class 'str'>
a = -5
b = -5
print(a == b)  # True
print(a is b)  # True
a = -7
b = -7
print(a is b)  # pycharm对字符串进行了优化处理才使得两者地址一样，在交互式界面上不一样为Flase
# sys中的intern方法强制2个字符串指向同一个对象
import sys

a = "abc%"
c = "abc%"
print(a is c)  # 交互式False
a = sys.intern(c)
print(a is c)  # Ture

# 使用 ’ ’ 或 " " 创建字符串
str1 = 'Hello Python'
str2 = "hello python"

# 下标索引访问
str1 = 'Hello Py'
print(str1[0])  # H
print(str1[-1])  # y

# 切片访问
str1 = 'Hello Py'
print(str1[0:5])
print(str1[-8:-1])
print(str1[:])
print(str1[::2])
"""
Hello
Hello P
Hello Py
HloP
截取字符串的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。
"""

# for循环遍历字符串
str_h = 'Hi Py'
for char in str_h:
    print(char)
"""
H
i
 
P
y
"""

# 检查元素是否存在
str1 = 'Hello Python'
print('H' in str1)  # Ture
print('Python' not in str1)  # False

# 字符串更新
str1 = 'Hello World'
print(str1[:6] + 'Python')  # Hello Python

# +连接（合并）
a = 'Hello'
b = 'Python'
print(a + b)  # HelloPython

# *复制（重复）
c = 'Hello'
print(c * 5)  # HelloHelloHelloHelloHello

# 打印原始字符 r / R
# 原始字符串：所有的字符串都是直 接按照字面的意思来使用，没有转义特殊或不能打印的字符。
# 原始字符串除在字符串的第一个引号前加上字母 r / R （可以大小写）以外，与普通字符串有着几乎完全相同的语法。
print(r'\n')  # \n
print(R'\n')  # \n
print(r'\t')  # \t
print(r'\a')  # \a

# 格式字符串
print('我叫 %s ,今年 %d 岁！' % ('pink', 21))  # 我叫 pink ,今年 21 岁！

# f-string
# f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去
name = 'pink'
print(f'Hello {name}')  # Hello pink

print(f'{1 + 2}')  # 3

baidu = {'name': 'Baidu', 'url': 'https://www.baidu.com'}
print(f'{baidu["name"]}:{baidu["url"]}')  # Baidu:https://www.baidu.com

# 使用 = 符号来拼接运算表达式与结果
x = 1
print(f'{x + 1}')  # 2

y = 1
print(f'{x + 1 = }')  # x + 1 = 2

# capitalize() 将字符串的第一个字母变成大写，其他字母变小写
str1 = 'hello python'
print(str1.capitalize())  # Hello python

# casefold() 方法返回一个字符串，其中所有字符均为小写。
str1 = 'Hello Python'
print(str1.casefold())  # hello python
# 此方法与 lower() 方法相似，但是 casefold() 方法更强大，更具攻击性，这意味着它将更多字符转换为小写字母，并且在比较两个用 casefold() 方法转换的字符串时会找到更多匹配项。

# lower() 方法转换字符串中所有大写字符为小写（符号和数字将被忽略）。
str1 = 'Hello Python'
print(str1.lower())  # hello python

# upper() 方法将字符串中的小写字母转为大写字母（符号和数字将被忽略）
str1 = 'Hello Python'
print(str1.upper())  # HELLO PYTHON

# title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写
str1 = 'HELLO Python'
print(str1.title())  # Hello Python

# swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。
str1 = 'Hello Python'
print(str1.swapcase())  # hELLO pYTHON

# islower() 方法检测字符串是否由小写字母组成。
str1 = 'Hello Python'
print(str1.islower())  # False
# 如果所有字符均为小写，则 islower() 方法返回 True，否则返回 False。不检查数字、符号和空格，仅检查字母字符。

# 如果所有字符均为小写，则 islower() 方法返回 True，否则返回 False。不检查数字、符号和空格，仅检查字母字符。
str1 = 'Hello Python'
print(str1.isupper())  # False
# 如果所有字符均大写，则 isupper() 方法返回 True，否则返回 False。不检查数字、符号和空格，仅检查字母字符。

# istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
str1 = 'Hello Python'
print(str1.istitle())  # True
# 如果文本中的所有单词均以大写字母开头，而单词的其余部分均为小写字母，则 istitle() 方法返回 True。否则返回 False。符号和数字将被忽略。

# count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
txt = "I love apples, apple are my favorite fruit"
print(txt.count("apple", 10, 24))  # 1

# find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回 -1。
txt = "Hello, welcome to my world."
x = txt.find("e")
print(x)  # 1
# 如果找不到该值，则 find() 方法返回 -1，但是 index() 方法将引发异常：

# index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 find() 方法一样，只不过如果str不在 string中会报一个异常
txt = "Hello, welcome to my world."
x = txt.index("e")
print(x)  # 1
# find() 方法与 index() 方法几乎相同，唯一的区别是，如果找不到该值，index() 方法将引发异常，则 find() 方法将返回 -1。

# rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1
txt = "Hello, welcome to my world."
x = txt.rfind("e")
print(x)  # 13
# 如果找不到该值，则 rfind() 方法返回 -1，但是 rindex() 方法将引发异常

# rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间
txt = "Hello, welcome to my world."
x = txt.rindex("e")
print(x)  # 13
# 如果找不到该值，则 rfind() 方法返回 -1，但是 rindex() 方法将引发异常
# rfind() 和 rindex() 都是查找指定值的最后一次出现。如果找不到该值，则 rfind() 方法将返回 -1，而 rindex() 方法将引发异常。

# startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
txt = "Hello, welcome to my world."
x = txt.startswith("wel", 7, 20)
print(x)  # True
# 如果字符串以指定的值开头，则 startswith() 方法返回 True，否则返回 False

# endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False。可选参数 “start” 与 “end” 为检索字符串的开始与结束位置。
txt = "Hello, welcome to my world."
x = txt.endswith("my world.")
print(x)  # False
# 如果字符串以指定值结尾，则 endswith() 方法返回 True，否则返回 False。

# encode() 方法以指定的编码格式编码字符串，decode() 方法以指定的解码格式解码字符串。
# errors参数可以指定不同的错误处理方案。
str = 'pink老师'

str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")

print("UTF-8 编码：", str_utf8)
print("GBK 编码：", str_gbk)

print("UTF-8 解码：", str_utf8.decode('UTF-8', 'strict'))
print("GBK 解码：", str_gbk.decode('GBK', 'strict'))
"""
UTF-8 编码： b'pink\xe8\x80\x81\xe5\xb8\x88'
GBK 编码： b'pink\xc0\xcf\xca\xa6'
UTF-8 解码： pink老师
GBK 解码： pink老师
"""

# center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
txt = "banana"
x = txt.center(20, "O")
print(x)  # OOOOOOObananaOOOOOOO

# ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
txt = "banana"
x = txt.ljust(20, "O")
print(x)  # bananaOOOOOOOOOOOOOO

# rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
txt = "banana"
x = txt.rjust(20, "O")
print(x)  # OOOOOOOOOOOOOObanana

# zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
a = "hello"
b = "welcome to my world"
c = "10.000"

print(a.zfill(10))  # 00000hello
print(b.zfill(10))  # welcome to my world
print(c.zfill(10))  # 000010.000

# lstrip() 方法用于截掉字符串左边的空格或指定字符。
txt = ",,,,,ssaaww.....banana"
x = txt.lstrip(",.asw")
print(x)  # string.rstrip(characters)

# rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。
txt = "banana,,,,,ssaaww....."
x = txt.rstrip(",.asw")
print(x)  # banan

# strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。
txt = ",,,,,rrttgg.....banana....rrr"
x = txt.strip(",.grt")
print(x)  # banana

# isspace() 方法检测字符串是否只由空白字符组成。
txt = "   s   "
x = txt.isspace()
print(x)  # False
# 如果字符串中的所有字符都是空格，则 isspace() 方法将返回 True，否则返回 False。

# isprintable() 方法检查文本中的所有字符是否可打印。
txt = "Hello!\nAre you #1?"
x = txt.isprintable()
print(x)  # False
# 如果所有字符都是可打印的，则 isprintable() 方法返回 True，否则返回 False。不可打印的字符可以是回车和换行符。

# isidentifier() 方法检查字符串是否是有效标识符。
a = "MyFolder"
b = "Demo002"
c = "2bring"
d = "my demo"

print(a.isidentifier())
print(b.isidentifier())
print(c.isidentifier())
print(d.isidentifier())
"""
True
True
False
False
如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。
如果字符串仅包含字母数字字母（a-z）和（0-9）或下划线（_），则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格。
"""

# isalnum() 方法检测字符串是否由字母和数字组成。
txt = "Company 12"
x = txt.isalnum()
print(x)  # False
# 如果所有字符均为字母数字，即字母（a-z）和数字（0-9），则 isalnum() 方法返回 True。
# 非字母数字的例子：(space)!#%&? 等等。

# isalpha() 方法检测字符串是否只由字母或文字组成。
txt = "Company10"
x = txt.isalpha()
print(x)  # False
# 如果所有字符都是字母（a-z），则 isalpha() 方法将返回 True。
# 非字母的字符例子：(space)!#%&? 等等。

# isdigit() 方法检测字符串是否只由数字组成。
a = "\u0030"  # unicode for 0
b = "\u00B2"  # unicode for ²

print(a.isdigit())  # True
print(b.isdigit())  # True
# 如果所有字符都是数字，则 isdigit() 方法将返回 True，否则返回 False。
# 指数（例如²）也被视作数字。

# isnumeric() 方法检测字符串是否只由数字组成，数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。
# 指数类似 ² 与分数类似 ½ 也属于数字。
a = "\u0030"  # unicode for 0
b = "\u00B2"  # unicode for ²
c = "10km2"

print(a.isnumeric())  # True
print(b.isnumeric())  # True
print(c.isnumeric())  # False
# 如果所有字符均为数字（0-9），则 isumeric() 方法返回 True，否则返回 False。
# 指数（比如 ² 和 ¾）也被视为数字值。

# isdecimal() 方法检查 unicode 对象中的所有字符是否都是小数。
a = "\u0030"  # unicode for 0
b = "\u0047"  # unicode for G

print(a.isdecimal())  # True
print(b.isdecimal())  # False
# 如果所有字符均为小数（0-9），则 isdecimal() 方法将返回 True。
# 此方法用于 unicode 对象。

# format() 方法格式化指定的值，并将其插入字符串的占位符内，占位符使用大括号 {} 定义。
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)
print(txt1)
print(txt2)
print(txt3)
"""
My name is Bill, I'am 64
My name is Bill, I'am 64
My name is Bill, I'am 64
"""

# format_map() 方法格式化字符串中的指定值。
str_a = '我是 {name} 老师 {gender} {age} 岁'
dict_1 = {'name': 'pink', 'gender': '男', 'age': 21}
print(str_a.format_map(dict_1))  # 我是 pink 老师 男 21 岁

# split() 通过指定分隔符从左侧对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
txt = "hello, my name is Bill, I am 63 years old"
x = txt.split(", ")
print(x)  # ['hello', 'my name is Bill', 'I am 63 years old']

# rsplit() 通过指定分隔符从右侧对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
txt = "apple, banana, cherry"
# 将 max 参数设置为 1，将返回包含 2 个元素的列表！
x = txt.rsplit(", ", 1)
print(x)  # ['apple, banana', 'cherry']
# rsplit() 方法从右侧开始将字符串拆分为列表。
# 如果未指定 “max”，则此方法将返回与 split() 方法相同的结果。
# 注释： 若指定 max，列表将包含指定数量加一的元素。

# splitlines() 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
txt = "Thank you for your visiting\nWelcome to China"
x = txt.splitlines(True)
print(x)  # ['Thank you for your visiting\n', 'Welcome to China']

# partition() 方法搜索指定的字符串，并将该字符串拆分为包含三个元素的元组。
# 第一个元素包含指定字符串之前的部分，第二个元素包含指定的字符串，第三个元素包含字符串后面的部分。
# 注释：此方法搜索指定字符串的第一个匹配项。
txt = "I could eat bananas all day"
x = txt.partition("bananas")
print(x)  # ('I could eat ', 'bananas', ' all day')
# 如果找不到指定的值，则 partition() 方法将返回一个元组，其中包含：1 - 整个字符串，2 - 空字符串，3 - 空字符串：
txt = "I could eat bananas all day"
x = txt.partition("apples")
print(x)  # ('I could eat bananas all day', '', '')

# rpartition() 方法搜索指定字符串的最后一次出现，并将该字符串拆分为包含三个元素的元组。
# 第一个元素包含指定字符串之前的部分，第二个元素包含指定的字符串，第三个元素包含字符串之后的部分
txt = "I could eat bananas all day, bananas are my favorite fruit"
x = txt.rpartition("bananas")
print(x)  # ('I could eat bananas all day, ', 'bananas', ' are my favorite fruit')

# aketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
# 两个字符串的长度必须相同，为一一对应的关系。

# translate() 返回被转换的字符串。
txt = "www.Baidu.com"
url = txt.maketrans('B', 'b')
print(txt.translate(url))  # www.baidu.com

# 使用字符串设置要替换的字符，一一对应
x = "aeiou"
y = "12345"
trans = str.maketrans(x, y)

str1 = "this is a string"
print(str1.translate(trans))  # th3s 3s 1 str3ng

# 设置要删除的字符参数：
txt = "baidu z alibaba  Z tencent"
x = "bat"
y = "BAT"
z = "zZ"  # 设置删除的字符
trans = txt.maketrans(x, y, z)
print(txt.translate(trans))  # BAidu  AliBABA   TencenT
print(trans)  # {98: 66, 97: 65, 116: 84, 122: None, 90: None

# join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
tuple_1 = ("baidu", "alibaba", "tencent")
x = "#".join(tuple_1)
print(x)  # baidu#alibaba#tencent

# replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
txt = "I like bananas"
x = txt.replace("bananas", "apples")
print(x)  # I like apples

# expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16…等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
txt = "H\te\tl\tl\to"
x = txt.expandtabs(2)
print(x)  # H e l l o