字符串的常用操作
1. 字符串的查询操作的方法
举例：
查找变量s='hello,hello' 中 'lo' 的位置
'''字符串的查询操作'''
s='hello,hello'
print(s.index('lo'))
print(s.find('lo'))
print(s.rindex('lo'))
print(s.rfind('lo'))
'''当查询不存在的字符时，index和rindex会报ValueError，find和rfind则返回-1，推荐用find'''
#print(s.index('k')) #ValueError: substring not found
print(s.find('k')) #-1
#print(s.rindex('k')) #ValueError: substring not found
print(s.rfind('k')) #-1
执行结果如下：
说明：字符串索引图如下：
使用index和find是，'lo' 出现的第一个位置是3，使用rindex和rfind查找最后一个'lo'的位置是9，当查找的字符不存在时，使用index和rindex时会报"ValueError"，使用find和rfind时则返回-1
2 字符串的大小写转换操作的方法
举例：
- 使用upper()方法将字符串 s='hello,Python' 都转成大写字母
s='hello,Python' # a=s.upper() #转成大写之后，产生一个新的字符串对象 # print(a,id(a)) # print(s,id(s))
执行结果：
说明：在对字符串进行大小写转换操作，会产生一个新的字符串对象，原来的字符串不变
- 使用lower()方法将字符串 s='hello,Python' 都转成小写字母
s='hello,Python' a=s.lower() #转成小写之后，产生一个新的字符串对象 print(a,id(a)) print(s,id(s))
执行结果如下：
- 使用swapcase()方法将字符串 s='hello,Python' 进行大小写互换
s='hello,Python' a=s.swapcase() #转换之后，产生一个新的字符串对象 print(a,id(a)) print(s,id(s))
执行结果：
- 使用capitalize()方法将字符串 s='hello,Python' 把第一个字母转成大写，其它字母转成小写
s='hello,Python' a=s.capitalize() #转换之后，产生一个新的字符串对象 print(a,id(a)) print(s,id(s))
执行结果：
- 使用title()方法将字符串 s='hello,Python' 把每个单词的第一个字母转成大写，其它字母转成小写
s='hello,Python' a=s.title() #转换之后，产生一个新的字符串对象 print(a,id(a)) print(s,id(s))
执行结果：
3 字符串内容对齐操作的方法
举例：
- 使用center()方法将字符串 s='hello,Python' 进行居中对齐操作
#居中对齐 s='hello,Python' print(s.center(20,'*')) #将s居中对齐，其它位置使用*进行填充
执行结果：
- 使用ljust()方法将字符串 s='hello,Python' 进行左对齐操作
#左对齐 s='hello,Python' print(s.ljust(20,'*')) print(s.ljust(10)) print(s.ljust(20))
执行结果：
说明：使用ljust()方法进行左对齐操作时，如果设置宽度10小于原字符串宽度12时，则返回原字符串，如果设置宽度20大于原字符串宽度12时，则右边默认使用空格填充
- 使用rjust()方法将字符串 s='hello,Python' 进行右对齐操作
#右对齐 s='hello,Python' print(s.rjust(20,'0')) print(s.rjust(20)) print(s.rjust(8))
执行结果：
说明：使用rjust()方法进行右对齐操作，当设置宽度20大于原字符串宽度12时，左侧默认使用空格填充，如果设置的宽度8小于原宽度12，则返回原字符串
- 使用zfill()方法将字符串 s='hello,Python' 进行右对齐操作
#右对齐，使用0进行填充
s='hello,Python'
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))
执行结果：
说明：使用zfill()方法进行右对齐时，左侧默认使用0填充，当填充的数据前有符号时，则将0填充至符号之后
4 字符串劈分操作的方法
举例：
- 用split()方法对字符串 s='hello world python' 进行劈分，使用默认空格劈分符
'''字符串的劈分（分割）''' s='hello world python' lst=s.split() #当不输入参数时，默认使用空格进行分割，分割后是一个列表 print(lst,type(lst))
执行结果：
说明：s='hello world python'中本身就包含空格，则会默认从空格处进行劈分，会劈分成'hello','world','python'3个字符串组成的列表
- 用split()方法对字符串 s='hello world python' 进行劈分，使用劈分符 '|' 进行劈分，并最多劈分1次
'''使用指定的劈分符进行劈分''' s1='hello|world|python' print(s1.split(sep='|')) #使用'|'进行劈分 print(s1.split(sep='|',maxsplit=1)) #使用'|'进行劈分，最多劈分1次，劈分之后剩余的子字符串会成为一个字符串
执行结果：
说明：使用split()从右侧使用'|'进行劈分时，劈分成3个字符串，当使用参数 maxsplit=1 设置最大劈分次数为1时，剩下的 world|python 会作为一个字符串进行保存
- 用rsplit()方法对字符串 s='hello world python' 进行劈分，使用劈分符 '|' 进行劈分，并最多劈分1次
'''rsplit()从右侧开始劈分''' s1='hello|world|python' print(s1.rsplit(sep='|')) print(s1.rsplit(sep='|',maxsplit=1)) #使用'|'进行劈分，最多劈分1次，劈分之后剩余的子字符串会成为一个字符串
执行结果：
说明：使用rsplit()从右侧使用'|'进行劈分时，和左侧劈分结果一样，都是劈分成3个字符串，当使用参数 maxsplit=1 设置最大劈分次数为1时，剩下的 hello|world 会作为一个字符串进行保存
5 判断字符串操作的方法
举例：
- 判断字符串是否是合法的标识符
'''判断字符串的操作'''
#判断字符串是否是合法的标识符
s='hello,python'
print('1.',s.isidentifier()) #False
print('2.','hello'.isidentifier()) #True
print('3.','张三_'.isidentifier()) #True
print('4.','张三_123'.isidentifier()) #True
执行结果：
说明：合法标识符是指含有字母、数字和下划线的字符串，s='hello,python' 中包含逗号，则执行结果为False
- 判断字符串是否由空白字符串组成
print('5.',' '.isspace()) #True
执行结果如下：
- 判断字符串是否全部由字母组成
#判断字符串是否全部由字母组成
print('6.','abc'.isalpha()) #True
print('7.','张三'.isalpha()) #True
print('8.','abc123'.isalpha()) #False
执行结果：
说明：'abc123' 中包含数字，故输出为False
- 判断字符串全部由十进制数字组成
#判断字符串全部由十进制数字组成
print('9.','123'.isdecimal()) #True
print('10.','123四'.isdecimal()) #False
print('11','ⅡⅡⅡⅢ'.isalpha()) #False
执行结果：
说明：'四' 不是十进制数字，返回False，'ⅡⅡⅡⅢ'也不是十进制数字，返回False
- 判断字符串是否全部由数字组成
#判断字符串是否全部由数字组成
print('12.','123'.isnumeric()) #True
print('13.','123四'.isnumeric()) #True
print('14.','ⅡⅡⅡⅢ'.isnumeric()) #True
执行结果：
说明：'四' 是数字，返回True，'ⅡⅡⅡⅢ'也是数字，返回True
- 判断字符串是否全部由字母和数字组成
#判断字符串是否全部由字母和数字组成
print('15.','abc1'.isalnum()) #True
print('16.','张三123'.isalnum()) #True
print('17.','abc！'.isalnum()) #False
执行结果：
说明：'张三123'是由数字和字母组成，'abc！'不是由数字和字母组成，则返回False
6. 字符串操作的其它方法
举例：
'''字符串的替换'''
s='hello,Python'
print(s.replace('Python','Java'))
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2))
执行结果：
说明：s1.replace('Python','Java',2) 中2表示最多替换2次，所以最后一个输出中还有一个Python
- 字符串的合并
lst=['hello','java','python']
print('|'.join(lst))
print(''.join(lst))
t=('hello','java','python')
print(''.join(t))
print('*'.join('Python'))
执行结果：
说明：'*'.join('Python') 中将Pyhton当成一个序列，如果想用空连接字符串，则用''即可
7.字符串的比较操作
运算符：>, >=, <,<=, ==, !=
比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
比较原理：两个字符进行比较时，比较的是其ordinal value（原始值），调用内置函数 ord 可以得到指定字符的ordinal value。与内置函数 ord 对应的是内置函数 chr，调用内置函数 chr 时指定 ordinal value可以得到其对应的字符。
举例：
- 比较 'apple' 和 'app' 两个字符串
'''字符串的比较操作'''
print('apple'>'app') #True
print('apple'>'banana') #False
print(ord('a'),ord('b'))
print(chr(97),chr(99))
执行结果：
说明：
apple 和 app 两个字符串比较，第一个字母a 相同，继续比较第二个字符p，第二个字符相同则继续比较第三个字符p，当比较到第4个字符 l 时，app中没有，则停止比较，因 apple 比 app 所包含的字母数多，则 apple 比 app 大，最后输出结果是True
apple 和 banana 比较，根据字符串比较原理，首先比较的是第一个字符a 和 b，a 的原始值是97，b的原始值是98，97 不等于98，所以第一个字母比较结果是False，则不会比较后面的字符，则两者比较输出结果为False，即 apple > banana 不成立。
- == 与 is 的区别
说明：== 比较的是内容，is比较的是内存地址
举例：
'''== 与 is 的区别 ==是比较内容，is是比较内存地址（id） ''' a=b='Python' c='Python' print(a==b) print(b==c) print(a is b) print(a is c) print(id(a)) print(id(b)) print(id(c))
执行结果：
8. 字符串的切片操作
字符串是不可变类型
- 不具备增、删、改等操作
- 切片操作将产生新的对象
完整语法结构：变量名[start:end:step]
示意图：
代码举例：
'''字符串的切片''' s='hello,Python' s1=s[:5] #由于没有指定其实元素，所以从第一个索引开始，截取到索引为5的元素（不包含5） s2=s[6:] #由于没有指定结束为止，所以切到字符串的最后一个元素 s3='!' newstr=s1+s3+s2 print(s1,id(s1)) #hello print(s2,id(s2)) print(s3,id(s3)) print(newstr,id(newstr))
执行结果：
说明：执行结果可以看出，执行切片操作时，都会产生新的对象，因为字符串时不可变类型。
完整语法结构代码示例：
'''完整语法示例 变量名[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
执行结果：
9. 格式化字符串
格式化字符串的三种方式
- 第一种：%作占位符
图解%占位符
代码示例：
'''格式化字符串'''
'''使用%作为占位符'''
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))
执行结果：
- 第二种：{}作占位符
图解{}占位符
代码示例：
'''使用{}作为占位符'''
name='张三'
age=20
print('我叫{0}，今年{1}岁'.format(name,age))
执行结果：
- 还可以使用f-string来进行格式化填充
代码示例：
'''使用f-string'''
print(f'我叫{name}，今年{age}岁')
执行结果：
- 数据精度处理
'''数据精度表示'''
print('%d' % 99)
print('%10d' % 99) #10表示宽度，除去字符外自动补充空格
print('hellohello')
print('%.3f' % 3.1415926) #.3表示是小数位点后三位
#同时表示宽度和精度
print('%10.3f' % 3.1415926) #一共总宽度未10，小数点后3位
执行结果：
用{}来表示精度和宽度
'''用{}表示宽度和精度'''
print('{0}'.format(3.1415926))
print('{0:.3}'.format(3.1415926)) #.3表示的是一共是3位数
print('{:.3f}'.format(3.1415926)) #.3f表示是3位小数
print('{:10.3f}'.format(3.1415926)) #同时设置宽度和精度，一共是10位，3位时小数
执行结果：
10.字符串的编码转换
为什么需要字符串的编码转换
编码与解码的方式
- 编码：将字符串转换为二进制数据(bytes)，方法是encode（）
- 解码：将bytes类型的数据转换成字符串类型，方法是decode（）
编码代码示例：
'''字符串的编码和解码''' s='开心的笨小孩' #编码 print(s.encode(encoding='GBK')) #在GBK这种编码格式中，一个中文字符占两个字节 print(s.encode(encoding='UTF-8')) #在UTF-8这种编码格式中，一个中文占3个字节
执行结果：
说明：使用GBK进行编码，一个中文占2个字节，有5个中文，所以共10个编码结果，前面的b标识二进制，在UTF-8编码中一个中文字符占3个字节，所以一共有15个二进制
解码代码示例：
#解码 #byte代表一个二进制数据（字节类型数据） s='开心的笨小孩' byte=s.encode(encoding='GBK') #编码 print(byte.decode(encoding='GBK')) #解码 byte=s.encode(encoding='UTF-8') #编码 print(byte.decode(encoding='UTF-8')) #解码
执行结果：
说明：使用什么样格式进行编码，必须使用同样的格式来解码，否则会报错
----------------------------------------------------------------------------------------------------
字符串知识点总结
1. 字符串的驻留
- 驻留的几种情况
- 驻留的优点
- 强制驻留的方法
2.字符串的常用方法
- 查询方法：index(),rindex(),find(),rfind()
- 大小写转换：upper(),lower()
- 内容对齐：center()
- 字符串的劈分：split()
- 字符串的判断：isdecimal()
- 字符串的替换：replace()
- 字符串的合并：join()
- 字符串的比较：>,>=,<,<=,==,!=
- 格式化字符串：%,format()
- 字符编码：encode(),decode()
--------------------------------------------------------------------------以上为字符串相关内容