字符串的驻留机制
字符串是Python的基本数据类型，是一个不可变的字符序列
什么叫字符串的驻留机制？——仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。
字符串可以用单引号’’ 双引号"" 三引号’’’ ‘’’ 定义
# 字符串的驻留机制
a = 'Python'
b = 'Python'
c = 'Python'
print(a, id(a)) # Python 2398872123696
print(b, id(b)) # Python 2398872123696
print(c, id(c)) # Python 2398872123696
# a, b, c, 的 id 相同，说明字符串'Python'在内存中只有一份驻留机制的几种情况（交互模式）：
①字符串的长度为0或1时
②符合标识符的字符串
③字符串只在编译时进行驻留，而非运行时
④[-5,256]之间的数字
sys中的intern方法可以强制2个字符串指向同一个对象
Pycharm对字符串进行了优化处理
字符串驻留机制的优缺点
当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。
在需要进行字符串拼接时，建议使用哪个str类型的join方法，而非 + ，因为jion()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比 + 效率高。
字符串的查询操作的方法
index() 查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError
rindex() 查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
find() 查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1
rfind() 查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1
# 字符串的查询操作
s = 'hello,hello'
print(s.index('lo')) # 3
print(s.rindex('lo')) # 9
print(s.find('lo')) # 3 建议使用，因为不会抛出异常
print(s.rfind('lo')) # 9 建议使用，因为不会抛出异常字符串的大小写转换操作的方法
upper() 把字符串中所有字符都转成大写字母
lower() 把字符串中所有字符都转成小写字母
swapcase() 把字符串中所有大写字母都转成小写字母，把所有小写字母都转成大写字母
capitalize() 把第一个字符转换为大写，把其余字符转换为小写
title() 把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写
# 字符串中的大小写转换，因为字符串是不可变序列，所以转换会产生新的字符串对象
s = 'hello,python'
print(s, id(s)) # hello,python 2680843843888
a = s.upper()
print(a, id(a)) # HELLO,PYTHON 2680839491056
b = s.lower()
print(b, id(b))
print(s == b) # True
print(s is b) # False字符串内容对齐操作的方法
center() 居中对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串。
ljust() 左对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串。
rjust() 右对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串。
zfill() 右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于原字符串的宽度，返回字符串本身
# 字符串内容对齐操作的方法
# 字符串内容对齐操作的方法
s = 'hello,Python'
print(s.center(20, '*')) # ****hello,Python****
print(s.ljust(20, '*')) # hello,Python********
print(s.rjust(20, '*')) # ********hello,Python
print(s.zfill(20)) # 00000000hello,Python
# 注意：
print('-1234'.zfill(20)) # -0000000000000001234 0填充在负号的右边字符串劈分操作的方法
split() 从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值是一个列表；以通过参数sep指定劈分字符串时的劈分符；通过参数maxsplit指定劈分字符串时的的最大劈分次数，在经过最大劈分次数之后，剩余的子串会单独作为一部分。
rsplit() 从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表；以通过参数sep指定劈分字符串时的劈分符；通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大劈分次数之后，剩余的子串会单独作为一部分
# 字符串劈分操作的方法
# split()从左侧开始劈分
s = 'hello world Python'
lst = s.split() # 没有指定劈分符，默认为空格
print(lst) # ['hello', 'world', 'Python']
s1 = 'hello|world|python'
print(s1.split(sep = '|')) # ['hello', 'world', 'python'] 指定劈分符为|
print(s1.split(sep = '|', maxsplit = 1)) # ['hello', 'world|python'] 劈分次数为1
# rsplit()从右侧开始劈分
print(s.rsplit()) # ['hello', 'world', 'Python']
print(s1.rsplit(sep = '|', maxsplit = 1)) # ['hello|world', 'python']判断字符串的方法
isidentifier() 判断指定的字符串是不是合法的标识符
isspace() 判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）
isalpha() 判断指定的字符串是否全部由字母组成
isdecimal() 判断指定字符串是否全部由十进制的数字组成
isnumeric() 判断指定的字符串是否全部由数字组成
isalnum() 判断指定字符串是否全部由字母和数字组成
# 判断字符串的方法
s = 'hello,python'
print(s.isidentifier()) # False 合法的标识符是字母、数字、下划线
# 但是应注意：
print('张三_'.isidentifier()) # True 这里结果为True的原因有待研究
print('\t'.isspace()) # True
print('hello'.isalpha()) # True
print('张三'.isalpha()) # True
print('张三123'.isnumeric()) # False
print('张三123'.isalnum()) # True字符串的替换与合并
字符串替换
replace() 第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第3个参数指定最大替换次数
字符串的合并
jion() 将列表或元组中的字符串合并成一个字符串
# 字符串的替换
s = 'hello,Python'
print(s.replace('Python', 'Java')) # hello,Java
s1 = 'hello,Python,Python,Python'
print(s1.replace('Python', 'java', 2)) # hello,java,java,Python
# 字符串的合并，注意join()是将 列表 或 元组 中的字符串合并成一个字符串
lst = ['hello', 'Java', 'Python']
print('|'.join(lst)) # hello|Java|Python
print(''.join(lst)) # helloJavaPython
t = ('hello', 'Java', 'Python')
print(''.join(t)) # helloJavaPython
# 注意：
print('*'.join('Python')) # P*y*t*h*o*n字符串的比较
运算符：>，>=，<，<=，==，!=
比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较。
比较原理：两个字符进行比较时，比较的是其ordinal value（序数值），调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value可以得到其对应的字符。
# 字符串的比较
print('apple' > 'app') # True
print('apple' > 'banana') # False
print(ord('a'), ord('b')) # 97 98
print(chr(97), chr(98)) # a b
# 注意：== 与 is 的区别，== 比较的是value。 is 比较的是id是否相等
a = b = 'Python'
c = 'Python'
print(a == b) # True
print(b == c) # True字符串的切片操作
注意：字符串是不可变类型，不具备增、删、改等操作，切片操作将产生新的对象
# 字符串的切片操作
s = 'hello,Python'
s1 = s[:5] # 由于没有指定起始起始位置，所以从0开始
print(s1) # hello
s2 = s[6:] # 由于没有指定结束位置，所以切到字符串的最后一个元素
print(s2)
# 字符串的链接
print(s1 + '!' + s2) # hello!Python
# 切片的完整格式 切片[start : end : step],step缺省时，步长为1
print(s[1:5:1]) # ello
print(s[1:6:2]) # el,
print(s[::-1]) # nohtyP,olleh 将字符串倒置
print(s[-6::1]) # Python格式化字符串
格式化字符串的三种方式
① %做占位符，%s表示字符串，%i或%d表示整数，%f表示浮点数
②{}做占位符
③f-string
# 格式化字符串
name = 'liu'
age = 23
# 1. % 做占位符
print('我的名字叫：%s，今年%d岁了。' % (name, age)) # 我的名字叫：liu，今年23岁了。
# 2. {} 做占位符
print('我叫{0}，今年{1}岁了。'.format(name, age)) # 我叫liu，今年23岁了。
# 3. f-string
print(f'我叫{name}，今年{age}岁。') # 我叫liu，今年23岁。格式化字符串时的宽度与精度
# 宽度
print('%10d' % 99) # 99 总宽度为10
# 精度
print('%.3f' % 3.1415926) # 3.142 保留三位小数
# 同时表示宽度和精度
print('%10.3f' % 3.1415926) # 3.142
print('{0}'.format(3.1415926)) # 3.1415926 花括号中的0表示占位符的顺序
print('{0:10.3}'.format(3.1415926)) # 3.14 10.3表示总宽度为10，保留三位有效数字数字
print('{0:10.3}'.format(0.12345)) # 0.123
print('{0:10.3f}'.format(3.1415926)) # 3.142 10.3f表示总宽度为10，保留三位小数字符串的编码转换
为什么需要字符串的编码转换：略略略
编码与解码的方式：
编码：将字符串转换为二进制数据（bytes）
解码：将bytes类型的数据转换成字符串类型
# 编码
s = '天涯共此时'
print(s.encode(encoding = 'GBK')) # b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
# 上行语句输出中的 b 表示二进制，在GBK这种编码格式中，一个中文占两个字节
print(s.encode(encoding = 'UTF-8')) # b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'
# 在UTF-8这种编码格式中，一个中文占三个字节
# 解码
byte = b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
print(byte.decode(encoding = 'GBK')) # 天涯共此时
# 用什么格式编码就要用什么格式解码
