第十八讲 python中的字典-访问-添加-删除-序列解包

还是那个同伟伟

已于 2024-08-01 10:57:40 修改

阅读量75

点赞数

分类专栏： python全栈工程师文章标签： python 字典字典的增删改查序列解包字典的方法

于 2024-08-01 10:57:12 首次发布

本文链接：https://blog.csdn.net/wei18791957243/article/details/140827234

版权

python全栈工程师专栏收录该内容

22 篇文章 0 订阅

订阅专栏

目录

1.字典的概念

2. 字典的创建

2.1 直接赋值创建字典

2.2 使用 zip() 函数来创建字典

2.3 使用 fromkeys() 方法

2.4 使用 dict() 构造函数

3.字典元素的访问

3.1 使用键来访问值

3.2 遍历键值对（Items）

3.3 遍历键（Keys）

3.4 遍历值（Values）

3.5 判断键是否存在

4.字典的添加

4.1 给字典新增“键值对”

4.2 update() 方法更新字典

5. 字典的修改

6. 字典元素的删除

6.1 使用 del 关键字

6.2 使用 pop() 方法

6.3 使用 popitem() 方法

6.4 clear() 方法清空字典中的所有元素

7. 序列解包

1.字典的概念

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。

字典（Dictionary）是一种无序、可变、键-值对（key-value pair）集合的数据类型。字典以大括号 {} 表示，每个键值对之间用逗号 , 分隔，键和值之间用冒号 : 分隔。

主要特点：

无序性： 字典中的元素没有固定的顺序。即使多次打印相同的字典，其顺序也可能不同。

可变性：字典中的元素可以通过键进行增加、删除或修改。这使得字典是一种非常灵活的数据结构。

键的唯一性：字典中的键必须是唯一的，即同一个字典中不能有两个相同的键。如果同一个键被赋予了多个值，后面的值会覆盖前面的值。

键的不可变性：字典中的键必须是不可变的类型，比如整数、浮点数、字符串、元组等。但是，列表等可变类型不能作为字典的键，因为可变类型不能保证其在字典中的唯一性和哈希性。
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。

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

2. 字典的创建

2.1 直接赋值创建字典

最简单的方法是直接用大括号 {} 来创建一个空字典或者包含初始键值对的字典。.
# 创建一个空字典
my_dict = {}

# 创建一个包含键值对的字典
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
2.2 使用 zip() 函数来创建字典

使用 zip() 函数可以将两个序列（如列表）的元素一一对应起来，然后可以通过 dict() 函数将这些对应的元素转换为字典的键值对。

例如，假设有两个列表 keys 和 values，可以通过 zip(keys, values) 创建一个由键值对元组组成的迭代器，然后再将其转换为字典：
keys = ['name', 'age', 'city']
values = ['Alice', 30, 'New York']

# 使用 zip 和 dict 函数创建字典
person = dict(zip(keys, values))
print(person)  # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York'}
2.3 使用 fromkeys() 方法

fromkeys() 方法用于创建一个新字典，指定所有键，并指定它们的初始值（默认为 None）。
# 使用 fromkeys 方法创建字典
keys = ['a', 'b', 'c']
default_value = 0
result = dict.fromkeys(keys, default_value)  # {'a': 0, 'b': 0, 'c': 0}
2.4 使用 dict() 构造函数

可以使用 dict() 函数来创建字典，传入包含键值对的元组列表或者关键字参数。
# 使用关键字参数创建字典
person = dict(name='Alice', age=30, city='New York')

# 使用元组列表创建字典
data = dict([('name', 'Bob'), ('age', 25), ('city', 'Los Angeles')])
3.字典元素的访问

3.1 使用键来访问值

字典中的元素访问主要通过键来实现，以下是几种常见的方法：

通过 [键] 获得“值”。若键不存在，则抛出异常。
通过get()方法获得“值”。推荐使用。优点是：指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象。推荐使用get()获取“值对象”
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 直接通过键访问值
print(person['name'])  # 输出: 'Alice'

# 使用 get() 方法，可以在键不存在时提供默认值
print(person.get('age'))  # 输出: 30
print(person.get('job', 'Not specified'))  # 输出: 'Not specified'
3.2 遍历键值对（Items）

列出所有的键值对
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 遍历字典的键值对
for key, value in person.items():
    print(f'{key}: {value}')
# 输出:
# name: Alice
# age: 30
# city: New York
3.3 遍历键（Keys）
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 遍历字典的键
for key in person:
    print(key)  # 输出: name, age, city
3.4 遍历值（Values）
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 遍历字典的值
for value in person.values():
    print(value)  # 输出: Alice, 30, New York
3.5 判断键是否存在

可以使用 in 关键字来判断一个键是否存在于字典中：
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 判断键是否存在
if 'age' in person:
    print('Age is present in the dictionary.')
4.字典的添加

4.1 给字典新增“键值对”

如果“键”已经存在，则覆盖旧的键值对；

如果“键”不存在，则新增“键值对”
# 创建一个空字典
person = {}

# 添加元素
person['name'] = 'Alice'
person['age'] = 30
person['city'] = 'New York'

print(person)
# 输出: {'name': 'Alice', 'age': 30, 'city': 'New York'}
4.2 update() 方法更新字典

update() 方法可以接受另一个字典或者键值对序列作为参数，将其添加到当前字典中或者更新已有的键值对。

如果key有重复，则直接覆盖。
person = {'name': 'Alice', 'age': 30}

# 更新字典
person.update({'age': 31, 'city': 'New York'})

print(person)
# 输出: {'name': 'Alice', 'age': 31, 'city': 'New York'}
update() 方法的参数可以是另一个字典，也可以是包含键值对元组的列表或者其他可迭代对象。

包含键值对元组的列表或其他可迭代对象： 除了字典外，update() 方法还可以接受包含键值对元组的列表或其他可迭代对象。每个元组包含两个元素，第一个元素作为键，第二个元素作为对应的值。方法会将这些键值对依次添加到当前字典中。
person = {'name': 'Alice', 'age': 30}
updates = [('age', 31), ('city', 'New York')]

person.update(updates)

print(person)
# 输出: {'name': 'Alice', 'age': 31, 'city': 'New York'}




person = {'name': 'Alice', 'age': 30}
updates = zip(['age', 'city'], [31, 'New York'])

person.update(updates)

print(person)
# 输出: {'name': 'Alice', 'age': 31, 'city': 'New York'}
5. 字典的修改

如果要修改字典中已有键的值，可以直接对键进行赋值操作：
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 修改元素
person['age'] = 31
person['city'] = 'San Francisco'

print(person)
# 输出: {'name': 'Alice', 'age': 31, 'city': 'San Francisco'}
6. 字典元素的删除

6.1 使用 del 关键字

可以使用 del 关键字删除字典中指定的键值对：
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 删除元素
del person['age']

print(person)
# 输出: {'name': 'Alice', 'city': 'New York'}
6.2 使用 pop() 方法

可以使用 pop(key) 方法删除并返回指定键的值，如果键不存在，则可以提供一个默认值：
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 删除元素并返回值
removed_age = person.pop('age')

print(person)
# 输出: {'name': 'Alice', 'city': 'New York'}

print(f'Removed age: {removed_age}')
# 输出: Removed age: 30
6.3 使用 popitem() 方法

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

popitem() 方法用于随机删除并返回字典中的一对键值对（注意Pythonthon 3.7+版本后删除的是最后一个插入的元素）
data = {
    "name": 'xiaoming',
    "age": 12
}

print(data)             # {'name': 'xiaoming', 'age': 12}
data.update({
    "school": 'USA'         
})
print(data)             # {'name': 'xiaoming', 'age': 12, 'school': 'USA'}
data.popitem()
print(data)             # {'name': 'xiaoming', 'age': 12}
6.4 clear() 方法清空字典中的所有元素
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 清空字典
person.clear()
print(person)  # 输出: {}
7. 序列解包

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。
x,y,z=(20,30,10)
(a,b,c)=(9,8,10)
[m,n,p]=[10,20,30]
序列解包用于字典时，默认是对“键”进行操作；如果需要对键值对操作，则需要使用items()；如果需要对“值”进行操作，则需要使用 values()
s = {'name':'xiaoming','age':30,'job':'teacher'}
name,age,job=s	        #默认对键进行操作
print(name)	            #name
name,age,job=s.items()	#对键值对进行操作
print(name)	            #('name', 'xiaoming')
name,age,job=s.values()	#对值进行操作
print(name)	            # xiaoming