要点概括：
1.列表
列表可以修改，而字符串和元组不能。在 Python 中，列表的方法如下所示：
列表的部分用法如下所示：
1
2
3
4
5
6
7
8
9
10
11
|
a = [66.25, 333, 333, 1, 1234.5]
print(a.count(333), a.count(66.25), a.count('x'))
a.insert(2, -1)
print(a)
print(a.index(333))
a.remove(333)
print(a)
a.reverse()
print(a)
a.sort()
print(a)
|
输出结果如下：
1
2
3
4
5
6
|
2 1 0
[66.25, 333, -1, 333, 1, 1234.5]
1
[66.25, -1, 333, 1, 1234.5]
[1234.5, 1, 333, -1, 66.25]
[-1, 1, 66.25, 333, 1234.5]
|
2.将列表用作堆栈
列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用append()方法可以把一个元素添加到堆栈顶。用不指定索引的pop()方法可以把一个元素从堆栈顶释放出来。如下所示：
1
2
3
4
5
6
7
8
9
10
|
stack = [3, 4, 5]
stack.append(6)
print(stack)
stack.append(7)
print(stack)
print('===============')
stack.pop()
print(stack)
stack.pop()
print(stack)
|
输出结果如下：
1
2
3
4
5
|
[3, 4, 5, 6]
[3, 4, 5, 6, 7]
===============
[3, 4, 5, 6]
[3, 4, 5]
|
3.将列表用作队列
队列，第一个先被加入列表中的的元素在取出的时候会第一个出来，即先进先出。如下所示：
1
2
3
4
5
6
7
8
9
10
|
from collections import deque
queue = deque(['Carol', 'Jack', 'Tom'])
queue.append('Terry')
queue.append('Michael')
print(queue)
queue.popleft() # 出队
print(queue)
queue.popleft() # 出队
print(queue)
|
输出结果如下：
1
2
3
|
deque(['Carol', 'Jack', 'Tom', 'Terry', 'Michael'])
deque(['Jack', 'Tom', 'Terry', 'Michael'])
deque(['Tom', 'Terry', 'Michael'])
|
4.列表推导式
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。另外，如果希望表达式推导出一个元组，就必须使用括号。下面的程序会生成1到10之内所有数的平方，如下所示：
1
2
|
a = [x * x for x in range(1, 11)]
print(a)
|
输出结果如下：
1
|
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
|
也可以在 for 后面加上 if 语句，下面程序可以筛选出仅由偶数组成的平方，如下所示：
1
2
|
a = [x * x for x in range(1, 11) if x % 2 == 0]
print(a)
|
输出结果如下：
也可以用两层循环生成全排列，如下所示：
1
2
|
a = [m + n for m in 'ABC' for n in 'abc']
print(a)
|
输出结果如下：
1
|
['Aa', 'Ab', 'Ac', 'Ba', 'Bb', 'Bc', 'Ca', 'Cb', 'Cc']
|
另外，对于列表推导式的执行顺序为：各语句之间是嵌套关系，左边第二个语句是最外层，依次往右进一层，最左边的第一条语句是最后一层，如下所示：
1
|
[x * y for x in range(1, 5) if x > 2 for y in range(1, 4) if x < 3]
|
上面的式子等同于：
1
2
3
4
5
|
for x in range(1, 5):
if x > 2:
for y in range(1, 4):
if x < 3:
x * y
|
当然，这里仅仅只是解释列表推导式的执行顺序，程序本身需要修改后才能运行。
再看一个例子，如下所示：
1
2
|
a = [1, 2, 3]
z = [x + 1 for x in [x ** 2 for x in a]]
|
可以将上式改写成下面的式子，如下所示：
1
2
3
4
5
6
7
8
|
a = [1, 2, 3]
b = []
c = []
for x in a:
b.append(x ** 2)
for x in b:
c.append(x + 1)
print(c)
|
输出结果如下：
5.嵌套列表
下面演示的是将3x4的矩阵列表转换成4x3的矩阵列表，如下所示：
1
2
3
4
5
6
7
|
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]
]
a = [[row[i] for row in matrix] for i in range(4)]
print(a)
|
输出结果如下：
1
|
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
|
6.集合推导式
如下所示：
1
2
|
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)
|
输出结果如下：
7.字典推导式
如下所示：
1
2
|
a = {x: x * 2 for x in range(5)}
print(a)
|
输出结果如下：
1
|
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8}
|
8.遍历技巧
在字典中遍历时，关键字和对应的值可以使用items()方法同时解读出来，如下所示：
1
2
3
|
person = {'name': 'Carol', 'age': 20, 'gender': 'male'}
for k, v in person.items():
print(k, v)
|
输出结果如下：
1
2
3
|
name Carol
age 20
gender male
|
在序列中遍历时，索引位置和对应值可以使用enumerate()函数同时得到，如下所示：
1
2
|
for i, v in enumerate(['Carol', 'Jack', 'Mike']):
print(i, v)
|
输出结果如下：
1
2
3
|
0 Carol
1 Jack
2 Mike
|
同时遍历两个或更多的序列，可以使用zip()组合，如下所示：
1
2
3
4
5
6
|
questions = ['name', 'quest', 'favorite color']
answers = ['Carol', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
print('What is your {0}? It is {1}.'.format(q, a))
# 也可以使用%s方法输出，结果是一样的
# print('What is your %s? It is %s.' % (q, a))
|
输出结果如下：
1
2
3
|
What is your name? It is Carol.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
|
要反向遍历一个序列，首先指定这个序列，然后调用reversed()函数，如下所示：
1
2
|
for i in reversed(range(1, 10, 2)):
print(i)
|
输出结果如下：
要按顺序遍历一个序列，使用sorted()函数返回一个已排序的序列，并不修改原值，如下所示：
1
2
3
|
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for i in sorted(set(basket)): # set()可以去重
print(i)
|
输出结果如下：
1
2
3
4
|
apple
banana
orange
pear
|