Python 基础（字典）

数据STUDIO

发布于 2021-06-24 10:22:00

4620

发布于 2021-06-24 10:22:00

文章被收录于专栏：数据STUDIO

字典是另一种可变容器模型，且可存储任意类型对象。

字典是一种可变数据类型
字典的元素存储方式是键值对的形式，键值对之间用逗号隔开
键值对的形式形如：key:value
最外层用{}括起来
d = {key1 : value1, key2 : value2 }
由于字典是键值对的形式，所以字典是无序的，自然不能切片和索引，而是通过键来取值

键：只能是不可变数据类型，一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一

值：可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组

字典的定义

使用dict()来定义字典

>>> a = dict([('k1',1), ('k2', 2), (('k31', 'k32'), 3), [('k41', 'k42', 'k43', ('k441', 'k442')), 4]])
>>> a
{'k1': 1,
 'k2': 2,
 ('k31', 'k32'): 3,
 ('k41', 'k42', 'k43', ('k441', 'k442')): 4}
>>> type(a)
dict

使用{ }来定义字典

>>> b = {'k1':1, 'k2':2, (1, 2, 3):3}
>>> b
{'k1':1, 'k2':2, (1, 2, 3):3}
>>> type(b)
dict

字典键的特性

字典值可以是任何的python对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

>>> dic = {'公众号': '数据STUDIO', 'Name': 'jim_learning', 'Name': 'Jim'}
>>> print("dic['Name']: ", dic['Name'])
dic['Name']:  Jim

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

>>> dic = {['公众号']: '数据STUDIO', 'Name': 'jim_learning'}
>>> print("dic['公众号']: ", dic['公众号'])

---------------------------------------------------------------------
TypeError                           Traceback (most recent call last)
<ipython-input-33-e29296bcd27a> in <module>
----> 1 dic = {['公众号']: '数据STUDIO', 'Name': 'jim_learning'}
      2 print("dic['公众号']: ", dic['公众号'])

TypeError: unhashable type: 'list'

字典的一些运算

in包含运算

判断元素是否是字典的键，如果键在字典dict里返回true，否则返回false

>>> dic = {'关注':'数据STUDIO', '点赞': 520}
>>> '点赞' in dic
True

字典没有加减乘除等运算。

字典对象的一些方法

三个增加方法

方法	说明
dict[key] = value	如果这个键不存在就是增加，存在就是修改值
dict.setdefault(key, default=None)	Python 字典 setdefault() 方法和 get()方法类似, 如果键名存在，则不会有任何变化。如果键不已经存在于字典中，将会添加键并将值设为默认值。
dict.update(dict2)	把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。dict2不会发生变化

dict[键名] = 值

增加一个新的键值对'name': 'jim_learning'

>>> dict1 = {'language1':'python', 'language2':'mysql'}
>>> dict1['name'] = 'jim_learning'
>>> dict1
{'language1': 'python', 'language2': 'mysql', 'name': 'jim_learning'}

>>> dict1['name'] = 'Jim'
>>> dict1
{'language1': 'python', 'language2': 'mysql', 'name': 'Jim'}

dict.setdefault('新键名', 值)

增加一个新的键值对'name': 'jim_learning'

>>> dict2 = {'language1':'python', 'language2':'mysql'}
>>> dict2.setdefault('name', 'jim_learning')  # 如果不存在这个键，就增加这个键
>>> dict2
{'language1': 'python', 'language2': 'mysql', 'name': 'jim_learning'}

>>> dict2.setdefault('name', 'Jim')  # 如果原来有这个键，则不会发生改变
>>> dict2
{'language1': 'python', 'language2': 'mysql', 'name': 'jim_learning'}

>>> dict2.setdefault('公众号', )   # 只写键，不写值，默认是None
>>> dict2
{'language1': 'python', 'language2': 'mysql', 'name': 'jim_learning', '公众号': None}

dict1.update(dict2)

把所有dic2中的键值对增加到dic1中。这个功能类似于我们在列表中学的extend()扩展功能

>>> dict1 = {'Name': 'Jim', 'Age': 18}
>>> dict2 = {'Sex': 'female'}
 
>>> dict1.update(dict2) # 该方法没有任何返回值。
>>> dict1
{'Name': 'Jim', 'Age': 18, 'Sex': 'female'}

>>> dict2
{'Sex': 'female'}

五种删除方法

方法	说明
del dict[key]	删除指定键值
dict.pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
dict.popitem()	随机返回并删除字典中的最后一对键和值。如果字典已经为空，却调用了此方法，就报出KeyError异常。
dict.clear()	删除字典内所有元素，留下一个空字典。(和列表对应操作相同）
Del dict	删除整个词典(和列表对应操作相同）

del 字典名['键名'] 删除指定键值对

scores={"Mike":88,"Tom":89,"Mary":95,"Jack":95}
del scores['Mike']
scores
{'Tom': 89, 'Mary': 95, 'Jack': 95}

字典名.pop('键名') 删除键值对+返回值

>>> scores = {"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores
{'Mike': 88, 'Tom': 89, 'Mary': 95, 'Jack': 95}
>>> scores.pop('Jack') 
95

>>> scores.pop()  #没有指定会报错
>>> scores
{'Mike': 88, 'Tom': 89, 'Mary': 95}

字典名.popitem() 随机删除一对键值对，并返回该键值对，一般是最后一对

>>> scores={"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores.popitem()
('Jack', 95)
>>> scores
{'Mike': 88, 'Tom': 89, 'Mary': 95}

如果列表为空，则会报错

dict1 = {}
dict1.popitem()
------------------------------------------------------------
KeyError                   Traceback (most recent call last)
<ipython-input-38-90ebb4ec6b65> in <module>
----> 1 l.popitem()

KeyError: 'popitem(): dictionary is empty'

字典名.clear() 清空字典

>>> scores = {"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores
{'Mike': 88, 'Tom': 89, 'Mary': 95, 'Jack': 95}
>>> scores.clear()  #所有键值对都被清楚
>>> scores
{}

del 字典名删除这个字典

>>> scores = {"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores
{'Mike': 88, 'Tom': 89, 'Mary': 95, 'Jack': 95}
>>> del scores

>>> scores       # 注意和clear()方法的区别
--------------------------------------------------------
NameError               Traceback (most recent call last)
<ipython-input-45-8359f9776778> in <module>
----> 1 scores       # 注意和clear()方法的区别

NameError: name 'scores' is not defined

一种修改方法

方法	说明
dict[key] = value	如果键名不存在就是增加，存在就是修改

>>> scores = {"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores
{'Mike': 88, 'Tom': 89, 'Mary': 95, 'Jack': 95}

# 把'Mike': 88 这个键值对的值改成100
>>> scores['Mike'] = 100  # 若此键存在修改，不存在就增加
>>> scores
{'Mike': 100, 'Tom': 89, 'Mary': 95, 'Jack': 95}

五种查找方法

方法	说明
dict[key]	返回该键对应的值，没有该键则报错
dict.get(key)	返回该键对应的值，没有该键不会报错
dict.keys()	返回包含所有键的列表，这个列表不是严格意义上的list，可以用list()转换成严格意义上的列表
dict.values()	返回包含所有值的列表，这个列表不是严格意义上的list，可以用list()转换成严格意义上的列表
Dict.items()	返回包含所有键值对的列表，每个键值对用元组存储，这个列表不是严格意义上的list，可以用list()转换成严格意义上的列表

dict[key]

取出该键所对应的值

>>> scores={"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores
{'Mike': 88, 'Tom': 89, 'Mary': 95, 'Jack': 95}
>>> scores["Tom"]
89

dict.get(键)

取出该键所对应的值

>>> scores={"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores
{'Mike': 88, 'Tom': 89, 'Mary': 95, 'Jack': 95}

dict.keys()

返回包含所有键的列表，这个列表不是严格意义上的list，可以用list()转换成严格意义上的列表

>>> scores={"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores
{"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> type(dic)
dict

>>> scores.keys()
dict_keys(['Mike', 'Tom', 'Mary', 'Jack'])
>>> list(scores.keys())
['Mike', 'Tom', 'Mary', 'Jack']

dict.values()

返回包含所有值的列表，这个列表不是严格意义上的list，可以用list()转换成严格意义上的列表

>>> scores={"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores
{"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> type(dic)
dict

>>> scores.values()
dict_values([88, 89, 95, 95])
>>> list(scores.values())
[88, 89, 95, 95]

dict.items()

返回包含所有键值对的列表，每个键值对用元组储存，这个列表不是严格意义上的list，可以用list()转换成严格意义上的列表

>>> scores={"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> scores
{"Mike":88,"Tom":89,"Mary":95,"Jack":95}
>>> type(dic)
dict

>>> scores.items()
dict_items([('Mike', 88), ('Tom', 89), ('Mary', 95), ('Jack', 95)])
>>> list(scores.items())
[('Mike', 88), ('Tom', 89), ('Mary', 95), ('Jack', 95)]

>>> dict(scores.items())
{'Mike': 88, 'Tom': 89, 'Mary': 95, 'Jack': 95}

字典的一些其他操作

>>> dic = {'k':'23','b':'55','a':'48'}
>>> sorted(dic.items(),key=lambda x :x[1])
[('k', '23'), ('a', '48'), ('b', '55')]
>>> print((i %2 for i in range(10)))
<generator object <genexpr> at 0x10df21550>
>>> [i %2 for i in range(10)]
[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2020-12-11，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法

本文分享自数据STUDIO 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

编程算法

登录后参与评论

0 条评论

热度