def add(a, b):
    return a + b

add(3, 5)          # 8   按位置

def greet(name, greeting):
    print(f"{greeting}，{name}")

greet(name="咖飞", greeting="你好")
greet(greeting="早上好", name="小王")

greet("咖飞", greeting="你好")     # ✅
greet(name="咖飞", "你好")         # ❌ SyntaxError

def greet(name, greeting="你好"):
    print(f"{greeting}，{name}")

greet("咖飞")                # 你好，咖飞
greet("咖飞", "早上好")       # 早上好，咖飞
greet("咖飞", greeting="hi") # hi，咖飞

def bad(x=1, y):    # ❌ SyntaxError: 非默认参数在默认参数后
    ...

def append(item, lst=[]):
    lst.append(item)
    return lst

append(1)     # [1]
append(2)     # [1, 2]     ！！ 上一次的 lst 还在

def append(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

def total(*args):
    print(type(args))    # <class 'tuple'>
    return sum(args)

total(1, 2, 3)         # 6
total(1, 2, 3, 4, 5)   # 15
total()                # 0

def show(**kwargs):
    print(type(kwargs))    # <class 'dict'>
    for k, v in kwargs.items():
        print(f"{k}={v}")

show(name="咖飞", age=3)
# name=咖飞
# age=3

def log(level, *args, **kwargs):
    print(f"[{level}]", *args, kwargs)

log("INFO", "server started", port=8080, host="localhost")
# [INFO] server started {'port': 8080, 'host': 'localhost'}

def f(a, b, c):
    print(a, b, c)

args = [1, 2, 3]
f(*args)                # 等价 f(1, 2, 3)

kwargs = {"a": 1, "b": 2, "c": 3}
f(**kwargs)             # 等价 f(a=1, b=2, c=3)

def wrapper(*args, **kwargs):
    # 做点前置逻辑
    return original_func(*args, **kwargs)

def f(pos_only, /, both, *, kw_only):
    print(pos_only, both, kw_only)

f(1, 2, kw_only=3)       # ✅
f(1, both=2, kw_only=3)  # ✅
f(pos_only=1, ...)       # ❌ 不允许，pos_only 只能位置
f(1, 2, 3)               # ❌ 不允许，kw_only 只能关键字

def spec(a, b, /, c, d, *args, e, f=10, **kwargs):
    ...

def register(
    name: str,
    age: int,
    *emails: str,
    active: bool = True,
    **extras: str,
) -> dict:
    return {"name": name, "age": age, "emails": emails,
            "active": active, "extras": extras}

register("咖飞", 3, "a@x.com", "b@x.com", active=False, city="北京")

# params.py
"""演示各种参数形式的组合用法。"""


def create_user(name: str, /, age: int, *hobbies: str,
                city: str = "北京", **extras) -> dict:
    """创建用户档案。

    Args:
        name: 姓名（仅位置）
        age: 年龄
        *hobbies: 任意多个爱好
        city: 城市，仅关键字，默认"北京"
        **extras: 额外自定义属性
    """
    return {
        "name": name,
        "age": age,
        "hobbies": hobbies,
        "city": city,
        **extras,
    }


print(create_user("咖飞", 3, "读书", "跑步", city="上海", height=178))

import time
import functools

def timed(func):
    """一个简易装饰器：打印函数耗时。"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} 耗时 {time.time() - start:.3f}s")
        return result
    return wrapper

@timed
def compute(n, base=10):
    return sum(i ** base for i in range(n))

compute(1000, base=3)

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("input")
parser.add_argument("--output", default="out.txt")
parser.add_argument("--verbose", "-v", action="store_true")
args = parser.parse_args()

print(args.input, args.output, args.verbose)

def f(x):
    x = 10       # 让本地名字 x 指向新对象，不影响外部
def g(lst):
    lst.append(1)  # 就地修改可变对象，外部感知得到

a = 5
f(a)
print(a)     # 5，没变

b = []
g(b)
print(b)     # [1]，变了

import datetime
def log(msg, ts=datetime.datetime.now()):
    print(ts, msg)
# 所有调用都用第一次 def 时的时间，除非 ts=None 再内部生成

f(**{"a": 1}, a=2)   # ❌ TypeError

def greet(name):
    print(f"你好，{name}")


greet("咖飞")     # 你好，咖飞

def add(a, b):
    return a + b

result = add(3, 5)
print(result)     # 8

def hello():
    print("hi")

result = hello()
print(result)     # None

def sign(n):
    if n > 0:
        return "正"
    if n < 0:
        return "负"
    return "零"

def stats(nums):
    return min(nums), max(nums), sum(nums) / len(nums)

low, high, avg = stats([1, 2, 3, 4, 5])
print(low, high, avg)     # 1 5 3.0

def circle_area(r):
    """计算圆的面积。

    Args:
        r: 半径，非负实数

    Returns:
        面积，float
    """
    return 3.14159 * r * r


print(circle_area.__doc__)
help(circle_area)      # 在 REPL 里查文档

def add(a: int, b: int) -> int:
    return a + b

def greet(name: str) -> None:
    print(f"你好，{name}")

def top_k(items: list[int], k: int) -> list[int]:
    return sorted(items, reverse=True)[:k]

def get_user(id: int) -> dict[str, str] | None:
    ...

def double(x):
    return x * 2

f = double        # 变量名指向函数对象
print(f(5))       # 10

# 传给别的函数
list(map(double, [1, 2, 3]))     # [2, 4, 6]

# 存进字典（策略模式）
ops = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
}
print(ops["add"](3, 4))      # 7

def foo():
    """foo 的说明"""
    pass

print(foo.__name__)     # 'foo'
print(foo.__doc__)      # 'foo 的说明'

foo.custom = 123        # 甚至能挂自定义属性
print(foo.custom)       # 123

double = lambda x: x * 2
add = lambda a, b: a + b

# 常用在 sort 的 key
sorted(users, key=lambda u: u.age)

# 纯函数
def add(a, b):
    return a + b

# 有副作用
total = 0
def add_to_total(x):
    global total
    total += x
    print(f"当前总和 {total}")

def greet(name, greeting="你好"):
    print(f"{greeting}，{name}")

greet("咖飞")                # 你好，咖飞
greet("小王", "早上好")       # 早上好，小王

def append_item(item, lst=[]):
    lst.append(item)
    return lst

print(append_item(1))   # [1]
print(append_item(2))   # [1, 2]  ！！ 上一次的 lst 还在

def append_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

def largest(nums):
    m = max(nums)     # 忘了 return

print(largest([1, 2, 3]))    # None

def sort_items(lst):
    lst.sort()         # 就地修改，调用方的 lst 也变了
    return lst

def list(x):
    return x

print(list([1, 2, 3]))     # 现在 list 是我们的函数，内置 list 被覆盖

def find(items, target):
    for x in items:
        if x == target:
            return x
    # 找不到时忘了 return，隐式返回 None

# temperature.py
"""温度单位转换工具集。"""


def celsius_to_fahrenheit(c: float) -> float:
    """摄氏 → 华氏。"""
    return c * 9 / 5 + 32


def fahrenheit_to_celsius(f: float) -> float:
    """华氏 → 摄氏。"""
    return (f - 32) * 5 / 9


def celsius_to_kelvin(c: float) -> float:
    """摄氏 → 开尔文。"""
    return c + 273.15


def kelvin_to_celsius(k: float) -> float:
    """开尔文 → 摄氏。"""
    return k - 273.15


def convert(value: float, from_unit: str, to_unit: str) -> float:
    """通用转换函数。所有非摄氏单位先转成摄氏，再从摄氏转到目标单位。"""
    from_unit = from_unit.upper()
    to_unit = to_unit.upper()

    # 先转成摄氏
    if from_unit == "C":
        c = value
    elif from_unit == "F":
        c = fahrenheit_to_celsius(value)
    elif from_unit == "K":
        c = kelvin_to_celsius(value)
    else:
        raise ValueError(f"未知单位：{from_unit}")

    # 再从摄氏转出
    if to_unit == "C":
        return c
    if to_unit == "F":
        return celsius_to_fahrenheit(c)
    if to_unit == "K":
        return celsius_to_kelvin(c)
    raise ValueError(f"未知单位：{to_unit}")


if __name__ == "__main__":
    # 冰水混合物
    assert celsius_to_fahrenheit(0) == 32
    assert convert(100, "C", "F") == 212
    assert convert(212, "F", "C") == 100

    print(f"25°C = {convert(25, 'C', 'F'):.1f}°F")
    print(f"25°C = {convert(25, 'C', 'K'):.2f}K")

abs(-5)              # 5    绝对值
divmod(17, 5)        # (3, 2)  同时算商和余数
pow(2, 10)           # 1024   等价 2 ** 10
pow(2, 10, 1000)     # 24     快速幂取模，密码学常用
round(3.5)           # 4      银行家舍入（四舍六入五留双）
round(3.14159, 2)    # 3.14
round(2.5)           # 2      不是 3！

min(3, 1, 4, 1, 5, 9, 2, 6)
max([3, 1, 4])
min("banana")                    # 'a'   字符串按字典序
min(users, key=lambda u: u.age)  # 按 key 找最小

# default 参数
max([], default=0)               # 空序列不报错

sum([1, 2, 3])
sum([1, 2, 3], start=100)        # 106

list(iter)           # 转列表
tuple(iter)          # 转元组
set(iter)            # 转集合
frozenset(iter)      # 转不可变集合
dict([("a", 1)])     # 转字典
str(x)               # 转字符串
bytes(iter)          # 转字节
bytearray(iter)      # 转可变字节
range(n)             # 数字序列

len(seq)             # 长度
sum(seq)             # 求和
min(seq), max(seq)   # 极值
sorted(seq)          # 排序（返回新列表）
sorted(seq, key=..., reverse=True)
reversed(seq)        # 反转迭代器
list(reversed([1, 2, 3]))    # [3, 2, 1]

any([False, True])   # True，任一为真
all([True, True])    # True，全为真
any([])              # False
all([])              # True   空的"全部为真"是空真

if any(x < 0 for x in nums):
    print("有负数")

if all(u.active for u in users):
    print("所有用户都活跃")

enumerate(seq, start=0)         # 产生 (index, item)
zip(a, b)                       # 并行迭代，最短为准
zip(a, b, strict=True)          # Python 3.10+，长度不等抛错
map(func, iter)                 # 每个元素调用 func
filter(pred, iter)              # 保留 pred 返回真的
range(start, stop, step)        # 数字序列
iter(iterable)                  # 拿到迭代器
next(iterator, default)         # 取下一个

for i, name in enumerate(names, start=1):
    print(f"{i}. {name}")

for a, b, c in zip(list_a, list_b, list_c):
    ...

# map
uppercase = list(map(str.upper, words))
# 等价推导式（更 Pythonic）
uppercase = [w.upper() for w in words]

# filter
positives = list(filter(lambda x: x > 0, nums))
# 等价推导式
positives = [x for x in nums if x > 0]

type(x)                          # 返回类型对象
isinstance(x, (int, float))      # x 是 int 或 float
issubclass(cls, base)            # cls 是不是 base 的子类
callable(x)                      # x 是不是可调用（函数/类/带 __call__）
id(x)                            # 对象唯一 id，一般不用
hash(x)                          # 计算哈希，不可哈希会报错

ord("A")            # 65
chr(65)             # 'A'
bin(10)             # '0b1010'
oct(10)             # '0o12'
hex(255)            # '0xff'
ascii("你好")        # "'\\u4f60\\u597d'"
repr(x)             # 对象的 repr，一般 print(repr(x))

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
input(prompt)
open(path, mode="r", encoding="utf-8")

getattr(obj, "name", default)    # 取属性，可给默认
setattr(obj, "name", value)      # 设属性
hasattr(obj, "name")             # 有没有该属性
delattr(obj, "name")             # 删属性
dir(obj)                         # 列出所有属性/方法
vars(obj)                        # 相当于 obj.__dict__

# 根据用户输入的操作名调用方法
op = input("操作：")
handler = getattr(controller, f"do_{op}", None)
if handler:
    handler()
else:
    print("未知操作")

eval("1 + 2")              # 3    求值一个表达式
exec("x = 5")              # 执行任意语句
compile(src, "<string>", "exec")  # 编译代码对象

object                    # 所有类的祖先
super()                   # 调用父类方法
staticmethod, classmethod, property   # 装饰器
type("MyClass", (Base,), {"x": 1})    # 动态建类

sorted(iter, key=None, reverse=False)

# 按长度排
sorted(words, key=len)

# 按元组第 2 项
sorted(pairs, key=lambda p: p[1])

# 稳定排序，可以多次 sort 组合多字段
records.sort(key=lambda r: r.age)
records.sort(key=lambda r: r.name)     # 主排序：name，次排序：age

# 或者一次搞定
records.sort(key=lambda r: (r.name, r.age))

list(reversed([1, 2, 3]))         # [3, 2, 1]
list(reversed(range(5)))          # [4, 3, 2, 1, 0]
list(reversed({1, 2, 3}))         # ❌ set 无序，不能 reversed

import math
math.sqrt(16)              # 4.0
math.floor(3.7)            # 3
math.ceil(3.2)             # 4
math.pi, math.e            # 常量

import random
random.random()            # [0.0, 1.0)
random.randint(1, 10)      # [1, 10]
random.choice([1, 2, 3])
random.shuffle(lst)        # 就地打乱

import statistics
statistics.mean([1, 2, 3])
statistics.median([1, 2, 3])

# 3.10：zip strict
zip([1, 2, 3], [4, 5], strict=True)   # ValueError

# 3.11：ExceptionGroup（并发场景多个异常聚合）
try:
    ...
except* ValueError as eg:
    ...

# 3.12：type 语法糖
type Vector = list[float]

memoryview(b"hello")       # 零拷贝的内存视图
slice(1, 5, 2)             # 可复用的切片对象
zip(*matrix)               # 矩阵转置的一行代码

# 组合技：一次拿多个属性
attrgetter, itemgetter, methodcaller  # 在 operator 模块

from operator import attrgetter, itemgetter

# 按属性排序
users.sort(key=attrgetter("age"))

# 按 dict 的 key 排序
data.sort(key=itemgetter("score"))

# 多字段
data.sort(key=itemgetter("category", "price"))

# stats.py
"""对一个学生成绩表做各种统计，尽量用内置函数。"""

students = [
    {"name": "张三", "score": 92, "class": "A"},
    {"name": "李四", "score": 78, "class": "B"},
    {"name": "王五", "score": 85, "class": "A"},
    {"name": "赵六", "score": 60, "class": "C"},
    {"name": "孙七", "score": 95, "class": "B"},
]

from operator import itemgetter

# 总人数、总分、平均、最大/最小
print("人数：", len(students))
print("总分：", sum(map(itemgetter("score"), students)))
print("平均：", sum(s["score"] for s in students) / len(students))
print("最高：", max(students, key=itemgetter("score")))
print("最低：", min(students, key=itemgetter("score")))

# 60 分以下
print("不及格：", list(filter(lambda s: s["score"] < 70, students)))

# 是否全员及格
print("全过：", all(s["score"] >= 60 for s in students))

# 是否有满分
print("有满分：", any(s["score"] == 100 for s in students))

# 排序（成绩降序）
print("排名：")
for i, s in enumerate(sorted(students, key=itemgetter("score"), reverse=True), 1):
    print(f"{i}. {s['name']} {s['score']}")

# 按班级分组（简单版）
from itertools import groupby
data_sorted = sorted(students, key=itemgetter("class"))
for cls, group in groupby(data_sorted, key=itemgetter("class")):
    group = list(group)
    print(f"班级 {cls}: 平均 {sum(g['score'] for g in group)/len(group):.1f}")

序列[start:stop:step]

a = [10, 20, 30, 40, 50, 60, 70]

a[2:5]       # [30, 40, 50]    索引 2 到 5（不含 5）
a[:3]        # [10, 20, 30]    从头到 3
a[3:]        # [40, 50, 60, 70]  从 3 到末尾
a[:]         # 完整拷贝
a[::2]       # [10, 30, 50, 70]  步长 2
a[1::2]      # [20, 40, 60]      奇数索引
a[::-1]      # 反转

a = [10, 20, 30, 40, 50]

a[-1]        # 50
a[-3:-1]     # [30, 40]
a[::-1]      # 反转
a[-1:-4:-1]  # [50, 40, 30]     步长 -1，从右往左

a = [1, 2, 3]
a[10]      # ❌ IndexError
a[10:20]   # ✅ 返回 []
a[-100:2]  # ✅ 返回 [1, 2]

a = [1, 2, 3, 4, 5]

# 长度相同：直接替换
a[1:3] = [20, 30]        # [1, 20, 30, 4, 5]

# 长度不同：延伸/收缩
a[1:3] = [10, 20, 30]    # [1, 10, 20, 30, 4, 5]
a[1:4] = []              # [1, 4, 5]   删除元素

# 用切片插入元素
a = [1, 2, 3]
a[1:1] = [10, 20]        # [1, 10, 20, 2, 3]

# 步长赋值：长度必须严格相等
a = [1, 2, 3, 4, 5, 6]
a[::2] = [100, 200, 300] # [100, 2, 200, 4, 300, 6]
a[::2] = [100, 200]      # ❌ ValueError: 长度不匹配

a = [[1, 2], [3, 4]]
b = a[:]
b.append([5, 6])       # a 不变
b[0][0] = 999          # a[0] 也变！内层引用共享

s = slice(1, 5, 2)
a = [10, 20, 30, 40, 50, 60]
print(a[s])          # [20, 40]  等价于 a[1:5:2]

s = "abcdefg"

s[2:5]      # 'cde'
s[::-1]     # 'gfedcba'   反转
s[::2]      # 'aceg'

# 判断回文
def is_palindrome(s: str) -> bool:
    return s == s[::-1]

b = b"hello"
print(b[1:4])      # b'ell'

ba = bytearray(b"hello")
ba[1:4] = b"XYZ"
print(ba)          # bytearray(b'hXYZo')

import numpy as np
arr = np.arange(20).reshape(4, 5)
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]
#  [15 16 17 18 19]]

arr[1:3, 2:4]      # 取子矩阵
# [[ 7  8]
#  [12 13]]

arr[:, 0]          # 第一列
arr[::2, ::2]      # 隔一行隔一列

from itertools import islice
# 逐条读 100 万行文件的第 100-200 行
with open("huge.log") as f:
    for line in islice(f, 100, 200):
        print(line)

s[::-1]              # 字符串/列表反转
list(reversed(s))    # 等价但返回列表

b = a[:]
# 更清晰：b = list(a) 或 a.copy()

def chunks(lst, n):
    """把 lst 按每 n 个一组切分。"""
    for i in range(0, len(lst), n):
        yield lst[i:i+n]

list(chunks([1,2,3,4,5,6,7], 3))    # [[1,2,3], [4,5,6], [7]]

head, *rest = a          # 用解包
head, tail = a[0], a[1:] # 用切片

a = a[1:]        # 去掉第一个
a = a[:-1]       # 去掉最后一个
a = a[1:-1]      # 去掉首尾

last_n = a[-n:]

mid = len(a) // 2
a = a[mid:] + a[:mid]   # 前后半段交换

a = [1, 2, 3, 4, 5]

# 单索引
a[0]       # 1
a[-1]      # 5
a[10]      # IndexError

# 切片
a[0:0]     # []
a[10:20]   # []
a[-10:10]  # 完整列表
a[:0]      # []

# rolling.py
"""对一个序列做定长滚动窗口，计算窗口内平均值。"""

from statistics import mean

def rolling_avg(data: list[float], window: int) -> list[float]:
    """每个窗口的平均值。data 长度 n → 输出长度 n-window+1。"""
    if window > len(data):
        return []
    return [mean(data[i:i+window]) for i in range(len(data) - window + 1)]


def paginate(lst: list, page_size: int) -> list[list]:
    """按 page_size 分页。"""
    return [lst[i:i+page_size] for i in range(0, len(lst), page_size)]


def head_tail(lst: list, n: int) -> tuple[list, list]:
    """返回头 n 个和尾 n 个（不重叠）。"""
    if len(lst) < 2 * n:
        return lst, []
    return lst[:n], lst[-n:]


if __name__ == "__main__":
    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print("滚动平均 (window=3):", rolling_avg(data, 3))
    print("分页 (size=4):", paginate(data, 4))
    print("头尾 3 个:", head_tail(data, 3))

{1, 2, 3}[::-1]     # ❌ TypeError

a = [1, 2, 3, 4]
a[::2] = [10, 20, 30]     # ❌ 步长切片必须长度严格匹配
a[::2] = [10, 20]         # ✅

a = [1, 2, 3]
c = a
a[:] = [10, 20]     # 修改原对象，c 也变
print(c)            # [10, 20]

a = [1, 2, 3]
c = a
a = [10, 20]        # a 指向新对象，c 不变
print(c)            # [1, 2, 3]

lst = [1, 2, 3]
lst[1:2][0] = 999          # 什么都没发生，lst 不变

arr = np.array([1, 2, 3])
arr[1:2][0] = 999          # arr[1] 变成 999！

name, age = "咖飞", 3

# %（1990 年代）
"我叫 %s，%d 岁" % (name, age)

# str.format()（Python 2.6+）
"我叫 {}，{} 岁".format(name, age)

# f-string（Python 3.6+，推荐）
f"我叫 {name}，{age} 岁"

"{:.2f}".format(3.14159)       # '3.14'
f"{3.14159:.2f}"               # '3.14'
"%.2f" % 3.14159               # '3.14'

f"{42:5d}"       # '   42'      默认右对齐
f"{42:<5d}"      # '42   '
f"{42:^5d}"      # ' 42  '
f"{42:*^5d}"     # '**42*'      用 * 填充
f"{'py':>10}"    # '        py'
f"{'py':-^10}"   # '----py----'

f"{7:04d}"       # '0007'   4 位宽度，前补 0
f"{-7:04d}"      # '-007'   带负号也占位
f"{7:=04d}"      # '0007'   显式指定"=对齐"（数字默认）

f"{3.14159:.2f}"       # '3.14'
f"{3.14159:.5f}"       # '3.14159'
f"{3:.2f}"             # '3.00'      整数也能格式化成 .2f

f"{1234567:,}"         # '1,234,567'
f"{1234567.89:,.2f}"   # '1,234,567.89'
f"{1234567:_}"         # '1_234_567'   Python 3.6+ 下划线分隔

f"{0.256:.1%}"    # '25.6%'
f"{0.256:.0%}"    # '26%'
f"{-0.05:+.1%}"   # '-5.0%'   显式加号

f"{255:b}"       # '11111111'
f"{255:o}"       # '377'
f"{255:x}"       # 'ff'
f"{255:X}"       # 'FF'
f"{255:#x}"      # '0xff'
f"{255:#010b}"   # '0b11111111'  # 表示带前缀，010 表示 10 位宽补零

f"{3:+}"         # '+3'
f"{-3:+}"        # '-3'
f"{3: }"         # ' 3'       正数留空格

f"{'py':10}"     # 'py        '  默认左对齐
f"{'py':>10}"    # '        py'  右对齐（字符串默认左）
f"{'long text':.4}"   # 'long'   截断到 4 字符

from datetime import datetime, date

now = datetime.now()
f"{now:%Y-%m-%d %H:%M:%S}"    # '2025-09-10 22:03:19'
f"{now:%Y年%m月%d日}"           # '2025年09月10日'
f"{now:%A}"                    # 'Wednesday'
f"{date.today():%Y/%m/%d}"     # '2025/09/10'

w = 10
p = 3

f"{3.14159:{w}.{p}f}"        # '     3.142'
f"{3.14159:{'>'}{w}.{p}f}"   # 同上，动态对齐

x, y = 42, 10
print(f"{x=}")           # x=42
print(f"{x+y=}")         # x+y=52
print(f"{x*y=:.2f}")     # x*y=420.00

user = {"name": "咖飞", "age": 3}
print(f"{user['name']=}")   # user['name']='咖飞'

name = "咖飞"
print(f"{name}")      # 咖飞
print(f"{name!r}")    # '咖飞'   带引号，输出 repr
print(f"{name!s}")    # 咖飞     默认，等价 str
print(f"{name!a}")    # '咖飞'  ascii-only

# 在调试语法里
print(f"{name=!r}")   # name='咖飞'

name = "咖飞"
# Python 3.11 前，引号不能跟外层一样
f'{f"内层 {name}":>10}'
# Python 3.12+ 允许同类型引号嵌套

template = "{name} 得了 {score} 分"
config_format = template.format(name="咖飞", score=99)

# 命名参数
"{last} {first}".format(first="咖", last="飞")

# 索引参数（可以重复使用）
"{0} {1} {0}".format("a", "b")

# 属性/索引访问
"{p.name}".format(p=some_obj)
"{d[key]}".format(d={"key": "value"})

"%s is %d years old" % ("咖飞", 3)
"%-10s | %5.2f" % ("cpu", 3.14)
"%(name)s %(age)d" % {"name": "咖飞", "age": 3}

import locale
locale.setlocale(locale.LC_ALL, "")

# n 格式会用 locale 规则
f"{1234567.89:n}"    # 中文环境：'1234567.89'

# invoice.py
"""格式化打印一份账单，展示各种 format spec 用法。"""

from datetime import datetime

items = [
    ("苹果",  10, 3.50),
    ("面包",   2, 8.00),
    ("咖啡豆", 1, 128.00),
    ("巧克力", 5, 15.90),
]

# 表头
print(f"{'咖飞小店':^40}")
print(f"{'账单':^40}")
print(f"{datetime.now():%Y-%m-%d %H:%M:%S}")
print("-" * 40)
print(f"{'商品':<10}{'数量':>6}{'单价':>10}{'小计':>12}")
print("-" * 40)

total = 0
for name, qty, price in items:
    subtotal = qty * price
    total += subtotal
    print(f"{name:<10}{qty:>6d}{price:>10,.2f}{subtotal:>12,.2f}")

print("-" * 40)
print(f"{'合计':<10}{'':>6}{'':>10}{total:>12,.2f}")
print(f"{'税率':<10}{'':>6}{'':>10}{0.13:>12.1%}")
print(f"{'含税':<10}{'':>6}{'':>10}{total * 1.13:>12,.2f}")

squares = []
for x in range(10):
    squares.append(x * x)

squares = [x * x for x in range(10)]

[表达式 for 变量 in 可迭代对象 if 条件]

# 平方
[x*x for x in range(5)]                   # [0, 1, 4, 9, 16]

# 过滤：只要正数
[x for x in [-2, -1, 0, 1, 2] if x > 0]   # [1, 2]

# 表达式可以是函数调用
[str(x).zfill(3) for x in range(5)]       # ['000', '001', '002', '003', '004']

# 既大于 0 又是偶数
[x for x in nums if x > 0 if x % 2 == 0]
# 等价于
[x for x in nums if x > 0 and x % 2 == 0]

# 正数保留，负数变 0
[x if x > 0 else 0 for x in nums]

# 所有 (i, j) 对
[(i, j) for i in range(3) for j in range(3)]
# [(0, 0), (0, 1), (0, 2), (1, 0), ..., (2, 2)]

# 展平二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 平方表
{n: n*n for n in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 反转字典
inv = {v: k for k, v in d.items()}

# 过滤字典
adults = {name: age for name, age in people.items() if age >= 18}

# 从两个列表 zip 出字典
d = {k: v for k, v in zip(keys, values)}
# 更简单：d = dict(zip(keys, values))

{x % 3 for x in range(10)}       # {0, 1, 2}

# 从文本抽取所有独立单词
{w.lower() for w in text.split() if w.isalpha()}

gen = (x*x for x in range(10))
print(gen)                        # <generator object ...>
print(next(gen))                  # 0
print(next(gen))                  # 1

for x in gen:
    print(x)

# ❌ 内存爆炸：一次性生成 1 亿个数字
sum([x*x for x in range(10**8)])

# ✅ 内存友好：逐个产生
sum(x*x for x in range(10**8))

sum(x*x for x in range(10))               # 括号省略
max((x.age for x in users), default=0)    # 有多个参数就不能省

uppercased = [w.upper() for w in words]
strs = [str(x) for x in nums]

positives = [x for x in nums if x > 0]

even_squares = [x*x for x in range(10) if x % 2 == 0]

{k: v for k, v in pairs}

inv = {v: k for k, v in d.items()}

from collections import defaultdict
counts = defaultdict(int)
for w in words:
    counts[w] += 1

# 用 Counter 更好
from collections import Counter
counts = Counter(words)

matrix = [[0] * cols for _ in range(rows)]

# 用 zip
transposed = list(zip(*matrix))

# 用推导式
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]

[x for x in range(3)]
print(x)      # NameError!

# 对比 for 循环
for x in range(3):
    pass
print(x)      # 2，泄漏了

# ❌ 反面教材：又长又难懂
result = [
    (u.name.strip(), age)
    for u in users
    if u.active
    for age in [max(0, u.age - u.exp)]
    if age > 18
]

# ✅ 拆成普通循环，可读性强
result = []
for u in users:
    if not u.active:
        continue
    age = max(0, u.age - u.exp)
    if age > 18:
        result.append((u.name.strip(), age))