在Python中，字典（dict）是一种内置的数据结构，它提供了键值对（key-value pairs）的存储方式。每个键都是唯一的，并且与一个值相关联。字典是Python中非常强大且灵活的数据类型，广泛应用于各种场景，如配置设置、数据存储、映射关系等。
字典的平均时间复杂度为O(1)用于查找、插入和删除操作。这是因为字典内部通常使用哈希表来实现。然而，在最坏的情况下（例如，所有键的哈希值都相同），时间复杂度可能会退化为O(n)。
内存使用方面，字典相对于列表等数据结构来说，内存开销可能更大，因为每个键值对都需要额外的存储空间来存储键和哈希值等信息。
下面是字典相关的操作示例：
# 创建字典与访问元素
dict1 = {} # 空字典
dict2 = {'name': 'Alice', 'age': 25} # 直接创建
print(dict2['name']) # 输出: Alice
print(dict2.get('age')) # 输出: 25（推荐避免KeyError）
dict3 = dict(name='Bob', age=30) # 使用dict构造函数
dict3['city'] = 'New York' # 向字典中添加另一个键值对
print(dict3) # 输出：{'name': 'Bob', 'age': 30, 'city': 'New York'}
entry = ('national', 'USA') # 准备一个新的键值对作为元组
dict3.update([entry]) # 需要列表形式[]
print(dict3) # 输出：{'name': 'Bob', 'age': 30, 'city': 'New York', 'national': 'USA'}
entries_list = [('national', 'UK'), ('occupation', 'Engineer')] # 创建一个包含多个键值对元组的列表
dict3.update(entries_list) # 使用update方法和包含多个元组的列表来更新字典
print(dict3) # 输出：{'name': 'Bob', 'age': 30, 'city': 'New York', 'national': 'UK', 'occupation': 'Engineer'}
dict4 = dict([('Jim', 23), ('Jacky', 22), ('Lucy', 21)])
print(dict4) # 输出：{'Jim': 23, 'Jacky': 22, 'Lucy': 21}
# 修改元素
dict2['age'] = 26 # 修改已有键的值
dict2['city'] = 'New York' # 添加新键值对
print(dict2) # 输出：{'name': 'Alice', 'age': 26, 'city': 'New York'}
# 删除元素
del dict2['city'] # 删除指定键
print(dict2) # 输出：{'name': 'Alice', 'age': 26}
value = dict2.pop('age') # 删除并返回对应值
print(value) # 输出：26
print(dict2) # 输出：{'name': 'Alice'}
dict2.clear() # 清空字典
print(dict2) # 输出：{}
# ############
my_dict = {'a': 1, 'b': 2, 'c': 3}
# 遍历键
for key in my_dict:
print(key, end='\t') # 输出：a b c
print() # 换行
# 遍历值
for value in my_dict.values():
print(value, end='\t') # 输出：1 2 3
print() # 换行
# 遍历键值对
for key, value in my_dict.items():
print(f"{key}: {value}", end='\t') # 输出：a: 1 b: 2 c: 3
print()
# #############
# 字典合并（Python 3.5+）
dict_a = {'a': 1, 'b': 2}
dict_b = {'b': 3, 'c': 4}
merged = dict_a | dict_b # 使用'|'合并字典,python3.9后推荐使用
print(merged) # 输出：{'a': 1, 'b': 3, 'c': 4}
merged = {**dict_a, **dict_b} #
print(merged) # 输出：{'a': 1, 'b': 3, 'c': 4}
merged = dict_a.copy() # 创建dict_a的一个副本，Python 3.5-3.8中推荐使用
merged.update(dict_b) # 使用dict_b中的键值对来更新merged
print(merged) # 输出：{'a': 1, 'b': 3, 'c': 4}
# 字典推导式
# range(5) 生成了一个从 0 到 4 的整数序列
# 对于序列中的每个整数 x，字典推导式计算 x**2（即 x 的平方），并将结果作为与键 x 关联的值存储在字典中。
# 得到了一个包含五个键值对的字典，其中每个键都是一个整数，每个值都是该整数的平方。
squares = {x: x ** 2 for x in range(5)} # {0:0, 1:1, 2:4...}
print(squares) # 输出：{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
#
# 键存在性检查
if 'a' in my_dict:
print("Key exists") # 输出：Key exists
# 设置默认值
count = my_dict.get('d', 0) # 若不存在返回0
print(count) # 输出：0
# 有序字典（Python 3.7+原生支持有序性）
from collections import OrderedDict
od = OrderedDict([('a', 1), ('b', 2)])
print(od) # 输出：OrderedDict({'a': 1, 'b': 2})
# ################
data = {'name': 'Alice', 'age': 30, 'city': 'Paris'}
# 获取所有键
keys = data.keys()
print(keys) # 输出：dict_keys(['name', 'age', 'city'])
# 获取所有值
values = data.values()
print(values) # 输出：dict_values(['Alice', 30, 'Paris'])
# 获取键值对元组列表
items = data.items()
print(items) # 输出：dict_items([('name', 'Alice'), ('age', 30), ('city', 'Paris')])
# 更新字典
data.update({'age': 31, 'country': 'FR'}) # 合并并覆盖
print(data) # 输出：{'name': 'Alice', 'age': 31, 'city': 'Paris', 'country': 'FR'}
# 删除最后一个元素（Python 3.7+）
last_item = data.popitem()
print(last_item) # 输出：('country', 'FR')
# ###############
# 多层嵌套字典
nested_dict = {
'user1': {'name': 'Alice', 'scores': [85, 90]},
'user2': {'name': 'Bob', 'scores': [78, 88]}
}
# 访问嵌套值，展示了如何在 Python 中通过多级键访问嵌套的数据结构。
# nested_dict['user1']：首先，从 nested_dict 中访问键 'user1' 对应的值，
# 这将返回另一部字典：{'name': 'Alice', 'scores': [85, 90]}。
# ['scores']：然后，从上一步返回的字典中访问键 'scores' 对应的值，这将返回一个列表：[85, 90]。
# [0]：最后，从上一步返回的列表中访问索引为 0 的元素，这将返回第一个分数：85。
print(nested_dict['user1']['scores'][0]) # 输出：85
#
# # 2. 字典排序
sorted_by_key = dict(sorted(data.items())) # 按键排序
print(sorted_by_key)
data.update({'age': '31'})
# 由于data字典中的值有int和str型，所以如果没有上面一行的代码，那么执行下面一行会有下面的错误提示：
# TypeError: '<' not supported between instances of 'int' and 'str'
sorted_by_val = dict(sorted(data.items(), key=lambda x: x[1])) # 按值排序
print(f"sorted by value:{sorted_by_key}") # 输出：sorted by value:{'age': 31, 'city': 'Paris', 'name': 'Alice'}
people = [ {'name': 'Alice', 'age': 30, 'city': 'Paris'}, {'name': 'Bob', 'age': 25, 'city': 'London'}]
# 按年龄排序人列表
sorted_people = sorted(people, key=lambda person: person['age'])
print(f"ascending sorted by age:{sorted_people}")
# 上面的代码输出：
# ascending sorted by age:[{'name': 'Bob', 'age': 25, 'city': 'London'}, {'name': 'Alice', 'age': 30, 'city': 'Paris'}]
# Python 的 sorted() 函数默认是按升序排列的，但可以通过指定 reverse=True 参数来按降序排列。
sorted_people = sorted(people, key=lambda person: person['age'], reverse=True)
print(f"descending sorted by age:{sorted_people}")
# 上面的代码输出：
# descending sorted by age:[{'name': 'Alice', 'age': 30, 'city': 'Paris'}, {'name': 'Bob', 'age': 25, 'city': 'London'}]
# 按城市排序人列表
sorted_people = sorted(people, key=lambda person: person['city'])
print(f"sorted by city:{sorted_people}")
# 上面的代码输出：
# sorted by city:[{'name': 'Bob', 'age': 25, 'city': 'London'}, {'name': 'Alice', 'age': 30, 'city': 'Paris'}]
#
# 默认字典（自动初始化缺失键）
from collections import defaultdict
dd = defaultdict(list)
# # 向 'fruits' 键对应的列表追加 'apple'
dd['fruits'].append('apple') # 自动创建空列表
print(dd) # 输出：defaultdict(<class 'list'>, {'fruits': ['apple']})
dd['vegetables'].append('carrot')
print(dd) # 输出：defaultdict(<class 'list'>, {'fruits': ['apple'], 'vegetables': ['carrot']})
#
# ############
# 综合示例：统计单词频率
text = "apple banana apple orange banana apple"
# 使用 split() 方法将字符串分割成一个单词列表。默认情况下，split() 方法按空格分割字符串。
words = text.split()
# 初始化一个空字典，用于存储单词及其出现次数。
word_count = {}
for word in words:
# 使用 get() 方法从 word_count 字典中获取当前单词的计数（如果单词不存在，则返回默认值 0），然后将计数加 1 并存回字典中。
word_count[word] = word_count.get(word, 0) + 1
print(f"wordCount:{word_count}") # 输出：wordCount:{'apple': 3, 'banana': 2, 'orange': 1}
