Python cookbook container first

1解压:

数目一致x,y=(x,y) 也可以用特殊符号_这种占位,只表示以后需要的,但是_这种要确保之后肯定用不到

数目不一致 x,*y,z=比较长的list dict ,*y可以用在顺序上的第一个.这种很有用尤其是在做字符串分割的时候 split(':')

def sum(items):
    head,*tail=items
    return head+sum(tail) if tail else head
sum(items) 

递归并不是Python擅长的,所以说什么是Python擅长的呢?估计得接着看,在书上找不到估计得百度了??(1)

3保留最后N个元素:

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

可以将搜索过程代码和使用搜索结果代码解耦

使用deque(maxlen=N)构造函数会新建一个固定大小的队列,当最新的元素加入并且这个队列已满的时候,最老的元素会自动被除

如果你不设置最大队列的大小,就会得到一个无限大小队列,你可以在队列的两端执行添加代码和弹出元素的操作

q=deque()
q.append(1)
q.appendleft()
q.pop()
q.popleft()

在队列两端插入或者删除元素的时间复杂度都是O(1),而在列表的开头插入或者删除元素的时间复杂度为O(N)

4怎么样从一个集合中获得最大或者最小的N个元素的列表:

heapp模块有两个函数:nlargest() nsmallest() 

import heapq
nums=[1,2,3,24,45,444,33,333,55,22,2,1]
print(heapq.nlargest(3,nums))
print(heapq.nsmallest(3,nums))
head.heapify(nums) #将整个排序

#使用
protfolio=[{'name':'IBM','shares':100.'price':91.1},                            
    {'name':'IBM','shares':50.'price':191.1},
    {'name':'IBM','shares':100.'price':91.1},
    {'name':'IBM','shares':100.'price':491.1},
    {'name':'IBM','shares':100.'price':391.1},
    {'name':'IBM','shares':100.'price':291.1},]

cheap=heapq.nsmallest(3,portfolio,key=lambda s:s['price'])

堆数据结构底层的实现细节....

堆数据结构最重要的细节就是heap[0]永远是最小的元素,heapq.heappop(nums)就可以得到最小的元素,时间复杂度是O(N),N是堆的大小

heap = []#建立一个常见的堆

heappush(heap,item)#往堆中插入一条新的值

item = heappop(heap)#弹出最小的值

item = heap[0]#查看堆中最小的值，不弹出

heapify(x)#以线性时间将一个列表转为堆

item = heapreplace(heap,item)#弹出一个最小的值，然后将item插入到堆当中。堆的整体的结构不会发生改变。
heappoppush()#弹出最小的值，并且将新的值插入其中

merge()#将多个堆进行合并

nlargest(n , iterbale, key=None)从堆中找出做大的N个数，key的
作用和sorted( )方法里面的key类似，用列表元素的某个属性和函数作为关键字

heap的逻辑结构是完全二叉树,并且二叉树的父节点的值小于该节点的所有子节点的值,这种实现可以使用heap[k]<=heap[2k+1]且heap[k]<=heap[2k+2],其中k为索引,从零开始技术的形式体现,对于堆来说,最小元素即为heap[0]

import heapq
def heapsort(iterable):
    h=[]
    for i in iterable:
        heapq.heappush(h,i) #放进去
    return [heapq.heappop(h) for i in range(len(h))]
#排序
s=[3,5,1,2,4,6,6,0,1]
print(heapsort(s))

#简单的优先级队列
import heapq
class heapQuery():
    def __init__(self):
        self._queue=[]
        self._index=0
    def push(self,priority,item):
        heapq.heappush(self._queue,(-priority,self._index,item))
        self._index+=1
    def pop(self):
        heapq.heappop(self._queue)[-1]
        
class item():
    def __init__(self,name):
        self.name=name
    def __repr__(self):
        return 'item({!r})'.format(self.name)
        
q=heapQuery()
q.push(1,item('foo'))
q.push(2,item('like'))
q.pop

6dict一个键对应多个值:

选择使用列表还是集合取决于你的实际需求,如果你想保持元素的插入顺序就应该使用列表,如果想去掉重复元素就使用集合(并且不关心元素的的书序问题)

collections 的defaultdict来构造这样的字典

from collections import defaultdict
d=defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(2)

from collections import defaultdict
d=defaultdict(set)
d['a'].add(1)
d['a'].add(1)
d['a'].add(2)
d['b'].add(3)

list的方法是append set的方法是add,乘机来总结下list tuple dict set的方法...

list append insert pop list[index]
tuple 不可变,里面的内容不可变,但是里面含有list的话,list是可变的,所以tuple是可变的也是不可变的
list tuple 用下标来访问内容,而dict用key来访问
dict key不可变,不可重复,value可变,将dict合并 dict(d.items()+d.items()) 或者dict(d,**d)
set 通过add remove来添加删除 
都可以通过len 和for来进行循环..

7想要构建一个将来需要序列化或者编码成其他格式的映射的时候,OrderedDict是非常有用的,想精确控制以JSON编码后字段的书序,可以先使用OrderedDict来构建这样的数据,OrderedDict内部维护着一个根据键的插入顺序排序的双向链表,每当一个新的元素插入进来的时候,它就会被放到链表的尾部,对于一个已经存在的键的重复赋值不会改变键的顺序

一个OrderedDict的大小是一个普通字典的两倍,因为它内部维护着另一个链表

from collections import OrderedDict
def order_dict():
    d=OrderedDict()
    d['foo']=1
    d['like']=2
    d['moo']=3
    d['zhizhang']=3
    for key in d:
        print(key,d[key])
        
order_dict

8字典的运算(比如求最大值,最小值,排序等等)?

prices={
    'ACME':45.23,
    'AAPL':612.78,
    'IBM':205.55,
    'HPQ':37.20,
    'FB':10.75,
}
min_price=min(zip(prices.values(),prices.keys()))
min_price
prices_sorted=sorted(zip(prices.values(),prices.keys()))
prices_sorted


日常总结,sorted的用法
sorted只要是可以迭代的就可以,reverse=True时候倒叙..
sorted(prices,key=lambda x:x[0])
list.sort() 

所谓的比较高级用法,就是使用lambda函数,配合使用fliter,map,reduce什么的.....
list(fliter(lambda x:x+1,list))

需要注意的是zip()函数创建的是一个只能访问一次的迭代器,要多次使用只能多次创键

9查找dict的相同点...

dict 的keys()或者items()方法返回结果

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()
尽管字典的values()方法也是类似的,但是它并不支持这里的集合操作,某种程度上,是因为值视图不能保证所有的值互不相同,折扣可能会导致某些集合操作出现问题,可以先将其转换成set,然后在执行(你非要用的时候)

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

解决方案:如果序列上的值都是hashtable类型,name可以就很简单的利用集合或者生成器来解决这个问题

def dudupe(items):
    seen=set()
    for item in items:
        if item not in seen:
            yield item
            seen.add(item)
a=[1,2,3,4,5,6,6,7]
p=list(dudupe(a))

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'])))

24页