关于python3.x:Python语言重要知识点梳理二字符串常用操作极其详细

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')) #运行后果 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  --> 查找最初一次呈现的地位，不存在返回 -1

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

# 实例
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()) #运行后果为 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|Python
hellojavaPython
P*y*t*h*o*n

82. 字符串的比拟操作

• 字符串的比拟操作

  • 运算符：>，>=，<，<=，==，！=
  • 比拟规定：首先比拟两个字符串中的第一个字符，如果相等则持续比拟下一个字符，顺次比拟上来，直到两个字符串中的字符不相等时，其比拟后果就是两个字符串的比拟后果，两个字符串中的所有后续字符将不再被比拟
  • 比拟原理：两上字符进行比拟时，比拟的是其 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'
--- 解码 ---
夏天的风
夏天的风