string —常见的字符串操作

源代码： Lib/string.py

String constants

此模块中定义的常量为：

• string. ascii_letters

  • 如下所述的ascii_lowercase和ascii_uppercase常量的串联。此值不依赖于语言环境。

• string. ascii_lowercase

  • 小写字母'abcdefghijklmnopqrstuvwxyz'。此值不依赖于语言环境，并且不会更改。

• string. ascii_uppercase

  • 大写字母'ABCDEFGHIJKLMNOPQRSTUVWXYZ'。此值不依赖于语言环境，并且不会更改。

• string. digits

  • 字符串'0123456789'。

• string. hexdigits

  • 字符串'0123456789abcdefABCDEF'。

• string. octdigits

  • 字符串'01234567'。

• string. punctuation

  • ASCII 字符串，在C语言环境“ !"#$%&'()*+,-./:;<=>?@[\]^_{|}~`”中被视为标点符号。

• string. printable

  • 视为可打印的 ASCII 字符字符串。这是digits，ascii_letters，punctuation和whitespace的组合。

• string. whitespace

  • 一个字符串，其中包含所有被视为空格的 ASCII 字符。这包括字符空格，制表符，换行符，返回符，换页符和垂直制表符。

自定义字符串格式

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

• 类别 string. Formatter

  • Formatter类具有以下公共方法：

• format(* format_string ，/*， *args ， * kwargs *)

  • 主要的 API 方法。它采用格式字符串以及任意一组位置和关键字参数。它只是一个调用vformat()的包装器。

在版本 3.7 中更改：格式字符串参数现在为positional-only。

• vformat(* format_string ， args ， kwargs *)
  • 此Function执行格式化的实际工作。对于要传递 sched 义的参数字典，而不是使用*args和**kwargs语法将字典作为单个参数解压缩和重新打包的情况，它作为单独的函数公开。 vformat()完成将格式字符串分解为字符数据和替换字段的工作。它调用下面描述的各种方法。

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

• parse(* format_string *)
  • 循环遍历 format_string 并返回一个可迭代的 Tuples(* literal_text ， field_name ， format_spec ， conversion *)。 vformat()使用它来将字符串分成 Literals 文本或替换字段。

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

• get_field(* field_name ， args ， kwargs *)

  • 给定parse()返回的* field_name *(请参见上文)，将其转换为要格式化的对象。返回一个 Tuples(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 *参数设置为关键字参数的字典。

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

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

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

• check_unused_args(* used_args ， args ， kwargs *)

  • 如果需要，实现检查未使用的参数。此函数的参数是格式字符串中实际引用的所有参数键的集合(位置参数为整数，命名参数为字符串)，以及对传递给的* args 和 kwargs *的引用 vformat。可以从这些参数中计算出未使用的参数集。如果检查失败，则认为check_unused_args()引发异常。

• format_field(* value ， format_spec *)

  • format_field()简单地调用内置的全局format()。提供了该方法，以便子类可以覆盖它。

• convert_field(* value ， conversion *)

  • 给定转换类型(如parse()方法返回的 Tuples)，转换值(由get_field()返回)。默认版本可以理解's'(str)，'r'(repr)和'a'(ascii)转换类型。

格式字符串语法

str.format()方法和Formatter类对格式字符串共享相同的语法(尽管在Formatter的情况下，子类可以定义自己的格式字符串语法)。语法与格式化的字符串 Literals的语法有关，但是存在差异。

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

替换字段的语法如下：

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

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

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

• field_name 本身以 arg_name 开头，可以是数字或关键字。如果是数字，则表示位置参数，如果是关键字，则表示命名关键字参数。如果格式字符串中的数字 arg_name 依次为 0、1、2，…，则可以全部Ellipsis(不只是某些数字)，并且数字 0、1、2，…将按该 Sequences 自动插入。由于 arg_name *不是用引号引起来的，因此无法在格式字符串中指定任意字典键(例如，字符串'10'或':-]')。 * arg_name *后可以跟任意数量的索引或属性表达式。形式'.name'的表达式使用getattr()选择命名的属性，而形式'[index]'的表达式使用getitem()进行索引查找。

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

在版本 3.4 中更改：Formatter可以Ellipsis位置参数说明符。

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

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

• conversion *字段在格式化之前引起类型强制转换。通常，格式化值的工作是pass值本身的format()方法完成的。但是，在某些情况下，最好强制将一种类型设置为字符串格式，以覆盖其自身对格式的定义。pass在调用format()之前将值转换为字符串，可以绕过常规的格式化逻辑。

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

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
"More {!a}"                      # Calls ascii() on the argument first

• format_spec 字段包含有关如何显示值的规范，包括字段宽度，对齐方式，填充，小数精度等详细信息。每个值类型都可以定义自己的“格式迷你语言”或 format_spec *的解释。

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

• format_spec 字段也可以在其中包含嵌套的替换字段。这些嵌套的替换字段可能包含字段名称，转换标志和格式说明，但不允许更深层的嵌套。在解释 format_spec *字符串之前，将替换 format_spec 中的替换字段。这允许动态指定值的格式。

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

格式规范迷你语言

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

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

通常的约定是，空格式规范会产生与您在值上调用str()相同的结果。非空格式规范通常会修改结果。

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

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

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

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

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

• sign *选项仅对数字类型有效，并且可以是以下之一：

'#'选项使“替代形式”用于转换。替代形式针对不同类型的定义不同。此选项仅对整数，浮点数，复数和小数类型有效。对于整数，当使用二进制，八进制或十六进制输出时，此选项将分别将前缀'0b'，'0o'或'0x'添加到输出值。对于浮点数，复数和小数，备用格式会导致转换结果始终包含小数点字符，即使后面没有数字也是如此。通常，只有在数字后面跟随小数点字符，这些转换的结果才会出现。此外，对于'g'和'G'转换，尾随零不会从结果中删除。

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

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

'_'选项表示将下划线用于浮点表示类型和整数表示类型'd'的千位分隔符。对于'b'，'o'，'x'和'X'的整数表示类型，将每 4 位插入下划线。对于其他演示文稿类型，指定此选项是错误的。

在版本 3.6 中进行了更改：添加了'_'选项(另请参见 PEP 515)。

• width *是一个十进制整数，定义了最小总字段宽度，包括任何前缀，分隔符和其他格式字符。如果未指定，则字段宽度将由内容确定。

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

• precision 是一个十进制数字，指示对于以'f'和'F'格式化的浮点值，在小数点后或对于'g'或'G'格式化的浮点值，在小数点前和后应显示多少位数。对于非数字类型，该字段指示最大字段大小-换句话说，将从字段内容中使用多少个字符。整数值不允许使用 precision *。

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

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

可用的整数表示类型为：

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

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

Format examples

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

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

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

按位置访问参数：

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ 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:
...     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
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 86.36%'

使用特定于类型的格式：

>>> 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), end=' ')
...     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

Template strings

模板字符串提供了更简单的字符串替换，如 PEP 292中所述。模板字符串的主要用例是国际化(i18n)，因为在这种情况下，比起 Python 中的其他内置字符串格式化工具，更简单的语法和Function使其更易于翻译。作为基于 i18n 的模板字符串构建的库的示例，请参见flufl.i18n软件包。

模板字符串使用以下规则支持基于$的替换：

• $$是逃生；用一个$代替。

• $identifier命名与 Map 键"identifier"匹配的替换占位符。默认情况下，"identifier"限于以下划线或 ASCII 字母开头的任何不区分大小写的 ASCII 字母数字字符串(包括下划线)。 $字符之后的第一个非标识符字符终止此占位符规范。

• ${identifier}等效于$identifier。当有效的标识符字符位于占位符之后但不是占位符的一部分时，例如"${noun}ification"，则是必需的。

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

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

• 类别 string. Template(模板)

  • 构造函数采用单个参数，即模板字符串。

• substitute(* mapping ={} ，/，** kwds *)

  • 执行模板替换，返回一个新字符串。 * mapping 是任何类似于字典的对象，其键与模板中的占位符匹配。或者，您可以提供关键字参数，其中关键字是占位符。当同时给出 mapping 和 kwds 且有重复项时， kwds *中的占位符优先。

• safe_substitute(* mapping ={} ，/，** kwds *)

  • 类似于substitute()，除了如果* mapping 和 kwds *中缺少占位符，而不是引发KeyError异常，原始占位符将完整显示在结果字符串中。而且，与substitute()不同，$的任何其他外观都将简单地返回$而不是提高ValueError。

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

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

• template
  • 这是传递给构造函数的* 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的子类来自定义占位符语法，定界符或用于解析模板字符串的整个正则表达式。为此，您可以覆盖以下类属性：

• • delimiter * –这是描述占位符引入定界符的 Literals 字符串。默认值为$。请注意，这不应为正则表达式，因为实现将根据需要在此字符串上调用re.escape()。请进一步注意，您无法在创建类后更改定界符(即，必须在子类的类命名空间中设置其他定界符)。
• • idpattern * –这是描述非支撑占位符模式的正则表达式。默认值为正则表达式(?a:[_a-z][_a-z0-9]*)。如果给定且* braceidpattern *为None，则此模式也将应用于大括号占位符。

在版本 3.7 中更改：* braceidpattern *可用于定义在括号内和括号外使用的单独模式。

• • braceidpattern * –类似于* idpattern ，但描述了括号占位符的模式。默认为None，表示回退到 idpattern *(即，括号内外都使用相同的模式)。如果给出，则可以为括号和非括号的占位符定义不同的模式。

3.7 版中的新Function。

• • flags * –在编译用于识别替换的正则表达式时将应用的正则表达式标志。默认值为re.IGNORECASE。请注意，re.VERBOSE将始终添加到标志中，因此自定义* idpattern *必须遵循详细的常规正则表达式约定。

3.2 版中的新Function。

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

• 转义 –此组匹配转义序列，例如$$，以默认模式显示。

• • named * –该组匹配不带括号的占位符名称；它不应在捕获组中包含定界符。

• 括号 –该组与括号内的占位符名称匹配；它不应在捕获组中包含定界符或大括号。

• 无效 –该组与任何其他定界符模式(通常是单个定界符)匹配，并且应出现在正则表达式的最后。

Helper functions

• string. capwords(* s ， sep = None *)
  • 使用str.split()将自变量分解为单词，使用str.capitalize()将每个单词大写，然后使用str.join()将大写单词连接起来。如果不存在可选的第二个参数* sep 或None，则将空格字符替换为单个空格，并删除开头和结尾的空格，否则 sep *用于拆分和合并单词。