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
标签：输出,apple,映射,python,dict,print,banana,字典 From： https://www.cnblogs.com/wangguishe/p/18138638