4月19日读书笔记——第二章序列构成的数组(1)

流畅的python

第二章序列构成的数组

在这之前，我想要先知道什么是序列。维基百科的答案是

数学上，序列是被排成一列的对象（或事件）；这样，每个元素不是在其他元素之前，就是在其他元素之后。

例如：(C,Y,R)是一个字母的序列：顺序是C第一，Y第二，R第三。序列可以是有限的（就像前面这个例子），也可以是无限的，就像所有正偶数的序列（2,4,6,…）。有限序列包含空序列（），它没有元素。序列中的元素也称为项，项的个数（可能是无限的）称为序列的长度。

python采用了统一的风格对这些序列数据进行处理。所以不管是字符串，列表，数组或是xml元素等等，都可以公用一套操作：迭代，切片，排序或是拼接。

2.12.12.1 内置序列类型概览
序列类型可以通过几个方面来划分：

容器序列（能存放不同的数据类型）
list, tuple, collection.deque…

collection.deque是类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)

扁平序列（只能容纳一种数据类型）
str, bytes, bytearray，memoryview…

memoryview() 函数返回给定参数的内存查看对象(Momory view)
bytearray() 方法返回一个新字节数组bytearray

或者按照能否被修改来分类：

可变序列
list, bytearray, memoryview, collection.deque…
不可变序列
tuple, str, bytes…

2.22.22.2 列表推导和可读性
推导式是Python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列的结构体
例子：

test_list = [1, 2, 3, 4, 5]
new_list = [10 + i for i in test_list]

test_list = [1, 2, 3, 4, 5]
new_list = []
for i in test_list:new_list.append(i+10)

上面的两份代码相比，明显上面的列表推导式更简洁。

Python在执行列表推导式时，会对可迭代的对象test_list进行迭代，将每一次迭代的值赋给循环变量i，然后收集变量表达式(i+10)的计算结果，最终由这些结果构成了新的列表，也就是列表推导式所返回的值。

只要支持 for 循环进行迭代的对象，都可以对它使用列表推导式。

原先python2.x版本的时候，会存在变量泄漏的问题（对象间的循环引用是导致内存泄漏的主要原因），实例如下：

>>> x = 'hello world'
>>> test = [x for x in 'nihao']
>>> x
'o'

换到python3.x的版本时，如下所示：

>>> x = 'hello world'
>>> test = [x for x in 'nihao']
>>> x
'hello world'

这是因为在python3中，它们像函数一样有了自己的局部作用域。表达式内部的变量和赋值只在局部起作用，而表达式的上下文里的同名变量还可以被正常引用，局部变量并不影响它们。

列表推导可以帮我们把一个序列或是其他可以迭代类型中的元素过滤或者加工，然后再新建一个列表。

但事实上，python内置的filter与map函数也可以做这件事。

>>> new_test = list(filter(lambda i: i >60, map(ord, x)))
>>> new_test
[104, 101, 108, 108, 111, 119, 111, 114, 108, 100]

但是在可读性上，我更愿意选择列表推导的方式。

列表推导还可以生成多个可迭代类型的笛卡尔积。假设有3个小朋友，每个小朋友的爸爸妈妈，可以通过这样的方式生成：

>>> kids = ['lily', 'andy', 'joe']
>>> parents = ['dad', 'mom']
>>> people = [k + "'s " + p for k in kids for p in parents]
>>> people
["lily's dad", "lily's mom", "andy's dad", "andy's mom", "joe's dad", "joe's mom"]

其中需要注意的是，两个循环的嵌套关系和上面列表推导中的for从句的先后循序应该是一致的。
但是目前，我们使用列表推导只能生成列表这一种数据类型。如果我们想生成别的数据类型，需要用到生成器表达式。

刚才列表生成要用到[ ],生成器生成则需要用到( )。

kids = ['lily', 'andy', 'joe']
parents = ['dad', 'mom']
people = (k + "'s" + p for k in kids for p in parents)
print(people)
# <generator object <genexpr> at 0x10785a0f8>
for p in people:print(p)
# lily'sdad
# lily'smom
# andy'sdad
# andy'smom
# joe'sdad
# joe'smom

使用生成器表达式的好处就是它是逐个地产出元素，而不是先建立一个完整的列表，再把这个列表传递到某个构造函数里。显然这样更节省内存。

2.32.32.3 元组不仅仅是不可变的列表
先来了解，什么叫不可变？
简单来讲，就是一旦一个对象被定义了，它的值就不能再被更新，除非重新创建一个新的对象。
诸如列表的插入元素、删除元素、添加元素、清空元素、修改元素等功能，在元组中通通没有，你是无法对其进行修改的。
所以元组很适合来存储一些不变的记录。

拆包可以让元组更完美得用作记录使用。

简单来说，元组拆包就是将元组中的元素分别赋给变量。
最好辨认的拆包形式就是平行赋值。
如下所示：

>>> provice, city, area = ('浙江', '杭州', '西湖')
>>> provice
'浙江'
>>> city
'杭州'
>>> area
'西湖'

还可以用 * 运算符把一个可迭代的对象拆开作为函数的参数,在python中，函数通常用 *args 来获取不确定数量的参数。

>>> number = (7, 3)
>>> num = divmod(*number)
>>> num
(2, 1)

>>> s1, s2, *student = ('小明', '小红', '小华', '小美')
>>> student
['小华', '小美']

用*来处理剩下的元素，要注意只能用在一个变量名前面，但是它可以在表达式的任意位置。

>>> s1, *student, s2 = ('小明', '小红', '小华', '小美')
>>> student
['小红', '小华']

元组设计已经很好用了，但是我们可能会想要给其中记录中的字段命个名。那么就需要第一章用过collection.namedtuple。
它可以构建一个带字段名的元组和一个有名字的类。
创建一个具名元组需要两个参数：类名，类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串。
它有一些专有的属性(还用第一章扑克牌的例子)：

>>> import collections
>>> Card = collections.namedtuple('Card', ['rank', 'suit'])
>>> Card._fields
('rank', 'suit')>>> new_card = ('红桃', '5')
>>> n = Card._make(new_card)
>>> n._asdict()
OrderedDict([('rank', '红桃'), ('suit', '5')])

_fields属性为一个包含这个类所有字段名称的元组。
_make()方法通过接受一个可迭代对象来生成这个类的实例。
_asdict()方法把具名元组以collections.OrderedDict(字典的子类，保存了元素被添加的顺序)的形式返回，我们可以利用它来把元组里的信息更具可读性的呈现出来。