Python Cookbook Chapter1总结

#通过赋值操作
#分解的对象：可迭代(元组，列表，字符串，文件，生成器等)
#取一个包含五个元素的序列
a=[1,2,3,4,(4,6)]
b='apple'
c=

#最简单粗糙的赋值
#元素数量必须匹配，否则报错
a1,a2,a3,a4,a5 = a
#如果想要丢掉某些值，使用不用的变量名‘_’
_,b2,b3,b4,_ = b

a=[1,2,3,4,5,6,7,8,9,0]

#使用‘*表达式’解决
def drop_first_last(numbers):
    first,*middle,last = numbers
    #所以好像没有avg函数？？？
    return (sum(middle)/len(middle))
print(drop_first_last(a))

#非常适合分解未知长度的可迭代对象
address='Users/xxxx/xxxx/pythoncookbook/chapter 1 数据结构和算法/1_2_分解任意长度的可迭代对象.py'
pan,*wenjianjia,pywenjian=address.split('/')
print(pan,wenjianjia,pywenjian)

from collections import deque

#deque创建了一个固定长度的队列，当有新东西加入则移除最旧的那个

#简单点，这里有一个循环
deque_list = deque(maxlen=5)
for i in range(0,100):
    if (i % 2) == 0:
        deque_list.append(i)
print(deque_list)
    

#生成器
#yield用于生成器
def oushu_scq(maxnum=100,num=5):
    deque_list2 = deque(maxlen=num)
    for i in range(0,maxnum):
        if (i % 2) ==0:
            deque_list2.append(i)
    yield deque_list2

b = oushu_scq(100,5)
print(next(b))

###只要一个时：max，min
a1=[1,2,3,4,5,6]
print(max(a1))
    

###较少个时
a2=[5,34,67,86,24,362,34,621,343]
import heapq

print(heapq.nlargest(3,a2))#这里会导出一个从大到小的list

print(heapq.nlargest(3,a2,key=lambda x: -x))#这里接受一个key

heap = list(a2)#将a2转换为堆的形式，特点是第一个元素是最小的
print(heapq.heappop(a2))#pop出最小的那个，剩下的a2又会变成堆的形式


###较多个时，先sort再切片

#如果有一个现成的队列，那么直接！
a=[
    {'name':'a','priority':3},
    {'name':'b','priority':2},
    {'name':'c','priority':3},
    {'name':'d','priority':1},
    ]
print(max(a,key=lambda s:s['priority']))


#自己建一个队列
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))#heappush(heap,项目)
        self.index += 1
    def pop(self):
        return heapq.heappop(self.queue)#heappop(项目),pop数字最小的
q = PriorityQueue()
q.push('a',3)
q.push('b',2)
q.push('c',3)
q.push('d',1)

print('name: ',q.pop()[-1],',','prioprity: ',-q.pop()[0])

#一键多值字典,可列表(保留插入顺序)，可合集(消除重复，无关顺序)
from collections import*


a = defaultdict(list)#也可以是set，2选1
a['a1'].append(2)
a['a1'].append(2)
a['a2'].append(2)


print(a)

from collections import OrderedDict
#orderedDict大小是普通字典的两倍
d = OrderedDict()
#d={}(我用普通的字典怎么也是一样的哦……)
#因为普通dict排序是计算 key 所在内存地址的 hash (hash是一种加密算法，可以保证唯一性)
d['a']='A'
d['b']='B'
d['c']='C'

print(d)
for i in d:
    print(i,d[i])


import json
json_d = json.dumps(d)
print(json_d)

example = {
    'x':100,
    'b':200,
    'c':300,
    'd':150
    }

min_example = min(example)#这个直接比的是key的大小

min_word = min(zip(example.values(),example.keys()))#用zip可以把key和value对调

min_word2 = min(example,key = lambda s:example[s])#得到最小值对应的key

print(min_example,min_word,min_word2)

b (100, 'x') x

#移除该序列中的重复项
a=[1,2,3,5,2,3,5,7,9,5,2]

def chongfu886(list):
    already = set()#set要说明，并且set可以避免重复
    for item in list:
        if item in already:
            next
        else:
            already.add(item)
            yield item
'''
简单一点的版本
if item not in alreay:
            yield item
            already.add(item)
'''

new_a = list(chongfu886(a))
print (new_a)

a ='hfadsjoioi2938128ycnbxsj931wy8hdfoisajoiudw91jkcdshkjhf3u1hiudhsa89219034'
b='178463974678326472180931820947139864817394709317984631897409218-093812'
s=slice(10,20)
a1=a[s]
b1=b[s]
a2=a[10:20]

print(a1,b1,a2)

from operator import itemgetter

a=[
    {'name':'a','priority':3},
    {'name':'b','priority':2},
    {'name':'c','priority':3},
    {'name':'d','priority':1},
    ]


#排序-itemgetter
a_by_priority = sorted(a,key=itemgetter('priority'))
#也支持多个key
#也可以用key = lambda s:s['priority']
#但是itemgetter性能更佳



#如果是不原生支持比较操作的对象，则用attrgetter


#分组-groupby
from itertools import groupby
for priority,items in groupby(a_by_priority,key=itemgetter('priority')):
    print(priority)
    for i in items:
        print('   ',i)