文章目录
在Python中内置了多种序列，其中最常用的两种：列表[]和元组()。
列表和元组的主要不同在于：列表是可以修改的，而元组不可以。这意味着列表适用于 需要中途添加元素的情形，而元组适用出于某种考虑需要禁止 修改序列的情形。
1 通用的序列操作
1.1 索引
序列中所有元素都有编号，并从0开始递增。而编号通常被称为索引。
你可以使用索引来获取元素，如：
>>> a = 'hello world'
>>> a[0]
'h'
当使用负数索引时，Python将从右（最后一个元素）开始往左数，因此-1是最后一个元素的位置：
>>> a[-1]
'd'
1.2 切片
使用两个索引，并用冒号分隔的方式来访问特定范围内的元素，称为切片。
其中，第一个索引是包含的的第一个元素的编号，第二个索引是切片后余下的第一个元素的编号，类似数学区间 [x, y) 的概念。
>>> n = [1,2,3,4,5,6,7,8,9,10]
>>> n[0:1]
[1]
>>> n[7:9]
[8, 9]
>>> n[-3:-1]
[8, 9]
但如果第一个索引指定的元素位于第二个索引指定的元素后面，结果就为空序列。
>>> n[-3:0]
[]
1.2.1 简写
如果切片结束于序列末尾，可省略第二个索引
>>> n[3:]
[4, 5, 6, 7, 8, 9, 10]
如果切片始于序列开头，可省略第一个索引
>>> n[:3]
[1, 2, 3]
如果要复制整个序列，可将两个索引都省略
>>> n[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1.2.2 步长
执行切片操作时，通常会省略另一个参数：步长。
在普通切片中，步长为1：
>>> n[::1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
步长为2时，将从起点和终点之间每隔一个元素提取一个元素
>>> n[::2]
[1, 3, 5, 7, 9]
注意：步长不能为0，否则无法想前移动，但可以为负数，即从右向左提取元素
>>> n[::0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: slice step cannot be zero
>>> n[::-2]
[10, 8, 6, 4, 2]
1.3 序列相加
可使用加法运算符来拼接序列，但不能拼接不同类型的序列。
>>> [1,2,3,4] + [5,6,7,8]
[1, 2, 3, 4, 5, 6, 7, 8]
>>> 'hello' + 'world'
'helloworld'
>>> 'hello' + [5,6,7,8]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "list") to str
1.4 乘法
将序列与数x相乘是，将重复这个序列x次来创建一个新序列
>>> [12] * 12
[12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12]
>>> 'python' * 5
'pythonpythonpythonpythonpython'
1.5 成员资格
要检查特定的值是否包含在序列中，可使用运算符in，检查是否满足指定的条件，并返回相应的值：满足时返回True，不满足返回False。
>>> s = 'hello world'
>>> 'h' in s
True
>>> 'L' in s
False
>>> 'H' in s
False
1.6 长度、最大值和最小值
内置函数len返回序列包含的元素个数，而max和min分别返回序列中最大和最小的元素。
>>> n = [100, 34, 886]
>>> len(n)
3
>>> max(n)
886
>>> min(n)
34
2 列表
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。可使用list函数可以将一个序列作为参数，并将其转换为元组：
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
对列表执行的所有标准序列操作，如索引，切片等，但列表还可以被修改。
2.1 赋值元素
只需要用普通的赋值语句，就能修改列表中的元素
>>> x = [1, 1, 1]
>>> x[1] = 2
>>> x
[1, 2, 1]
2.2 删除元素
使用del语句即可删除列表中的元素
>>> del x[2]
>>> x
[1, 2]
2.3 切片赋值
切片赋值的方式，可以同时给多个元素赋值
>>> name = list('Li')
>>> name
['L', 'i']
>>> name[1:] = list('ang')
>>> name
['L', 'a', 'n', 'g']
使用切片赋值，还可在不替换原有元素的情况下插入新元素
>>> n = [1,5]
>>> n[1:1] = [2,3,4]
>>> n
[1, 2, 3, 4, 5]
当然也可以反过来删除切片
>>> n = [1, 2, 3, 4, 5]
>>> n[1:4] = []
>>> n
[1, 5]
2.4 列表方法
2.4.1 append
方法append用于将一个对象附加到列表末尾
>>> n = [1, 2, 3]
>>> n.append(4)
>>> n
[1, 2, 3, 4]
2.4.2 clear
方法clear清空列表的内容
>>> n = [1, 2, 3]
>>> n.clear()
>>> n
[]
2.4.3 copy
常规复制，只是将两一个名称关联到列表
>>> a = [1, 2, 3]
>>> b = a
>>> b[1] = 4
>>> a
[1, 4, 3]
要让a和b指向不同的列表，就必须将b关联到a的副本
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> b[1] = 4
>>> b
[1, 4, 3]
>>> a
[1, 2, 3]
2.4.4 count
方法count计算指定的元素在列表中出现了多少次。
>>> x = [[1, 2], 2, 1, 1, [1, 2]]
>>> x.count(2)
1
>>> x.count([1, 2])
2
2.4.5 extend
方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给extend。换言之，可使用一个列表扩展另一个列表。
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
>>> b
[4, 5, 6]
与拼接不同，extend修改了被扩展的序列，而在常规拼接中，返回的是一个全新的序列
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]
2.4.6 index
方法index在列表中查找指定值第一次出现的索引
>>> n = [1,2,3,3,4]
>>> n.index(2)
1
>>> n.index(3)
2
>>> n.index(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 5 is not in list
搜索5时，发生了异常，因为列表中根本不包含5
2.4.7 insert
方法insert用于将一个对相关插入列表
>>> n = [1, 2, 3, 4, 5]
>>> n.insert(3, 'four')
>>> n
[1, 2, 3, 'four', 4, 5]
2.4.8 pop
方法pop从列表中删除一个元素（默认为最后一个元素），并返回这个元素。使用pop可实现栈（stack）
>>> n = [1, 2, 3]
>>> n.pop()
3
>>> n
[1, 2]
>>> n.pop(0)
1
>>> n
[2]
pop是唯一即修改列表又返回一个非None值的列表方法
2.4.9 remove
方法remove用于删除第一个所指定值的元素
>>> x = [1, 2 ,3, 2, 4, 5]
>>> x.remove(2)
>>> x
[1, 3, 2, 4, 5]
>>> x.remove(2)
>>> x
[1, 3, 4, 5]
>>> x.remove(6)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
2.4.10 reverse
方法reverse按相反的顺序排列列表中的元素。
>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]
2.4.11 sort
方法sort用于对列表就地排序（由小到大）。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。
>>> x = [1, 2, 4, 3, 6, 5]
>>> x.sort()
>>> x
[1, 2, 3, 4, 5, 6]
如果要将元素按照相反的顺序排列，可以先使用sort方法，在调用方法reverse，或者使用reverse参数
>>> x = [1, 2, 4, 3, 6, 5]
>>> x.sort(reverse=True)
>>> x
[6, 5, 4, 3, 2, 1]
方法sort还有一个可选参数是key。参数key类似于参数cmp，主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
如，按照长度排序：
>>> x = ['ad', 'abcd', 'abc']
>>> x.sort(key=len)
>>> x
['ad', 'abc', 'abcd']
3 元组
与列表一样，元组也是序列，唯一的差别在于元组是不能修改的。元组的语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。
>>> 1,2,3
(1, 2, 3)
元组还可用圆括号括起（这也是通常采用的方法）
>>> (1,2,3)
(1, 2, 3)
空元祖
>>> ()
()
只有一个值的元祖，注意需要加上逗号
>>> 12,
(12,)
函数tuple的工作原理与list很像，它将一个序列作为参数，并将其转换为元组。
>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple('1,2,3')
('1', ',', '2', ',', '3')
一般而言元组会用在以下两个方面：
- 元组用作映射中的键（以及集合的成员），而列表不行。
- 有些内助函数和方法返回元组。
4 总结
序列是一种数据结构，其中的元素带编号（编号从0开始）。列表、字符串，和元组都属于序列，其中列表是可变的，而元组和字符串是不可变的。
