python数据结构算法_Python——数据结构和算法

1. 解压变量

1. 最简单的变量解压

data = [ 'ACME', 50, 91.1, (2012, 12, 21) ]

name, _, price, date= data

2. 需要一个变量接收多个值

s = [1,2,3,4,5]

a,*b, c =s>>> a为1; b为[2,3,4]; c为5.

3. 存在嵌套的情况

record = ('ACME', 50, 123.45, (12, 18, 2012))

name,*_, (*_, year) = record

2. 优先队列与Top-K

1. FIFO队列

使用deque实现长度为n的FIFO队列。 deque(maxlen=N) 会创建一个大小为N的FIFO队列。

deque有如下函数: append、appendleft、pop、popleft。

from collections importdequedef search(lines, pattern, history=5):

previous_lines= deque(maxlen=history)for line inlines:if pattern inline:yieldline, previous_lines

previous_lines.append(line)

这里使用生成器函数可使搜索过程代码和使用搜索结果代码解耦。

2. TOP-K

1. top-1

通常采用min、max函数求得最大/小值。

2. top-k

通常采用nlargest、nsmallest函数

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'])

3. 堆数组

nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]importheapq

heap=list(nums)

heapq.heapify(heap)

heap>>> [-4, 2, 1, 23, 7, 2, 18, 23, 42, 37, 8]

# 弹出与插入元素heapq.heappop(heap)

heapq.headpush(heap, 1)

4. 优先队列

importheapqclassPriorityQueue:def __init__(self):

self._queue=[]

self._index=0defpush(self, item, priority):

heapq.heappush(self._queue, (-priority, self._index, item))

self._index+= 1

defpop(self):return heapq.heappop(self._queue)[-1]

-priority 使元素优先级从高到低排列， index 保障了优先级相同的元素按照插入先后顺序排列。

3. 字典

1. multidict

from collections importdefaultdict

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)

type(d)>>> collections.defaultdict

其会自动为将要访问的键（即使字典中并不存在这样的键）创建映射实体。如果不需要这种操作，考虑如下方法。

d = {} #一个普通的字典

d.setdefault('a', []).append(1)

d.setdefault('a', []).append(2)

d.setdefault('b', []).append(4)

2. TreeMap

from collections importOrderedDict

d=OrderedDict()

d['foo'] = 1d['bar'] = 2

OrderedDict 内部有着一个用于维护键插入顺序排序的双向链表。所以，相对Dict，OrderedDict需要两倍的储存空间。

3. Dict的运算

1. 需要根据取最大值与最小值

prices ={'ACME': 45.23,'AAPL': 612.78,'IBM': 205.55,'HPQ': 37.20,'FB': 10.75}

min_price=min(zip(prices.values(), prices.keys()))>>> (10.75, 'FB')

max_price =max(zip(prices.values(), prices.keys()))>>> (612.78, 'AAPL')prices_sorted=sorted(zip(prices.values(), prices.keys()))>>> [(10.75, 'FB'), (37.2, 'HPQ'),(45.23, 'ACME'), (205.55, 'IBM'),(612.78, 'AAPL')]

其中zip函数的用法为

a = [1, 2, 3]

b= [4, 5, 6]

c= [7, 8, 9]

zip(a, b, c)>>> [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

需要注意的是，zip是一个迭代器，所以不能反复使用。

2. 差、并、交集

可使用 items keys values 等函数后，获取到相应集合，利用集合运算函数进行运算。

4. 集合

1. 元素去重

a = [1,2,1]

set(a)

该方法只可用于可hash对象，否则应自行构建hash函数。