Python标准库---12、内置类型:文本序列类型（str）

摘要：上一篇文章标准库内置类型迭代器类型序列类型下一篇文章标准库内置类型二进制序列类型文本序列类型在中处理文本数据是使用对象，也称为字符串。正式的定义为十进制数字符就是一般分类中的字符。

上一篇文章：Python标准库---11、内置类型:迭代器类型、序列类型（list-typle-range）
下一篇文章：Python标准库---13、内置类型：二进制序列类型 ( bytes, bytearray, memoryview)

在 Python 中处理文本数据是使用 str 对象，也称为 字符串。 字符串是由 Unicode 码位构成的不可变 序列。 字符串字面值有多种不同的写法：

单引号: "允许包含有 "双" 引号"

双引号: "允许包含有 "单" 引号"。

三重引号: """三重单引号""", """三重双引号"""

使用三重引号的字符串可以跨越多行 —— 其中所有的空白字符都将包含在该字符串字面值中。

作为单一表达式组成部分，之间只由空格分隔的多个字符串字面值会被隐式地转换为单个字符串字面值。 也就是说，("spam " "eggs") == "spam eggs"。

请参阅 字符串和字节串字面值 有解有关不同字符串字面值的更多信息，包括所支持的转义序列，以及使用 r ("raw") 前缀来禁用大多数转义序列的处理。

字符串也可以通过使用 str 构造器从其他对象创建。

由于不存在多带带的“字符”类型，对字符串做索引操作将产生一个长度为 1 的字符串。 也就是说，对于一个非空字符串 s, s[0] == s[0:1]。

不存在可变的字符串类型，但是 str.join() 或 io.StringIO 可以被用来根据多个片段高效率地构建字符串。

在 3.3 版更改: 为了与 Python 2 系列的向下兼容，再次允许字符串字面值使用 u 前缀。 它对字符串字面值的含义没有影响，并且不能与 r 前缀同时出现。

返回 object 的 字符串 版本。 如果未提供 object 则返回空字符串。 在其他情况下 str() 的行为取决于 encoding 或 errors 是否有给出，具体见下。

如果 encoding 或 errors 均未给出，str(object) 返回 object.__str__()，这是 object 的“非正式”或格式良好的字符串表示。 对于字符串对象，这是该字符串本身。 如果 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() 之前获取缓冲区对象下层的 bytes 对象。 请参阅 二进制序列类型 --- bytes, bytearray, memoryview 与 缓冲协议 了解有关缓冲区对象的信息。

将一个 bytes 对象传入 str() 而不给出 encoding 或 errors 参数的操作属于第一种情况， 将返回非正式的字符串表示（另请参阅 Python 的 -b 命令行选项）。 例如:

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

有关 str 类及其方法的更多信息，请参阅下面的 文本序列类型 --- str 和 字符串的方法 小节。 要输出格式化字符串，请参阅 格式化字符串字面值 和 格式字符串语法 小节。 此外还可以参阅 文本处理服务 小节。

字符串实现了所有 一般 序列的操作，还额外提供了以下列出的一些附加方法。

字符串还支持两种字符串格式化样式，一种提供了很大程度的灵活性和可定制性 (参阅 str.format(), 格式字符串语法 和 自定义字符串格式化) 而另一种是基于 C printf 样式的格式化，它可处理的类型范围较窄，并且更难以正确使用，但对于它可处理的情况往往会更为快速 (printf 风格的字符串格式化)。

标准库的 文本处理服务 部分涵盖了许多其他模块，提供各种文本相关工具（例如包含于 re 模块中的正则表达式支持）。

返回原字符串的副本，其首个字符大写，其余为小写。

返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。

消除大小写类似于转为小写，但是更加彻底一些，因为它会移除字符串中的所有大小写变化形式。 例如，德语小写字母 "ß" 相当于 "ss"。 由于它已经是小写了，lower() 不会对 "ß" 做任何改变；而 casefold() 则会将其转换为 "ss"。

消除大小写算法的描述请参见 Unicode 标准的 3.13 节。

3.3 新版功能.

返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。

反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。

返回原字符串编码为字节串对象的版本。 默认编码为 "utf-8"。 可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 "strict"，表示编码错误会引发 UnicodeError。 其他可用的值为 "ignore", "replace", "xmlcharrefreplace", "backslashreplace" 以及任何其他通过 codecs.register_error() 注册的值，请参阅 Error Handlers 小节。 要查看可用的编码列表，请参阅 标准编码 小节。

在 3.1 版更改: 加入了对关键字参数的支持。

如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。 每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。 要展开字符串，当前列将被设为零并逐一检查字符串中的每个字符。 如果字符为制表符 (	)，则会在结果中插入一个或多个空格符，直到当前列等于下一个制表位。 （制表符本身不会被复制。） 如果字符为换行符 (
) 或回车符 (
)，它会被复制并将当前列重设为零。 任何其他字符会被不加修改地复制并将当前列加一，不论该字符在被打印时会如何显示。

    >>> "01	012	0123	01234".expandtabs()
    "01      012     0123    01234"
    >>> "01	012	0123	01234".expandtabs(4)
    "01  012 0123    01234"

返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。

注解

find() 方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，请使用 in 操作符:

    >>> "Py" in "Python"
    True

执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。

    >>> "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(**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 新版功能.

类似于 find()，但在找不到子类时会引发 ValueError。

如果字符串中至少有一个字符且所有字符均为字母或数字则返回真值，否则返回假值。 如果以下方法中的一个返回 True 则字符 c 为字母或数字: c.isalpha(), c.isdecimal(), c.isdigit(), or c.isnumeric()。

如果字符串中至少有一个字符且所有字符均为字母则返回真值，否则返回假值。 字母类字符是在 Unicode 字符数据库中被定义为 "Letter" 的字符，即一般分类特征属性为 "Lm", "Lt", "Lu", "Ll" 或 "Lo" 其中之一。 请注意这不同于 Unicode 标准所定义的 "Alphabetic" 特征属性。

如果字符串为空或所有字符均为 ASCII 字符则返回真值，否则返回假值。 ASCII 字符的码位范围为 U+0000-U+007F。

3.7 新版功能.

如果字符串中至少有一个字符且所有字符均为十进制数字符则返回真值，否则返回假值。 十进制数字符是以 10 为基数的计数制会用来组成数值的字符，例如 U+0660, ARABIC-INDIC DIGIT ZERO。 正式的定义为：十进制数字符就是 Unicode 一般分类 "Nd" 中的字符。

如果字符串中至少有一个字符且所有字符均为数字字符则返回真值，否则返回假值。 数字字符包括十进制数字符和需要特别处理的数字，例如兼容性上标数字。 这也涵盖了不能被用来组成以 10 为基数的数值的数字，例如 Kharosthi 数字。 正式的定义为：数字字符就是特征属性值 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。

如果字符串根据语言定义属于有效的标识符则返回真值，参见 标识符和关键字。

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

如果字符串中至少有一个区分大小写的字符  且此类字符均为小写则返回真值，否则返回假值。

如果字符串中至少有一个字符且所有字符均为数值字符则返回真值，否则返回假值。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定义为：数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。

如果字符串中所有字符均为可打印字符或字符串为空则返回真值，否则返回假值。 不可打印字符是在 Unicode 字符数据库中被定义为 "Other" 或 "Separator" 的字符，例外情况是 ASCII 空格字符 (0x20) 被视作可打印字符。 （请注意在此语境下可打印字符是指当对一个字符串发起调用 repr() 时不必被转义的字符。 它们与字符串写入 sys.stdout 或 sys.stderr 时所需的处理无关。）

如果字符串中至少有一个字符且所有字符均为空白字符则返回真值，否则返回假值。 空白字符是在 Unicode 字符数据库中被定义为 "Other" 或 "Separator" 并且其双向特征属性为 "WS", "B" 或 "S" 之一的字符。

如果字符串中至少有一个字符且为标题字符串则返回真值，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回假值。

如果字符串中至少有一个区分大小写的字符 , 具此类字符均为大写则返回真值，否则返回假值。

返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。

返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

返回原字符串的副本，其所有区分大小写的字符 4 均转换为小写。

所用转换小写算法的描述请参见 Unicode 标准的 3.13 节。

返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:

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

此静态方法返回一个可供 str.translate() 使用的转换对照表。

如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、（任意长度的）字符串或 None 的字典。 字符键将会被转换为码位序号。

如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。 如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。

在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。

返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。

返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。

类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。

返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 除了从右边开始拆分，rsplit() 的其他行为都类似于下文所述的 split()。

返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:

    >>> "   spacious   ".rstrip()
    "   spacious"
    >>> "mississippi".rstrip("ipz")
    "mississ"

返回一个由字符串内单词组成的列表，使用 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"]

返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。

此方法会以下列行边界进行拆分。 特别地，行边界是 universal newlines 的一个超集。

在 3.2 版更改: v 和 f 被添加到行边界列表

例如:

    >>> "ab c

de fg
kl
".splitlines()
    ["ab c", "", "de fg", "kl"]
    >>> "ab c

de fg
kl
".splitlines(keepends=True)
    ["ab c
", "
", "de fg
", "kl
"]

不同于 split()，当给出了分隔字符串 sep 时，对于空字符串此方法将返回一个空列表，而末尾的换行不会令结果中增加额外的行:

    >>> "".splitlines()
    []
    >>> "One line
".splitlines()
    ["One line"]

作为比较，split("
") 的结果为:

    >>> "".split("
")
    [""]
    >>> "Two lines
".split("
")
    ["Two lines", ""]

如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

返回原字符串的副本，移除其中的前导和末尾字符。 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"

返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。

返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。

例如:

    >>> "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."

返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。 当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。

你可以使用 str.maketrans() 基于不同格式的字符到字符映射来创建一个转换映射表。

另请参阅 codecs 模块以了解定制字符映射的更灵活方式。

返回原字符串的副本，其中所有区分大小写的字符 4 均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。

所用转换大写算法的描述请参见 Unicode 标准的 3.13 节。

返回原字符串的副本，在左边填充 ASCII "0" 数码使其长度变为 width。 正负值前缀 ("+"/"-") 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。

例如:

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

注解

此处介绍的格式化操作具有多种怪异特性，可能导致许多常见错误（例如无法正确显示元组和字典）。 使用较新的 格式化字符串字面值，str.format() 接口或 模板字符串 有助于避免这样的错误。 这些替代方案中的每一种都更好地权衡并提供了简单、灵活以及可扩展性优势。

字符串具有一种特殊的内置操作：使用 % (取模) 运算符。 这也被称为字符串的 格式化 或 插值 运算符。 对于 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.

在此情况下格式中不能出现 * 标记符（因其需要一个序列类的参数列表）。

转换旗标为：

可以给出长度修饰符 (h, l 或 L)，但会被忽略，因为对 Python 来说没有必要 -- 所以 %ld 等价于 %d。

转换类型为：

![图片上传中...]

注释:

此替代形式会在第一个数码之前插入标示八进制数的前缀 ("0o")。

此替代形式会在第一个数码之前插入 "0

取决于是使用 "x" 还是 "X" 格式）。

此替代形式总是会在结果中包含一个小数点，即使其后并没有数码。

小数点后的数码位数由精度决定，默认为 6。

此替代形式总是会在结果中包含一个小数点，末尾各位的零不会如其他情况下那样被移除。

小数点前后的有效数码位数由精度决定，默认为 6。

7; 如果精度为 N，输出将截短为 N 个字符。

参见 PEP 237。

由于 Python 字符串显式指明长度，%s 转换不会将 "0" 视为字符串的结束。

在 3.1 版更改: 绝对值超过 1e50 的 %f 转换不会再被替换为 %g 转换。

上一篇文章：Python标准库---11、内置类型:迭代器类型、序列类型（list-typle-range）
下一篇文章：Python标准库---13、内置类型：二进制序列类型 ( bytes, bytearray, memoryview)