python字典

# python字典
Python字典是一种无序、可变、键-值对的集合。每个键值对都由一个键和一个值组成，键值对之间用逗号分隔，整个字典用大括号包围。字典的键必须是唯一的，而值可以是任何数据类型，包括数字、字符串、列表、元组、甚至是字典。

以下是一个简单的Python字典的例子：

```python
# 创建一个字典
my_dict = {"apple": 2, "banana": 3, "orange": 4}

# 输出字典
print(my_dict)

# 输出结果：
{'apple': 2, 'banana': 3, 'orange': 4}
```
在上面的例子中，我们创建了一个包含3个键值对的字典，并将其存储在变量my_dict中。我们可以通过调用print()函数来输出这个字典。

Python字典支持许多常用的操作，包括添加、更新、删除、查询等等

## 字典的创建
1、使用大括号 {} 和冒号 : 创建字典，每个键值对之间用逗号 , 分隔。例如：
```python
person = {'name': 'Tom', 'age': 25, 'city': 'Beijing'}
```

2、使用 dict() 函数创建字典，每个键值对之间用逗号 , 分隔。例如：
```python
person = dict(name='Tom', age=25, city='Beijing')
```

3、使用键列表和值列表来创建字典，可以使用 zip() 函数将键列表和值列表打包成一个元组的列表，然后再使用 dict() 函数将其转换成字典。例如：
```python
Copy code
keys = ['name', 'age', 'city']
values = ['Tom', 25, 'Beijing']
person = dict(zip(keys, values))
```
其中，keys 列表中的元素为字典的键，values 列表中的元素为字典的值。zip() 函数将两个列表中的元素一一对应打包成元组，返回一个元组的列表，然后再使用 dict() 函数将其转换成字典。

4、使用 fromkeys() 方法创建字典，fromkeys() 方法使用指定的键列表作为字典的键，将它们的值设置为默认值。例如：
```python
keys = ['name', 'age', 'city']
person = dict.fromkeys(keys, 'unknown')
```
上面代码中，将 keys 列表作为字典的键，将它们的值都设置为 'unknown'。

注意：字典中的键必须是可哈希的，即不可变类型，如字符串、整数、浮点数、元组等。

## 常用方法

### fromkeys()方法
fromkeys()是字典类的一个方法，用于创建一个新字典，其中给定的键（或迭代器）具有一个默认值。它的语法如下：

```python
dict.fromkeys(keys[, value])
```
其中，keys是一个包含要用作字典键的值的序列或可迭代对象，value是可选参数，指定要用作默认值的值。如果不提供value参数，则默认为None。

以下是一些示例：

```python
# 从列表创建字典
keys = ['a', 'b', 'c']
new_dict = dict.fromkeys(keys)
print(new_dict)  # {'a': None, 'b': None, 'c': None}

# 从元组创建字典
keys = ('x', 'y', 'z')
new_dict = dict.fromkeys(keys, 0)
print(new_dict)  # {'x': 0, 'y': 0, 'z': 0}

# 从集合创建字典
keys = {'mango', 'banana', 'apple'}
new_dict = dict.fromkeys(keys, 1)
print(new_dict)  # {'apple': 1, 'banana': 1, 'mango': 1}
```
在第一个示例中，keys是一个包含字典键的列表。由于未提供value参数，因此将使用默认值None。调用dict.fromkeys()方法将返回一个新字典，其中所有键都将设置为None。

在第二个示例中，keys是一个包含字典键的元组，并且为value参数提供了默认值0。在这种情况下，调用dict.fromkeys()方法将返回一个新字典，其中所有键都将设置为0。

在第三个示例中，keys是一个包含字典键的集合，并且为value参数提供了默认值1。在这种情况下，调用dict.fromkeys()方法将返回一个新字典，其中所有键都将设置为1。

### keys()方法
keys() 方法返回一个字典视图对象，该对象包含字典中所有的键。字典视图对象是一个动态对象，它会随着字典内容的更改而更新。

例如：

```python
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}

keys = my_dict.keys()

print(keys)  # dict_keys(['name', 'age', 'gender'])

# 修改字典内容
my_dict['phone'] = '123456789'

print(keys)  # dict_keys(['name', 'age', 'gender', 'phone'])
```
注意：在 Python 2.x 中，keys() 方法返回一个列表，而不是字典视图对象。

### values()方法
values() 方法是 Python 字典（dictionary）类型的内置方法，用于获取字典中的所有值。该方法返回一个包含字典所有值的列表。

以下是一个示例：

```python
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
values = person.values()
print(values)
```
输出结果为：

```python
dict_values(['Alice', 30, 'New York'])
```
可以看到，values() 方法返回了一个列表，其中包含了字典中的所有值。在上面的示例中，这些值分别为 'Alice'、30 和 'New York'。

需要注意的是，返回的列表中的元素顺序是不确定的，并且可能与添加键值对的顺序不同。如果要按照特定顺序获取值，可以先使用 keys() 方法获取键列表，然后根据键列表中的顺序来获取值。

```python
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
keys = ['name', 'age', 'city']
values = [person[key] for key in keys]
print(values)
```
输出结果为：
```python
['Alice', 30, 'New York']
```
在这个示例中，我们首先使用 keys() 方法获取了字典中所有的键，然后使用列表推导式遍历键列表，根据键来获取对应的值，并将这些值存储在一个新的列表中。这样就可以按照特定顺序获取值了。

### items()方法
items() 方法是 Python 字典（dictionary）类型的内置方法，用于返回字典的所有 (key, value) 元组。

语法格式如下：

```python
dict.items()
```
其中，dict 表示字典名称。

该方法返回的结果是一个可迭代对象，其中每个元素都是一个 (key, value) 元组，其中 key 表示字典中的键，value 表示对应的值。

示例代码：

```python
Copy code
d = {'apple': 1, 'banana': 2, 'orange': 3}
items = d.items()
print(items)
```
输出结果：
```python
dict_items([('apple', 1), ('banana', 2), ('orange', 3)])
```
可以使用 for 循环遍历 items 中的元素：

```python
for item in items:
    print(item)
```
输出结果：
```python
('apple', 1)
('banana', 2)
('orange', 3)
```
也可以通过转换为列表，再进行遍历：

```python
items_list = list(d.items())
print(items_list)
```
输出结果：

```python
[('apple', 1), ('banana', 2), ('orange', 3)]
```
注意，items() 方法返回的对象是一个视图（view）对象，该对象会随着原字典的修改而修改。因此，如果你在遍历字典的同时修改了字典，可能会导致错误的结果。

### get()方法
get()方法用于获取字典中指定键的值，如果键不存在，可以指定默认值。其语法为：

```python
dict.get(key, default=None)
```
其中，key表示要获取值的键，default表示当键不存在时返回的默认值，如果不指定默认值，则返回None。

举个例子：

```python
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
name = person.get('name')
gender = person.get('gender', 'Unknown')
print(name)    # 输出 Alice
print(gender)  # 输出 Unknown，因为 gender 键不存在，使用了默认值
```

### clear()方法
clear()方法是Python字典中的一个内置方法，用于清空字典中所有的元素。

语法格式如下：

```python
dict.clear()
```
其中，dict表示待清空的字典对象。

例如：

```python
# 创建一个字典
my_dict = {'name': 'Tom', 'age': 25, 'gender': 'male'}

# 清空字典
my_dict.clear()

# 输出清空后的字典
print(my_dict)  # 输出 {}
```

### copy()方法
copy()方法是字典对象的一个方法，用于创建并返回一个字典的浅复制，即复制原字典的键值对，但是并不复制键和值本身。

使用方法如下：

```python
original_dict = {"a": 1, "b": 2, "c": 3}
new_dict = original_dict.copy()
```
在上述代码中，original_dict是原始字典对象，new_dict是original_dict的浅复制。修改new_dict不会影响original_dict。

需要注意的是，如果原始字典中的值本身是可变对象（比如列表），那么在浅复制中，复制后的新字典和原始字典中的这个值将引用同一个对象，因此修改一个字典的值也会影响到另一个字典的值。

示例如下：

```python
original_dict = {"a": [1, 2], "b": 2}
new_dict = original_dict.copy()
new_dict["a"].append(3)
print(original_dict)  # 输出 {"a": [1, 2, 3], "b": 2}
print(new_dict)  # 输出 {"a": [1, 2, 3], "b": 2}
```
在上面的示例中，原始字典original_dict包含一个值为列表的键值对{"a": [1, 2]}，使用copy()方法复制字典后，新字典new_dict也包含一个值为列表的键值对{"a": [1, 2]}。然后修改新字典new_dict中的列表值，即在列表末尾添加元素3，发现原始字典original_dict的对应值也发生了相应变化，即列表变为[1, 2, 3]。

### update()方法
update()方法是字典对象的一个方法，它用于将一个字典中的键值对更新到另一个字典中。如果存在相同的键，那么会用新的值覆盖旧的值。该方法有两种不同的用法：

传递一个字典作为参数，将该字典中的键值对更新到原字典中：
```python
dict1 = {'name': 'Alice', 'age': 20}
dict2 = {'age': 21, 'city': 'Beijing'}
dict1.update(dict2)
print(dict1)  # 输出 {'name': 'Alice', 'age': 21, 'city': 'Beijing'}
```
传递键值对作为参数，将它们添加到原字典中，如果键已经存在，则更新对应的值：

```python
dict1 = {'name': 'Alice', 'age': 20}
dict1.update(age=21, city='Beijing')
print(dict1)  # 输出 {'name': 'Alice', 'age': 21, 'city': 'Beijing'}
```
需要注意的是，如果传递了不合法的参数，比如传递了多个值给一个键，则会抛出TypeError异常。另外，update()方法并不返回任何值，它直接修改原字典对象。