【第四章】Python字符串

认识字符串

• 是基本数据类型，是一个不可变的字符序列  

• 字符串的驻留机制：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，后续创建相同的字符串时，不会开辟新空间，而是叭该字符串的地址赋给新创建的变量。  

• 驻留机制的几种情况（交互模式）----了解一下

• 字符串的长度为0或者1时

• 符合标识符的字符串

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

• [-5,256]之间的i整数数字

```doctest# 打开交互模式C:\Users\Administrator>pythonPython 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:54:40) [MSC v.1900 64 bit (AMD64)] on win32Type "help", "copyright", "credits" or "license" for more information.# 长度为0或者1时驻留>>> s1=''>>> s2=''>>> si is s2# 符合标识符的字符串驻留>>> s1 = 'abc%'>>> s2 = 'abc%'>>> s1 is s2False>>> id(s1)2373409098192>>> id(s2)2373409098248>>>>>> s1 = 'abcx'>>> s2 = 'abcx'>>> s1 is s2True>>> id(s1)2373409098360>>> id(s2)2373409098360>>># 直接运行的时候不驻留>>> a='abc'>>> b='ab'+'c'>>> c=''.join(['ab'+'c'])>>> a is bTrue>>> a is cFalse>>> a'abc'>>> type(a)<class 'str'>>>> c'abc'>>> type(c)<class 'str'># 编译是驻留>>> a is cTrue```

2.1 查询

• index()：查询子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError

• rindex()：查询子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError

• find()：查询子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1

• rfind()：查询子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

```python# 查询练习s = 'hello,hello'print(s.index('lo'))  # ==>3print(s.find('lo'))  # ==>3print(s.rindex('lo'))  # ==>9print(s.rfind('lo'))  # ==>9print(s.index('k'))  # ==>ValueErrorprint(s.find('k'))  # ==>-1print(s.rindex('k'))  # ==>ValueErrorprint(s.rfind('k'))  # ==>-1```

2.2 大小写转换

• upper()：叭字符串中所有字符都转成大写字母

• lower()：叭字符串中所有字符都转成小写字母

• swapcase()：叭字符串中所有大写字母转成小写字母，小写字母转成大写字母

• capitalize()：叭第一个字符转换成大写，叭其余字符转换成小写

• title()：叭每个单词的第一个字符转换成大写，叭每个单词的剩余字符转换成小写

```python# 大小写转换练习,转换之后会产生新的字符串s = 'hello,python'a = s.upper()print(a)  # ==>HELLO,PYTHONprint(s.lower())  # ==>hello,pythons1 = 'hELLo,Python'print(s1.swapcase())  # ==>HellO,pYTHONprint(s1.capitalize())  # ==>Hello,pythonprint(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

```python# 对齐练习,空格不好区别，全用*练习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,Pythonsprint(s.rjust(10, '*'))  # ==>hello,Pythons# 右对齐，填充字符为0print(s.zfill(20))  # ==>0000000hello,Pythonsprint(s.zfill(10))  # ==>hello,Pythonsprint('-1980'.zfill(8))  # ==>-0001980```

2.4 分割操作

• split(sep, maxsplit)：从字符串的左边开始分割，默认的分割符为空格，返回的值是一个列表

• sep -- 指定的分隔符，默认空格

• maxsplit -- 分割次数，经过最大次数分割之后，剩余的子串会单独作为一部分。

• rsplit(sep, maxsplit)：从字符串的右边开始分割，默认的分割符为空格，返回的值是一个列表

• sep -- 指定的分隔符，默认空格

• maxsplit -- 分割次数，经过最大次数分割之后，剩余的子串会单独作为一部分。

```python# 默认分割是空格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()：判断指定字符串是否全部由字母和数字组成

```python# 判断练习s ='hello,python'print(s.isidentifier())  # ==>Falseprint('hello'.isidentifier())  # ==>Trueprint('张三'.isidentifier())  # ==>Trueprint('张三_123'.isidentifier())  # ==>Trueprint('\t'.isspace())  # ==>Trueprint('\n'.isspace())  # ==>Trueprint('\r'.isspace())  # ==>Trueprint(' '.isspace())  # ==>Trueprint('\b'.isspace())  # ==>Falseprint('abc'.isalpha())  # ==>Trueprint('张三'.isalpha())  # ==>Trueprint('张三1'.isalpha())  # ==>Falseprint('123'.isdecimal())  # ==>Trueprint('123四'.isdecimal())  # ==>Falseprint('ⅠⅡⅢ'.isdecimal())  # ==>Falseprint('123'.isnumeric())  # ==>Trueprint('123四'.isnumeric())  # ==>Trueprint('ⅠⅡⅢ'.isnumeric())  # ==>Trueprint('abc1'.isalnum())  # ==>Trueprint('张三123'.isalnum())  # ==>Trueprint('abc!'.isalnum())  # ==>False```

2.6 字符串替换

• replace(old, new, count)：该方法返回替换后得到的字符串，替换前后的字符串不发生变化

• old -- 指定被替换的子串

• new -- 指定替换子串的字符串

• count -- 指定最大替换次数

```python# 替换练习s = 'hello,Python'print(s.replace('Python', 'java'))  # ==>hello,javas = 'hello,Python,Python,Python'print(s.replace('Python', 'java', 2))  # ==>hello,java,java,Python```

2.7 字符串合并

• join()：将列表或元组中的字符串合并成一个字符串

```pythonlis = ['hello', 'java', 'python']print('|'.join(lis))  # ==>hello|java|pythonprint('_'.join(lis))  # ==>hello_java_pythont = ('hello', 'java', 'python')print('|'.join(t))  # ==>hello|java|pythonprint('_'.join(t))  # ==>hello_java_pythonprint('*'.join('python'))  # ==>p*y*t*h*o*n```

2.8 字符串的切片

• 切片将产生新的对象

• 操作类似于列表的切片

```pythons = 'hello,python'# 没有起始位置，从0开始s1 = s[:5]print(s1)  # ==>hello# 没有指定结束位置，直接切到结束s2 = s[6:]print(s2)  # ==>pythons3 = '!'new_s = s1 + s2 + s3print(new_s)  # ==>hellopython!# 从1开始切到5（不包括5），步长为1print(s[1:5:1])  # ==>ello# 没哟开始和结束，默认从0开始到字符串的最后一个元素print(s[::2])  # ==>hlopto# 默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数print(s[::-1])  # ==>nohtyp,ollehprint(s[-6::1])  # ==>python```

4.1 格式化字符串的方式

• 方式一：%作占位符（%s:字符串、%d:整数、%f:浮点数、%.nf:保留n位小数）

• 方式二：{}作占位符（format）

• 方式三：f-string

```python# 方式一：%name = '张三'age = 20print('我叫%s,今天%d岁' % (name, age))  # ==>我叫张三,今天20岁# 方式二：{}print('我叫{},今天{}岁'.format(name, age))  # ==>我叫张三,今天20岁# 方式三：f-stringprint(f'我叫{name},今天{age}岁')  # ==>我叫张三,今天20岁print('%d' % 99)  # ==>99# 这里的10表示宽度print('%10d' % 99)  # ==>        99# 这里.3表示保留的位数print('%f' % 3.1415926)  # ==>3.141593print('%.3f' % 3.1415926)  # ==>3.142# 这里10.3 表示宽度为10，精度为小数点后3位print('%10.3f' % 3.1415926)  # ==>     3.142print('{}'.format(3.1415925))  # ==>3.1415925# 这里.3 表示的是一共3位数，0 表示占位符的顺序，可以省略print('{0:.3}'.format(3.1415925))  # ==>3.14print('{:.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 字符串，里面的字符就不需要转义了

```pythonprint(r'\(~_~)/ \(~_~)/')  # ==>\(~_~)/ \(~_~)/print(r'\n\t\r')  # ==>\n\t\r```