Python 3.7.1 模块 string

源代码： Lib/string.py

也可以看看 str类型及方法

1. 字符串常量

源码定义如下：

whitespace = ' \t\n\r\v\f'
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_letters = ascii_lowercase + ascii_uppercase
digits = '0123456789'
hexdigits = digits + 'abcdef' + 'ABCDEF'
octdigits = '01234567'
punctuation = r"""!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"""
printable = digits + ascii_letters + punctuation + whitespace

在这个模块中定义的常量如下：

string.ascii_letters

ascii_lowercase + ascii_uppercase的结果 。该值不依赖于本地设置。

string.ascii_lowercase

小写字母 a-z.该值不依赖于本地设置以及不会被修改。

string.ascii_uppercase

大写字母 A-Z.该值不依赖于本地设置以及不会被修改。

string.digits

字符串 0-9.

string.hexdigits

十六进制数字对应的字符串 '0123456789abcdefABCDEF'.

string.octdigits

八进制数字对应字符串'01234567'.

string.punctuation

在 C语言 中被定义为ASCII 字符的字符集合而成的字符串

string.printable

被定义为printable的ASCII 字符集合而成的字符串，这是一个包含了 digits + ascii_letters + punctuation + whitespace 的组合

string.whitespace

包含所有ASCII中可当作空白的字符集合而成的字符串。这包括字符间的空格、 tab、 换行符(\n)、 return(\r)、 换页符(\f)和垂直制表符（\v -> vertical tab）。

2. 自定义字符串格式

内置string类提供了通过format()方法 执行复杂变量替换和值格式化的功能，参见PEP 3101。string模块中的Formatter类允许您使用与内置format()方法相同的实现来创建和自定义您自己的字符串格式化行为。

2.1 class string.Formatter

Formatter 类有下列公共方法：

format（format_string，* args，** kwargs ）
主要的API方法。它采用格式字符串和一组任意位置和关键字参数。它只是一个调用vformat()的包装器。

在python 3.7中更改：格式字符串参数现在 positional-only(只能由位置提供的参数)。

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 ）
给定parse()中返回的field_name（参见上文），将其转换为要格式化的对象。返回一个元组（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参数就是其中的关键字参数字典。

对于复合字段名称，仅为字段名称的第一个组件调用这些函数; 后续组件通过常规属性和索引操作来处理。

因此，例如，字段表达式“0.name”将导致 get_value()使用键参数0 调用。通过调用getattr()内置函数返回name 后将查找该属性。get_value()

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

    def get_value(self, key, args, kwargs):
        if isinstance(key, int):
            return args[key]
        else:
            return kwargs[key]

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

format_field（value，format_spec ）
format_field()只简单地调用全局format()内置函数。提供该方法以便子类可以覆盖它。

convert_field（价值，转换）
根据给定的转换类型（如parse()方法返回的元组）转换值（get_field()返回值）。默认版本理解's'（str），'r'（repr）和'a'（ascii）转换类型。

---

译者实例，这里提供一个简单的使用string.Formatter类的例子：

def string_format():
    from string import Formatter
    sf = Formatter()
    
    ostr = '{1},Mr {0!s}! Your gf {gfname} is arriving as {time}'
    tuple_param = ('leng','hello','feng')
    dict_param = {"gfname": "qian", "time":"3:40"}
    
    print(sf.format(ostr,*tuple_param,**dict_param))
# 输出结果
hello,Mr leng! Your gf qian is arriving as 3:40

这里注意一下列表参数和字典参数的传入方式，*和**。

---

3. 格式字符串语法

str.format()方法和Formatter 类共享格式字符串的相同语法（尽管在Formatter子类中，可以定义自己的格式字符串语法）。语法与格式化字符串文字的语法相关，但存在差异。

格式字符串包含由大括号{}括起的“替换字段” 。除了大括号中的任何内容都被视为文本，它将不加改变地复制到输出中。如果你需要在文字文本中包含一个大括号字符，可以通过加倍{{}}来转义它。

替换字段 的语法如下：

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，前面有一个:。这些指定非默认格式的替换值。
另请参阅 格式规范迷你语言 部分。

---

译者实例，先看这个例子，再看下面的大段解释文字，才能更好理解文档的意思：

a = 'hello\n'
print("{1!s}mr {0!r:*^30},you arriving at }{{time!s}}}".format("leng\n",a,time="3:40"))
# 输出结果
hello
mr ***********'leng\n'***********,you arriving at {3:40}

解释一下：
（1）!之前就是field_name，可以是索引数字，也可以是字典中的键（也就是parse（format_string ）函数返回的field_name)
（2）!之后跟一个字符，这里跟了s和r，分别是str和raw的缩写，结果很明显，r原样输出了字符串里的\n，s转义了\n
（3）:之后就是format_spec部分，这里是让0位置的参数居中显示，两边用*填充，更多format_spec的用法在后面说
（4）输出{time}，用了两层{}包裹一个待格式化的{}

---

field_name

field_name本身开始于arg_name，arg_name是一个数字或一个关键字。如果它是一个数字，它引用一个位置参数，如果它是一个关键字，它引用一个命名关键字参数。如果格式字符串中的数字arg_names按顺序为0,1,2，…，它们都可以省略，数字0,1,2，…将按顺序自动插入。由于arg_name不是引号分隔的，因此无法在格式字符串中指定任意字典键（例如，字符串’10’或’:-]’）。arg_name之后可以进行任何数量的索引或属性表达式。表达式.name选择使用getattr()查找属性，而表达式[index]使用__getitem__()进行索引查找。

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

在版本3.4中的更改：使用Formatter可以省略位置参数说明符。

例子：

"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

conversion在格式化之前会进行类型强制转换。通常，格式化值的工作是通过值本身的__format__()方法完成的。但是，在某些情况下，最好强制将类型格式化为字符串，从而覆盖其自己的格式定义。通过在调用__format__()之前将值转换为字符串，可以绕过普通的格式化逻辑。

目前支持三种conversion 标志：!s调用str() 值，!r调用repr()和!a调用 ascii()。

"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字段内部还可以嵌套替换字段。这些嵌套的替换字段可能包含field_name，conversion和format_spec，但不允许更深的嵌套。在解释format_spec字符串之前，format_spec中的替换字段将被替换。这允许动态指定值的格式。

有关示例，请参阅格式示例部分。

3.1 格式规范Mini-Language

3.1.1 定义

format_spec用于格式字符串中包含的替换字段中，以定义各个值的显示方式（请参阅 格式字符串语法和格式化字符串文字）。它们也可以直接传递给内置 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" | "%"

3.1.2 各选项的含义

align

如果指定了有效的对齐值(align)，则可以在其前面加上填充字符（fill, 可以是任何字符的，除了{和}），如果省略则默认为空格。但是，可以插入带有嵌套替换字段的花括号。

各种align选项的含义如下：

对齐方式	含义
<	左对齐字段，默认用空格填充
>	右对齐字段，默认用空格填充
^	居中对齐字段，默认用空格填充
=	强制将填充物放在符号和数字中间，用于’+0000120’这种格式的数字，只能应用于数字类型，当0紧接在字段宽度之前，成为默认的填充值

例子：

def str_format():
    print("{0:-<30}".format('left'))
    print("{0:>30}".format('right'))
    print("{0:*^30}".format('center'))
    print("{0:=+08}".format(120))
    print("{0:0=+8}".format(120))
# 输出结果
left--------------------------
                         right
************center************
+0000120
+0000120

后两个输出语句一致，其用法都是一样的，都用0来填充。

sign

sign 选项只支持数字类型，可以是如下选项之一

选项	含义
+	数字的符号符号会被显示，数字可以是正数或负数
-	负数的符号会被显示，正数的符号用填充物占位（默认行为）
	正数会显示前导填充物，符号为为空，负数会显示符号和前导填充物

def str_format2():
    print("{:0=+8}".format(123))
    print("{:0=+8}".format(-123))
    print("{:0=-8}".format(123))
    print("{:0=-8}".format(-123))
    print("{:0= 8}".format(123))
    print("{:0= 8}".format(-123))
    print("{:0=8}".format(123))
    print("{:0=8}".format(-123))
# 输出结果
+0000123
-0000123
00000123
-0000123
 0000123
-0000123
00000123
-0000123

# 选项

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

例子：

def str_jing():
    a = 123.456
    b = 3e-7
    c = "%g" %(6.000)
    print("{},{:#x},{:#o},{:#b}".format(a,int(a),int(a),int(a)))
    print("{},{:x},{:o},{:b}".format(a, int(a), int(a), int(a)))
    print("{:#},{:#},{:#},{:#G}".format(a,b,6.000,,6.000))
#输出结果
123.456,0x7b,0o173,0b1111011
123.456,7b,173,1111011
123.456,3.e-07,6.0,6.000

, 选项

,选项表示千位分隔符。对于区域设置感知分隔符，请改用n。
版本：在3.1版中更改，添加了,选项（另请参阅PEP 378）。

print("{0:,},{0:_}".format(123456789))
#输出结果
123,456,789,123_456_789

_ 选项

_选项表示对数字分隔符使用下划线表示浮点表示类型和整数表示类型’d’。对于整数呈现类型’b’， ‘o’，‘x’，和’X’，下划线将每4位插入。对于其他演示文稿类型，指定此选项是错误的。
版本：在版本3.6中更改，添加了’_'选项（另请参阅PEP 515）。

print("{0:_},{0:_x}".format(123456789))
#输出结果
123_456_789,75b_cd15

width

width是定义最小字段宽度的十进制整数。如果未指定，则字段宽度将由内容确定。

如果没有给出显式对齐，则使用0来填充。这等同于align选项的=。

precision

precision(精度) 是指示浮点型数据f和F 的小数点之后应该有多少数字，或f和F 转化为g或G之前。对于非数字类型，该字段表示最大字段大小 - 换句话说，将使用字段内容中的前N个字符数。precision不允许应用于整数值。

def str_pre():
    a = 11123.45600
    b = 'hello, mr leng!'
    #c ='!'
    print("{0:8.2f},{0:8.8f},{0:8.8G}".format(a))
    print("{0:s}\n{0:.5s}\n{1:.5%}".format(b,a))
# 输出结果
11123.46,11123.45600000,11123.456
hello, mr leng!
hello
1112345.60000%

type

最后，type确定应如何呈现数据。

（1）可用的字符串表示类型是：

类型	含义
‘s’	字符串格式。这是字符串的默认类型，可以省略。
None	同’s’

（2）可用的整数表示类型是：

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

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

浮点和小数值的可用表示类型是：

类型	含义
‘e’	指数表示法。使用字母“e”以科学记数法打印数字以表示指数。默认精度为6。
‘E’	指数表示法。同e，只是可以用大写表示
‘f’	定点表示法。将数字显示为定点数。默认精度为6。
‘F’	定点表示法。同’f’，但转换 nan到 NAN，inf到INF
‘g’	一般格式。 1. 对于给定的精度(p >= 1)，将数字舍入为p位有效数字，然后根据其大小以定点格式或科学计数法格式化结果。 2. 精确的规则如下：假设结果格式中存在类型 ‘e’ 和精度 p-1，结果将具有指数exp。然后如果-4 <= exp < p，数字将被格式化为类型’f’和精度p-1-exp 。否则，使用类型’e’和 精度 p-1 格式化数字。在这两种情况下，从有效数字中删除不重要的尾随零，如果后面没有剩余数字，则也会删除小数点。 3. 正负无穷大，正负零和NaN，分别被格式化为inf和-inf， 0，-0和nan，而不管精度。 4. 精度0被视为等于精度1。默认精度为6。
‘G’	一般格式。与’g’相同，除了一种情况， 如果数字太大，转换为’E’。无穷大和NaN的表示也是大写的。
‘n’	数字。'与’g’相同，除了一种情况，除了它使用当前语言环境设置插入适当的数字分隔符之外，它是相同的。
‘%’	百分比。将数字乘以100并以（‘f’）格式显示，后跟百分号。
None	类似于’g’，除了定点表示法，使用时，小数点后至少有一位数字。默认精度与表示特定值所需的一样。总体效果是匹配由其他格式修饰符更改的str()输出。

3.2. 格式化示例

（1）按位置访问参数：

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

（2）按名称访问参数：

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

（3）访问这些参数的属性：

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

（4）访问参数的项：

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

（5）替换%s和%r：

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

（6）替换%+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'

（7）替换%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'

（8）表示百分比：

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

（9）使用特定于类型的格式：

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

（10）嵌套参数和更复杂的例子：

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

4. strings模板

模板字符串提供更简单的字符串替换，如 PEP 292 中所述 。模板字符串的主要用途是国际化（i18n），因为在该上下文中，更简单的语法和功能使其比Python中的其他内置字符串格式化工具更容易翻译。作为基于i18n模板字符串构建的库的示例，请参阅 flufl.i18n 软件包。

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

• $$是转义; 它被替换为单个$。
• $identifier命名匹配 映射键名为identifier的值。默认情况下，"identifier"仅限于以下划线或ASCII字母开头的任何不区分大小写的ASCII字母数字字符串（包括下划线）。字符$后面的第一个非标识符字符终止此占位符规范。
• ${identifier}相当于$identifier。当有效标识符字符在占位符后面但不是占位符的一部分时，例如，${noun} ification。

$字符串中的任何其他情况都将导致ValueError报错。

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

4.1 class string.Template(template)

构造函数接收单个参数，即模板字符串。

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

safe_substitute（mapping，** kwds ）
同substitute()，除了一种情况， mapping和kwds中如果缺少占位符， 不引发KeyError异常，原始占位符将在结果字符串中完整显示。此外，与substitute()不同的是，任何其他形式的$只会返回$而不是抛出ValueError。

虽然可能仍会出现其他异常，但此方法称为“安全”，因为它总是尝试返回可用的字符串而不是引发异常。在另一种意义上，safe_substitute()可能是安全以外的任何东西，因为它会默默地忽略包含悬空分隔符，无法匹配的大括号或不是有效Python标识符的占位符的格式错误的模板。

Template 实例还提供一个public 数据属性：

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'

4.1.1 高级用法

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

delimiter - 这是描述占位符引入分隔符的文字字符串。默认值为$。请注意，这 不应该是正则表达式，因为根据需要，实现可能会用 re.escape()调用此字符串。还要注意，在创建类之后不能更改分隔符（即必须在子类的类命名空间中设置不同的分隔符）。

idpattern - 这是描述非占位符模式的正则表达式。默认值是正则表达式 (?a:[_a-z][_a-z0-9]*)。如果给出了这个并且braceidpattern是None，此模式也将适用于占位符。

注意 由于默认标志是re.IGNORECASE，因此模式[a-z]可以与某些非ASCII字符匹配。这就是我们在这里使用本地a flag的原因。
版本：python 3.7中更改-> braceidpattern可用于定义大括号内部和外部使用的单独模式。

braceidpattern - 这类似于idpattern，但描述了支撑占位符的模式。默认值None意味着回 退到idpattern（即在括号内部和外部使用相同的模式）。如果给定，则允许您为占位和占位符定义不同的模式。

版本：3.7中的新功能。

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

版本：3.2中的新功能。

4.1.2 其他

或者，您可以通过覆盖类属性模式来提供整个正则表达式模式。如果执行此操作，则该值必须是具有四个命名捕获组的正则表达式对象。捕获组对应于上面给出的规则以及无效的占位符规则：

• escaped - 此组匹配转义序列，例如，默认模式$$。
• named - 此组匹配未支撑的占位符名称; 它不应该包括捕获组中的分隔符。
• braced - 此组匹配括号括号占位符名称; 它不应该包括捕获组中的分隔符或大括号。
• invalid - 此组匹配任何其他分隔符模式（通常是单个分隔符），它应该出现在正则表达式的最后。

5. 帮助函数

string.capwords(s,sep=None)

使用str.split()将参数拆分为单词，使用str.capitalize()将每个单词大写，并使用str.join()拼接大写单词 。如果没有可选的第二个参数sep或者None，空格字符的运行被单个空格替换，并且删除了前导和尾随空格，否则sep用于拆分和连接单词。

译者例子：

def str_capwords():
    import string
    s = "\thEllo, mr Leng's wife mR's QiAN"
    s1 = "\t@hEllo, @mr @Leng's @wife mR's @QiAN"
    print(string.capwords(s))
    print(string.capwords(s1,sep='@'))
# 输出结果
Hello, Mr Leng's Wife Mr's Qian
	@Hello, @Mr @Leng's @Wife mr's @Qian

分析：
（1）sep参数的作用其实就是你手动确定单词开始的边界。
（2）此方法 比 str.title()好，好处是去掉了titile方法对于单词边界判断模糊的问题。