# ? 合法：元組內(nèi)所有元素都是可哈希的
locations = {
    (35.68, 139.69): "東京",  # 元組內(nèi)是兩個(gè)浮點(diǎn)數(shù)
    (40.71, -74.01): "紐約"   # 元組內(nèi)是兩個(gè)浮點(diǎn)數(shù)
}

# ? 非法：元組內(nèi)包含列表（不可哈希）
locations = {
    ([35.68, 139.69]): "東京"  # TypeError: unhashable type: 'list'
}

# 方法1：使用 hash() 函數(shù)
print(hash("hello"))  # ? 可以，輸出哈希值
print(hash([1, 2, 3]))  # ? TypeError: unhashable type: 'list'

# 方法2：使用 isinstance() 檢查
from collections.abc import Hashable
print(isinstance("hello", Hashable))  # ? True
print(isinstance([1, 2, 3], Hashable))  # ? False

# 創(chuàng)建空字典
empty_dict = {}

# 創(chuàng)建帶初始值的字典
student = {
    "name": "張三",
    "age": 18,
    "score": 95
}
print(student)  # 輸出: {'name': '張三', 'age': 18, 'score': 95}

# 創(chuàng)建空字典
empty_dict = dict()

# 使用關(guān)鍵字參數(shù)創(chuàng)建
student = dict(name="李四", age=20, score=88)
print(student)  # 輸出: {'name': '李四', 'age': 20, 'score': 88}

# 從鍵值對(duì)序列創(chuàng)建
pairs = [("name", "王五"), ("age", 22), ("score", 92)]
student = dict(pairs)
print(student)  # 輸出: {'name': '王五', 'age': 22, 'score': 92}

# 從另一個(gè)字典創(chuàng)建
original = {"a": 1, "b": 2}
copy_dict = dict(original)
print(copy_dict)  # 輸出: {'a': 1, 'b': 2}

# 創(chuàng)建所有鍵值都為 None 的字典
keys = ["name", "age", "score"]
student = dict.fromkeys(keys)
print(student)  # 輸出: {'name': None, 'age': None, 'score': None}

# 創(chuàng)建所有鍵值都為指定默認(rèn)值的字典
student = dict.fromkeys(keys, 0)
print(student)  # 輸出: {'name': 0, 'age': 0, 'score': 0}

{key: value for item in iterable}

# 示例1：從列表創(chuàng)建字典（鍵為數(shù)，值為數(shù)的平方）
squares = {x: x**2 for x in range(5)}
print(squares)  # 輸出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 示例2：將兩個(gè)列表組合成字典
keys = ["name", "age", "city"]
values = ["張三", 25, "北京"]
person = dict(zip(keys, values))
print(person)  # 輸出: {'name': '張三', 'age': 25, 'city': '北京'}

# 示例3：將字符串轉(zhuǎn)換為字符計(jì)數(shù)字典
word = "hello"
char_count = {char: word.count(char) for char in word}
print(char_count)  # 輸出: {'h': 1, 'e': 1, 'l': 2, 'o': 1}

# 示例1：只保留偶數(shù)的平方
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}
print(even_squares)  # 輸出: {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

# 示例2：根據(jù)條件轉(zhuǎn)換數(shù)據(jù)
scores = {"語(yǔ)文": 85, "數(shù)學(xué)": 92, "英語(yǔ)": 78, "物理": 90}
pass_scores = {subject: score for subject, score in scores.items() if score >= 80}
print(pass_scores)  # 輸出: {'語(yǔ)文': 85, '數(shù)學(xué)': 92, '物理': 90}

# 示例1：嵌套循環(huán)創(chuàng)建字典
pairs = {(x, y): x + y for x in range(3) for y in range(3)}
print(pairs)  # 輸出: {(0, 0): 0, (0, 1): 1, (0, 2): 2, (1, 0): 1, ...}

# 示例2：使用條件表達(dá)式（三元運(yùn)算符）
numbers = [1, 2, 3, 4, 5]
label = {n: "偶數(shù)" if n % 2 == 0 else "奇數(shù)" for n in numbers}
print(label)  # 輸出: {1: '奇數(shù)', 2: '偶數(shù)', 3: '奇數(shù)', 4: '偶數(shù)', 5: '奇數(shù)'}

# 示例3：從字典推導(dǎo)新字典
original = {"a": 1, "b": 2, "c": 3}
doubled = {k: v * 2 for k, v in original.items()}
print(doubled)  # 輸出: {'a': 2, 'b': 4, 'c': 6}

# 創(chuàng)建字典
student = {"name": "張三", "age": 18, "score": 95}

# 通過(guò)鍵獲取值
print(student["name"])  # 輸出: 張三
print(student["age"])   # 輸出: 18
print(student["score"])  # 輸出: 95

# 鍵不存在時(shí)，會(huì)報(bào)錯(cuò)
print(student["gender"])  # ? KeyError: 'gender'

student = {"name": "張三", "age": 18, "score": 95}

# 使用 get() 方法獲取值
print(student.get("name"))    # 輸出: 張三
print(student.get("gender"))  # 輸出: None（鍵不存在）

# 指定默認(rèn)值
print(student.get("gender", "未知"))  # 輸出: 未知

student = {"name": "張三", "age": 18, "score": 95}

# keys()：獲取所有鍵
print(student.keys())   # 輸出: dict_keys(['name', 'age', 'score'])

# values()：獲取所有值
print(student.values()) # 輸出: dict_values(['張三', 18, 95])

# items()：獲取所有鍵值對(duì)
print(student.items())  # 輸出: dict_items([('name', '張三'), ('age', 18), ('score', 95)])

# 遍歷所有鍵
for key in student.keys():
    print(key)

# 遍歷所有值
for value in student.values():
    print(value)

# 遍歷所有鍵值對(duì)
for key, value in student.items():
    print(f"{key}: {value}")

student = {"name": "張三", "age": 18, "score": 95}

# 檢查鍵是否存在
print("name" in student)     # 輸出: True
print("gender" in student)   # 輸出: False

# 檢查鍵是否不存在
print("gender" not in student)  # 輸出: True

# 場(chǎng)景1：先檢查再獲?。ū苊?KeyError）
if "gender" in student:
    print(student["gender"])
else:
    print("性別未知")

# 場(chǎng)景2：條件判斷
if "score" in student and student["score"] >= 60:
    print("考試及格")
else:
    print("需要補(bǔ)考")

# 創(chuàng)建空字典
student = {}

# 添加單個(gè)鍵值對(duì)
student["name"] = "張三"
student["age"] = 18
student["score"] = 95

print(student)  # 輸出: {'name': '張三', 'age': 18, 'score': 95}

# 多次賦值可以繼續(xù)添加
student["city"] = "北京"
print(student)  # 輸出: {'name': '張三', 'age': 18, 'score': 95, 'city': '北京'}

student = {"name": "張三", "age": 18}

# 鍵不存在，添加新鍵值對(duì)
result = student.setdefault("score", 95)
print(result)        # 輸出: 95（返回設(shè)置的值）
print(student)       # 輸出: {'name': '張三', 'age': 18, 'score': 95}

# 鍵已存在，不改變?cè)兄?
result = student.setdefault("name", "李四")
print(result)        # 輸出: 張三（返回原有值）
print(student)       # 輸出: {'name': '張三', 'age': 18, 'score': 95}（name 未被修改）

# 只傳一個(gè)參數(shù)時(shí)，默認(rèn)值為 None
student.setdefault("address")
print(student)       # 輸出: {'name': '張三', 'age': 18, 'score': 95, 'address': None}

# 場(chǎng)景1：統(tǒng)計(jì)水果出現(xiàn)次數(shù)
fruits = ["蘋果", "香蕉", "蘋果", "橙子", "香蕉", "蘋果"]
count = {}

for fruit in fruits:
    count.setdefault(fruit, 0)  # 如果鍵不存在，初始化為 0
    count[fruit] += 1          # 然后加 1

print(count)  # 輸出: {'蘋果': 3, '香蕉': 2, '橙子': 1}

# 場(chǎng)景2：分組數(shù)據(jù)
students = [
    {"name": "張三", "class": "A"},
    {"name": "李四", "class": "B"},
    {"name": "王五", "class": "A"}
]

groups = {}
for student in students:
    cls = student["class"]
    groups.setdefault(cls, []).append(student["name"])

print(groups)  # 輸出: {'A': ['張三', '王五'], 'B': ['李四']}

student = {"name": "張三", "age": 18}

# 使用字典更新
student.update({"score": 95, "city": "北京"})
print(student)  # 輸出: {'name': '張三', 'age': 18, 'score': 95, 'city': '北京'}

# 使用關(guān)鍵字參數(shù)更新
student.update(grade="A", status="active")
print(student)  # 輸出: {'name': '張三', 'age': 18, 'score': 95, 'city': '北京', 'grade': 'A', 'status': 'active'}

# 使用鍵值對(duì)序列更新（列表、元組均可）
pairs = [("gender", "男"), ("height", 175)]
student.update(pairs)
print(student)  # 輸出: {'name': '張三', 'age': 18, 'score': 95, 'city': '北京', 'grade': 'A', 'status': 'active', 'gender': '男', 'height': 175}

# update() 也會(huì)覆蓋已存在的鍵
student.update({"age": 20, "name": "李四"})
print(student)  # 輸出: {'name': '李四', 'age': 20, 'score': 95, ...}

student = {"name": "張三", "age": 18, "score": 95}

# 修改已存在的鍵的值
student["age"] = 20
student["score"] = 88

print(student)  # 輸出: {'name': '張三', 'age': 20, 'score': 88}

# 嵌套字典
user = {
    "name": "張三",
    "profile": {
        "email": "zhangsan@example.com",
        "age": 18
    }
}

# 修改嵌套字典中的值
user["profile"]["age"] = 20
user["profile"]["email"] = "new_email@example.com"

print(user)
# 輸出: {'name': '張三', 'profile': {'email': 'new_email@example.com', 'age': 20}}

student = {"name": "張三", "age": 18, "score": 95}

# 使用字典修改多個(gè)值
student.update({"age": 20, "score": 88})

print(student)  # 輸出: {'name': '張三', 'age': 20, 'score': 88}

# 使用關(guān)鍵字參數(shù)修改
student.update(age=22, status="graduated")

print(student)  # 輸出: {'name': '張三', 'age': 22, 'score': 88, 'status': 'graduated'}

student = {"name": "張三", "age": 18, "score": 95}

# 刪除鍵值對(duì)，并獲取被刪除的值
removed_value = student.pop("age")
print(removed_value)  # 輸出: 18
print(student)       # 輸出: {'name': '張三', 'score': 95}

# 鍵不存在時(shí)，會(huì)拋出 KeyError
# student.pop("gender")  # ? KeyError: 'gender'

# 可以設(shè)置默認(rèn)值，避免異常
removed_value = student.pop("gender", None)
print(removed_value)  # 輸出: None（鍵不存在，返回默認(rèn)值）

student = {"name": "張三", "age": 18, "score": 95}

# 刪除最后一個(gè)鍵值對(duì)
removed = student.popitem()
print(removed)   # 輸出: ('score', 95)（返回鍵值對(duì)元組）
print(student)   # 輸出: {'name': '張三', 'age': 18}

# 繼續(xù)刪除
removed = student.popitem()
print(removed)   # 輸出: ('age', 18)
print(student)   # 輸出: {'name': '張三'}

# 字典為空時(shí)，拋出 KeyError
# student.popitem()  # ? KeyError: 'popitem(): dictionary is empty'

student = {"name": "張三", "age": 18, "score": 95}

# 刪除指定的鍵值對(duì)
del student["age"]
print(student)  # 輸出: {'name': '張三', 'score': 95}

# 刪除不存在的鍵會(huì)拋出異常
# del student["gender"]  # ? KeyError: 'gender'

# 刪除整個(gè)字典
del student
# print(student)  # ? NameError: name 'student' is not defined

student = {"name": "張三", "age": 18, "score": 95}

# 清空字典
student.clear()
print(student)  # 輸出: {}（空字典）
print(len(student))  # 輸出: 0

# 字典變量仍然存在，可以繼續(xù)使用
student["name"] = "李四"
print(student)  # 輸出: {'name': '李四'}

student = {"name": "張三", "age": 18, "score": 95, "city": "北京"}

# 方法1：直接遍歷字典（默認(rèn)遍歷鍵）
for key in student:
    print(key)
# 輸出:
# name
# age
# score
# city

# 方法2：使用 keys() 方法
for key in student.keys():
    print(key)
# 輸出同上

# 在需要明確語(yǔ)義時(shí)，使用 keys() 更清晰
print("學(xué)生信息包含以下字段：")
for key in student.keys():
    print(f"  - {key}")

student = {"name": "張三", "age": 18, "score": 95, "city": "北京"}

# 遍歷所有值
for value in student.values():
    print(value)
# 輸出:
# 張三
# 18
# 95
# 北京

# 實(shí)際應(yīng)用：計(jì)算平均分
scores = {"語(yǔ)文": 85, "數(shù)學(xué)": 92, "英語(yǔ)": 78, "物理": 90}
total = sum(scores.values())
count = len(scores)
average = total / count
print(f"平均分: {average}")  # 輸出: 平均分: 86.25

# 找出最高分
max_score = max(scores.values())
print(f"最高分: {max_score}")  # 輸出: 最高分: 92

student = {"name": "張三", "age": 18, "score": 95, "city": "北京"}

# 遍歷所有鍵值對(duì)
for key, value in student.items():
    print(f"{key}: {value}")
# 輸出:
# name: 張三
# age: 18
# score: 95
# city: 北京

# 實(shí)際應(yīng)用：篩選符合條件的數(shù)據(jù)
scores = {"語(yǔ)文": 85, "數(shù)學(xué)": 92, "英語(yǔ)": 78, "物理": 90}
print("及格的科目：")
for subject, score in scores.items():
    if score >= 80:
        print(f"  {subject}: {score}分")
# 輸出:
# 及格的科目：
#   語(yǔ)文: 85分
#   數(shù)學(xué): 92分
#   物理: 90分

# 實(shí)際應(yīng)用：構(gòu)建新字典
original = {"a": 1, "b": 2, "c": 3}
doubled = {}
for key, value in original.items():
    doubled[key] = value * 2
print(doubled)  # 輸出: {'a': 2, 'b': 4, 'c': 6}

# 示例1：遍歷鍵值對(duì)并篩選
scores = {"語(yǔ)文": 85, "數(shù)學(xué)": 92, "英語(yǔ)": 78, "物理": 90}
pass_scores = {subject: score for subject, score in scores.items() if score >= 80}
print(pass_scores)  # 輸出: {'語(yǔ)文': 85, '數(shù)學(xué)': 92, '物理': 90}

# 示例2：遍歷鍵值對(duì)并轉(zhuǎn)換
student = {"name": "張三", "age": 18, "score": 95}
formatted = {f"學(xué)生{k}": f"值{v}" for k, v in student.items()}
print(formatted)  # 輸出: {'學(xué)生name': '值張三', '學(xué)生age': '值18', '學(xué)生score': '值95'}

# 示例3：鍵值互換
original = {"a": 1, "b": 2, "c": 3}
reversed_dict = {v: k for k, v in original.items()}
print(reversed_dict)  # 輸出: {1: 'a', 2: 'b', 3: 'c'}

# 示例4：合并兩個(gè)字典（鍵不同時(shí)）
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged = {k: v for d in [dict1, dict2] for k, v in d.items()}
print(merged)  # 輸出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 簡(jiǎn)單字典（鍵對(duì)應(yīng)單個(gè)值）
student = {"name": "張三", "age": 18}

# 嵌套字典（鍵對(duì)應(yīng)一個(gè)字典）
student = {
    "name": "張三",
    "profile": {
        "age": 18,
        "city": "北京",
        "email": "zhangsan@example.com"
    },
    "scores": {
        "語(yǔ)文": 85,
        "數(shù)學(xué)": 92,
        "英語(yǔ)": 78
    }
}

# 創(chuàng)建嵌套字典
company = {
    "部門A": {"員工數(shù)": 10, "預(yù)算": 50000},
    "部門B": {"員工數(shù)": 15, "預(yù)算": 80000}
}

# 查：訪問嵌套字典中的值
print(company["部門A"])              # 輸出: {'員工數(shù)': 10, '預(yù)算': 50000}
print(company["部門A"]["員工數(shù)"])     # 輸出: 10

# 增：添加新的嵌套字典
company["部門C"] = {"員工數(shù)": 8, "預(yù)算": 30000}
print(company)
# 輸出: {'部門A': {...}, '部門B': {...}, '部門C': {...}}

# 改：修改嵌套字典中的值
company["部門A"]["預(yù)算"] = 60000
print(company["部門A"])  # 輸出: {'員工數(shù)': 10, '預(yù)算': 60000}

# 增：在嵌套字典中添加新鍵值對(duì)
company["部門A"]["負(fù)責(zé)人"] = "張三"
print(company["部門A"])  # 輸出: {'員工數(shù)': 10, '預(yù)算': 60000, '負(fù)責(zé)人': '張三'}

# 刪：刪除嵌套字典中的鍵值對(duì)
del company["部門B"]["員工數(shù)"]
print(company["部門B"])  # 輸出: {'預(yù)算': 80000}

# 使用 pop() 刪除并獲取值
removed = company["部門C"].pop("預(yù)算")
print(removed)    # 輸出: 30000
print(company["部門C"])  # 輸出: {'員工數(shù)': 8}

# 安全訪問嵌套字典
print(company.get("部門D", {}))           # 輸出: {}（鍵不存在返回默認(rèn)值）
print(company.get("部門A", {}).get("預(yù)算"))  # 輸出: 60000

# 鏈?zhǔn)秸{(diào)用需要注意：任何一個(gè) get() 返回默認(rèn)值都會(huì)繼續(xù)調(diào)用
print(company.get("部門D", {}).get("預(yù)算"))  # 輸出: None（不會(huì)報(bào)錯(cuò)）

# 嵌套字典
company = {
    "部門A": {"員工數(shù)": 10, "預(yù)算": 50000},
    "部門B": {"員工數(shù)": 15, "預(yù)算": 80000}
}

# 遍歷外層字典的所有鍵值對(duì)
print("=== 遍歷所有部門及其信息 ===")
for dept, info in company.items():
    print(f"部門: {dept}")
    for key, value in info.items():
        print(f"  {key}: {value}")
# 輸出:
# 部門: 部門A
#   員工數(shù): 10
#   預(yù)算: 50000
# 部門: 部門B
#   員工數(shù): 15
#   預(yù)算: 80000

# 遍歷所有值（嵌套字典的值）
print("\n=== 遍歷所有詳細(xì)信息 ===")
for dept, info in company.items():
    for value in info.values():
        print(value)
# 輸出: 10, 50000, 15, 80000

# 使用字典推導(dǎo)式創(chuàng)建新嵌套字典
doubled = {dept: {k: v * 2 for k, v in info.items()} for dept, info in company.items()}
print(doubled)
# 輸出: {'部門A': {'員工數(shù)': 20, '預(yù)算': 100000}, '部門B': {'員工數(shù)': 30, '預(yù)算': 160000}}

# 統(tǒng)計(jì)所有部門的總預(yù)算
total_budget = sum(info["預(yù)算"] for info in company.values())
print(f"總預(yù)算: {total_budget}")  # 輸出: 總預(yù)算: 130000

# 找出員工數(shù)最多的部門
# company.items() 返回鍵值對(duì)元組：(鍵, 值) = (部門名稱, {'員工數(shù)': 10, '預(yù)算': 50000})
# x[0] 是部門名稱（鍵），x[1] 是員工數(shù)和預(yù)算（值，是一個(gè)字典）
max_staff_dept = max(company.items(), key=lambda x: x[1]["員工數(shù)"])
print(f"員工最多的部門: {max_staff_dept[0]}")  # 輸出: 員工最多的部門: 部門B

students = {
    "張三": {
        "語(yǔ)文": 85,
        "數(shù)學(xué)": 92,
        "英語(yǔ)": 78
    },
    "李四": {
        "語(yǔ)文": 90,
        "數(shù)學(xué)": 88,
        "英語(yǔ)": 95
    },
    "王五": {
        "語(yǔ)文": 75,
        "數(shù)學(xué)": 82,
        "英語(yǔ)": 80
    }
}

# 查詢某個(gè)學(xué)生的成績(jī)
print(students["張三"]["數(shù)學(xué)"])  # 輸出: 92

# 計(jì)算每個(gè)學(xué)生的平均分
for name, scores in students.items():
    avg = sum(scores.values()) / len(scores)
    print(f"{name}的平均分: {avg:.1f}")

# 找出每科最高分
subjects = ["語(yǔ)文", "數(shù)學(xué)", "英語(yǔ)"]
for subject in subjects:
    max_score = max(students[name][subject] for name in students)
    print(f"{subject}最高分: {max_score}")

orders = {
    "訂單001": {
        "商品": "iPhone 15",
        "數(shù)量": 2,
        "價(jià)格": 5999,
        "客戶": {
            "姓名": "張三",
            "電話": "13800138000",
            "地址": "北京市朝陽(yáng)區(qū)"
        }
    },
    "訂單002": {
        "商品": "MacBook Pro",
        "數(shù)量": 1,
        "價(jià)格": 12999,
        "客戶": {
            "姓名": "李四",
            "電話": "13900139000",
            "地址": "上海市浦東新區(qū)"
        }
    }
}

# 訪問嵌套的客戶信息
print(orders["訂單001"]["客戶"]["姓名"])  # 輸出: 張三

# 統(tǒng)計(jì)總收入
total = sum(order["價(jià)格"] * order["數(shù)量"] for order in orders.values())
print(f"總收入: {total}")  # 輸出: 總收入: 24997

config = {
    "數(shù)據(jù)庫(kù)": {
        "MySQL": {
            "host": "localhost",
            "port": 3306,
            "max_connections": 100
        },
        "Redis": {
            "host": "localhost",
            "port": 6379
        }
    },
    "日志": {
        "級(jí)別": "INFO",
        "文件路徑": "/var/log/app.log",
        "最大大小": "100MB"
    }
}

# 訪問深層配置
print(config["數(shù)據(jù)庫(kù)"]["MySQL"]["host"])  # 輸出: localhost