Python Str字符串

定义

文本序列类型-Python中的str文本数据是用str对象或字符串处理的。字符串是Unicode代码点的不可变序列。字符串文字的书写方式多种多样：

单引号：'allows embedded "double" quotes'
双引号："allows embedded 'single' quotes"
三重引号：'''Three single quotes''', """Three double quotes"""

三重引号字符串可以跨多行-所有关联的空格都将包含在字符串文本中。
作为单个表达式的一部分并且它们之间只有空格的字符串文字将隐式转换为单个字符串文字。也就是说，（“spam”“eggs”）=“spam eggs”。

也可以使用 str 构造函数从其他对象创建字符串。

>>> str(['a', 'b', 'c', 'd'])
"['a', 'b', 'c', 'd']"
>>> tr = 'fyz is nb plus Pro Max'
>>> type(tr)
<class 'str'>

由于没有单独的“字符”类型，索引字符串会生成长度为 1 的字符串。也就是说，对于非空字符串 s，s[0] == s[0:1]。
由于也没有可变的字符串类型，但str.join()或io.StringIO可用于从多个片段有效地构造字符串。

class str(object=’’)

class str(object=b’’, encoding=‘utf-8’, errors=‘strict’)

返回对象的字符串版本。如果未提供对象，则返回空字符串。否则， str() 的行为取决于是否给出了encoding或errors，如下所示。

如果既没有给出编码也没有给出错误，str(object)返回object.__str__()，它是 object的“非正式”或可很好打印的字符串表示。对于字符串对象，这是字符串本身。如果 object没有 __str__()方法，则 str()回退到返回 repr(object)。

如果至少给出了编码或错误之一，则对象应该是一个类似字节的对象（例如字节或字节数组）。在这种情况下，如果 object是一个 bytes（或 bytearray）对象，那么 str(bytes, encoding, errors)等价于 bytes.decode(encoding, errors)。否则，在调用bytes.decode() 之前获取缓冲区对象下的字节对象。

在没有编码或错误参数的情况下将字节对象传递给str()属于返回非正式字符串表示的第一种情况

Str创建

str.join(iterable) 返回一个字符串，它是 iterable 中字符串的串联。如果可迭代对象中有任何非字符串值，包括字节对象，则会引发 TypeError。元素之间的分隔符是提供此方法的字符串。

>>> "*".join(["a", '2', "?"])
'a*2*?'

str.encode(encoding="utf-8", errors="strict") 将字符串的编码版本作为字节对象返回。默认编码为“utf-8”。可能会给出错误以设置不同的错误处理方案。错误的默认值是“严格”，这意味着编码错误会引发 UnicodeError。其他可能的值是 'ignore'、'replace'、'xmlcharrefreplace'、'backslashreplace' 和通过 codecs.register_error()注册的任何其他名称，请参阅部分错误处理程序。

>>> tr.encode(encoding="utf-8", errors="strict")
b'fyz is nb plus Pro Max'

str.format(*args, **kwargs)执行字符串格式化操作。调用此方法的字符串可以包含由大括号{}分隔的文字文本或替换字段。每个替换字段包含位置参数的数字索引或关键字参数的名称。返回字符串的副本，其中每个替换字段都替换为相应参数的字符串值。

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

有关可以在 format 中指定的各种格式选项的说明，请参阅[ Format String Syntax][]。

注意：当使用 n 类型（例如：'{:n}'.format(1234)）格式化数字（int、float、complex、decimal.Decimal 和子类）时，该函数会临时将 LC_CTYPE 语言环境设置为 LC_NUMERIC 语言环境如果localeconv() 的decimal_point和killon_sep字段是非ASCII 或长于1 个字节，并且LC_NUMERIC 语言环境与LC_CTYPE 语言环境不同，则解码它们。此临时更改会影响其他线程。

在 3.7 版更改: 当用 n 类型格式化数字时，该函数在某些情况下临时将 LC_CTYPE 语言环境设置为 LC_NUMERIC 语言环境。

str.format_map(mapping) 与 str.format(**mapping) 类似，但其直接使用映射而不是复制到字典中。如果例如映射是 dict 子类，这很有用：

>>> class Default(dict):def __missing__(self, key):return key>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

字符串方法

字符串实现了所有常见的序列操作，以及下面描述的附加方法。

字符串还支持两种样式的字符串格式，一种提供很大程度的灵活性和自定义（str.format()、Format String Syntax 和 Custom String Formatting），另一种基于处理更窄类型范围的 C printf 样式格式并且更难正确使用，但对于它可以处理的情况（printf样式的字符串格式）通常更快。

标准库的文本处理服务部分涵盖了许多其他模块，这些模块提供了各种与文本相关的实用程序（包括 re 模块中的正则表达式支持）

字符串格式化输出方法

Str拆分

str.partition(sep)在第一次出现 sep时拆分字符串，并返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身和分隔符之后的部分。如果未找到分隔符，则返回一个包含字符串本身的 3 元组，后跟两个空字符串。

>>> str = "fyzisnb"
>>> str.partition("is")
('fyz', 'is', 'nb')

str.rpartition(sep) 在最后一次出现 sep 时拆分字符串，并返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身和分隔符之后的部分。如果未找到分隔符，则返回一个包含两个空字符串的 3 元组，后跟字符串本身。

split()系列

str.split(sep=None, maxsplit=-1)返回字符串中单词的列表，使用 sep 作为分隔符字符串。如果给出了 maxsplit，则最多完成 maxsplit次分割（因此，列表最多有maxsplit+1 个元素）。
- 如果未指定 maxsplit或-1，则对拆分的数量没有限制（进行所有可能的拆分）。如果给出了 sep，则连续的分隔符不会组合在一起并被视为分隔空字符串（例如，'1,,2'.split(',') 返回 ['1', '', '2']）。 sep参数可能由多个字符组成（例如，'1<>2<>3'.split('<>') 返回 ['1', '2', '3']）。用指定的分隔符拆分空字符串返回['']。
```
>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']
```
- 如果未指定 sep或为 None，则应用不同的拆分算法：将连续空格的运行视为单个分隔符，如果字符串有前导或尾随空格，则结果将在开头或结尾不包含空字符串。因此，拆分空字符串或仅由空格组成的字符串与 None分隔符将返回 []。
```
>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']
```
str.rsplit(sep=None, maxsplit=-1)返回字符串中单词的列表，使用 sep作为分隔符字符串。如果给出了 maxsplit，则最多完成 maxsplit 次分割，即最右边的分割。如果未指定 sep或 None，则任何空白字符串都是分隔符。除了从右侧拆分之外，rsplit()的行为类似于 split()，下面将对其进行详细描述。
```
>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'
>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'
```
str.splitlines([keepends])返回字符串中的行列表，在行边界处断开。结果列表中不包含换行符，除非给出了 keepends并且为 true。此方法在以下行边界上拆分。特别是，边界是通用换行符的超集。

\n换行符,\r回车符,\r\n回车符+换行符,\v或\x0b换行符,\f或\x0c换行符,\x1c文件分隔符,\x1d组分隔符,\x1e记录分隔符,\x85下一行（C1控制代码）,\u2028行分隔符,\u2029段落分隔符

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
# 作为比较 str.split()
>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

str格式化删除

str.strip([chars])返回删除前导和尾随字符的字符串副本。
- chars 参数是一个字符串，指定要删除的字符集。如果省略或 None，则 chars 参数默认为删除空格。 chars 参数不是前缀或后缀；相反，其值的所有组合都被剥离：
```
>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'
```
- 最外面的前导和尾随字符参数值从字符串中剥离。字符从前导端移除，直到到达不包含在 chars 中的字符集中的字符串字符。类似的动作发生在尾端。例如：
```
>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'
```
str.lstrip([chars])返回删除前导字符的字符串副本。…
str.rstrip([chars])返回删除尾随字符的字符串副本。…

>>> '   spacious   '.lstrip()
'spacious   '
>>> '   spacious   '.rstrip()
'   spacious'
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'
>>> 'mississippi'.rstrip('ipz')
'mississ'

str.removeprefix(prefix, /)如果字符串以前缀字符串开头，则返回字符串[len(prefix):]。否则，返回原始字符串的副本：3.9 版中的新功能。

>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

str.removesuffix(suffix, /) 如果字符串以后缀字符串结尾并且该后缀不为空，则返回字符串[:-len(suffix)]。否则，返回原始字符串的副本： 3.9 版中的新功能。

>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'

Str访问查找

str.[[start] : [stop] [: step]]切片查找

>>> str = "abcdefgh"
>>> str[0]  #直接索引访问
'a'
>>> str[2:5]
'cde'
>>> str[2:5:2]
'ce'
>>> str[::-1]
'hgfedcba'

str.count(sub[, start[, end]]) 返回子串 sub 在 [start, end)范围内非重叠出现的次数。可选参数 start和 end被解释为切片符号。
str.find(sub[, start[, end]]) 返回字符串中的最小索引，在切片 s[start:end] 中找到子字符串 sub。可选参数 start和 end被解释为切片符号。如果未找到 sub 则返回 -1。

注意：只有在需要知道 sub 的位置时才应该使用 find() 方法。要检查 sub 是否是子字符串，请使用 in 运算符

str.index(sub[, start[, end]]) 与 find()类似，但在未找到子字符串时引发 ValueError。

>>> tr = 'fyz is nb plus Pro Max'
>>> tr.count("p",0,22)
1
>>> tr.find("nb",0,10), tr.index('nb')
(7, 7)
>>> "is" in tr
True

str.rfind(sub[, start[, end]]) 返回字符串中找到子字符串 sub的最高索引，使得 sub包含在 s[start:end] 中。可选参数 start和 end被解释为切片符号。失败时返回 -1。
str.rindex(sub[, start[, end]])与 rfind() 类似，但在未找到子字符串 sub时引发 ValueError。

>>> tr.rfind("a"), tr.rindex("a")
(20, 20)

str.endswith(suffix[, start[, end]])如果字符串以指定的后缀结尾，则返回 True，否则返回 False。 suffix也可以是要查找的后缀元组；使用可选start，从该位置开始测试；使用可选end，在该位置停止比较。
str.startswith(prefix[, start[, end]])如果字符串以前缀开头，则返回 True，否则返回 False。 prefix也可以是要查找的前缀元组。使用可选的开始，测试字符串从该位置开始。使用可选结束，停止在该位置比较字符串。

>>> tr = 'fyz is nb plus Pro Max'
>>> tr.startswith("fy"), tr.startswith("is",4,20)
>>> (True, True)
>>> tr.endswith("ax"),tr.endswith("a")
>>> (True, False)

Str大小写

str.swapcase()返回字符串的副本，其中大写字符转换为小写字符，反之亦然。请注意，s.swapcase().swapcase() == s不一定正确。
str.lower() 返回所有大小写字符转换为小写的字符串副本。
str.upper() 返回所有大小写字符 [4] 转换为大写的字符串副本。请注意，如果 s 包含未区分大小写的字符或者结果字符的 Unicode 类别不是“Lu”（字母，大写），则 s.upper().isupper() 可能为 False，例如 e.g.“Lt” (Letter, titlecase)。

>>> "Fyz".swapcase(), "FYZ1".swapcase()
('fYZ', 'fyz1')
>>> "Fyz".lower(),  "Fyz".upper()
('fyz', 'FYZ')

str.capitalize()返回字符串的副本，其中第一个字符大写，其余字符小写。

在 3.8 版更改: 现在将第一个字符放入标题而不是大写。这意味着像digraphs这样的字符只会将它们的第一个字母大写，而不是完整的字符。

str.casefold() 返回字符串的大小写折叠副本。大小写折叠字符串可用于无大小写匹配。
- Casefolding 类似于小写，但更具侵略性，因为它旨在消除字符串中的所有大小写区别。例如，德语小写字母“ß”相当于“ss”。由于它已经是小写的，lower()对'ß'没有任何作用； casefold() 将其转换为“ss”。

>>> tr = "fyz is nb plus Pro Max"
>>> tr.capitalize()
'Fyz is nb plus pro max'
>>> tr.casefold()
'fyz is nb plus pro max'

str.title()返回字符串的标题版本，其中单词以大写字符开头，其余字符为小写。

该算法使用一个简单的独立于语言的单词定义为连续字母组。该定义适用于许多上下文，但它意味着收缩和所有格中的撇号形成单词边界，这可能不是预期的结果，可以使用正则表达式构造撇号的解决方法：

>>> 'Hello world'.title()
'Hello World'
>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"
>>> import re
>>> def titlecase(s):return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",lambda mo: mo.group(0).capitalize(),s)>>> titlecase("they're bill's friends.")
"They're Bill's Friends."
>>>

Str填充

str.zfill(width) 返回用 ASCII'0'数字填充的字符串的副本，以生成长度为 width的字符串。通过在符号字符之后而不是之前插入填充来处理前导符号前缀 ('+'/'-')。如果宽度小于或等于 len(s)，则返回原始字符串。
str.ljust(width[, fillchar]) 返回长度width的字符串中左对齐的字符串。填充是使用fillchar完成的（默认为 ASCII 空间）。如果宽度小于或等于 len(s)，则返回原始字符串。
str.rjust(width[, fillchar])返回长度width的字符串中右对齐的字符串。 …
str.center(width[, fillchar])以长度宽度的字符串居中返回。填充是使用指定的填充字符完成的（默认为 ASCII 空间）。如果宽度小于或等于 len(s)，则返回原始字符串。

>>> "42".zfill(5), "-42".zfill(5)
('00042', '-0042')
>>> "exam".ljust(6,"*"), "exam".rjust(6,"*")
('exam**', '**exam')
>>> "fyz".center(10,"*")
'***fyz****'

Str替换

str.replace(old, new[, count])返回字符串的副本，其中所有出现的子字符串 old都被 new替换。如果给出了可选参数count，则替换count次 (only the first countoccurrences are replaced)。

>>> str = "this is string example....wow!!! is"
>>> str.replace("is", "was", 2)
'thwas was string example....wow!!! is'

str.expandtabs(tabsize=8)返回字符串的副本，其中所有制表符都替换为一个或多个空格，具体取决于当前列和给定的制表符大小。制表符位置出现在每个制表符大小的字符（默认为 8，在第 0、8、16 列等处给出制表符位置）。为了扩展字符串，当前列设置为零，并逐个字符地检查字符串。如果字符是制表符 (\t)，则会在结果中插入一个或多个空格字符，直到当前列等于下一个制表符位置。（不复制制表符本身。）如果字符是换行符 (\n) 或回车符 (\r)，则复制它并将当前列重置为零。任何其他字符都被原封不动地复制，并且无论打印时字符的表示方式如何，当前列都会增加 1。

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'

static str.maketrans(x[, y[, z]]) 这个静态方法返回一个可用于 str.translate() 的转换表。
- 如果只有一个参数，它必须是将 Unicode 序数（整数）或字符（长度为 1 的字符串）映射到 Unicode 序数、字符串（任意长度）或 None的字典。然后字符键将被转换为序数。
- 如果有两个参数，它们必须是等长的字符串，并且在生成的字典中，x 中的每个字符都会映射到 y 中相同位置的字符。如果有第三个参数，它必须是一个字符串，其字符将在结果中映射为 None。
```
>>>intab = "aeiou"
>>> outtab = "12345"
>>> trantab = str.maketrans(intab, outtab)
>>> str = "this is string example....wow!!!"
>>> str.translate(trantab)
'th3s 3s str3ng 2x1mpl2....w4w!!!'
```
str.translate(table) 返回字符串的副本，其中每个字符都已通过给定的table映射。表必须是通过 __getitem__()实现索引的对象，通常是映射或序列。当由 Unicode 序数（整数）索引时，表对象可以执行以下任一操作：返回 Unicode 序数或字符串，将字符映射到一个或多个其他字符； return None，从返回字符串中删除字符；或引发 LookupError异常，将字符映射到自身。您可以使用str.maketrans() 从不同格式的字符到字符映射创建转换映射。
```
from string import maketrans   # 引用 maketrans 函数。intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)str = "this is string example....wow!!!";
print str.translate(trantab);
```

str成分判断

str.isalnum()如果字符串中的所有字符都是字母数字并且至少有一个字符，则返回 True，否则返回 False。如果以下之一返回 True，则字符 c 是含有字母或数字的：c.isalpha()、c.isdecimal()、c.isdigit() 或 c.isnumeric()。

>>> "a".isalnum(), "1".isalnum(), "冯".isalnum(), "".isalnum()
(True, True, True, False)

str.isalpha() 如果字符串中的所有字符都是字母并且至少有一个字符，则返回 True，否则返回 False。字母字符是在 Unicode 字符数据库中定义为“字母”的字符，即具有一般类别属性为“Lm”、“Lt”、“Lu”、“Ll”或“Lo”之一的字符。请注意，这与 Unicode 标准中定义的“字母”属性不同。
str.isdecimal()如果字符串中的所有字符都是十进制字符并且至少有一个字符，则返回 True，否则返回 False。十进制字符是那些可用于形成以 10 为基数的数字的字符，例如 U+0660，阿拉伯-印度数字零。正式的十进制字符是 Unicode 通用类别“Nd”中的字符。

>>> "a".isalpha(), "1".isalpha()
(True, False)
>>> "1".isdecimal(), "a".isdecimal()
(True, False)

str.isdigit()如果字符串中的所有字符都是数字并且至少有一个字符，则返回 True，否则返回 False。数字包括十进制字符和需要特殊处理的数字，例如兼容性上标数字。这涵盖了不能用于形成以 10 为基数的数字的数字，例如 Kharosthi 数字。正式地，数字是具有属性值 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。
str.isnumeric()如果字符串中的所有字符都是数字字符并且至少有一个字符，则返回 True，否则返回 False。 Numeric 字符包括digit 字符，以及所有具有 Unicode 数值属性的字符，例如 U+2155，普通分数五分之一。形式上，Numeric 字符是具有属性值 Numeric_Type=Digit、Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。

>>> "123".isdigit(), "12a".isdigit()
(True, False)
>>> "123".isnumeric(), "12a".isnumeric()
(True, False)

str.isascii()如果字符串为空或字符串中的所有字符都是 ASCII，则返回 True，否则返回 False。 ASCII 字符的代码点在 U+0000-U+007F 范围内。

>>> "aA/".isascii(), "冯".isascii()
(True, False)

str.isidentifier()如果根据语言定义、标识符和关键字部分，字符串是有效标识符，则返回 True。
keyword.iskeyword()测试字符串s是否为保留标识符，如def和class

>>> "list".isidentifier(), "0a".isidentifier()
(True, False)
>>> from keyword import iskeyword
>>> 'hello'.isidentifier(), iskeyword('hello')
(True, False)
>>> 'def'.isidentifier(), iskeyword('def')
(True, True)

str.islower()如果字符串中的所有大小写字符都是小写并且至少有一个大小写字符，则返回True，否则返回False。
str.istitle()如果字符串是标题字符串并且至少有一个字符，则返回 True，例如大写字符只能跟在非大小写字符后面，小写字符只能跟在大小写字符后面。否则返回 False。
str.isupper() 如果字符串中的所有大小写字符都是大写并且至少有一个大小写字符，则返回 True，否则返回 False。

>>> "abc".islower(), "aA1".islower()
(True, False)
>>> "Fyz Is Nb".istitle(), "Fyz Is NB".istitle()
(True, False)
>>> "ABC".isupper(), "Aa1".isupper()
(True, False)

str.isprintable() 如果字符串中的所有字符都可打印或字符串为空，则返回 True，否则返回 False。不可打印字符是在 Unicode 字符数据库中定义为“其他”或“分隔符”的字符，但被认为可打印的 ASCII 空格 (0x20) 除外。
str.isspace() 如果字符串中只有空白字符且至少有一个字符，则返回 True，否则返回 False。

如果在 Unicode 字符数据库（参见 unicodedata）中，一个字符是空白字符，或者它的一般类别是 Zs（“分隔符，空格”），或者它的双向类是 WS、B或 S之一。

>>> "ab12".isprintable(), "\n12".isprintable()
(True, False)
>>> " ".isspace(), " as ".isspace()
(True, False)