python高级操作

python补充

1.去掉最大值和最小值,然后求平均值

def drop_first_last(grades):
    first, *middle, last = grades
    return sum(middle) / len(middle)

2.在迭代操作或者其他操作的时候，怎样只保留最后有限几个元素的历史记录？在多行上面做简单的文本匹配，并只返回在前 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)
if __name__ == '__main__':
    with open(r'../../cookbook/somefile.txt') as f:
        for line, prevlines in search(f, 'python', 5):
            for pline in prevlines:
                print(pline, end='')
                print(line, end='')
                print('-' * 20)
                

在队列两端插入或删除元素时间复杂度都是 O(1) ，而在列表的开头插入或删除元
素的时间复杂度为 O(N) 。
>>> q = deque()
>>> q.append(1)
>>> q.append(2)
>>> q.append(3)
>>> q
deque([1, 2, 3])
>>> q.appendleft(4)
>>> q
deque([4, 1, 2, 3])

3.怎样从一个集合中获得最大或者最小的 N 个元素列表？

heapq 模块有两个函数：nlargest() 和 nsmallest() 可以完美解决这个问题。
import heapq
nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]
print(heapq.nlargest(3, nums)) # Prints [42, 37, 23]
print(heapq.nsmallest(3, nums)) # Prints [-4, 1, 2]

4.怎样实现一个按优先级排序的队列？并且在这个队列上面每次 pop 操作总是返回优先级最高的那个元素

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))
        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)
>>> q.pop()
Item('bar')
>>> q.pop()
Item('spam')
>>> q.pop()
Item('foo')
>>> q.pop()
Item('grok')
>>>

仔细观察可以发现，第一个 pop() 操作返回优先级最高的元素。另外注意到如果
两个有着相同优先级的元素 ( foo 和 grok )，pop 操作按照它们被插入到队列的顺序返
回的。

5.字典中的键映射多个值

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

d = defaultdict(list)
for key, value in pairs:
    d[key].append(value)

6.你想创建一个字典，并且在迭代或序列化这个字典的时候能够控制元素的顺序。

为 了 能 控 制 一 个 字 典 中 元 素 的 顺 序， 你 可 以 使 用 collections 模 块 中 的
OrderedDict 类。在迭代操作的时候它会保持元素被插入时的顺序，示例如下：
from collections import OrderedDict
def ordered_dict():
d = OrderedDict()
d['foo'] = 1
d['bar'] = 2
d['spam'] = 3
d['grok'] = 4
# Outputs "foo 1", "bar 2", "spam 3", "grok 4"
for key in d:
print(key, d[key])

当你想要构建一个将来需要序列化或编码成其他格式的映射的时候， OrderedDict
是非常有用的。比如，你想精确控制以 JSON 编码后字段的顺序，你可以先使用
OrderedDict 来构建这样的数据：
>>> import json
>>> json.dumps(d)
'{"foo": 1, "bar": 2, "spam": 3, "grok": 4}'
>>>

7.字典的运算:怎样在数据字典中执行一些计算操作 (比如求最小值、最大值、排序等等)？

考虑下面的股票名和价格映射字典：
prices = {
'ACME': 45.23,
'AAPL': 612.78,
'IBM': 205.55,
'HPQ': 37.20,
'FB': 10.75
}
为了对字典值执行计算操作，通常需要使用 zip() 函数先将键和值反转过来。比
如，下面是查找最小和最大股票价格和股票值的代码：
min_price = min(zip(prices.values(), prices.keys()))
# min_price is (10.75, 'FB')
max_price = max(zip(prices.values(), prices.keys()))
# max_price is (612.78, 'AAPL')