7.1. string — 常见的字符串操作 — Python 文档

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

源代码： :source:`Lib/string.py`

---

string 模块包含许多有用的常量和类，以及一些已弃用的遗留函数，这些函数也可用作字符串的方法。 此外，Python 的内置字符串类支持 序列类型 — str、unicode、列表、元组、字节数组、缓冲区、xrange 部分中描述的序列类型方法，以及在 字符串方法 部分。 要输出格式化字符串，请使用模板字符串或 字符串格式化操作 部分中描述的 % 运算符。 另请参阅 re 模块以了解基于正则表达式的字符串函数。

7.1.1. 字符串常量

该模块中定义的常量是：

string.ascii_letters

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

string.ascii_lowercase

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

string.ascii_uppercase

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

string.digits

字符串 '0123456789'。

string.hexdigits

字符串 '0123456789abcdefABCDEF'。

string.letters

字符串 lowercase 和 uppercase 的串联如下所述。 具体值取决于语言环境，会在调用 locale.setlocale() 时更新。

string.lowercase

包含所有被视为小写字母的字符的字符串。 在大多数系统上，这是字符串 'abcdefghijklmnopqrstuvwxyz'。 具体值取决于语言环境，会在调用 locale.setlocale() 时更新。

string.octdigits

字符串 '01234567'。

string.punctuation

在 C 语言环境中被视为标点字符的 ASCII 字符字符串。

string.printable

被视为可打印的字符串。 这是数字、字母、标点和空格的组合。

string.uppercase

包含所有被视为大写字母的字符的字符串。 在大多数系统上，这是字符串 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'。 具体值取决于语言环境，会在调用 locale.setlocale() 时更新。

string.whitespace

包含所有被视为空格的字符的字符串。 在大多数系统上，这包括字符空格、制表符、换行符、回车、换页和垂直制表符。

7.1.2. 自定义字符串格式

2.6 版中的新功能。

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

class string.Formatter

Formatter 类具有以下公共方法：

format(format_string, *args, **kwargs)

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

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() 以 key 参数为 0 被调用。 name 属性会在 get_value() 返回后通过调用内置的 getattr() 函数来查找。

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

check_unused_args(used_args, args, kwargs)

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

format_field(value, format_spec)

format_field() 只是调用内置的全局 format()。 提供该方法以便子类可以覆盖它。

convert_field(value, conversion)

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

7.1.3. 格式化字符串语法

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

格式字符串包含用大括号 {} 包围的“替换字段”。 大括号中未包含的任何内容都被视为文字文本，将原样复制到输出中。 如果需要在文字文本中包含大括号字符，可以通过加倍转义：{{ 和 }}。

替换字段的语法如下：

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，前面是冒号 ':'。 这些指定替换值的非默认格式。

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

field_name 本身以 arg_name 开头，它可以是数字或关键字。 如果是数字，则表示位置参数，如果是关键字，则表示命名关键字参数。 如果格式字符串中的数字 arg_names 依次为 0, 1, 2, ... ，它们都可以省略（不仅仅是一些），并且数字 0, 1, 2, ... 将按该顺序自动插入。 因为 arg_name 不是引号分隔的，所以不能在格式字符串中指定任意的字典键（例如，字符串 '10' 或 ':-]'）。 arg_name 后面可以跟任意数量的索引或属性表达式。 '.name' 形式的表达式使用 getattr() 选择命名属性，而 '[index]' 形式的表达式使用 __getitem__() 进行索引查找。

2.7 版本变更：str.format() 和 unicode.format() 的位置参数说明符可以省略，所以 '{} {}' 等价于 '{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'.

conversion 字段在格式化之前导致类型强制。 通常，格式化值的工作由值本身的 __format__() 方法完成。 但是，在某些情况下，需要强制将类型格式化为字符串，覆盖其自己的格式化定义。 通过在调用 __format__() 之前将值转换为字符串，绕过了正常的格式化逻辑。

当前支持两种转换标志：'!s' 调用 str() 值，以及 '!r' 调用 repr()。

一些例子：

"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_spec 字段包含如何呈现值的规范，包括字段宽度、对齐方式、填充、小数精度等细节。 每个值类型都可以定义自己的“格式化迷你语言”或对 format_spec 的解释。

大多数内置类型都支持通用格式迷你语言，这将在下一节中描述。

format_spec 字段还可以在其中包含嵌套的替换字段。 这些嵌套的替换字段可能包含字段名称、转换标志和格式规范，但不允许更深的嵌套。 format_spec 中的替换字段在解释 format_spec 字符串之前被替换。 这允许动态指定值的格式。

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

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 字符，该字符可以是任何字符，如果省略则默认为空格。 使用 str.format() 时，不能使用文字花括号（“{”或“}”）作为 fill 字符 方法。 但是，可以插入带有嵌套替换字段的花括号。 此限制不会影响 format() 函数。

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

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

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

sign 选项只对数字类型有效，可以是以下之一：

选项	意义
'+'	表示正数和负数都应使用一个符号。
'-'	表示一个符号应该只用于负数（这是默认行为）。
空间	表示应在正数上使用前导空格，在负数上使用减号。

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

',' 选项表示使用逗号作为千位分隔符。 对于区域设置感知分隔符，请改用 'n' 整数表示类型。

在 2.7 版中更改： 添加了 ',' 选项（另见 PEP 378）。

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

如果没有给出明确的对齐方式，在 width 字段前面加上一个零 ('0') 字符可以为数字类型启用符号感知零填充。 这等效于 '0' 的 fill 字符和 '=' 的 alignment 类型。

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

最后，type 决定了数据的呈现方式。

可用的字符串表示类型有：

类型	意义
's'	字符串格式。 这是字符串的默认类型，可以省略。
None	与 's' 相同。

可用的整数表示类型有：

类型	意义
'b'	二进制格式。 输出以 2 为底的数字。
'c'	特点。 在打印之前将整数转换为相应的 unicode 字符。
'd'	十进制整数。 输出以 10 为底的数字。
'o'	八进制格式。 输出基数为 8 的数字。
'x'	十六进制格式。 输出以 16 为基数的数字，对 9 以上的数字使用小写字母。
'X'	十六进制格式。 输出以 16 为基数的数字，9 以上的数字使用大写字母。
'n'	数字。 这与 'd' 相同，不同之处在于它使用当前区域设置来插入适当的数字分隔符。
None	与 'd' 相同。

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

浮点和十进制值的可用表示类型有：

类型	意义
'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'。 无穷大和 NaN 的表示也是大写的。
'n'	数字。 这与 'g' 相同，不同之处在于它使用当前区域设置来插入适当的数字分隔符。
'%'	百分比。 将数字乘以 100 并以固定 ('f') 格式显示，后跟百分号。
None	与 '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'

按名称访问参数：

>>> '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 版中的新功能。

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

• $$ 是一个逃生； 它被替换为单个 $。
• $identifier 命名与 "identifier" 的映射键匹配的替换占位符。 默认情况下，"identifier" 必须拼写一个 Python 标识符。 $ 字符后的第一个非标识符字符终止此占位符规范。
• ${identifier} 相当于 $identifier。 当有效标识符字符跟在占位符之后但不是占位符的一部分时是必需的，例如 "${noun}ification"。

$ 在字符串中的任何其他出现都将导致 ValueError 升高。

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

class string.Template(template)

构造函数接受一个参数，即模板字符串。

substitute(mapping[, **kws])

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

safe_substitute(mapping[, **kws])

与 substitute() 一样，除了如果 mapping 和 kws 中缺少占位符，而不是引发 KeyError 异常，原始占位符将完整地出现在结果字符串中。 此外，与 substitute() 不同，$ 的任何其他外观将简单地返回 $ 而不是提升 ValueError。

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

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 – 这是描述引入分隔符的占位符的文字字符串。 默认值为 $。 请注意，这应该 不是 是正则表达式，因为实现将根据需要在此字符串上调用 re.escape()。
• idpattern – 这是描述非大括号占位符模式的正则表达式（大括号将根据需要自动添加）。 默认值为正则表达式 [_a-z][_a-z0-9]*。

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

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

7.1.5. 字符串函数

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

string.capwords(s[, sep])

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

string.maketrans(from, to)

返回一个适合传递给 translate() 的转换表，它将 from 中的每个字符映射到 to 中相同位置的字符； from 和 to 的长度必须相同。

笔记

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

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

下面的函数列表也被定义为字符串和 Unicode 对象的方法； 有关这些的更多信息，请参见 字符串方法 部分。 您应该将这些函数视为已弃用，尽管它们在 Python 3 之前不会被删除。 该模块中定义的函数是：

string.atof(s)

自 2.0 版起已弃用： 使用 float() 内置函数。

将字符串转换为浮点数。 该字符串必须具有 Python 中浮点字面量的标准语法，可选地以符号开头（+ 或 -）。 请注意，当传递字符串时，这与内置函数 float() 的行为相同。

笔记

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

string.atoi(s[, base])

自 2.0 版起已弃用： 使用 int() 内置函数。

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

string.atol(s[, base])

自 2.0 版起已弃用： 使用 long() 内置函数。

将字符串 s 转换为给定 base 中的长整数。 该字符串必须由一位或多位数字组成，可选地前面有一个符号（+ 或 -）。 base 参数与 atoi()[X65X] 的含义相同。 不允许尾随 l 或 L，除非基数为 0。 请注意，在没有 base 或 base 设置为 10 的情况下调用时，这与传递字符串时的内置函数 long() 的行为相同。

string.capitalize(word)

返回 word 的副本，仅其第一个字符大写。

string.expandtabs(s[, tabsize])

根据当前列和给定的制表符大小，将字符串中的制表符扩展为一个或多个空格。 在字符串中出现每个换行符后，列号将重置为零。 这不理解其他非打印字符或转义序列。 标签大小默认为 8。

string.find(s, sub[, start[, end]])

返回 s 中的最低索引，其中找到了子串 sub，使得 sub 完全包含在 s[start:end] 中。 失败时返回 -1。 start 和 end 的默认值和负值的解释与切片相同。

string.rfind(s, sub[, start[, end]])

像 find() 但找到最高索引。

string.index(s, sub[, start[, end]])

与 find() 类似，但在未找到子字符串时引发 ValueError。

string.rindex(s, sub[, start[, end]])

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

string.count(s, sub[, start[, end]])

返回字符串 s[start:end] 中子字符串 sub 的（非重叠）出现次数。 start 和 end 的默认值以及负值的解释与切片相同。

string.lower(s)

返回 s 的副本，但将大写字母转换为小写字母。

string.split(s[, sep[, maxsplit]])

返回字符串 s 的单词列表。 如果可选的第二个参数 sep 不存在或 None，则单词由任意的空白字符字符串（空格、制表符、换行符、回车、换页）分隔。 如果存在第二个参数 sep 而不是 None，则它指定一个字符串作为单词分隔符。 返回的列表将比字符串中分隔符的非重叠出现次数多一项。 如果给出 maxsplit，则最多发生 maxsplit 次分裂，并且字符串的剩余部分作为列表的最后一个元素返回（因此，列表最多有 [ X192X] 元素）。 如果未指定 maxsplit 或 -1，则分割次数没有限制（进行所有可能的分割）。

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

string.rsplit(s[, sep[, maxsplit]])

返回字符串 s 的单词列表，从末尾扫描 s。 出于所有意图和目的，结果单词列表与 split() 返回的相同，除非显式指定了可选的第三个参数 maxsplit 且非零。 如果给出 maxsplit，则最多 maxsplit 次分裂 - 最右边 次 - 发生，并且字符串的其余部分作为第一个元素返回列表（因此，列表最多包含 maxsplit+1 元素）。

2.4 版中的新功能。

string.splitfields(s[, sep[, maxsplit]])

此函数的行为与 split() 相同。 （过去 split() 只用一个参数，而 splitfields() 只用两个参数。）

string.join(words[, sep])

连接出现 sep 的单词列表或元组。 sep 的默认值是单个空格字符。 string.join(string.split(s, sep), sep) 等于 s 总是正确的。

string.joinfields(words[, sep])

此函数的行为与 join() 相同。 （过去 join() 只用一个参数，而 joinfields() 只用两个参数。）注意没有 joinfields() 字符串对象的方法； 改用 join() 方法。

string.lstrip(s[, chars])

返回删除前导字符的字符串副本。 如果省略 chars 或 None，则删除空白字符。 如果给定而不是 None，则 chars 必须是字符串； 字符串中的字符将从调用此方法的字符串的开头删除。

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

string.rstrip(s[, chars])

返回删除尾随字符的字符串副本。 如果省略 chars 或 None，则删除空白字符。 如果给定而不是 None，则 chars 必须是字符串； 字符串中的字符将从调用此方法的字符串的末尾剥离。

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

string.strip(s[, chars])

返回删除前导和尾随字符的字符串副本。 如果省略 chars 或 None，则删除空白字符。 如果给定而不是 None，则 chars 必须是字符串； 字符串中的字符将从调用此方法的字符串的两端剥离。

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

string.swapcase(s)

返回 s 的副本，但小写字母转换为大写字母，反之亦然。

string.translate(s, table[, deletechars])

从 s 中删除 deletechars（如果存在）中的所有字符，然后使用 table 翻译这些字符，它必须是一个 256 个字符的字符串，给出每个字符值的翻译，按其序数索引。 如果table为None，则只执行字符删除步骤。

string.upper(s)

返回 s 的副本，但将小写字母转换为大写字母。

string.ljust(s, width[, fillchar])

string.rjust(s, width[, fillchar])
string.center(s, width[, fillchar])

这些函数分别在给定宽度的字段中左对齐、右对齐和居中字符串。 它们返回一个至少为 width 个字符宽的字符串，通过用字符 fillchar（默认为空格）填充字符串 s 直到给定宽度来创建在右侧、左侧或两侧。 字符串永远不会被截断。

string.zfill(s, width)

在左侧填充数字字符串 s 零位，直到达到给定的 width。 正确处理以符号开头的字符串。

string.replace(s, old, new[, maxreplace])

返回字符串 s 的副本，其中所有出现的子字符串 old 替换为 new。 如果给出了可选参数 maxreplace，则替换第一个 maxreplace 出现。