Python数据结构之字典类型（dict）

字典类型（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"))
66666

　　4.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)])

　　6.in操作符

　　说明： 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