Python中字典的12种遍历方式和20个常用操作全攻略

# 一本最简词典
word_book = {
    "apple": "苹果",
    "banana": "香蕉",
    "cat": "猫"
}
print(word_book["apple"])  # 苹果

# 方式1: 花括号字面量（最常用）
d1 = {"name": "alice", "age": 25}

# 方式2: dict() 构造函数 + 关键字参数
d2 = dict(name="bob", age=30)

# 方式3: dict() + 可迭代对象（每个元素是长度为2的序列）
d3 = dict([("name", "charlie"), ("age", 28)])

# 方式4: 字典推导式
d4 = {x: x ** 2 for x in range(1, 5)}
print(d4)  # {1: 1, 2: 4, 3: 9, 4: 16}

# 方式5: dict.fromkeys() 批量创建
d5 = dict.fromkeys(["a", "b", "c"], 0)
print(d5)  # {'a': 0, 'b': 0, 'c': 0}

# 方式6: zip() 组合两个列表
keys = ["name", "age", "city"]
values = ["david", 22, "beijing"]
d6 = dict(zip(keys, values))
print(d6)  # {'name': 'david', 'age': 22, 'city': 'beijing'}

score = {"math": 90, "english": 85, "chinese": 92}

for k in score:
    print(k, "->", score[k])
# math -> 90
# english -> 85
# chinese -> 92

for k in score.keys():
    print(k)
# math
# english
# chinese

# .keys() 返回的是动态视图，可以参与集合运算
print(score.keys() & {"math", "art"})  # {'math'}

for v in score.values():
    print(v)
# 90
# 85
# 92

# 常见用法：求和、求平均
total = sum(score.values())
avg = total / len(score)
print(total, avg)  # 267 89.0

for subject, mark in score.items():
    print(f"{subject}: {mark}分")
# math: 90分
# english: 85分
# chinese: 92分

for idx, (k, v) in enumerate(score.items(), start=1):
    print(f"第{idx}名: {k} {v}分")
# 第1名: math 90分
# 第2名: english 85分
# 第3名: chinese 92分

data = {"banana": 3, "apple": 5, "cherry": 2}

# 按键的字母序
for k in sorted(data):
    print(k, data[k])
# apple 5
# banana 3
# cherry 2

data = {"banana": 3, "apple": 5, "cherry": 2}

# 按值升序
for k, v in sorted(data.items(), key=lambda x: x[1]):
    print(k, v)
# cherry 2
# banana 3
# apple 5

# 按值降序
for k, v in sorted(data.items(), key=lambda x: x[1], reverse=true):
    print(k, v)
# apple 5
# banana 3
# cherry 2

d = {"a": 1, "b": 2, "c": 3}

for k in reversed(d):
    print(k, d[k])
# c 3
# b 2
# a 1

# 对 items 逆序
for k, v in reversed(d.items()):
    print(k, v)
# c 3
# b 2
# a 1

prices = {"apple": 5.5, "banana": 3.2, "orange": 4.8, "grape": 12.0}

# 遍历中过滤：只保留价格 >= 5 的水果
expensive = {k: v for k, v in prices.items() if v >= 5}
print(expensive)  # {'apple': 5.5, 'grape': 12.0}

# 遍历中转换：所有商品打八折
discounted = {k: round(v * 0.8, 1) for k, v in prices.items()}
print(discounted)  # {'apple': 4.4, 'banana': 2.6, 'orange': 3.8, 'grape': 9.6}

inventory = {"apple": 10, "banana": 0, "orange": 5, "grape": 0}

# 找出库存为0的商品
for k, v in inventory.items():
    if v == 0:
        print(f"缺货: {k}")
# 缺货: banana
# 缺货: grape

students = {
    "alice": {"age": 20, "score": 88},
    "bob":   {"age": 21, "score": 92},
    "charlie": {"age": 19, "score": 85}
}

for name, info in students.items():
    print(f"{name}: 年龄 {info['age']}, 成绩 {info['score']}")
# alice: 年龄 20, 成绩 88
# bob: 年龄 21, 成绩 92
# charlie: 年龄 19, 成绩 85

d = {"x": 10, "y": 20, "z": 30}
it = iter(d.items())

while true:
    try:
        k, v = next(it)
        print(k, v)
    except stopiteration:
        break
# x 10
# y 20
# z 30

user = {"name": "alice", "age": 25}

# 方式1: 直接索引（key 不存在报错）
print(user["name"])  # alice

# 方式2: get() — 安全取值，不存在返回 none
print(user.get("email"))  # none

# 方式3: get() + 默认值 — 最佳实践
print(user.get("email", "unknown@example.com"))  # unknown@example.com

# 方式4: setdefault() — 取不到就设置并返回
print(user.setdefault("role", "guest"))  # guest
print(user)  # {'name': 'alice', 'age': 25, 'role': 'guest'}

d = {"a": 1, "b": 2}

# 单个新增/修改
d["c"] = 3
print(d)  # {'a': 1, 'b': 2, 'c': 3}

# 批量更新 update()
d.update({"b": 99, "d": 4, "e": 5})
print(d)  # {'a': 1, 'b': 99, 'c': 3, 'd': 4, 'e': 5}

# python 3.9+ 并集运算符 | （返回新字典，不修改原字典）
d2 = {"f": 6, "g": 7}
merged = d | d2
print(merged)  # {'a': 1, 'b': 99, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7}
print(d)       # {'a': 1, 'b': 99, 'c': 3, 'd': 4, 'e': 5}  -- 原字典不变

# 原地更新 |=（python 3.9+）
d |= d2
print(d)       # {'a': 1, 'b': 99, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7}

# ** 解包合并（兼容老版本，返回新字典）
d3 = {"x": 10, "y": 20}
combined = {**d, **d3}
print(combined)  # {'a': 1, 'b': 99, ..., 'x': 10, 'y': 20}

d = {"a": 1, "b": 2, "c": 3, "d": 4}

# pop(key) — 删除并返回值，key 不存在报错
val = d.pop("c")
print(val, d)  # 3 {'a': 1, 'b': 2, 'd': 4}

# pop(key, default) — 安全删除，不存在返回默认值
val = d.pop("z", "not found")
print(val)  # not found

# popitem() — 删除并返回最后一个键值对（lifo）
last = d.popitem()
print(last, d)  # ('d', 4) {'a': 1, 'b': 2}

# del — 直接删除（key 不存在报 keyerror）
del d["b"]
print(d)  # {'a': 1}

# clear() — 清空所有元素
d.clear()
print(d)  # {}

d = {"name": "alice", "age": 25}

# in 运算符 — 判断键是否存在（o(1) 时间复杂度）
print("name" in d)    # true
print("email" in d)   # false
print("email" not in d)  # true

# len() — 键值对数量
print(len(d))  # 2

# 判空
if not d:
    print("字典为空")
else:
    print(f"字典有 {len(d)} 项")
# 字典有 2 项

d = {"a": 1, "b": 2}
keys_view = d.keys()
vals_view = d.values()
items_view = d.items()

print(keys_view)   # dict_keys(['a', 'b'])
print(vals_view)   # dict_values([1, 2])
print(items_view)  # dict_items([('a', 1), ('b', 2)])

# 动态性：修改原字典后，视图自动反映变化
d["c"] = 3
print(keys_view)   # dict_keys(['a', 'b', 'c'])
print(vals_view)   # dict_values([1, 2, 3])

import copy

original = {"a": [1, 2, 3], "b": {"nested": true}}

# 浅拷贝：顶层独立，嵌套对象共享引用
shallow = original.copy()  # 等价于 dict(original) 或 {**original}
shallow["a"].append(4)
print(original["a"])  # [1, 2, 3, 4] — 原字典也被影响！

# 深拷贝：完全独立，递归复制所有嵌套对象
deep = copy.deepcopy(original)
deep["a"].append(5)
print(original["a"])  # [1, 2, 3, 4] — 原字典不受影响

# 用同一个默认值初始化所有键
keys = ["name", "age", "city"]
d = dict.fromkeys(keys, "n/a")
print(d)  # {'name': 'n/a', 'age': 'n/a', 'city': 'n/a'}

# 陷阱：默认值是可变对象时，所有键共享同一个对象！
d_bad = dict.fromkeys(["a", "b", "c"], [])
d_bad["a"].append(1)
print(d_bad)  # {'a': [1], 'b': [1], 'c': [1]} — 全部被改了！

# 正确做法：用字典推导式给每个键创建独立对象
d_good = {k: [] for k in ["a", "b", "c"]}
d_good["a"].append(1)
print(d_good)  # {'a': [1], 'b': [], 'c': []}

# 过滤：只保留成绩 >= 80 的高分选手
scores = {"alice": 90, "bob": 55, "charlie": 85, "david": 72}
passed = {k: v for k, v in scores.items() if v >= 80}
print(passed)  # {'alice': 90, 'charlie': 85}

# 转换：成绩转为等级
grades = {k: "优" if v >= 90 else "良" if v >= 70 else "中" if v >= 60 else "差"
          for k, v in scores.items()}
print(grades)  # {'alice': '优', 'bob': '差', 'charlie': '良', 'david': '中'}

# 键值互换
original = {"a": 1, "b": 2, "c": 3}
swapped = {v: k for k, v in original.items()}
print(swapped)  # {1: 'a', 2: 'b', 3: 'c'}

import json

# 序列化：dict → json 字符串
user = {"name": "alice", "age": 25, "active": true, "tags": ["python", "web"]}
json_str = json.dumps(user)
print(json_str)
# {"name": "alice", "age": 25, "active": true, "tags": ["python", "web"]}
print(type(json_str))  # <class 'str'>

# 反序列化：json 字符串 → dict
parsed = json.loads(json_str)
print(parsed)           # {'name': 'alice', 'age': 25, 'active': true, 'tags': ['python', 'web']}
print(type(parsed))     # <class 'dict'>
print(parsed["name"])   # alice

data = {"title": "python 字典入门教程", "author": "张三"}

# 默认行为：中文被转义，完全不可读
print(json.dumps(data))
# {"title": "python 字典入门教程", "author": "张三"}

# 加上 ensure_ascii=false：中文原样保留
print(json.dumps(data, ensure_ascii=false))
# {"title": "python 字典入门教程", "author": "张三"}

config = {
    "server": {"host": "0.0.0.0", "port": 8080},
    "database": {"engine": "postgresql", "pool_size": 10},
    "debug": false
}

pretty = json.dumps(config, indent=2, ensure_ascii=false, sort_keys=true)
print(pretty)
# {
#   "database": {
#     "engine": "postgresql",
#     "pool_size": 10
#   },
#   "debug": false,
#   "server": {
#     "host": "0.0.0.0",
#     "port": 8080
#   }
# }

# 写入 json 文件
config = {"version": "1.0", "settings": {"theme": "dark", "lang": "zh"}}

with open("config.json", "w", encoding="utf-8") as f:
    json.dump(config, f, ensure_ascii=false, indent=2)
# 文件内容：
# {
#   "version": "1.0",
#   "settings": {
#     "theme": "dark",
#     "lang": "zh"
#   }
# }

# 读取 json 文件
with open("config.json", "r", encoding="utf-8") as f:
    loaded = json.load(f)
print(loaded["settings"]["theme"])  # dark

from datetime import datetime, date
from decimal import decimal

data = {
    "user": "alice",
    "created_at": datetime.now(),
    "birthday": date(2000, 1, 15),
    "balance": decimal("99.99")
}

# 方式1：自定义 default 函数
def json_default(obj):
    if isinstance(obj, datetime):
        return obj.strftime("%y-%m-%d %h:%m:%s")
    if isinstance(obj, date):
        return obj.strftime("%y-%m-%d")
    if isinstance(obj, decimal):
        return float(obj)
    raise typeerror(f"object of type {type(obj).__name__} is not json serializable")

result = json.dumps(data, default=json_default, ensure_ascii=false, indent=2)
print(result)
# {
#   "user": "alice",
#   "created_at": "2026-07-20 10:30:00",
#   "birthday": "2000-01-15",
#   "balance": 99.99
# }

# 方式2：继承 jsonencoder（适合复用场景）
class customencoder(json.jsonencoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.strftime("%y-%m-%d %h:%m:%s")
        if isinstance(obj, date):
            return obj.strftime("%y-%m-%d")
        if isinstance(obj, decimal):
            return float(obj)
        return super().default(obj)

result2 = json.dumps(data, cls=customencoder, ensure_ascii=false)

json_str = '''
{
    "user": "bob",
    "created_at": "2026-07-20 14:30:00",
    "balance": 128.50
}
'''

from datetime import datetime

def revive_dates(dct):
    """如果发现 created_at 字段，自动转回 datetime 对象"""
    result = {}
    for k, v in dct.items():
        if k.endswith("_at") and isinstance(v, str):
            try:
                result[k] = datetime.strptime(v, "%y-%m-%d %h:%m:%s")
            except valueerror:
                result[k] = v
        else:
            result[k] = v
    return result

parsed = json.loads(json_str, object_hook=revive_dates)
print(parsed)
# {'user': 'bob', 'created_at': datetime.datetime(2026, 7, 20, 14, 30), 'balance': 128.5}
print(type(parsed["created_at"]))  # <class 'datetime.datetime'>