Python字典

描述：Python字典是另一种可变容器模型，且可存储任意类型对象，如字符串，数字，元组等其他容器模型。

创建字典
字典是由键和对应值成对组成。（也称“键值对”）字典也被称作关联数组或哈希表。
例：

dict = {'donot':'789','please':'552','Yes':'741'}

也可以：

dict0 = {'abc':456}
dict1 = {'qwe':130,3.14:5687}

注意：

1. 每个键与值用冒号隔开
2. 每个键值对间用逗号隔开
3. 整体放在花括号中
4. 键必须独一无二，相同时会被覆盖，但是值不必
5. 键必须是不变的，如字符串，数字或元组，但是值没有限制

字典中的增删改查
例：dict = {"name":"ahong","age":15,"sex":"男"}

1. 增

dict = {"name":"ahong","age":15,"sex":"男"}
dict["tel"] = 121#末尾追加
print(dict)

2. 删

dict = {"name":"ahong","age":15,"sex":"男"}
dict.pop("name")#使用pop删除
#del dict["age"]#直接用del删
print(dict)
#删除整个字典 del dict

3. 改

dict = {"name":"ahong","age":15,"sex":"男"}
dict.update({"age":'18'})#更新
#dict["age"] = 18#覆盖
print(dict)

4. 查

dict = {"name":"ahong","age":15,"sex":"男"}
print(dict["name"])#直接查键即可

dict中的方法

dict = {"name":"ahong","age":15,"sex":"男"}

print(dict.keys())#所有键
print(dict.values())#所有值
print(dict.items())#所有键值对
print(dict.get("name"))#取值
print(dict.pop("name"))#删除
dict.update({"name":'aqiu',"age":11})#更新，如果输入的键不存在，则在末尾添加
gs = dict.copy()#复制
dict.clear()#清空
dict.popitem()#删除最后一个键值对

简单查看
dict = {"name":"ahong","age":15,"sex":"男"} for key,value in dict.items(): print(key,value)
Python2中存在无序字典，Python3.X中自动按照存储顺序打印出来，但存储的都是无序的，而不是乱序。

让字典的键对应多个值

dict={"name":['lhy','ahong']}

也可以选择更优雅的方法，使用collections模块中的defaultdict来构造这样的字典，defaultdict的一个特征是他会自动初始化每个key刚开始对应的值。

from collections import defaultdict
d = defaultdict(list)
d['name'].append("lhy")
d['name'].append("ahong")
print(d)
print('--------------------')
print(d.get('name'))

字典中的内置函数

len(dict)			#计算字典元素的个数，即键的总数
str(dict)			#输出字典可打印的字符串表示
type(variable)		#返回输入的变量类型，如果变量是字典就返回字典类型

判断字典中key是否存在的

dict = {"name":"ahong","age":15,"sex":"男"}
print('name' in dict.keys())

Python字典按照value进行排序
例：d = {‘a’:1,‘b’:4,‘c’:2}
按照value进行排序：
#方法一：内置排序

d = {'a':1,'b':4,'c':2}
ds = sorted(d.items(),key = lambda x:x[1],reverse = False)
print(ds)

或

d = {'a':1,'b':4,'c':2}
import operator
ds = sorted(d.items(),key = operator.itemgetter(1),reverse=True)
#倒叙reverse=True
print(ds)

或
利用OrderedDict和sorted()内置函数对已有的字典进行排序

from collections import OrderedDict
d = {'a':1,'b':4,'c':2}
d = OrderedDict(sorted(d.items(),key=lambda item: item[1]))
print(d)

zip

d = {'a':1,'b':4,'c':2}
f = zip(d.values(),d.keys())
ds = sorted(f)
print(ds)

按照key进行排序：

d = {'a':1,'c':2,'b':4}
import operator
ds = sorted(d.items(),key = operator.itemgetter(0))
print(ds)

d = {'a':1,'c':2,'b':4}
ds = sorted(d.items(),key = lambda x:x[0])
print(ds)

d = {'a':1,'c':2,'b':4}
from collections import OrderedDict
ds = OrderedDict(sorted(d.items(),key=lambda item: item[0]))
print(ds)

d = {'a':1,'c':2,'b':4}
f = zip(d.keys(),d.values())
ds = sorted(f)
print(ds)

若键值为元组，则仍旧按照自然顺序，例：
before： (1,3)(1,2)(2,3)
after： (1,2)(1,3)(2,3)
如果键或值的类型不统一，则无法排序。

dict存储和查找的具体实现过程

正常想要获取dict中的值，首先要知道key通过dict[key]获取对应的value，在散列表中为了达到这种操作，
首先会计算key的hash值即散列值，把这个值最低的几位数字当作偏移量，在散列表里查找表元（具体取几位，得看当前散列表的大小）。
若找到表元为空，异常KeyError，不为空，表元里会有一对found_key:found_value。
这时候 Python 会检验 search_key == found_key 是否为真，如果它们相等的话，就会返回 found_value。如果两个值不匹配，则是散列冲突。
而散列表本身的索引又只依赖于这个数字的一部分。
为了解决散列冲突，算法会在散列值中另外再取几位，然后用特殊的方法处理一下，把新得到的数字再当作索引来寻找表元。
若这次找到的表元是空的，则同样抛出 KeyError；若非空，或者键匹配，则返回这个值；或者又发现了散列冲突，则重复以上的步骤。