python cook book第三版 读书笔记1（第一章）

因本人看的英文版，为自己翻译，不准确处见谅。

1.1把序列拆开赋值到变量里，可能本人翻译比较别嘴，但意思就是下面这样

>>> p=(4,5)
>>> x,y=p
>>> x
4
>>> y
5

>>> data=['alice',50,91.1,(2012,12,21)]
>>> name,shares,price,data=data
>>> name
'alice'
>>> shares
50
>>> price
91.099999999999994
>>> data
(2012, 12, 21)

这里列举了元组和列表，但对字符串等序列依然有用，对此处变量与元素必须是一一对应的，有几个变量就有多少元素，否则会报错。

1.2从任意长度的迭代器里拆分元素，大概意思就是说用*参数可以代替多个变量，之后可以给这个形参使用迭代器，可能由于本人的python为2.6，没有此功能

>>> data=[1,2,3,4,5,6,7]
>>> *trailing,current=data

之后打出trailing是[1,2,3,4,5,6]这样一个列表，current是7。

1.3保持最后n个元素，这里使用了deque这样一个概念，就是双端队列，有队列和栈的特性，只限在两端进行操作，下面这个例子是找到匹配的项，之后存到队列里。本章告诉我们使用deque来保存后面几个元素

>>> from collections import deque
>>> def search(lines,pattern,history=5):
...     previous_line=deque(maxlen=history)
...     for line in lines:
...             if pattern in line:
...                     yield line,previous_lines
...             previous_lines.append(line)
...

1.4找到最大或者最小的n个元素，这里使用堆排序heapq，里面的nlargest，nsmallest来找出最大或者最小n个元素。

>>> import heapq
>>> nums=[1,2,3,23,7,-4,18,23,42,37,2]
>>> print heapq.nlargest(3,nums)
[42, 37, 23]
>>> print heapq.nsmallest(3,nums)
[-4, 1, 2]

这里使用heapify可以把列表元素进行堆排序，个人觉得默认是小根堆（也可以选择大根堆吧），之后使用heappop可以返回堆顶函数。

>>> heap=nums
>>> heapq.heapify(heap)
>>> heap
[-4, 2, 1, 23, 2, 3, 18, 23, 42, 37, 7]

>>> heapq.heappop(heap)
-4
>>> heapq.heappop(heap)
1.5实现一个优先队列，本章作者使用堆实现了一个优先队列，优先级由使用者自己定义，之后可以使用q.pop()函数依次弹出。

import heapq
class PriorityQueue:
     def __init__(self):
             self._queue=[]
             self._index=0
     def push(self,item,priority):
             heapq.heappush(self._queue,(-priority,self._index,item))
             self._index+=1
     def pop(self):
             return heapq.heappop(self._queue)[-1]
class Item:
     def __init__(self,name):
             self.name=name
     def __repr__(self):
             return 'Item({!r})'.format(self.name)
q=PriorityQueue()
q.push(Item('foo'),1)
q.push(Item('bar'),5)
q.push(Item('pam'),4)
q.push(Item('grok'),1)

1.6给一个字典每个key匹配多个值，作者在此处说，一个key只能匹配一个值，要想匹配多个值，就要把值放进一个集合里面。
>>> d={'a':[1,2,3],'b':[4,5]}
>>> d['a']
[1, 2, 3]
>>> d['b']
[4, 5]
>>> d['a'].append(1)
>>> d['a']
[1, 2, 3, 1]

1.7保持字典排序，本章主要引入了一个能够保持顺序的字典，顺序为你插入的顺序。（普通字典是默认排序的）

>>> from collections import OrderedDict
>>> d=OrderedDict()
>>> d['foo']=1
>>> d['abc']=2
>>> d['spm']=3
>>> d['grk']=4
>>> d['kvm']=0
>>> for key in d:
...     print key,d[key]
...
foo 1
abc 2
spm 3
grk 4
kvm 0

1.8字典进行计算，本章主要介绍了字典如何排序，找出大小值等，主要使用zip()函数处理。

>>> f
{'ac': 4, 'foo': 5, 'fwf': 6}
>>> min(zip(f.values(),f.keys()))
(4, 'ac')
>>> max(zip(f.values(),f.keys()))
(6, 'fwf')

1.9找到两个字典共有的值，使用集合的运算，但是2.6.6不支持字典这种功能，列表可以。

>>> a={'x':1,'y':2,'z':3}
>>> b={'w':10,'x':11,'y':2}

>>> a.keys()&b.keys()

>>> a.keys()-b.keys()

>>> a.items()-b.items()

1.10在排过序的序列里去掉重复的值

>>> 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=[1,2,3,1,2]

>>> list(dedupe(a))
[1, 2, 3]

对于序列的表完全可以使用集合，因为集合里面没有重复的值

>>> set(a)
set([1, 2, 3])

1.13给字典带有通用key的元素排序，其实就是使用sorted（tmp1，tmp2）函数，第一个参数是字典名，第二个参数可以用itemgetter（）来制定key值。这个方法和下面的方法都要通过from opearator import XXX引进来。

1.14给对象排序，还是使用sorted（tmp1，tmp2）函数，第一个参数是类名，第二个参数用attrgetter（）或者属性，按照属性值排序。

1.15字典分组，可以考虑使用groupby（tmp1，tmp2）函数，第一个参数字典名，第二个参数是按什么分组，用itemgetter（）获取key值。

1.20合并两个字典到一个里，使用了ChainMap，需要从from collections import进来，但是python2.6.6不能使用。