Types: 6. Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange

6. Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange

有七种序列类型：字符串，Unicode字符串，列表，元组，字节数组，缓冲区和xrange对象。

对于其他容器，请参阅内置dict()和set()函数以及collections模块。

字符串文字用单引号或双引号写入：'xyzzy'，"frobozz"。有关字符串文字的更多信息，请参阅字符串文字。Unicode字符串很像字符串，但是在语法中使用前面的'u'字符指定：u'abc'，u"def"。除了这里描述的功能之外，字符串方法部分中还描述了特定于字符串的方法。列表用方括号构成，用逗号分隔项目：[a, b, c]。元组由逗号运算符（不在方括号内）构造，带或不带括号括起来，但空元组必须带括号括起来的括号，如a, b, c或()。单个元组元组必须具有尾随逗号，例如(d,)。

Bytearray对象是使用内置函数创建的bytearray()。

缓冲区对象不直接受Python语法支持，但可以通过调用内置函数来创建buffer()。他们不支持连接或重复。

xrange类型的对象类似于缓冲区，因为没有特定的语法来创建它们，但是它们是使用xrange()函数创建的。它们不支持切片，串联或重复使用in，not in，min()或max()对它们是无效的。

大多数序列类型支持以下操作。在in和not in操作具有比较操作相同的优先级。在+与*操作具有相同的优先级对应的数字运算。[3]为可变序列类型提供了其他方法。

此表列出按升序优先级排序的序列操作。在表中，s和t是相同类型的序列; n，i和j是整数：

Operation	结果	笔记
x in s	如果s的项等于x，则为真，否则为False	(1)
x不在s中	假如一个s的项等于x，则为假，否则为真	(1)
s + t	s和t的连接	(6)
s * n，n * s	相当于将n次添加到自身	(2)
si	第s项，起源0	(3)
如果：J-	从我到j的切片	(3)(4)
如果：J-ķ	从步骤k的i到j的片段	(3)(5)
只有（一）	s的长度	​
分钟）	s的最小项	​
MAX（S）	最大的项目	​
s.index（x）的	s中第一次出现x的索引	​
s.count（x）的	s中出现x的总次数	​

序列类型也支持比较。具体来说，元组和列表通过比较相应的元素按字典顺序进行比较。这意味着为了比较相等，每个元素必须相等并且两个序列必须是相同类型并具有相同长度。（有关完整的详细信息，请参阅语言参考中的比较。）

Notes:

• 当s是一个字符串或Unicode字符串对象时in，not in操作就像一个子串测试一样。在2.3之前的Python版本中，x必须是长度为1的字符串。在Python 2.3及更高版本中，x可以是任意长度的字符串。

• 小于n的值0被视为0（其产生与s相同类型的空序列）。请注意，序列中的项目不会被复制; 它们被多次引用。这经常困扰着新的Python程序员; 考虑：列表= [[]] * 3 >>>列表[[]，[]，[]] >>> lists0.append（3）>>>列表[3，3]发生了什么[[]]是一个包含一个空列表的单元素列表，所以这三个元素[[]] * 3都是对这个单个空列表的引用。修改任何元素lists修改这个单子列表。您可以通过这种方式创建不同列表的列表：lists = [[] for i in range（3）] >>> lists0.append（3）>>> lists1.append（5）>>> lists2.append（7 ）>>> lists [3，5，7]常见问题解答条目中提供了进一步说明如何创建多维列表？。

• 如果i或j是负数，则该索引是相对于序列s的末尾：len(s) + i或被len(s) + j替换。但请注意，-0依然如此0。

• 的切片小号从我到Ĵ被定义为物品的具有索引序列ķ使得i <= k < j。如果我或j大于len(s)，请使用len(s)。如果我被省略或者None使用0。如果省略了j，或者None使用len(s)。如果我大于或等于j，则切片为空。

• 步骤k中从i到j的s片段被定义为具有这样的索引的项目序列。换句话说，在指数，，，等等，停车时Ĵ达到（但绝不包括Ĵ）。当k是正数时，如果它们更大，则i和j会减少。当k是负数时，如果i和j更大，则i和j减小。如果我或j被省略或x = i + n*k0 <= n < (j-i)/kii+ki+2*ki+3*klen(s)len(s) - 1None，它们变成了“终点”值（终点取决于k的符号）。请注意，k不能为零。如果k是None，它被视为像1。

• CPython实现细节：如果s和t都是字符串，则一些Python实现（例如CPython）通常可以为窗体s = s + t或窗体的赋值执行就地优化s += t。如果适用，这种优化使得二次运行时间不太可能。这种优化是版本和实现相关的。对于性能敏感的代码，最好使用str.join()确保不同版本和实现之间一致的线性级联性能的方法。

在版本2.4中更改：以前，字符串连接从来没有发生过。

6.1。字符串方法

下面列出了8位字符串和Unicode对象都支持的字符串方法。其中一些也可用于bytearray对象。

另外，Python的字符串支持序列类型中描述的序列类型方法 - str，unicode，list，tuple，bytearray，buffer，xrange部分。要输出格式化的字符串，请使用%字符串格式操作部分中描述的模板字符串或运算符。另请参阅re模块，了解基于正则表达式的字符串函数。

str.capitalize()

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

对于8位字符串，此方法是区域设置相关的。

str.center(width[, fillchar])

返回以一个长度宽度的字符串为中心。填充是使用指定的fillchar完成的（默认为空格）。

在版本2.4中更改：支持fillchar参数。

str.count(sub[, start[, end]])

返回范围start，end 中子串sub的非重叠次数。可选参数开始和结束被解释为切片符号。

str.decode([encoding[, errors]])

使用注册编码的编码解码器解码字符串。编码默认为默认的字符串编码。可能会给出错误来设置不同的错误处理方案。默认值是'strict'，意味着编码错误会增加UnicodeError。其他可能的值是'ignore'，'replace'并且通过注册的任何其他名称codecs.register_error()，请参见编解码器基类。

2.2版本中的新功能。

在版本2.3中进行了更改：添加了对其他错误处理方案的支持。

在2.7版本中进行了更改：添加了对关键字参数的支持。

str.encode([encoding[, errors]])

返回字符串的编码版本。默认编码是当前的默认字符串编码。可能会给出错误来设置不同的错误处理方案。错误的默认值是'strict'，这意味着编码错误会引发一个错误UnicodeError。其他可能的值'ignore'，'replace'，'xmlcharrefreplace'，'backslashreplace'并通过注册的任何其他名称codecs.register_error()，请参见编解码基础类。有关可能的编码列表，请参见标准编码部分。

2.0版本中的新功能。

在版本2.3中进行了更改：添加了对'xmlcharrefreplace'和'backslashreplace'和其他错误处理方案的支持。

在2.7版本中进行了更改：添加了对关键字参数的支持。

str.endswith(suffix[, start[, end]])

返回True字符串是否与指定的结束后缀，否则返回False。后缀也可以是后缀的元组来查找。随着可选启动，测试开始在那个位置。选择结束时，停止在该位置进行比较。

在版本2.5中更改：接受元组作为后缀。

str.expandtabs([tabsize])

返回字符串的副本，其中所有制表符由一个或多个空格替换，具体取决于当前列和给定制表符大小。选项卡位置出现在每个制表符大小字符中（默认值为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 子字符串的最低索引s[start:end]。可选参数开始和结束被解释为切片符号。-1如果未找到子项，则返回。

注释

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'

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

这种字符串格式化方法是Python 3中的新标准，应优先%于新代码中字符串格式化操作中描述的格式。

2.6版本中的新功能。

str.index(sub[, start[, end]])

就像find()，但ValueError在没有找到子字符串时引发。

str.isalnum()

如果字符串中的所有字符都是字母数字并且至少有一个字符，则返回true，否则返回false。

对于8位字符串，此方法是区域设置相关的。

str.isalpha()

如果字符串中的所有字符都是字母并且至少有一个字符，则返回true，否则返回false。

对于8位字符串，此方法是区域设置相关的。

str.isdigit()

如果字符串中的所有字符都是数字并且至少有一个字符，则返回true，否则返回false。

对于8位字符串，此方法是区域设置相关的。

str.islower()

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

对于8位字符串，此方法是区域设置相关的。

str.isspace()

如果字符串中只有空格字符，并且至少有一个字符，则返回true，否则返回false。

对于8位字符串，此方法是区域设置相关的。

str.istitle()

如果字符串是一个标题字符串并且至少有一个字符，则返回true，例如，大写字符只能跟在未写入的字符之后，而小写字母只能在已封装的字符之后。否则返回false。

对于8位字符串，此方法是区域设置相关的。

str.isupper()

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

对于8位字符串，此方法是区域设置相关的。

str.join(iterable)

返回一个字符串，它是可 迭代迭代中字符串的串联。元素之间的分隔符是提供此方法的字符串。

str.ljust(width[, fillchar])

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

在版本2.4中更改：支持fillchar参数。

str.lower()

返回字符串的一个副本，并将所有装入字符的字符[4]转换为小写字母。

对于8位字符串，此方法是区域设置相关的。

str.lstrip([chars])

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

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

在版本2.2.2中更改：支持chars参数。

str.partition(sep)

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

2.5版本中的新功能。

str.replace(old, new[, count])

返回所有出现的旧字符串替换为新字符串的副本。如果给出可选的参数计数，则仅替换第一个计数事件。

str.rfind(sub[, start[, end]])

返回找到substring 子字符串的最高索引，这样sub就包含在其中s[start:end]。可选参数开始和结束被解释为切片符号。返回-1失败。

str.rindex(sub[, start[, end]])

像rfind()但ValueError子字符串子未找到时引发。

str.rjust(width[, fillchar])

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

在版本2.4中更改：支持fillchar参数。

str.rpartition(sep)

在最后出现的sep处拆分字符串，并返回包含分隔符之前的部分，分隔符本身和分隔符之后的部分的三元组。如果未找到分隔符，则返回包含两个空字符串的三元组，然后返回字符串本身。

2.5版本中的新功能。

str.rsplit([sep[, maxsplit]])

使用sep作为分隔符字符串，返回字符串中单词的列表。如果给出maxsplit，则最多maxsplit分裂，最右边的分裂。如果没有指定sep或者None任何空格字符串是分隔符。除了从右边分开外，rsplit()其行为split()如下所述。

2.4版本中的新功能。

str.rstrip([chars])

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

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

在版本2.2.2中更改：支持chars参数。

str.split([sep[, maxsplit]])

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

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

如果未指定sep或is None，则应用不同的分割算法：将连续空白的运行视为单个分隔符，并且如果字符串具有前导或尾随空白，则结果的开始或结束将不包含空字符串。因此，用None分隔符分隔一个空字符串或一个只包含空格的字符串会返回[]。

例如，' 1 2 3 '.split()返回['1', '2', '3']并' 1 2 3 '.split(None, 1)返回['1', '2 3 ']。

str.splitlines([keepends])

返回字符串中行的列表，在行边界处突破。此方法使用通用换行符方法来分割线条。除非换行符不包括在结果列表中keepends，并给出正确的。

Python的认识"\r"，"\n"以及"\r\n"作为边界线为8位字符串。

例如：

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(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', '']

unicode.splitlines([keepends])

返回字符串中的行列表，如str.splitlines()。但是，Unicode方法在以下行边界上分割，这些行边界是8位字符串识别的通用换行符的超集。

表示	描述
\ n	换行
\ r	回车
\ r \ n	回车+换行
\ v或\ x0b	线条制表
\ f或\ x0c	换页
\ X1C	文件分隔符
\ X1D	组分隔符
\ x1e	记录分隔符
\ x85	下一行（C1控制代码）
\ u2028	线分隔符
\ u2029	段落分隔符

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

str.startswith(prefix[, start[, end]])

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

在版本2.5中更改：接受元组作为前缀。

str.strip([chars])

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

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

在版本2.2.2中更改：支持chars参数。

str.swapcase()

返回大写字符转换为小写字符串的副本，反之亦然。

对于8位字符串，此方法是区域设置相关的。

str.title()

返回字符串的字幕版本，其中字以大写字符开头，其余字符为小写字母。

该算法使用简单的与语言无关的单词作为连续字母组的定义。该定义在许多情况下都有效，但这意味着收缩和占有者中的撇号会形成单词边界，这可能不是理想的结果：

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

对于8位字符串，此方法是区域设置相关的。

str.translate(table[, deletechars])

返回删除可选参数deletechars中出现的所有字符的字符串副本，其余字符已通过给定的转换表映射，该转换表必须是长度为256的字符串。

您可以使用模块中的maketrans()帮助器功能string来创建转换表。对于字符串对象，请将表参数设置None为仅用于删除字符的翻译：

>>> 'read this short text'.translate(None, 'aeiou')
'rd ths shrt txt'

2.6版新增功能：支持None 表格参数。

对于Unicode对象，该translate()方法不接受可选的deletechars参数。相反，它会返回一个s的副本，其中所有字符已经通过给定的转换表映射，该表必须是Unicode序号到Unicode序号，Unicode字符串或None。未映射的字符保持不变。映射到的字符None被删除。请注意，更灵活的方法是使用codecs模块创建自定义字符映射编解码器（请参阅encodings.cp1251示例）。

str.upper()

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

对于8位字符串，此方法是区域设置相关的。

str.zfill(width)

返回长度宽度字符串中填充零的数字字符串。符号前缀处理正确。如果宽度小于或等于，则返回原始字符串len(s)。

New in version 2.2.2.

以下方法仅出现在unicode对象上：

unicode.isnumeric()

True如果S中只有数字字符则返回，False否则返回。数字字符包括数字字符和具有Unicode数值属性的所有字符，例如U + 2155，VULGAR FRACTION ONE FIFTH。

unicode.isdecimal()

True如果S中只有十进制字符则返回，False否则返回。十进制字符包括数字字符以及可用于形成十进制小数数字的所有字符，例如U + 0660，ARABIC-INDIC DIGIT ZERO。

6.2。字符串格式化操作

字符串和Unicode对象有一个独特的内置操作：%操作符（模）。这也被称为字符串格式化或插值运算符。鉴于format % values（其中格式是字符串或Unicode对象），格式中的%转换规范将替换为零个或多个值元素。其效果与使用C语言相似。如果format是一个Unicode对象，或者使用该转换转换的任何对象都是Unicode对象，则结果也将是一个Unicode对象。sprintf()%s

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

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

• 该'%'字符表示说明符的开始。

• 映射键（可选），由括号括起来的字符序列组成（例如(somename)）。

• 转换标志（可选），影响某些转换类型的结果。

• 最小字段宽度（可选）。如果指定为'*'（星号），则将从元组的下一个元素值中读取实际宽度，并且要转换的对象位于最小字段宽度和可选精度之后。

• 精度（可选），以'.'（点）形式给出，然后是精度。如果指定为'*'（星号），则将从元组的下一个元素的值中读取实际宽度，并且要转换的值位于精度之后。

• 长度修饰符（可选）。

• 转换类型。

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

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

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

转换标志字符是：

标志	含义
'#'	值转换将使用“替代形式”（下面定义）。
'0'	转换将为数字值填充零。
'-'	转换后的值将保持调整状态（如果两者都被赋予，将覆盖'0'转换）。
' '	（一个空格）在由正确的数字（或空字符串）产生的一个空白应该留下一个有符号的转换。
'+'	符号字符（'+'或' - '）将在转换之前（覆盖“空格”标志）。

长度修饰符（h，l或L）可能存在，但会被忽略，因为它对于Python不是必需的 - 例如与之%ld相同%d。

转换类型是：

转变	含义	笔记
'd'	带符号的整数小数。	​
'一世'	带符号的整数小数。	​
这个	签署八进制值。	(1)
“在”	已过时的类型 - 与“d”相同。	(7)
'X'	签名的十六进制（小写）。	(2)
'X'	签名的十六进制（大写）。	(2)
“与”	浮点指数格式（小写）。	(3)
'E'	浮点指数格式（大写）。	(3)
'F'	浮点十进制格式。	(3)
'F'	浮点十进制格式。	(3)
'G'	浮点格式。如果指数小于-4或小于精度，则使用小写指数格式，否则使用小数格式。	(4)
'G'	浮点格式。如果指数小于-4或者不小于精度，则使用大写指数格式，否则使用小数格式。	(4)
'C'	单个字符（接受整数或单个字符串）。	​
'R'	String（使用repr（）转换任何Python对象）。	(5)
'S'	字符串（使用str（）转换任何Python对象）。	(6)
'%'	没有参数被转换，结果为'％'字符。	​

注释：

• '0'如果结果的前导字符不是零，则替换形式将导致在左侧填充和数字格式之间插入前导零（）。

• 替代形式会导致在第一个数字之前插入'0x'或'0X'取决于是否使用了'x'或'X'格式。

• 替代形式会导致结果始终包含小数点，即使没有数字跟着它。精度决定小数点后的位数，默认为6。

• 替代形式导致结果始终包含小数点，并且尾部零不会像原本那样被删除。精度决定小数点前后的有效位数，默认值为6。

• 该%r转换是在Python 2.0中添加的。精度决定了使用的字符的最大数量。

• 如果提供的对象或格式是一个unicode字符串，则结果字符串也是unicode。精度决定了使用的字符的最大数量。

• 见PEP 237。

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

在版本2.7中进行了更改：%f绝对值超过1e50的数字转换不再被%g转换替代。

附加的字符串操作在标准模块中定义string和re。

6.3。XRange类型

该xrange类型是一种常用于循环的不可变序列。该xrange类型的优点是xrange对象总是会占用相同数量的内存，而不管它所代表的范围的大小。没有一致的性能优势。

XRange对象的行为很少：它们只支持索引，迭代和len()函数。

6.4。可变序列类型

列表和bytearray对象支持允许就地修改对象的其他操作。其他可变序列类型（添加到语言中时）也应该支持这些操作。字符串和元组是不可变的序列类型：一旦创建，这些对象就不能被修改。以下操作定义在可变序列类型上（其中x是任意对象）：

手术	结果	笔记
if = x	s的项目i被x替换	​
如果：j = t	从i到j的片段由可迭代的t的内容替换	​
del si：j	相同，如果：j = []	​
如果：j：k = t	si：j：k的元素被t的元素替换	(1)
del if：j：k	从列表中删除si：j：k的元素	​
s.append（x）的	与slen（s）相同：len（s）= x	(2)
s.extend（t）或s + = t	大部分与slen（s）相同：len（s）= t	(3)
s * = n	将其内容重复n次更新	(11)
s.count（x）的	返回i的数量为si == x	​
s.index（x [，i，j]）	返回最小的k，使得sk == x和i <= k <j	(4)
s.insert（i，x）	相同：i = x	(5)
s.pop（ⅰ）	与x = if相同; 德尔斯; 返回x	(6)
s.remove（x）的	与del ss.index（x）相同	(4)
s.reverse（）	反转s的项目到位	(7)
s.sort（[cmp [，key，reverse]]）	对s的项目进行排序	(7)(8)(9)(10)

注释：

• t必须与它正在替换的切片具有相同的长度。

• Python的C实现在历史上接受了多个参数，并将它们隐式地加入到一个元组中; 这不再适用于Python 2.0。自从Python 1.4以来，这种错误的使用已被废弃。

• t可以是任何可迭代的对象。

• 在s中未找到xValueError时引发。当负方向索引作为方法的第二个或第三个参数传递时，与切片索引相同，将添加列表长度。如果它仍然是负数，就像截面索引一样截断为零。在版本2.3中更改：以前，没有用于指定开始和停止位置的参数。index()index()

• 如果将负向索引作为方法的第一个参数传递，则会像insert()添加切片索引一样添加列表长度。如果它仍然是负数，就像截面索引一样截断为零。在版本2.3中更改：以前，所有负指数都被截断为零。

• 该pop()方法的可选参数我默认为-1，所以默认情况下最后一项被删除并返回。

• 在排序或倒排大型列表时，sort()和reverse()方法会修改列表以实现空间节约。为了提醒您，他们以副作用的方式操作，他们不会返回排序或颠倒的列表。

• 该sort()方法采用可选参数来控制比较。 cmp指定两个参数（列表项）的自定义比较函数，它应该返回一个负数，零或正数，具体取决于第一个参数是否小于，等于或大于第二个参数：cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值是None。 key指定一个用于从每个列表元素中提取比较键的参数的函数：key=str.lower。默认值是None。 reverse是一个布尔值。如果设置为True，则列表元素按照每个比较被颠倒的顺序进行排序。一般来说，关键和反向转换过程比指定等效的cmp函数要快得多。这是因为对于每个列表元素，cmp被多次调用，而按键和反向触摸每个元素只有一次。用functools.cmp_to_key()一个老式的转换CMP功能的关键功能。在版本2.3中进行了更改：添加None了对等效于省略cmp的支持。

在版本2.4中进行了更改：添加了对密钥和反向的支持。

• 从Python 2.3开始，该sort()方法保证稳定。如果确保不会更改比较相等的元素的相对顺序，则排序是稳定的 - 这对于多次排序（例如，按部门排序，然后按薪级）进行排序很有帮助。

• CPython实现细节：列表正在排序时，尝试对列表进行更改或甚至检查的影响是未定义的。Python 2.3和更新版本的C实现使得列表在持续时间内显示为空，并且ValueError如果它能够检测列表在排序过程中发生了变异，则引发该列表。

• 值n是一个整数或实现的对象__index__()。n的零和负值清除序列。序列中的项目不会被复制; 它们被多次引用，如s * n序列类型 - str，unicode，list，tuple，bytearray，buffer，xrange中所解释的。