Python3 From Zero——{最初的意识：001～数据结构和算法}

一、从队列两端高效插入、删除元素，及保留固定数量的数据条目:

collections.deque([iterable[,maxlen=N]])

a = collections.deque([1, 2],maxlen=3)

a.appendleft(3)

[3, 1, 2]

a.appendleft(4)

[4, 3, 1]

a.popleft()

[3, 1]

二、求队列中最大或最小的N个元素

思路1：heapq.nlargest(N, iterable, key=None)、heapq.nsmallest(N, iterable, key=xxx)

思路2：先排序，再切片：sorted(items)[:N]、sorted(items)[-N:]

如果对象是一个字典，则可以先用zip将字典的key、value反转形成包含元组的列表,如：min_xxx = min(zip(dict.values(), dict.key()))

三、实现自定义优先级队列

heapq.heappush(heap, item),item表示自定义的优先级标识，可以为元组、列表等，用以实现多级联排

heapq.heappop(heap)，剔除并显示综合优先级最小的元素

四、字典的key、key-value支持常见的集合操作（value不支持），如并集(&)、交集(|)、差集(单向-,双向^)等，无须事先转换为集合，可用于比较两个字典之间keys或items的异同、重叠等，如：a.keys() - b.keys()，a.items() & b.items()

五、找出序列中出现次数最多的元素

首先collections.Counter(list/tuple/str)形成一个Counter对象，然后collections.Counter.most_common(N)，即可得出“出现次数最多的前N个元素”。在底层实现中，Counter是一个字典，在元素和它们出现的次数之间做了映射；Counter之间是可以进行+-*/等数学运算的、用.update追加源数据以更新次数统计结果等；详情help(collections.Counter)

六、筛选「可同时替换」序列中的元素

列表推导式，示例：test = [n**2 if n > 0 else 0 for n in mylist]

针对复杂筛选条件，先将筛选逻辑放到单独的函数中，然后使用内建的filter()函数处理：test = list(filter(my_def, values))，只显示使my_def（通常为try－except结构）结果为True的value组成的列表

七、从字典中提取符合自定义条件的字集

示例：sub_dict = {key: value for key, value in my_dict.items() if value > 200或if key in other_dict} 

八、enumerate(iterable, start=0)，为原始对象添加index序列，可自定义index起始数字

>>> for i,j in enumerate({'a':1,'b':2}.items(), start=10):
...  print(i, j)
... 
10 ('b', 2)
11 ('a', 1)

九、内置函数：sorted、reversed，不修改源数据；.sort、.reverse是列表、字典等的方法，原地修改源数据

sorted(iterable, key=None, reverse=False) 

十、abs(int/float)、any(iterable)、all(iterable)

abs:返回绝对值

all():如果迭代器里面的任何元素都非零或非空,返回True；否则返回False

any():如果迭代器里面的其中一个或多个元素非零或非空，返回True；否则返回False

十一、 转换并同时计算数据：使用生成器推导式————高效、优雅；生成器方案会以迭代的方式转换数据，更省内存

# Determine if any .py files exist in a directory
import os
files = os.listdir('dirname')
if any(name.endswith('.py') for name in files):
    print('There be python!')
else:
    print('Sorry, no python.')
# Output a tuple as CSV
s = ('ACME', 50, 123.45)
print(','.join(str(x) for x in s))    ＃join用于连接字符串
# Data reduction across fields of a data structure
portfolio = [
    {'name':'GOOG', 'shares': 50},
    {'name':'YHOO', 'shares': 75},
    {'name':'AOL', 'shares': 20},
    {'name':'SCOX', 'shares': 65}
]
min_shares = min(s['shares'] for s in portfolio)

# Original: Returns 20
min_shares = min(s['shares'] for s in portfolio)
# Alternative: Returns {'name': 'AOL', 'shares': 20}
min_shares = min(portfolio, key=lambda s: s['shares'])    ＃生成一个迭代器

十二、合并多个字典或映射

思路1：from collections import ChainMap，仅是在逻辑上连接两个字典，并不创建新字典，优先查询位置在前的字典的数据，原字典的数据变动可以同步体现

a = {'x': 1, 'z': 3 }
b = {'y': 2, 'z': 4 }

from collections import ChainMap
c = ChainMap(a,b)
print(c['x']) # Outputs 1 (from a)
print(c['y']) # Outputs 2 (from b)
print(c['z']) # Outputs 3 (from a)

思路2：dict_bak.update({new_dict})，更新原字典（的副本），原重复的key的value将被覆盖，仅能查询到新字典中的数据，原字典的变动无法同步体现

test = dict(a)    #用dict生成原字典的副本，不破坏原字典数据
c = test.update(b)
print(c['z']) # Outputs 4 (from b)