python 文本序列类型相关(str)
在 Python 中处理文本数据是使用 str 对象，也称为 字符串。 字符串是由 Unicode 码位构成的不可变 序列。 字符串字面值有多种不同的写法：
单引号: ‘允许包含有 “双” 引号’双引号: “允许包含有 ‘单’ 引号”。三重引号:'''三重单引号''',"""三重双引号"""
使用三重引号的字符串可以跨越多行 —— 其中所有的空白字符都将包含在该字符串字面值中。
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
>>> str(1)
'1'
>>> str(True)
'True'
str(b'Zoot!')
"b'Zoot!'"
字符串常量
string.ascii_letters
下文所述 ascii_lowercase 和 ascii_uppercase 常量的拼连。 该值不依赖于语言区域。
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
string.ascii_lowercase
小写字母 ‘abcdefghijklmnopqrstuvwxyz’。 该值不依赖于语言区域，不会发生改变。
string.ascii_uppercase
大写字母 ‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’。 该值不依赖于语言区域，不会发生改变。
string.digits
字符串 ‘0123456789’。
string.hexdigits
字符串 ‘0123456789abcdefABCDEF’。
string.octdigits
字符串 ‘01234567’。
string.punctuation
String of ASCII characters which are considered punctuation characters in the C locale.
>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
string.printable
由被视为可打印符号的 ASCII 字符组成的字符串。 这是 digits, ascii_letters, punctuation 和 whitespace 的总和。
>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'
string.whitespace
由被视为空白符号的 ASCII 字符组成的字符串。 其中包括空格、制表、换行、回车、进纸和纵向制表符。
>>> string.whitespace
' \t\n\r\x0b\x0c'
字符串的方法
str.capitalize()
返回原字符串的副本，其首个字符大写，其余为小写。
>>> 'hello world'.capitalize()
'Hello world'
str.casefold()
返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。
>>> 'Hello WORLD'.casefold()
'hello world'
消除大小写类似于转为小写，但是更加彻底一些，因为它会移除字符串中的所有大小写变化形式。 例如，德语小写字母 ‘ß’ 相当于 “ss”。 由于它已经是小写了，lower() 不会对 ‘ß’ 做任何改变；而 casefold() 则会将其转换为 “ss”。
消除大小写算法的描述请参见 Unicode 标准的 3.13 节。
3.3 新版功能.
str.center(width[, fillchar])
返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。
>>> 'Hello World'.center(30)
' Hello World '
str.count(sub[, start[, end]])
反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。
>>> 'Hello World'.count('l')
3
>>> 'Hello World'.count('l', 3)
2
str.encode(encoding="utf-8", errors="strict")
返回原字符串编码为字节串对象的版本。
encoding— 默认编码为 ‘utf-8’。 标准编码errors— 默认值为 ‘strict’，表示编码错误会引发 UnicodeError。其他可用的值为 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及任何其他通过 codecs.register_error() 注册的值，请参阅 错误处理方案 小节。 要查看可用的编码列表，请参阅 标准编码 小节。
>>> 'hello world 中国'.encode('gb2312')
b'hello world \xd6\xd0\xb9\xfa'
在 3.1 版更改: 加入了对关键字参数的支持。
str.endswith(suffix[, start[, end]])
如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
str.expandtabs(tabsize=8)
把字符串中的 tab 符号(‘\t’)转为空格，tab 符号(‘\t’)默认的空格数是 8。
>>> '01\t012\t0123\t01234'.expandtabs()
'01 012 0123 01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01 012 0123 01234'
str.find(sub[, start[, end]])
返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。
str— 指定检索的字符串beg— 开始索引，默认为0。end— 结束索引，默认为字符串的长度len(str)。
>>> 'hello world'.find('hello')
0
>>> 'hello world'.find('lo')
3
注解 find() 方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，请使用 in 操作符:
>>> 'Py' in 'Python'
True
str.format(*args, **kwargs)
执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。
>>> "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 区域。
str.format_map(mapping)
类似于 str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict。 适宜使用此方法的一个例子是当 mapping 为 dict 的子类的情况：
>>> class Default(dict):
... def __missing__(self, key):
... return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'
3.2 新版功能.
str.index(sub[, start[, end]])
类似于 find()，但在找不到子类时会引发 ValueError。
str.isalnum()
如果字符串中至少有一个字符且所有字符均为字母或数字则返回真值，否则返回假值。 如果以下方法中的一个返回 True 则字符 c 为字母或数字: c.isalpha(), c.isdecimal(), c.isdigit(), or c.isnumeric()。
>>> 'hello123'.isalnum() # 可以包含 字母 和 数字
True
>>> 'hello 123'.isalnum() # 含有非 字母 或 数字 -> 空格 => false
False
str.isalpha()
如果字符串中至少有一个字符且所有字符均为字母则返回真值，否则返回假值。 字母类字符是在 Unicode 字符数据库中被定义为 “Letter” 的字符，即一般分类特征属性为 “Lm”, “Lt”, “Lu”, “Ll” 或 “Lo” 其中之一。 请注意这不同于 Unicode 标准所定义的 “Alphabetic” 特征属性。
>>> 'helloworld'.isalpha() # 只能包含字母
True
>>> 'hello123'.isalpha() # 含有数字 => false
False
>>> 'hello 123'.isalpha() # 含有空格 / 数字 => false
False
str.isascii()
如果字符串为空或所有字符均为 ASCII 字符则返回真值，否则返回假值。 ASCII 字符的码位范围为 U+0000-U+007F。
3.7 新版功能.
str.isdecimal()
如果字符串中至少有一个字符且所有字符均为十进制数字符则返回真值，否则返回假值。 十进制数字符是以 10 为基数的计数制会用来组成数值的字符，例如 U+0660, ARABIC-INDIC DIGIT ZERO。 正式的定义为：十进制数字符就是 Unicode 一般分类 “Nd” 中的字符。
>>> '123'.isdecimal() # 只能包含 十进制数字
True
>>> 'hello 123'.isdecimal() # 含有 数字/ 空格 => false
False
str.isdigit()
如果字符串中至少有一个字符且所有字符均为数字字符则返回真值，否则返回假值。 数字字符包括十进制数字符和需要特别处理的数字，例如兼容性上标数字。 这也涵盖了不能被用来组成以 10 为基数的数值的数字，例如 Kharosthi 数字。 正式的定义为：数字字符就是特征属性值 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。
>>> '123'.isdigit() # 只能包含 数字字符
True
str.isidentifier()
如果字符串根据语言定义属于有效的标识符则返回真值，参见 标识符和关键字。
>>> 'abc123'.isidentifier() # 有效标识符
True
>>> '123'.isidentifier() # 无效标识符
False
注意: 可用于标识符的字符:
- 大写和小写字母 A 至 Z，下划线 _ 以及数字 0 至 9，但不可以数字打头。
- 标识符的长度没有限制。对大小写敏感。
str.islower()
如果字符串中至少有一个区分大小写的字符且此类字符均为小写则返回真值，否则返回假值。
>>> 'hello world'.islower()
True
>>> 'Hello World'.islower()
False
str.isnumeric()
如果字符串中至少有一个字符且所有字符均为数值字符则返回真值，否则返回假值。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定义为：数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。
>>> '123'.isnumeric()
True
>>> 'hello 123'.isnumeric() # 包含了非 数值字符 => false
False
str.isprintable()
如果字符串中所有字符均为可打印字符或字符串为空则返回真值，否则返回假值。 不可打印字符是在 Unicode 字符数据库中被定义为 “Other” 或 “Separator” 的字符，例外情况是 ASCII 空格字符 (0x20) 被视作可打印字符。 （请注意在此语境下可打印字符是指当对一个字符串发起调用 repr() 时不必被转义的字符。 它们与字符串写入 sys.stdout 或 sys.stderr 时所需的处理无关。）
>>> 'hello 123'.isprintable()
True
str.isspace()
如果字符串中只有空白字符且至少有一个字符则返回真值，否则返回假值。
>>> ''.isspace() # 违背至少有一个字符 => false
False
>>> ' '.isspace() # 一个空白字符 => true
True
>>> ' '.isspace() # 两个空白字符 => true
True
>>> 'hello 123'.isspace() # 包含非空白字符 => false
False
str.istitle()
如果字符串中至少有一个字符且为标题字符串则返回真值，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回假值。
>>> 'Hello World'.istitle() # 大写字符之后只能带非大写字符、小写字符必须有大写字符打头
True
>>> 'hello world'.istitle()
False
str.isupper()
如果字符串中至少有一个区分大小写的字符 4 具此类字符均为大写则返回真值，否则返回假值。
>>> 'hello world'.isupper() # 包含些小字符 => false
False
>>> 'Hello World'.isupper() # 包含些小字符 => false
False
>>> 'HELLO WORLD'.isupper() # 都是大写字符 => true
True
str.join(iterable)
返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。
>>> ",".join(["hello", "world", "123"])
'hello,world,123'
str.ljust(width[, fillchar])
返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
>>> 'hello world'.ljust(30) # 左对齐，右边不够按 fillchar 补齐
'hello world '
str.lower()
返回原字符串的副本，其所有区分大小写的字符 4 均转换为小写。
>>> 'HELLO WORLD'.lower() # 转小写
'hello world'
str.lstrip([chars])
返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:
>>> ' spacious '.lstrip() # 删除左边空格字符
'spacious '
>>> 'www.example.com'.lstrip('cmowz.') # 删除左边指定chars的字符
'example.com'
static str.maketrans(x[, y[, z]])
此静态方法返回一个可供 str.translate() 使用的转换对照表。
如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、（任意长度的）字符串或 None 的字典。 字符键将会被转换为码位序号。
如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。 如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。
str.partition(sep)
在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。
>>> 'hello world 123'.partition(' ') # 以空格首次出现的位置，拆分为3个元组
('hello', ' ', 'world 123')
str.replace(old, new[, count])
返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。
>>> 'hello world'.replace('world', '123')
'hello 123'
str.rfind(sub[, start[, end]])
返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。
>>> 'hello world'.rfind('l') # 从右边开始寻找，返回索引(索引从0开始)
9
>>> 'hello world'.rfind('z') # 未找到，返回-1
-1
str.rindex(sub[, start[, end]])
类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。
str.rjust(width[, fillchar])
返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。
>>> 'hello world'.rjust(30)
' hello world'
str.rpartition(sep)
在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。
>>> 'hello world 123'.rpartition(' ') # 从右边查找并拆分
('hello world', ' ', '123')
>>>
str.rsplit(sep=None, maxsplit=-1)
返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 除了从右边开始拆分，rsplit() 的其他行为都类似于下文所述的 split()。
>>> 'hello world 123'.rsplit(' ')
['hello', 'world', '123']
>>> 'hello world 123'.rsplit(' ', 1) # 第二个参数切割次数
['hello world', '123']
str.rstrip([chars])
返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:
>>> ' spacious '.rstrip()
' spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'
str.split(sep=None, maxsplit=-1)
返回一个由字符串内单词组成的列表，使用 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']
str.splitlines([keepends])
返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 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', '']
str.startswith(prefix[, start[, end]])
如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。
str.strip([chars])
返回原字符串的副本，移除其中的前导和末尾字符。 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'
str.swapcase()
返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。
str.title()
返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。
例如:
>>> '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)[0].upper() +
... mo.group(0)[1:].lower(),
... s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."
str.translate(table)
返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 getitem() 来实现索引操作的对象，通常为 mapping 或 sequence。 当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。
你可以使用 str.maketrans() 基于不同格式的字符到字符映射来创建一个转换映射表。
另请参阅 codecs 模块以了解定制字符映射的更灵活方式。
str.upper()
返回原字符串的副本，其中所有区分大小写的字符 4 均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 “Lu” (Letter, uppercase) 而是 “Lt” (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。
>>> 'hello world'.upper() # 小写转大写
'HELLO WORLD'
所用转换大写算法的描述请参见 Unicode 标准的 3.13 节。
str.zfill(width)
返回原字符串的副本，在左边填充 ASCII ‘0’ 数码使其长度变为 width。 正负值前缀 (‘+’/‘-‘) 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。
例如:
>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'
自定义字符串格式化
class string.Formatter
实例化
import string
f = string.Formatter()
类包含下列公有方法：
format(format_string, *args, **kwargs)
首要的 API 方法。 它接受一个格式字符串和任意一组位置和关键字参数。 它只是一个调用 vformat() 的包装器。
s = "my name is {name}"
print( f.format(s, name = 'lily') )
# 输出: my name is lily
s2 = "my name is {name:>20}"
print( f.format(s2, name = 'lily') )
# 右对齐输出: my name is lily
vformat(format_string, args, kwargs)
此函数执行实际的格式化操作。 它被公开为一个单独的函数，用于需要传入一个预定义字母作为参数，而不是使用 args 和 *kwargs 语法将字典解包为多个单独参数并重打包的情况。 vformat() 完成将格式字符串分解为字符数据和替换字段的工作。 它会调用下文所述的几种不同方法。
此外，Formatter 还定义了一些旨在被子类替换的方法：
parse(format_string)
循环遍历 format_string 并返回一个由可迭代对象组成的元组 (literal_text, field_name, format_spec, conversion)。 它会被 vformat() 用来将字符串分解为文本字面值或替换字段。
元组中的值在概念上表示一段字面文本加上一个替换字段。 如果没有字面文本（如果连续出现两个替换字段就会发生这种情况），则 literal_text 将是一个长度为零的字符串。 如果没有替换字段，则 field_name, format_spec 和 conversion 的值将为 None。
get_field(field_name, args, kwargs)
给定 field_name 作为 parse() (见上文) 的返回值，将其转换为要格式化的对象。 返回一个元组 (obj, used_key)。 默认版本接受在 PEP 3101 所定义形式的字符串，例如 “0[name]” 或 “label.title”。 args 和 kwargs 与传给 vformat() 的一样。 返回值 used_key 与 get_value() 的 key 形参具有相同的含义。
get_value(key, args, kwargs)
提取给定的字段值。 key 参数将为整数或字符串。 如果是整数，它表示 args 中位置参数的索引；如果是字符串，它表示 kwargs 中的关键字参数名。
args 形参会被设为 vformat() 的位置参数列表，而 kwargs 形参会被设为由关键字参数组成的字典。
For compound field names, these functions are only called for the first component of the field name; Subsequent components are handled through normal attribute and indexing operations.
因此举例来说，字段表达式 ‘0.name’ 将导致调用 get_value() 时附带 key 参数值 0。 在 get_value() 通过调用内置的 getattr() 函数返回后将会查找 name 属性。
如果索引或关键字引用了一个不存在的项，则将引发 IndexError 或 KeyError。
check_unused_args(used_args, args, kwargs)
在必要时实现对未使用参数进行检测。 此函数的参数是是格式字符串中实际引用的所有参数键的集合（整数表示位置参数，字符串表示名称参数），以及被传给 vformat 的 args 和 kwargs 的引用。 未使用参数的集合可以根据这些形参计算出来。 如果检测失败则 check_unused_args() 应会引发一个异常。
format_field(value, format_spec)
format_field() 会简单地调用内置全局函数 format()。 提供该方法是为了让子类能够重载它。
convert_field(value, conversion)
使用给定的转换类型（来自 parse() 方法所返回的元组）来转换（由 get_field() 所返回的）值。 默认版本支持 ‘s’ (str), ‘r’ (repr) 和 ‘a’ (ascii) 等转换类型。
模板字符串
模板字符串支持基于 $ 的替换，使用以下规则：
$$ 为转义符号；它会被替换为单个的 $。
$identifier 为替换占位符，它会匹配一个名为 “identifier” 的映射键。 在默认情况下，”identifier” 限制为任意 ASCII 字母数字（包括下划线）组成的字符串，不区分大小写，以下划线或 ASCII 字母开头。 在 $ 字符之后的第一个非标识符字符将表明占位符的终结。
${identifier} 等价于 $identifier。 当占位符之后紧跟着有效的但又不是占位符一部分的标识符字符时需要使用，例如 “${noun}ification”。
在字符串的其他位置出现 $ 将导致引发 ValueError。
string 模块提供了实现这些规则的 Template 类。 Template 有下列方法：
class string.Template(template)
该构造器接受一个参数作为模板字符串。
实例化:
from string import Template
t = Template("$boy love $girl")
substitute(mapping, **kwds)
执行模板替换，返回一个新字符串。
- mapping 为任意字典类对象，其中的键将匹配模板中的占位符。
- 或者你也可以提供一组关键字参数，其中的关键字即对应占位符。
- 当同时给出 mapping 和 kwds 并且存在重复时，则以 kwds 中的占位符为优先。
# 占位符
print( t.substitute(boy = 'tim', girl = 'lily') )
# 输出: tim love lily
# 字典类对象
d = dict(boy = 'jim', girl = 'mody')
print( t.substitute(d) )
# 输出: jim love mody
safe_substitute(mapping, **kwds)
类似于 substitute()，不同之处是如果有占位符未在 mapping 和 kwds 中找到，不是引发 KeyError 异常，而是将原始占位符不加修改地显示在结果字符串中。 另一个与 substitute() 的差异是任何在其他情况下出现的 $ 将简单地返回 $ 而不是引发 ValueError。
print( t.safe_substitute(other = 'other') )
# 输出: $boy love $girl
Template 的实例还提供一个公有数据属性：
template
这是作为构造器的 template 参数被传入的对象。 一般来说，你不应该修改它，但并不强制要求只读访问。
