python基础语法学习记录之数据结构和算法（1）

参考cookbook的学习笔记

1. 解压序列赋值给多个变量

元组：

>>> p = (4, 5)
>>> x, y = p
>>> x
4 >
>> y
5 >
>>

列表：

>>> data = [ 'ACME', 50, 91.1, (2012, 12, 21) ]
>>> name, shares, price, date = data
>>> name
'ACME'
>>> date
(2012, 12, 21)
>>> name, shares, price, (year, mon, day) = data
>>> name
'ACME'
>>> year
2012
>>> mon
12
>>> day
21
>>>

字符串：

>>> s = 'Hello'
>>> a, b, c, d, e = s
>>> a
'H'
>>> b
'e'
>>> e
'o'
>>>

技巧：
利用任意变量名占位，获取其他需要的数据

>>> data = [ 'ACME', 50, 91.1, (2012, 12, 21) ]
>>> _, shares, price, _ = data
>>> shares
50
>>> price
91.1
>>>

异常：
变量个数和序列元素的个数不匹配,会出现如下异常

>>> p = (4, 5)
>>> x, y, z = p
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: need more than 2 values to unpack
>>>

2. 解压可迭代对象赋值给多个变量

>>> record = ('Dave', 'dave@example.com', '773-555-1212', '847-555-1212')
>>> name, email, *phone_numbers = record
>>> name
'Dave'
>>> email
'dave@example.com'
>>> phone_numbers
['773-555-1212', '847-555-1212']
>>>

异常：
星号表达式 python3可支持，获得的数据类型为列表，python2可用切片的方式替代，切片获得的数据与原数据类型一致

>>> record = ('Dave', 'dave@example.com', '773-555-1212', '847-555-1212')
>>> phone_numbers = record[-2:]
>>> phone_numbers
('773-555-1212', '847-555-1212')

3. 保留最后N个元素

利用队列实现只保留最后N个元素

from collections import deque
def search(lines, pattern, history=5):
    previous_lines = deque(maxlen=history)
    for li in lines:
        if pattern in li:
            previous_lines.append(li)
    return previous_lines

使用举例：

if __name__ == '__main__':
    with open(r'./data') as f:
        prevlines = search(f, 'python', 5)
        for pline in prevlines:
            print (pline)

data中数据如下：
python1
python2
python3
python4
python5
python6
python7

输出：
python3

python4

python5

python6

python7

解释：
使用 deque(maxlen=N) 构造函数会新建一个固定大小的队列。当新元素加入且队列已满时，最老元素会自动移除。

>>> q = deque(maxlen=3)
>>> q.append(1)
>>> q.append(2)
>>> q.append(3)
>>> q
deque([1, 2, 3], maxlen=3)
>>> q.append(4)
>>> q
deque([2, 3, 4], maxlen=3)
>>> q.append(5)
>>> q
deque([3, 4, 5], maxlen=3)

如果不设置最大队列大小，会得到一个无限大小队列，可在队列的两端执行添加和弹出元素的操作。

>>> 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])
>>> q.pop()
3 >
>> q
deque([4, 1, 2])
>>> q.popleft()
4

遗留问题：
思考在队列两端插入或删除元素时间复杂度，在列表的开头插入或删除元素的时间复杂度。根据源码进行分析。

4. 查找最大或最小的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}
] c
heap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])

此段代码在对每个元素进行对比时，会以 price 的值进行比较

5. 实现一个按优先级排序的队列

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)

使用举例：

if __name__ == '__main__':
    q = PriorityQueue()
    for i in range(10):
        q.push(Item(i),i)
    for i in range(10):
        print(q.pop())

输出：
(-9, 9, Item9)
(-8, 8, Item8)
(-7, 7, Item7)
(-6, 6, Item6)
(-5, 5, Item5)
(-4, 4, Item4)
(-3, 3, Item3)
(-2, 2, Item2)
(-1, 1, Item1)
(0, 0, Item0)

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

defaultdict 会自动初始化每个key刚开始对应的值，所以只需要直接做append操作即可。

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)

7. 字典中关键字按插入顺序保存

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

8. 字典中的最大最小值

zip():

zip() 函数会将键和值反转过来
prices = {
'ACME': 45.23,
'AAPL': 612.78,
'IBM': 205.55,
'HPQ': 37.20,
'FB': 10.75
}

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

max():

min(prices) # Returns 'AAPL'
max(prices) # Returns 'IBM'

min(prices.values()) # Returns 10.75
max(prices.values()) # Returns 612.78

min(prices, key=lambda k: prices[k]) # Returns 'FB'
max(prices, key=lambda k: prices[k]) # Returns 'AAPL'

min_value = prices[min(prices, key=lambda k: prices[k])]