字典 DICTIONARY

字典  DICTIONARY

定义：

是一系列键值对，每个键都与一个值相关联。

别名：哈希表、关联数组。

键：

一个对象能不能作为字典的key，就取决于其有没有__hash__方法。所以所有python自带类型中，除了list、dict、set和内部至少带有上述三种类型之一的tuple之外，其余的对象都能当key。

数值/字符串/完全不可变的元祖/函数(内建或自定义)/类(内建或自定义)/方法/包等等都可以，不过有的实际意义不高

两个不同的相等数字可以有相同的哈希值，比如1和1.0。

print(hash(1))               #out: 1
print(hash(1.0))             #out: 1
print(hash('1'))             #out:3261292616000953093
print(hash('1.0'))           #out:5308054082424683454
print(hash((1,2)))           #out:3713081631934410656
#print(hash([1,2]))          #out:TypeError: unhashable type: 'list'
#print(hash({1:2,3:4}))      #out:TypeError: unhashable type: 'dict'
set_1 = set([1,2])
#print(hash(set_1))          #out:TypeError: unhashable type: 'set'
#print(hash((1,[2,3])))      #out:TypeError: unhashable type: 'list'

值：

任何数据类型都可以做值。

创建：

参考：https://www.cnblogs.com/xujiu/p/8352608.html

#创建一个空字典
empty_dict = dict() 
print(empty_dict)

#用**kwargs可变参数传入关键字创建字典
a = dict(one=1,two=2,three=3) 
print(a)

#传入可迭代对象
b = dict(zip(['one','two','three'],[1,2,3]))
print(list(zip(['one','two','three'],[1,2,3])))
print(b)

#传入可迭代对象 
c = dict([('one', 1), ('two', 2), ('three', 3)])
print(c)

c1 = dict([('one', 1), ('two', 2), ('three', 3),('three', 4),('three', 5)])
print(c1)#如果键有重复，其值为最后重复项的值。 


#传入映射对象，字典创建字典  
d = dict({'one': 1, 'two': 2, 'three': 3}) 
print(d) 

print(a == b == c == d)


输出：

{}
{'one': 1, 'two': 2, 'three': 3}
[('one', 1), ('two', 2), ('three', 3)]
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 5}
{'one': 1, 'two': 2, 'three': 3}
True

查：

dict[key]

如果key在字典中，则返回值。否则会报错

dict_1 = dict([('a',1),('b',2),('c',3)])
print(dict_1['a'])                            #out:1
print('d' in dict_1)                          #out:False
print(dict_1['d'])                            #out:KeyError: 'd'

访问所有的键、值、键值对。

dict_1 = dict([('a',1),('b',2),('c',3)])
print(dict_1.keys())                       #out: dict_keys(['a', 'b', 'c'])    
print(dict_1.values())                     #out: dict_values([1, 2, 3])
print(dict_1.items())                      #out: dict_items([('a', 1), ('b', 2), ('c', 3)])

增：

dict[key_new] = value

dict_3 = dict([('a',1),('b',2),('c',3)])
print(dict_3)         #out:{'a': 1, 'b': 2, 'c': 3}
dict_3['d'] = 4
print(dict_3)         #out:{'a': 1, 'b': 2, 'c': 3, 'd': 4}

删：

del dict[key]

dict_3 = dict([('a',1),('b',2),('c',3)])
print(dict_3)         #out:{'a': 1, 'b': 2, 'c': 3}
dict_3['d'] = 4
print(dict_3)         #out:{'a': 1, 'b': 2, 'c': 3, 'd': 4}
del dict_3['a']
print(dict_3)         #out:{'b': 2, 'c': 3, 'd': 4}

改:

dict_3 = dict([('a',1),('b',2),('c',3)])
print(dict_3)         #out:{'a': 1, 'b': 2, 'c': 3}
dict_3['d'] = 4
print(dict_3)         #out:{'a': 1, 'b': 2, 'c': 3, 'd': 4}
del dict_3['a']
print(dict_3)         #out:{'b': 2, 'c': 3, 'd': 4}
dict_3['b'] = 20
print(dict_3)         #out:{'b': 20, 'c': 3, 'd': 4} 

增改：

dict_3 = dict([('a',1),('b',2),('c',3)])
dict_4 = dict(zip(['b','d','a'],[5,6,1]))
dict_6 = dict_3.update(dict_4)
print(dict_3)                          #out:{'a': 1, 'b': 5, 'c': 3, 'd': 6}
print(dict_4)                          #out:{'b': 5, 'd': 6, 'a': 1}
print(dict_6)                          #out:None
dict_3.update(dict_4)  不返回任何数据，也可以说返回None。

 还有另外一种方法

print({**{'a':1,'b':2}, **{'a':3}})
a = {'a':1,'b':2}
b = {'a':3}
a.update(b)
print(a)

遍历：

dict_1 = dict([('a',1),('b',2),('c',3)])
for k_1 in dict_1:       #默认遍历键。
    print(k_1)
print('------分割线------')
for k in dict_1.keys():
    print(k)
print('------分割线------')
for k in dict_1.values():
    print(k)
print('------分割线------')
for key,value in dict_1.items():
    value =  str(value)
    print(key + ':' + value)

结果：

内置函数：

type 、len 、str

dict_1 = dict([('a',1),('b',2),('c',3)])
print(type(dict_1))             #out:<class 'dict'>
print(len(dict_1))              #out:3
str_d = str(dict_1) 
print(type(str_d))             #out:<class 'str'>

 内置方法：

序号	方法	描述
1	dict.get(key,'default')	得到key对应的值，如果无对应的值，返回default
2	dict.fromkeys(seq,value)	创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
3	dict.clear()	清空字典。
4	dict.copy()	返回一个浅复制的字典。
5	dict.pop(key)	弹出key对应的值
6	dict.popitems()	随机返回并删除字典中的一对键和值(一般删除末尾对)。
7	dict.keys()	返回一个键的迭代器，可以使用 list() 来转换为列表
8	dict.values()	返回一个值得迭代器，可以使用 list() 来转换为列表
9	dict.items()	以列表返回可遍历的(键, 值) 元组数组
10	dict.setdefault(key,default = None)	如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。
11	dict_1.update(dict_2)	dict_2中的值更新到dict_1中。如果dict_1中不存在，则增加改键值对。

 

推导式：

dict_1 = dict([('a',1),('b',2),('c',3)])
dict_2 ={key:values**2 for key,values in dict_1.items()}
print(dict_2)         # out:{'a': 1, 'b': 4, 'c': 9}

键值对互换：

可以对应创建字典的四种方法。

a = dict(one=1,two=2,three=3) 
a_1 = {}
for key,value in a.items():
    a_1[value] = key
b = dict(zip(['one','two','three'],[1,2,3]))
b_1 = dict(zip(b.values(),b.keys()))
c = dict([('one', 1), ('two', 2), ('three', 3)])
c_1 = dict([value,key] for key,value in c.items() )
d = dict({'one': 1, 'two': 2, 'three': 3}) 
d_1 = {value:key for key,value in d.items()}
d_2 = dict({value:key for key,value in d.items()})
print(a_1)                                       #out:{1: 'one', 2: 'two', 3: 'three'}
print(a_1 == b_1 == c_1 == d_1 == d_2)           #out: True  

嵌套：

字典列表：字典中嵌套列表，此时可以实现一个键对应一个列表，而一个列表又要多个值。