2.python-dict
python-dict
mapping 对象会将 hashable值映射到任意对象。 映射属于可变对象。 目前仅有一种标准映射类型 字典。
字典是一种通过名字或者关键字引用的得数据结构， 这种结构类型也称之为映射。 其中 key 类型需要时被哈希，其键几乎可以是任何值，可以是数字、字符串、元组 ，同一个字典中相同的 key 只有一个。value 值可以任意，且可以相同 。 字典类型是Python中唯一內建的映射类型。
注意，浮点数比较很不精确，因此千万不要用浮点数作为key
常用属性方法
dict={}
keys(self) # 以列表返回一个字典所有的键
values(self) # 以列表返回字典中的所有值
items(self) # 以列表返回可遍历的(键, 值) 元组数组
dict[key] # 返回以 key为键的项。如果映射中不存在 key 则会引发 KeyError
get(self,k,d=None) # 返回指定键的值，如果值不在字典中返回default值
update(dict2) # 将dict2的键值对更新到dict中
setdefault(self,k,d=None) # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
fromkeys(seq[, val]) # 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
pop(self,k,d=None) # 删除给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值
popitem(self) # 随机返回并删除字典中的一对键和值
clear(self) # 删除字典内所有的元素
copy(self) # 返回一个字典的浅copy ，俗称赋值
# 其他内置函数
cmp(dict1, dict2) # 比较两个字典元素。
list(dict) # 返回字典中使用的所有键的列表
len(dict) # 返回字典中的项数
str(dict) # 输出字典中可以打印的字符串标识
reversed(dict) # 回一个逆序获取字典键的迭代器
del dict[key] # 将 d[key] 从 d 中移除。 如果映射中不存在 key 则会引发 KeyError。
key in dict # 如果 d 中存在键 key 则返回 True，否则返回 False。
iter(d) # 返回字典中的键、值 (键, 值)的迭代器。
创建初始化
字典可以通过将以逗号分隔的 键: 值 对列表包含于花括号之内来创建，例如: {'jack': 4098, 'sjoerd': 4127} 或 {4098: 'jack', 4127: 'sjoerd'}，也可以通过 dict构造器来创建。
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
#创建一个空字典
a_dict = {}
b_dict = dict()
# 赋值创建1
c_dict = {'a':1,'b':'to','c':'63'}
d_dict = {1:2,3:4,5:6}
# 赋值创建2
d_dict = dict(a=1,b='to',c='63')
e_dict = dict(zhang=10000,wang=10000,li=10000,zhao=10000)
# 赋值创建3 - 元组转字典
dict(zip(['a','b'],[1,2]))
{'a': 1, 'b': 2}
# 赋值创建4 - 元组转字典
dict([('a',1),('b',2)])
{'a': 1, 'b': 2}
seq = ('Google', 'Runoob', 'Taobao')
dict = dict.fromkeys(seq，value=10) # seq - 键的序列
print(dict)
# 结果
{'Google': 10, 'Taobao': 10, 'Runoob': 10}
# list/set/dict 均不可被哈希
list = [1,2,3,4]
info2 = {list:'number'}
输出
TypeError: unhashable type: 'list'
返回键值对
keys() # 以类-列表形式返回 所有键(key) 顺序不是字典的顺序
values() # 以类-列表形式返回 所有值(value) 顺序和keys()返回的顺序对应
items() # 返回可遍历元组(键,值) ,包含了dict 所有数据
dict ={'k1':'v1','k2':'v2','k3':'v3'}
#1,请循环遍历除所有的key
print(dict.keys(), type(dict.keys()))
print(dict.values(),type(dict.values()))
print(dict.items(),type(dict.items()))
# 输出
dict_keys(['k1', 'k2', 'k3']) <class 'dict_keys'>
dict_values(['v1', 'v2', 'v3']) <class 'dict_values'>
dict_items([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')]) <class 'dict_items'>
# 转换成list
print(list(dict.keys()))
# 输出：
['k1', 'k2', 'k3']
增加键值
info ={'name':'zhangsan','age':'32'}
info['work'] = 'school' # 增加一个不存在的key
print(info)
结果：
{'name': 'zhangsan', 'age': '32', 'work':'school'}
a_dict={'name':'zhangsan','age':'32'}
b_dict={'work':'beijing'}
b_dict.update('home'='shenzhen')
b_dict.update(a_dict)
print(b_dict)
# 结果
{'name':'zhangsan','age':'32','home':'shenzhen','work':'beijing'}
dict.setdefault(key, default=None)
dict = {'dog': '哈士奇', 'cat': 'Tom'}
res1=dict.setdefault('dog', "Tom")
res2=dict.setdefault('mouse','jack')
print(res1)
print(res2)
# 结果
哈士奇
jack
访问修改
主要是通过 key 来进行访问修改
# 案例1
info ={'name':'zhangsan','age':'32'}
print(info['name'])
#输出
zhangsan
print(info['work']) # 报错 KeyError
# 案例2
dict.get(key,default=None) # 字典的get()方法，返回指定键的值，如果值不在字典中返回默认值。
info ={'name':'zhangsan','age':'32'}
print(info.get('name'))
print(info.get('work'))
# 输出
zhangsan
None
# 案例3
info ={'name':'zhangsan','age':'32'}
info['work']='beijing'
print(info)
# 输出
{'name': 'zhangsan', 'age': '32', 'work': 'beijing'}
删除键值
pop(key) # 根据 key 值弹出 key,value, key 必须有，否则报错，删除 key,value, 返回value
popitem() # 删除 dict(不为空) 底层存储的最后一个键值, 返回 tuple (key,value)
del dict[key] # 根据 key 删除dict 无返回
info ={'id';'1','name':'zhangsan','age':'32','work':'school'}
respop=info.pop('work')
print(info)
print(respop)
结果：
{'id';'1','name': 'zhangsan', 'age': '32'}
school
respopitem=info.popitem()
print(respopitem)
# 结果：
('age','32')
del info['name']
print(info)
# j
{'id';'1'}
其他操作
字典排序
w_dict={'learn': 2, 'play': 1, 'work': 3}
# 按照字典降序排序，输出列表
# 通过sorted 函数 加 匿名函数方式
print(sorted(w_dict.items(), key=lambda w_dict:w_dict[1],reverse=True))
# 结果
[('work', 3), ('learn', 2), ('play', 1)]
# 案例2
a_dic = {'a':{'val':3}, 'b':{'val':4}, 'c':{'val':1}}
# 通过val来进行降序排序
dict= sorted(a_dic.iteritems(), key=lambda d:d[1]['val'], reverse = True)
print(dict)
# 结果
[('b', {'val': 4}), ('a', {'val': 3}), ('c', {'val': 1})]
合并字典
def merge_dict(dic1, dic2):
return {**dic1, **dic2}
# python3.5后支持的一行代码实现合并字典
merge_dict({'a': 1, 'b': 2}, {'c': 3})
# {'a': 1, 'b': 2, 'c': 3}
修改merged['x']=10，dic1中的x值 不变 ， merged 是重新生成的一个 新字典 。
from collections import ChainMap
merged2 = ChainMap(dic1,dic2)
print(merged2)
# ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4})
ChainMap 却不同，它在内部创建了一个容纳这些字典的列表。因此使用ChainMap合并字典，
修改merged['x']=10后，dic1中的x值 改变 ，如
值最大字典
def max_pairs(dic):
if len(dic) == 0:
return dic
max_val = max(map(lambda v: v[1], dic.items()))
return [item for item in dic.items() if item[1] == max_val]
r = max_pairs({'a': -10, 'b': 5, 'c': 3, 'd': 5})
print(r)
# [('b', 5), ('d', 5)]
topn字典
from heapq import nlargest
# 返回字典d前n个最大值对应的键
def topn_dict(d, n):
return nlargest(n, d, key=lambda k: d[k])
topn_dict({'a': 10, 'b': 8, 'c': 9, 'd': 10}, 3)
# ['a', 'd', 'c']
