Python __ 列表与元组
序列
在Python中，最基本的数据结构为序列（sequence）。
序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，依此类推。，用负索引表示序列末尾元素的位置。
序列包括：列表list，元组tuple和字符串str
通用的序列操作
有几种操作适用于所有序列:索引、迭代、切片、相加、相乘和成员资格检查
另外，Python还提供了一些内置函数，可用于确定序列的长度以及找出序列中最大和最小的元素。
索引
索引用来访问单个元素。
序列中的所有元素都有编号——从0开始递增。
使用负数索引时，Python将从右（即从最后一个元素）开始往左数，因此-1是最后一个元素的位置。
>>> str="Hello"
>>> print(str[0])
>>> print(str[-1])
>>> print("Hello"[-1])
H
o
o
如果函数调用返回一个序列，可直接对其执行索引操作。例如，如果你只想获取用户输入的
年份的第4位，可像下面这样做：
>>> fourth = input('Year: ')[3]
# 输入：2005
>>> fourth
'5'
切片
切片（slicing）：用来访问特定范围内的元素。
可使用两个索引，并用冒号分隔：
第一个索引是包含的第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号（也就是左闭右开）。
>>> tag = '<a href="http://www.python.org">Python web site</a>'
>>> tag[9:30]
'http://www.python.org'
>>> tag[32:-4]
'Python web site'
简写
执行切片操作时，如果切片结束于序列末尾，可省略第二个索引。
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[-3:]
[8, 9, 10]
同样，如果切片始于序列开头，可省略第一个索引。
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[:3]
[1, 2, 3]
要复制整个序列，可将两个索引都省略。
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
步长
如果不指定，步长默认为1。
这意味着从一个元素移到下一个元素，因此切片包含起点和终点之间的所有元素。
可以显式地指定了步长，步长可以为正数，也可以为负数、即从右向左提取元素。
当然，步长不能为0，否则无法向前移动。
例如：
>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
>>> numbers[3:6:3]
[4]
>>> numbers[8:3:-1]
[9, 8, 7, 6, 5]
显式地指定步长时，也可使用简写。
>>> numbers[::4]
[1, 5, 9]
序列相加
可使用加法运算符来拼接序列。
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello,' + 'world!'
'Hello, world!'
>>> [1, 2, 3] + 'world!'
Traceback (innermost last):
File "<pyshell>", line 1, in ?
[1, 2, 3] + 'world!'
TypeError: can only concatenate list (not "string") to list
从错误消息可知，不能拼接列表和字符串，虽然它们都是序列。一般而言，不能拼接不同类
型的序列。
乘法
将序列与数x相乘时，将重复这个序列x次来创建一个新序列：
>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]
None、空列表和初始化
空列表是使用不包含任何内容的两个方括号（[]）表示的。
如果要创建一个可包含10个元素的列表，但没有任何有用的内容，
一般使用是使用[0]*10，这将创建一个包含10个零的列表。
在有些情况下，你可能想使用表示“什么都没有”的值，如表示还没有在列表中添加任何内容。在这种情况下，可使用None。（在Python中，None表示什么都没有。）
因此，要将列表的长度初始化为10，可像下面这样做：
>>> sequence = [None] * 10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]
成员资格
要检查特定的值是否包含在序列中，可使用运算符in。
它检查是否满足指定的条件，并返回相应的值：满足时返回True，不满足时返回False。
使用示例：
>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False
长度、最小值和最大值
内置函数len返回序列包含的元素个数，
min和max分别返回序列中最小和最大的元素
（可以直接将数作为实参，后两个样例）
>>> numbers = [100, 34, 678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34
>>> max(2, 3)
3
>>> min(9, 3, 2, 5)
2
列表
不同于元组和字符串，列表是可变的，即可修改其内容。
因此，列表有很多特有的方法。
函数list()
函数list()可将任何序列（而不仅仅是字符串）转化为list
>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
基本操作
1. 修改列表：给元素赋值
用索引表示法给特定位置的元素赋值，如x[1] = 2。
2. 删除元素
使用del语句即可从列表中删除元素。
>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']
通过切片增删改查
可以通过切片实现列表的增删改查
>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']
通过切片赋值和分别给每个元素赋值不同是：
通过使用切片赋值，可将切片替换为长度与其不同的序列。
>>> name = list('Perl')
>>> name[1:] = list('ython')
>>> name
['P', 'y', 't', 'h', 'o', 'n']
使用切片赋值还可在不替换原有元素的情况下插入新元素。
通过“替换”了一个空切片，相当于插入了一个序列。
>>> numbers = [1, 5]
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]
采取相反的措施，即可删除。
>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4] = []
>>> numbers
[1, 5]
上述代码与del numbers[1:4]等效。
列表方法
append 原地修改
方法append用于将一个对象附加到列表末尾。
clear
方法clear就地清空列表的内容。
copy
方法copy 复制列表。
常规复制只是将另一个名称关联到列表。（修改一个，另一个也改变）
使用copy方法是新建一个副本。（修改一个，另一个不变）这类似于使用a[:]或list(a)，它们也都复制a。
# 常规
>>> a = [1, 2, 3]
>>> b = a
>>> b[1] = 4
>>> a
[1, 4, 3]
#copy
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> b[1] = 4
>>> a
[1, 2, 3]
count
方法count计算指定的元素在列表中出现了多少次。
extend
方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提
供给方法extend。换而言之，你可使用一个列表来扩展另一个列表。
虽然看起来类似于拼接，但存在一个重要差别：那就是将修改被扩展的序列（下面的a），在常规拼接中，情况是返回一个全新的序列。而extend函数吃就地修改。
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
index
方法index在列表中查找指定值第一次出现的索引。
insert
方法insert用于将一个对象插入列表。
和append不同，insert需要指定index。
pop
方法pop删除列表的最后一个元素，并返回这一元素。
pop是唯一既修改列表又返回一个非None值的列表方法。
- 到这里就可以使用列表模拟栈了
python没有实现栈。但是可以模拟出来
使用append来替代压入（push）
使用pop弹出
remove
方法remove用于删除第一个为指定值的元素。
>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']
reverse
方法reverse按相反的顺序排列列表中的元素
sort
方法sort用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序
排列，而不是返回排序后的列表的副本
如果想获取排序后的列表的副本：
只是将x赋给y是不可行的，因为这样x和y将指向同一个列表，需要使用copy。
最好使用函数sorted。
>>> x = [4, 6, 2, 1, 7, 9]
>>> y = sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]
高级排序
方法sort接受两个可选参数：key和reverse。
参数key类似于参数cmp：你将其设置为一个用于排序的函数。然而，不会直接使用这个函数来判断一个元素是否比另一个元素小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。
因此，要根据长度对元素进行排序，可将参数key设置为函数len。
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']
对于另一个关键字参数reverse，只需将其指定为一个真值（True或False），以指出是否要按相反的顺序对列表进行排序。
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort(reverse=True)
>>> x
[9, 7, 6, 4, 2, 1]
函数sorted也接受参数key和reverse，用法和sort一样。
元组tuple：不可修改的序列
与列表一样，元组也是序列，唯一的差别在于元组是不能修改的（字符串也不能修改）。
创建元组很简单，常见有三种方法：****
- 只要将一些值用逗号分隔，就能自动创建一个元组。
- 元组还可用圆括号括起（通常采用的做法）。
- 函数tuple()：与list很像，它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。
>>> 1, 2, 3
(1, 2, 3)
>>> (1, 2, 3)
(1, 2, 3)
空元组用两个不包含任何内容的圆括号表示。
>>> ()
()
但是对于创建只包含一个值的元组有点特殊：
虽然只有一个值，但是必须在它后面加上逗号。
>>> 42
42
>>> 42,
(42,)
>>> (42,)
(42,)
为何要熟悉元组？
原因有以下两个。
- 它们用作映射中的键（以及集合的成员），而列表不行。
- 有些内置函数和方法返回元组。
只要不尝试修改元组，与元组“打交道”通常意味着像处理列表一样处理它们（需要使用元组没有的index和count
等方法时例外）。
