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

源代码: Lib/string.py


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

7.1.1. 字符串常量

此模块中定义的常量为:

  • string. ascii_letters

  • string. ascii_lowercase

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

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

    • 字符串'0123456789'
  • string. hexdigits

    • 字符串'0123456789abcdefABCDEF'
  • string. letters

  • 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 版的新Function。

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

  • 类别 string. Formatter

  • format(* format_string *, *args * kwargs *)

    • 主要的 API 方法。它采用格式字符串以及任意一组位置和关键字参数。它只是一个调用vformat()的包装器。
  • 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属性。

如果索引或关键字引用的项目不存在,则应引发IndexErrorKeyError

  • check_unused_args(* used_args args kwargs *)

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

  • convert_field(* value conversion *)

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

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 *,后面带有一个冒号':'。这些指定替换值的非默认格式。

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

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

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

当前支持两个转换标志:'!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_spec 字段包含有关如何显示值的规范,包括字段宽度,对齐方式,填充,小数精度等详细信息。每个值类型都可以定义自己的“格式迷你语言”或 format_spec *的解释。

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

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

有关示例,请参见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

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

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

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

Note

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

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

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

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

  • width *是十进制整数,用于定义最小字段宽度。如果未指定,则字段宽度将由内容确定。

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

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

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

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

Note

TypeMeaning
's'字符串格式。这是字符串的默认类型,可以Ellipsis。
None's'相同。

可用的整数表示类型为:

Note

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

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

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

Note

TypeMeaning
'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-inf0-0nan,而与精度无关。

> 精度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中所述。模板使用以下规则而不是常规的基于%的替换,而是支持基于$的替换:

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

  • $identifier命名与 Map 键"identifier"匹配的替换占位符。默认情况下,"identifier"必须拼写 Python 标识符。 $字符之后的第一个非标识符字符终止此占位符规范。

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

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

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

  • 类别 string. Template(模板)

    • 构造函数采用单个参数,即模板字符串。
  • substitute(* mapping * [,*** kws *])

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

    • substitute()相似,不同之处在于,如果* mapping kws *中缺少占位符,而不是引发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-z][_a-z0-9]*

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

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

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

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

7.1.5. 字符串函数

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

  • string. capwords(* s * [,* sep *])

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

    • 返回适合传递给translate()的转换表,该转换表会将* from 中的每个字符 Map 到 to *中相同位置的字符; * from to *必须具有相同的长度。

Note

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

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

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

  • string. atof(* s *)
    • 自 2.0 版起不推荐使用:使用float()内置函数。

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

Note

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

  • string. atoi(* s * [,* base *])
    • 自 2.0 版起不推荐使用:使用int()内置函数。

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

  • string. atol(* s * [,* base *])
    • 自 2.0 版起不推荐使用:使用long()内置函数。

将字符串* s 转换为给定 base *中的长整数。该字符串必须由一个或多个数字组成,并可以在其后加上一个符号(+-)。 * base 参数的含义与atoi()相同。除非末尾为 0,否则不允许尾随lL。请注意,在不带 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 *]])

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

  • 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 个分割数,并且字符串的其余部分将作为列表的最后一个元素返回(因此,列表最多具有maxsplit+1个元素)。如果未指定 maxsplit *或-1,则分割数没有限制(已进行所有可能的分割)。

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

  • string. rsplit(* s * [,* sep * [,* maxsplit *]])
    • 返回字符串* s 的单词列表,从末尾扫描 s 。出于所有目的和目的,所得单词列表与split()返回的单词列表相同,除非明确指定了可选的第三个参数 maxsplit 且非零。如果指定了 maxsplit ,最多会出现 maxsplit *个分割数–最右边的分割数,并且字符串的其余部分将作为列表的第一个元素返回(因此,列表最多包含maxsplit+1个元素)。

2.4 版的新Function。

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

  • string. join(* words * [,* sep *])

    • 将一系列带有* sep *出现的单词的列表或 Tuples 连接起来。 * sep 的默认值是一个空格字符。 string.join(string.split(s, sep), sep)等于 s *始终是正确的。
  • string. joinfields(* words * [,* sep *])

    • 此函数的行为与join()相同。 (过去,join()仅与一个参数一起使用,而joinfields()仅与两个参数一起使用。)请注意,字符串对象上没有joinfields()方法。请改用join()方法。
  • string. lstrip(* s * [,* chars *])

    • 返回删除了前导字符的字符串的副本。如果Ellipsis* chars None,则将删除空格字符。如果给定而不是None,则 chars *必须为字符串;字符串中的字符将从调用此方法的字符串的开头删除。

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

  • string. rstrip(* s * [,* chars *])
    • 返回删除了结尾字符的字符串副本。如果Ellipsis* chars None,则将删除空格字符。如果给定而不是None,则 chars *必须为字符串;字符串中的字符将从调用此方法的字符串末尾去除。

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

  • string. strip(* s * [,* chars *])
    • 返回已删除前导和尾随字符的字符串副本。如果Ellipsis* 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 个字符宽的字符串,该字符串是pass在字符串 s 内填充字符 fillchar *(默认为空格)直到在右侧,左侧或两侧都使用给定的宽度而创建的。该字符串永远不会被截断。
  • string. zfill(* s width *)

    • 在左边用零数字填充数字字符串* s ,直到达到给定的 width *。以符号开头的字符串已正确处理。
  • string. replace(* s old new * [,* maxreplace *])

    • 返回字符串* s 的副本,并将所有出现的子字符串 old 替换为 new 。如果给出了可选参数 maxreplace ,则替换第一个 maxreplace *事件。