7.1. 字符串—常见的字符串操作

源代码： Lib/string.py

string模块包含许多有用的常量和类，以及一些不赞成使用的旧函数，这些函数也可以作为字符串方法使用。另外，Python 的内置字符串类支持序列类型— str，unicode，list，tuple，bytearray，buffer，xrange部分中描述的序列类型方法，以及String Methods部分中描述的特定于字符串的方法。要输出格式化的字符串，请使用模板字符串或字符串格式化操作部分中所述的%运算符。另外，有关基于正则表达式的字符串函数，请参见re模块。

7.1.1. 字符串常量

此模块中定义的常量为：

7.1.2. 自定义字符串格式

2.6 版的新Function。

内置的 str 和 unicode 类提供了pass PEP 3101中描述的str.format()方法进行复杂的变量替换和值格式化的Function。 string模块中的Formatter类允许您使用与内置format()方法相同的实现来创建和自定义自己的字符串格式设置行为。

此外，Formatter定义了许多打算由子类替换的方法：

Tuples 中的值在概念上表示 Literals 文本的范围，后跟单个替换字段。如果没有 Literals 文本(如果连续出现两个替换字段，则可能会发生)，那么* literal_text 将是一个零长度的字符串。如果没有替换字段，则 field_name ， format_spec 和 conversion *的值为None。

对于复合字段名称，仅对于字段名称的第一部分才调用这些函数；后续组件pass常规属性和索引操作进行处理。

因此，例如，字段表达式'0.name'将导致的* key *参数为 0 被调用。get_value()返回后，将pass调用内置getattr()函数来查找name属性。

如果索引或关键字引用的项目不存在，则应引发IndexError或KeyError。

7.1.3. 格式字符串语法

str.format()方法和Formatter类对格式字符串共享相同的语法(尽管在Formatter的情况下，子类可以定义自己的格式字符串语法)。

格式字符串包含用大括号{}包围的“替换字段”。花括号中不包含的所有内容均视为 Literals 文本，该文本原样复制到输出中。如果需要在 Literals 文本中包含大括号字符，可以pass加倍{{和}}进行转义。

替换字段的语法如下：

Note

replacement_field ::=  "{" [field_name] ["!" conversion] [":" format_spec] "}"
field_name        ::=  arg_name ("." attribute_name | "[" element_index "]")*
arg_name          ::=  [identifier | integer]
attribute_name    ::=  identifier
element_index     ::=  integer | index_string
index_string      ::=  <any source character except "]"> +
conversion        ::=  "r" | "s"
format_spec       ::=  <described in the next section>

用不太正式的术语来说，替换字段可以以* field_name 开头，该字段指定要格式化其值并将其插入输出的对象，而不是替换字段。可以在 field_name 后面紧跟一个 conversion 字段，该字段之前带有一个感叹号'!'，以及一个 format_spec *，后面带有一个冒号':'。这些指定替换值的非默认格式。

另请参见格式规格迷你语言部分。

在版本 2.7 中更改：str.format()和unicode.format()可以Ellipsis位置参数说明符，因此'{} {}'等效于'{0} {1}'，u'{} {}'等效于u'{0} {1}'。

一些简单的格式字符串示例：

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

当前支持两个转换标志：'!s'调用值上的str()和'!r'调用值repr()。

Some examples:

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

大多数内置类型都支持通用的格式化迷你语言，这将在下一节中进行介绍。

有关示例，请参见Format examples部分。

7.1.3.1. 格式规格迷你语言

在格式字符串中包含的替换字段中使用“格式规范”来定义如何显示各个值(请参见格式字符串语法)。它们也可以直接传递给内置的format()函数。每种格式表类型可以定义如何解释格式规范。

尽管某些格式化选项仅受数字类型支持，但大多数内置类型都为格式规范实现了以下选项。

一般约定是，空格式字符串("")会产生与您在值上调用str()相同的结果。非空格式字符串通常会修改结果。

标准格式说明符的一般形式是：

format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
fill        ::=  <any character>
align       ::=  "<" | ">" | "=" | "^"
sign        ::=  "+" | "-" | " "
width       ::=  integer
precision   ::=  integer
type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

如果指定了有效的* align 值，则可以在其前面加上 fill 字符，该字符可以是任何字符，如果Ellipsis，则默认为空格。使用str.format()方法时，不能使用 Literals 大括号(“ {”或“ }”)作为 fill *字符。但是，可以插入带有嵌套替换字段的花括号。此限制不会影响format()函数。

各种对齐选项的含义如下：

Note

Option Meaning
'<' 强制字段在可用空间内左对齐(这是大多数对象的默认设置)。
'>' 强制字段在可用空间内右对齐(这是数字的默认值)。
'=' 强制将填充放置在符号(如果有)之后但在数字之前。这用于打印格式为“ 000000120”的字段。此对齐选项仅对数字类型有效。当字段宽度紧前为“ 0”时，它将成为默认值。
'^' 强制字段在可用空间内居中。

请注意，除非定义了最小字段宽度，否则字段宽度将始终与要填充的数据大小相同，因此在这种情况下，对齐选项没有任何意义。

Note

Option Meaning
'+' 表示正号和负号都应使用符号。
'-' 指示符号只能用于负数(这是默认行为)。
space 表示应在正数上使用前导空格，在负数上使用减号。

'#'选项仅对整数有效，并且仅对二进制，八进制或十六进制输出有效。如果存在，它指定输出将分别以'0b'，'0o'或'0x'作为前缀。

','选项表示使用千位分隔符的逗号。对于可识别语言环境的分隔符，请改用'n'整数表示类型。

在 2.7 版中进行了更改：添加了','选项(另请参见 PEP 378)。

如果未给出明确的对齐方式，则在* width 字段之前加零('0')字符可启用数字类型的符号感知零填充。这等效于'0'的 fill 字符和'='的 alignment *类型。

最后，* type *确定应如何显示数据。

可用的字符串表示形式为：

Note

Type Meaning
's' 字符串格式。这是字符串的默认类型，可以Ellipsis。
None 与's'相同。

可用的整数表示类型为：

Note

Type Meaning
'b' 二进制格式。输出以 2 为底的数字。
'c' 字符。在打印之前将整数转换为相应的 unicode 字符。
'd' 十进制整数。输出以 10 为底的数字。
'o' 八进制格式。输出以 8 为底的数字。
'x' 十六进制格式。以小写字母输出 9 以后的数字，以 16 为基数输出数字。
'X' 十六进制格式。使用大写字母表示 9 以上的数字，输出以 16 为底的数字。
'n' 数。与'd'相同，除了它使用当前的语言环境设置插入适当的数字分隔符。
None 与'd'相同。

除了上述表示类型之外，还可以使用下面列出的浮点表示类型('n'和None除外)格式化整数。这样做时，float()用于在格式化之前将整数转换为浮点数。

浮点数和十进制值的可用表示形式为：

Note

Type Meaning
'e' 指数表示法。用字母“ e”以科学计数法打印数字以表示指数。默认精度为6。
'E' 指数表示法。与'e'相同，除了它使用大写字母'E'作为分隔符。
'f' 定点表示法。将数字显示为定点数字。默认精度为6。
'F' 定点表示法。与'f'相同。
'g' 通用格式。对于给定的精度p >= 1，这会将数字四舍五入为p个有效数字，然后根据结果的大小以定点格式或科学计数法格式化结果。


> 精确规则如下：假设以演示文稿类型'e'和精度p-1格式化的结果将具有exp指数。然后，如果为-4 <= exp < p，则数字将以显示类型'f'和精度p-1-exp进行格式化。否则，该数字将以显示类型'e'和精度p-1进行格式化。在这两种情况下，从有效数中除去不重要的尾随零，并且如果在其后没有剩余数字，则也除去小数点。

> 正负无穷大，正负零和 nans 分别设置为inf，-inf，0，-0和nan，而与精度无关。

> 精度0被视为等效于1。默认精度为6。
| 'G' |常规格式。与'g'相同，但如果数字太大则切换到'E'。 | ||||||||||||||||||||||||||||||||||||||。
| 'n' |编号。与'g'相同，不同之处在于它使用当前的语言环境设置来插入适当的数字分隔符。
| '%' |百分比。 |将数字乘以 100 并以固定('f')格式显示，后跟一个百分号。
|无|与'g'相同。|

7.1.3.2. 格式范例

本节包含str.format()语法的示例以及与旧%-格式的比较。

在大多数情况下，语法类似于旧的%格式，只是增加了{}，并且使用:而不是%。例如，'%03.2f'可以翻译为'{:03.2f}'。

新格式的语法还支持新的和不同的选项，如以下示例所示。

按位置访问参数：

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>> '{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be repeated
'abracadabra'

pass名称访问参数：

>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'

访问参数的属性：

>>> c = 3-5j
>>> ('The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.').format(c)
'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point(object):
...     def __init__(self, x, y):
...         self.x, self.y = x, y
...     def __str__(self):
...         return 'Point({self.x}, {self.y})'.format(self=self)
...
>>> str(Point(4, 2))
'Point(4, 2)'

访问参数项：

>>> coord = (3, 5)
>>> 'X: {0[0]};  Y: {0[1]}'.format(coord)
'X: 3;  Y: 5'

替换%s和%r：

>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"

对齐文本并指定宽度：

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

替换%+f，%-f和% f并指定符号：

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

替换%x和%o并将值转换为不同的基数：

>>> # format also supports binary numbers
>>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
>>> # with 0x, 0o, or 0b as prefix:
>>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'

使用逗号作为千位分隔符：

>>> '{:,}'.format(1234567890)
'1,234,567,890'

表达百分比：

>>> points = 19.5
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 88.64%'

使用特定于类型的格式：

>>> import datetime
>>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)
>>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
'2010-07-04 12:15:58'

嵌套参数和更复杂的示例：

>>> for align, text in zip('<^>', ['left', 'center', 'right']):
...     '{0:{fill}{align}16}'.format(text, fill=align, align=align)
...
'left<<<<<<<<<<<<'
'^^^^^center^^^^^'
'>>>>>>>>>>>right'
>>>
>>> octets = [192, 168, 0, 1]
>>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
'C0A80001'
>>> int(_, 16)
3232235521
>>>
>>> width = 5
>>> for num in range(5,12):
...     for base in 'dXob':
...         print '{0:{width}{base}}'.format(num, base=base, width=width),
...     print
...
    5     5     5   101
    6     6     6   110
    7     7     7   111
    8     8    10  1000
    9     9    11  1001
   10     A    12  1010
   11     B    13  1011

7.1.4. 模板字符串

2.4 版的新Function。

模板提供了更简单的字符串替换，如 PEP 292中所述。模板使用以下规则而不是常规的基于%的替换，而是支持基于$的替换：

字符串中$的任何其他出现都会导致ValueError引发。

string模块提供实现这些规则的Template类。 Template的方法是：

尽管仍然可能发生其他异常，但是此方法被称为“安全”，因为它总是try返回可用的字符串而不是引发异常。从另一种意义上讲，safe_substitute()可能不是安全的，因为它会默默地忽略格式错误的模板，这些模板包含悬挂的定界符，不匹配的括号或不是有效 Python 标识符的占位符。

Template个实例还提供了一个公共数据属性：

这是如何使用模板的示例：

>>> from string import Template
>>> s = Template('$who likes $what')
>>> s.substitute(who='tim', what='kung pao')
'tim likes kung pao'
>>> d = dict(who='tim')
>>> Template('Give $who $100').substitute(d)
Traceback (most recent call last):
...
ValueError: Invalid placeholder in string: line 1, col 11
>>> Template('$who likes $what').substitute(d)
Traceback (most recent call last):
...
KeyError: 'what'
>>> Template('$who likes $what').safe_substitute(d)
'tim likes $what'

高级用法：可以派生Template的子类来自定义占位符语法，定界符或用于解析模板字符串的整个正则表达式。为此，您可以覆盖以下类属性：

或者，您可以pass覆盖类属性* pattern *来提供整个正则表达式模式。如果这样做，则该值必须是带有四个命名捕获组的正则表达式对象。捕获组与上面给出的规则以及无效的占位符规则相对应：

7.1.5. 字符串函数

以下Function可用于对字符串和 Unicode 对象进行操作。它们不能作为字符串方法使用。

Note

不要使用从lowercase和uppercase派生的字符串作为参数；在某些 locale，它们的长度不一样。对于大小写转换，请始终使用str.lower()和str.upper()。

7.1.6. 不推荐使用的字符串函数

以下Function列表也定义为字符串和 Unicode 对象的方法；有关更多信息，请参见第String Methods节。您应该将这些Function视为已弃用，尽管直到 Python 3 才会将其删除。此模块中定义的Function是：

将字符串转换为浮点数。该字符串必须具有 Python 中浮点 Literals 的标准语法，可以选择在其后加上一个符号(+或-)。请注意，在传递字符串时，此行为与内置函数float()相同。

Note

传入字符串时，可能会返回 NaN 和 Infinity 的值，具体取决于基础 C 库。导致这些值返回的特定字符串集合完全取决于 C 库，并且已知会有所不同。

将字符串* s 转换为给定 base *中的整数。该字符串必须由一个或多个数字组成，并可以在其后加上一个符号(+或-)。 * base *默认为 10.如果为 0，则根据字符串的前导字符(去除符号后)选择默认的基数：0x或0X表示 16，0表示 8，其他表示 10. base *为 16，尽管不是必需的，但始终接受前导0x或0X。传递字符串时，其行为与内置函数int()相同。 (另请注意：要更灵活地解释数字 Literals，请使用内置函数eval()。)

将字符串* s 转换为给定 base *中的长整数。该字符串必须由一个或多个数字组成，并可以在其后加上一个符号(+或-)。 * base 参数的含义与atoi()相同。除非末尾为 0，否则不允许尾随l或L。请注意，在不带 base 或将 base *设置为 10 的情况下调用时，此行为与传递字符串时的内置函数long()相同。

空字符串的 split 行为取决于* sep 的值。如果未指定 sep 或指定为None，则结果将为空列表。如果将 sep *指定为任何字符串，则结果将是一个包含一个元素的列表，该元素为空字符串。

2.4 版的新Function。

在版本 2.2.3 中更改：添加了* chars *参数。 * chars *参数不能在 2.2 以前的版本中传递。

在版本 2.2.3 中更改：添加了* chars *参数。 * chars *参数不能在 2.2 以前的版本中传递。

在版本 2.2.3 中更改：添加了* chars *参数。 * chars *参数不能在 2.2 以前的版本中传递。

首页