第九天学Python：字典及其常用操作指令

前几天说了列表和元组，今天来讲讲另一个强大的数据类型：
字典
字典，是一个可变的无序集合，是一种以键值对为基本元素的可存储各种数据类型的集合，用大括号“ { } ”来表示，元素之间用逗号分隔。
键值对
键值对由“ 键 ”和“ 值 ”组成，中间由冒号 : 分隔，如：‘K’:18"，这里键为 K，对应值为 18。键值对实现了紧密的一对一关系，所以字典是属于典型的一对一映射关系的数据类型。

test1={} #空字典
test2={'ksy':18}
test3={'aim':'Python',2:}

这里要注意的两点是：
1.一个字典对象里所有的键必须唯一。

>>> test={1:'A',2:'B',2:'C',2:'D'}
>>> print(test)
{1: 'A', 2: 'D'}

可见，在字典里相同键的键值对只会保留最后一个.
2.“键”是不可变的：不能对元素的键直接修改
当键的命名失误出错的时候，不能直接修改键，只能删除键，所以像列表这样的可修改对象也不能做键。

增加元素

直接添加

增加元素有两种方式，第一种是直接增加：

>>> D={'K':1,'S':2}
>>> D['Y']=3
>>> print(D)
{'K': 1, 'S': 2, 'Y': 3}

若在直接添加元素的时候输入了已有的键，则会改变此键对应的值

>>> D={'K':1,'S':2}
>>> D['S']=3
>>> print(D)
{'K': 1, 'S': 3}

在列表操作中也有这样的写法，列表里L[x]=y是修改对应元素的值，而字典D[x]=y是增加新元素。

setdefault：添加元素

>>> D={'K':1,'S':2}
>>> D.setdefault('Y',3)
3
>>> print(D)
{'K': 1, 'S': 2, 'Y': 3}

如果在命名了键以后不输入值，则会默认给None这个值

>>> D.setdefault('W')
>>> print(D)
{'K': 1, 'S': 2, 'Y': 3, 'W': None}

这里跟直接添加不一样的是，在用setdefault指令添加已有的键时，不会修改对应的值，只会显示原本已有的值

>>> D.setdefault('K',10)
1
>>> print(D)
{'K': 1, 'S': 2, 'Y': 3, 'W': None}

删除元素

del()函数

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> del(D['S'])
>>> print(D)
{'K': 1, 'Y': 3}

pop：删除指定键值对，并返回键值

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> test=D.pop('S')
>>> print(D)
{'K': 1, 'Y': 3}
>>> print(test)
2

popitem：删除最后一个键值对，并以元组形式返回其键值对

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> test=D.popitem()
>>> print(D)
{'K': 1, 'S': 2}
>>> print(test)
('Y', 3)

修改元素

直接修改

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> D['Y']=30
>>> print(D)
{'K': 1, 'S': 2, 'Y': 30}

其实这就是之前直接添加元素时输入已有键以后的结果

update：用一个字典更新另一个

>>> D1={'K': 1, 'S': 2, 'Y': 3}
>>> D2={'K':10,'S':20}
>>> D1.update(D2)
>>> print(D1)
{'K': 10, 'S': 20, 'Y': 3}

若D2和D1中有对应的键，则会把D1的键值换成D2的；若没有，则会增加相应的键值对。

>>> D3={'Y':30,'X':40,'W':50}
>>> D1.update(D3)
>>> print(D1)
{'K': 10, 'S': 20, 'Y': 30, 'X': 40, 'W': 50}

查找元素

直接查找

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> D['K']
1

若查找一个不存在的值，则会报错

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> D['W']
KeyError: 'W'

get：查找键

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> D.get('S')
2

若查找一个不存在的值，则会返回空的值

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> D.get('W')
>>> 

相比直接查找，get不会报错，有些时候更符合实际程序需要

遍历

遍历的意思就是对集合里的元素依次访问，常和for语句一起使用

items：遍历所有键值对，并以元组形式返回所有键值对

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> D.items()
dict_items([('K', 1), ('S', 2), ('Y', 3)])

结合for语句：

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> for i in D.items():
('K', 1)
('S', 2)
('Y', 3)

这里要注意的是：items()得到的是builtin_function_or_method，翻译过来叫…自行翻译/斜眼笑

>>> type(D.items)
<class 'builtin_function_or_method'>

keys：遍历所有键

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> D.keys()
dict_keys(['K', 'S', 'Y'])

结合for语句：

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> for i in D:
	print(i)
K
S
Y

这里如果把D写成D.keys()，输出也是一样的。

values：遍历所有值

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> D.values()
dict_values([1, 2, 3])

结合for语句

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> for i in D.values():
	print(i)
1
2
3

或者

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> for i in D:
	print(D[i])
1
2
3

这种遍历方法其实是先遍历键，再查看字典键对应的值。

其他操作

fromkeys：用给定键建立新字典，默认值为None

>>> D1={'K': 1, 'S': 2, 'Y': 3}
>>> D2={}.fromkeys(D1)
>>> print(D2)
{'K': None, 'S': None, 'Y': None}

clear：清空字典

>>> D={'K': 1, 'S': 2, 'Y': 3}
>>> D.clear()
>>> print(D)
{}

copy：复制字典

>>> D1={'K': 1, 'S': 2, 'Y': 3}
>>> D2=D1.copy()
>>> print(D2)
{'K': 1, 'S': 2, 'Y': 3}
>>>id(D1)
49683624
>>>id(D1)
49683840

可知，copy后得到的字典地址不同。而直接让字典相等的话会得到相同的地址，如下：

>>> D1={'K': 1, 'S': 2, 'Y': 3}
>>> D3=D1
>>> print(D3)
{'K': 1, 'S': 2, 'Y': 3}
>>> id(D1)
49683624
>>> id(D3)
49683624

可见，通过这种直接相等的方式获得第二个字典，二者本质上还是同一个字典，这会导致：当我们改变D3的元素时，D1的元素也会改变；而copy指令会避免这个问题
…
…
今天就说这么多了，字典的操作和列表很相似，但是各有各的使用方法与适用场景，这一点还是希望各位仔细体会。

声明：文章仅供学习交流使用，若有程序错误和写法不当之处烦请私信我，我将及时改正，还请海涵，谢谢！