Python学习笔记2：构造序列：列表推导和生成器表达式

欢迎访问个人网站：www.comingnext.cn

1. 关于Python内置序列类型

a. 按能否存放不同类型的数据区分

容器序列：

list、tuple 和collections.deque这些序列能存放不同类型的数据

扁平序列：

str、bytes、bytearray、memoryview和array.array，这类序列只能容纳一种类型。

b. 按能否被修改来分类

可变序列：

list、bytearray、array.array、collections.deque 和 memoryview。

不可变序列：

tuple、str 和 bytes。

最重要也是最基础的Python内置序列就是列表(list)，list既是一个容器序列，也是一个可变序列。

2. Python的列表

a. 列表的方法

列表有很多的方法，以下取自官方文档：

list.append(x) 
将项目添加到列表的末尾。相当于 a[len(a):] = [x].

list.extend(L) 
通过附加给定列表中的所有项目来扩展列表。相当于 a[len(a):] = L.

list.insert(i, x) 在给定位置插入项目。第一个参数为被插入元素的位置索引，因此 a.insert(0, x) 在列表头插入值， a.insert(len(a), x)相当于 a.append(x).

list.remove(x) 从列表中删除值为x的第一个项目。如果没有这样的项目是一个错误。

list.pop([i]) 删除列表中给定位置的项目，并返回。如果没有给定位置，a.pop()将会删除并返回列表中的最后一个元素。（方法声明中i周围的方括号表示参数是可选的，而不是您应在该位置键入方括号。您将在Python库参考中频繁地看到此符号。）

list.clear()
从列表中删除所有项目。相当于 del a[:].

list.index(x)
返回值为x的第一个项目的列表中的索引。如果没有这样的项目是一个错误。

list.count(x)
返回x出现在列表中的次数。

list.sort(key=None, reverse=False) 排序列表中的项 (参数可被自定义, 参看 sorted() ).

list.reverse()
列表中的元素按位置反转。

list.copy()
返回列表的浅副本。相当于 a[:].

b. 用法示例

列表作为栈使用：

>>> x = [1,2,3,4,5]
>>> x.append(6)
>>> x
[1, 2, 3, 4, 5, 6]
>>> x.pop()
6
>>> x
[1, 2, 3, 4, 5]

列表作为队列使用：

>>> from collections import deque # 若要实现一个队列， collections.deque 被设计用于快速地从两端操作。
>>> queue = deque(x)
>>> queue
deque([1, 2, 3, 4, 5])
>>> queue.append(6)
>>> queue
deque([1, 2, 3, 4, 5, 6])
>>> queue.popleft()
1
>>> queue.pop()
6
>>> queue
deque([2, 3, 4, 5])

3.列表推导式

a.普通列表

列表推导式是Python构建新列表的一个快捷方式。
最简单的一个用法：

>>> chars = ‘ABCD‘
>>> list = []
>>> for char in chars:
...     list.append(char)
...
>>> list
[‘A‘, ‘B‘, ‘C‘, ‘D‘]

或者是这种方法：

>>> chars = ‘ABCD‘
>>> list = [char for char in chars]
>>> list
[‘A‘, ‘B‘, ‘C‘, ‘D‘]

对于学过Python的人来说，第二种更具有可读性，而且代码比较简洁，同时第二种也更具Python风格。因此更加推荐第二种写法

b.笛卡儿积

笛卡儿积是一个列表，列表里的元素是由输入的可迭代类型的元素对构成的元组，因此笛卡儿积列表的长度等于输入变量的长度的乘积。 用列表推导可以生成两个或以上的可迭代类型的笛卡儿积：

>>> cross = [(x,y) for x in range(4) for y in range(4)]
>>> cross
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), 
(2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3)]
>>> colors = [‘black‘, ‘white‘]
>>> sizes = [‘S‘, ‘M‘, ‘L‘]
>>> tshirts = [(color, size) for color in colors for size in sizes]
>>> tshirts
[(‘black‘, ‘S‘), (‘black‘, ‘M‘), (‘black‘, ‘L‘), (‘white‘, ‘S‘), (‘white‘, ‘M‘), (‘white‘, ‘L‘)]
>>> tshirts = [(color,size) for size in sizes
...                         for color in colors]
>>> tshirts
[(‘black‘, ‘S‘), (‘white‘, ‘S‘), (‘black‘, ‘M‘), (‘white‘, ‘M‘), (‘black‘, ‘L‘), (‘white‘, ‘L‘)]
>>>

4.生成器表达式

如果想生成其他类型的序列，生成器表达式就派上了用场。

虽然也可以用列表推导来初始化元组、数组或其他序列类型，但是生成器表达式是更好的选择。这两者最大的不同就是生成器表达式背后遵守了迭代器协议，可以逐个地产出元素，而不是先建立一个完整的列表，然后再把这个列表传递到某个构造函数里。这种方式显然能够节省内存。

生成器表达式的语法跟列表推导差不多，只不过把方括号换成圆括号而已（接上面）:

>>> tshirts = ((color, size) for color in colors for size in sizes)
>>> tshirts
<generator object <genexpr> at 0x00000245FC9D40A0>
>>> print(tshirts)
>>> for tshirt in tshirts:
...     print(tshirt)
...
(‘black‘, ‘S‘)
(‘black‘, ‘M‘)
(‘black‘, ‘L‘)
(‘white‘, ‘S‘)
(‘white‘, ‘M‘)
(‘white‘, ‘L‘)

通过这个例子可以看出，生成器表达式得到的tshirts是一个generator，而上一个例子中，列表推导式生成的是一个list，差别仅在于此处是()，而上一处是[]。
在本例中，tshirts是一个生成器对象，可迭代。生成tshirts的时候，不会在内存中留下一个列表，因此打印出来是 at 0x00000245FC9D40A0>，而在每次for循环运行时才生成一个组合，这样才能打印出它的内容，因此你也可以选择只打印出其中的某些数据而不必全部打出。换句话说，它是用到的时候才生成内容的，当数据比较大的时候，生成器表达式能明显的节约内存。

原文：http://www.cnblogs.com/zivwong/p/7401200.html