百木园4.3 字符串(str、bytes)
4.3.1 字符串前置知识
4.3.1.1 字符串的概念
字符串由一系列字符组成，字符(Character)是各种文字和符号的总称，包括各国家文字、标点符号、图形符号、数字等。字符串是编程语言中表示文本的数据类型。
字符串就是由一个个元素(字符)组成的。像这种由一个个元素按照顺序组成的数据，在Python语言里面，把这种特性的数据称之为 sequence，翻译成中文就是序列。关于序列，我们将在后续内容中详细介绍。
4.3.1.2 字符集
字符集是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同，常见字符集有：ASCII字符集、GB2312字符集、BIG5字符集、 GB18030字符集、Unicode字符集等。
字符集简单来说，就是一张表格，是字符和id的对应表。
4.3.1.3 字符编码、解码
因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit，也成为位）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），如果要表示更大的整数，就必须用更多的字节。比如两个字节可以表示的最大整数是65535，4个字节可以表示的最大整数是4294967295。
计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果。
通俗的说，按照某种规则将字符存储在计算机中，如a用什么表示，称为编码；反之，将存储在计算机中的二进制数解析成字符显示出来，称为解码，如同密码学中的加密和解密。
在解码过程中，如果使用了错误的解码规则，则会导致目标字符被解析成其它字符或者乱码。
4.3.1.3.1 编码发展史
美国人发明了计算机，用八位0和1的组合，一一对应英文中的字符，整出了一个表格，ASCII表。也就是大名鼎鼎的ASCII字符集。
ASCII字符集主要包括控制字符(回车键、退格、换行键等)；可显示字符(英文大小写字符、阿拉伯数字和西文符号)。
计算机传入中国，中国地大物博，繁体字和简体字多，8位字节最多表示256个字符，满足不了人们的日常工作需要，于是对ASCII扩展，新字符集叫GB2312。后来发现GB2312还不够用，扩充之后形成GB18030。
每个国家都像中国一样，把自己的语言编码，于是出现了各种各样的编码，如果你不安装相应的编码，就无法正确解码查看到正确的内容。
由于各个国家的编码无法进行国际交流。一个国际组织一起创造了一种编码 UNICODE(Universal Multiple-Octet Coded Character Set)规定所有字符用两个字节表示，就是固定的，所有的字符就两个字节，计算机容易识别。
UNICODE虽然解决了各自为战的问题，但是美国人不愿意了，因为美国原来的ASCII只需要一个字节就可以了。UNICODE编码却让他们的语言多了一个字节，白白浪费一个字节的存储空间。经过协商，出现了一种新的转换格式，被称为通用转换格式，也就是UTF(unicode transformation format)。常见的有UTF-8、UTF-16。UTF-8规定，美国字符一个字节，欧洲两个字符，东南亚三个字符。
4.3.1.3.2 ASCII编码
ASCII(American Standard Code for Information Interchange，美国信息交换标准代码)是基于拉丁字母的一套电脑编码系统。它主要用于显示现代英语，而其扩展版本EASCII则可以显示其他西欧语言。它是现今最通用的单字节编码系统。
ASCII编码将ASCII字符集转换为计算机系统可以存储的数字的编码规则。使用7位(bits)表示一个字符，共128字符；但是7位编码的字符集只能支持128个字符，为了表示更多的欧洲常用字符对ASCII进行了扩展，ASCII扩展字符集使用8位(bits)表示一个字符，共256字符。
4.3.1.3.3 GBXXXX字符集和编码
GB2312标准共收录6763个汉字，GB2312对任意字符都采用双字节表示。
GBK共收入21886个汉字和图形符号，GBK对任意字符都采用双字节表示。
GB18030共收录汉字70244个，GB18030编码是一二四字节变长编码。其单字节，与 ASCII 编码兼容。
注：GBK兼容GB2312，GB18030兼容GBK。
4.3.1.3.4 Unicode字符集和编码
Unicode是国际组织制定的可以容纳世界上所有文字和符号的字符编码方案，记录着世界上所有字符对应的一个数字。
Unicode只是一个字符集，并不是一个编码方式。有2种，一种是UCS-2字符集，利用2个字节表示字符，一共可以表示65535个字符。另一种是UCS-4字符集，利用4个字节表示字符，一共可以表示近43亿个字符。每一个码位可以代表一个字符，可以不通过编码就直接显示出来。
4.3.1.3.5 UTF-8编码
UTF-8 是目前互联网上使用最广泛的一种 Unicode 编码方式，它的最大特点就是可变长。它可以使用 1 - 4 个字节表示一个字符，根据字符的不同变换长度。
UTF-8以字节为单位对Unicode进行编码。UTF-8的特点是对不同范围的字符使用不同长度的编码。对于0x00—0x7F之间的字符，UTF-8编码与 ASCII 编码完全相同。
对于需要使用 N 个字节来表示的字符(N > 1)，第一个字节的前 N 位都设为 1，第 N + 1 位设为0，剩余的 N - 1 个字节的前两位都设位 10，剩下的二进制位则使用这个字符的 Unicode 码点来填充。
4.3.1.3.6 ANSI编码
ANSI编码就是当地系统默认编码，在中国，ANSI编码默认为GBK。
4.3.1.4 Python中的编码、解码
Python3的字符串在Python内部的表示是unicode编码，因此在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码(decode)成unicode，再从unicode编码(encode)成另一种编码。
encode的作用是将unicode编码转换成其他编码的字符串，如str.encode(gbk)，表示将unicode编码的字符串str转换成gbk编码。
string = \'离离原上草，一岁一枯荣\'.encode(\'gbk\')
print(type(string))
print(string)
<class \'bytes\'>
b\'\\xc0\\xeb\\xc0\\xeb\\xd4\\xad\\xc9\\xcf\\xb2\\xdd\\xa3\\xac\\xd2\\xbb\\xcb\\xea\\xd2\\xbb\\xbf\\xdd\\xc8\\xd9\'
通过chardet.detect可以对编码进行检测
>>> print(chardet.detect(string))
{\'encoding\': \'GB2312\', \'confidence\': 0.7407407407407407, \'language\': \'Chinese\'}
decode的作用是将其他编码的字符串转换成unicode编码，如str.decode(gbk)，表示将gbk编码的字符串str转换成unicode编码。
string = \'离离原上草，一岁一枯荣\'.encode(\'gbk\')
print(string)
print(string.decode(\'gbk\'))
b\'\\xc0\\xeb\\xc0\\xeb\\xd4\\xad\\xc9\\xcf\\xb2\\xdd\\xa3\\xac\\xd2\\xbb\\xcb\\xea\\xd2\\xbb\\xbf\\xdd\\xc8\\xd9\'
离离原上草，一岁一枯荣
总结：想要将其他的编码转换成UTF-8必须先将其解码成unicode然后重新编码成UTF-8，它是以unicode为转换媒介的。如：s=\'中文\' 如果是在utf8的文件中，该字符串就是utf8编码，如果是在gb2312的文件中，则其编码为gb2312。这种情况下，要进行编码转换，都需要先用 decode方法将其转换成unicode编码，再使用encode方法将其转换成其他编码。
通常，在没有指定特定的编码方式时，都是使用系统默认编码创建的代码文件。
PS：为了方便理解和记忆，可以粗略的将编码理解为加密，解码理解为解密。编码(加密)之前的文本是能看懂的明文，但是编码(加密)之后就成了看不懂的密文(bytes类型)，不同的加密方式就对应不同的编码方式。只有通过对应的解码(解密)方式才能正确解密。
4.3.2 字符串的创建
4.3.2.1 通过字符串标识符创建
在Python中可以使用单引号（\'\'）或双引号（\"\"）来表示字符串，多行字符串可以使用三重引号 \'\'\' 或 \"\"\" 来表示。
\'hello，world\'
\"祝你好运~\"
\"\"\"
多行内容：
离离原上草，一岁一枯荣。
野火烧不尽，春风吹又生。
远芳侵古道，晴翠接荒城。
又送王孙去，萋萋满别情。
\"\"\"
注意：
1、在Python中，没有单个字符，只有字符串。单独的一个字符也是字符串。
2、Python中单引号和双引号单独使用完全相同。
4.3.2.2 字符串的拼接和重复
参见可迭代对象章节中的序列的拼接和重复
4.3.2.3 字符转义
如果我们需要定义的字符串中有引号，直接定义会报错：
>>> string = \'Let\'s go\'
Traceback (most recent call last):
File \"C:\\Program Files\\Python3102\\lib\\code.py\", line 63, in runsource
code = self.compile(source, filename, symbol)
File \"C:\\Program Files\\Python3102\\lib\\codeop.py\", line 185, in call
return _maybe_compile(self.compiler, source, filename, symbol)
File \"C:\\Program Files\\Python3102\\lib\\codeop.py\", line 102, in _maybe_compile
raise err1
File \"C:\\Program Files\\Python3102\\lib\\codeop.py\", line 91, in _maybe_compile
code1 = compiler(source + \"\\n\", filename, symbol)
File \"C:\\Program Files\\Python3102\\lib\\codeop.py\", line 150, in call
codeob = compile(source, filename, symbol, self.flags, True)
File \"\", line 1
string = \'Let\'s go\'
^
SyntaxError: unterminated string literal (detected at line 1)
这是因为定义字符串时，引号要两两配对，而在上面的字符串中出现了3个单引号，无法进行配对。这个时候我们可以用双引号进行定义字符串：
>>> string = \"Let\'s go\"
在定义字符串时，单引号和双引号都可以。字符串中有单独的双引号也同理。
一般的，我们在用双引号定义字符串时，字符串本身的内容中就不能包含双引号，而在用单引号定义字符串时，字符串本身的内容中就不能包含单引号。
但是，如果需要定义的字符串内容中既有单引号又有双引号该怎么办呢？有2种方法可以处理这种情况：
1、采用三引号定义，三单引号或双引号都行
2、采用字符转义
4.3.2.3.2 字符转义
字符转义就是用一个特定的符号对某个字符进行转义，让这个字符代表其它的意思。在Python中用\\对符号进行转义。常见转义字符如下：
| 转义字符 | 描述 | 显示效果 |
|---|---|---|
| \\ | 反斜杠符号 | \\ |
| \' | 单引号 | \' |
| \" | 双引号 | \" |
| \\b | 退格 | |
| \\n | 换行 | |
| \\t | 制表符 |
如果使用转义，则上面的示例可以用\'Let\'s go\'来表示。虽然单引号包裹的内容中含有单引号。但是也不会报错，因为字符串中的单引号用\\进行转义了。
4.3.2.4 字符串前缀
在Python3中，字符串的类型只有2种，分别是：str、bytes。在字符串前面可以加上前缀，产生不同的效果，比较常用的前缀有：r、u、b。
r：表示之后的字符串中的内容不进行转义，保持原样
u：表示之后的字符串为Unicode，在Python3中默认所有的字符串为此种类型。
b：表示之后的字符串为bytes类型
windows系统绝对路径会包含\\符号，如果在Python中要表示windows系统的路径经常会报错，因为会将路径中的\\及后面的字符当成转义符进行转义，对于日常使用非常不方便。这个时候就可以用到r前缀：
>>> print(\'C:\\new\\name\') # 这里的\\n代表换行，与预期不符
C:\\new
ame
>>> print(r\'C:\\new\\name\') # 字符串中的内容原样显示
C:\\some\\name
这样，上面的字符串中的\\n才不会当成换行符显示。而是保持原样。
4.3.3 字符串的访问
4.3.3.1 字符串索引
参见可迭代对象章节中的序列的索引
4.3.3.2 字符串切片
参见可迭代对象章节中的序列的切片
4.3.3.3 遍历字符串
参见可迭代对象章节中的可迭代对象的遍历
4.3.3.4 成员资格检查
参见可迭代对象章节中的成员资格检查
4.3.4 字符串的修改
Python 字符串不能修改，是可哈希的。因此，为字符串中某个索引位置赋值会报错：
>>> string = \'Python\'
>>> string[0] = \'J\'
Traceback (most recent call last):
File \"C:\\Program Files\\Python3102\\lib\\code.py\", line 90, in runcode
exec(code, self.locals)
File \"\", line 1, in
TypeError: \'str\' object does not support item assignment
要生成不同的字符串，应新建一个字符串：
>>> string = \'Python\'
>>> \'J\' + string[1:]
>>> string[:2] + \'py\'
\'Jython\'
\'Pypy\'
4.3.5 字符串的删除
由于字符串是可哈希的，因此无法删除字符串中的某个元素(字符)。要删除其中的某个元素(字符)也只能通过新建字符串的方式完成。
>>> string = \'Python\'
>>> str2 = string[:2] + string[3:]
>>> str2
\'Pyhon\'
4.3.6 字符串格式化
如果对字符串的输出的格式有要求，需要用到字符串的格式化。比如，在群发短信时，每次的名称不一样，但是内容是一样的，这个时候就需要用到字符串的格式化。
xx您好！这里是山东小红花集团...
4.3.6.1 %格式化
Python可以通过使用%占位符的方式来格式化字符串。例如：
>>> \'Hello, %s\' % \'world\'
>>> \'Hi, %s, you are %d years old.\' % (\'Yagami\', 16)
\'Hello, world\'
\'Hi, Yagami, you are 16 years old.\'
stars = (\"黎明\", \"华仔\", \"郭富城\", \"张学友\")
print(\"四大天王：%s, %s, %s, %s\" % stars)
四大天王：黎明, 华仔, 郭富城, 张学友
在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，后面变量的括号可以省略。
%格式化中常见的占位符：
| 占位符 | 替换内容 |
|---|---|
| %d | 整数 |
| %f | 浮点数 |
| %s | 字符串 |
| %x | 十六进制整数 |
其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：
print(\'%9d-%09d\' % (3, 1))
print(\'%.6f\' % 3.1415926)
3-0000000013.141593
如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：
>>> \'Age: %s. Gender: %s\' % (25, True)
\'Age: 25. Gender: True\'
关于自定义格式，将会在后面的自定义格式章节进行详细介绍。
使用%转义百分号
>>> \'growth rate: %d %%\' % 7
\'growth rate: 7 %\'
4.3.6.2 format
format是Python2.6开始新增的一种格式化字符串的函数，它会用传入的参数依次替换字符串内的占位符{0}、{1}……
使用方法：通过format函数中的参数来代替字符串中的{}内容。
指定位置
>>> \"{} {}\".format(\"hello\", \"world\") # 不设置指定位置，按默认顺序
>>> \"{1} {0} {1}\".format(\"hello\", \"world\") # 设置指定位置
\'hello world\'
\'world hello world\'
设置参数
>>> \"网站名：{name}, 地址：{url}\".format(name=\"本\", url=\"www.ben.com\")
\'网站名：本, 地址：www.ben.com\'
通过字典设置参数
>>> site = {\"name\": \"本\", \"url\": \"www.ben.com\"}
>>> \"网站名：{name}, 地址 {url}\".format(**site)
\'网站名：本, 地址：www.ben.com\'
通过列表索引设置参数
>>> my_list = [\'本\', \'www.ben.com\']
>>> \"网站名：{0[0]}, 地址 {0[1]}\".format(my_list) # \"0\" 是必须的
\'网站名：本, 地址：www.ben.com\'
使用{}转义大括号
>>> \"{} 对应的位置是 {{10}}\".format(\"ben\")
ben对应的位置是 {10}
你还可以指定要转换的值是哪种类型，更准确地说，是要将其视为哪种类型。例如，你可能提供一个整数，但将其作为小数进行处理。为此可在格式说明(即冒号后面)使用字符f(表示定点数)。
>>> \"π is {:.2f}\".format(3.1415926)
\'π is 3.14\'
关于自定义格式，将会在后面的自定义格式章节进行详细介绍。
4.3.6.1 f-string
f-string，亦称为格式化字符串常量(formatted string literals)，是Python3.6新引入的一种字符串格式化方法，该方法源于PEP 498 – Literal String Interpolation，主要目的是使格式化字符串的操作更加简便。f-string在形式上是以 f 或 F 修饰符引领的字符串(f\'xxx\' 或 F\'xxx\')，以大括号 {} 标明被替换的字段；f-string在本质上并不是字符串常量，而是一个在运行时运算求值的表达式。
f-string在功能方面不逊于传统的%-formatting语句和str.format()函数，同时性能又优于二者，且使用起来也更加简洁明了，因此对于Python3.6及以后的版本，推荐使用f-string进行字符串格式化。
简单使用
f-string用大括号 {} 表示被替换字段，其中直接填入替换内容：
>>> name = \'Eric\'
>>> f\'Hello, my name is {name}\'
\'Hello, my name is Eric\'
>>> number = 7
>>> f\'My lucky number is {number}\'
\'My lucky number is 7\'
>>> price = 19.99
>>> f\'The price of this book is {price}\'
\'The price of this book is 19.99\'
表达式求值与函数调用
f-string的大括号 {} 可以填入表达式或调用函数，Python会求出其结果并填入返回的字符串内：
>>> f\'A total number of {24 * 8 + 4}\'
\'A total number of 196\'
>>> f\'Complex number {(2 + 2j) /(2 - 3j)}\'
\'Complex number(-0.15384615384615388+0.7692307692307692j)\'
>>> name = \'ERIC\'
>>> f\'My name is {name.lower()}\'
\'My name is eric\'
>>> import math
>>> f\'The answer is {math.log(math.pi)}\'
\'The answer is 1.1447298858494002\'
引号、大括号与反斜杠
f-string大括号内所用的引号不能和大括号外的引号定界符冲突，可根据情况灵活切换 \' 和 \"：
>>> f\'I am {\"Eric\"}\'
\'I am Eric\'
>>> f\'I am {\'Eric\'}\'
File \"<stdin>\", line 1 f\'I am {\'Eric\'}\' ^SyntaxError: invalid syntax
若 \' 和 \" 不足以满足要求，还可以使用 \'\'\' 和 \"\"\"。
大括号外的引号还可以使用 \\ 转义，但大括号内不能使用 \\ 转义：
>>> f\'\'\'He\'ll say {\"I\'m Eric\"}\'\'\'
\"He\'ll say I\'m Eric\"
>>> f\'\'\'He\'ll say {\"I\'m Eric\"}\'\'\'
File \"<stdin>\", line 1SyntaxError: f-string expression part cannot include a backslash
f-string大括号外如果需要显示大括号，则应输入连续两个大括号 {{ 和 }}：
>>> f\'5 {\"{stars}\"}\'
>>> f\'{{5}} {\"stars\"}\'
\'5 {stars}\'
\'{5} stars\'
上面提到，f-string大括号内不能使用 \\ 转义，事实上不仅如此，f-string大括号内根本就不允许出现 \\。如果确实需要 \\，则应首先将包含 \\ 的内容用一个变量表示，再在f-string大括号内填入变量名。
4.3.6.2 自定义格式
通过对上述3种格式化字符串的方法的学习，我们可以大致的了解在格式化字符串中用到的自定义格式。
这3种格式化字符串的方法中都可以用到自定义格式，方法也大同小异。下面就详细的来介绍下如何自定义格式。
主要包括：对齐、宽度、符号、补零、精度、进制等
4.3.6.2.1 对齐相关
< 左对齐(字符串默认对齐方式)，&格式化使用-
右对齐(数值默认对齐方式) ，
&格式化使用+
^ 居中，适用于f-string和format
var1 = \'python\'
var2 = -3.1415
print(f\'|{var1:>10}|\')
print(\'|{:^10}|\'.format(var2))
print(\'|%+10s|\' % var1)
print(\'|%-10s|\' % var2)
| python|
| -3.1415 |
| python|
|-3.1415 |
4.3.6.2.2 数字符号相关格式描述符
-
负数前加负号(-)，正数前加正号(+)
-
负数前加负号(-)，正数前不加任何符号(默认)
空格 负数前加负号(-)，正数前加一个空格
注：仅适用于数值类型。
var1 = 3.14
var2 = -4.13
print(f\'|{var1:+}|\')
print(\'|{:-}|\'.format(var2))
print(\'|{: }|\'.format(var1))
print(\'|%+s|\' % var1)
|+3.14|
|-4.13|
| 3.14|
|3.14|
4.3.6.2.3 宽度与精度相关格式描述符
width 整数 width 指定宽度
0width 整数 width 指定宽度，开头的 0 指定高位用 0 补足宽度
width.precision 整数 width 指定宽度，整数 precision 指定显示精度
注意：
1、0width 不可用于复数类型和非数值类型，width.precision 不可用于整数类型。
2、width.precision 用于不同格式类型的浮点数、复数时的含义也不同：用于 f、F、e、E 和 % 时 precision 指定的是小数点后的位数，用于 g 和 G 时 precision 指定的是有效数字位数(小数点前位数+小数点后位数)。
3、width.precision 除浮点数、复数外还可用于字符串，此时 precision 含义是只使用字符串中前 precision 位字符。
var1 = 3.1415
print(f\'|{var1:8}|\')
print(\'|{:8.3}|\'.format(var1))
print(\'|{:.4}|\'.format(var1))
print(\'|%10.5s|\' % var1)
| 3.1415|
| 3.14|
|3.142|
| 3.141|
4.3.6.2.4 千位分隔符相关格式描述符
, 使用,作为千位分隔符
_ 使用_作为千位分隔符
注意：
1、若不指定 , 或 ，则f-string不使用任何千位分隔符，此为默认设置。
2、仅适用于浮点数、复数与十进制整数：对于浮点数和复数，, 只分隔小数点前的数位。
3、 适用于浮点数、复数与二、八、十、十六进制整数：对于浮点数和复数，_ 只分隔小数点前的数位；对于二、八、十六进制整数，固定从低位到高位每隔四位插入一个 _(十进制整数是每隔三位插入一个 _)。
var1 = 31415
print(f\'|{var1:_}|\')
print(\'|{:,}|\'.format(var1))
print(\'|%,s|\' % var1) # 不适用
|31_415|
|31,415|
Traceback (most recent call last):
File \"E:\\studypy\\tmp.py\", line 4, in
print(\'|%s|\' % var1)
ValueError: unsupported format character \'\' (0x5f) at index 2
4.3.6.2.5 格式类型相关格式描述符
格式描述符 含义与作用 适用变量类型
s 普通字符串格式 字符串
b 二进制整数格式 整数
c 字符格式，按unicode编码将整数转换为对应字符 整数
d 十进制整数格式 整数
o 八进制整数格式 整数
x 十六进制整数格式(小写字母) 整数
X 十六进制整数格式(大写字母) 整数
e 科学计数格式，以 e 表示 ×10^ 浮点数、复数、整数(自动转换为浮点数)
E 与 e 等价，但以 E 表示 ×10^ 浮点数、复数、整数(自动转换为浮点数)
f 定点数格式，默认精度(precision)是6 浮点数、复数、整数(自动转换为浮点数)
F 与 f 等价，但将 nan 和 inf 换成 NAN 和 INF 浮点数、复数、整数(自动转换为浮点数)
g 通用格式，小数用 f，大数用 e 浮点数、复数、整数(自动转换为浮点数)
G 与 G 等价，但小数用 F，大数用 E 浮点数、复数、整数(自动转换为浮点数)
% 百分比格式，数字自动乘上100后按 f 格式排版，并加 % 后缀 浮点数、整数(自动转换为浮点数)
4.3.7 字符串的方法
4.3.7.1 编码解码类
4.3.7.1.1 encode(encoding=\'UTF-8\',errors=\'strict\')
描述
对指定的字符串进行编码。编码后的返回结果是bytes类型。
errors参数用来设置不同错误的处理方案。默认为 \'strict\',意为编码错误引起一个UnicodeError。其他可能得值有 \'ignore\', \'replace\', \'xmlcharrefreplace\', \'backslashreplace\'
示例
s1 = \'ab甲乙\'
s2 = s1.encode(encoding=\'utf-8\')
print(s2)
b\'ab\\xe7\\x94\\xb2\\xe4\\xb9\\x99\'
4.3.7.1.2 decode(encoding=\"utf-8\", errors=\"strict\")
描述
对bytes对象的进行解码。解码后的返回结果为str类型。
errors参数用来设置不同错误的处理方案。默认为 \'strict\',意为编码错误引起一个UnicodeError。 其他可能得值有 \'ignore\', \'replace\', \'xmlcharrefreplace\', \'backslashreplace\'
示例
s1 = \'ab甲乙\'
s2 = s1.encode(encoding=\'utf-8\')
print(s2)
s3 = s2.decode(encoding=\'utf-8\')
print(s3)
b\'ab\\xe7\\x94\\xb2\\xe4\\xb9\\x99\'
ab甲乙
4.3.7.2 查找统计类
4.3.7.2.1 count
参见可迭代对象章节中序列小节中的序列count方法
4.3.7.2.2 find(str, beg=0, end=len(string))、rfind
描述
返回str在string里面出现的索引。未找到则返回-1。rfind表示从右边开始查找。
beg参数和end参数代表查找的范围，默认在整个str中查找。
示例
s = \' Python tian \\t mao \\n taobao \'
print(s.find(\'o\'))
print(s.find(\'ao\'))
print(s.find(\'io\'))
5
16
-1
4.3.7.2.3 index、rindex
可参见可迭代对象章节中序列小节中的序列index方法
4.3.7.3 格式化类
4.3.7.3.1 center(width, fillchar)
描述
返回一个指定的宽度width居中的字符串，fillchar为填充的字符，默认为空格。
示例
s = \' Python tian \\t mao taobao \'
print(f\"|{s.center(30)}|\")
print(f\"|{s.center(30, \'*\')}|\")
| Python tian mao taobao |
|** Python tian mao taobao **|
4.3.7.3.2 ljust(width[, fillchar])、rjust
描述
返回一个原字符串左(右)对齐，并使用fillchar填充至长度width的新字符串，fillchar默认为空格。
示例
s = \' Python tian \\t mao taobao \'
print(f\"|{s.ljust(30)}|\")
print(f\"|{s.ljust(30, \'*\')}|\")
| Python tian mao taobao |
| Python tian mao taobao ****|
4.3.7.3.3 zfill(width)
描述
返回长度为width的字符串，原字符串右对齐，前面填充0
示例
s = \' Python tian \\t mao taobao \'
print(f\"|{s.zfill(30)}|\")
|0000 Python tian mao taobao |
4.3.7.4 合并截取类
4.3.7.4.1 join(seq)
描述
以指定字符串作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串。
示例
seq = [\'a\', \'b\', \'c\']
s = \'*\'.join(seq)
print(s)
abc
4.3.7.4.2 lstrip()、rstrip()
描述
截掉字符串左边(右边)的空格或指定字符。
示例
s = \' Python tian \\t mao taobao \'
print(f\"|{s.lstrip()}|\")
print(f\"|{s.rstrip()}|\")
print(f\"|{s.rstrip(\'ao \')}|\")
|Python tian mao taobao |
| Python tian mao taobao|
| Python tian mao taob|
4.3.7.4.3 split(str=\"\", num=string.count(str))
描述
以str为分隔符截取字符串。默认为空格、换行、制表符等。如果 num 有指定值，则仅截取 num+1 个子字符串
示例
s = \' Python tian \\t mao \\n taobao \'
print(f\"|{s.split()}|\")
print(f\"|{s.split(\'o\')}|\")
|[\'Python\', \'tian\', \'mao\', \'taobao\']|
|[\' Pyth\', \'n tian \\t ma\', \' \\n ta\', \'ba\', \' \']|
4.3.7.4.4 splitlines([keepends])
描述
按照行(\'\\r\',\'\\r\\n\',\\n\')分隔，返回一个包含各行作为元素的列表，如果参数keepends为False，不包含换行符，如果为True，则保留换行符。
示例
s = \' Python tian \\t mao \\n taobao \'
print(f\"|{s.splitlines()}|\")
print(f\"|{s.splitlines(True)}|\")
|[\' Python tian \\t mao \', \' taobao \']|
|[\' Python tian \\t mao \\n\', \' taobao \']|
4.3.7.4.5 strip([chars])
描述
在字符串上同时执行lstrip()和rstrip()
示例
s = \' Python tian \\t mao taobao \'
print(f\"|{s.strip()}|\")
print(f\"|{s.strip(\'ao \')}|\")
|Python tian mao taobao|
|Python tian mao taob|
4.3.7.5 判断类
4.3.7.5.1 startswith(substr, beg=0,end=len(string))、endswith
描述
检查字符串是否是以指定子字符串substr开头，是则返回True，否则返回False。如果beg 和 end 指定值，则在指定范围内检查。
示例
s = \' Python tian \\t mao taobao \'
print(f\"|{s.startswith(\' \')}|\")
print(f\"|{s.endswith(\'a\')}|\")
|True|
|False|
4.3.7.5.2 islower()、isupper()
描述
如果字符串中有可以区分大小写的字符，并且都是小写(大写)，则返回True，否则返回False
示例
s = \' python tian \\t mao 赛车12 \'
print(f\"|{s.islower()}|\")
print(f\"|{s.isupper()}|\")
|True|
|False|
4.3.7.5.3 isalnum()
描述
如果字符串仅包含字母和数字，则返回True，否则返回False。
示例
s1 = \'python 赛车12\'
print(f\"|{s1.isalnum()}|\")
s2 = \'python 12\'
print(f\"|{s2.isalnum()}|\")
s3 = \'python12\'
print(f\"|{s3.isalnum()}|\")
|False|
|False|
|True|
4.3.7.5.4 isalpha()
描述
如果字符串仅包含字母和文字(中文、日文等)，则返回True，否则返回False。
示例
s1 = \'python 赛车12\'
print(f\"|{s1.isalpha()}|\")
s2 = \'python 12\'
print(f\"|{s2.isalpha()}|\")
s3 = \'python12\'
print(f\"|{s3.isalpha()}|\")
s4 = \'python赛车\'
print(f\"|{s4.isalpha()}|\")
s5 = \'こんにちは\'
print(f\"|{s5.isalpha()}|\")
|False|
|False|
|False|
|True|
|False|
4.3.7.5.5 isdecimal()
描述
检查字符串是否只包含十进制字符，如果是返回true，否则返回false。
示例
s = \'python 赛车12\'
print(f\"|{s.isdecimal()}|\")
s = \'p12\'
print(f\"|{s.isdecimal()}|\")
s = \'12\'
print(f\"|{s.isdecimal()}|\")
s = \'0x12\'
print(f\"|{s.isdecimal()}|\")
|False|
|False|
|True|
|False|
4.3.7.5.6 isdigit()、isnumeric()
描述
如果字符串中仅包含数字，则返回True，否则返回False。
4.3.7.5.7 isspace()
描述
如果字符串中仅包含空格，则返回True，否则返回False。
4.3.7.5.8 istitle()
描述
如果字符串中的单词全都是title格式(首字母大写)，则返回True，否则返回False。
4.3.7.6 转换类
4.3.7.6.1 capitalize()
描述
仅将字符串的第一个字符转换为大写。如果第一个不是字母，则不做操作。
示例
s = \' python Tian 赛车12 \'
print(f\"|{s.capitalize()}|\")
s = \'python Tian 赛车12 \'
print(f\"|{s.capitalize()}|\")
| python tian 赛车12 |
|Python tian 赛车12 |
4.3.7.6.2 lower()、upper()
描述
将字符串中的小写(大写)字母全部转换成大写(小写)字母
示例
s = \' pyTHon Tian 赛车12 \'
print(f\"|{s.lower()}|\")
s = \'python Tian 赛车12 \'
print(f\"|{s.upper()}|\")
| python tian 赛车12 |
|PYTHON TIAN 赛车12 |
4.3.7.6.3 replace(old, new [, max])
描述
把将字符串中的old替换成new,如果max指定，则替换不超过max次。
示例
s = \' pyTHon Tian 赛车12 \'
print(f\"|{s.replace(\'T\',\'*\')}|\")
print(f\"|{s.replace(\'T\',\'*\', 1)}|\")
print(f\"|{s.replace(\'Ti\',\'/\', 1)}|\")
| py*Hon ian 赛车12 |
| pyHon Tian 赛车12 |
| pyTHon /an 赛车12 |
4.3.7.6.4 title()
描述
返回标题化的字符串,就是说所有单词都是以大写开始，其余字母均为小写。
4.3.7.6.5 expandtabs(tabsize)
描述
把字符串string中的tab符号转为空格，tab符号默认的空格数是8。
示例
s = \'\\tTian 赛车12 \'
print(f\"|{s}|\")
print(f\"|{s.expandtabs()}|\")
print(f\"|{s.expandtabs(2)}|\")
| Tian 赛车12 |
| Tian 赛车12 |
| Tian 赛车12 |
4.3.7.6.6 swapcase()
描述
将字符串中大写转换为小写，小写转换为大写。
4.3.7.6.7 maketrans()、translate(table, deletechars=\"\")
描述
maketrans用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
translate则根据table给出的表(包含256个字符)转换string的字符。
这两个方法组合可以方便快速的对字符串多个字符进行替换。
示例
s = \' python Tian 赛车12 \'
x = \"yo\"
y = \"ab\"
z = \"车\" # 设置删除的字符
mytable = s.maketrans(x, y, z)
print(mytable)
print(s.translate(mytable))
{121: 97, 111: 98, 36710: None}
pathbn Tian 赛12
从自动化办公到智能化办公
来源：https://www.cnblogs.com/sibide/p/16390595.html
本站部分图文来源于网络，如有侵权请联系删除。