字符串(str、bytes)

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))

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-000000001

3.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对应的位置是

你还可以指定要转换的值是哪种类型，更准确地说，是要将其视为哪种类型。例如，你可能提供一个整数，但将其作为小数进行处理。为此可在格式说明(即冒号后面)使用字符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 1

SyntaxError: 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