python 映射类型 dict

dict 定义

字典（Dict）是一种用于存储键-值对数据的数据结构。字典使用花括号{}来创建，每个键值对之间使用冒号:分隔。可变的、无序的、key不重复。

dict 的特点

键值对存储：字典是由键值对构成的集合，每个键值对之间使用冒号（:）分隔，键和值之间使用逗号分隔，所有键都是唯一的。
无序性：字典中的键值对是无序存储的，不会按照插入顺序排列。
可变性：字典是可变的，可以进行添加、修改和删除操作。
键的不可变性：字典中的键必须是不可变的，值可以是任意对象。

dict 初始化

dict()是一个内置函数，用于创建字典对象。
可以通过传递关键字参数或其他可迭代对象来创建字典。
关键字参数的写法是 key1=value1, key2=value2, ...，或者传递关键字参数的元组列表或字典。

# 使用关键字参数创建字典
my_dict1 = dict(name='Alice', age=30, city='New York')
print(my_dict1)  # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 使用元组列表创建字典
tuple_list = [('name', 'Bob'), ('age', 25), ('city', 'Los Angeles')]
my_dict2 = dict(tuple_list)
print(my_dict2)  # 输出: {'name': 'Bob', 'age': 25, 'city': 'Los Angeles'}

# 使用字典推导式创建字典
keys = ['name', 'age', 'city']
values = ['Dan', 40, 'London']
my_dict3 = {k: v for k, v in zip(keys, values)}
print(my_dict3)  # 输出: {'name': 'Dan', 'age': 40, 'city': 'London'}

# 使用关键字参数和默认值创建字典
default_values = ['default_name', 'default_age', 'default_city']
my_dict4 = dict.fromkeys(['name', 'age', 'city'], default_values)
print(my_dict4)  # 输出: {'name': ['default_name', 'default_age', 'default_city'], 'age': ['default_name', 'default_age', 'default_city'], 'city': ['default_name', 'default_age', 'default_city']}

字典元素的访问

[]：使用方括号 [] 加上键名来访问对应的值。如果键不存在，Python会抛出一个 KeyError。
get()：这种方法可以避免抛出 KeyError，如果键不存在，可以返回一个默认值。
setdefault()：如果键不存在于字典中，setdefault() 会添加键并将值设为默认值。如果键已存在，返回其对应的值。

# []
d = {'apple': 1, 'banana': 2}
print(d['apple'])  # 输出 1

# get()
d = {'apple': 1, 'banana': 2}
print(d.get('apple', 'Not Found'))  # 输出 1
print(d.get('cherry', 'Not Found'))  # 输出 'Not Found'

# setdefault()
d = {'apple': 1, 'banana': 2}
print(d.setdefault('apple', 3))  # 输出 1，因为键已存在
print(d.setdefault('cherry', 3))  # 输出 3，并添加 'cherry': 3 到字典
print(d)            # 输出: {'apple': 1, 'banana': 2, 'cherry': 3}

dict 元素增加修改

d[key] = value：将key对应的值修改为value。key不存在添加新的kv对。
update([other]) -> None：使用另一个字典的kv对更新本字典。key不存在，就添加。key存在，覆盖已经存在的key对应的值。就地修改。

# []
d = {'apple': 1, 'banana': 2}
d['cherry'] = 3  # 增加新的键值对
print(d)  # 输出 {'apple': 1, 'banana': 2, 'cherry': 3}

# 修改
d = {'apple': 1, 'banana': 2}
d['banana'] = 5  # 修改已存在的键 'banana' 的值
print(d)  # 输出 {'apple': 1, 'banana': 5}

# 使用 update() 方法
d = {'apple': 1, 'banana': 2}
d.update({'banana': 5, 'cherry': 3})  # 更新 'banana' 和增加 'cherry'
print(d)  # 输出 {'apple': 1, 'banana': 5, 'cherry': 3}

# 使用元组列表来更新
d.update([('mango', 4), ('banana', 6)])
print(d)  # 输出 {'apple': 1, 'banana': 6, 'cherry': 3, 'mango': 4}

dict 元素删除

del: 使用 del 可以删除字典中特定的键值对。如果尝试删除不存在的键，将会引发 KeyError。
pop(): pop() 方法用于删除字典中的特定项，并返回该项的值。如果键不存在，并且没有提供默认值，也会引发 KeyError。
clear(): 如果你想删除字典中的所有项，可以使用 clear() 方法。这会移除字典中的所有键值对，留下一个空字典。
popitem(): 这种方法主要用于在遍历字典时逐个删除项，或者当你需要随机移除字典中的元素而不必使用额外的库或函数。

# 使用 del 语句
d = {'apple': 1, 'banana': 2, 'cherry': 3}
del d['banana']  # 删除键 'banana' 及其对应的值
print(d)  # 输出 {'apple': 1, 'cherry': 3}

# 使用 pop() 方法
d = {'apple': 1, 'banana': 2, 'cherry': 3}
value = d.pop('banana')  # 删除 'banana' 并返回其值
print(value)  # 输出 2
print(d)  # 输出 {'apple': 1, 'cherry': 3}

value = d.pop('mango', 'Not Found')  # 尝试删除 'mango'，返回 'Not Found'
print(value)  # 输出 'Not Found'

# 使用 clear() 方法
d = {'apple': 1, 'banana': 2, 'cherry': 3}
d.clear()  # 清空字典
print(d)  # 输出 {}

d = {'apple': 1, 'banana': 2, 'cherry': 3}

# 移除最后一个键值对
item = d.popitem()
print(item)  # 输出 ('cherry', 3)
print(d)     # 输出 {'apple': 1, 'banana': 2}

# 再次移除最后一个键值对
item = d.popitem()
print(item)  # 输出 ('banana', 2)
print(d)     # 输出 {'apple': 1}

# 最后一次使用 popitem()
item = d.popitem()
print(item)  # 输出 ('apple', 1)
print(d)     # 输出 {}

# 如果再次尝试 popitem()，字典已为空，将抛出 KeyError
try:
    d.popitem()
except KeyError:
    print("Error: The dictionary is empty.")

dict 遍历

遍历字典

# 遍历所有键
d = {'apple': 1, 'banana': 2, 'cherry': 3}
for key in d:
    print(key, d[key])
# 输出：apple 1 banana 2 cherry 3

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

# 遍历所有键和值
for key, value in d.items():
    print(key, value)
# 输出：apple 1 banana 2 cherry 3

# 使用 enumerate 遍历字典的键值对
my_dict = {"name": "Alice", "age": 30, "city": "New York"}
for index, (key, value) in enumerate(my_dict.items()):
    print(f"Index {index}: Key: {key}, Value: {value}")
# 输出：Index 0: Key: name, Value: Alice Index 1: Key: age, Value: 30 Index 2: Key: city, Value: New York

在遍历中删除元素

# 使用列表的副本来遍历键：
d = {'apple': 1, 'banana': 2, 'cherry': 3}
for key in list(d.keys()):  # 使用 keys() 的列表副本
    if d[key] > 1:
        del d[key]
print(d)  # 输出 {'apple': 1}

# 使用 items() 方法并复制
for key, value in list(d.items()):  # 使用 items() 的列表副本
    if value > 1:
        del d[key]
print(d)  # 输出 {'apple': 1}

# 通过 popitem() 方法遍历和修改
d = {'apple': 1, 'banana': 2, 'cherry': 3}
while d:
    key, value = d.popitem()
    print(f'Removed {key} with value {value}')  # 输出：Removed cherry with value 3  Removed banana with value 2  Removed apple with value 1
    # 可以根据需要添加更多逻辑
print(d)  # 输出空字典 {}

defaultdict

defaultdict 是 collections 模块提供的一种字典子类，它可以设定默认值类型，当访问不存在的键时，会自动创建对应类型的默认值，而不会引发 KeyError 异常。

defaultdict 的特点 

设定默认值类型：通过指定一个默认的工厂函数，defaultdict 允许在访问缺失键时自动创建该类型的默认值。
无需手动检查键是否存在：使用 defaultdict 可以避免手动检查键是否存在，简化代码逻辑。
方便的默认值初始化：在处理频繁的键值访问时，defaultdict 可以减少代码量，并且使得代码更加清晰和高效。

defaultdict 的初始化

# 创建一个 defaultdict，默认值类型为列表
from collections import defaultdict

num_dict = defaultdict(list)
num_dict['odd'].append(1)
num_dict['even'].append(2)
num_dict['odd'].append(3)

print(num_dict)  # 输出: defaultdict(<class 'list'>, {'odd': [1, 3], 'even': [2]})

# 创建一个 defaultdict，默认值类型为 int
from collections import defaultdict

count_dict = defaultdict(int)
days = ['Mon', 'Tue', 'Wed', 'Thu']

for day in days:
    count_dict[day] += 1

print(count_dict)  # 输出: defaultdict(<class 'int'>, {'Mon': 1, 'Tue': 1, 'Wed': 1, 'Thu': 1})

from collections import defaultdict

# 创建一个 defaultdict，默认值类型为 lambda 函数
char_dict = defaultdict(lambda: 'Unknown')
char_dict['a'] = 'Apple'
char_dict['b'] = 'Banana'

print(char_dict['c'])   # 输出: Unknown，自动创建默认值
print(char_dict)  # 输出: defaultdict(<function <lambda> at 0x000001A285C067A0>, {'a': 'Apple', 'b': 'Banana', 'c': 'Unknown'})

defaultdict 使用示例

# 计数器
from collections import defaultdict

counter = defaultdict(int)
words = ["apple", "banana", "apple", "orange", "banana", "apple"]
for word in words:
    counter[word] += 1

print(counter)  # 输出: defaultdict(<class 'int'>, {'apple': 3, 'banana': 2, 'orange': 1})

# 多值映射
from collections import defaultdict

multi_dict = defaultdict(list)

multi_dict["fruits"].append("apple")
multi_dict["fruits"].append("banana")
multi_dict["vegetables"].append("carrot")

print(multi_dict)  # 输出: defaultdict(<class 'list'>, {'fruits': ['apple', 'banana'], 'vegetables': ['carrot']})

# 分组
from collections import defaultdict

grouped_data = defaultdict(list)
records = [("John", "Apple"), ("Anna", "Banana"), ("John", "Banana"), ("Anna", "Apple")]
for name, fruit in records:
    grouped_data[name].append(fruit)

print(grouped_data)  # 输出: defaultdict(<class 'list'>, {'John': ['Apple', 'Banana'], 'Anna': ['Banana', 'Apple']})

OrderedDict

OrderedDict 是 collections 模块提供的一个有序字典（Ordered Dictionary），它会记住元素插入的顺序，因此迭代它时会按照元素插入的顺序进行。

OrderedDict 的特点

保持顺序：OrderedDict 跟踪键值对的插入顺序，允许按照添加顺序迭代键值对。
重新排序功能：OrderedDict 提供了重新排序的方法，例如 move_to_end 和 popitem，这些方法可以用来改变或者维护键的顺序。
适用场景：当需要按照插入顺序遍历字典中的元素时，或者需要在保存键值对时保持固定顺序时，OrderedDict 特别有用。

OrderedDict 初始化

可以通过将一个键值对列表传递给 OrderedDict 的构造器来初始化它，或者使用关键字参数。

from collections import OrderedDict

# 通过列表初始化
items = [("apple", 1), ("banana", 2)]
ordered_dict = OrderedDict(items)
print(ordered_dict)    # 输出: OrderedDict([('apple', 1), ('banana', 2)])

# 通过关键字参数初始化
ordered_dict = OrderedDict(apple=1, banana=2)
print(ordered_dict)    # 输出: OrderedDict([('apple', 1), ('banana', 2)])

OrderedDict 的示例

# 添加元素，并显示元素保持插入顺序
from collections import OrderedDict

ordered_dict = OrderedDict()
ordered_dict["apple"] = 1
ordered_dict["banana"] = 2
ordered_dict["orange"] = 3

for key, value in ordered_dict.items():
    print(key, value)
# 输出: apple 1, banana 2, orange 3

# 移动元素到末尾
from collections import OrderedDict

ordered_dict = OrderedDict(apple=1, banana=2, orange=3)
print("Original:", ordered_dict)   # 输出: Original: OrderedDict([('apple', 1), ('banana', 2), ('orange', 3)])

ordered_dict.move_to_end('banana')
print("After moving banana to end:", ordered_dict)    # 输出: After moving banana to end: OrderedDict([('apple', 1), ('orange', 3), ('banana', 2)])

# 使用 popitem。popitem 方法类似于普通字典的 popitem，但是可以控制弹出的是最后还是最先插入的项：
from collections import OrderedDict

ordered_dict = OrderedDict(apple=1, banana=2, orange=3)
print("Original:", ordered_dict)   # 输出: Original: OrderedDict([('apple', 1), ('banana', 2), ('orange', 3)])

# 弹出最后一个元素
last_item = ordered_dict.popitem()
print("Popped last item:", last_item)  # 输出: Popped last item: ('orange', 3)
print("After popping last item:", ordered_dict)   # 输出: After popping last item: OrderedDict([('apple', 1), ('banana', 2)])

# 弹出第一个元素
first_item = ordered_dict.popitem(last=False)
print("Popped first item:", first_item)    # 输出: Popped first item: ('apple', 1)
print("After popping first item:", ordered_dict) # 输出: After popping first item: OrderedDict([('banana', 2)])

参考文档

https://docs.python.org/zh-cn/3.12/library/stdtypes.html#/mapping-types-dict