一、字典的基本操作
字典（Dictionary）是一种Python基本数据类型，是一种无序、可变的数据类型，它由键值对（key-value）组成。
字典使用大括号{}来表示，键和值之间使用冒号:分隔，键值对之间使用逗号,分隔。
字典中的键必须是唯一的，且不可变的数据类型，而值可以是任意类型的对象。
字典可以通过键来访问对应的值。
1、创建字典
方法1：使用 {} 创建字典
当使用{}创建字典时，可以通过不同的方式创建空字典和非空字典。下面是相应的示例：
# 创建空字典
empty_dict = {}
# 创建非空字典
non_empty_dict = {'name': 'John', 'age': 25, 'city': 'New York'}方法2：使用dict() 函数创建字典
当使用dict()函数创建字典时，你可以通过传递不同的参数来创建空字典和非空字典。下面是相应的示例：
# 创建空字典
empty_dict = dict()
# 创建非空字典
non_empty_dict = dict(name='John', age=25, city='New York')dict()函数注释如下：
class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
"""由上可知，dict()函数提供了多种创建字典的方式，具体取决于你传递给它的参数。下面是几种常见的用法：
2.1 使用dict(**kwargs) 函数传入关键字参数创建字典
person = dict(name='Alice', age=25, city='New York')
print(person ) # {'name': 'Alice', 'age': 25, 'city': 'New York'}2.2 使用dict(iterable) 函数传入可迭代对象创建字典
pairs = [('name', 'Alice'), ('age', 25), ('city', 'New York')]
person = dict(pairs)
print(person) # {'name': 'Alice', 'age': 25, 'city': 'New York'}2.3 使用dict()函数和zip()函数结合创建字典
keys = ['name', 'age', 'city']
values = ['Alice', 25, 'New York']
dictionary = dict(zip(keys, values))
print(dictionary) # {'name': 'Alice', 'age': 25, 'city': 'New York'}使用这种方法，你可以根据需要灵活地创建字典，而不需要显式地编写键值对。
2.4 使用dict.fromkeys()函数创建字典
keys = ['name', 'age', 'city']
default_value = 'Unknown'
new_dict = dict.fromkeys(keys, default_value)
print(new_dict) # {'name': 'Unknown', 'age': 'Unknown', 'city': 'Unknown'}`dict.fromkeys(*args, **kwargs)`函数接受两个参数：一个可迭代对象作为键的集合，以及一个可选参数作为默认值。它将使用可迭代对象中的每个元素作为字典的键，并将默认值分配给每个键。
总之，dict.fromkeys()函数是一个快速创建具有相同默认值的字典的方便方法。
2、访问字典
使用 dict['key'] 的方式来访问字典，其中 'key' 是要访问的键名。通过这种方式，可以直接获取字典中指定键的对应值。
以下是两种常见的访问字典元素的方法：
# 创建一个字典
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
# 使用方括号[]访问字典元素
name = person['name']
# 使用get()方法访问字典元素
age = person.get('age')需要注意的是，如果使用方括号`[]`访问一个不存在的键，会抛出`KeyError`异常。而使用`get()`方法访问一个不存在的键时，会返回`None`，或者也可以指定一个默认值作为`get()`方法的第二个参数。
3、更新字典
可以使用 `dict['key'] = value` 的方式来更新字典中特定键的值。如果键存在，则该值将被更新；如果键不存在，则将创建一个新的键值对。
键存在的示例代码：
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['b'] = 4 # 更新键 'b' 的值为 4
print(my_dict) # 输出: {'a': 1, 'b': 4, 'c': 3}在上面的示例中，通过 `my_dict['b'] = 4` 的方式将键 `'b'` 的值从原来的 `2` 更新为 `4`。
键不存在的示例代码：
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['d'] = 5 # 添加新的键值对 {'d': 5}
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 5}在上面的示例中，通过 `my_dict['d'] = 5` 的方式添加了一个新的键值对 `{'d': 5}` 到字典中。
二、字典的属性方法
可以使用dir(dict)函数，打印输出字典dict的所有属性和方法。
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']根据每种方法的用途可以分为如下几类：
增：'update',
删：'pop', 'popitem',clear',
改：'update',
查：'keys', 'values','items', 'get','setdefault',
其它：'copy', 'fromkeys',1、更新字典（update）
dict.update()方法用于更新字典中的键值对。如果给定的字典与原字典中的键相同，则更新原字典中的键对应的值；如果给定的字典中的键在原字典中不存在，则将其添加到原字典中。
语法如下：
def update(self, E=None, **F): -> None- dict：表示要更新的字典对象。
- E：可选参数，可以是一个字典或可迭代对象。用于更新字典的键值对。
- **F：可变关键字参数，用于接收额外的键值对。这些键值对会在更新字典时被添加或更新。
- 返回值：None，所以该方法会直接修改原始字典，而不会返回一个新的字典。
代码实例：
1. 使用字典对象更新字典：
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)
print(dict1) # 输出: {'a': 1, 'b': 3, 'c': 4}2. 使用可迭代对象更新字典：
dict1 = {'a': 1, 'b': 2}
items = [('b', 3), ('c', 4)]
dict1.update(items)
print(dict1) # 输出: {'a': 1, 'b': 3, 'c': 4}3. 使用关键字参数更新字典：
dict1 = {'a': 1, 'b': 2}
dict1.update(c=3, d=4)
print(dict1) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}2、删除字典中元素（del、pop、popitem、clear）
删除字典中的元素有多种方法，以下是一些常用的方式：
1. 使用 del 关键字删除指定键的元素：
my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['a']
print(my_dict) # 输出: {'b': 2, 'c': 3}2. 使用 pop(key) 方法删除指定键的元素：
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.pop('a')
print(my_dict) # 输出: {'b': 2, 'c': 3}3. 用 popitem() 方法随机删除并返回一个键值对：
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.popitem()
print(my_dict) # 输出: {'a': 1, 'b': 2}4. 使用 clear() 方法清空整个字典：
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.clear()
print(my_dict) # 输出: {}3、获取字典中所有键和值（keys、values、items）
字典的 `keys()`、`values()` 和 `items()` 方法是用于获取字典中元素的方法。
- `keys()` 方法返回一个包含字典所有键的视图（view）。可以通过将其转换为其他类型（如列表）来获取键的列表。
- `values()` 方法返回一个包含字典所有值的视图（view）。同样可以通过将其转换为其他类型来获取值的列表。
- `items()` 方法返回一个包含字典所有键值对的视图（view）。每个键值对都表示为一个元组，可以通过将其转换为其他类型来获取键值对的列表。
下面是一些示例代码：
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys = my_dict.keys()
values = my_dict.values()
items = my_dict.items()
print(keys) # 输出: dict_keys(['a', 'b', 'c'])
print(values) # 输出: dict_values([1, 2, 3])
print(items) # 输出: dict_items([('a', 1), ('b', 2), ('c', 3)])
# 转换为列表
key_list = list(keys)
value_list = list(values)
item_list = list(items)
print(key_list) # 输出: ['a', 'b', 'c']
print(value_list) # 输出: [1, 2, 3]
print(item_list) # 输出: [('a', 1), ('b', 2), ('c', 3)]4、获取字典中指定键的值（get、setdefault）
1. `get(key, default)` 方法用于获取指定键的值。如果字典中存在该键，则返回对应的值；如果字典中不存在该键，则返回指定的默认值。示例代码如下：
my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.get('a', 0)
print(value) # 输出: 1
value = my_dict.get('d', 0)
print(value) # 输出: 0在上面的示例中，第一个 `get()` 方法返回了键 `'a'` 对应的值 `1`，而第二个 `get()` 方法返回了指定的默认值 `0`，因为字典中不存在键 `'d'`。
2. `setdefault(key, default)` 方法用于获取指定键的值。如果字典中存在该键，则返回对应的值；如果字典中不存在该键，则将指定的键值对添加到字典中，并返回指定的默认值。示例代码如下：
my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.setdefault('a', 0)
print(value) # 输出: 1
value = my_dict.setdefault('d', 4)
print(value) # 输出: 4
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}在上面的示例中，第一个 `setdefault()` 方法返回了键 `'a'` 对应的值 `1`，而第二个 `setdefault()` 方法将键 `'d'` 和默认值 `4` 添加到字典中，并返回了指定的默认值 `4`。
5、复制字典（copy）
`copy()` 方法用于创建字典的副本。通过 `copy()` 方法可以复制一个字典，将原字典的键值对复制到新的字典中。
下面是一个示例代码：
my_dict = {'a': 1, 'b': 2, 'c': 3}
new_dict = my_dict.copy()
print(new_dict) # 输出: {'a': 1, 'b': 2, 'c': 3}在上面的示例中，`copy()` 方法创建了一个新的字典 `new_dict`，并将 `my_dict` 中的键值对复制到了 `new_dict` 中。这样，`new_dict` 和 `my_dict` 是两个独立的字典对象，对其中一个字典的修改不会影响到另一个字典。
需要注意的是，使用 `copy()` 方法进行复制时，复制的是字典的内容而不是引用，因此对复制后的字典进行修改不会影响到原始字典。
reference：
