Python列表（list）

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

　　此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

• 创建列表
  　　创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可

list = [1, 2, 3, 4, 5 ]

• 访问列表中的值

　　使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符。这个与字符串的截取字符串类似在此就不赘述了。

list = [1, 2, 3, 4, 5,6,7]
print("list[1:5]: ", list[1:5])
＃　list[1:5]:  [2, 3, 4, 5]

列表的常见操作

添加元素

• list.insert(i, x)
  在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个链表之前，而 a.insert(len(a), x) 相当于 a.append(x)。

• list.append(obj)
  在列表末尾添加新的对象，相当于 list[len(list):] = [obj]。

• list.extend(seq)
  在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
  相当于 list[len(list):] = seq。

list = [1, 2, 3, 4, 5]
list.append(7)
print(list)
# [1, 2, 3, 4, 5, 7]
list.extend([6, 7, 8, 9])
print(list)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

删除元素

• del(list[0:n]) 移除列表中0到n+1值。

• list.pop(obj=list[-1])
  移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

• list.remove(obj)
  移除列表中某个值的第一个匹配项

例一

list1 = ['physics', 'chemistry', 1997, 2000]
print(list1)
del (list1[2])
print("del后 : ")
print(list1)

# del后 : 
# ['physics', 'chemistry', 2000]

例二

list1 = ['physics', 'chemistry', 1997, 2000]
print(list1)
list1.remove(2000)
print("remove后 : ")
print(list1)
# remove后 : 
# ['physics', 'chemistry', 1997]

例三

list1 = ['physics', 'chemistry', 1997, 2000]
print(list1)
list1.pop()
print("pop后 : ")
print(list1)
# pop后 : 
# ['physics', 'chemistry', 1997]

修改元素

list[n]=x 把第n+1个值修改为x

list1 = ['physics', 'chemistry', 1997, 2000]
list1[1] = 1995
print(list1)
# ['physics', 1995, 1997, 2000]

其他常用方法

方法	描述
cmp(list1, list2)	比较两个列表的元素
len(list)	列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表
list.count(obj)	统计某个元素在列表中出现的次数
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.reverse()	反向列表中元素
list.sort([func])	对原列表进行排序
list.clear()	从列表中删除所有元素。相当于 del a[:]。

将列表当做堆栈使用

　　列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如：

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

将列表当做队列使用

　　你也可以把链表当做队列使用，队列作为特定的数据结构，最先进入的元素最先释放（先进先出）。不过，列表这样用效率不高。相对来说从列表末尾添加和弹出很快；在头部插入和弹出很慢（因为，为了一个元素，要移动整个列表中的所有元素）。

要实现队列，使用 collections.deque，它为在首尾两端快速插入和删除而设计。例如:

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

列表推导式

　　列表推导能非常简洁的构造一个新列表:只用一条简洁的表达式即可对得到的元素进行转换变形其基本格式如下:

[expr for value in collection ifcondition]

　　过滤条件可有可无，取决于实际应用，只留下表达式；相当于下面这段for循环:

result = []  
 for value in collection:  
     if condition:  
         result.append(expression)  

　　每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

　　这里我们将列表中每个数值乘三，获得一个新的列表：

>>> vec = [2, 4, 6] 
>>> [3*x for x in vec]
 [6, 12, 18]

　　这里我们对序列里每一个元素逐个调用某方法：

>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

以下是一些关于循环和其它技巧的演示：

>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]

矩阵的转换

Python的列表还可以嵌套。（看的官方文档和别人翻译后参考的写的）

以下实例展示了3X4的矩阵列表

>>> matrix = [[1, 2, 3, 4],[5, 6, 7, 8], [9, 10, 11, 12]]
>>> matrix
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

以下实例将3X4的矩阵列表转换为4X3列表

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

以下实例也可以使用以下方法来实现：

>>> matrix = [[1, 2, 3, 4],[5, 6, 7, 8], [9, 10, 11, 12]]
>>> transposed = [] 
>>> for i in range(4):transposed.append([row[i] for row in matrix]) 
... 
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

另外一种实现方法：

>>> matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
>>> transposed = []
>>> for i in range(4):
...		# 下面的3行实现了列表的嵌套
... 	transposed_row = []
... 	for row in matrix:
... 		transposed_row.append(row[i])
... 	transposed.append(transposed_row)
... 
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

等价于下面的代码

matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
transposed = []
for i in range(4):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
        transposed.append(transposed_row)
print(transposed)