4.7. Text Sequence Type — str

Python中的文本数据由str对象或strings处理。字符串是Unicode编码的不可变序列。字符串文字以各种方式写入：

• 单引号：'允许嵌入"双"引号'
• 双引号："允许嵌入'单'引号"。
• 三重引号：'''三个单引号'''，"""三个双引号"""

三重引用的字符串可能会跨越多行 - 所有相关的空白字符都将包含在字符串文字中。

两个字符串文字之间如果只有空格，则将被隐式转换为单个字符串文字。也就是说：

>>>'span' 'eggs'
'spaneggs'

请参阅String and Bytes literals了解更多关于各种形式的字符串的信息，包括支持的转义序列和r（raw）前缀，禁用大多数转义序列处理等。

字符串也可以使用str构造函数从其他对象创建。

由于Python没有单独的character类型，索引字符串会产生长度为1的字符串。也就是说，对于非空字符串s，s [0] == s [0：1]。

Python也没有可变的字符串类型，但str.join()或io .StringIO可用于从多个片段高效地构建字符串。

版本3.3中更改：为了向后兼容Python 2系列，字符串文字再次允许使用u前缀。它对字符串文字的含义没有影响，不能与“r”前缀组合。

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict') # 针对byte-like字符串

返回object的string表示。如果未提供object，则返回空字符串。否则，str()的行为取决于是否给出encoding或errors，如下所示:

如果encoding和errors都没有给出，str(object)返回object .__ str__()，这是object的informal或可打印的字符串表示形式。对于字符串对象，这是字符串本身。如果object没有__str__()方法，那么str ()回退到repr(object)。

如果给出encoding或errors中的至少一个，object应该是bytes-like object(例如bytes或bytearray)。在这种情况下，如果object是bytes(或bytearray)对象，那么str(bytes，encoding，errors)等同于bytes.decode(encoding，errors)。否则，在调用bytes.decode()之前获取缓冲区对象的字节对象。

不带参数encoding和errors的将bytes对象传递给str()属于返回informal字符串表示形式的第一种情况

>>> str(b'Zoot!')
"b'Zoot!'"

4.7.1. String Methods

字符串支持所有通用的序列方法，还支持以下所述的方法

字符串还支持两种格式的字符串格式，一种提供了很大的灵活性和定制（参见str.format()，Format String Syntax和Custom String Formatting，另一种基于Cprintf样式格式处理的类型范围较窄，稍微难以正确使用，但对于可处理的情况通常更快（printf-style String Formatting）。

标准库的Text Processing Services部分涵盖了许多其他模块，它们提供了各种文本相关的工具（包括re模块中的正则表达式支持）。

str.capitalize()
返回字符串的副本: 除了第一个字符变为大写外(数字不变)，其他的所有字符强制变成小写。

>>>'123aBcDeFg'.capitalize()
'123abcdefg'

str.casefold()
返回字符串的副本:Casefolded strings may be used for caseless matching.
casefold类似于lower，但更具侵略性，因为它旨在删除字符串中的所有案例区别。例如，德语小写字母ß等同于ss。由于它已经是小写字母，lower()对于ß不起作用 ;但是casefold()可以将其转换为ss。

>>>'ß'.lower()
'ß'
>>>'ß'.casefold()
'ss'

Unicode标准的第3.13节描述了casefold的算法。

New in version 3.3.

str.center(width[, fillchar])
返回一个新的字符串：原本的字符串居中显示在一个长度为width的字符串中。填充是使用指定的fillchar(默认是ASCII中的空格' ')完成的。如果width小于或等于len（s），则返回原始字符串。

>>>r = '1234'
>>>r.center(10) # str.center(width)    width > len(r)
'   1234   '
>>>r.center(3) # str.center(width)   width <= len(r)
'1234'
>>>r.center(10,'.') # str.center(width, fillchar)
'...1234...'
>>>r
'1234'

str.count(sub[, start[, end]])
返回范围[start，end]中子字符串sub的非重叠次数。可选参数start和end为切片符号。

str.encode(encoding="utf-8", errors="strict")
以字节对象的形式返回字符串的编码版本。默认编码是“utf-8”。 给出errors参数来设置不同的错误处理方案。 errors的默认值是'strict'，这意味着编码错误会引发UnicodeError。其他可能的值是'ignore'，'replace'，'xmlcharrefreplace'，'backslashreplace'和通过codecs.register_error()注册的任何其他名称，请参见[Error Handlers]一节。有关可能的编码列表，请参见[Standard Encodings]部分。

# errors:
# strict    
# ignore    
# replace    
# xmlcharrefreplace    
# backslashreplace    
# 通过codecs.register_error()注册的任何其他名称

Changed in version 3.1: Support for keyword arguments added.

str.endswith(suffix[, start[, end]])
如果字符串以指定的suffix结尾，则返回True，否则返回False。 suffix也可以是一个由后缀组成的元组。如果有start参数，则测试从start位置开始。如果有stop参数，则测试在stop位置停止

>>>r = 'abcdefgxyz'
>>>r.endswith('xyz') # 匹配到xyz
True
>>>r.endswith(('xyz', 'z')) # 使用元组，匹配到xyz
True
>>>r.endswith(('opq', 'rst','xyz'), -3, len(r))  # 使用元组,  (len(r) - 3, len(r))匹配到xyz
True
>>>r.endswith(('opq', 'rst','xyz', 'xy'), -3, len(r) - 1) # 匹配到xy
True

str.expandtabs(tabsize=8)
返回字符串的副本，其中所有制表符由一个或多个空格替换，具体取决于当前列和给定的制表符大小。tab替换出现在每个\t字符出现的位置（tabsize默认值是8）。当要展开字符串时，当前列设置为零，字符串逐个检查。如果该字符是一个制表符(\ t)，则在结果中插入一个或多个空格字符(取决于设置的tabsize的大小)，直到当前列等于下一个制表符位置(制表符本身不被复制).如果该字符是换行符(\ n)或返回符号(\ r)，则复制该字符并将当前列重置为零。任何其他字符都将被不变地复制，而当前列增加1，无论打印时字符如何表示。

>>>'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在切片的[start：end]内找到。可选参数start和end被解释为切片符号。如果未找到sub，则返回-1。

Note:
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'
>>>'{a} + {b} = {sum}'.format(a=1, b=2, sum=(1 + 2))
'1 + 2 = 3'

有关可以在格式字符串中指定的各种格式选项的说明，请参见[Format String Syntax]。

Note
当使用n类型（例如{：n}'.format（1234））格式化一个数字（[int]，[float]，[float]和其子类）时，函数将LC_CTYPE语言环境临时设置为LC_NUMERIC语言环境，以解码localeconv()的decimal_point和thousands_sep字段，如果它们是非ASCII或长于1个字节，并且LC_NUMERIC语言环境不同于LC_CTYPE区域设置。此临时更改会影响其他线程。

locale 是根据计算机用户所使用的语言，所在国家或者地区，以及当地的文化传统
所定义的一个软件运行时的语言环境。通常情况下它可以按照涉及使用习惯分为12大类:
- 语言符号及其分类（LC_CTYPE)
- 数字（LC_NUMBERIC）
- 比较习惯（LC_COLLATE)
- 时间显示格式（LC_TIME）
- 货币单位（LC_MONETARY)
- 信息主要是提示信息，错误信息，状态信息，标题，标签，按钮和菜单等（LC_MESSAGES）
- 行么书写方式（LC_NAME）
- 地址书写方式（LC_ADDRESS）
- 电话号码书写方式（LC_TELEPHONE）
- 度量衡表达方式（LC_MEASUREMENT）
- 默认纸张尺寸大小（LC_PAPER）
- 对locale 自身包含信息的概述（LC_IDENTIFICATION）
- 除此之外还有一个LANGUAGE参数，它与LC_MESSAGES相似

Changed in version 3.6.5: 在使用n类型格式化数字时，函数在某些情况下会将LC_CTYPE语言环境临时设置为LC_NUMERIC类型。

str.format_map(mapping)
类似于str.format（mapping），除了直接使用mapping而不是复制到dict。例如如果mapping是一个字典子类，这是有用的：

>>>class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

New in version 3.2.

str.index(sub[, start[, end]])
类似find()，但在未找到子字符串时引发ValueError。

str.isalnum()
如果字符串中的所有字符都是字母数字且至少有一个字符，则返回true，否则返回false。如果以下其中一个返回True：c.isalpha（），c.isdecimal（），c.isdigit（）或c.isnumeric（），则字符c为isalnum。

str.isalpha()
如果字符串中的所有字符都是字母，并且至少有一个字符，则返回true，否则返回false。字母字符是在Unicode字符数据库中定义为“Letter”的那些字符，即具有一般类别属性是“Lm”，“Lt”，“Lu”，“Ll”或“Lo”之一的字符(参阅附录)。请注意，这与Unicode标准中定义的“字母”属性不同。

str.isdecimal()
如果字符串中的所有字符都是十进制字符，并且至少有一个字符，则返回true，否则返回false。十进制字符是那些可以用来形成基数为10的数字，例如U + 0660，阿拉伯数字0。形式上，十进制字符是Unicode常规类别“Nd”中的字符。

str.isdigit()
如果字符串中的所有字符都是数字并且至少有一个字符，则返回true，否则返回false。数字包含需要特殊处理的十进制字符和数字，例如兼容性上标数字。这包括不能用来形成基数为10的数字，如Kharosthi数字。形式上，数字是具有属性值Numeric_Type = Digit或Numeric_Type = Decimal的字符。

str.isidentifier()
如果字符串是符合语言定义的有效标识符，则返回true. 标识符和关键字。

使用keyword.iskeyword()来测试保留的标识符，如def和class。

str.islower()
如果字符串中的所有cased字符都是小写字母，并且至少有一个cased字符，则返回true，否则返回false。

str.isnumeric()
如果字符串中的所有字符都是数字字符，并且至少有一个字符，则返回true，否则返回false。数字字符包括digit字符和具有Unicode数字值属性的所有字符，例如U + 2155，VULGAR分数ONE FIFTH。形式上，数字字符是具有属性值Numeric_Type = Digit，Numeric_Type = Decimal或Numeric_Type = Numeric的字符。

str.isprintable()
如果字符串中的所有字符都可打印或字符串为空，则返回true，否则返回false。非可打印字符是在Unicode字符数据库中定义为“Other”或“Separator”的字符，但ASCII空格（0x20）被认为是可打印的。 （注意，在这个上下文中的可打印字符是那些在字符串上调用repr()时不应该被转义的字符，它不会影响写入sys.stdout或sys.stderr）。

str.isspace()
如果字符串中只有空格字符，并且至少有一个字符，则返回true，否则返回false。空格字符是在Unicode字符数据库中定义为“Other”或“Separator”的那些字符，以及具有“WS”，“B”或“S”之一的双向属性的那些字符。

str.istitle()
如果字符串是一个标题字符串，并且至少有一个字符，则返回true，例如，大写字符只能跟在uncased字符之后，而小写字符只能在一个cased字符之后。否则返回false。

str.isupper()
如果字符串中的所有cased字符都是大写且至少有一个cased字符，则返回true，否则返回false。

str.join(iterable)
返回一个字符串，它是iterable中字符串的串联。如果iterable中有任何非字符串值，包括bytes对象，则会引发TypeError`。元素之间的分隔符是提供此方法的字符串。

str.ljust(width[, fillchar])
返回一个新的字符串。如果width<=len(str),则字符串不变，否则将字符串左对齐，并且在后面填充fillchar（默认是ASCII的空格）.

str.lower()
返回字符串的一个副本，并将所有字符转换为小写字母。

str.lstrip([chars])
返回删除前导字符的字符串的副本。 chars参数是一个字符串，指定要删除的字符集。如果省略或者None，chars参数默认删除空格。 chars参数不是一个前缀;相反，它的值的所有组合都被剥离了：

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

static str.maketrans(x[, y[, z]])
这个静态方法返回一个可用于str.translate()的转换表

如果只有一个参数，它必须是一个将Unicode序数（整数）或字符（长度为1的字符串）映射到Unicode序号，字符串（任意长度）或None的字典。字符键将被转换为序号。
如果有两个参数，它们必须是长度相等的字符串，并且在结果字典中，x中的每个字符将映射到y中相同位置的字符。
如果有第三个参数，它必须是一个字符串，其字符将被映射到结果中的None。

>>>l = '123qwe'
>>>l.maketrans({'1':'2'})
{49: '2'}
>>>l.maketrans('123','456')
{49: 52, 50: 53, 51: 54}
>>>l.maketrans('123','456', 'qwe')
{49: 52, 50: 53, 51: 54, 113: None, 119: None, 101: None}

str.partition(sep)
在sep的第一个出现处拆分字符串，并返回包含分隔符之前的部分，分隔符本身和分隔符之后的部分的三元组。如果找不到分隔符，则返回包含字符串本身及两个空字符串的三元组。

>>>l.partition('3')
('12', '3', 'qwe')
>>>l.partition('0')
('123qwe', '', '')
>>>l.partition('234')
('123qwe', '', '')
>>>l.partition('23')
('1', '23', 'qwe')

str.replace(old, new[, count])返回所有出现的子字符串old替换为new的字符串的副本。如果给出可选参数count，则只会替换count`次数。

>>>l = 'youyouyouyou'
>>>l.replace('y', 'r', 2)
'rourouyouyou'

str.rfind(sub[, start[, end]])
返回找到substring sub的字符串中的最高索引，使得sub包含在s [start：end]内。可选参数start和end被解释为切片符号。当失败时返回-1。
对比find方法，此方法为从后往前查找(rfind-->right find)

str.rindex(sub[, start[, end]])
和rfind()一样，但是在找不到子字符串sub时引发ValueError。
对比index方法，此方法为从后往前查找(rindex-->right index)

str.rjust(width[, fillchar])
返回字符串右对齐的长度为width的字符串。填充是使用指定的fillchar（默认是ASCII中的空格）完成的。如果width小于或等于len（s），则返回原始字符串。
对比ljust方法，此方法为右对齐。

str.rpartition(sep)
在sep的最后出现处拆分字符串，并返回包含分隔符之前的部分，分隔符本身和分隔符之后的部分的三元组。如果未找到分隔符，则返回包含两个空字符串的三元组，然后返回字符串本身。
对比partition方法，rpartition从右到左遍历。

str.rsplit(sep=None, maxsplit=-1)
返回字符串中的单词列表，使用sep作为分隔符字符串。如果给出maxsplit，最多分割maxsplit次，此方法从最右边开始分割。如果sep没有指定或者没有，则任何空格字符串都是分隔符。除了从右边分割外，[rsplit()]的行为就像[split（）]，这在下面详细描述。

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']) 。用指定的分隔符分割空字符串会返回['']。

For example:

>>>'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”分隔符分开将返回[]。

For example:

>>>'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])
返回字符串中lines的列表，在lines边界处突破。换行符不包含在结果列表中，除非* keepends *被给出且为真。
此方法分割在以下行边界上。特别是，边界是universal newlines的超集:

Changed in version 3.2:将\v和\f添加到行边界列表中。

For example:

>>> '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']

Unlike [split()] when a delimiter string sep is given, this method returns an empty list for the empty string, and a terminal line break does not result in an extra line:
与[split()]不同，此方法返回空字符串的空列表，并且终端行分隔不会导致多余行：

>>>"".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

For comparison, split('\n') gives:

>>>''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

str.startswith(prefix[, start[, end]])
如果字符串以prefix开头，则返回True，否则返回False。 prefix也可以是一个前缀元组来查找。使用可选的start，测试字符串从该位置开始。使用可选的end，停止在该位置比较字符串。
类比endswith.

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()
返回字符串的字幕版本，其中字以大写字符开头，其余字符为小写字母。
For example:

>>> '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()
返回字符串的所有字符转换为大写的副本。请注意，如果s包含uncased字符，或者如果生成的字符的Unicode类别不是“Lu”（Letter，大写），则str.upper().isupper()可能是False。比如： “Lt”（Letter，titlecase）。

Unicode标准的第3.13节描述了The uppercasing algorithm.

str.zfill(width)
返回一个左边填充了ASCII0数字的字符串的副本，以产生一个长度为width的字符串。 前导符号前缀（'+'/`` - '）是通过在符号字符之后插入填充符*而不是之前处理的。 如果width小于或等于len（s）`，则返回原始字符串
For example:

>>>"42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

4.7.2. printf-style String Formatting

Note

The formatting operations described here exhibit a variety of quirks that lead to a number of common errors (such as failing to display tuples and dictionaries correctly). Using the newer [formatted string literals] or the [str.format()] interface helps avoid these errors. These alternatives also provide more powerful, flexible and extensible approaches to formatting text.
这里描述的格式化操作表现出各种各样的怪癖，导致许多常见错误（如未能正确显示元组和字典）。使用新的formatted string literals或str.format()接口有助于避免这些错误。这些替代方案还提供了更强大，灵活和可扩展的方法来格式化文本。

字符串对象有一个独特的内置操作：％操作符（模）。这也被称为字符串* formatting 或 interpolation 运算符。给定format％values（其中 format 是一个字符串）， format 中的％转换规范被替换为 values *的零个或多个元素。其效果与在C语言中使用sprintf（）类似。

If format requires a single argument, values may be a single non-tuple object. [[5]]] Otherwise, values must be a tuple with exactly the number of items specified by the format string, or a single mapping object (for example, a dictionary).

A conversion specifier contains two or more characters and has the following components, which must occur in this order:

1. The '%' character, which marks the start of the specifier.
2. Mapping key (optional), consisting of a parenthesised sequence of characters (for example, (somename)).
3. Conversion flags (optional), which affect the result of some conversion types.
4. Minimum field width (optional). If specified as an '*' (asterisk), the actual width is read from the next element of the tuple in values, and the object to convert comes after the minimum field width and optional precision.
5. Precision (optional), given as a '.' (dot) followed by the precision. If specified as '*' (an asterisk), the actual precision is read from the next element of the tuple in values, and the value to convert comes after the precision.
6. Length modifier (optional).
7. Conversion type.

When the right argument is a dictionary (or other mapping type), then the formats in the string must include a parenthesised mapping key into that dictionary inserted immediately after the '%' character. The mapping key selects the value to be formatted from the mapping. For example:

>>>print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

In this case no * specifiers may occur in a format (since they require a sequential parameter list).

The conversion flag characters are:

A length modifier (h, l, or L) may be present, but is ignored as it is not necessary for Python – so e.g. %ld is identical to %d.

The conversion types are:

Notes:

1. The alternate form causes a leading octal specifier ('0o') to be inserted before the first digit.

2. The alternate form causes a leading '0x' or '0X' (depending on whether the 'x' or 'X' format was used) to be inserted before the first digit.

3. The alternate form causes the result to always contain a decimal point, even if no digits follow it.

   The precision determines the number of digits after the decimal point and defaults to 6.

4. The alternate form causes the result to always contain a decimal point, and trailing zeroes are not removed as they would otherwise be.

   The precision determines the number of significant digits before and after the decimal point and defaults to 6.

5. If precision is N, the output is truncated to N characters.

6. See PEP 237.

Since Python strings have an explicit length, %s conversions do not assume that '\0' is the end of the string.

Changed in version 3.1: %f conversions for numbers whose absolute value is over 1e50 are no longer replaced by %g conversions.

附录: