Python 字典 【5】

一、 字典

1 映射类型数据结构介绍

• 在字典存放的每个元素都是以一对儿键值对。
• 在 Python 中 字典通常被称为 dict，键 称为 key，值称为 value
• 字典中不可以存在相同的 key，但是 value 可以

>>> b = {}  创建空字典
>>> type(b)
<class 'dict'>  类型 dict
>>> 
>>> a = {1:2,1:3}  键是唯一的 只能返回一个  返回最后一个
>>> a
{1: 3}

>>> b = {1:'we','er':'fd'}
>>> b
{1: 'we', 'er': 'fd'}

dict() 字典的类型  同样可以转化为字典
>>> d_tpl = [('a','1'),('b','2'),('c','3')] 
>>> dict3 = dict(d_tpl)
>>> dict3
{'a': '1', 'b': '2', 'c': '3'}

>>> d_tpl2 = ['a1','b2','c3']
>>> dict4 = dict(d_tpl2)
>>> dict4
{'a': '1', 'b': '2', 'c': '3'}
>>> dict3 is dict4
False
>>> dict3 == dict4
True
>>> id(dict3)
140424213285296
>>> id(dict4)
140424213284976
>>> 

2 哪些数据可以作为字典的 kye   key 通常是 字符串  它可以是 Python 中任意不可变类型

总之字典的kye 不可更改 属于不可变得 列表相对可变不可作为字典的key

比如  布尔型 True 1 False 0  整型  1  6  浮点型 1.0  元组 （1, 2, 3）字符串

关于字典的 key

在 Python 内部用一个哈希表来维护字典中的 key 到 value 的映射关系。

所以 key 必须是可哈希的。判断一个对象是否可哈希，可以使用 hash() 函数

返回一个整数，就是可哈希，反之会抛出 TypeError 异常

>>> hash(3)   可以
3
>>> hash('ewe')
6569464819370180438
>>> hash((1,2))
3713081631934410656
>>> hash([1, 2])   不可以 [1, 2] s是一个列表可以更改
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> 

获取 key 对应的 value      获取字典所有的 key       获取字典所有的 value

d1 = {'a': 1, 'b': 2}
d1['a']        # key 必须存在，不存在，抛出异常    

d1.get('a')    # 获取到 'a' 对应的值(value)

d1.get('c')    # key 不存在字典中，则返回 None

d1.get('c', '5')  # key 不存在，返回指定的 value


>>> d1.keys()  获取键
dict_keys(['a', 'b'])
>>> b = d1.keys()
>>> b
dict_keys(['a', 'b'])
>>> list(b)  转化为列表 
['a', 'b']


>>> d1.values()  获取值
dict_values([1, 2])
>>> b = list(d1.values())
>>> b
[1, 2]
>>> b = d1.values()
>>> b
dict_values([1, 2])
>>> 

同时获取字典的 key 和 value
>>> d1.items()
dict_items([('a', 1), ('b', 2)])
>>> list(d1.items())
[('a', 1), ('b', 2)]
>>> b = list(d1.items())

循环字典的 key 和 value

>>> a,b = [1,2]
>>> a
1
>>> b
2
>>> a,b=[('a', 1), ('b', 2)]
>>> a
('a', 1)
>>> b
('b', 2)
>>> for k ,v in d1.items():
...     print(k, v)
... 
a 1
b 2

使用 = 修改或更新字典

可以使用 等号 对字典的 key 进行直接赋值操作。

假如 key 不存在与字典中，这个 key 和 对应值也会被创建到字典中。

In [50]: d5 = {}

In [51]: d5['a'] = 1

In [52]: d5['b'] = 2

In [53]: d5
Out[53]: {'a': 1, 'b': 2}

In [54]: d5['li'] = [1,3,5]

In [55]: d5
Out[55]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}

>>> d1
{'a': 1, 'b': 2, 'c': 3}
>>> d1['a'] = 3
>>> d1
{'a': 3, 'b': 2, 'c': 3}

 使用 update() 更新字典

把一个已经存在的字典中的键值对，添加到另一个字典中。
In [59]: d5
Out[59]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}

In [60]: d6 = {'a': 2,'d': 2,'e': 5}

In [61]: d5.update(d6)

In [62]: d5
Out[62]: {'a': 2, 'b': 2, 'd': 2, 'e': 5, 'li': [1, 3, 5]}

注意： 更新时，相同的 key ，它的值会被新的值替代，这个特性同样适用与 = 号方式的

python3.5+
>>> x = {'a': 1, 'b': 2}
>>> y = {'c': 1, 'd': 2}
>>> z = {**x,**y}
>>> z
{'a': 1, 'b': 2, 'c': 1, 'd': 2}

in 成员判断

>>> z
{'a': 1, 'b': 2, 'c': 1, 'd': 2}
>>> 'a' in z
True
>>> 'a' in z.keys()
True
>>> 'g' in z.keys()
False
>>> 

删除和清空字典

dict_obj = {'a': 1}
del  dict_obj['a']  # 从字典中删除指定 key 的键值对
del  dict_obj       # 删除字典本身，字典自身就不存在于内存中了
>>> z
{'a': 1, 'b': 2, 'c': 1, 'd': 2}
>>> del z['a']
>>> z
{'b': 2, 'c': 1, 'd': 2}
>>> del z
>>> z
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'z' is not defined
>>> 
>>> z= {1:2,3:4}
>>> z.clear()
>>> z
{}                 # 字典本身还在内存中，只是内容没了

 

pop()

从字典中删除指定 key 的键值对，并返回这个 key 对应的值

In [49]: d6 = {'b': 2, 'c': '3', 'd': 'new key', 'li': [1, 3, 5]}

In [50]: li = d6.pop('li')
    
In [51]: print(li)
Out [51]: [1, 3, 5]

用字典实现 switch … case 语句

Python 中没有 switch … case 语句，这个问题Python之父龟叔表示这个语法过去没有，现在没有，以后也不会有。因为Python简洁的语法完全可以用 if … elif 实现。如果有太多的分支判断，还可以使用字典来代替。

arg = input(">>:")

if arg == "0":
    print('zero')
elif arg == "1":
    print('one')
elif arg == "2":
    print("two")
else:
    print("nothing")

可以用字典来实现这个更简洁

data = {
    "0": "zero",
    "1": "one",
    "2": "two",
}

while True:
    a = input("请输入")
    b = data.get(a,"nothing")
    print(b)
~