四、Python字符串
1、认识字符串
1.1 是基本数据类型，是一个不可变的字符序列
1.2 字符串的驻留机制：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，后续创建相同的字符串时，不会开辟新空间，而是叭该字符串的地址赋给新创建的变量。
1.3 驻留机制的几种情况（交互模式）----了解一下
① 字符串的长度为0或者1时
② 符合标识符的字符串
③ 字符串只在编译时进行驻留，而非运行时
④ [-5,256]之间的i整数数字
# 打开交互模式 C:\Users\Administrator>python Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:54:40) [MSC v.1900 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. # 长度为0或者1时驻留 >>> s1=‘‘ >>> s2=‘‘ >>> si is s2 # 符合标识符的字符串驻留 >>> s1 = ‘abc%‘ >>> s2 = ‘abc%‘ >>> s1 is s2 False >>> id(s1) 2373409098192 >>> id(s2) 2373409098248 >>> >>> s1 = ‘abcx‘ >>> s2 = ‘abcx‘ >>> s1 is s2 True >>> id(s1) 2373409098360 >>> id(s2) 2373409098360 >>> # 直接运行的时候不驻留 >>> a=‘abc‘ >>> b=‘ab‘+‘c‘ >>> c=‘‘.join([‘ab‘+‘c‘]) >>> a is b True >>> a is c False >>> a ‘abc‘ >>> type(a) <class ‘str‘> >>> c ‘abc‘ >>> type(c) <class ‘str‘> # 编译是驻留 >>> a is c True
2、字符串的常用操作（*****）
2.1 查询
① index()：查询子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError
② rindex()：查询子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
③ find()：查询子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1
④ rfind()：查询子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1
# 查询练习 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 print(s.find(‘k‘)) # ==>-1 print(s.rindex(‘k‘)) # ==>ValueError print(s.rfind(‘k‘)) # ==>-1
2.2 大小写转换
① upper()：叭字符串中所有字符都转成大写字母
② lower()：叭字符串中所有字符都转成小写字母
③ swapcase()：叭字符串中所有大写字母转成小写字母，小写字母转成大写字母
④ capitalize()：叭第一个字符转换成大写，叭其余字符转换成小写
⑤ title()：叭每个单词的第一个字符转换成大写，叭每个单词的剩余字符转换成小写
# 大小写转换练习,转换之后会产生新的字符串 s = ‘hello,python‘ a = s.upper() print(a) # ==>HELLO,PYTHON print(s.lower()) # ==>hello,python s1 = ‘hELLo,Python‘ print(s1.swapcase()) # ==>HellO,pYTHON print(s1.capitalize()) # ==>Hello,python print(s1.title()) # ==>Hello,Python
2.3 对齐操作
① center(width, fillchar)：居中对齐，如果指定的长度小于原字符串的长度则返回原字符串。
width -- 字符串的总宽度
fillchar -- 可选参数，填充字符，默认为空格
② ljust(width, fillchar)：左对齐，如果指定的长度小于原字符串的长度则返回原字符串。
width -- 指定字符串长度
fillchar -- 可选参数，填充字符，默认为空格
③ rjust(width, fillchar)：右对齐，如果指定的长度小于字符串的长度则返回原字符串。
width -- 指定填充指定字符后中字符串的总长度
fillchar -- 可选参数，填充的字符，默认为空格
④ zfill(width)：右对齐，前面填充0，如果指定的长度小于字符串的长度则返回原字符串。
width -- 指定字符串的长度。原字符串右对齐，前面填充0
# 对齐练习,空格不好区别，全用*练习 s = ‘hello,Pythons‘ # 居中 print(s.center(20, ‘*‘)) # ==>***hello,Pythons**** # 左对齐 print(s.ljust(20, ‘*‘)) # ==>hello,Pythons******* print(s.ljust(10, ‘*‘)) # ==>hello,Pythons # 右对齐 print(s.rjust(20, ‘*‘)) # ==>*******hello,Pythons print(s.rjust(10, ‘*‘)) # ==>hello,Pythons # 右对齐，填充字符为0 print(s.zfill(20)) # ==>0000000hello,Pythons print(s.zfill(10)) # ==>hello,Pythons print(‘-1980‘.zfill(8)) # ==>-0001980
2.4 分割操作
① split(sep, maxsplit)：从字符串的左边开始分割，默认的分割符为空格，返回的值是一个列表
sep -- 指定的分隔符，默认空格
maxsplit -- 分割次数，经过最大次数分割之后，剩余的子串会单独作为一部分。
② rsplit(sep, maxsplit)：从字符串的右边开始分割，默认的分割符为空格，返回的值是一个列表
sep -- 指定的分隔符，默认空格
maxsplit -- 分割次数，经过最大次数分割之后，剩余的子串会单独作为一部分。
# 默认分割是空格 s =‘hello world python‘ print(s.split()) # ==>[‘hello‘, ‘world‘, ‘python‘] s1 =‘hello|world|python‘ # 左边开始分割 print(s1.split()) # ==>[‘hello|world|python‘] print(s1.split(sep=‘|‘)) # ==>[‘hello‘, ‘world‘, ‘python‘] print(s1.split(sep=‘|‘, maxsplit=1)) # ==>[‘hello‘, ‘world|python‘] # 右边开始分割 print(s1.rsplit()) # ==>[‘hello|world|python‘] print(s1.rsplit(sep=‘|‘)) # ==>[‘hello‘, ‘world‘, ‘python‘] print(s1.rsplit(sep=‘|‘, maxsplit=1)) # ==>[‘hello|world‘, ‘python‘]
2.5 判断字符串的操作
① isidentifier()：判断指定的字符串是不是合法的标识符
② isspace()：判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符、空格）
③ isalpha()：判断指定的字符串是否全部由字母组成
④ isdecimal()：判断指定字符串是否全部由十进制的数字组成
⑤ isnumeric()：判断指定字符串是否全部由数字组成
⑥ isalnum()：判断指定字符串是否全部由字母和数字组成
# 判断练习 s =‘hello,python‘ print(s.isidentifier()) # ==>False print(‘hello‘.isidentifier()) # ==>True print(‘张三‘.isidentifier()) # ==>True print(‘张三_123‘.isidentifier()) # ==>True print(‘\t‘.isspace()) # ==>True print(‘\n‘.isspace()) # ==>True print(‘\r‘.isspace()) # ==>True print(‘ ‘.isspace()) # ==>True print(‘\b‘.isspace()) # ==>False print(‘abc‘.isalpha()) # ==>True print(‘张三‘.isalpha()) # ==>True print(‘张三1‘.isalpha()) # ==>False print(‘123‘.isdecimal()) # ==>True print(‘123四‘.isdecimal()) # ==>False print(‘ⅠⅡⅢ‘.isdecimal()) # ==>False print(‘123‘.isnumeric()) # ==>True print(‘123四‘.isnumeric()) # ==>True print(‘ⅠⅡⅢ‘.isnumeric()) # ==>True print(‘abc1‘.isalnum()) # ==>True print(‘张三123‘.isalnum()) # ==>True print(‘abc!‘.isalnum()) # ==>False
2.6 字符串替换
① replace(old, new, count)：该方法返回替换后得到的字符串，替换前后的字符串不发生变化
old -- 指定被替换的子串
old -- 指定替换子串的字符串
count -- 指定最大替换次数
# 替换练习 s = ‘hello,Python‘ print(s.replace(‘Python‘, ‘java‘)) # ==>hello,java s = ‘hello,Python,Python,Python‘ print(s.replace(‘Python‘, ‘java‘, 2)) # ==>hello,java,java,Python
2.7 字符串合并
① join()：将列表或元组中的字符串合并成一个字符串
lis = [‘hello‘, ‘java‘, ‘python‘] print(‘|‘.join(lis)) # ==>hello|java|python print(‘_‘.join(lis)) # ==>hello_java_python t = (‘hello‘, ‘java‘, ‘python‘) print(‘|‘.join(t)) # ==>hello|java|python print(‘_‘.join(t)) # ==>hello_java_python print(‘*‘.join(‘python‘)) # ==>p*y*t*h*o*n
2.8 字符串的切片
① 切片将产生新的对象
② 操作类似于列表的切片
s = ‘hello,python‘ # 没有起始位置，从0开始 s1 = s[:5] print(s1) # ==>hello # 没有指定结束位置，直接切到结束 s2 = s[6:] print(s2) # ==>python s3 = ‘!‘ new_s = s1 + s2 + s3 print(new_s) # ==>hellopython! # 从1开始切到5（不包括5），步长为1 print(s[1:5:1]) # ==>ello # 没哟开始和结束，默认从0开始到字符串的最后一个元素 print(s[::2]) # ==>hlopto # 默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数 print(s[::-1]) # ==>nohtyp,olleh print(s[-6::1]) # ==>python
3、字符串比较操作
3.1 运算符：>、>=、<、<=、==、!=
3.2 比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
3.3 比较原理：比较的其实是原始值，可以通过内置函数ord来获取指定字符的原始值，相对的是内置函数chr，可以通过chr获取指定原始值对应的字符。
# 比较操作 print(‘apple‘ > ‘app‘) # ==>True print(‘apple‘ > ‘banana‘) # ==>False print(ord(‘a‘)) # ==>97 print(ord(‘b‘)) # ==>98 print(chr(97)) # ==>a # ==与is的区别：==比较的是vlaue是否相等，is比较的是id是否相同 a = b = ‘python‘ c = ‘python‘ print(a == b) # ==>True print(b == c) # ==>True print(a is b) # ==>True print(a is c) # ==>True
4、格式化字符串
4.1 格式化字符串的方式
① 方式一：%作占位符（%s:字符串、%d:整数、%f:浮点数、%.nf:保留n位小数）
② 方式二：{}作占位符（format）
③ 方式三：f-string
# 方式一：%
name = ‘张三‘
age = 20
print(‘我叫%s,今天%d岁‘ % (name, age)) # ==>我叫张三,今天20岁
# 方式二：{}
print(‘我叫{},今天{}岁‘.format(name, age)) # ==>我叫张三,今天20岁
# 方式三：f-string
print(f‘我叫{name},今天{age}岁‘) # ==>我叫张三,今天20岁
print(‘%d‘ % 99) # ==>99
# 这里的10表示宽度
print(‘%10d‘ % 99) # ==> 99
# 这里.3表示保留的位数
print(‘%f‘ % 3.1415926) # ==>3.141593
print(‘%.3f‘ % 3.1415926) # ==>3.142
# 这里10.3 表示宽度为10，精度为小数点后3位
print(‘%10.3f‘ % 3.1415926) # ==> 3.142
print(‘{}‘.format(3.1415925)) # ==>3.1415925
# 这里.3 表示的是一共3位数，0 表示占位符的顺序，可以省略
print(‘{0:.3}‘.format(3.1415925)) # ==>3.14
print(‘{:.3}‘.format(3.1415925)) # ==>3.14
# .3f表示3位小数
print(‘{:.3f}‘.format(3.1415925)) # ==>3.142
# 同时设置宽度和精度，一共10位，3位是小数
print(‘{:10.3f}‘.format(3.1415925)) # ==> 3.142
4.2 raw字符串与多行字符串:一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀r，表示这是一个 raw 字符串，里面的字符就不需要转义了
print(r‘\(~_~)/ \(~_~)/‘) # ==>\(~_~)/ \(~_~)/ print(r‘\n\t\r‘) # ==>\n\t\r
5、字符串的编码
5.1 编码：将字符串转换为二进制数据（bytes）
5.2 解码：将bytes类型的数据转换为字符串类型
5.3 python3中，默认使用UTF-8 Unicode来进行编码
s = ‘好好学习‘ # 编码 print(s.encode(encoding=‘GBK‘)) # GBK编码中一个中文占两个字节 print(s.encode(encoding=‘UTF-8‘)) # UTF-8编码中一个中文占三个字节 # 解码 byte = s.encode(encoding=‘GBK‘) print(byte.decode(encoding=‘gbk‘)) # 编码和解码的类型要一致 print(byte.decode(encoding=‘utf-8‘)) # ==>UnicodeDecodeError
原文：https://www.cnblogs.com/xuanling/p/14364554.html