- Unicode简介
- 字符串基础
- 字符串字面量
- 实际应用中的字符串
- 字符串方法
- 字符串格式化
简单的说,ASCII是Unicode文本的一种简单形式，但只是众多可能的编码和字母表中的一种
-
在Python3.X中，有三种字符串类型：str用于Unicode文本（包括ASCII），bytes用于二进制数据（包括已编码的文本），而bytearray是bytes的一个可修改的变体。
-
在Python2.X中，unicode字符串表示Unicode文本，str字符串同时处理8位文本和二进制数据，而bytearray从3.X向后移植，在Python2.6和随后版本中可用。普通文件的内容是str直接表示的字节，但是codecs模块打开Unicode文本文件，处理编码，并将内容作为unicode对象表示。
字符串可以用来表示能够编码为文本或字节的任何事物。这样的文本包含符号和词语、载入到内存中的文本文件的内容、Internet网址和Python源代码等。字符串可以用来保持用于媒体文件和网络传输的原始字节，还有国际化程序中使用的编码和解码形式的非ASCII Unicode文本。
Python的字符串被划分为不可变序列这一类别，意味着这些字符串所包含的字符存在从左至右的位置顺序，并且它们不可以在原始位置修改。
| 操作 | 解释 |
|---|---|
| S = '' | 空字符串 |
| S = "spam's" | 双引号 |
| S = 'S\np\ta\n\x00m' | 转义序列 |
| S = """...multiline...""" | 三引号字符串 |
| S = r'\temp\spam' | 不进行转义的原始字符串 |
| B = b'sp\xc4m' | 字节串 |
| U = u'sp\xc4m' | Unicode字符串 |
| S1 +S2 | 拼接 |
| S*3 | 重复 |
| S[i] | 索引 |
| S[i:j] | 分片 |
| len(S) | 长度 |
| "a %s parrot" % kind | C风格字符串格式化表达式 |
| "a {0} parrot".format(kind) | 字符串格式化表达式 |
| S.find() | 查找 |
| S.rstrip() | 移除右侧空白 |
| S.replace('src', 'dest') | 替换 |
| S.split(',') | 用分隔符分组 |
| S.isdigit() | 内容测试 |
| S.lower() | 大小写转换 |
| S.endwith('spam') | 尾部测试 |
| 'spam'.join(strlist) | 分隔符连接 |
| S.encode('latin-1') | Unicode编码 |
| B.decode('utf-8') | Unicode解码 |
| for i in S: print(i) | 迭代 |
| 'spam' in S | 成员关系 |
| [c*2 for c in S] | 推导式 |
| map(ord, S) | ord返回单个字符的ASCII序列 |
| re.match('sp(.*)am', line) | 模式匹配 |
Python的字符串用起来还是挺简单的，也许最复杂的事情就是有入场多的方法可以使用
- 单引号：
'sp"am' - 双引号：
"sp'am" - 三引号：
""".."'t,est""" - 转义序列：
"s\tp\na\0m" - 原始字符串：
r"C:\new\test.spm" - 字节字面量：
b'sp\x01am' - Unicode字面量：
u'eggs\u0020spam'
单引号和双引号的形式是目前最常见的，其他的形式都是服务于特定场景的。
字符串字面量可以包围在两个单引号和两个双引号之中---两种形式同样有效，并返回相同类型的对象：
>>> 'shrubbery',"shrubbery"
('shrubbery', 'shrubbery')虽然两种形式都可以。但这里推荐在字符串周围使用单引号，只是因为它阅读起来稍微简单，这是一项纯粹主观的风格，但Python也以这种方式显示字符串，所以这里推荐使用单引号
反斜杠用来引入特殊的字符编码，称为转义序列
转义序列让我们能够在字符串中嵌入不容易通过键盘输入的字符。字符\以及字符串字面量中在它后面的一个或多个字符，在生成的字符串对象中会被单个字符所替代，这个字符拥有通过转义序列定义的二进制值。例如，下面有一个五字符的字符串，其中嵌入了一个换行符和制表符：
>>> s = 'a\nb\tc'其中两个字符\n表示单个字符---换行符；\t表示单个字符---制表符。这个字符串打印时的格式取决于打印的方式。交互模式下是以转义序列的形式回显的，但print会将其解释出来：
>>> s
'a\nb\tc'
>>> print(s)
a
b c为了清楚的了解这个字符串中到底有多少个实际的字符，使用len函数---它会返回一个字符串中字符的实际数量，无论该字符传是如何编码或显示的：
>>> len(s)
5| 转义字符 | 说明 |
|---|---|
| \n | 换行符，将光标位置移到下一行开头。 |
| \r | 回车符，将光标位置移到本行开头。 |
| \t | 水平制表符，也即 Tab 键，一般相当于四个空格。 |
| \a | 蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。 |
| \b | 退格（Backspace），将光标位置移到前一列。 |
| \\ | 反斜线 |
| \' | 单引号 |
| \" | 双引号 |
| \ | 在字符串行尾的续行符，即一行未完，转到下一行继续写。 |
myfile = open('C:\new\text.txt', 'w')本来的目的是打开C:\new目录下名为text.txt文件。但这里存在\n和\t,所以要使用r前缀进行阻止转义或使用\来转义\
>>> path1 = r'C:\new\text.txt'
>>> path2 = 'C:\\new\\text.txt'
>>> path1
'C:\\new\\text.txt'
>>> path2
'C:\\new\\text.txt'
>>> len(path1), len(path2)
(15, 15)这种形式以三个引号开始（单引号和双引号都可以），并紧跟任意行数的文本，并且以与开始相同的三个引号结尾
>>> multilines = """Always look
... on the bright
... side of life."""
>>> multilines
'Always look\n\ton the bright\nside of life.'字符串被定义为字符的有序集合，所以字符串支持索引操作。就像在C语言中一样，Python偏移量是从0开始的，并且比字符串的长度小1的偏移量结束。与C语言不同的是，Python还支持负偏移量，从类似字符串这样的序列中获取元素。
>>> s = 'abcdefg'
>>> s[0]
'a'
>>> s[1]
'b'
>>> s[-1]
'g'序列也支持切片（slice）操作，这是一种一步就能够提取整个分片的方法，例如
>>> S
'spam'
>>> S[0:2]
'sp'
切片是左闭右开原则
在一个分片中，左边界默认为0，并且右边界默认为分片序列的长度。这引入了一些常用方法:
>>> S
'spam'
>>> S[1:]
'pam'
>>> S[0:3]
'spa'
>>> S[:-1]
'spa'
>>> S[:]
'spam'
>>> S[::-1]
'maps'
Python设计的座右铭之一就是拒绝猜测。作为强类型语言，不能隐式的将字符串与数字相加
>>> '42' + 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str这是有意设计的，因为+既能进行加法运算也能够进行拼接操纵，这种转换的选择会变得模棱两可。因此Python将其作为错误处理。
int可以将字符串转为数字、str将数字转为字符串
>>> s = '42'
>>> i = 1
>>> type(s), type(int(s))
(<class 'str'>, <class 'int'>)
>>> type(i), type(str(i))
(<class 'int'>, <class 'str'>)可以将字符转换为其底层的整数码（ASCII字节值），通过内置的ord函数来实现---返回用来表示内存中相应字符的实际二进制值。
而chr函数将会执行相反操作，获取整数码并将其转化为对应的字符
>>> ord('s')
115
>>> chr(115)
's'技术上讲，这两者都可以在字符和它们的Unicode序数或”码点“之间相互转换。Unicode序数只是它们在底层字符集中的识别数字。对于ASCII文本，码点是熟悉的7位整数，可用内存中的单个字节存储。
>>> "".join("abcde")
'abcde'
>>> ":".join("abcde")
'a:b:c:d:e'
>>> a = list('abcde')
>>> a
['a', 'b', 'c', 'd', 'e']
>>> ":".join(a)
'a:b:c:d:e'
>>> ":".join(['abcde'])
'abcde'除表达式运算符意外，字符串还提供了一系列实现复杂的文本处理任务的方法，在Python中，表达式和内置函数可用在不同的类型之间工作，但方法通常特定于对象类型，如字符串方法只在字符串类型的对象上起作用。
-
属性获取
具有object.attribute形式的表达式可用理解为”获取对象object中attribute属性的值“
-
调用表达式
具有function(arguments)形式的表达式可以理解为：”调用函数function的代码，向其传递零个或多个逗号分隔的参数argument对象，并且返回函数的返回值“
合并两者可以调用一个对象方法，调用表达式为
object.attribute(arguments)示例如下：
>>> 'abcde'.find('a')
0通过指定分隔符对字符串进行切片，默认使用空白字符分割，立即返回一个列表
返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。
如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 '1,,2'.split(',') 将返回 ['1', '', '2'])。 sep 参数可能由多个字符组成 (例如 '1<>2<>3'.split('<>') 将返回 ['1', '2', '3'])。 使用指定的分隔符拆分空字符串将返回 ['']。
例如:
>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']
如果 sep 未指定或为 None，则会应用另一种拆分算法：连续的空格会被视为单个分隔符，其结果将不包含开头或末尾的空字符串，如果字符串包含前缀或后缀空格的话。 因此，使用 None 拆分空字符串或仅包含空格的字符串将返回 []。
例如:
>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> ' 1 2 3 '.split()
['1', '2', '3']
按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值
此方法会以下列行边界进行拆分。
| 表示符 | 描述 |
|---|---|
\n |
换行 |
\r |
回车 |
\r\n |
回车 + 换行 |
\v 或 \x0b |
行制表符 |
\f 或 \x0c |
换表单 |
\x1c |
文件分隔符 |
\x1d |
组分隔符 |
\x1e |
记录分隔符 |
\x85 |
下一行 (C1 控制码) |
\u2028 |
行分隔符 |
\u2029 |
段分隔符 |
在 3.2 版更改: \v 和 \f 被添加到行边界列表
例如:
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']不同于 split()，当给出了分隔字符串 sep 时，对于空字符串此方法将返回一个空列表，而末尾的换行不会令结果中增加额外的行:
>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']作为比较，split('\n') 的结果为:
>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。
>>> 'abc1abc1abc1'.partition('1')
('abc', '1', 'abc1abc1')
>>> 'abc1abc1abc1'.partition('2')
('abc1abc1abc1', '', '')在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。
>>> 'abc1abc1abc1'.rpartition('1')
('abc1abc1abc', '1', '')
>>> 'abc1abc1abc1'.rpartition('2')
('', '', 'abc1abc1abc1')返回原字符串的副本，其所有区分大小写的字符均转换为小写。
>>> 'ABcd'.lower()
'abcd'返回原字符串的副本，其中所有区分大小写的字符均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。
>>> 'AbCd'.upper()
'ABCD'返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。
>>> 'abCD'.swapcase()
'ABcd'返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。
例如:
>>> 'Hello world'.title()
'Hello World'该算法使用一种简单的与语言无关的定义，将连续的字母组合视为单词。 该定义在多数情况下都很有效，但它也意味着代表缩写形式与所有格的撇号也会成为单词边界，这可能导致不希望的结果:
>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"可以使用正则表达式来构建针对撇号的特别处理:
>>> import re
>>> def titlecase(s):
... return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
... lambda mo: mo.group(0).capitalize(),
... s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."返回原字符串的副本，其首个字符大写，其余为小写。
在 3.8 版更改: 第一个字符现在被放入了 titlecase 而不是 uppercase。 这意味着复合字母类字符将只有首个字母改为大写，而再不是全部字符大写。
>>> 'pleaseaskmewhy'.capitalize()
'Pleaseaskmewhy'
>>> 'please ask me why'.capitalize()
'Please ask me why'返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。
>>> "abc".center(10)
' abc '
>>> "abc".center(10, '+')
'+++abc++++'
>>> "abc".center(1)
'abc'返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。 正负值前缀 ('+'/'-') 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。
例如:
>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
>>> 'abc'.ljust(10,'#')
'abc#######'返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
>>> 'abc'.rjust(10,'#')
'#######abc'返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。
>>> 'abcabcabc'.replace('a','A')
'AbcAbcAbc'
>>> 'abcabcabc'.replace('a','A',2)
'AbcAbcabc'返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:
>>> ' spacious '.rstrip()
' spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'
要删除单个后缀字符串，而不是全部给定集合中的字符，请参见 str.removesuffix() 方法。 例如:
>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'
返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:
>>> ' spacious '.lstrip()
'spacious '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'参见 str.removeprefix() ，该方法将删除单个前缀字符串，而不是全部给定集合中的字符。 例如:
>>> 'Arthur: three!'.lstrip('Arthur: ')
'ee!'
>>> 'Arthur: three!'.removeprefix('Arthur: ')
'three!'返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合:
>>> ' spacious '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'最外侧的前导和末尾 chars 参数值将从字符串中移除。 开头端的字符的移除将在遇到一个未包含于 chars 所指定字符集的字符时停止。 类似的操作也将在结尾端发生。 例如:
>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'如果字符串以 后缀 字符串结尾，并且 后缀 非空，返回 string[:-len(suffix)] 。否则，返回原始字符串的副本：
>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'如果字符串以 前缀 字符串开头，返回 string[len(prefix):] 。否则，返回原始字符串的副本：
>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。
>>> a = 'hello'*5
>>> a
'hellohellohellohellohello'
>>> a.count('hello')
5返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。
>>> 'hello'.find('h')
0
>>> 'hello'.find('a')
-1find() 方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，请使用 in 操作符:
>>> 'Py' in 'Python'
True
返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。
>>> 'hello'.rfind('l')
3类似于 find()，但在找不到子类时会引发 ValueError
>>> 'hello'.index('l')
2
>>> 'hello'.index('a')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。
>>> 'hello'.index('l')
2
>>> 'hello'.rindex('l')
3如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
>>> 'abc'.startswith('a')
True
>>> 'abcdef'.startswith('b',1,2)
True如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
>>> 'abcdef'.endswith('f')
True
>>> 'abcdef'.endswith('cd',2,4)
Truestartswith 和 endswith 起始位置都是前包后不包
如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True ， 否则返回 False 。 如果 c.isalpha() ， c.isdecimal() ， c.isdigit() ，或 c.isnumeric() 之中有一个返回 True ，则字符c是字母或数字。
>>> ''.isalnum()
False
>>> '3544'.isalnum()
True如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False 。字母字符是指那些在 Unicode 字符数据库中定义为 "Letter" 的字符，即那些具有 "Lm"、"Lt"、"Lu"、"Ll" 或 "Lo" 之一的通用类别属性的字符。 注意，这与 Unicode 标准中定义的"字母"属性不同。
>>> 'abc'.isalpha()
True
>>> 'abc3'.isalpha()
False
>>> ''.isalpha()
False如果字符串为空或字符串中的所有字符都是 ASCII ，返回 True ，否则返回 False 。ASCII 字符的码点范围是 U+0000-U+007F 。3.7 新版功能.
如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 True ， 否则返回 False 。十进制字符指那些可以用来组成10进制数字的字符，例如 U+0660 ，即阿拉伯字母数字0 。 严格地讲，十进制字符是 Unicode 通用类别 "Nd" 中的一个字符。
>>> '3424'.isdecimal()
True
>>> '0b1010'.isdecimal()
False如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False 。 数字包括十进制字符和需要特殊处理的数字，如兼容性上标数字。这包括了不能用来组成 10 进制数的数字，如 Kharosthi 数。 严格地讲，数字是指属性值为 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。
>>> '0b1010'.isdigit()
False
>>> '3424'.isdigit()
True如果字符串是有效的标识符，返回 True ，依据语言定义， 标识符和关键字节。调用 keyword.iskeyword()来检测字符串 s是否为保留标识符，例如def和class。示例：>>>>>> from keyword import iskeyword >>> 'hello'.isidentifier(), iskeyword('hello') True, False >>> 'def'.isidentifier(), iskeyword('def') True, True `
>>> 'for'.isidentifier()
True
>>> '2_f'.isidentifier()
False如果字符串中至少有一个区分大小写的字符 且此类字符均为小写则返回 True ，否则返回 False 。
>>> 'abc'.islower()
True
>>> 'Abc'.islower()
False如果字符串中至少有一个字符且所有字符均为数值字符则返回 True ，否则返回 False 。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定义为：数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。
如果字符串中所有字符均为可打印字符或字符串为空则返回 True ，否则返回 False 。 不可打印字符是在 Unicode 字符数据库中被定义为 "Other" 或 "Separator" 的字符，例外情况是 ASCII 空格字符 (0x20) 被视作可打印字符。 （请注意在此语境下可打印字符是指当对一个字符串发起调用 repr()时不必被转义的字符。 它们与字符串写入 sys.stdout或 sys.stderr 时所需的处理无关。）
如果字符串中只有空白字符且至少有一个字符则返回 True ，否则返回 False 。空白 字符是指在 Unicode 字符数据库 (参见 unicodedata) 中主要类别为 Zs ("Separator, space") 或所属双向类为 WS, B 或 S 的字符。
>>> ''.isspace()
False
>>> ' '.isspace()
True
>>> '\t'.isspace()
True如果字符串中至少有一个字符且为标题字符串则返回 True ，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回 False 。
>>> 'Hello World'.istitle()
True
>>> 'Hello world'.istitle()
False
>>> 'Hello_world'.istitle()
False
>>> 'Hello_World'.istitle()
True如果字符串中至少有一个区分大小写的字符 4 且此类字符均为大写则返回 True ，否则返回 False 。>>>>>> 'BANANA'.isupper() True >>> 'banana'.isupper() False >>> 'baNana'.isupper() False >>> ' '.isupper() False
>>> 'ANC'.isupper()
True返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError 调用该方法的字符串将作为元素之间的分隔。
>>> "#".join('abcde')
'a#b#c#d#e'返回原字符串编码为字节串对象的版本。 默认编码为 'utf-8'。 可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。 其他可用的值为 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及任何其他通过 codecs.register_error()注册的值。
errors 参数默认不会被检查，以获得最佳性能，而只在第一次编码错误时使用。启用 Python 开发模式 ，或者使用调试构建来检查 errors
在 3.1 版更改: 加入了对关键字参数的支持。
在 3.9 版更改: errors 现在在开发模式和调试模式下都会被检查。
>>> 'abc'.encode()
b'abc'
>>> '啊'.encode()
b'\xe5\x95\x8a'返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping或 sequence。 当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。
字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便
此处介绍的格式化操作具有多种怪异特性，可能导致许多常见错误（例如无法正确显示元组和字典）。
字符串具有一种特殊的内置操作：使用 % (取模) 运算符。 这也被称为字符串的 格式化 或 插值 运算符。 对于 format % values (其中 format 为一个字符串)，在 format 中的 % 转换标记符将被替换为零个或多个 values 条目。 其效果类似于在 C 语言中使用 sprintf()。
如果 format 要求一个单独参数，则 values 可以为一个非元组对象，否则的话，values 必须或者是一个包含项数与格式字符串中指定的转换符项数相同的元组，或者是一个单独映射对象（例如字典）。
转换标记符包含两个或更多字符并具有以下组成，且必须遵循此处规定的顺序：
'%'字符，用于标记转换符的起始。- 映射键（可选），由加圆括号的字符序列组成 (例如
(somename))。 - 转换旗标（可选），用于影响某些转换类型的结果。
- 最小字段宽度（可选）。 如果指定为
'*'(星号)，则实际宽度会从 values 元组的下一元素中读取，要转换的对象则为最小字段宽度和可选的精度之后的元素。 - 精度（可选），以在
'.'(点号) 之后加精度值的形式给出。 如果指定为'*'(星号)，则实际精度会从 values 元组的下一元素中读取，要转换的对象则为精度之后的元素。 - 长度修饰符（可选）。
- 转换类型。
当右边的参数为一个字典（或其他映射类型）时，字符串中的格式 必须 包含加圆括号的映射键，对应 '%' 字符之后字典中的每一项。 映射键将从映射中选取要格式化的值。 例如：
>>> print('%(language)s has %(number)03d quote types.' %
... {'language': "Python", "number": 2})
Python has 002 quote types.在此情况下格式中不能出现 * 标记符（因其需要一个序列类的参数列表）。
转换旗标为：
| 标志 | 含义 |
|---|---|
'#' |
值的转换将使用“替代形式”（具体定义见下文）。 |
'0' |
转换将为数字值填充零字符。 |
'-' |
转换值将靠左对齐（如果同时给出 '0' 转换，则会覆盖后者）。 |
' ' |
(空格) 符号位转换产生的正数（或空字符串）前将留出一个空格。 |
'+' |
符号字符 ('+' 或 '-') 将显示于转换结果的开头（会覆盖 "空格" 旗标）。 |
可以给出长度修饰符 (h, l 或 L)，但会被忽略，因为对 Python 来说没有必要 -- 所以 %ld 等价于 %d。
转换类型为：
| 转换符 | 含义 |
|---|---|
'd' |
有符号十进制整数。 |
'i' |
有符号十进制整数。 |
'o' |
有符号八进制数。 |
'u' |
过时类型 -- 等价于 'd'。 |
'x' |
有符号十六进制数（小写）。 |
'X' |
有符号十六进制数（大写）。 |
'e' |
浮点指数格式（小写）。 |
'E' |
浮点指数格式（大写）。 |
'f' |
浮点十进制格式。 |
'F' |
浮点十进制格式。 |
'g' |
浮点格式。 如果指数小于 -4 或不小于精度则使用小写指数格式，否则使用十进制格式。 |
'G' |
浮点格式。 如果指数小于 -4 或不小于精度则使用大写指数格式，否则使用十进制格式。 |
'c' |
单个字符（接受整数或单个字符的字符串）。 |
'r' |
字符串（使用 repr() 转换任何 Python 对象）。 |
's' |
字符串（使用 str() 转换任何 Python 对象）。 |
'a' |
字符串（使用 ascii() 转换任何 Python 对象）。 |
'%' |
不转换参数，在结果中输出一个 '%' 字符。 |
注释:
-
此替代形式会在第一个数码之前插入标示八进制数的前缀 (
'0o')。 -
此替代形式会在第一个数码之前插入
'0x'或'0X'前缀（取决于是使用'x'还是'X'格式）。 -
此替代形式总是会在结果中包含一个小数点，即使其后并没有数码。
小数点后的数码位数由精度决定，默认为 6。
-
此替代形式总是会在结果中包含一个小数点，末尾各位的零不会如其他情况下那样被移除。
小数点前后的有效数码位数由精度决定，默认为 6。
-
如果精度为
N，输出将截短为N个字符。
由于 Python 字符串显式指明长度，%s 转换不会将 '\0' 视为字符串的结束。
在 3.1 版更改: 绝对值超过 1e50 的 %f 转换不会再被替换为 %g 转换。
执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。
>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3' 当使用
n类型 (例如:'{:n}'.format(1234)) 来格式化数字 (int,float,complex,decimal.Decimal及其子类) 的时候，该函数会临时性地将LC_CTYPE区域设置为LC_NUMERIC区域以解码localeconv()的decimal_point和thousands_sep字段，如果它们是非 ASCII 字符或长度超过 1 字节的话，并且LC_NUMERIC区域会与LC_CTYPE区域不一致。 这个临时更改会影响其他线程。
在 3.7 版更改: 当使用 n 类型格式化数字时，该函数在某些情况下会临时性地将 LC_CTYPE 区域设置为 LC_NUMERIC 区域。
像%格式化表达式一样，格式化调用可以变得更复杂以支持更多高级用途。例如，格式化字符串可以指定对象属性和字典键
>>> 'My {1[kind]} runs {0.platform}'.format(sys, {'kind': 'laptop'})
'My laptop runs win32'第一个{}内调用了字典的键kind， 第二个{}导入了已经import的sys模块对象的platform属性。
>>> 'My {map[kind]} runs {sys.platform}'.format(map={'kind': 'laptop'}, sys=sys)
'My laptop runs win32'
上面这个例子大同小异，只不过是将位置索引换成关键字索引
同样的，格式化字符串中的方括号中可以指定列表（以及其他可索引序列）的偏移量来执行索引，但是只有单个正偏移量才能再格式化字符串的语法中有效，因此，这一功能并不完全通用。
和%表达式一样，要指定负的偏移量或分片，或者使用任意表达式的结果，必须在格式化字符串自身之外运行表达式：
>>> somelist = list('SPAM')
>>> somelist
['S', 'P', 'A', 'M']
>>> 'first={0[0]}, third={0[2]}'.format(somelist)
'first=S, third=A'
>>> 'first={0}, last={1}'.format(somelist[0], somelist[-1])
'first=S, last=M'
>>> 'first={0}, last={1}, middle={2}'.format(*parts)
"first=S, last=M, middle=['P', 'A']"对于格式化方法，我们在可能为空的替换目标的标识码之后使用一个冒号，后面跟着可以指定字段大小，对齐方式和特定类型编码的格式化说明符。
如下是可以在一个格式字符串中作为替代目标出现的形式化结构---它的四个部分全部都是可选的，中间必须不带有空格：
{fieldname component !conversionflag :formarspec}-
fieldname是辨识参数的一个数字或关键字。e.g.
'a{range}a'.format(range=10) -
component是有着大于等于零个.name或者[index]引用的字符串，它可被省略以使用完整的参数值。其中的引用用来获取参数的属性或索引值。e.g.
'{[0]}'.format(list(range(10)) -
conversionflag如果出现则以！开始，后面跟着r、s或者a，在这个值上分别调用repr、str或ascii内置函数
-
formatspec如果出现则以：开始，后面跟着文本，指定了如何表示该值，包括字段宽度、对齐方式、补零、小数精确度等细节，并以一个可选的数据类型码结束
-
冒号后面的formatspec组件本身也有着丰富的格式，形式上的描述是：
[[fill]align][sign][#][0][width][,][.precision][typecode]- fill : 除{或}之外的任意填充字符
- align：可以是> 、< 、= 或^ ,分别表示左对齐、右对齐、符号字符后的填充、或居中对齐；
- sign：可以是+、-或空格；
- ， ：逗号选项请求一个逗号表示从Python2.7和3.1开始使用的千分位分隔符；
- width和precision：与%表达式中时一样，而formatspec也可以包含嵌套的只有字段名称的{}格式化字符串，它从参数列表动态地获取值（和格式化表达式中的*很相似）
- typecode：几乎完全与在%表达式中使用的，但格式化方法还允许使用以二进制格式显示整数的b类型码，运行一个%类型码显示百分数，并且只使用d来表示以10为底的整数。注意与表达式的%s不通风，这里的s类型码要求一个字符串对象作为参数，通常可以省略类型码以接受任何类型
-
"{} {xxx}".format(*args,**kwargs) -> str
- args是可变位置参数，是一个元组
- kwargs是可变关键字参数，是一个字典
- 花括号表示占位符
- {}表示按照顺序匹配位置参数，{n}表示取位置下参数索引为n的值
- {xxx}表示在关键字参数中搜索名称一致的
- {{}}表示打印花括号
>>> "{0} am {1}, and U are {2}".format('I','Superman','Jocker')
'I am Superman, and U are Jocker'>>> import datetime
>>> d = datetime.datetime.now()
>>> d
datetime.datetime(2019, 12, 25, 12, 5, 50, 227286)
>>> "{:%Y}".format(d)
'2019'
>>> "{:%Y-%m-%d %H:%M:%S}".format(d)
'2019-12-25 12:05:50'>>> "{server}:{port}".format(server="127.0.0.1",port="8080")
'127.0.0.1:8080'>>> "{}*{}={}".format(2,3,6)
'2*3=6'
>>> "{}*{}={:>2}".format(2,8,16)
'2*8=16'
>>> "{}*{}={:>2}".format(2,3,6)
'2*3= 6'
#填充
>>> "{}*{}={:#^4}".format(2,3,6)
'2*3=#6##'
>>> "{}*{}={:#^4}".format(2,3,116)
'2*3=116#'>>> ip = [192,168,0,1]
>>> "{}.{}.{}.{}".format(*ip)
'192.168.0.1>>> "{{{} is not ok}}".format('ok')
'{ok is not ok}'>>> "{}".format(2**0.5)
'1.4142135623730951'
>>> "{:f}".format(2**0.5) #f为浮点数格式，默认6位
'1.414214'
>>> "{:3.2f}".format(200**0.5) #3个占位符，保留小数点后2位
'14.14'
>>> "{:30.2f}".format(200**0.5) #30个占位符，保留小数点后2位
' 14.14'
>>> "{:<30.2f}".format(200**0.5) #30个占位符，保留小数点后2位，左对齐
'14.14 '>>> '{0:X}, {1:o}, {2:b}'.format(255, 255, 255)
'FF, 377, 11111111'
>>> bin(255), int('11111111',2), 0b11111111
('0b11111111', 255, 255)
>>> hex(255), int('FF', 16), 0xFF
('0xff', 255, 255)
>>> oct(255), int('377', 8), 0o377
('0o377', 255, 255)