字典：无序的，可变的键值对集合，字典是另一种可变容器模型，且可存储任意类型对象
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
# d = {key1 : value1, key2 : value2 }
# 键必须是唯一的，但值则不必。
# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
1 info = {"name": "cq", "age": 18, "class": "first"}
2 print(info, type(info))
3 print(info['name'])
4 print(info['age'])
输出结果:
{'name': 'cq', 'age': 18, 'class': 'first'} <class 'dict'>
cq
18
# 方式2
# Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
# fromkeys()方法语法：
# dict.fromkeys(seq[, value])
# 参数：
# seq -- 字典键值列表。
# value -- 可选参数, 设置键序列（seq）的值。
# 返回值：
# 该方法返回一个新字典
# fromkeys:是一个静态方法，类和对象都可以调用
1 seq = ("name", "age", "class")
2 dic = dict.fromkeys(seq)
3 print("新字典为:: ", dic)
4
5 dic = dict.fromkeys(seq, 10)
6 print("新的字典为:: ", dic)
7
8 dic = dict.fromkeys([1, 2, 3], 20)
9 print("新的字典:: ", dic)
输出结果：
新字典为:: {'name': None, 'age': None, 'class': None}
新的字典为:: {'name': 10, 'age': 10, 'class': 10}
新的字典:: {1: 20, 2: 20, 3: 20}
# 字典定义的注意事项
1：key不能被重复 如果重复了，后值会把前值覆盖掉
1 dic = {1: "a", 2: "b", 1: "c"} 2 print(dic)
输出结果:
{1: 'c', 2: 'b'}
2：key必须是任意不可变类型
Python字典的实现原理
# 字典类型是Python中最常用的数据类型之一，它是一个键值对的集合，字典通过键来索引，关联到相对的值
# 理论上它的复杂度是O(1)
# 那么dict的内部实现原理是什么呢？
# 在Python中，字典是通过哈希表实现的。
# 哈希表(hash tables)也叫散列表，根据关键值对(Key-value)而直接进行访问的数据结构。它通过把key和value
# 映射到表中的一个位置来访问记录，这种查询速度非常快，更新也快。而这个映射函数叫做哈希函数，存放值的数组叫做
# 哈希表，哈希函数的实现方式决定了哈希表的搜索效率，具体实现过程是：
# 1：数据添加：把key通过哈希函数转换成一个整型数字，然后就将这个整型数字对数组长度进行取余，取余结果就当做数组
# 的下标，将value存储在以该数字为下标的数组空间里
# 2：数据查询：再次使用哈希函数将key转换为对应的数组下标，并定位到数组的位置获取value
# 但是,对key进行hash的时候,不同的key可能hash出来的结果是一样的,尤其是数据量增多的时候这个问题叫做哈希冲突
# 如果解决这种冲突情况呢?通常的做法有两种,一种是链接法,另一种是开放寻址法,Python选择后者
# 开放寻址法中,所有的元素都存放在散列表中,当产生哈希冲突然时,通过一个探测函数计算出下一个候选位置,如果下一个获选
# 位置还是有冲突,那么不断的通过探测函数往下找,直到找到一个空槽来存放插入元素
字典的常用操作
# 增加操作
# dict[key] = value
# 当key在原字典中不存在的时候，即为新增操作
1 dic = {"name": "xq", "age": 18}
2 print(dic, id(dic))
3
4 dic["height"] = 180
5 print(dic, id(dic))
输出结果：
{'name': 'xq', 'age': 18} 31652432
{'name': 'xq', 'age': 18, 'height': 180} 31652432
# 删除操作
# del dic[key]
# key必须存在，否则就会报一个keyerror的一个错误
1 dic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
2 # 删除单个元素
3 del dic['Name']
4 print("删除Name关键字:: ", dic)
5
6 # 删除字典
7 del dic
8 # print(dic) 此时再打印访问字典就会报错，dic is not defined
输出结果：
删除Name关键字:: {'Age': 7, 'Class': 'First'}
# 字典clear()方法
# clear()是清空字典内的所有元素的，返回值为None
# 注意：字典本身还存在，只是字典里的内容被清空，注意和del的区别
1 dic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
2 returnValue = dic.clear()
3 print("returnValue:: ", returnValue)
输出结果：
returnValue:: None
# 字典的clear()有什么特点呢？
1 dic = {"name": "xq", "sex": "female", "age": 18}
2 dic1 = dic
3 dic.clear()
4 print("dic:: ", dic)
5 print("dic1:: ", dic1)
6 # 可以发现当原字典dic被引用时，想清空原字典中的元素，用clear()方法，dic1字典中的元素也同时被清除了。
输出结果：
dic:: {}
dic1:: {}
# 字典pop()方法 dic.pop(key[, default])
# 移除字典数据pop()方法的作用是：删除指定给定键所对应的值，返回这个值并从字典中把它移除。
# 注意字典pop()方法与列表pop()方法作用完全不同。
1 dic = {"a": 1, "b": 2}
2 result = dic.pop("a")
3 print("result:: ", result)
4 print("dic:: ", dic)
5 # 如果给定的key不存在，则返回给定的默认值，如果没有给定默认值，则报错
6 dic = {"a": 1, "b": 2}
7 result = dic.pop("a1", 666)
8 print("result:: ", result)
9 # dic.pop("a1") 会报错
输出结果：
result:: 1
dic:: {'b': 2}
result:: 666
# 字典popitem()方法
# Python 字典 popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
# 如果字典已经为空，却调用了此方法，就报出KeyError异常。
1 dic = {"name": "xq", "sex": "female", "age": 18}
2 result = dic.popitem()
3 print("result:: ", result)
4 print("dic:: ", dic)
输出结果：
result:: ('age', 18)
dic:: {'name': 'xq', 'sex': 'female'}
# 字典修改操作
# 只能修改值，而不能修改key
# 修改单个键值对：
# dic[key] = value
# 直接设置，如果key不存在，则新增，如果存在，则修改
1 dic = {"name": "xq", "age": 18}
2 dic["age"] = 21
3 print("修改后的字典为:: ", dic)
输出结果：
修改后的字典为:: {'name': 'xq', 'age': 21}
# 批量修改键值对
# oldDic.update(newDic)
# 根据新的字典，批量更新旧字典中的键值对
# 如果旧字典中没有对应的key值，则新增键值对
1 oldDic = {"name": "xq", "age": 18}
2 newDic = {"age": 21, "address": "beijing"}
3 oldDic.update(newDic)
4 print("更新后字典为:: ", oldDic)
输出结果：
更新后字典为:: {'name': 'xq', 'age': 21, 'address': 'beijing'}
# 字典的查找操作
# 1:获取单个值的情况
# 方式1: dic[key]
# 如果key不存在则会报错
dic = {"name": "xq", "age": 18}
print(dic["age"])
# 方式2:
# dict.get(key, default=None)
# 参数:
# key -- 字典中要查找的键。
# default -- 如果指定键的值不存在时，返回该默认值值。
# Python 字典 get() 函数返回指定键的值，如果值不在字典中返回默认值
1 dic = {"name": "xq", "age": 18, "address": "beijing"}
2 v = dic.get("age")
3 print("v的返回值:: ", v)
4 result = dic.get("class", 666)
5 print(result, dic)
输出结果：
v的返回值:: 18
666 {'name': 'xq', 'age': 18, 'address': 'beijing'}
# 方式3:
# dict.setdefault(key, default=None)
# 参数:
# key -- 查找的键值。
# default -- 键不存在时，设置的默认键值。
# Python 字典 setdefault() 方法和get()方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
1 dic = {"name": "xq", "age": 18, "address": "beijing"}
2 res = dic.setdefault("age")
3 print("res的返回值:: ", res)
4 result = dic.setdefault("class", 666)
5 print(result, dic)
输出结果：
res的返回值:: 18
666 {'name': 'xq', 'age': 18, 'address': 'beijing', 'class': 666}
# 查询所有的值
# 查询所有的键
# 查询所有的键值对
# Python 字典 values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
# 注意：Python2.x 是直接返回列表
# 语法
# dict.values()
# 返回值:
# 返回迭代器。
1 dic = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
2 print("字典所有值为::", list(dic.values()))
输出结果：字典所有值为:: ['female', 7, 'Zara']
# Python3 字典 keys() 方法返回一个迭代器，可以使用 list() 来转换为列表。
# 注意：Python2.x 是直接返回列表
# keys()方法语法：
# dict.keys()
# 返回值：
# 返回一个迭代器
1 dic = {"name": "xq", "age": 18, "address": "beijing"}
2 print("字典所有的key值:: ", list(dic.keys()))
输出结果为：字典所有的key值:: ['name', 'age', 'address']
# Python 字典 items() 方法以列表返回可遍历的(键, 值) 元组数组。
# 注意：Python2.x 是直接返回列表
# items()方法语法：
# dict.items()
# 返回值:
# 返回可遍历的(键, 值) 元组数组
1 dic = {"name": "xq", "age": 18, "address": "beijing"}
2 print("字典的所有键值对:: ", dic.items())
3
4 for i, j in dic.items():
5 print(i, " :", j)
输出结果：
字典的所有键值对:: dict_items([('name', 'xq'), ('age', 18), ('address', 'beijing')])
name : xq
age : 18
address : beijing
# 另外，这几个函数，Python2.x与Python3.x是有一定区别的，请看代码
Python2.x版本下
1 dic = {"name": "xq", "age": 18, "address": "beijing"}
2
3 # 获取所有的值
4 vs = dic.values()
5
6 # 获取所有的key值
7 ks = dic.keys()
8
9 # 获取所有的键值对
10 its = dic.items()
11
12 print(dic)
13 print(vs)
14 print(ks)
15 print(its)
16
17 # 此时字典增加一项
18 dic["sex"] = "female"
19
20 print(dic)
21 print(vs)
22 print(ks)
23 print(its)
输出结果：
{'age': 18, 'name': 'xq', 'address': 'beijing'}
[18, 'xq', 'beijing']
['age', 'name', 'address']
[('age', 18), ('name', 'xq'), ('address', 'beijing')]
{'age': 18, 'sex': 'female', 'name': 'xq', 'address': 'beijing'}
[18, 'xq', 'beijing']
['age', 'name', 'address']
[('age', 18), ('name', 'xq'), ('address', 'beijing')]
Python3.x版本下的
1 dic = {"name": "xq", "age": 18, "address": "beijing"}
2
3 # 获取所有的值
4 vs = dic.values()
5
6 # 获取所有的key值
7 ks = dic.keys()
8
9 # 获取所有的键值对
10 its = dic.items()
11
12 print(dic)
13 print(vs)
14 print(ks)
15 print(its)
16
17 # 此时字典增加一项
18 dic["sex"] = "female"
19
20 print(dic)
21 print(vs)
22 print(ks)
23 print(its)
输出结果：
{'name': 'xq', 'age': 18, 'address': 'beijing'}
dict_values(['xq', 18, 'beijing'])
dict_keys(['name', 'age', 'address'])
dict_items([('name', 'xq'), ('age', 18), ('address', 'beijing')])
{'name': 'xq', 'age': 18, 'address': 'beijing', 'sex': 'female'}
dict_values(['xq', 18, 'beijing', 'female'])
dict_keys(['name', 'age', 'address', 'sex'])
dict_items([('name', 'xq'), ('age', 18), ('address', 'beijing'), ('sex', 'female')])
看打印的结果可以看出：Python2.x版本下，所有的键、值和键值对结果都是以列表形式呈现的，而Python3.x版本下面都是迭代器形式呈现，而且当我们
往字典里面增加键值对的时候，Python2.x版本下面并不会把新增的键值对放到我们所获取的键、值和键值对里面，Python3.x则不是。
# 遍历
# 1:先遍历所有的key，然后根据key获取对应的值
dic = {"name": "xq", "age": 18, "address": "北京"}
# 先获取所有的keys
keys = dic.keys()
# 遍历所有的keys
for key in keys:
print(key, " :", dic[key])
# 2:直接遍历所有的键值对
dic = {"name": "xq", "age": 18, "address": "北京"}
for x,y in dic.items():
print(x, " :", y)
dic = {"name": "xq", "age": 18, "address": "北京"}
# 计算
# len(info)
# 计算键的个数
print(len(dic))
# 判定
# x in dic
# 判定dic中的key，是否存在x
print("name" in dic)
# x not in dic
# 判定dic中的key,是否不存在x
print("name" not in dic)
# dic.has_key(key)
# 已经过期，建议使用in来代替，Python2.x还可以使用