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不能使用。