序列的操作--cookbook读书笔记

1. 删除序列相同元素并保持顺序

如果序列上的值都是hashable 类型，那么可以很简单的利用集合或者生成器来解决这个问题。如果你想消除元素不可哈希(比如dict 类型) 的序列中重复元素的话，将序列元素转换成hashable 类型进行比较即可。

def dedupe(items, key=None):
    seen = set()
    for item in items:
        val = item if key is None else key(item)
        if val not in seen:
            yield item
            seen.add(val)

>>> a = [ {'x':1, 'y':2}, {'x':1, 'y':3}, {'x':1, 'y':2}, {'x':2, 'y':4}]
>>> list(dedupe(a, key=lambda d: (d['x'],d['y'])))
[{'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 2, 'y': 4}]
>>> list(dedupe(a, key=lambda d: d['x']))
[{'x': 1, 'y': 2}, {'x': 2, 'y': 4}]

2. 命名切片

你避免了大量无法理解的硬编码下标，使得你的代码更加清晰可读。内置的slice() 函数创建了一个切片对象，可以被用在任何切片允许使用的地方。

>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]

3. 排序不支持原生比较的对象（包括通过关键字排列字典）

使用operator 模块的itemgetter 函数，可以非常容易的排序字典。使用operator.attrgetter()函数，可以排序类（通过其属性）。除了排序，该技术也同样适用于min() 和max() 等函数。

rows = [
{'fname': 'Brian', 'lname': 'Jones', 'uid': 1003},
{'fname': 'David', 'lname': 'Beazley', 'uid': 1002},
{'fname': 'John', 'lname': 'Cleese', 'uid': 1001},
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}
]
rows_by_lfname = sorted(rows, key=itemgetter('lname','fname'))
print(rows_by_lfname)

>>> from operator import attrgetter
>>> sorted(users, key=attrgetter('user_id'))
[User(3), User(23), User(99)]

其实key=lambda也可以实现以上功能，选择使用lambda 函数或者是attrgetter() 、itemgetter()可能取决于个人喜好。但是，attrgetter() 、itemgetter()函数通常会运行的快点，并且还能同时允许多个字段进行比较。

4. 通过某个字段将记录分组，itertools.groupby() 函数对于这样的数据分组操作非常实用。

from operator import itemgetter
from itertools import groupby
# Sort by the desired field first
rows.sort(key=itemgetter('date'))
# Iterate in groups
for date, items in groupby(rows, key=itemgetter('date')):
    print(date)
    for i in items:
        print(' ', i)

5. 过滤序列元素

最简单的过滤序列元素的方法就是使用列表推导（[n for n in mylist if n > 0]）。使用列表推导的一个潜在缺陷就是如果输入非常大的时候会产生一个非常大的结果集，占用大量内存。如果你对内存比较敏感，那么你可以使用生成器表达式迭代产生过滤的元素。有时候，过滤规则比较复杂，不能简单的在列表推导或者生成器表达式中表达出来。比如，假设过滤的时候需要处理一些异常或者其他复杂情况。这时候你可以将过滤代码放到一个函数中，然后使用内建的filter() 函数。

values = ['1', '2', '-3', '-', '4', 'N/A', '5']
def is_int(val):
    try:
        x = int(val)
        return True
    except ValueError:
        return False
ivals = list(filter(is_int, values))
print(ivals)
# Outputs ['1', '2', '-3', '4', '5']

6. 映射名称到序列元素，collections.namedtuple() 函数通过使用一个普通的元组对象来实现。

>>> from collections import namedtuple
>>> Subscriber = namedtuple('Subscriber', ['addr', 'joined'])
>>> sub = Subscriber('jonesy@example.com', '2012-10-19')
>>> sub
Subscriber(addr='jonesy@example.com', joined='2012-10-19')
>>> sub.addr
'jonesy@example.com'
>>> sub.joined
'2012-10-19'

7. 在数据序列上执行聚集函数(比如sum() , min() , max() )

首先你需要先转换或者过滤数据，一个非常优雅的方式去结合数据计算与转换就是使用一个生成器表达式参数。

portfolio = [
{'name':'GOOG', 'shares': 50},
{'name':'YHOO', 'shares': 75},
{'name':'AOL', 'shares': 20},
{'name':'SCOX', 'shares': 65}
]
min_shares = min(s['shares'] for s in portfolio)