dict遍历所有key python python dict遍历顺序

字典创立

# 创建空字典
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')]