字典创立
# 创建空字典
e = dict()
e = {}
# 使用dict指定关键字参数创建字典,key不允许使用表达式
f = dict(k1 = 1,k2 = 'v2')
print (f)
# 打印 {'k1': 1, 'k2': 'v2'}
# 创建两个键值对字典
s = [('k1',1),('k2',2)]
h = dict(s)
print (h)
# 打印 {'k1': 1, 'k2': 2}
遍历Key
dict = {'a': 1, 'b': 2, 'c': 3}
for key in dic:
print(key, ':', dic[key])
for key in dic.keys():
print(key, ':', dic[key])
结果:
a:1
b:2
c:3
遍历Value
for value in dic.values():
print(value)
结果:
1
2
3
遍历键值对值
dic = {'a': 1, 'b': 2, 'c': 3}
for key,value in dic.items():
print(key, ':', value)
结果:
a:1
b:2
c:3
for kv in dic.items():
print(kv) # kv[0] = 'a' kv[1]=1
结果:
('a', 1)
('b', 2)
('c', 3)
对字典进行排序
k = 20
# reverse: True,从大到下;False,从小到大
top_list = list(sorted(dic.items(), key=lambda item:item[1], reverse=True))[:k]
# 参数reverse = True 表示反序从大到小排列, False表示从小到大
# 打印前top
for element in top_list:
key = element[0]
value = element[1]
print(key,"\t",value)
通过某个关键字排序一个字典列表
rows = [
{'fname': 'Brian', 'lname': 'Jones', 'uid': 1003},
{'fname': 'David', 'lname': 'Beazley', 'uid': 1002},
{'fname': 'John', 'lname': 'Cleese', 'uid': 1001},
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}
]
from operator import itemgetter
rows_by_fname = sorted(rows, key=itemgetter('fname'))
rows_by_uid = sorted(rows, key=itemgetter('uid'))
print(rows_by_fname)
[{'fname': 'Big', 'uid': 1004, 'lname': 'Jones'},
{'fname': 'Brian', 'uid': 1003, 'lname': 'Jones'},
{'fname': 'David', 'uid': 1002, 'lname': 'Beazley'},
{'fname': 'John', 'uid': 1001, 'lname': 'Cleese'}]
print(rows_by_uid)
[{'fname': 'John', 'uid': 1001, 'lname': 'Cleese'},
{'fname': 'David', 'uid': 1002, 'lname': 'Beazley'},
{'fname': 'Brian', 'uid': 1003, 'lname': 'Jones'},
{'fname': 'Big', 'uid': 1004, 'lname': 'Jones'}]
rows_by_lfname = sorted(rows, key=itemgetter('lname','fname'))
print(rows_by_lfname)
[{'fname': 'David', 'uid': 1002, 'lname': 'Beazley'},
{'fname': 'John', 'uid': 1001, 'lname': 'Cleese'},
{'fname': 'Big', 'uid': 1004, 'lname': 'Jones'},
{'fname': 'Brian', 'uid': 1003, 'lname': 'Jones'}]
# 不要忘了这节中展示的技术也同样适用于 min() 和 max() 等函数
>>> min(rows, key=itemgetter('uid'))
{'fname': 'John', 'lname': 'Cleese', 'uid': 1001}
>>> max(rows, key=itemgetter('uid'))
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}
对字典先按值再按键排序
dic = {'b' : 89, 'a' : 89, 'd' : 70, 'e' : 90}
result = sorted(dic.items(), key=lambda kv: (kv[1], kv[0]),reverse=False)
# lambda表达式中,指定先按值kv[1]排序,后按键kv[0]排序
print(result)
out: [('d', 70), ('a', 89), ('b', 89), ('e', 90)]
result = sorted(dic.items(), key=lambda kv: (-kv[1], kv[0]),reverse=False)
# "-kv[1]" 表对值的排序反过来排
print(result)
out: [('e', 90), ('a', 89), ('b', 89), ('d', 70)]
dic = {5 : 89, 2 : 89, 8 : 70, 6 : 90}
result = sorted(dic.items(), key=lambda kv: (kv[1], kv[0]),reverse=False)
print(result)
out: [(8, 70), (2, 89), (5, 89), (6, 90)]
字典value初始化
from collections import defaultdict
# 初始化每个key对应一个列表
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)
for key, value in pairs:
d[key].append(value
创建有序字典
使用 collections 模块中的OrderedDict 类,在迭代操作的时候它会保持元素被插入时的顺序
from collections import OrderedDict
# 初始化每个key对应一个列表
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 内部维护着一个根据键插入顺序排序的双向链表。每次当一个新的元
素插入进来的时候,它会被放到链表的尾部。对于一个已经存在的键的重复赋值不会
改变键的顺序。
需要注意的是,一个 OrderedDict 的大小是一个普通字典的两倍,因为它内部维
护着另外一个链表。所以如果你要构建一个需要大量 OrderedDict 实例的数据结构的
时候 (比如读取 100,000 行 CSV 数据到一个 OrderedDict 列表中去),那么你就得仔细
权衡一下是否使用 OrderedDict 带来的好处要大过额外内存消耗的影响。
二维字典
# 创建二维字典
dict_2d = {'one': {'a': 1, 'b': 2}, 'two': {'a': 1}}
dict_2d['one']['b'] # 输出: 2
# 更新二维字典
# 因为二维字典的两层key和value之间会混淆,需要判断第一个key是否已经存在了
def updatedict(thedict, key_a, key_b, val):
if key_a in thedict:
thedict[key_a].update({key_b: val})
else:
thedict.update({key_a:{key_b: val}})
updatedict(dict_2d,"three","a",1)
updatedict(dict_2d,"one","b",4)
# 输出:{'one': {'a': 1, 'b': 4}, 'two': {'a': 1}, 'three': {'a': 1}}
字典运算
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')
# 可以使用 zip() 和 sorted() 函数来排列字典数据:
prices_sorted = sorted(zip(prices.values(), prices.keys()))
# prices_sorted is [(10.75, 'FB'), (37.2, 'HPQ'),
# (45.23, 'ACME'), (205.55, 'IBM'),
# (612.78, 'AAPL')]