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

  • 字符串只在编译时进行驻留，而非运行时

    • python是一种解释型语言，但实际上它的解释器也能够了解成编译器，它负责将python代码编译成字节码，也就是.pyc文件，

 [-5，256]之间的整数数字

  • 字符串驻留机制的优缺点

    • 当须要值雷同的字符串时，能够间接从字符串池里拿来应用，防止频繁的创立和销毁，晋升效率和节约内存，因而拼接字符串和批改字符串是会比拟影响性能的。

    • 在须要进行字符串拼接时倡议应用str类型的join办法，而非+，因为join（）办法是先计算出所有字符中的长度，而后再拷贝，只new一次对象，效率要比"+"效率高

      76.字符串的罕用操作_字符串的查问操作

  • 能够把字符串看成是字符的列表，所以字符串与列表查的操作是十分类似的，但区别就在于，当取得字符串中指定的索引时，除了有Index外，还有rindex、find以及rfind办法，
#实例s='hello,hello'print(s.index('lo')) #运行后果3print(s.find('lo')) #运行后果3print(s.rindex('lo')) #运行后果9print(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  -->查找最初一次呈现的地位，不存在返回-1

77.字符串的罕用操作_字符串的大小写转换操作方法

#实例print('---字符串中的大小写转换的办法---')s='hello,python'a=s.upper() #转大写后会产生一个新的字符串对象(艰深讲就是会增加一个内存空间，内存地址会变)print(a,id(a)) #转换后；运行后果为HELLO,PYTHON 2969352950256print(s,id(s)) #转换前；运行后果为hello,python 2969352985584b=s.lower() #转换后会产生一个新的字符串对象print(b,id(b)) #运行后果为hello,python 1939784160688print(s,id(s)) #运行后果为hello,python 1939783867376print(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.Pythonprint(s.rjust(20)) #运行后果为        hello.Pythonprint(s.rjust(10)) #运行后果为hello.Pythonprint('---右对齐.zfill() 应用0进行填充---')print(s.zfill(20))print(s.zfill(10))print('-8910'.zfill(8))#运行后果---居中对齐.center()---****hello.Python****---左对齐.ljust()---hello.Python********hello.Pythonhello.Python        ---右对齐.rjust()---********hello.Python        hello.Pythonhello.Python---右对齐.zjust() 应用0进行填充---00000000hello.Pythonhello.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()) #运行后果为falseprint('2','hello'.isidentifier()) #运行后果为trueprint('3','张三_'.isidentifier()) #运行后果为trueprint('4','张三_123'.isidentifier()) #运行后果为true'''判断指定的字符串是否全副由空白字符组成（回车、换行，程度制表符）'''print('5','\t'.isspace()) #运行后果为true'''判断指定的字符串是否全副由字母组成'''print('6','abc'.isalpha()) #运行后果trueprint('7','张三'.isalpha()) #运行后果为trueprint('8','张三1'.isalpha()) #运行后果为false'''判断指定字符串是否全副由十进制的数字组成'''print('9','123'.isdecimal()) #运行后果为trueprint('10','123四'.isdecimal()) #运行后果为falseprint('11','ⅡⅡⅡ'.isdecimal()) #运行后果为false'''判断指定的字符串是否全副由数字组成'''print('12','123'.isnumeric()) #运行后果为trueprint('13','123四'.isnumeric()) #运行后果为trueprint('14','ⅡⅡⅡ'.isnumeric()) #运行后果为true  -->验证罗马数字也是数字'''判断指定字符串是否全副由字母和数字组成'''print('15','abc1'.isalnum()) #运行后果为trueprint('16','张三123'.isalnum()) #运行后果为trueprint('17','abc!'.isalnum()) #运行后果为false

81.字符串的罕用操作_替换与合并

#实例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|PythonhellojavaPythonP*y*t*h*o*n

82.字符串的比拟操作

  • 字符串的比拟操作

    • 运算符：>，>=，<，<=，==，！=
    • 比拟规定：首先比拟两个字符串中的第一个字符，如果相等则持续比拟下一个字符，顺次比拟上来，直到两个字符串中的字符不相等时，其比拟后果就是两个字符串的比拟后果，两个字符串中的所有后续字符将不再被比拟
    • 比拟原理：两上字符进行比拟时，比拟的是其ordinal value（原始值），调用内置函数ord能够失去指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value能够失去其对应的字符
#实例print('apple'>'app') #trueprint('apple'>'banana') #false -->相当于97>98吗？当然不大于所以为falseprint(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) #Trueprint(a==c) #Trueprint(a is b) #Trueprint(a is c) #Trueprint(id(a)) #3004608322480print(id(b)) #3004608322480print(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='!' #将叹号赋值给s3new_str=s1+s3+s2 #将切出来的两个字符串s1和s2与s3叹号通过连接符+连贯，赋值给new_strprint(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），步长为1print(s[::2]) #默认从0开始，没有写完结，默认到字符串最初一个元素，步长为2，两个元素之间的索引距离为2print(s[::-1]) #默认从字符串的最初一个元素开始，到字符串的第一个元素完结，因为步长为正数print(s[-6::1]) #从索引为-6开始，到字符串最初一个元素完结，步长为1#运行后果helloPythonhello!Python---验证id内存地址是否雷同---30912680335843091270854256309127091857630912635577443091270920432---切片[start:end:step] 残缺的写法---ellohloPtonohtyP,olleh

84.格式化字符串

解析：字符串的拼接操作会产生很多新的字符串会造成空间的节约，所以这时候就须要应用格式化字符串就能够了（按肯定格局输入的字符串）。

#我的名字叫：{0}，往年{1}岁了，我真的叫：{0}'.format（name，age）解析 #所有format(name)都会用0去替换#实例'''格式化字符串罕用根本用法'''print('---格式化字符串一：%作占位符---')name='某酷'age=20print('我叫%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位数，如果想示意小数要在前面加fprint('{0:.3f}'.format(3.1415926)) #冒号：后面的0代表的是占位符的程序，也就是format()内的第几个，与索引相似print('---不应用%，应用{}同时实现宽度和精度的管制---')print('{0:10.3f}'.format(3.1415926)) #占位符0，宽度10个字符，保留后三位小数#运行后果---格式化字符串一：%作占位符---我叫某酷,往年20岁---格式化字符串二：{}作占位符---我叫某酷,往年20岁---格式化字符串三：f-string---我叫某酷,往年20岁---示意宽度d---99        99hellohello---示意精度f---3.1415933.142---同时示意宽度和精度---     3.142---不应用%，应用{}也能够实现---3.1415926---不应用%，应用{}也能够实现---3.143.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'---解码---夏天的风夏天的风