数据结构和算法

解包赋值

p &＃61; [1, 2, 3]
a, b, c &＃61; p# _表示被丢弃的值
_, d, _ &＃61; p# 可变长解包
*a, b &＃61; p# 字串切割解包
line &＃61; &＃39;nobody:hello:world:123:/dirname&＃39;
a, *_, c, d &＃61; line.split(&＃39;:&＃39;)

保留最后N个元素

from collections import dequep &＃61; list(range(10))
d &＃61; deque(maxlen&＃61;3)def keep_history():for i in p:yield id.append(i)

查找最大或最小的N个元素

适合在大集合中查找少量元素&＃xff1b;若N大小与集合大小接近&＃xff0c;直接排序后切片&＃xff1b;若找唯一最大最小值&＃xff0c;直接用max/min方法。

import heapqnums &＃61; [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 &＃61; [
{&＃39;name&＃39;: &＃39;IBM&＃39;, &＃39;shares&＃39;: 100, &＃39;price&＃39;: 91.1},
{&＃39;name&＃39;: &＃39;AAPL&＃39;, &＃39;shares&＃39;: 50, &＃39;price&＃39;: 543.22},
{&＃39;name&＃39;: &＃39;FB&＃39;, &＃39;shares&＃39;: 200, &＃39;price&＃39;: 21.09},
{&＃39;name&＃39;: &＃39;HPQ&＃39;, &＃39;shares&＃39;: 35, &＃39;price&＃39;: 31.75},
{&＃39;name&＃39;: &＃39;YHOO&＃39;, &＃39;shares&＃39;: 45, &＃39;price&＃39;: 16.35},
{&＃39;name&＃39;: &＃39;ACME&＃39;, &＃39;shares&＃39;: 75, &＃39;price&＃39;: 115.65}
]
# 通过关键字参数排序然后取出N个值
cheap &＃61; heapq.nsmallest(3, portfolio, key&＃61;lambda s: s[&＃39;price&＃39;])
expensive &＃61; heapq.nlargest(3, portfolio, key&＃61;lambda s: s[&＃39;price&＃39;])

字典键映射多个值

from collections import defaultdictd &＃61; defaultdict(list)d[&＃39;a&＃39;].append(1)
d[&＃39;a&＃39;].append(2)
d[&＃39;b&＃39;].append(3)

字典排序

from collections import OrderedDictd &＃61; OrderedDict()
d[&＃39;a&＃39;] &＃61; 1
d[&＃39;b&＃39;] &＃61; 2
d[&＃39;c&＃39;] &＃61; 3

字典运算

最大值、最小值、排序&＃xff0c;用zip将键值反转。

prices &＃61; {
&＃39;ACME&＃39;: 45.23,
&＃39;AAPL&＃39;: 612.78,
&＃39;IBM&＃39;: 205.55,
&＃39;HPQ&＃39;: 37.20,
&＃39;FB&＃39;: 10.75
}
min_price &＃61; min(zip(prices.values(), prices.keys()))max_price &＃61; max(zip(prices.values(), prices.keys()))prices_sorted &＃61; sorted(zip(prices.values(), prices.keys()))

zip函数创建的是只能访问一次的迭代器。

查找两字典的相同元素

交并差集运算。

a &＃61; {
&＃39;x&＃39; : 1,
&＃39;y&＃39; : 2,
&＃39;z&＃39; : 3
}
b &＃61; {
&＃39;w&＃39; : 10,
&＃39;x&＃39; : 11,
&＃39;y&＃39; : 2
}# Find keys in common
a.keys() & b.keys() # { &＃39;x&＃39;, &＃39;y&＃39; }
# Find keys in a that are not in b
a.keys() - b.keys() # { &＃39;z&＃39; }
# Find (key,value) pairs in common
a.items() & b.items() # { (&＃39;y&＃39;, 2) }

删除相同元素并保持顺序

# 元素可哈希&＃xff0c;如列表元组
def dedupe(items):seen &＃61; set()for item in items:if item not in seen:yield itemseen.add(item)# 元素不可哈希&＃xff0c;如字典
def dedupe(items, key&＃61;None):seen &＃61; set()for item in items:val &＃61; item if key is None else key(item)if val not in seen:yield itemseen.add(val)
list(dedupe(a, key&＃61;lambda d: (d[&＃39;x&＃39;],d[&＃39;y&＃39;])))

命名切片

通过slice方法将切片赋值到变量&＃xff0c;然后调用变量。

SHARES &＃61; slice(20, 23)
PRICE &＃61; slice(31, 37)
cost &＃61; int(record[SHARES]) * float(record[PRICE])

序列中出现次数最多的元素

from collections import Counterwords &＃61; [
&＃39;look&＃39;, &＃39;into&＃39;, &＃39;my&＃39;, &＃39;eyes&＃39;, &＃39;look&＃39;, &＃39;into&＃39;, &＃39;my&＃39;, &＃39;eyes&＃39;,
&＃39;the&＃39;, &＃39;eyes&＃39;, &＃39;the&＃39;, &＃39;eyes&＃39;, &＃39;the&＃39;, &＃39;eyes&＃39;, &＃39;not&＃39;, &＃39;around&＃39;, &＃39;the&＃39;,
&＃39;eyes&＃39;, "don&＃39;t", &＃39;look&＃39;, &＃39;around&＃39;, &＃39;the&＃39;, &＃39;eyes&＃39;, &＃39;look&＃39;, &＃39;into&＃39;,
&＃39;my&＃39;, &＃39;eyes&＃39;, "you&＃39;re", &＃39;under&＃39;
]
word_counts &＃61; Counter(words)
top_three &＃61; word_counts.most_common(3)

通过关键字排序一个字典列表

from operator import itemgetterrows &＃61; [
{&＃39;fname&＃39;: &＃39;Brian&＃39;, &＃39;lname&＃39;: &＃39;Jones&＃39;, &＃39;uid&＃39;: 1003},
{&＃39;fname&＃39;: &＃39;David&＃39;, &＃39;lname&＃39;: &＃39;Beazley&＃39;, &＃39;uid&＃39;: 1002},
{&＃39;fname&＃39;: &＃39;John&＃39;, &＃39;lname&＃39;: &＃39;Cleese&＃39;, &＃39;uid&＃39;: 1001},
{&＃39;fname&＃39;: &＃39;Big&＃39;, &＃39;lname&＃39;: &＃39;Jones&＃39;, &＃39;uid&＃39;: 1004}
]rows_by_fname &＃61; sorted(rows, key&＃61;itemgetter(&＃39;fname&＃39;))
rows_by_uid &＃61; sorted(rows, key&＃61;itemgetter(&＃39;uid&＃39;))
# 多个关键字
rows_by_lfname &＃61; sorted(rows, key&＃61;itemgetter(&＃39;lname&＃39;,&＃39;fname&＃39;))# 支持下标索引
itemgetter(0, 1)

排序不支持原生比较的对象

内置sorted方法的关键字参数key接受一个可调用对象&＃xff0c;利用函数返回一个值用于比较。

class User:def __init__(self, user_id):self.user_id &＃61; user_iddef __repr__(self):return &＃39;User({})&＃39;.format(self.user_id)def sort_notcompare():users &＃61; [User(23), User(3), User(99)]print(users)print(sorted(users, key&＃61;lambda u: u.user_id))

或通过operator的attrgetter方法替代这个函数&＃xff0c;并且通常这个方法运行得快一点。

from operator import attrgettersorted(users, key&＃61;attrgetter(&＃39;user_id&＃39;))

合并多个字典

从逻辑上合并然后执行操作&＃xff0c;而不是物理上的合并。

from collections import ChainMapa &＃61; {&＃39;x&＃39;: 1, &＃39;z&＃39;: 3 }
b &＃61; {&＃39;y&＃39;: 2, &＃39;z&＃39;: 4 }c &＃61; ChainMap(a,b)
print(c[&＃39;x&＃39;]) # Outputs 1 (from a)
print(c[&＃39;y&＃39;]) # Outputs 2 (from b)
print(c[&＃39;z&＃39;]) # Outputs 3 (from a)

对新字典的更新或删除操作总是影响第一个字典。