python数据结构与算法（一）

1.序列中的N个元素赋值给变量

data = [1,2,3,"string!",["python","php"]]
num_1,num_2, num_3,num_4,str_1,[list_1,list_2] = data#简单的赋值语句解压并赋值给多个变量，唯一的前提就是变量的数量必须跟序列元素的数量是一样的
print(list_1)
#如果一个可迭代对象的元素个数超过变量个数时，会抛出一个 ValueError，Python 的星号表达式可以用来，能从这个可迭代对象中解压出 N 个元素出来
num_x,*midsomething =data
print(midsomething)
print(midsomething[-1][0])

运行结果：

　python
 [2, 3, 4, 'string!', ['python', 'php']]
  python

---

#扩展的迭代解压语法是专门为解压不确定个数或任意个数元素的可迭代对象而设计 的。通常，这些可迭代对象的元素结构有确定的规则
line = 'nobody:*:-2:-2:Unprivileged User:/var/empty:/usr/bin/false'
uname,*fields,homedir,sh=line.split(":") #星号语法分割字符串

print(uname,homedir,sh)

运行结果：
nobody /var/empty /usr/bin/false

2.保留最后有限的历史记录

from collections import deque
def search(lines, pattern, history=5):
    previous_lines = deque(maxlen=history)#使用 deque(maxlen=N) 构造函数会新建一个固定大小的队列。当新的元素加入并
且这个队列已满的时候，最老的元素会自动被移除掉
    for li in lines:
        if pattern in li:
            previous_lines.append(li)
    return previous_lines


with open('C:\Users\master\Desktop\text.txt')as f:
    print(list(search(f, 'line', 3)))


运行结果：
['fourteenthline
', 'fifteenthline
', 'sixteenthline
']

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

heapq 模块有两个函数：nlargest() 和 nsmallest() 可以完美解决这个问题

当要查找的元素个数相对比较小的时候，函数 nlargest() 和 nsmallest() 是很 合适的。如果你仅仅想查找唯一的最小或最大 (N=1) 的元素的话，那么使用 min() 和 max() 函数会更快些。类似的，如果 N 的大小和集合大小接近的时候，通常先排序这 个集合然后再使用切片操作会更快点 ( sorted(items)[:N] 或者是 sorted(items)[- N:] )。需要在正确场合使用函数 nlargest() 和 nsmallest() 才能发挥它们的优势 (如果 N 快接近集合大小了，那么使用排序操作会更好些)。

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]

---

portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', '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}
]
cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])

　4.　设置优先级

class PriorityQueue:
    def __init__(self):
        self._queue=[]
        self._index =0
    def push(self,item,priority):
        heapq.heappush(self._queue,(-priority,self._index,item))#优先级为负数的目的是使得元素按照优先级从高到低排序。这个跟普通的按优先级从低到高排序的堆排序恰巧相反。index 变量的作用是保证同等优先级元素的正确排序。通过保存一个不断增加的index 下标变量，可以确保元素按照它们插入的顺序排序
        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('bet'),5)
q.push(Item('bar'),2)
print(q.pop(),q.pop(),q.pop())#第一个 pop() 操作返回优先级最高的元素。另外注意到如果两个有着相同优先级的元素 ( bar 和 bbr )，pop 操作按照它们被插入到队列的顺序返回的。

5.实现一个键对应多个值的字典

from collections import defaultdict
#果你想要一个键映射多个值，那么你就需要将这多个值放到另外的容器中，比如列表或者集合里面。
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)
print(dict(d))
d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)
d['b'].add(4)
print(dict(d))

6.在数据字典中执行一些计算操作 (比如求最小值、最大值、排序等等)

prices = {
'ACME': 45.23,
'AAPL': 612.78,
'IBM': 205.55,
'HPQ': 37.20,
'FB': 10.75
}
print(min(prices,key=lambda x:prices[x]))#min()和max()函数中提供 key 函数参数来获取最小值或最大值对应的键的信息。
price_sorted = sorted(zip(prices.values(),prices.keys()))#以使用 zip() 和 sorted() 函数来排列字典数据
print(price_sorted)
print(max(zip(prices.values(),prices.keys())))