Python序列之字典

2023-12-31 16:54:53

系列文章目录

  1. Python序列之列表
  2. Python序列之元组
  3. 本篇文章


前言

前面我们已经讲了Python中的列表:Python序列之列表和元组:Python序列之元组
。今天我们再来看一下Python中另一种常用的序列——字典。

一、字典是什么?

字典是 “键值对”的无序可变序列。字典中的每个元素都是一个“键值对”,包含:“键对象"和"值对象”,即key:value对,可以通过“键对象"实现快速获取、删除、更新对应的"值对象"。
在这里插入图片描述
一个典型的字典的定义方式:

a = {'name': 'yyy', 'age': 3, 'job': 'programmer'}

列表中我们通过”下标数字"找到对应的对象,字典中通过“键对象“找到对应的“值对象”

  • “键”是任意的不可变数据,比如:整数、浮点数、字符串、元组。
  • 但是:列表、字典、集合这些可变对象,不能作为“键”。
  • 并且“键”不可重复
  • “值”可以是任意的数据,并且可重复。

二、字典的操作

1.创建

(1)通过{}dict()创建

a = {'name': 'yyy', 'age': 3, 'job': 'programmer'}
b = dict(name='yyy', age=3, job='programmer')
c = dict([('name', 'yyy'), ('age', 3), ('job', 'programmer')])
d = {}  # 创建一个空字典
e = dict()  # 创建一个空字典

print(a)  # 输出:{'name': 'yyy', 'age': 3, 'job': 'programmer'}
print(b)  # 输出:{'name': 'yyy', 'age': 3, 'job': 'programmer'}
print(c)  # 输出:{'name': 'yyy', 'age': 3, 'job': 'programmer'}
print(d)  # 输出:{}
print(e)  # 输出:{}

(2)通过zip()创建

既然可以用上面创建c的方式创建字典,那自然可以用zip()函数:

keys = ['name', 'age', 'job']
values = ['yyy', '3', 'programmer']
d = dict(zip(keys, values))
print(d)  # 输出:{'name': 'yyy', 'age': '3', 'job': 'programmer'}

(3)通过fromkeys()创建值为空的字典

k = ['name', 'age', 'job']
d = dict.fromkeys(k)
print(d)  # 输出:{'name': None, 'age': None, 'job': None}

小问题:之前说字典的“键”不可重复,如何重复了会怎样?会报错吗?

a = {'name':'yyy', 'age':18, 'age':3}
print(a)  # 输出:{'name': 'yyy', 'age': 3}

可见,如果键重复了,后面的键值对会把前面的覆盖掉。

2.元素的访问

(1)通过[键]获得“值”。

若键不存在,则抛出异常。

a = {'name': 'yyy', 'age': 3, 'job': 'programmer'}
print(a['name'])  # 输出:yyy
print(a['height'])  # 输出:报错:KeyError: 'height'

(2)通过get()方法获得“值”。

**推荐使用!**优点是:指定键不存在,返回None;也可以设定指定键不存在时默认返回的对象。推荐使用get()获取"值对象”。

a = {'name': 'yyy', 'age': 3, 'job': 'programmer'}
print(a.get('name'))  # 输出:yyy

# 使用get()不会报错,整个过程变得很优雅~
print(a.get('height'))  # 输出:None

# 还尅通过第二个参数指定当键不存在时的返回值
print(a.get('height', 185))  # 输出:185

(3)列出所有的键值对、所有的键、所有的值

a = {'name': 'yyy', 'age': 3, 'job': 'programmer'}

b = a.items()
print(b)  # 输出:ict_items([('name', 'yyy'), ('age', 3), ('job', 'programmer')])

k = a.keys()
print(k)  # 输出:dict_keys(['name', 'age', 'job'])

v = a.values()
print(v)  # 输出:dict_values(['yyy', 3, 'programmer'])

(4)用len()计算键值对的个数

a = {'name': 'yyy', 'age': 3, 'job': 'programmer'}
print(len(a))  # 输出:3

(5)用in检测一个键是否在字典中

a = {'name': 'yyy', 'age': 3, 'job': 'programmer'}
print('name' in a)  # 输出:True
print('height' in a)  # 输出:False

3.元素的添加、修改、删除

(1)给字典新增"键值对"。

如果"键"已经存在,则覆盖旧的键值对;如果"键"不存在,则新增"键值对"。

a = {'name': 'yyy', 'age': 18, 'job': 'programmer'}
a['height'] = 185
a['age'] = 3
print(a)  # 输出:{'name': 'yyy', 'age': 3, 'job': 'programmer', 'height': 185}

(2)使用update()将新字典中所有键值对全部添加到旧字典对象上。

如果key有重复,则直接覆盖

a = {'name': 'yyy', 'age': 3, 'job': 'programmer'}
b = {'name': 'sheep', 'height': 185, 'gender': 'man'}
a.update(b)
print(a)  # 输出:{'name': 'sheep', 'age': 3, 'job': 'programmer', 'height': 185, 'gender': 'man'}

(3)删除元素:del()clear()pop()

字典中元素的删除,可以使用del()方法;或者者clear()删除所有键值对;pop()删除指定键值对,并返回对应的“值对象”。

a = {'name': 'yyy', 'age': 3, 'job': 'programmer', 'height': 185}

del(a['name'])
print(a)  # 输出:{'age': 3, 'job': 'programmer', 'height': 185}

age = a.pop('age')
print(a)  # 输出:{'job': 'programmer', 'height': 185}
print(age)  # 输出:3

a.clear()
print(a)  # 输出:{}

(4)popitem():随机删除和返回该键值对。

字典是"无序可变序列",因此没有第一个元素、最后一个元素的概念;popitem()弹出随机的项,因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项,这个方法就非常有效(因为不用首先获取键的列表)

a = {'name': 'yyy', 'age': 3, 'job': 'programmer', 'height': 185}

result1 = a.popitem()
result2 = a.popitem()

print(result1)  # 输出:('height', 185)
print(result2)  # 输出:('job', 'programmer')
print(a)  # 输出:{'name': 'yyy', 'age': 3}

4.序列解包

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。

x, y, z = (20, 30, 10)
(a, b, c) = (9, 8, 10)
[m, n, p] = ['a', 'b', 'c']

序列解包用于字典时,默认是对"键"进行操作;如果需要对键值对操作,则需要使用items();如果需要对"值"进行操作,则需要使用values();

a = {'name': 'yyy', 'age': 3, 'job': 'programmer'}
x, y, z = a
print(x)  # 输出:name

x, y, z = a.items()
print(x)  # 输出:('name', 'yyy')

x, y, z = a.values()
print(x)  # 输出:yyy

5.练习:用字典对表格数据进行存取

数据表格如下:

姓名年龄薪资城市
张三1810000北京
李四1930000上海
王五2020000深圳
people1 = {'name': '张三', 'age': 18, 'salary': 10000, 'city': '北京'}
people2 = {'name': '李四', 'age': 19, 'salary': 30000, 'city': '上海'}
people3 = {'name': '王五', 'age': 20, 'salary': 20000, 'city': '深圳'}
# 存进一张表格
table = [people1, people2, people3]
# 访问表格数据
for i in range(len(table)):
    print(table[i].get('name'), table[i].get('age'), table[i].get('salary'), table[i].get('city'))

# 输出:
# 张三 18 10000 北京
# 李四 19 30000 上海
# 王五 20 20000 深圳

三、字典的底层原理(重要)

(1)存储键值对的过程

字典对象的核心是散列表。散列表是一个稀疏数组(总是有空白元素的数组),数组的每个单元叫做bucket。每个bucket有两部分:一个是键对象的引用,一个是值对象的引用。由于,所有bucket结构和大小一致,我们可以通过偏移量来读取指定bucket
在这里插入图片描述
先创建一个字典a:

a = {}

a['name'] = 'yyy'

假设字典a对象创建完后,数组长度为8:
在这里插入图片描述
我们要把’name’='yyy’这个键值对放到字典对象a中,首先第一步需要计算键"name"的散列值。Python中可以通过hash()函数来计算。

print(bin(hash('name')))  # 输出:-0b1010111101001110110101100100101

由于数组长度为8,我调拿计算出的散列值的最右边3位数字作为偏移量,即"101",十进制是数字5。我们查看偏移量5,对应的bucket是否为空。如果为空,则将键值对放进去。如果不为空,则依次取右边3位作为偏移量,即"100",十进制是数字4。再查看偏移为4的bucket是否为空。直到找到为空的bucket将键值对放进去。流程图如下:
在这里插入图片描述

那如果当前数组满了怎么办?很简单——扩容
python会根据散列表的拥挤程度扩容。“扩容"指的是:创造更大的数组,将原有内容拷贝到新数组中。接近2/3时,数组就会扩容。

(2)查找值对象的过程

明白了一个键值对是如何存储到数组中的,根据键对象取到值对象,理解起来就简单了。

>>> a.get('name')
'yyy'

当调用a.get('name'),就是根据键’name’查找到"键值对",从而找到值对象’yyy’。我们仍然要首先计算’yyy’对象的散列值:

>>> bin(hash('name'))
'-0b1010111101001110110101100100101'

和存储的底层流程算法一致,也是依次取散列值的不同位置的数字。假设数组长度为8,我们可以拿计算出的散列值的最右边3位数字作为偏移量,即101,十进制是数字5。我们查看偏移量5,对应的 bucket是否为空。如果为空,则返回 None。如果不为空,则将这个bucket的键对象计算对应散列值,和我们的散列值进行比较,如果相等。则将对应"值对象"返回。如果不相等,则再依次取其他几位数字,重新计算偏移量。依次取完后,仍然没有找到。则返回 None。流程图如下:
在这里插入图片描述
在这里插入图片描述


总结

  1. 字典在内存中开销巨大,典型的用空间换时间
  2. 键查询速度很快。
  3. 往字典里面添加新建可能导致扩容,导致散列表中键的次序变化。因此,不要在遍历字典的同时进行字典的修改
  4. 键必须可散列
    • 数字、字符串、元组,都是可散列的
    • 自定义对象需要支持下面三点:(面向对象章节中再展开说)
      ①支持hash()函数
      ②支持通过_eq_()方法检测相等性
      ③ 若a==b为真,则 hash(a)==hash(b)也为真

文章来源:https://blog.csdn.net/qq_43617936/article/details/135218802
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。