python-cookbook学习

#分解值过多的情况

    record = ("Dave","lyfq2018@163.com","170895kk","135678432")
    
    name,email,*phone_number = record
    print(phone_number)
    
    list_a = [1,2,3,4,5,6,7,8]
    
    *a,b= list_a
    print(b)
    
    from collections import deque
    
    def search(lines,pattern,history=5):
        previous_lines = deque(maxlen=history)
        for line in lines:
            if pattern in line:
                yield line,previous_lines
            previous_lines.append(line)

#找到最大或者最小的N个元素

    import heapq
    
    nums = [1,8,2,23,7,-4,18,23,42,37,2]
    print(heapq.nlargest(3,nums))
    print(heapq.nsmallest(3,nums))
    
    portfolio = [{'name':'IBM','shares':100,'price':91.1},
                 {'name':'AAPL','shares':50,'price':543.32},
                 {'name':'FB','shares':200,'price':21.09},
                 {'name':'HFQ','shares':35,'price':31.75}]
    
    cheap = heapq.nsmallest(3,portfolio,key=lambda s:s['price'])
    print(cheap)

#最大或者最小的单个元素：min(),max(),N同n相差较大
#相差不大时，可以先对集合进行排序然后再做切片操作

    sort_nums = sorted(nums)[:3]
    print(sort_nums)

#实现优先级队列

    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('spam',),4)
    q.push(Item('grok'),1)

#heappop总是返回最小的那个值

#在字典中将键映射到多个值上
#列表保留了原有的顺序，而集合则删除了重复的元素且处于无序

    from collections import defaultdict
    
    d = defaultdict(list)
    d['a'].append(1)
    d['a'].append(2)
    d['b'].append(3)
    
    print(d)
    d = defaultdict(set)
    
    d['a'].add(1)
    d['b'].add(2)
    d['a'].add(3)
    print(d)
    
    d = {}
    
    d.setdefault('a',[]).append(1)
    d.setdefault('a',[]).append(2)
    d.setdefault('b',[]).append(3)

#setdefault都会创建一个新的初始值新实例。defaultdict会自己初始化第一个值

    # d = {}
    # for key, value in pairs:
    #     if key not in d:
    #         d[key] = []
    #     d[key].append(value)
    # d = defaultdict(list)
    # for key,value in pairs:
    #     d[key].append(value)

#让字典保持有序  构建映射结构以便稍后对其做序列化或编码成另外一种格式
from collections import OrderedDict
#OrderedDict内部维护了一个双相链表，其会根据元素加入的顺序来排列键的位置，其大小是普通字典的两倍多，因此要充分考虑其好处和内存开销之间的关系

    d = OrderedDict()
    d['foo']=1
    d['bar']=2
    d['spam']=3
    d['grok']=4
    
    for key in d:
        print(key,d[key])
    
    import json
    c = json.dumps(d)
    d = json.loads(c)
    print(d)

#与字典有关的计算问题
#zip函数可以将字典的key，value反过来,zip创建了一个迭代器，其内容只能被消费一次

    prices = {"a":2,'b':3,'f':7,'e':1}
    min_price = min(zip(prices.values(),prices.keys()))
    print(min_price)

#对数据进行排序
sorted_price = sorted(zip(prices.values(),prices.keys()))
print(sorted_price)

min_p = min(prices.values()) #不能显示出与键的关联信息
#如果相同最会返回key值较大或者较小的那个条目

#在两个字典中寻找相同点
a = {'x':1,'y':2,'z':3}
b = {'w':10,'x':1,'y':2}

c = a.keys() & b.keys()
print(c)

d = a.keys() - {'z'}
print(d)

e = a.items() & b.items()
print(e)

f = {key:a[key] for key in a.keys() - {'z','w'}}
print(f)

#从序列中移除重复项且保持元素间顺序不变
#可哈希

def dedupe(items):
    seen = set()
    for item in items:
        if item not in seen:
            yield item
            seen.add(item)

#不可哈希
def dedupe(items,key=None):
    seen = set()
    for item in items:
        #参数key指定一个函数将序列中的元素转换为可哈希的类型
        val = item if key is None else key(item)
        if val not in seen:
            yield item
            seen.add(val)
#对切片命名
#slice(),indices()

#查找序列中出现次数最多的元素
from collections import  Counter
#most_common,update Counter 可以进行数学运算+ -

#通过公共键对字典列表进行排序

from operator import itemgetter
#形似rows = [{},{},{}]
#利用sorted(rows,key=itemgetter('one',['two']))进行排序
#或者lambda函数 sorted（rows，key=lambda r:(r['one'],r['two']))
#但是itemgetter运行的更为快速

#根据字段将记录分组
from itertools import groupby
#首先利用itemgetter进行排序，在利用groupby进行分组
#或者利用defaultdict进行 一值对应多值

#对序列中的元素作筛减 
#列表推导式 生成器表达式
from itertools import compress

#其接受一个可迭代对象以及一个布尔选择器序列作为输入。将一个序列的筛选结果映射到另外一个相关的序列时非常有用。
#compress会返回一个迭代器，可以使用list将其转换为列表

#从字典中提取子集
#字典推导式

#将名称映射到序列的元素中
from collections import  namedtuple

#命名元组的主要作用在于同它所控制的元素位置间解耦

#将多个映射合并为单个映射
from collections import ChainMap
#或者dict的update函数