字典类型（dict）
字典数据类型介绍
字典键值对的增加
字典键值对的删除
字典键值对的修改
字典键值对的查看
字典键的特性
字典的嵌套
字典的内置方法
解构（解包）和封装
一、字典数据类型介绍
字典是Python中唯一的一个映射类型，它是以 { } 扩起来的键值对组成的{key:value}；在字典中key是唯一的，在保存的时候，根据key来计算出一个内存地址，然后将key-value保存在这个地址中，这种算法被称为hash算法，所以，切记，在dict中存储的key-value中的key必须是可hash的；
字典是一个可变的无序的可以存储任何类型的类型；
字典中的key都必须是可哈希的，不可变的数据类型；
字典中的值没有限制，可以是任何数据类型；
一个简单的字典实例：
>>> dic = {"name":"zjk","age":18}
二、字典键值对的增加
字典中的键值对增加有两个基本方式：dict[key] = value dict.setdefault(key,value)
1.dict[key] = value
实例：
>>> dic = {"name":"zjk","age":18}
>>> dic["like"] = [1,2,3]
>>> print(dic)
{'name': 'zjk', 'age': 18, 'like': [1, 2, 3]}2.dict.setfefault(key,value)
说明：如果键在字典中存在不进行任何操作,否则就添加；
实例：
>>> dic = {"name":"zjk","age":18}
>>> dic.setdefault("home","wuan")
'wuan'
>>> print(dic)
{'name': 'zjk', 'age': 18, 'home': 'wuan'}
三、字典键值对的删除
删除键值对的四种方法：pop(key)，del dic[key]、popitem()、clear()
1.dict.pop(key)
说明：删除键值对，有返回值，返回的是被删除的key的value；
>>> dic = {"name":"zjk","age":18}
>>> a = dic.pop("age")
>>> print(a,dic)
18 {'name': 'zjk'}2.del dict[key]
说明：通过key删除
实例：
>>> dic = {"name":"zjk","age":18}
>>> del dic["name"]
>>> print(dic)
{'age': 18}3.dict.popitem()
说明：随机删除，默认删除最后一个，（还在测试中）
实例：
>>> dic = {"name":"zjk","age":18}
>>> dic.popitem()
('age', 18)
>>> print(dic)
{'name': 'zjk'} >>> dic = {"name":"zjk","age":18}
>>> a = dic.popitem()
>>> print(dic,a)
{'name': 'zjk'} ('age', 18)
4.dic.clear()
说明：清空字典；
实例：
>>> dic = {"name":"zjk","age":18}
>>> dic.clear()
>>> print(dic)
{}
四、字典键值对的修改
修改字典两种方法：dic[key] = value dic.update(字典)
1.dic[key] = value
实例：
>>> dic = {"name":"zjk","age":18}
>>> dic["name"] = "lalala"
>>> print(dic)
{'name': 'lalala', 'age': 18}2.dic.update(字典)
说明：将一个字典导入到另一个字典中，新的数据会覆盖旧的数据；
实例：
>>> dic = {"name":"zjk","age":18}
>>> dic1 = {"home":"wuan","age":23,"high":"66666"}
>>> dic.update(dic1)
>>> print(dic)
{'name': 'zjk', 'age': 23, 'home': 'wuan', 'high': '66666'}
五、字典键值对的查看
查看字典的几种方法：for循环、dic[key]、get(key)、setfault(key)
1.for循环
实例：
>>> dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
>>> for n in dic:
... print(n)
...
a
b
c
d
e
>>> for n in dic.values():
... print(n)
...
1
2
3
4
5
>>> for n in dic.items():
... print(n)
...
('a', 1)
('b', 2)
('c', 3)
('d', 4)
('e', 5)2.dict[key]
说明：如果key在字典中存在，则返回对应key的value值，如果key不存在，则报错；
实例：
>>> dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
>>> print(dic["a"])
1
>>> print(dic["b"])
2
>>> print(dic["aaa"])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'aaa'3.dict.get(key，default=None)
说明：返回指定键的值，如果值不在字典中则返回default值；
实例：
>>> dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
>>> print(dic.get("a"))
1
>>> print(dic.get("aaa"))
None
>>> print(dic.get("aaa","66666"))
666664.dict.setfault(key，dafault)
说明：和get类似，如果键存在的话返回键对应的值，但如果键不存在的话，将会在字典中添加键并将值设为default；
实例：
>>> dic = {"a":1,"b":2,"c":3,"d":4,"e":5}
>>> print(dic.setdefault("a","888"))
1
>>> print(dic.setdefault("aaaa","888"))
888
>>> print(dic)
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'aaaa': '888'}
六、字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行；
不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
>>> dic = {"a":1,"b":2,"c":3,"a":4}
>>> print(dic["a"])
4
七、字典键的嵌套
字典里可以无限嵌套，字典也可以嵌套字典：
dic = {
'name':'汪峰',
'age':43,
'wife':{
'name':'国际章',
'age':39,
'salary':100000
},
'baby':[
{'name':'熊大','age':18},
{'name':'熊二','age':15},
]
}
八、字典键的内置方法
1.clear(self)
说明：用于删除字典内所有元素，清空字典；
语法：dict.clear()
实例：
>>> dic = {"a":1,"b":2,"c":3}
>>> dic.clear()
>>> print(dic)
{}
2.copy(self)
说明：返回一个字典的浅复制，将字典进行复制；
语法：dcit.copy()
返回值：返回一个字典的浅复制；
实例：
>>> dic = {"name":"zjk","age":23}
>>> dic1 = dic.copy()
>>> print(dic1)
{'name': 'zjk', 'age': 23}
3.fromkeys(*args, **kwargs)
说明：用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值；
语法：dict.fromkeys(*args, **kwargs)
返回值：该方法返回字典；
实例：
>>> li = ["name","age","like"]
>>> a = dict.fromkeys(li,"666")
>>> print(a)
{'name': '666', 'age': '666', 'like': '666'}
>>> print(type(a))
<class 'dict'>需要注意的是，由fromkeys生成的新字典中，所有的key都是共享的一个value，如果所这个被共享的value是一个可变类型，
1.----------------- 当共享的value是一个可哈希的数据类型时，该字典中的某个key的值被修改，不会影响其他key的value--------------------
>>> li = ["name","age","like"]
>>> a = dict.fromkeys(li,"666")
>>> a
{'name': '666', 'age': '666', 'like': '666'}
>>> a["age"] = "777"
>>> a
{'name': '666', 'age': '777', 'like': '666'}
2.----------------当共享的value是一个可变的数据类型时，该字典中的某个key的值被修改后，其他key的值都会被修改 ----------------------------
>>> li1 = ["name","age","like"]
>>> a = dict.fromkeys(li,[111,222])
>>> a
{'name': [111, 222], 'age': [111, 222], 'like': [111, 222]}
>>> a["like"].append(333)
>>> a
{'name': [111, 222, 333], 'age': [111, 222, 333], 'like': [111, 222, 333]}
那么，如果其中有个key的值进行了改变，那么该字典中所有的value都会被改变；
例如：
4.get(self, k, d=None)
说明：返回指定键的值，如果值不在字典中返回默认值。默认值为None；
语法：dict.get(key,default=None)
参数：key ------> 字典中要查找的键；
default ------> 如果指定的值不存在，返回该默认值；
返回值：返回指定键的值，如果值不在字典中返回默认值 None；
实例：
>>> dic = {"name":"zjk","age":23}
>>> print(dic.get("name"))
zjk
>>> print(dic.get("name11"))
None
>>> print(dic.get("name11","888"))
888
5.items(self)
说明：以列表形式返回可遍历的(键, 值) 元组数组；
dict.items()
返回值：返回可遍历的(键, 值) 元组数组；
实例：
>>> dic = {"name":"zjk","age":23}
>>> print(dic.items())
dict_items([('name', 'zjk'), ('age', 23)])
操作符
说明： in 操作符用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false。
key in dict
参数：key -------> 要在字典中查找的键；
返回值：如果键在字典里返回true，否则返回false；
实例：
>>> dic = {"name":"zjk","age":23}
>>> if "name" in dic:
... print(666)
... else :
... print(111)
...
666
>>> if "hahaha" in dic:
... print(666)
... else :
... print(111)
...
111
7.keys(self)
说明：以列表返回一个字典所有的键；
dict.keys()
返回值：返回一个字典所有的键。
实例：
>>> dic = {"name":"zjk","age":23}
>>> print(dic.keys())
dict_keys(['name', 'age'])
8.pop(self, k, d=None)
说明：删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
语法：dict.pop(k, d=None)
参数：key ----------> 要删除的键值；
default -------> 如果没有key，返回default值
返回值：返回被删除的value值
实例：
>>> dic = {"name":"zjk","age":23}
>>> a = dic.pop("age")
>>> print(dic,a)
{'name': 'zjk'} 23
>>>
>>> dic = {"name":"zjk","age":23}
>>> print(dic.pop("aaaaa","666"))
666
9.popitem(self)
说明：随机返回并删除字典中的一对键和值(一般删除末尾对)；如果字典已经为空，却调用了此方法，就报出KeyError异常；
语法：dcit.popitem()
返回值：返回一个键值对(key,value)形式。是一个元组类型；
实例：
>>> dic = {"name":"zjk","age":23}
>>> b = dic.popitem()
>>> print(dic,b)
{'name': 'zjk'} ('age', 23)>>> dic = {}
>>> b = dic.popitem()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'
10.setdefault(self, k, d=None)
说明：setdefault() 方法和get()方法类似, 如果键不已经存在于字典中，将会在字典中添加键并将值设为默认值。
dict.setdefault(key,default=None)
参数：key -----------> 查找的键值；
default -------> 键不存在时，设置的默认键值；
返回值：如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。
实例：
>>> dic = {"name":"zjk","age":23}
>>> print(dic.setdefault("name"))
zjk
>>> print(dic.setdefault("aaaaa"))
None
>>> print(dic.setdefault("bbbbb","6666"))
6666
>>> print(dic)
{'name': 'zjk', 'age': 23, 'aaaaa': None, 'bbbbb': '6666'}
11.update(self, E=None, **F)
说明：把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里，如果有相同的键值进行替换；
dict.update(dict2)
参数：dict2 -----> 添加到指定字典dict里的字典。
实例：
>>> dic = {"name":"zjk","age":23}
>>> dic1 = {"a":1,"b":2,"age":18}
>>> dic.update(dic1)
>>> print(dic)
{'name': 'zjk', 'age': 18, 'a': 1, 'b': 2}
12.values(self)
说明：以列表返回字典中的所有值；
dict.values()
返回值：返回字典中的所有值；
实例：
>>> print(dic)
{'name': 'zjk', 'age': 18, 'a': 1, 'b': 2}
>>> print(dic.values())
dict_values(['zjk', 18, 1, 2])
九、解构（解包）和封装
元素在左边是解构，元素在右边是封装；
封装的定义：将多个值使用逗号分隔，组合在一起；本质上返回一个元组，只是省略了小括号；Python特有语法，被很多语言学习和借鉴；
解构的定义：按照元素顺序，把线性解构的元素，赋值给变量；
Python3中的解构变化：
通过使用星号 * 加上变量，可以接受所有元素；
不能单一的使用星号作为变量接收，如果可以，相当于lst[0:0]
同一个解构中，只能使用一个星号；
当左边变量超过右边元素个数的时候，是不允许的；
两大用法：
对称性赋值：
对称性赋值在很多情况下被称为解构，其实只是解构的一小部分；
把线性结果（包括字典和list等）的元素解开，并按顺序赋值给其他变量；
左边接收的变量数要和右边解开的元素个数一致；
通常用在x,y = y,x 相当于将y,x先封装为一个元组(y,x),等价于x,y = (y,x)，然后依据位置参数进行依次赋值。
简化添加类型：
极大的简化了“添加”的类型，比如结合字典，并且以明确的方式进行：
例如：
实例：
>>> a,b = 1,2
>>> print(a,b)
1 2
>>> a,b = (1,2)
>>> print(a,b)
1 2
>>> a,b = [1,2]
>>> print(a,b)
1 2
>>> a,b = {1,2}
>>> print(a,b)
1 2
>>> a,b = {"a":1,"b":2}
>>> print(a,b)
a b
>>>
>>>
>>>
>>> a,*b = {1,2,3}
>>> print(a,b)
1 [2, 3]
>>> a,*b,c = {1,2,3,4,5,6,7,8}
>>> print(a,b,c)
1 [2, 3, 4, 5, 6, 7] 8
