（六）Python列表、元组、列表推导式

列表对象及其方法

列表[]是Python的内置数据结构之一，拥有强大的功能。
列表是包含若干元素的连续内存存储空间，列表中每个元素储存的也是对值的引用，所以列表中每一个元素可以是任意类型的对象，比如数字类型，元组类型，列表类型等等。

1. 列表创建与删除

直接使用赋值运算和方括号lst = [elem,...]就可以创建列表对象
还可以使用list()函数将一些可迭代对象转换成列表对象

>>> lst = [1, 2, 3]
>>> lst
[1, 2, 3]
>>>type(lst)
list

>>>type(range(10))
range
>>>list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

使用del命令可以删除列表或者删除列表中的元素

>>> l = list(range(5))
>>> del l[0]
>>> l
[1, 2, 3, 4]

>>> del l
>>> l
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-47-05a1d84e2e00> in <module>
      1 del l
----> 2 l

NameError: name 'l' is not defined

使用del命令不一定是删除数据，本质上，del是删除变量对数据的引用，基于Python的垃圾自动回收机制，如果一个值没有任何变量的引用，那么这个值就会在内存空间中删除。
如果有两个变量同时引用一个值，那么删除一种一个变量不会影响另外一个

>>> l = ['string', 123]
>>> k = l
>>> del l
>>> k
['string', 123]

2. 列表元素访问与切片

（1）元素下标访问

创建一个列表lst后，直接使用整数作为下标来访问指定索引处的元素即可。
Python列表支持双向索引，也就是：

1. 正向索引，起始序号为0，末尾序号为length - 1，即表长-1；
2. 反向索引，最后一个元素的索引为-1， 依次往前。

>>>lst = ['P', 'H', 'K', 'N']
>>>lst[0]
'P'
>>>lst[-1]
'N'

（2）列表切片

形式上，在方括号定界符内采用这样的表达式：[start:end:step]就可以实现切片操作。参数：

1. start：起始索引，默认为0；
2. end：截止索引，默认为列表长度（左闭右开区间[start, end))，当使用-1作为end索引时，依然是截至到倒数第二个元素
3. step：步长，默认为1，当步长为负数时，比如-1，需要使用[end:start:step=-1] 来正确切片。

列表切片不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表
之前的所有赋值、更换，增加元素，删除元素都可以采用切片的形式。

1. 获取整个列表的切片操作为lst[:]

>>> l = [1, 2, 3, 4]
>>> l[:]
[1, 2, 3, 4]

2. 获取列表的一部分操作为lst[s:e:step]

>>> l[1:3]
[2, 3]
>>> l[1:]
[2, 3, 4]

3. 赋值lst[s:e:step] = new_lst,这里要求新列表长度和切片列表长度一致

>>> l[1:3] = [9, 0]
>>> l
[1, 9, 0, 4]

4. 删除操作lst[s:e:step] = []

>>> l[:] = []
>>> l
[]

3. 列表常用方法

1. list.append(x)，将x追加至列表尾部；
2. list.extend(L: iterabl)，将可迭代对象L的元素追加至当前列表的尾部；
3. list.insert(index, x)，在指定索引index位置插入元素x，然后修改整个列表；
4. list.remove(x)，删除第一个值为x的元素，修改整个列表，如果x不存在则抛出异常；
5. list.pop([index])，默认删除并返回索引为index的值，index默认为-1也就是最后一个元素；如果列表为空或者索引不在区间内，则抛出异常；
6. list.clear()，清除整个列表的元素，保留列表对象；
7. list.index(x, start, end)，返回列表中第一个值为x的索引，或者在切片list[start:end]中的索引，如不在则返回异常；
8. list.count(x)，返回x在列表中出现的次数；
9. list.reverse()，反转列表；
10. list.sort(key=None, reverse=False)， 以key为关键进行排序，默认升序。

使用运算符对列表进行操作

1. +号连接两个列表并返回一个新列表

>>> x = [1,2,3]
>>> y = [4,5,6]
>>> z = x + y
>>> z
[1,2,3,4,5,6]

2. *号复制列表

>>> x = [0]*5
>>> x
[0,0,0,0,0]

4. 列表推导式

列表推到式又称列表内涵，可以使用非常简洁的方式对可迭代对象进行遍历、过滤和再次计算，可以快速生成满足需要的列表。

列表推导式的语法格式为:

[expression for exper1 in sequence1 if condition1
			for exper2 in sequence2 if condition2
			for exper3 in sequence3 if condition3
			...
			for experN in sequenceN if conditionN]

这相当于N层循环的操作，每个表达式的含义：

1. sequenceN：遍历的序列；
2. experN：对于需要遍历的序列的中间变量；
3. expression：对于中间变量的表达式；
4. conditionN：判断表达式

比如，实现列表复制操作

>>> lst1 = [1, 2, 3, 4, 5]
>>> new_lst = [item for item in lst1]
>>>> new_lst
[1, 2, 3, 4, 5]

筛选元素（筛选偶数）

>>> lst = list(range(10))
>>> new_lst = [item for item in lst if not item%2]
>>> new_lst
[0, 2, 4, 6, 8]

双层循环

>>> vec = [[1,2,3], [4,5], [6,7,8,9]]
>>> new = [x for y in vec for x in y]
>>> new
[1, 2, 3, 4, 5, 6, 7, 8, 9]

元组

1. 创建元组

和创建列表不同，元组的定界符是采用圆括号()，但是，当创建只有一个元素的元组时，必须要在元素后面加入,，也就是new_tuple = (elem,)
使用函数tuple()也可以把迭代对象变成元组

2. 元组的性质

1. 元组是不可变类型，一旦创建就不可以更改了，所以没有加入，删除等方法；
2. 元组支持双向索引；
3. 元组支持运算符，会返回一个新的元组

#变量可变
>>> x = (1, 2, 3)
>>> x += (5, 6)
>>> x
(1, 2, 3, 5, 6)

>>> (0,)*10
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

#元组不可变
>>> (1, 2) += (4, 5)
File "", line 1
    (1,2) += (3,4)
                  ^
SyntaxError: can't assign to literal