(最全资料)列表、元组、数组、文本序列的字符串操作详解(6)Python语言(必读进阶学习教程)(参考资料)

序列类型- ，，list tuplerange

有三种基本序列类型：列表，元组和范围对象。专门用于处理二进制数据和文本字符串的附加序列类型 在专门章节中描述。

>>> r = range(0, 20, 2) 
>>> r 
range(0, 20, 2) 
>>> 11 in r 
False 
>>> 10 in r 
True 
>>> r.index(10) 
5 
>>> r[5] 
10 
>>> r[:5] 
range(0, 10, 2) 
>>> r[-1] 
18

文本序列类型 – str

Python中的文本数据由str对象或字符串处理。字符串是Unicode代码点的不可变 序列。字符串文字以多种方式编写：

• 单引号： 'allows embedded "double" quotes'
• 双引号：。"allows embedded 'single' quotes"
• 三重引用：，'''Three single quotes'''"""Three double quotes"""

三引号字符串可能跨越多行 – 所有相关的空格都将包含在字符串文字中。

字符串文字是单个表达式的一部分，它们之间只有空格，将隐式转换为单个字符串文字。就是这样。("spam ""eggs") == "spam eggs"

有关各种形式的字符串文字的更多信息，包括支持的转义序列，以及禁用大多数转义序列处理的（“raw”）前缀，请参阅字符串和字节文字r。

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

由于没有单独的“字符”类型，索引的字符串产生一个长度1。也就是说，对于一个非空字符串的字符串小号，。s[0] == s[0:1]

也没有可变的字符串类型，但str.join()还是 io.StringIO可以用来有效地构造从多个片段字符串。

class str（object =” ）

class str（object = b”，encoding =’utf-8′，errors =’strict’ ）

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

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

如果给出了编码或错误中的至少一个，则对象应该是类似 字节的对象（例如bytes或bytearray）。在这种情况下，如果object是bytes（或bytearray）对象，则等效于 。否则，在调用之前获取缓冲区对象下的字节对象。有关缓冲区对象的信息，请参阅二进制序列类型 – 字节，字节数组，内存视图和 缓冲区协议。str(bytes,encoding, errors)bytes.decode(encoding, errors)bytes.decode()

bytes在str()没有编码 或错误参数的情况下传递对象属于第一种返回非正式字符串表示的情况（另请参阅-bPython 的命令行选项）。例如：

>>>
>>> str(b'Zoot!')
"b'Zoot!'"

 

有关str类及其方法的更多信息，请参阅下面的 文本序列类型 – str和字符串方法部分。要输出格式化字符串，请参阅格式化字符串文字和格式字符串语法 部分。另外，请参阅“ 文本处理服务”部分。

字符串方法

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

字符串还支持两种样式的字符串格式，一种提供了很大的灵活性和自定义（参见str.format()， 格式字符串语法和自定义字符串格式），另一种基于C printf样式格式，处理较窄的类型范围，并且稍微难以使用正确，但对于它可以处理的情况（printf样式的字符串格式）通常更快。

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

str.capitalize（）

返回字符串的副本，其首字符大写，其余字符小写。

str.casefold（）

返回字符串的包含案例的副本。表壳折叠字符串可用于无壳匹配。

Casefolding类似于lowercasing但更具攻击性，因为它旨在删除字符串中的所有大小写区别。例如，德语小写字母'ß'相当于"ss"。因为它已经是小写的，所以lower()什么都不做'ß'; casefold() 将其转换为"ss"。

案例折叠算法在Unicode标准的3.13节中描述。

版本3.3中的新功能。

str.center（width [，fillchar ] ）

以长度宽度的字符串为中心返回。使用指定的fillchar完成填充（默认为ASCII空间）。如果width小于或等于，则返回原始字符串len(s)。

str.count（sub [，start [，end ] ] ）

返回[ start，end ] 范围内substring sub的非重叠出现次数。可选参数start和end被解释为切片表示法。

str.encode（encoding =“utf-8”，errors =“strict” ）

将字符串的编码版本作为字节对象返回。默认编码是'utf-8'。可以给出错误以设置不同的错误处理方案。错误的默认值是'strict'，意味着编码错误会引发错误UnicodeError。其他可能的值'ignore'，'replace'，'xmlcharrefreplace'， 'backslashreplace'和其他任何名义通过挂号codecs.register_error()，见错误处理程序。有关可能的编码列表，请参阅标准编码部分。

在3.1版中更改：添加了对关键字参数的支持。

str.endswith（后缀[，start [，end ] ] ）

返回True字符串是否与指定的结束后缀，否则返回 False。 后缀也可以是要查找的后缀元组。通过可选的 启动，从该位置开始测试。使用可选结束，停止在该位置进行比较。

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'

 

str.find（sub [，start [，end ] ] ）

返回在切片中找到substring sub的字符串中的最低索引s[start:end]。可选参数start和end被解释为切片表示法。-1如果未找到sub，则返回。

注意

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

>>>
>>> 'Py' in 'Python'
True

 

str.format（* args，** kwargs ）

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

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

 

有关可以在格式字符串中指定的各种格式选项的说明，请参阅格式字符串语法。

注意

当格式化数（int，float，complex， decimal.Decimal和亚类）与n类型（例如：'{:n}'.format(1234)），功能暂时设定 LC_CTYPE的区域设置到LC_NUMERIC区域解码 decimal_point和thousands_sep领域localeconv()如果它们是非ASCII或长于1个字节，而LC_NUMERIC区域设置为不同的比LC_CTYPE当地的。此临时更改会影响其他线程。

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

str.format_map（映射）

类似于str.format(**mapping)，除了mapping直接使用而不是复制到dict。如果例如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'

 

版本3.2中的新功能。

str.index（sub [，start [，end ] ] ）

喜欢find()，但是ValueError在找不到子串的时候会加注。

str.isalnum（）

如果字符串中的所有字符都是字母数字且至少有一个字符，则返回true，否则返回false。字符c是字母数字，如果下面的返回之一True：c.isalpha()，c.isdecimal()， c.isdigit()，或c.isnumeric()。

str.isalpha（）

如果字符串中的所有字符都是字母并且至少有一个字符，则返回true，否则返回false。字母字符是在Unicode字符数据库中定义为“字母”的那些字符，即具有一般类别属性的那些字符是“Lm”，“Lt”，“Lu”，“L1”或“Lo”之一。请注意，这与Unicode标准中定义的“字母”属性不同。

str.isascii（）

如果字符串为空或字符串中的所有字符都是ASCII，则返回true，否则返回false。ASCII字符的代码点范围为U + 0000-U + 007F。

版本3.7中的新功能。

str.isdecimal（）

如果字符串中的所有字符都是十进制字符并且至少有一个字符，则返回true，否则返回false。十进制字符是可用于在基数10中形成数字的字符，例如U + 0660，ARABIC-INDIC DIGIT ZERO。正则小数字符是Unicode常规类别“Nd”中的字符。

str.isdigit（）

如果字符串中的所有字符都是数字并且至少有一个字符，则返回true，否则返回false。数字包括十进制字符和需要特殊处理的数字，例如兼容性上标数字。这包括不能用于在基数10中形成数字的数字，如Kharosthi数字。形式上，数字是具有属性值Numeric_Type = Digit或Numeric_Type = Decimal的字符。

str.isidentifier（）

如果字符串是根据语言定义，标识符和关键字部分的有效标识符，则返回true 。

使用keyword.iskeyword()测试保留的标识符，例如 def和class。

str.islower（）

如果字符串中的所有外壳字符[4]都是小写且至少有一个外壳字符，则返回true，否则返回false。

str.isnumeric（）

如果字符串中的所有字符都是数字字符，则返回true，并且至少有一个字符，否则返回false。数字字符包括数字字符，以及具有Unicode数值属性的所有字符，例如U + 2155，VULGAR FRACTION ONE FIFTH。形式上，数字字符是具有属性值Numeric_Type = Digit，Numeric_Type = Decimal或Numeric_Type = Numeric的字符。

str.isprintable（）

如果字符串中的所有字符都是可打印的或字符串为空，则返回true，否则返回false。不可打印的字符是Unicode字符数据库中定义为“其他”或“分隔符”的字符，但ASCII空间（0x20）除外，它被认为是可打印的。（请注意，此上下文中的可打印字符repr()是在字符串上调用时不应转义 的字符。它与写入sys.stdout或的字符串的处理无关sys.stderr。）

str.isspace（）

如果字符串中只有空格字符并且至少有一个字符，则返回true，否则返回false。空白字符是Unicode字符数据库中定义为“其他”或“分隔符”的字符，以及具有双向属性的字符是“WS”，“B”或“S”之一。

str.istitle（）

如果字符串是一个带有标题的字符串并且至少有一个字符，则返回true，例如，大写字符可能只跟随无框字符，而小写字符只能跟随字符。否则返回false。

str.isupper（）

如果字符串中的所有外壳字符[4]都是大写且至少有一个外壳字符，则返回true，否则返回false。

str.join（可迭代的）

返回一个字符串，它是iterable中字符串的串联。TypeError如果在iterable中有任何非字符串值，包括bytes对象，则会引发 A. 元素之间的分隔符是提供此方法的字符串。

str.ljust（width [，fillchar ] ）

返回长度的字符串左对齐字符串宽度。使用指定的fillchar完成填充（默认为ASCII空间）。如果width小于或等于，则返回原始字符串len(s)。

str.lower（）

返回字符串的副本，并将所有套接字符[4]转换为小写。

所使用的小写算法在Unicode标准的3.13节中描述。

str.lstrip（[ chars ] ）

返回删除了前导字符的字符串副本。的字符 参数是要除去的字符串指定的字符集。如果省略或None，则chars参数默认为删除空格。该字符 参数不是前缀; 相反，它的所有值组合都被剥离：

>>>
>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

 

static str.maketrans（x [，y [，z ] ] ）

此静态方法返回可用于的转换表str.translate()。

如果只有一个参数，则它必须是将Unicode序数（整数）或字符（长度为1的字符串）映射到Unicode序数，字符串（任意长度）或字典的字典None。然后将字符键转换为序数。

如果有两个参数，则它们必须是长度相等的字符串，并且在结果字典中，x中的每个字符将映射到y中相同位置的字符。如果有第三个参数，则它必须是一个字符串，其字符将映射到None结果中。

str.partition（sep ）

在第一次出现sep时拆分字符串，并返回包含分隔符之前的部分的3元组，分隔符本身以及分隔符之后的部分。如果未找到分隔符，则返回包含字符串本身的3元组，后跟两个空字符串。

str.replace（旧的，新的[，计数] ）

返回字符串的副本，其中所有出现的substring old都替换为 new。如果给出可选参数计数，则仅 替换第一次计数。

str.rfind（sub [，start [，end ] ] ）

返回找到substring sub的字符串中的最高索引，以便包含subs[start:end]。可选参数start 和end被解释为切片表示法。-1失败时返回。

str.rindex（sub [，start [，end ] ] ）

喜欢rfind()但ValueError在找不到子串子时加注。

str.rjust（width [，fillchar ] ）

以长度宽度的字符串返回右对齐的字符串。使用指定的fillchar完成填充（默认为ASCII空间）。如果width小于或等于，则返回原始字符串len(s)。

str.rpartition（sep ）

在最后一次出现sep时拆分字符串，并返回包含分隔符之前的部分的3元组，分隔符本身以及分隔符之后的部分。如果找不到分隔符，则返回包含两个空字符串的3元组，后跟字符串本身。

str.rsplit（sep = None，maxsplit = -1 ）

使用sep作为分隔符字符串，返回字符串中单词的列表。如果给出maxsplit，则最多完成maxsplit分割，最右边的分割。如果未指定sepNone，则任何空格字符串都是分隔符。除了从右边分裂之外，rsplit()其行为类似于split()下面详细描述的。

str.rstrip（[ chars ] ）

返回删除了尾随字符的字符串副本。的字符 参数是要除去的字符串指定的字符集。如果省略或None，则chars参数默认为删除空格。该字符 参数不是后缀; 相反，它的所有值组合都被剥离：

>>>
>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

 

str.split（sep = None，maxsplit = -1 ）

使用sep作为分隔符字符串，返回字符串中单词的列表。如果给出maxsplit，则最多完成maxsplit拆分（因此，列表将具有最多maxsplit+1元素）。如果未指定maxsplit-1，则对分割数量没有限制（进行所有可能的分割）。

如果给出了sep，则连续的分隔符不会组合在一起，并被视为分隔空字符串（例如，'1,,2'.split(',')返回）。该月的参数可以由多个字符（例如，返回）。返回使用指定分隔符拆分空字符串。['1', '','2']'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.splitlines（[ keepends ] ）

返回字符串中的行列表，在行边界处断开。除非给出keepends且为true，否则换行符不包括在结果列表中。

此方法在以下行边界上分割。特别是，边界是普遍换行的超集。

表示	描述
\n	换行
\r	回程
\r\n	回车+换行
\v 要么 \x0b	行列表
\f 要么 \x0c	换页
\x1c	文件分隔符
\x1d	组分隔符
\x1e	记录分隔符
\x85	下一行（C1控制代码）
\u2028	行分隔符
\u2029	段落分隔符

在版本3.2中更改：\v并\f添加到行边界列表。

例如：

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

 

与给定split()分隔符字符串sep时不同，此方法返回空字符串的空列表，并且终端换行符不会产生额外的行：

>>>
>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']
为了比较，split('\n')给出：
>>>
>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

 

str.startswith（前缀[，start [，end ] ] ）

返回True字符串是否与开始前缀，否则返回False。 前缀也可以是要查找的前缀元组。使用可选的启动，测试字符串从该位置开始。使用可选结束，停止比较该位置的字符串。

str.strip（[ chars ] ）

返回删除了前导和尾随字符的字符串副本。的字符参数是要除去的字符串指定的字符集。如果省略或None，则chars参数默认为删除空格。该字符参数不是前缀或后缀; 相反，它的所有值组合都被剥离：

>>>
>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

 

最外层的前导和尾随字符参数值将从字符串中删除。从前端删除字符，直到到达字符集中未包含的字符串字符。在尾端发生类似的动作。例如：

>>>
>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'

 

str.swapcase（）

返回字符串的副本，其中大写字符转换为小写，反之亦然。请注意，它不一定是真的 。s.swapcase().swapcase() == s

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)[0].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

 

str.translate（表）

返回字符串的副本，其中每个字符已通过给定的转换表进行映射。该表必须是通过__getitem__()（通常是映射或 序列）实现索引的对象。当由Unicode序数（整数）索引时，表对象可以执行以下任何操作：返回Unicode序号或字符串，以将字符映射到一个或多个其他字符; return None，从返回字符串中删除字符; 或者引发 LookupError异常，将角色映射到自身。

您可以使用str.maketrans()不同格式的字符到字符映射创建转换映射。

另请参阅该codecs模块，以获得更灵活的自定义字符映射方法。

str.upper（）

返回字符串的副本，并将所有套接字符[4]转换为大写。请注意，s.upper().isupper()可能是False如果s 包含无套管的字符或如果所得到的字符（县）的Unicode类别不是“吕氏春秋”（字母，大写），但如“LT”（字母，首字母大写）。

使用的大写算法在Unicode标准的3.13节中描述。

str.zfill（宽度）

返回用ASCII '0'数字填充的字符串的副本，以生成长度为宽度的字符串。一个前置符号前缀（'+'/ '-'）是通过将填充处理后的符号字符，而不是之前。如果width小于或等于，则返回原始字符串len(s)。

例如：

>>>
>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

 

printf式字符串格式

String对象有一个独特的内置操作：%operator（modulo）。这也称为字符串格式或插值运算符。给定（格式为字符串），格式的转换规范将替换为零个或多个值元素。效果类似于在C语言中使用。format % values%sprintf()

如果format需要单个参数，则值可以是单个非元组对象。[5] 否则，值必须是具有格式字符串指定的项目数的元组，或者是单个映射对象（例如，字典）。

转换说明符包含两个或多个字符，并具有以下组件，这些组件必须按以下顺序出现：

1. 该'%'字符，标记说明符的开头。
2. 映射键（可选），由带括号的字符序列组成（例如(somename)）。
3. 转换标志（可选），它会影响某些转换类型的结果。
4. 最小字段宽度（可选）。如果指定为'*'（星号），则从值的元组的下一个元素读取实际宽度，并且要转换的对象在最小字段宽度和可选精度之后。
5. 精度（可选），以'.'（点）表示，后跟精度。如果指定为'*'（星号），则从值的元组的下一个元素读取实际精度，并且要转换的值在精度之后。
6. 长度修饰符（可选）。
7. 转换类型。

当右参数是字典（或其他映射类型）时，字符串中的格式必须包括括号中的映射键，该字符串紧接在'%'字符后面插入的字典中。映射关键字从映射中选择要格式化的值。例如：

>>> print('%(language)s has %(number)03d quote types.' % 
...     {'language': "Python", "number": 2}) 
Python has 002 quote types.

在这种情况下*，格式中不会出现说明符（因为它们需要顺序参数列表）。

转换标志字符是：

可以存在长度修饰符（h，l或L），但忽略它，因为它不是Python所必需的 – 因此例如%ld是相同的%d。

转换类型包括：

笔记：

1. 替代形式导致'0o'在第一个数字之前插入前导八进制说明符（）。

2. 在另一种形式使得领先'0x'或'0X'（取决于是否'x'或'X'使用格式）的第一位数字之前插入。

3. 替代形式导致结果始终包含小数点，即使后面没有数字也是如此。

   精度确定小数点后的位数，默认为6。

4. 替代形式导致结果始终包含小数点，并且不会删除尾随零，否则它们将被删除。

   精度确定小数点前后的有效位数，默认为6。

5. 如果是precision N，则输出将截断为N字符。

6. 看到 PEP 237。

由于Python字符串具有明确的长度，因此%s转换不会假定它'\0'是字符串的结尾。