- 一、 需求：排除list的第一个以及最后一个元素之后，进行平均数的求解
def avg(agrs):
return sum(agrs)/len(agrs)
def drop_first_last(grades):
first, *middle, last = grades
return avg(middle)
print(drop_first_last((1, 2, 3, 4, 5, 6, 7, 8, 9)))
输出：5.0
注意middle变量永远都是列表类型，不管中间有多少（包括0），所以任何使用到middle变量的代码就不需要做多余的类型检查去确认它是否是列表类型了.
- 二、从一个集合中获得最大或者最小的N个元素列表
heaps模块有两个函数:nlargest()与smallest()可以解决这个问题
import heapq
nums = [1,8,2,23,7,-4,18,23,42,37,2]
print(heapq.nlargest(3,nums))#获取最大的前3个数
print(heapq.nsmallest(4,nums))
[42, 37, 23]
[-4, 1, 2, 2]
两个函数都能狗解手一个关键字参数，用于更复杂的数据结构
import heapq
portInfo = [
{'name':'IBM','shares':100,'price':91.1},
{'name':'APPLE','shares':50,'price':543.22},
{'name':'FB','shares':200,'price':21.09},
{'name':'HPQ','shares':35,'price':31.75},
{'name':'YHOO','shares':45,'price':16.35},
{'name':'ACME','shares':75,'price':115.65},
]
expensive = heapq.nlargest(3,portInfo,key=lambda s:s['price'])
cheap = heapq.nsmallest(3,portInfo,key=lambda s : s['shares'])
print(expensive)
print(cheap)
# key = lambda s: s['price']
# print(key(portInfo[1]))
在上面的代码对每个元素进行对比的时候，会以price的值进行比较
[{'shares': 50, 'name': 'APPLE', 'price': 543.22}, {'shares': 75, 'name': 'ACME', 'price': 115.65}, {'shares': 100, 'name': 'IBM', 'price': 91.1}]
[{'shares': 35, 'name': 'HPQ', 'price': 31.75}, {'shares': 45, 'name': 'YHOO', 'price': 16.35}, {'shares': 50, 'name': 'APPLE', 'price': 543.22}]
如果你想在一个集合中查找最小或最大的N个元素，并且N小于集合元素数量，那么这些函数提供了很好的性能。因为在底层实现里边，首先会将集合数据进行堆排序后放入一个列表中：
nums = [1,4,5,2,6,7,2,6,7,1,2,9]
heapq.heapify(nums)
print(nums)
注意：heapq.heapify(nums)这个操作并没有返回值
[1, 1, 2, 2, 2, 7, 5, 6, 7, 6, 4, 9]
堆数据结构最重要的特征是heap[0]永远是最小的元素，并且剩余的元素可以很容易通过调用heapq.heappop()方法得到，该方法会先将第一个元素弹出来，然后用下一个最小的元素来取代被弹出元素(成为最小的元素，这种操作时间复杂度为O(N),N是堆大小)
当要查找的元素个数相对比较小的时候，函数nlargest()和nsmallest()是很合适的。如果你仅仅想查找唯一的最小或最大(N=1)的元素的话，那么使用min()和max()函数会更快些。类似的，如果N的大小和集合大小接近的时候,通常先排序这个集合然后在使用切片操作会更快点(sorted(items)[:N]或者是sorted(items)[-N:])。
-
1.6 怎样实现一个键对应多个值得字典(也叫
multidict)
解决方案：一个字典就是一个键对应一个单值的映射。如果你想要一个键映射多个值，那么你就需要将这多个值放到另外的容器中，比如列表或者集合里边，你可以像下面这样构造这样的字典
d = {
'a':[1,2,3],
'b':[4,5],
'c':[6,7,8,9]
}
e = {
'a':{1,2,3},
'b':{4,5},
'c':{6,7,8,9}
}
print(d)
print(e)
我发现一个奇怪的现象，就这这两个输出语句同时打印的话，输出是有序的，两个都是有序的，如果分开只打印一句的话，就是乱的，当然，列表的内部是有序的
选择使用列表还是集合取决于你的实际需求，如果你想保持元素的插入顺序就应该使用列表，如果你想去掉重复元素就使用集合(并且不关心元素的顺序问题)
1.7字典排序
问题：你想创建一个字典，并且在迭代或序列化这个字典的时候能够控制元素的顺序。
解决方案：为了控制一个字典中元素的顺序，你可以使用collections模块中的OrderedDict类。在迭代操作的嘶吼它会保持元素被插入时的顺序，示例如下:
from collections import OrderedDict
def order_dict():
d = OrderedDict()
d['bar'] = 2
d['grok'] = 4
d['foo'] = 1
d['spam'] = 3
for k in d:
print(k,d[k])
# for (k,v) in d.items():
# print(k,v)
order_dict()
bar 2
grok 4
foo 1
spam 3
- 当你想要构建一个将来需要序列化或编码成其他格式的映射的时候，
OrderedDict是非常有用的。比如你想精确控制以JSON编码后字段的顺序，你可以先使用OrderedDict来构建这样的数据
import json
from collections import OrderedDict
d = OrderedDict()
d['bar'] = 2
d['grok'] = 4
d['foo'] = 1
d['spam'] = 3
print(d)
print(json.dumps(d))
>OrderedDict([('bar', 2), ('grok', 4), ('foo', 1), ('spam', 3)])
{"bar": 2, "grok": 4, "foo": 1, "spam": 3}
`OrderedDict`内部维护着一个根据键插入顺序排序的双向链表。每次当一个新的元素插入进来的时候，它会被放到链表的尾部。对于一个已经存在的键的重复赋值不会改变键的顺序。需要注意的是，一个 `OrderedDict`的大小是一个普通字典的两倍，因为它内部维护着另一个链表。所以如果你需要构建一个需要大量`OrderedDict`实例的数据结构的时候(比如读取100000行CSV数据到一个OrderedDict列表中去)，那么就得考虑一下`OrderedDict`带来的好处与额外内存消耗了。
##### 1.8字典的运算
怎么在数据字典中执行一些计算操作(比如求最小值、最大值、排序等等)?
prices = {
'ACME':45.23,
'APPL':612.78,
'IBM':205.55,
'HPQ':37.20,
'FB':10.75
}
print(prices)
print(min(zip(prices.values(),prices.keys())))
print(min(zip(prices.keys(),prices.values())))
为了对字典值执行计算操作，通常需要使用`zip()`函数。。。。关于zip(),未完待续。。。。
* 同样的，可以结合`zip()` 和`sorted()`函数来排列字典
prices_sorted = sorted(zip(prices.values(),prices.keys()))
print(prices_sorted)
> [(10.75, 'FB'), (37.2, 'HPQ'), (45.23, 'ACME'), (205.55, 'IBM'), (612.78, 'APPL')]
* 需要注意的是`zip()`函数创建的是一个只能访问一次的迭代器。
prices_and_names = zip(prices.values(),prices.keys())
print(min(prices_and_names))
print(max(prices_and_names))#这里就会报错如下：
>(10.75, 'FB')
Traceback (most recent call last):
File "/Users/mudy/Documents/Python/Fishc/day01.py", line 160, in <module>
print(max(prices_and_names))
ValueError: max() arg is an empty sequence
* 1.9查找两字典的相同点
  怎么在两个字典中寻找相同点(比如相同的键，相同的值)
a = {
'x' : 1,
'y' : 2,
'z' : 3,
}
b = {
'w' : 10,
'x' : 11,
'y' : 2
}
print(a.keys() & b.keys())#AB同时存在的key
print(a.keys()-b.keys())#在A不在B里的
print(a.items()&b.items())#AB中同时存在的元素
>{'y', 'x'}
{'z'}
{('y', 2)}
你还可以这么的，假如你想以现有字典构造一个排除几个指定键的新字典。
c = {key:a[key] for key in a.keys()-{'z'}} #列表生成式
print(c)
>{'y': 2, 'x': 1}
##### 1.10删除序列相同元素并保持顺序
 怎样在一个序列上面保持元素顺序的同事消除重复的值。
关于`yield`可以看[这篇文章](https://www.oschina.net/translate/improve-your-python-yield-and-generators-explained)
`return隐含的意思是函数正将执行代码的控制权返回给函数被调用的地方。而"yield"的隐含意思是控制权的转移是临时和自愿的，我们的函数将来还会收回控制权。`
