当前位置：首页 > news >正文

python之dict

news 2024/11/6 16:53:45

一、 dict常用用法

1. 创建字典

使用花括号 `{}` 创建字典

# 创建一个空字典
empty_dict = {}# 创建一个包含键值对的字典
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
print(my_dict)

使用 `dict()` 函数创建字典

# 使用 dict() 函数创建字典
my_dict = dict(name='Alice', age=25, city='New York')
print(my_dict)

2. 访问字典中的值

使用键访问值

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 访问字典中的值
name = my_dict['name']
age = my_dict['age']
print(name)  # 输出: Alice
print(age)   # 输出: 25

使用 `get()` 方法访问值

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 使用 get() 方法访问值
name = my_dict.get('name')
age = my_dict.get('age')
print(name)  # 输出: Alice
print(age)   # 输出: 25# 如果键不存在，get() 方法可以返回一个默认值
address = my_dict.get('address', 'Unknown')
print(address)  # 输出: Unknown

3. 修改字典

添加或更新键值对

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 添加新的键值对
my_dict['email'] = 'alice@example.com'
print(my_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}# 更新已有的键值对
my_dict['age'] = 26
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'email': 'alice@example.com'}

4. 删除键值对

使用 `del` 关键字删除键值对

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 删除键值对
del my_dict['age']
print(my_dict)  # 输出: {'name': 'Alice', 'city': 'New York'}

使用 `pop()` 方法删除键值对并返回值

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 使用 pop() 方法删除键值对并返回值
age = my_dict.pop('age')
print(age)      # 输出: 25
print(my_dict)  # 输出: {'name': 'Alice', 'city': 'New York'}

5. 遍历字典

遍历键

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 遍历字典的键
for key in my_dict:print(key)
# 输出:
# name
# age
# city

遍历值

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 遍历字典的值
for value in my_dict.values():print(value)
# 输出:
# Alice
# 25
# New York

遍历键值对

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 遍历字典的键值对
for key, value in my_dict.items():print(f"{key}: {value}")
# 输出:
# name: Alice
# age: 25
# city: New York

6. 检查键是否存在

使用 `in` 关键字检查键是否存在

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 检查键是否存在
if 'name' in my_dict:print("Name is in the dictionary")
else:print("Name is not in the dictionary")
# 输出: Name is in the dictionaryif 'address' in my_dict:print("Address is in the dictionary")
else:print("Address is not in the dictionary")
# 输出: Address is not in the dictionary

7. 字典的其他操作

获取字典的长度

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 获取字典的长度
length = len(my_dict)
print(length)  # 输出: 3

清空字典

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 清空字典
my_dict.clear()
print(my_dict)  # 输出: {}

复制字典

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}# 复制字典
new_dict = my_dict.copy()
print(new_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

8. 字典推导式

使用字典推导式创建字典

# 使用字典推导式创建字典
squares = {x: x**2 for x in range(5)}
print(squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

`9.dict.fromkeys`

dict.fromkeys是 Python 字典的一个类方法，用于创建一个新的字典，其中的键来自一个可迭代对象，而所有键对应的值都是同一个指定的值。这个方法非常有用，特别是在需要初始化一个具有相同默认值的字典时。

语法

dict.fromkeys(iterable, value=None)

iterable：一个可迭代对象，如列表、元组、集合等，包含将要作为字典键的元素。
value：可选参数，所有键对应的初始值，默认为 None。

示例

创建一个空值的字典

keys = ['a', 'b', 'c']
new_dict = dict.fromkeys(keys)
print(new_dict)  # 输出: {'a': None, 'b': None, 'c': None}

创建一个具有指定值的字典

keys = ['a', 'b', 'c']
value = 0
new_dict = dict.fromkeys(keys, value)
print(new_dict)  # 输出: {'a': 0, 'b': 0, 'c': 0}

应用场景

初始化配置字典：在配置文件中初始化默认值。
创建默认值字典：在处理数据时，为某些键设置默认值。

示例代码

初始化配置字典

# 定义配置项
config_keys = ['host', 'port', 'user', 'password']# 使用 fromkeys 创建配置字典，初始值为 None
config_dict = dict.fromkeys(config_keys)
print(config_dict)  # 输出: {'host': None, 'port': None, 'user': None, 'password': None}# 为配置项赋值
config_dict['host'] = 'localhost'
config_dict['port'] = 8080
config_dict['user'] = 'admin'
config_dict['password'] = 'secret'print(config_dict)
# 输出: {'host': 'localhost', 'port': 8080, 'user': 'admin', 'password': 'secret'}

创建默认值字典

# 定义键
keys = ['apple', 'banana', 'cherry']# 使用 fromkeys 创建默认值字典，初始值为 0
default_dict = dict.fromkeys(keys, 0)
print(default_dict)  # 输出: {'apple': 0, 'banana': 0, 'cherry': 0}# 更新字典中的值
default_dict['apple'] = 5
default_dict['banana'] = 3
default_dict['cherry'] = 7print(default_dict)
# 输出: {'apple': 5, 'banana': 3, 'cherry': 7}

注意事项

值的引用：如果 value 是一个可变对象（如列表），那么所有键将引用同一个对象。修改其中一个键的值会影响所有键的值。

keys = ['a', 'b', 'c']
value = []
new_dict = dict.fromkeys(keys, value)# 修改一个键的值
new_dict['a'].append(1)
print(new_dict)  # 输出: {'a': [1], 'b': [1], 'c': [1]}# 如果需要每个键有不同的值，可以使用列表推导式
new_dict = {key: [] for key in keys}
new_dict['a'].append(1)
print(new_dict)  # 输出: {'a': [1], 'b': [], 'c': []}

键的唯一性：dict.fromkeys 会自动处理重复的键，确保字典中的键是唯一的。

二. 补充内容

1. 字典的合并

使用 `update()` 方法合并字典

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}# 使用 update() 方法合并字典
dict1.update(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

使用字典解包合并字典（Python 3.5+）

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}# 使用字典解包合并字典
merged_dict = {**dict1, **dict2}
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

2. 字典的排序

按键排序

my_dict = {'c': 3, 'a': 1, 'b': 2}# 按键排序
sorted_dict = dict(sorted(my_dict.items()))
print(sorted_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

按值排序

my_dict = {'c': 3, 'a': 1, 'b': 2}# 按值排序
sorted_dict = dict(sorted(my_dict.items(), key=lambda item: item[1]))
print(sorted_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

3. 默认值和 `defaultdict`

使用 `defaultdict` 设置默认值

from collections import defaultdict# 创建一个 defaultdict，设置默认值为 0
my_dict = defaultdict(int)# 访问不存在的键
my_dict['a'] += 1
my_dict['b'] += 2
print(my_dict)  # 输出: defaultdict(<class 'int'>, {'a': 1, 'b': 2})

4. 字典的嵌套

嵌套字典

nested_dict = {'person1': {'name': 'Alice', 'age': 25},'person2': {'name': 'Bob', 'age': 30}
}# 访问嵌套字典中的值
print(nested_dict['person1']['name'])  # 输出: Alice

5. 字典的过滤

使用字典推导式过滤字典

my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}# 过滤出值大于 2 的键值对
filtered_dict = {k: v for k, v in my_dict.items() if v > 2}
print(filtered_dict)  # 输出: {'c': 3, 'd': 4}

6. 字典的映射

使用 `map()` 和 `dict()` 进行映射

my_dict = {'a': 1, 'b': 2, 'c': 3}# 将字典的值平方
mapped_dict = dict(map(lambda item: (item[0], item[1] ** 2), my_dict.items()))
print(mapped_dict)  # 输出: {'a': 1, 'b': 4, 'c': 9}

7. 字典的反向（键值对交换）

反转字典的键值对

my_dict = {'a': 1, 'b': 2, 'c': 3}# 反转字典的键值对
reversed_dict = {v: k for k, v in my_dict.items()}
print(reversed_dict)  # 输出: {1: 'a', 2: 'b', 3: 'c'}

8. 字典的序列化和反序列化

使用 `json` 模块进行序列化和反序列化

import jsonmy_dict = {'a': 1, 'b': 2, 'c': 3}# 序列化字典为 JSON 字符串
json_str = json.dumps(my_dict)
print(json_str)  # 输出: '{"a": 1, "b": 2, "c": 3}'# 反序列化 JSON 字符串为字典
new_dict = json.loads(json_str)
print(new_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

9. 字典的合并和去重

合并多个字典并去重

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict3 = {'a': 1, 'd': 5}# 合并多个字典并去重
merged_dict = {k: v for d in [dict1, dict2, dict3] for k, v in d.items()}
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4, 'd': 5}

10. 字典的键和值的转换

将字典的键和值互换

my_dict = {'a': 1, 'b': 2, 'c': 3}# 将字典的键和值互换
swapped_dict = {v: k for k, v in my_dict.items()}
print(swapped_dict)  # 输出: {1: 'a', 2: 'b', 3: 'c'}

11. 字典的条件更新

使用条件表达式更新字典

my_dict = {'a': 1, 'b': 2, 'c': 3}# 使用条件表达式更新字典
updated_dict = {k: (v + 1 if v > 1 else v) for k, v in my_dict.items()}
print(updated_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

12. 字典的键值对计数

使用 `collections.Counter` 计算字典中值的出现次数

from collections import Countermy_dict = {'a': 1, 'b': 2, 'c': 1, 'd': 2, 'e': 3}# 计算字典中值的出现次数
value_counts = Counter(my_dict.values())
print(value_counts)  # 输出: Counter({1: 2, 2: 2, 3: 1})

查看全文

http://www.mrgr.cn/news/66861.html