『无为则无心』Python序列 — 21、Python字典及其常用操作

1、字典的应用场景
2、字典的概念
3、创建字典的语法
4、字典常见操作

1、字典的应用场景

思考1：如果有多个数据，例如：'Tom', '男', 20，如何快速存储？

答：列表

list1 = ['Tom', '男', 20]

思考2：如何查找到数据'Tom'？

答：查找到下标为0的数据即可。

list1[0]

思考3：如果将来数据顺序发生变化，如下所示，还能用list1[0]访问到数据'Tom'吗？。

list1 = ['男', 20, 'Tom']

答：不能，数据'Tom'此时下标为2。

思考4：数据顺序发生变化，每个数据的下标也会随之变化，如何保证数据顺序变化前后能使用同一的标准查找数据呢？

答：字典，字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。

2、字典的概念

字典属于一种新的数据结构，称为映射（mapping）。

字典不再是序列，无法通过为止索引完成元素值的获取，只能通过键索引实现。

字典也是Python中唯一内建的映射类型。
字典的作用和列表类似，都是用来存储对象的容器。
列表存储数据的性能很好，但是查询数据的不是很方便（要么知道下标，要么就要一个一个遍历）。
在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素。
在查询元素时，字典的效率是非常快的。
在字典中可以保存多个对象，每个对象都会有一个唯一的名字。
- 这个唯一的名字，我们称其为键（key），
  
  通过key可以快速的查询value。
  
  字典的键可以是任意的不可变对象（int、str、bool、tuple ...），但是一般我们都会使用str。
  
  字典的键是不能重复的，如果出现重复的后边的会替换到前边的。
- 这个对象，我们称其为值（value），字典的值可以是任意对象。
- 所以字典，我们也称为叫做键值对（key-value）结构。
- 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项（item）。

3、创建字典的语法

字典特点：

符号为大括号。
数据为键值对形式出现。
各个键值对之间用逗号隔开。

# 1.创建有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(type(dict1))  # <class 'dict'>
# 2.创建空字典
# 方式1
dict2 = {}
print(type(dict2))  # <class 'dict'>
# 方式2，通过dict()函数
dict3 = dict()
print(type(dict3))  # <class 'dict'>
# 3.使用dict()函数来创建有元素的字典
# 每一个参数都是一个键值对，参数名就是键，参数名就是值
# （这种方式创建的字典，key都是字符串）
d = dict(name='孙悟空', age=18, gender='男')
print(d) # {'name': '孙悟空', 'age': 18, 'gender': '男'}
print(type(d)) # <class 'dict'>

注意：一般称冒号前面的为键(key)，简称k；冒号后面的为值(value)，简称v。

4、字典常见操作

（1）字典的增加操作

写法：字典序列[key] = 值。

注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 1.修改字典中name的值。
dict1['name'] = 'Rose'
# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)
# 2.新增id属性
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)

注意：字典为可变类型。

（2）字典的删除操作

@1、del()方法或 del函数

del()方法或 del函数：删除字典或删除字典中指定键值对。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 1.删除字典中指定的键值对
# 结果：{'name': 'Tom', 'age': 20}
del dict1['gender']
print(dict1)
# 2.通过del删除整个字典
# 结果：NameError: name 'dict1' is not defined
del(dict1)
print(dict1)
# 3.所删除的key不包含在字典中，会抛异常
# 结果：KeyError: 'genders'
del dict1['genders']
print(dict1)

@2、clear()方法

clear()方法：清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1)  # {}

@3、popitem()方法

popitem()方法随机删除字典中的一个键/值对，一般都会删除最后一个键值对。

删除之后，它会将删除的key-value作为返回值返回，

返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value。

"""
1.在字典中删除一个键值对。
输出结果：
result =  ('c', 3)
{'a': 1, 'b': 2}
"""
d = {'a': 1, 'b': 2, 'c': 3}
result = d.popitem()
print("result = ", result)
print(d)
# 2.当使用popitem()删除一个空字典时，会抛出异常。
# 结果：KeyError: 'popitem(): dictionary is empty'
d = {}
d.popitem()

@4、pop(key[, default])方法

"""
1.pop(key[, default])方法，
根据key删除字典中的key-value,
会将被删除的value返回！
输出结果：
result =  1
{'b': 2, 'c': 3}
"""
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('a')
print("result = ", result)
print(d)
"""
2.如果删除的key，在字典中不存在，会抛出异常。
"""
# 结果：KeyError: 'f'
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('f') # 异常
"""
3.如果指定了默认值，再删除不存在的key时，不会报错，
而是直接返回默认值。
输出结果：
result =  这是默认值
{'a': 1, 'b': 2, 'c': 3}
"""
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('z','这是默认值')
print("result = ", result)
print(d)

（3）字典的修改

@1、通过key修改字典

写法：字典序列[key] = 值

注意：如果key存在则修改这个key对应的值，如果key不存在则新增此键值对。

dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}
# 修改
# 结果：{'name': 'Lily', 'age': 20, 'gender': '男'}
dict1['name'] = 'Lily'
print(dict1)
# 增加
# 结果：{'name': 'Lily', 'age': 20, 'gender': '男', 'id': 110}
dict1['id'] = 110
print(dict1)

@2、setdefault(key[, default])方法

"""
setdefault(key[, default]) 可以用来向字典中添加key-value,
如果key已经存在于字典中，则返回key的值，不会对字典做任何操作,
如果key不存在，则向字典中添加这个key，并设置value，返回默认值。
"""
# 1.存在key，不会对字典做任何操作,返回key的值
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
result = dict1.setdefault('name','猪八戒')
print('result =',result) # result = Tom
print(dict1) # {'name': 'Tom', 'age': 20, 'gender': '男'}
# 2.不存在key，添加值，返回key的默认值
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
result = dict1.setdefault('id','猪八戒')
print('result =',result) # result = 猪八戒
print(dict1) # {'name': 'Tom', 'age': 20, 'gender': '男', 'id': '猪八戒'}

@3、update([other])方法

"""
将其他的字典中的key-value添加到当前字典中
如果有重复的key，则后边的会替换到当前的
"""
# 结果：{'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
d = {'a': 1, 'b': 2, 'c': 3}
d2 = {'d': 4, 'e': 5, 'f': 6, 'a': 7}
d.update(d2)
print(d)

（4）字典的查找

@1、key值查找

key必须加引号，否则按变量识别。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 1.key存在返回对应的值
print(dict1['name'])  # Tom
# 2.字典中没有对应的key
# 结果KeyError: 'id'
print(dict1['id'])  # 报错

如果当前查找的key存在，则返回对应的值；否则则报错。

@2、get()方法

该方法用来根据键来获取字典中的值。

语法：

字典序列.get(key, 默认值)

注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。

快速体验：

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 1.如果key存在，返回对应的值
print(dict1.get('name'))  # Tom
# 2.如果key不存在，返回默认值。
print(dict1.get('id', 110))  # 110
# 3.如果key不存在，也没有设置默认值，则返回None。
print(dict1.get('id'))  # None

@3、keys()方法

示例：

# 查找字典中所有的key，返回一个序列，包含字典中所有的key。
# 是一个可迭代的序列。（就是支持for遍历）
# 结果：dict_keys(['name', 'age', 'gender'])
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys())

遍历字典的key：

"""
# dict1.keys()得到可遍历的对象
输出结果：
name
age
gender
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)

@4、values()方法

示例：

# 查找字典中所有的value值，返回一个序列，包含字典中所有的value值。
# 是一个可迭代的序列。
# 结果：dict_values(['Tom', 20, '男'])
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values())

遍历字典的value：

"""
# dict1.values()得到可遍历的对象
输出结果：
Tom
20
男
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
    print(value)

@5、items()方法

示例：

# 查找字典中所有的键值对，返回一个序列，包含字典中所有的键值对（项）。
# 是一个可迭代的序列。
# 可迭代对象里面的数据是元组（有的也叫双值子序列），
# 元组中数据1是字典的key，元组中数据2是字典key对应的值。
# 结果：dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items())

遍历字典的元素：

"""
# dict1.items()得到可遍历的对象，其中的元素是一个元组。
输出结果：
('name', 'Tom')
('age', 20)
('gender', '男')
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
    print(item)

遍历字典的键值对：

也就是将得到的数据进行一个拆包动作。

"""
xx.items(): 返回可迭代对象，内部的元素是元组，
而元组有2个数据，将元组中的第一个数据赋值给第一个变量，第二个数据赋值给第二个变量。
也就是元组数据1是字典的key，元组数据2是字典的value，
这就是所谓的拆包动作。（可以看元祖中将的序列的拆包）
输出结果：
name = Tom
age = 20
gender = 男
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(f'{key} = {value}')

（5）`copy()`复制

和列表中的用法一样，这里补充说明：

copy()方法用于对字典进行浅复制，复制以后的对象，和原对象是独立，修改一个不会影响另一个。

但注意，浅复制会简单复制对象内部的值，如果内部值也是一个可变对象，这个可变对象不会被复制。

#基本用法和列表一样。（可以看列表）
"""
# 字典的value可以存储的还是字典，
这个value值的字典用copy()方法的时候，是不进行复制的，
在内存中还是一份的，所以修改其中一个字典的value，
另一个也会改变。
输出结果：
d =  {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3}
d2 =  {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3}
"""
d = {'a': {'name': '孙悟空', 'age': 18}, 'b': 2, 'c': 3}
d2 = d.copy()
d2['a']['name'] = '猪八戒'
print("d = ", d)
print("d2 = ", d2)