75.字符串的创建与驻留机制
字符串
- 在Python中字符串是基本数据类型，是一个不可变的字符序列
- 什么叫字符串驻留机制呢？
- 仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量
#实例
a='Python'
b="Python"
c='''Python'''
print(a,id(a)) #输出变量a，查看id地址
print(b,id(b))
print(c,id(c))
驻留机制的几种情况（交互模式）
- 字符串的长度为0或1时
- 符合标识符的字符串
- 字符串只在编译时进行驻留，而非运行时
- [-5，256]之间的整数数字
sys中的intern方法强制2个字符串指向同一个对象
- PyCharm对字符串进行了优化处理
打开Python交互式进行测试
- 字符串的长度为0或1时
符合标识符的字符串
- 下面这个就是符合标识符的字符串了，可以看到id内存地址均为3424
- 下面这个就是符合标识符的字符串了，可以看到id内存地址均为3424
字符串只在编译时进行驻留，而非运行时
- python是一种解释型语言，但实际上它的解释器也可以理解成编译器，它负责将python代码编译成字节码，也就是.pyc文件，
[-5，256]之间的整数数字
字符串驻留机制的优缺点
- 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。
在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join（）方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高
76.字符串的常用操作_字符串的查询操作
- 可以把字符串看成是字符的列表，所以字符串与列表查的操作是非常相似的，但区别就在于，当获得字符串中指定的索引时，除了有Index外，还有rindex、find以及rfind方法，
#实例
s='hello,hello'
print(s.index('lo')) #运行结果3
print(s.find('lo')) #运行结果3
print(s.rindex('lo')) #运行结果9
print(s.rfind('lo')) #运行结果9
#实例
#print(s.index('k')) #运行结果为ValueError: substring not found 译文：子串没找到
print(s.find('k')) #运行结果为-1 -->-->查找最后一次出现的位置，不存在返回-1；建议用不抛异常这种方法
#print(s.rindex('k')) #运行结果为SyntaxError: unexpected EOF while parsing 译文：解析时出现意外
print(s.rfind('k')) #运行结果为-1 -->查找最后一次出现的位置，不存在返回-177.字符串的常用操作_字符串的大小写转换操作方法
#实例
print('---字符串中的大小写转换的方法---')
s='hello,python'
a=s.upper() #转大写后会产生一个新的字符串对象(通俗讲就是会添加一个内存空间，内存地址会变)
print(a,id(a)) #转换后；运行结果为HELLO,PYTHON 2969352950256
print(s,id(s)) #转换前；运行结果为hello,python 2969352985584
b=s.lower() #转换后会产生一个新的字符串对象
print(b,id(b)) #运行结果为hello,python 1939784160688
print(s,id(s)) #运行结果为hello,python 1939783867376
print(b==s) #内容相同
print(b is a) #运行结果为false，也就是说内容是相同的，内存地址不同，没有字符串驻留机制
#print(s.lower(),id(s.lower()))
#print(s,id(s))
s2='hello,Python'
print(s2.swapcase()) #运行结果为HELLO,pYTHON -->小写转大写，大写转小写
print(s2.title()) #运行结果为Hello,Python -->每个单词首字母都转大写，其它都转小写
78.字符串的常用操作_字符串内容对齐操作的方法
#实例（很像文档中的左对齐、居中对齐、右对齐）
s='hello.Python' #声明一个变量
print('---居中对齐.center()---')
print(s.center(20,'*')) #运行结果为****hello.Python**** -->设置s变量的字符串为居中20个字符，hello,Python为12个字符，20-12=8因此指定星号*为两侧填充内容
print('---左对齐.ljust()---')
print(s.ljust(20,'*')) #
print(s.ljust(10)) #运行结果为hello.Python -->设置参数小于字符串字符长度且不指定第二个参数，将返回原字符
print(s.ljust(20)) #运行结果为hello.Python -->不指定第二个参数，输出结果后面是相应的空格
print('---右对齐.rjust()---')
print(s.rjust(20,'*')) #运行结果为********hello.Python
print(s.rjust(20)) #运行结果为 hello.Python
print(s.rjust(10)) #运行结果为hello.Python
print('---右对齐.zfill() 使用0进行填充---')
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))
#运行结果
---居中对齐.center()---
****hello.Python****
---左对齐.ljust()---
hello.Python********
hello.Python
hello.Python
---右对齐.rjust()---
********hello.Python
hello.Python
hello.Python
---右对齐.zjust() 使用0进行填充---
00000000hello.Python
hello.Python
-0008910
79.字符串的常用操作_字符串的劈分
#实例
print('---split()--从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表---')
s='hello world Python'
lst=s.split()
print(lst)
print('---split()--通过参数sep指定劈分字符串是的劈分符---')
s1='hello|world|Python'
print(s1.split(sep='|'))
print('---split()--通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分---')
print(s1.split(sep='|',maxsplit=1))
print('---rsplit()--从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表---')
print(s.rsplit())
print('---rsplit()--以通过参数sep指定劈分字符串是的劈分符---')
print(s1.rsplit('|')) #可以指定分隔符
print('---rsplit()--通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分---')
print(s1.rsplit(sep='|',maxsplit=1)) #从右边指定分割次数为1
#运行结果
---split()--从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表---
['hello', 'world', 'Python']
---split()--通过参数sep指定劈分字符串是的劈分符---
['hello', 'world', 'Python']
---split()--通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分---
['hello', 'world|Python']
---rsplit()--从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表---
['hello', 'world', 'Python']
---rsplit()--以通过参数sep指定劈分字符串是的劈分符---
['hello', 'world', 'Python']
---rsplit()--通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分---
['hello|world', 'Python']80.字符串的常用操作_字符串判断的相关方法
#字符串遍历补充
print('---直接遍历---')
source='appke,tiger,banana'
for sh in source:
print(sh)
print('---下标遍历---')
for index,sh in enumerate(source):
print(index,end='')
print(sh)
print('---range遍历---')
for index in range(len(source)):
print(index)
print('---迭代器---')
for sh in iter(source):
print(sh)
#实例
'''判断指定的字符串是不是合法的标识符'''
s='hello,python'
print('1',s.isidentifier()) #运行结果为false
print('2','hello'.isidentifier()) #运行结果为true
print('3','张三_'.isidentifier()) #运行结果为true
print('4','张三_123'.isidentifier()) #运行结果为true
'''判断指定的字符串是否全部由空白字符组成（回车、换行，水平制表符）'''
print('5','\t'.isspace()) #运行结果为true
'''判断指定的字符串是否全部由字母组成'''
print('6','abc'.isalpha()) #运行结果true
print('7','张三'.isalpha()) #运行结果为true
print('8','张三1'.isalpha()) #运行结果为false
'''判断指定字符串是否全部由十进制的数字组成'''
print('9','123'.isdecimal()) #运行结果为true
print('10','123四'.isdecimal()) #运行结果为false
print('11','ⅡⅡⅡ'.isdecimal()) #运行结果为false
'''判断指定的字符串是否全部由数字组成'''
print('12','123'.isnumeric()) #运行结果为true
print('13','123四'.isnumeric()) #运行结果为true
print('14','ⅡⅡⅡ'.isnumeric()) #运行结果为true -->验证罗马数字也是数字
'''判断指定字符串是否全部由字母和数字组成'''
print('15','abc1'.isalnum()) #运行结果为true
print('16','张三123'.isalnum()) #运行结果为true
print('17','abc!'.isalnum()) #运行结果为false81.字符串的常用操作_替换与合并
#实例
print('---.replace()字符串替换__两个参数---')
s='hello,Python'
print(s.replace('Python','Java'))
print('---.replace()字符串替换__三个参数---')
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2))
print('---.join()字符串合并---')
lst=['hello','java','Python']
print('|'.join(lst))
print(''.join(lst)) #为空会把三个单词连在一起组成新字符串
print('*'.join('Python')) #会把Python当作字符串序列进行连接
#运行结果
---.replace()字符串替换__两个参数---
hello,Java
---.replace()字符串替换__三个参数---
hello,Java,Java,Python
---.join()字符串合并---
hello|java|Python
hellojavaPython
P*y*t*h*o*n82.字符串的比较操作
字符串的比较操作
- 运算符：>，>=，<，<=，==，！=
- 比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
- 比较原理：两上字符进行比较时，比较的是其ordinal value（原始值），调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value可以得到其对应的字符
#实例
print('apple'>'app') #true
print('apple'>'banana') #false -->相当于97>98吗？当然不大于所以为false
print(ord('a'),ord('b'))
print(ord('杨')) #26472 -->看下的原始值是多少
print(chr(97),chr(98)) #a b -->能输出a和b说明它们互为相反的操作
print(chr(26472)) #杨 -->26472原始值会得到对应字符码？输出结果为杨，答案是会
'''==与is的区别 ==比较的是value值 is比较的是id内存是否相等'''
a=b='Python'
c='Python'
print(a==b) #True
print(a==c) #True
print(a is b) #True
print(a is c) #True
print(id(a)) #3004608322480
print(id(b)) #3004608322480
print(id(c)) #3004608322480 -->abc内存都一直的原因是，字符串常量内存驻留机制，有相同的内容会指向同一个id内存空间83.字符串的切片操作
字符串是不可变类型
- 不具备增、删、改等操作
- 切片操作将产生新的对象
#s[:5] -->不指定起始位置切到索引为5的位置实际切到4
#s[6:] -->不指定结束位置从索引为6的位置一直切到最后，而切出的字符串将从0重新开始表示
#s1+!+s2 --> +号是连接符，因此s1+!+s2几十将hello加上！加上Python组成新字符串，而索引从0重新开始标识
#实例
s='hello,Python'
s1=s[:5] #由于没有指定起始位置，所以从0开始切到索引为4的元素
s2=s[6:] #由于没有指定结束位置，所以切到字符串最后一个元素
s3='!' #将叹号赋值给s3
new_str=s1+s3+s2 #将切出来的两个字符串s1和s2与s3叹号通过连接符+连接，赋值给new_str
print(s1)
print(s2)
print(new_str)
print('---验证id内存地址是否相同---')
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(new_str)) #答案是不相同的，由此可见每一次切出来的都是一个新的字符串
print('---切片[start:end:step] 完整的写法---')
print(s[1:5:1]) #从1开始截到5（不包含5），步长为1
print(s[::2]) #默认从0开始，没有写结束，默认到字符串最后一个元素，步长为2，两个元素之间的索引间隔为2
print(s[::-1]) #默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数
print(s[-6::1]) #从索引为-6开始，到字符串最后一个元素结束，步长为1
#运行结果
hello
Python
hello!Python
---验证id内存地址是否相同---
3091268033584
3091270854256
3091270918576
3091263557744
3091270920432
---切片[start:end:step] 完整的写法---
ello
hloPto
nohtyP,olleh
84.格式化字符串
解析：字符串的拼接操作会产生很多新的字符串会造成空间的浪费，所以这时候就需要使用格式化字符串就可以了（按一定格式输出的字符串）。
#我的名字叫：{0}，今年{1}岁了，我真的叫：{0}'.format（name，age）解析
#所有format(name)都会用0去替换
#实例
'''格式化字符串常用基本用法'''
print('---格式化字符串一：%作占位符---')
name='某酷'
age=20
print('我叫%s,今年%d岁' % (name,age)) #固定符号百分号 name和age是一个元组（此时name就会添加到%s位置，age就会添加到%d位置）
print('---格式化字符串二：{}作占位符---')
print('我叫{0},今年{1}岁'.format(name,age))
print('---格式化字符串三：f-string---')
print(f'我叫{name},今年{age}岁') #这种写法前面加个f就代表”格式化字符串“
#除了这三种，还有一些表示宽度和精度怎么使用
print('---表示宽度d---')
print('%d' % 99)
print('%10d' % 99) #在%d中间加上值，表示宽度，10个宽度就代表10个字符的宽度
print('hellohello')
print('---表示精度f---')
print('%f' % 3.1415926)
print('%.3f' % 3.1415926) #如想保留三位小数，在%f中间加上.3即可
print('---同时表示宽度和精度---')
print('%10.3f' % 3.1415926) #一共总宽度为10字符，小数点后三位；在%f中间加上10.3即可
print('---不使用%，使用{}也可以实现---')
print('{0}'.format(3.1415926)) #花括号{}内索引不写也可以，但建议在花括号{}多的情况下要写一下
print('---不使用%，使用{}也实现精度控制---')
print('{0:.3}'.format(3.1415926)) # .3表示的是一共3位数，如果想表示小数要在后面加f
print('{0:.3f}'.format(3.1415926)) #冒号：前面的0代表的是占位符的顺序，也就是format()内的第几个，与索引类似
print('---不使用%，使用{}同时实现宽度和精度的控制---')
print('{0:10.3f}'.format(3.1415926)) #占位符0，宽度10个字符，保留后三位小数
#运行结果
---格式化字符串一：%作占位符---
我叫某酷,今年20岁
---格式化字符串二：{}作占位符---
我叫某酷,今年20岁
---格式化字符串三：f-string---
我叫某酷,今年20岁
---表示宽度d---
99
99
hellohello
---表示精度f---
3.141593
3.142
---同时表示宽度和精度---
3.142
---不使用%，使用{}也可以实现---
3.1415926
---不使用%，使用{}也可以实现---
3.14
3.142
85.字符串的编码与解码
编码与解码的万式
- 编码：将字符串转换为二进制数据（bytes）
- 解码：将bytes类型的数据转换成字符串类型
- 解析：例如将A计算机数据传到B计算机中，需要使用字节进行传输，这时候就需要将str字符串转换成二进制数据传送到B计算机，尔后B计算机再将二进制数据转换成字符串显示。
#实例
s='夏天的风'
print('---编码---')
print(s.encode(encoding='GBK')) #在GBK这种编码格式中，一个英文占两个字节（输出结果前面的b'表示bits类型二进制），夏天的风4个字符8个字节
print(s.encode(encoding='utf-8')) #在UTF-8这种编码格式中，一个中文占三个字节
print('---解码---')
#byte代表一个二进制数据（字节类型的数据），注意：编码和解码的格式要相同。
byte=s.encode(encoding='GBK') #编码
print(byte.decode(encoding='GBK')) #解码
byte=s.encode(encoding='UTF-8') #编码
print(byte.decode(encoding='UTF-8')) #解码
#运行结果
---编码---
b'\xcf\xc4\xcc\xec\xb5\xc4\xb7\xe7'
b'\xe5\xa4\x8f\xe5\xa4\xa9\xe7\x9a\x84\xe9\xa3\x8e'
---解码---
夏天的风
夏天的风