字典

# ------------------- 1. 创建 (Create) -------------------
# 方式一：使用大括号 {} 字面量创建（最常用）
user_profile = {
    "username": "Alice",       # 键: "username"，值: "Alice"
    "email": "alice@example.com",
    "followers": 150
}
print(f"新用户创建: {user_profile}")

# 方式二：使用 dict() 构造函数，关键字参数风格
user_settings = dict(theme="dark", notifications_enabled=True)
print(f"用户设置: {user_settings}")

# 方式三：使用 dict() 传入键值对列表（适合动态生成）
pairs = [("name", "Bob"), ("age", 25)]
user_from_pairs = dict(pairs)
print(f"从列表创建: {user_from_pairs}")

# 方式四：使用 dict.fromkeys() 批量创建同值字典
keys = ["a", "b", "c"]
same_val_dict = dict.fromkeys(keys, 0)   # 所有键初始值为 0
print(f"fromkeys 创建: {same_val_dict}")


# ------------------- 2. 访问 (Read) -------------------
# 方式一：方括号 []，键不存在时抛出 KeyError
print(f"用户名: {user_profile['username']}")

# 方式二：get() 方法，键不存在时返回默认值（更安全）
print(f"邮箱: {user_profile.get('email')}")
print(f"地理位置: {user_profile.get('location', '未设置')}")  # 键不存在 → 返回 '未设置'

# 判断键是否存在（推荐用 in，不用 has_key，Python 3 已移除）
if 'followers' in user_profile:
    print(f"粉丝数: {user_profile['followers']}")


# ------------------- 3. 修改与添加 (Update) -------------------
# 修改现有键的值
user_profile['followers'] = 175
print(f"更新粉丝数: {user_profile}")

# 添加新的键值对
user_profile['location'] = 'New York'
print(f"添加地理位置: {user_profile}")

# 使用 update() 批量更新或添加，也可用于合并字典
user_profile.update({
    "email": "new.alice@example.com",   # 已有键 → 覆盖
    "is_active": True                    # 新键 → 添加
})
print(f"批量更新后: {user_profile}")


# ------------------- 4. 删除 (Delete) -------------------
# 使用 del 关键字删除指定键值对
del user_profile['is_active']
print(f"删除 is_active 后: {user_profile}")

# 使用 pop() 删除并返回该键的值，可设置默认值以防 KeyError
location = user_profile.pop('location', 'N/A')
print(f"移除的地理位置: {location}")
print(f"移除 location 后: {user_profile}")

# popitem() 移除并返回最后插入的键值对（LIFO），3.7+ 中非常有用
last_item = user_profile.popitem()
print(f"最后插入的项: {last_item}")
print(f"最终字典: {user_profile}")

user_profile = {
    "username": "Alice",
    "email": "alice@example.com",
    "followers": 175
}

# 1. 遍历键 (Keys) —— 直接 for 循环默认遍历键
print("--- 遍历键 ---")
for key in user_profile:                # 等价于 user_profile.keys()
    print(key)

# 2. 遍历值 (Values)
print("--- 遍历值 ---")
for value in user_profile.values():
    print(value)

# 3. 遍历键值对 (Items) —— 最常用
print("--- 遍历键值对 ---")
for key, value in user_profile.items():
    print(f"{key}: {value}")

# 4. 按键排序遍历（字典本身按插入顺序，如需其他排序需手动处理）
print("--- 按键排序遍历 ---")
for key in sorted(user_profile.keys()):
    print(f"{key}: {user_profile[key]}")

# 5. 视图是动态的 —— 修改字典后视图自动更新
keys_view = user_profile.keys()
print(f"修改前: {list(keys_view)}")
user_profile["bio"] = "Hello"
print(f"修改后: {list(keys_view)}")    # 视图中自动多了 'bio'

# 示例 1: 创建一个数字及其平方的字典
squares = {x: x**2 for x in range(1, 6)}
print(squares)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 示例 2: 从现有字典筛选和转换
user_data = {"Alice": 25, "Bob": 20, "Charlie": 30}
# 创建一个只包含年龄大于 22 岁用户的新字典
adults = {name: age for name, age in user_data.items() if age > 22}
print(adults)  # 输出: {'Alice': 25, 'Charlie': 30}

# 示例 3: 键值翻转
inverted = {v: k for k, v in user_data.items()}
print(inverted)  # 输出: {25: 'Alice', 20: 'Bob', 30: 'Charlie'}
# ⚠️ 注意：如果值有重复，后出现的键会覆盖前面的

# ---------- 方式一：get() —— 只读不写 ----------
# 键不存在时返回默认值，但不修改字典
d = {"a": 1}
val = d.get("b", 0)       # 返回 0，字典不变
print(d)                   # {'a': 1}

# ---------- 方式二：setdefault() —— 读写合一 ----------
# 键不存在时插入默认值并返回，键存在则返回已有值
d = {"a": 1}
val = d.setdefault("b", 0)   # 插入 "b": 0，返回 0
print(d)                      # {'a': 1, 'b': 0}
val = d.setdefault("a", 99)  # "a" 已存在，返回 1，不修改
print(d)                      # {'a': 1, 'b': 0}

# 典型用法：一键多值分组
groups = {}
for name, dept in [("Alice", "工程"), ("Bob", "市场"), ("Carol", "工程")]:
    groups.setdefault(dept, []).append(name)
print(groups)  # {'工程': ['Alice', 'Carol'], '市场': ['Bob']}

# ---------- 方式三：defaultdict —— 全局默认工厂 ----------
from collections import defaultdict

# defaultdict(list) 在访问不存在的键时自动创建空列表
groups_dd = defaultdict(list)
for name, dept in [("Alice", "工程"), ("Bob", "市场"), ("Carol", "工程")]:
    groups_dd[dept].append(name)          # 无需 setdefault，直接 append
print(dict(groups_dd))  # {'工程': ['Alice', 'Carol'], '市场': ['Bob']}

# defaultdict(int) 常用于计数
counter = defaultdict(int)
for ch in "hello":
    counter[ch] += 1                       # 不存在时默认为 0
print(dict(counter))  # {'h': 1, 'e': 1, 'l': 2, 'o': 1}

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# ---------- 方式一：| 运算符（Python 3.9+） ----------
merged = dict1 | dict2            # 创建新字典，重复键取右侧
print(merged)                     # {'a': 1, 'b': 3, 'c': 4}

# ---------- 方式二：|= 原地合并（Python 3.9+） ----------
d = {'a': 1, 'b': 2}
d |= dict2                        # 就地修改，不创建新字典
print(d)                          # {'a': 1, 'b': 3, 'c': 4}

# ---------- 方式三：解包 {**d1, **d2}（Python 3.5+） ----------
merged = {**dict1, **dict2}       # 创建新字典
print(merged)                     # {'a': 1, 'b': 3, 'c': 4}

# ---------- 方式四：update() ----------
merged = dict1.copy()             # 先拷贝，避免修改原字典
merged.update(dict2)              # 就地更新
print(merged)                     # {'a': 1, 'b': 3, 'c': 4}

# ---------- 方式五：ChainMap（不复制，逻辑合并） ----------
from collections import ChainMap
chain = ChainMap(dict2, dict1)    # 查找时先查 dict2，再查 dict1
print(chain['a'])                 # 1（来自 dict1）
print(chain['b'])                 # 3（dict2 优先）
# ChainMap 不创建新字典，适合大量字典的"虚拟合并"

users = {
    "user1": {
        "name": "Alice",
        "email": "alice@example.com"
    },
    "user2": {
        "name": "Bob",
        "email": "bob@example.com"
    }
}

# 访问嵌套字典
print(users["user1"]["name"])  # 输出: Alice

# 安全访问多层嵌套（避免 KeyError）
email = users.get("user3", {}).get("email", "未知")
print(email)  # 输出: 未知

from collections import defaultdict

# 示例：统计单词频率
text = "python is powerful and python is easy"

# 使用普通字典 —— 需要 get() 处理缺失键
word_count = {}
for word in text.split():
    word_count[word] = word_count.get(word, 0) + 1

# 使用 defaultdict(int)，默认值为 0 —— 更简洁
word_count_default = defaultdict(int)
for word in text.split():
    word_count_default[word] += 1

print(dict(word_count_default))  # {'python': 2, 'is': 2, 'powerful': 1, 'and': 1, 'easy': 1}

# 常用工厂函数
dd_list = defaultdict(list)    # 默认值 []，用于一键多值
dd_set = defaultdict(set)      # 默认值 set()，用于去重分组
dd_int = defaultdict(int)      # 默认值 0，用于计数
dd_str = defaultdict(str)      # 默认值 ""，用于字符串拼接

from collections import OrderedDict

# 创建一个 OrderedDict
od = OrderedDict()
od['first'] = 1
od['second'] = 2
od['third'] = 3

print(od)  # OrderedDict([('first', 1), ('second', 2), ('third', 3)])

# 将 'second' 移动到末尾（LRU 缓存的经典操作）
od.move_to_end('second')
print(od)  # OrderedDict([('first', 1), ('third', 3), ('second', 2)])

# 将 'first' 移动到开头
od.move_to_end('first', last=False)
print(od)  # OrderedDict([('first', 1), ('third', 3), ('second', 2)])

# 弹出最早插入的项（FIFO）
oldest = od.popitem(last=False)
print(oldest)  # ('first', 1)

# 顺序敏感的相等判断
from collections import OrderedDict
a = OrderedDict([('x', 1), ('y', 2)])
b = OrderedDict([('y', 2), ('x', 1)])
print(a == b)  # False —— 顺序不同则不等
print(dict(a) == dict(b))  # True —— 普通 dict 不比较顺序

from collections import Counter

# 创建 Counter
text = "python is powerful and python is easy"
c = Counter(text.split())
print(c)  # Counter({'python': 2, 'is': 2, 'powerful': 1, 'and': 1, 'easy': 1})

# most_common(n) —— 取出现次数最多的 n 个
print(c.most_common(2))  # [('python', 2), ('is', 2)]

# Counter 支持算术运算
c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2)
print(c1 + c2)   # Counter({'a': 4, 'b': 3})  —— 对应键相加
print(c1 - c2)   # Counter({'a': 2})           —— 对应键相减，≤0 的键被移除
print(c1 | c2)   # Counter({'a': 3, 'b': 2})   —— 取每键最大值
print(c1 & c2)   # Counter({'a': 1, 'b': 1})   —— 取每键最小值

# elements() —— 返回所有元素的迭代器（按计数重复）
print(list(Counter(a=2, b=3).elements()))  # ['a', 'a', 'b', 'b', 'b']

from collections import ChainMap

defaults = {"theme": "light", "font": "Arial", "lang": "zh"}
user_config = {"theme": "dark"}          # 用户自定义覆盖默认值

config = ChainMap(user_config, defaults)  # 查找顺序：user_config → defaults
print(config["theme"])  # "dark"（来自 user_config）
print(config["font"])   # "Arial"（来自 defaults）
print(config["lang"])   # "zh"（来自 defaults）

# 修改只影响第一个映射
config["font"] = "Helvetica"
print(user_config)  # {'theme': 'dark', 'font': 'Helvetica'} —— 写入了 user_config
print(defaults)     # {'theme': 'light', 'font': 'Arial', 'lang': 'zh'} —— 未变

text = "python makes dictionaries easy to use python"

# 方式一：普通字典 + get()
word_count = {}
for word in text.split():
    word_count[word] = word_count.get(word, 0) + 1
print(word_count)

# 方式二：defaultdict(int)
from collections import defaultdict
word_count_dd = defaultdict(int)
for word in text.split():
    word_count_dd[word] += 1
print(dict(word_count_dd))

# 方式三：Counter（最简洁）
from collections import Counter
word_count_c = Counter(text.split())
print(word_count_c)
print(f"出现最多的词: {word_count_c.most_common(1)}")

# ❌ 错误：遍历时删除键会抛出 RuntimeError
d = {"a": 1, "b": 2, "c": 3}
for key in d:
    if key == "b":
        del d[key]  # RuntimeError: dictionary changed size during iteration

# ✅ 方法一：遍历键的副本
for key in list(d.keys()):
    if key == "b":
        del d[key]

# ✅ 方法二：使用字典推导式创建新字典
d = {k: v for k, v in d.items() if k != "b"}

# ✅ 方法三：先收集要删除的键，再统一删除
to_delete = [k for k, v in d.items() if v == 2]
for key in to_delete:
    del d[key]

# ❌ 列表不可哈希，不能作为 key
d = {}
d[[1, 2]] = "value"  # TypeError: unhashable type: 'list'

# ✅ 使用元组代替列表
d[(1, 2)] = "value"  # OK

# ⚠️ 元组内也不能包含可变对象
d[(1, [2, 3])] = "value"  # TypeError: unhashable type: 'list'
d[(1, (2, 3))] = "value"  # OK

original = {"user": {"name": "Alice"}}
shallow = original.copy()         # 浅拷贝：嵌套对象仍然共享引用

shallow["user"]["name"] = "Bob"   # 修改了嵌套字典
print(original["user"]["name"])   # "Bob" —— 原字典也被改了！

# ✅ 使用 deepcopy 进行深拷贝
from copy import deepcopy
original = {"user": {"name": "Alice"}}
deep = deepcopy(original)
deep["user"]["name"] = "Bob"
print(original["user"]["name"])   # "Alice" —— 原字典不受影响

# 在 Python 3.7+ 中，以下行为是可靠的
d = {}
d["z"] = 1
d["a"] = 2
d["m"] = 3
print(list(d.keys()))  # ['z', 'a', 'm'] —— 按插入顺序

# 但不要依赖此特性做跨版本兼容的代码
# 如果需要顺序保证且需兼容 3.6-，请使用 OrderedDict

value = my_dict.get('key', 'default_value')

value = my_dict.setdefault('key', 'default_value')

# 按键排序
sorted_by_key = dict(sorted(my_dict.items()))

# 按值排序
sorted_by_value = dict(sorted(my_dict.items(), key=lambda x: x[1], reverse=True))

from collections import defaultdict
dd = defaultdict(list)
dd['new_key'].append('value')  # 自动创建空列表

merged = dict1 | dict2
# 或原地合并
dict1 |= dict2

merged = {**dict1, **dict2}