python字典的用法

最新推荐文章于 2024-07-12 16:16:27 发布

Tallbo

最新推荐文章于 2024-07-12 16:16:27 发布

阅读量607

点赞数 20

分类专栏： python工程师学习笔记文章标签： python 开发语言

本文链接：https://blog.csdn.net/Tallbo/article/details/140372687

版权

python工程师学习笔记专栏收录该内容

15 篇文章 2 订阅

订阅专栏

一. 创建方法

1. 基础创建方法

使用字面量语法
- 空字典
```
d = {}
```
  创建一个空字典。
- 带初始值的字典
```
d = {'key1': 'value1', 'key2': 'value2'}
```
  创建一个包含指定键值对的字典。
使用 dict() 构造函数
- 关键字参数
```
d = dict(key1='value1', key2='value2')
```
  使用关键字参数创建字典，其中键是参数名，值是参数值。
- 键值对的元组列表
```
d = dict([('key1', 'value1'), ('key2', 'value2')])
```
  使用键值对的元组列表创建字典。
- 键值对的生成器
```
d = dict(((k, v) for k, v in [('key1', 'value1'), ('key2', 'value2')]))
```
  使用生成器表达式创建字典。
- 使用 zip() 函数
```
keys = ['key1', 'key2']
values = ['value1', 'value2']
d = dict(zip(keys, values))
```
  使用 zip() 函数将两个序列（键和值）配对，创建字典。
使用 fromkeys() 方法
- 创建具有相同值的字典
```
keys = ['key1', 'key2']
d = dict.fromkeys(keys, 'default_value')
```
  使用 fromkeys() 方法创建一个新字典，所有键的默认值为 'default_value'。
- 创建具有默认值的字典
```
keys = ['key1', 'key2']
d = dict.fromkeys(keys)  # 默认值为 None
```
  使用 fromkeys() 方法创建一个新字典，所有键的默认值为 None。

2. 字典推导式

简单字典推导
```
d = {x: x**2 for x in (2, 3, 4)}
```
使用字典推导式创建一个字典，其中每个键是序列中的值，每个值是其平方。
带条件的字典推导
```
d = {x: x**2 for x in range(5) if x % 2 == 0}
```
使用字典推导式创建一个字典，其中每个键是序列中的值，每个值是其平方，但仅包含偶数键。

3. 使用 `copy` 模块

浅拷贝字典
```
original = {'key1': 'value1', 'key2': 'value2'}
shallow_copy = original.copy()
```
创建原始字典的浅拷贝，新字典与原字典共享同一嵌套对象的引用。

深拷贝字典

import copy
original_dict = {
    'key1': 'value1',
    'key2': {
        'subkey1': 'subvalue1',
        'subkey2': ['listitem1', 'listitem2']
    }
}
deep_copy = copy.deepcopy(original_dict)

使用 deepcopy() 创建原字典的深拷贝，新字典及其所有嵌套对象都是完全独立的。

4. 高级字典类型

collections.defaultdict
```
from collections import defaultdict
d = defaultdict(list)  # 默认值为 []
```
创建一个字典，如果访问的键不存在，则返回默认值（这里是空列表）。
collections.OrderedDict
```
from collections import OrderedDict
d = OrderedDict([('key1', 'value1'), ('key2', 'value2')])
```
创建一个保持插入顺序的字典（Python 3.7 及更高版本的普通字典也保持顺序）。
collections.Counter
```
from collections import Counter
d = Counter('abracadabra')
```
创建一个计数器字典，其中键是元素，值是元素出现的次数。

collections.ChainMap

from collections import ChainMap
d1 = {'key1': 'value1'}
d2 = {'key2': 'value2'}
combined = ChainMap(d1, d2)

创建一个合并的字典视图，按顺序查找多个字典中的键。

types.MappingProxyType

from types import MappingProxyType
d = {'key1': 'value1'}
read_only_d = MappingProxyType(d)

创建字典的只读视图，原字典可变，视图不可变。

5. 自定义字典类型

自定义字典类型

class MyDict(dict):
    def __setitem__(self, key, value):
        print(f'Adding {key}: {value}')
        super().__setitem__(key, value)

d = MyDict()
d['key1'] = 'value1'

通过继承 dict 创建一个自定义字典类型，重写 __setitem__ 方法，增加自定义行为。

6. 使用 JSON 模块

从 JSON 字符串创建字典

import json
json_str = '{"key1": "value1", "key2": "value2"}'
d = json.loads(json_str)

从 JSON 字符串中解析并创建字典。

7. 字典合并

使用解包操作符

d1 = {'key1': 'value1'}
d2 = {'key2': 'value2'}
merged_dict = {**d1, **d2}

使用解包操作符 ** 合并多个字典。

使用字典合并运算符 (Python 3.9+)
- 合并字典
```
d1 = {'key1': 'value1'}
d2 = {'key2': 'value2'}
merged_dict = d1 | d2
```
  使用 | 运算符合并字典，新字典包含所有键值对。
- 更新字典
```
d1 = {'key1': 'value1'}
d2 = {'key2': 'value2'}
d1 |= d2
```
  使用 |= 运算符更新字典，将 d2 中的键值对添加到 d1 中。

8. 使用生成器

字典生成器表达式
```
d = dict((key, value) for key, value in zip(['key1', 'key2'], ['value1', 'value2']))
```
使用生成器表达式创建字典，通过 zip() 函数将键和值配对生成字典。

二. 查询方法

1. 基础查询方法

dict.get()

value = d.get('key', 'default_value')  # 查询键的值，如果键不存在，则返回 'default_value'

dict.setdefault()

value = d.setdefault('key', 'default_value')  # 查询键的值，如果键不存在，则设置键的值为 'default_value'

dict.pop()

value = d.pop('key', 'default_value')  # 查询并移除键的值，如果键不存在，则返回 'default_value'

dict.popitem()

key, value = d.popitem()  # 移除并返回字典中的最后一个键值对（Python 3.7+）

2. 键和值查询

dict.keys()

keys = d.keys()  # 返回一个视图对象，包含字典的所有键

dict.values()

values = d.values()  # 返回一个视图对象，包含字典的所有值

dict.items()

items = d.items()  # 返回一个视图对象，包含字典的所有 (键, 值) 对

3. 高级查询特性

dict.fromkeys()

new_dict = dict.fromkeys(['key1', 'key2'], 'default_value')  # 创建一个新的字典，所有键的值为 'default_value'

dict.get() with Multiple Keys

values = {k: d.get(k) for k in ['key1', 'key2']}  # 使用多个键获取对应值

dict.viewkeys(), dict.viewvalues(), dict.viewitems() (Python 2.x)

# Python 2.x 方法示例，不适用于 Python 3.x
viewkeys = d.viewkeys()  # 返回视图对象，包含字典的所有键
viewvalues = d.viewvalues()  # 返回视图对象，包含字典的所有值
viewitems = d.viewitems()  # 返回视图对象，包含字典的所有 (键, 值) 对

4. 自定义查询

自定义字典类的查询方法

class MyDict(dict):
    def __contains__(self, key):
        print(f'Checking if {key} is in the dictionary')
        return super().__contains__(key)

d = MyDict({'key1': 'value1'})
exists = 'key1' in d  # 输出 "Checking if key1 is in the dictionary" 然后返回 True

5. 使用 `collections` 模块

collections.defaultdict

from collections import defaultdict
d = defaultdict(lambda: 'default_value')  # 默认值为 'default_value'
value = d['non_existing_key']  # 查询不存在的键，返回默认值 'default_value'

collections.Counter

from collections import Counter
counter = Counter({'key1': 2, 'key2': 1})
count = counter['key1']  # 返回键 'key1' 的计数，即 2

collections.OrderedDict

from collections import OrderedDict
d = OrderedDict([('key1', 'value1'), ('key2', 'value2')])

collections.ChainMap

from collections import ChainMap
d1 = {'key1': 'value1'}
d2 = {'key2': 'value2'}
combined = ChainMap(d1, d2)
value = combined['key1']  # 查询合并后的字典中的值

types.MappingProxyType

from types import MappingProxyType
d = {'key1': 'value1'}
read_only_d = MappingProxyType(d)
value = read_only_d['key1']  # 查询只读字典中的值

6. JSON 处理

从 JSON 字符串创建字典

import json
json_str = '{"key1": "value1", "key2": "value2"}'
d = json.loads(json_str)  # 将 JSON 字符串转换为字典

将字典转换为 JSON 字符串

json_str = json.dumps(d)  # 将字典转换为 JSON 字符串

7. 其他查询方法

dict 与 set 操作的交互

d = {'key1': 'value1', 'key2': 'value2'}
set_of_keys = set(d.keys())

通过 lambda 函数进行动态查询

d = {'key1': 'value1', 'key2': 'value2'}
query = lambda k: d.get(k, 'default_value')
value = query('key1')  # 返回 'value1'

dict 视图对象与转换

d = {'key1': 'value1', 'key2': 'value2'}
keys_list = list(d.keys())  # 将键视图转换为列表

字典视图对象的操作

d = {'key1': 'value1', 'key2': 'value2'}
keys_view = d.keys()
keys_list = list(keys_view)  # 将视图对象转换为列表进行操作

三. 修改方法

1. 基础修改方法

添加或更新键值对

d = {'key1': 'value1'}
d['key2'] = 'value2'  # 添加新键 'key2'，值为 'value2'
d['key1'] = 'new_value1'  # 更新键 'key1' 的值为 'new_value1'

使用 update() 方法

d = {'key1': 'value1'}
d.update({'key2': 'value2'})  # 添加或更新多个键值对
d.update(key3='value3', key4='value4')  # 另一种更新方式，传入关键字参数

2. 删除键值对

使用 del 关键字

d = {'key1': 'value1', 'key2': 'value2'}
del d['key1']  # 删除键 'key1' 和对应的值

使用 pop() 方法

d = {'key1': 'value1', 'key2': 'value2'}
value = d.pop('key1')  # 移除键 'key1'，并返回其值
value = d.pop('key3', 'default_value')  # 如果键 'key3' 不存在，返回 'default_value'

使用 popitem() 方法

d = {'key1': 'value1', 'key2': 'value2'}
key, value = d.popitem()  # 移除并返回字典中的最后一个 (键, 值) 对

使用 clear() 方法

d = {'key1': 'value1', 'key2': 'value2'}
d.clear()  # 清空字典，删除所有键值对

3. 修改键

通过创建新字典进行键修改

d = {'key1': 'value1', 'key2': 'value2'}
d = {('new_key1' if k == 'key1' else k): v for k, v in d.items()}

通过 pop() 和 update() 方法修改键

d = {'key1': 'value1', 'key2': 'value2'}
value = d.pop('key1')
d.update({'new_key1': value})

4. 高级修改特性

使用 defaultdict 修改

from collections import defaultdict
d = defaultdict(int)
d['key1'] += 1  # 修改或初始化键 'key1' 的值为 1

collections.ChainMap 合并和修改

from collections import ChainMap
d1 = {'key1': 'value1'}
d2 = {'key2': 'value2'}
combined = ChainMap(d1, d2)
combined['key3'] = 'value3'  # 修改合并后的字典（实际更新的是 d1）

collections.OrderedDict 修改

from collections import OrderedDict
d = OrderedDict([('key1', 'value1'), ('key2', 'value2')])
d.move_to_end('key1')  # 将 'key1' 移动到末尾（Python 3.7+）

使用 MappingProxyType 创建只读视图

from types import MappingProxyType
d = {'key1': 'value1'}
read_only_d = MappingProxyType(d)
# 不能修改 read_only_d，因为它是只读的

5. 其他修改方法

通过字典推导式修改

d = {'key1': 'value1', 'key2': 'value2'}
d = {k: (v + '_modified' if k == 'key1' else v) for k, v in d.items()}

使用 dict 方法 copy() 修改

d = {'key1': 'value1'}
d_copy = d.copy()
d_copy['key2'] = 'value2'  # 修改副本，不影响原字典

通过 JSON 处理修改

import json
d = {'key1': 'value1'}
json_str = json.dumps(d)
d_new = json.loads(json_str)
d_new['key2'] = 'value2'  # 修改解析后的字典

自定义字典类的修改

class MyDict(dict):
    def __setitem__(self, key, value):
        print(f'Setting {key} to {value}')
        super().__setitem__(key, value)

d = MyDict({'key1': 'value1'})
d['key2'] = 'value2'  # 输出 "Setting key2 to value2" 然后更新字典

下面是 Python 字典的所有“删除”方法和操作特性的详细分类汇总：

四. 删除方法

1. 基础删除方法

使用 del 关键字

d = {'key1': 'value1', 'key2': 'value2'}
del d['key1']  # 删除键 'key1' 和对应的值
# 如果键不存在，会引发 KeyError

使用 pop() 方法

d = {'key1': 'value1', 'key2': 'value2'}
value = d.pop('key1')  # 移除键 'key1'，并返回其值
# 如果键不存在，会引发 KeyError，除非提供了默认值
value = d.pop('key3', 'default_value')  # 如果键 'key3' 不存在，返回 'default_value'

使用 popitem() 方法

d = {'key1': 'value1', 'key2': 'value2'}
key, value = d.popitem()  # 移除并返回字典中的最后一个 (键, 值) 对
# 在空字典上调用会引发 KeyError

使用 clear() 方法

d = {'key1': 'value1', 'key2': 'value2'}
d.clear()  # 清空字典，删除所有键值对
# 结果是一个空字典 {}

2. 高级删除特性

collections.OrderedDict 中的 move_to_end() 方法

from collections import OrderedDict
d = OrderedDict([('key1', 'value1'), ('key2', 'value2')])
d.move_to_end('key1')  # 将 'key1' 移动到末尾（Python 3.7+）
# 注意：此操作不会删除键，只是重新排序

使用 defaultdict 删除键

from collections import defaultdict
d = defaultdict(int)
d['key1'] = 1
del d['key1']  # 删除键 'key1'，defaultdict 不会抛出 KeyError
# 注意：删除键后，访问该键会引发 KeyError

collections.ChainMap 中的删除

from collections import ChainMap
d1 = {'key1': 'value1'}
d2 = {'key2': 'value2'}
combined = ChainMap(d1, d2)
del d1['key1']  # 删除 d1 中的键 'key1'
# 删除操作仅影响第一个字典 d1，不会影响其他合并的字典

3. 其他删除方法

通过字典推导式删除键

d = {'key1': 'value1', 'key2': 'value2'}
d = {k: v for k, v in d.items() if k != 'key1'}  # 删除键 'key1'
# 生成一个新的字典，不会修改原字典

通过 dict 方法 copy() 删除

d = {'key1': 'value1', 'key2': 'value2'}
d_copy = d.copy()
del d_copy['key1']  # 删除副本中的键 'key1'
# 原字典 d 不受影响

删除字典视图中的键

d = {'key1': 'value1', 'key2': 'value2'}
keys_view = d.keys()
# keys_view 本身不可修改，但可以通过修改原字典来影响视图

使用 MappingProxyType 创建只读视图

from types import MappingProxyType
d = {'key1': 'value1'}
read_only_d = MappingProxyType(d)
# 不能直接修改 read_only_d，因为它是只读的

五. 遍历方法

1. 遍历键

使用 for 循环遍历字典的键：

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict:
    print(key)

这将输出：

a
b
c

2. 遍历值

使用 values() 方法遍历字典的值：

my_dict = {'a': 1, 'b': 2, 'c': 3}
for value in my_dict.values():
    print(value)

这将输出：

1
2
3

3. 遍历键值对

使用 items() 方法遍历字典的键值对：

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
    print(f"Key: {key}, Value: {value}")

这将输出：

Key: a, Value: 1
Key: b, Value: 2
Key: c, Value: 3

4. 遍历并计算

计算所有值的总和：

my_dict = {'a': 1, 'b': 2, 'c': 3}
total = sum(my_dict.values())
print(total)  # 输出 6

5. 使用字典视图

遍历键视图：

my_dict = {'a': 1, 'b': 2, 'c': 3}
keys_view = my_dict.keys()
for key in keys_view:
    print(key)

遍历值视图：

my_dict = {'a': 1, 'b': 2, 'c': 3}
values_view = my_dict.values()
for value in values_view:
    print(value)

遍历项视图：

my_dict = {'a': 1, 'b': 2, 'c': 3}
items_view = my_dict.items()
for key, value in items_view:
    print(f"Key: {key}, Value: {value}")

6. 使用字典推导式

生成新的字典：

my_dict = {'a': 1, 'b': 2, 'c': 3}
squared_dict = {key: value**2 for key, value in my_dict.items()}
print(squared_dict)  # 输出 {'a': 1, 'b': 4, 'c': 9}

7. 结合其他数据结构

遍历字典和列表：

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict:
    print(f"Key: {key}, Value: {my_dict[key]}")

将字典的键或值与列表结合：

my_dict = {'a': 1, 'b': 2, 'c': 3}
keys = list(my_dict.keys())
values = list(my_dict.values())
for key, value in zip(keys, values):
    print(f"Key: {key}, Value: {value}")