Python的字典推导式从入门到精通

{key_expr: value_expr for item in iterable if condition}

# 创建一个字典，将数字映射到其平方
squares = {x: x**2 for x in range(5)}
print(squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

lst = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

s = {x**2 for x in range(5)}  # {0, 1, 4, 9, 16}

d = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 将名字映射到长度
names = ["Alice", "Bob", "Charlie"]
name_lengths = {name: len(name) for name in names}
print(name_lengths)  # 输出: {'Alice': 5, 'Bob': 3, 'Charlie': 7}

# 仅包含偶数的平方
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}

# 生成笛卡尔积的键值对
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, ...}

# 将值加倍
old_dict = {"a": 1, "b": 2, "c": 3}
doubled = {k: v * 2 for k, v in old_dict.items()}
print(doubled)  # 输出: {'a': 2, 'b': 4, 'c': 6}

# 将字符串转换为大写并计算长度
words = ["python", "code", "data"]
upper_lengths = {word.upper(): len(word) for word in words}
print(upper_lengths)  # 输出: {'PYTHON': 6, 'CODE': 4, 'DATA': 4}

# 筛选长度大于 3 且以 'a' 开头的名字
names = ["alice", "bob", "anna", "alexander"]
filtered = {name: len(name) for name in names if len(name) > 3 and name.startswith("a")}
print(filtered)  # 输出: {'alice': 5, 'alexander': 9}

# 创建学生成绩表
students = ["Alice", "Bob"]
subjects = ["Math", "Science"]
scores = {student: {subject: 0 for subject in subjects} for student in students}
print(scores)  # 输出: {'Alice': {'Math': 0, 'Science': 0}, 'Bob': {'Math': 0, 'Science': 0}}

# 配对名字和年龄
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
user_dict = {name: age for name, age in zip(names, ages)}
print(user_dict)  # 输出: {'Alice': 25, 'Bob': 30, 'Charlie': 35}

# 生成编号键
items = ["apple", "banana", "orange"]
indexed = {f"item_{i}": item for i, item in enumerate(items)}
print(indexed)  # 输出: {'item_0': 'apple', 'item_1': 'banana', 'item_2': 'orange'}

# 根据值大小分类
numbers = range(10)
categories = {n: "even" if n % 2 == 0 else "odd" for n in numbers}
print(categories)  # 输出: {0: 'even', 1: 'odd', 2: 'even', ...}

# 处理大数据集
large_dict = {x: x**2 for x in range(1000000)}  # 直接创建
gen_dict = dict((x, x**2) for x in range(1000000))  # 生成器方式

import sys
print(sys.getsizeof(large_dict))  # 更大
print(sys.getsizeof((x, x**2) for x in range(1000000)))  # 更小

# 传统循环
def create_dict_loop(n):
    d = {}
    for x in range(n):
        d[x] = x**2
    return d

# 字典推导式
def create_dict_comp(n):
    return {x: x**2 for x in range(n)}

# 性能测试
import timeit
print(timeit.timeit(lambda: create_dict_loop(1000), number=1000))  # 约 0.23 秒
print(timeit.timeit(lambda: create_dict_comp(1000), number=1000))  # 约 0.18 秒

names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
# 推导式
d1 = {name: age for name, age in zip(names, ages)}
# dict() + zip()
d2 = dict(zip(names, ages))
# 性能测试
print(timeit.timeit(lambda: {name: age for name, age in zip(names, ages)}, number=1000))  # 约 0.012 秒
print(timeit.timeit(lambda: dict(zip(names, ages)), number=1000))  # 约 0.010 秒

# 内存密集
d = {x: x**2 for x in range(1000000)}
# 内存友好
d = dict((x, x**2) for x in range(1000000))

# 差：重复调用 len()
d = {name: len(name) for name in names}
# 好：缓存结果
lengths = [len(name) for name in names]
d = {name: length for name, length in zip(names, lengths)}

import pandas as pd
# 假设 CSV 数据
data = pd.DataFrame({"name": ["Alice", "Bob"], "age": [25, 30]})
# 转换为字典
name_age = {row["name"]: row["age"] for _, row in data.iterrows()}
print(name_age)  # 输出: {'Alice': 25, 'Bob': 30}

name_age = data.set_index("name")["age"].to_dict()

endpoints = ["users", "products", "orders"]
base_url = "https://api.example.com"
urls = {endpoint: f"{base_url}/{endpoint}" for endpoint in endpoints}
print(urls)  # 输出: {'users': 'https://api.example.com/users', ...}

lights = ["red", "green", "yellow"]
durations = [30, 60, 10]
light_config = {light: {"duration": dur, "active": False} for light, dur in zip(lights, durations)}
print(light_config)
# 输出: {'red': {'duration': 30, 'active': False}, ...}

positions = [(0, 0), (1, 1)]
states = {(x, y): "empty" for x, y in positions}

edges = [(0, 1), (1, 2), (2, 0)]
graph = {node: [] for node in range(3)}
for u, v in edges:
    graph[u].append(v)
# 使用推导式初始化
graph = {node: [v for u, v in edges if u == node] for node in range(3)}
print(graph)  # 输出: {0: [1], 1: [2], 2: [0]}

text = "apple banana apple orange"
words = text.split()
word_freq = {word: words.count(word) for word in set(words)}
print(word_freq)  # 输出: {'apple': 2, 'banana': 1, 'orange': 1}

pairs = [("a", 1), ("a", 2)]
d = {k: v for k, v in pairs}
print(d)  # 输出: {'a': 2}（覆盖）

d = {k: [v for _, v in pairs if _ == k] for k, _ in pairs}
print(d)  # 输出: {'a': [1, 2]}

d = {f"{x}_{y}": x * y for x in range(5) for y in range(5) if x > y and y % 2 == 0}

d = {}
for x in range(5):
    for y in range(5):
        if x > y and y % 2 == 0:
            d[f"{x}_{y}"] = x * y

d = dict((x, x**2) for x in range(1000000))

from itertools import islice
d = {x: x**2 for x in islice(range(1000000), 0, 1000)}

d = {[1, 2]: "value"}  # TypeError: unhashable type: 'list'

d = {(1, 2): "value"}

from typing import Dict, List
def create_mapping(names: List[str]) -> Dict[str, int]:
    return {name: len(name) for name in names}

pip install mypy
mypy script.py

flake8 --max-line-length=100 script.py

pylint --disable=too-long-line script.py

names = ["Alice", "Bob"]
%timeit {name: len(name) for name in names}

def create_dict(names: List[str]) -> Dict[str, int]:
    """Create a dictionary mapping names to their lengths.

    Args:
        names (List[str]): List of names.

    Returns:
        Dict[str, int]: Dictionary with name-length pairs.
    """
    return {name: len(name) for name in names}

import pandas as pd
data = pd.DataFrame({"product": ["apple", "banana"], "price": [1.5, 2.0]})
price_dict = {row["product"]: row["price"] for _, row in data.iterrows()}
print(price_dict)  # 输出: {'apple': 1.5, 'banana': 2.0}

price_dict = data.set_index("product")["price"].to_dict()

intersections = [(0, 0), (1, 1)]
traffic_states = {(x, y): {"light": "red", "vehicles": 0} for x, y in intersections}
print(traffic_states)
# 输出: {(0, 0): {'light': 'red', 'vehicles': 0}, (1, 1): {'light': 'red', 'vehicles': 0}}

import requests
users = requests.get("https://api.example.com/users").json()
user_map = {user["id"]: user["name"] for user in users}

user_map = {user["id"]: user["name"] for user in users if "name" in user}

docs = ["apple banana", "banana orange", "apple pear"]
index = {word: [i for i, doc in enumerate(docs) if word in doc.split()] for word in set(" ".join(docs).split())}
print(index)  # 输出: {'apple': [0, 2], 'banana': [0, 1], 'orange': [1], 'pear': [2]}