>>> 1 + 1
2

name = "Python"
print(name)

# 这一行不会被执行
x = 10  # 行尾也可以写注释

起步 ──► 语法基础 ──► 数据结构 ──► 函数 ──► 面向对象 ──► 进阶特性 ──► 工程实践
第1-3章    第4-7章      第8-10章    第11-13章   第16-18章    第19-24章    第25-28章
                            │
                            └──► 异常/文件（第14-15章）

for i in range(1, 6):
    print(i)

python3 --version

brew install python

winget install Python.Python.3.14

sudo apt update && sudo apt install python3 python3-pip python3-venv

# 安装 uv（macOS/Linux）
curl -LsSf https://astral.sh/uv/install.sh | sh

# 用 uv 安装 Python
uv python install 3.14

Python 3.14.x (main, ...) [...]
Type "help", "copyright", "credits" or "license" for more information.
>>>

>>> 2 + 3
5
>>> "hello".upper()
'HELLO'

python3 hello.py

$ python3
>>> 2 ** 100
1267650600228229401496703205376
>>> exit()

$ cat first.py
print("我装好 Python 了")
$ python3 first.py
我装好 Python 了

print("Hello, World!")

Hello, World!

print("a", "b", "c")          # a b c   —— 多个参数用空格分隔
print("a", "b", sep="-")      # a-b     —— 自定义分隔符
print("no newline", end="")   # 不换行
print()                       # 打印一个空行

name = input("请输入你的名字：")
print("你好，" + name)

请输入你的名字：小明
你好，小明

age = input("年龄：")   # 用户输入 18
print(age + 1)         # 报错！TypeError: can only concatenate str (not "int") to str

age = int(input("年龄："))
print(age + 1)   # 19

# 单行注释

x = 1  # 行尾注释

# 多行注释就是写多个 #
# 像这样
# 一行一个

"""
这几行在语法上是一个字符串，
没被赋值给任何变量，所以效果上等于注释。
放在函数/类/模块开头时，它有特殊含义（文档字符串）。
"""

# ❌ 无用注释：代码本身已经说清楚了
count = count + 1  # count 加一

# ✅ 有用注释：解释了代码看不出来的意图
count += 1  # 服务端从 1 开始计数，客户端从 0 开始，这里补偿差值

if 5 > 3:
    print("这行属于 if 内部")
    print("这行也是")
print("这行在 if 外面，无论如何都会执行")

# bmi.py —— 计算身体质量指数
# 分级采用中国成人标准（WS/T 428）：正常 18.5-23.9，超重 24.0-27.9，肥胖 ≥28
# 注意与 WHO 国际标准不同（WHO：超重 ≥25，肥胖 ≥30）

print("=== BMI 计算器 ===")

height = float(input("身高（米，如 1.75）："))
weight = float(input("体重（公斤）："))

bmi = weight / (height ** 2)

print(f"你的 BMI 是 {bmi:.1f}")

if bmi < 18.5:
    print("偏瘦")
elif bmi < 24:
    print("正常")
elif bmi < 28:
    print("偏胖")
else:
    print("肥胖")

=== BMI 计算器 ===
身高（米，如 1.75）：1.75
体重（公斤）：70
你的 BMI 是 22.9
正常

print("请输入两个数")
a = input()
b = input()
print("和是", a + b)

name = input("你的名字：")
age = int(input("你的年龄："))
print(f"你好 {name}，明年你就 {age + 1} 岁了")

celsius = float(input("摄氏温度："))
fahrenheit = celsius * 9 / 5 + 32
print(f"{celsius}°C = {fahrenheit}°F")

print("请输入两个数")
a = float(input())
b = float(input())
print("和是", a + b)

x = 10
message = "hello"
pi = 3.14159

x = 10        # 现在 x 是整数
x = "hello"   # 现在 x 是字符串，完全合法

user_name = "小明"       # ✅ 变量/函数：小写 + 下划线（snake_case）
MAX_RETRY = 3           # ✅ 常量：全大写
class UserProfile:      # ✅ 类名：首字母大写驼峰（PascalCase）
_internal = 1           # ✅ 前缀下划线：表示"内部使用，别碰"

userName = "小明"        # ❌ 这是 Java/JS 风格，Python 里不这么写
l = 1                   # ❌ 小写 l 和数字 1 难以区分
list = [1, 2]           # ❌ 覆盖了内置函数 list

>>> import keyword
>>> keyword.kwlist          # 硬关键字：任何位置都不能用作名字
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break',
 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',
 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal',
 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

>>> keyword.softkwlist      # 软关键字：只在特定语法位置才有特殊含义
['_', 'case', 'match', 'type']

>>> type(42)
<class 'int'>
>>> type(3.14)
<class 'float'>
>>> type("hi")
<class 'str'>
>>> type(True)
<class 'bool'>

a = 42
b = -17
c = 1_000_000     # 下划线做千位分隔符，纯粹为了可读，值就是 1000000

# 其他进制
binary = 0b1010   # 二进制 → 10
octal = 0o17      # 八进制 → 15
hexa = 0xFF       # 十六进制 → 255

>>> 2 ** 1000
10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376

x = 3.14
y = -0.001
z = 2.5e3      # 科学计数法 = 2500.0
w = 1e-4       # = 0.0001

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False

# 方法 1：比较时允许误差
import math
math.isclose(0.1 + 0.2, 0.3)   # True

# 方法 2：涉及钱等需要精确的场合，用 Decimal
from decimal import Decimal
Decimal("0.1") + Decimal("0.2")    # Decimal('0.3')  ✅

# 方法 3：分数用 Fraction
from fractions import Fraction
Fraction(1, 3) + Fraction(1, 6)    # Fraction(1, 2)

is_ready = True
is_done = False

>>> True + True
2
>>> sum([True, False, True])   # 统计有多少个 True
2

False, None, 0, 0.0, 0j, "", [], (), {}, set(), range(0)

if []:
    print("不会执行")     # 空列表是假

if [0]:
    print("会执行")       # 非空列表是真，哪怕里面装的是 0

if "False":
    print("会执行")       # 非空字符串永远是真！

result = None

def f():
    print("hi")

x = f()       # 打印 hi
print(x)      # None —— 函数没有 return，默认返回 None

if x is None:        # ✅
if x is not None:    # ✅
if x == None:        # ❌ 能work但不地道，且自定义类可能重载 == 导致意外

int("42")        # 42       字符串 → 整数
int(3.99)        # 3        截断，不是四舍五入！
int("0b101", 2)  # 5        指定进制
float("3.14")    # 3.14
float(7)         # 7.0
str(42)          # "42"
bool(0)          # False
bool("hi")       # True

round(3.99)      # 4
round(3.14159, 2)  # 3.14

>>> round(0.5)
0
>>> round(1.5)
2
>>> round(2.5)
2

>>> int("abc")
ValueError: invalid literal for int() with base 10: 'abc'

>>> "3" + 5
TypeError: can only concatenate str (not "int") to str

bool("")
bool(" ")
bool([])
bool([[]])
int(-3.7)
round(-3.5)
True + 1
type(1 / 1)

_x    2fast    my-var    myVar    class    Class    数据    __init__

bool("")      # False —— 空字符串
bool(" ")     # True  —— 有一个空格，非空
bool([])      # False —— 空列表
bool([[]])    # True  —— 含一个元素的列表（那个元素是空列表，但不影响外层）
int(-3.7)     # -3    —— 向 0 截断，不是向下取整
round(-3.5)   # -4    —— 银行家舍入，取偶数
True + 1      # 2     —— bool 是 int 的子类
type(1 / 1)   # <class 'float'> —— / 永远返回 float，即使整除

n = float(input("输入一个数字："))
print(f"平方：{n ** 2}")
print(f"立方：{n ** 3}")
print(f"大于 100：{n > 100}")

import math
math.isclose(0.1 + 0.2, 0.3)   # True

7 + 3     # 10   加
7 - 3     # 4    减
7 * 3     # 21   乘
7 / 3     # 2.3333333333333335   除（永远返回 float）
7 // 3    # 2    整除（向下取整）
7 % 3     # 1    取余
7 ** 3    # 343  幂

>>> -7 // 3
-3          # 向下取整（往负无穷方向），不是截断
>>> -7 % 3
2           # 结果符号跟除数一致

n % 2 == 0        # 判断偶数
n % 15 == 0       # 判断能同时被 3 和 5 整除
seconds % 60      # 秒转分秒
i % len(items)    # 循环索引，不会越界

a == b     # 相等
a != b     # 不等
a > b      # 大于
a < b      # 小于
a >= b     # 大于等于
a <= b     # 小于等于

>>> x = 5
>>> 1 < x < 10        # 等价于 1 < x and x < 10
True
>>> 0 <= score <= 100  # 判断分数合法，非常好用

True and False    # False   —— 两个都真才真
True or False     # True    —— 一个真就真
not True          # False   —— 取反

# 常见用法：先检查存在性，再访问
if user is not None and user.is_active:
    ...
# 如果 user 是 None，and 短路，不会执行 user.is_active（否则会报错）

>>> "a" and "b"
'b'          # 都真，返回最后一个
>>> "" or "default"
'default'    # 前面是假，返回后面
>>> 0 or None
None

name = user_input or "匿名"   # user_input 为空字符串时用 "匿名"

port = config_port if config_port is not None else 8080
# 而不是 config_port or 8080 —— 因为 0 是有特殊含义的合法值（表示"让系统随便分配一个端口"），
# 用 or 会把用户明确写的 0 悄悄换成 8080

x = 5
x += 3     # x = x + 3 → 8
x -= 2     # 6
x *= 2     # 12
x /= 4     # 3.0  （注意变成 float 了）
x //= 2    # 1.0
x **= 3    # 1.0
x %= 2     # 1.0

a = [1, 2, 3]
b = [1, 2, 3]
c = a

a == b    # True  —— 内容一样
a is b    # False —— 但是两个不同的列表对象
a is c    # True  —— 同一个对象

if x is None:      # ✅
if x is True:      # 一般写 if x: 就够了
if name is "abc":  # ❌ 永远不要这样比较字符串

>>> a = 256; b = 256
>>> a is b
True          # CPython 缓存了 -5 到 256 的整数
>>> a = 257; b = 257
>>> a is b
False         # 超出缓存范围

"a" in "abc"           # True
3 in [1, 2, 3]         # True
"key" in {"key": 1}    # True  —— 字典查的是键
5 not in [1, 2, 3]     # True

# 100 万个元素，判断存在性
big_list = list(range(1_000_000))
big_set = set(big_list)

999_999 in big_list    # 慢
999_999 in big_set     # 快几百倍

5 & 3     # 1   按位与     0101 & 0011 = 0001
5 | 3     # 7   按位或     0101 | 0011 = 0111
5 ^ 3     # 6   按位异或   0101 ^ 0011 = 0110
~5        # -6  按位取反
5 << 1    # 10  左移一位（相当于乘 2）
5 >> 1    # 2   右移一位（相当于整除 2）

**                          幂
+x  -x  ~x                  正负号、按位取反
*  /  //  %                 乘除
+  -                        加减
<<  >>                      移位
&                           按位与
^                           按位异或
|                           按位或
比较  ==  !=  <  >  in  is   比较类
not                         逻辑非
and                         逻辑与
or                          逻辑或

2 + 3 * 4        # 14，不是 20
(2 + 3) * 4      # 20
2 ** 3 ** 2      # 512，幂是右结合：2 ** (3 ** 2)
-2 ** 2          # -4，因为 ** 优先级高于负号：-(2 ** 2)

# 传统写法
data = input()
while data != "quit":
    print(data)
    data = input()

# 海象写法
while (data := input()) != "quit":
    print(data)

# 避免调用两次函数
if (n := len(items)) > 10:
    print(f"太多了：{n} 个")

17 // 5
-17 // 5
17 % 5
-17 % 5
2 ** 3 ** 2
not 0 or 1
[] or "x"
1 == 1.0
1 is 1.0

17 // 5      # 3
-17 // 5     # -4   （向下取整，不是 -3）
17 % 5       # 2
-17 % 5      # 3    （符号跟除数）
2 ** 3 ** 2  # 512  （右结合）
not 0 or 1   # True （not 0 → True，True or 1 短路返回 True）
[] or "x"    # 'x'
1 == 1.0     # True （值相等）
1 is 1.0     # False（不同类型，不同对象）

total = int(input("秒数："))
hours = total // 3600
minutes = total % 3600 // 60
seconds = total % 60
print(f"{hours} 小时 {minutes} 分 {seconds} 秒")

minutes, seconds = divmod(total, 60)
hours, minutes = divmod(minutes, 60)

year = int(input("年份："))
is_leap = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
print(is_leap)

a, b = b, a

s1 = "双引号"
s2 = '单引号'          # 完全等价
s3 = """三引号
可以跨行"""
s4 = '''也可以用单三引号'''

"他说：'你好'"        # ✅ 外双内单
'He said: "hi"'      # ✅ 外单内双
"He said: \"hi\""    # 也可以转义，但没上面好看

"\n"     # 换行
"\t"     # 制表符
"\\"     # 反斜杠本身
"\""     # 双引号
"\'"     # 单引号
"\u4e2d" # Unicode 码点 → 中

print("C:\new\table")       # \n 和 \t 被当成转义了，输出乱七八糟
print(r"C:\new\table")      # C:\new\table  ✅

name = "小明"
age = 18

f"我叫{name}，今年{age}岁"           # 我叫小明，今年18岁
f"明年 {age + 1} 岁"                # 可以放任何表达式
f"{name.upper()}"                  # 可以调用方法

pi = 3.14159265

f"{pi:.2f}"        # '3.14'      保留 2 位小数
f"{pi:10.2f}"      # '      3.14' 宽度 10，右对齐
f"{pi:<10.2f}"     # '3.14      ' 左对齐
f"{pi:^10.2f}"     # '   3.14   ' 居中
f"{pi:+.2f}"       # '+3.14'     总是显示符号

n = 1234567
f"{n:,}"           # '1,234,567'  千位分隔
f"{n:_}"           # '1_234_567'
f"{n:>12}"         # '     1234567' 右对齐宽度 12
f"{n:012}"         # '000001234567' 补零

r = 0.8567
f"{r:.1%}"         # '85.7%'      百分比

f"{255:b}"         # '11111111'   二进制
f"{255:o}"         # '377'        八进制
f"{255:x}"         # 'ff'         十六进制
f"{255:X}"         # 'FF'
f"{255:08b}"       # '11111111'   补零到 8 位

x = 42
print(f"{x=}")           # x=42
print(f"{x * 2 = }")     # x * 2 = 84

"我叫{}，{}岁".format(name, age)      # str.format()，Python 3.0+
"我叫%s，%d岁" % (name, age)          # % 格式化，最老，来自 C

s = "hello"
s[0] = "H"     # TypeError: 'str' object does not support item assignment

s = "hello"
t = s.upper()
print(s)   # hello  —— 原来的没变
print(t)   # HELLO

s = "Python"
#    012345      正向索引
#   -654321      负向索引

s[0]      # 'P'
s[5]      # 'n'
s[-1]     # 'n'   最后一个
s[-2]     # 'o'   倒数第二个
s[10]     # IndexError!

s = "Python"

s[0:3]     # 'Pyt'    索引 0,1,2
s[:3]      # 'Pyt'    省略 start 表示从头
s[3:]      # 'hon'    省略 stop 表示到尾
s[:]       # 'Python' 整个复制
s[1:5:2]   # 'yh'     步长 2
s[::-1]    # 'nohtyP' 步长 -1 = 反转
s[::2]     # 'Pto'    每隔一个取
s[-3:]     # 'hon'    最后三个
s[:-3]     # 'Pyt'    去掉最后三个

s[100:200]    # ''  空字符串，不报错
s[0:100]      # 'Python'

"hello".upper()        # 'HELLO'
"HELLO".lower()        # 'hello'
"hello world".title()  # 'Hello World'
"hello".capitalize()   # 'Hello'
"Hello".swapcase()     # 'hELLO'
"Hello".casefold()     # 'hello'  比 lower() 更彻底，适合不区分大小写比较

"  hi  ".strip()       # 'hi'      两端
"  hi  ".lstrip()      # 'hi  '    左边
"  hi  ".rstrip()      # '  hi'    右边
"xxhixx".strip("x")    # 'hi'      去掉指定字符
"file.txt".removesuffix(".txt")   # 'file'  Python 3.9+
"pre_name".removeprefix("pre_")   # 'name'

"hello".find("ll")        # 2    找不到返回 -1
"hello".index("ll")       # 2    找不到抛 ValueError
"hello".rfind("l")        # 3    从右边找
"hello".count("l")        # 2
"hello".startswith("he")  # True
"hello".endswith((".jpg", ".png"))   # 可以传元组，任一匹配即可
"ll" in "hello"           # True  ← 只判断存在，用这个最简单

"a-b-c".replace("-", "+")       # 'a+b+c'
"a-b-c".replace("-", "+", 1)    # 'a+b-c'  只替换第一个

"a,b,c".split(",")           # ['a', 'b', 'c']
"a b  c".split()             # ['a', 'b', 'c']  不带参数按任意空白分，且忽略连续空白
"a,b,c".split(",", 1)        # ['a', 'b,c']     最多分 1 次
"a,b,c".rsplit(",", 1)       # ['a,b', 'c']     从右边分
"line1\nline2".splitlines()  # ['line1', 'line2']
"a=1".partition("=")         # ('a', '=', '1')  分成三段

",".join(["a", "b", "c"])    # 'a,b,c'
"".join(["a", "b"])          # 'ab'
"\n".join(lines)             # 用换行连接

# ❌ 慢：每次 += 都创建新字符串
result = ""
for word in words:
    result += word

# ✅ 快
result = "".join(words)

"abc".isalpha()      # True   全是字母
"123".isdigit()      # True   全是数字
"a1".isalnum()       # True   字母或数字
"  ".isspace()       # True   全是空白
"Hello".istitle()    # True
"ABC".isupper()      # True

"5".zfill(3)         # '005'
"hi".ljust(10, ".")  # 'hi........'
"hi".rjust(10)       # '        hi'
"hi".center(10, "*") # '****hi****'

s = "中文"
b = s.encode("utf-8")     # str → bytes: b'\xe4\xb8\xad\xe6\x96\x87'
s2 = b.decode("utf-8")    # bytes → str: '中文'

len(s)    # 2  两个字符
len(b)    # 6  六个字节（UTF-8 里一个汉字占 3 字节）

open("file.txt", encoding="utf-8")

"apple" < "banana"     # True   按字符的 Unicode 码点逐位比较
"Apple" < "apple"      # True   大写字母码点小于小写
"10" < "9"             # True   ⚠️ 字符串比较不是数值比较！

a.casefold() == b.casefold()

s = "Hello, World!"
s[::-1]           # '!dlroW ,olleH'
s.upper()         # 'HELLO, WORLD!'
s[7:12]           # 'World'
s[:5]             # 'Hello'
s.count("l")      # 3

raw = " 张三, 李四 ,王五 "
names = [name.strip() for name in raw.split(",")]
print(names)   # ['张三', '李四', '王五']

text = input("输入一句话：")
cleaned = text.lower().replace(" ", "")
if cleaned == cleaned[::-1]:
    print("是回文")
else:
    print("不是回文")

path = "/home/user/documents/report.pdf"
filename = path.split("/")[-1]        # 'report.pdf'
ext = filename.split(".")[-1]         # 'pdf'

from pathlib import Path
p = Path(path)
p.name      # 'report.pdf'
p.suffix    # '.pdf'
p.stem      # 'report'

f"{1234567.891:,.2f}"    # '1,234,567.89'

age = 18

if age >= 18:
    print("成年")
elif age >= 13:
    print("青少年")
else:
    print("儿童")

if is_logged_in:
    if is_admin:
        print("管理员面板")
    else:
        print("用户面板")
else:
    print("请登录")

# ❌ 嵌套三层
def process(user):
    if user is not None:
        if user.is_active:
            if user.has_permission:
                do_work()

# ✅ 提前返回，扁平化
def process(user):
    if user is None:
        return
    if not user.is_active:
        return
    if not user.has_permission:
        return
    do_work()

status = "成年" if age >= 18 else "未成年"

for item in [1, 2, 3]:
    print(item)

for char in "abc":
    print(char)

for key in {"a": 1, "b": 2}:
    print(key)      # 遍历字典默认得到键

range(5)         # 0, 1, 2, 3, 4        （含头不含尾）
range(2, 5)      # 2, 3, 4
range(0, 10, 2)  # 0, 2, 4, 6, 8
range(5, 0, -1)  # 5, 4, 3, 2, 1

for i in range(5):
    print(i)       # 0 1 2 3 4

fruits = ["苹果", "香蕉", "橙子"]

# ❌ C 语言式写法
for i in range(len(fruits)):
    print(i, fruits[i])

# ✅ Python 式写法
for i, fruit in enumerate(fruits):
    print(i, fruit)

# 从 1 开始编号
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")

names = ["张三", "李四"]
ages = [25, 30]

for name, age in zip(names, ages):
    print(f"{name}: {age}")

for x in reversed([1, 2, 3]):     # 3 2 1
    ...
for x in sorted([3, 1, 2]):       # 1 2 3
    ...

count = 0
while count < 5:
    print(count)
    count += 1

# 一直问到输入合法为止
while True:
    answer = input("y/n? ").lower()
    if answer in ("y", "n"):
        break
    print("请输入 y 或 n")

count = 0
while count < 5:
    print(count)     # 忘了 count += 1 → 永远打印 0

for i in range(10):
    if i == 3:
        continue      # 跳过本次剩余部分，进入下一轮
    if i == 6:
        break         # 直接结束整个循环
    print(i)
# 输出：0 1 2 4 5

for item in items:
    if item.is_target:
        print("找到了")
        break
else:
    print("遍历完了也没找到")

def find_pair(matrix, target):
    for row in matrix:
        for x in row:
            if x == target:
                return True     # 直接跳出所有层
    return False

def handle(command):
    match command.split():
        case ["quit"]:
            return "退出"
        case ["go", direction]:
            return f"走向 {direction}"
        case ["drop", *items]:
            return f"丢下 {len(items)} 件物品"
        case _:
            return "看不懂"

match response:
    case {"status": 200, "data": data}:
        print(f"成功：{data}")
    case {"status": 404}:
        print("找不到")
    case {"status": code} if code >= 500:
        print(f"服务器错误 {code}")
    case _:
        print("未知响应")

STATUS_OK = 200
match code:
    case STATUS_OK:      # ❌ 这会把 code 赋给 STATUS_OK，永远匹配！
        ...
    case Status.OK:      # ✅ 带点的名字才是值比较
        ...

handlers = {"start": do_start, "stop": do_stop}
handlers.get(command, do_unknown)()

def todo():
    pass          # 语法上需要一个语句，但还没想好写什么

class Empty:
    ...           # Ellipsis，效果一样，类型标注场景常见

import random

secret = random.randint(1, 100)
attempts = 0
MAX_ATTEMPTS = 7

print(f"我想了一个 1-100 的数，你有 {MAX_ATTEMPTS} 次机会")

while attempts < MAX_ATTEMPTS:
    raw = input(f"第 {attempts + 1} 次猜：")

    if not raw.isdigit():
        print("请输入数字")
        continue          # 输入非法不算次数

    guess = int(raw)
    attempts += 1

    if guess == secret:
        print(f"猜对了！用了 {attempts} 次")
        break
    elif guess < secret:
        print("小了")
    else:
        print("大了")
else:
    print(f"次数用完了，答案是 {secret}")

*
**
***
****
*****

for n in range(1, 101):
    if n % 3 == 0 and n % 5 != 0:
        print(n)

for n in range(1, 31):
    if n % 15 == 0:
        print("FizzBuzz")
    elif n % 3 == 0:
        print("Fizz")
    elif n % 5 == 0:
        print("Buzz")
    else:
        print(n)

for i in range(1, 6):
    print("*" * i)

n = int(input("输入一个数："))

if n < 2:
    print("不是质数")
else:
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            print(f"不是质数，能被 {i} 整除")
            break
    else:
        print("是质数")

numbers = []
while True:
    raw = input("输入数字（空行结束）：")
    if raw == "":
        break
    numbers.append(float(raw))

if numbers:
    print(f"总和：{sum(numbers)}")
    print(f"平均：{sum(numbers) / len(numbers)}")
else:
    print("没有输入任何数字")

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}×{i}={i*j}", end="\t")
    print()

fruits = ["苹果", "香蕉", "橙子"]
numbers = [1, 2, 3]
mixed = [1, "a", 3.14, True, None, [1, 2]]    # 可以混装任何类型
empty = []

fruits[0]      # '苹果'
fruits[-1]     # '橙子'
fruits[1:]     # ['香蕉', '橙子']
fruits[::-1]   # ['橙子', '香蕉', '苹果']

fruits[0] = "梨"
fruits[1:3] = ["葡萄"]      # 切片赋值：用一个元素替换两个

lst = [1, 2, 3]

# 增
lst.append(4)             # [1, 2, 3, 4]        末尾加一个
lst.extend([5, 6])        # [1, 2, 3, 4, 5, 6]  末尾加多个
lst.insert(0, 0)          # [0, 1, 2, ...]      指定位置插入
lst += [7]                # 等价于 extend

# 删
lst.remove(3)             # 删除第一个值为 3 的元素，没有则抛 ValueError
x = lst.pop()             # 删除并返回最后一个
x = lst.pop(0)            # 删除并返回索引 0 的元素
del lst[0]                # 按索引删
del lst[1:3]              # 按切片删
lst.clear()               # 清空

# 查
lst.index(2)              # 2 第一次出现的索引，没有则抛 ValueError
lst.count(2)              # 2 出现的次数
2 in lst                  # True

# 改（排序、反转）
lst.sort()                # 原地排序，返回 None
lst.sort(reverse=True)    # 降序
lst.reverse()             # 原地反转

a = [1, 2]
a.append([3, 4])    # [1, 2, [3, 4]]    ← 把整个列表当一个元素塞进去
b = [1, 2]
b.extend([3, 4])    # [1, 2, 3, 4]      ← 逐个加入

lst = [3, 1, 2]
result = lst.sort()      # result 是 None！
print(result)            # None

new = sorted(lst)         # ✅ 返回新列表，原列表不变
new = list(reversed(lst)) # ✅

lst = [1, 2, 3, 4]
for x in lst:
    if x % 2 == 0:
        lst.remove(x)     # ❌ 结果是 [1, 3, 4]，2 被删后索引错位跳过了 3

lst = [x for x in lst if x % 2 != 0]     # ✅

for i in range(len(lst) - 1, -1, -1):
    if lst[i] % 2 == 0:
        del lst[i]

words = ["banana", "Apple", "cherry"]

sorted(words)                          # ['Apple', 'banana', 'cherry']  大写在前
sorted(words, key=str.lower)           # ['Apple', 'banana', 'cherry']  忽略大小写
sorted(words, key=len)                 # 按长度
sorted(words, reverse=True)            # 降序

people = [
    {"name": "张三", "age": 30},
    {"name": "李四", "age": 25},
    {"name": "王五", "age": 30},
]

# 按年龄排序
sorted(people, key=lambda p: p["age"])

# 多级排序：先按年龄，年龄相同按名字
sorted(people, key=lambda p: (p["age"], p["name"]))

# 年龄降序，名字升序（技巧：数值取负）
sorted(people, key=lambda p: (-p["age"], p["name"]))

from operator import itemgetter
sorted(people, key=itemgetter("age", "name"))

point = (3, 4)
single = (42,)        # ⚠️ 单元素元组必须有逗号！(42) 只是加了括号的整数
empty = ()
no_paren = 3, 4       # 括号可省略，逗号才是关键

point[0] = 5     # TypeError

locations = {(0, 0): "原点", (1, 1): "对角"}   # ✅ 元组做键
locations = {[0, 0]: "原点"}                  # ❌ TypeError: unhashable type

def divmod_(a, b):
    return a // b, a % b     # 返回元组

q, r = divmod_(17, 5)        # 3, 2

a, b = 1, 2               # a=1, b=2
a, b = b, a               # 交换，不需要临时变量

x, y, z = [1, 2, 3]       # 列表也能解包
name, age = ("张三", 25)

# 星号收集剩余部分
first, *rest = [1, 2, 3, 4]      # first=1, rest=[2, 3, 4]
*init, last = [1, 2, 3, 4]       # init=[1, 2, 3], last=4
a, *mid, z = [1, 2, 3, 4, 5]     # a=1, mid=[2,3,4], z=5

# 忽略不需要的值，约定用下划线
_, important, _ = (1, 2, 3)

# 嵌套解包
(a, b), c = (1, 2), 3

pairs = [(1, "a"), (2, "b")]
for num, letter in pairs:
    print(num, letter)

a, b = [1, 2, 3]     # ValueError: too many values to unpack

a = [1, 2, 3]
b = a            # b 和 a 指向同一个列表
b.append(4)
print(a)         # [1, 2, 3, 4]  ← a 也变了！

b = a.copy()        # 推荐
b = a[:]            # 切片复制
b = list(a)         # 构造新列表

a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)      # [[1, 2, 99], [3, 4]]  ← 内层还是共享的！

import copy
b = copy.deepcopy(a)     # 递归复制所有层

grid = [[0] * 3] * 3        # ❌ 三行指向同一个列表
grid[0][0] = 1
print(grid)                  # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]

grid = [[0] * 3 for _ in range(3)]   # ✅ 每行都是新列表

nums = [3, 1, 4, 1, 5, 9, 2, 6]

len(nums)         # 8
sum(nums)         # 31
max(nums)         # 9
min(nums)         # 1
sorted(nums)      # [1, 1, 2, 3, 4, 5, 6, 9]
any([0, 1, 0])    # True   有任意一个真
all([1, 1, 0])    # False  全部为真才真
list(reversed(nums))

# max/min 也支持 key
max(words, key=len)                 # 最长的词
max(people, key=lambda p: p["age"]) # 年龄最大的人

# sum 可以指定起始值
sum([[1], [2]], [])                 # [1, 2]  （拼接列表，但效率低）

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

matrix[1][2]        # 6   第 2 行第 3 列

# 遍历
for row in matrix:
    for value in row:
        print(value, end=" ")
    print()

# 转置（行列互换）
transposed = list(zip(*matrix))    # [(1,4,7), (2,5,8), (3,6,9)]

a = [1, 2, 3]
b = a
c = a[:]
a.append(4)
print(b, c)

nums = [3, 7, 1, 9, 4, 1, 7]

max(nums)                      # 9
min(nums)                      # 1
sum(nums) / len(nums)          # 4.571428571428571

sorted(set(nums))              # [1, 3, 4, 7, 9]

[n for n in nums if n > 3]     # [7, 9, 4, 7]

nums[::-1]                     # 切片，返回新列表
list(reversed(nums))           # 同上
nums.reverse()                 # 原地反转，返回 None

nested = [[1, 2], [3, 4], [5, 6]]

# 方法 1：推导式（最常用）
flat = [x for row in nested for x in row]

# 方法 2：itertools
from itertools import chain
flat = list(chain.from_iterable(nested))

# 方法 3：循环
flat = []
for row in nested:
    flat.extend(row)

scores = [("张三", 85), ("李四", 92), ("王五", 78)]
ranked = sorted(scores, key=lambda s: s[1], reverse=True)

for rank, (name, score) in enumerate(ranked, start=1):
    print(f"第 {rank} 名：{name} {score} 分")

def dedup(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

def dedup(items):
    return list(dict.fromkeys(items))

grid = [[0] * 3 for _ in range(3)]   # ✅

person = {
    "name": "张三",
    "age": 25,
    "city": "北京",
}

empty = {}
from_pairs = dict([("a", 1), ("b", 2)])
from_kwargs = dict(name="张三", age=25)

person["name"]              # '张三'
person["email"]             # ❌ KeyError!

person.get("email")         # None，不报错
person.get("email", "无")   # '无'，指定默认值

person["age"] = 26              # 修改
person["email"] = "[email protected]"     # 键不存在则添加

person.update({"age": 27, "phone": "138..."})   # 批量更新
person |= {"age": 28}                          # Python 3.9+ 的合并写法

del person["email"]
age = person.pop("age")             # 删除并返回值
age = person.pop("age", None)       # 键不存在时返回默认值，不报错
key, val = person.popitem()         # 删除并返回最后插入的一对
person.clear()

for key in person:                  # 默认遍历键
    print(key)

for key in person.keys():           # 显式，等价
    ...
for value in person.values():
    ...
for key, value in person.items():   # 最常用
    print(f"{key}: {value}")

"name" in person          # True   —— 查的是键
"张三" in person.values() # True   —— 查值需要显式指定

d = {[1, 2]: "x"}     # TypeError: unhashable type: 'list'
d = {(1, 2): "x"}     # ✅

text = "hello world"
counts = {}
for char in text:
    counts[char] = counts.get(char, 0) + 1

from collections import Counter
counts = Counter(text)
counts.most_common(3)       # 出现最多的 3 个 [(‘l', 3), ('o', 2), ...]

from collections import defaultdict

words = ["apple", "avocado", "banana", "blueberry"]
groups = defaultdict(list)
for word in words:
    groups[word[0]].append(word)
# {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry']}

groups = {}
for word in words:
    groups.setdefault(word[0], []).append(word)

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 3}

merged = {**a, **b}       # {'x': 1, 'y': 20, 'z': 3}  后者覆盖前者
merged = a | b            # Python 3.9+，同上，更清晰

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

squares = {n: n**2 for n in range(5)}        # {0:0, 1:1, 2:4, 3:9, 4:16}
filtered = {k: v for k, v in d.items() if v > 10}

config = {
    "database": {"host": "localhost", "port": 5432},
    "cache": {"ttl": 300},
}

config["database"]["host"]                      # 'localhost'
config.get("cache", {}).get("size", 100)        # 安全地取深层值

s = {1, 2, 3}
s = set([1, 2, 2, 3])       # {1, 2, 3}  自动去重
empty = set()               # ⚠️ 不能写 {}，那是空字典

s.add(4)
s.remove(4)          # 不存在则 KeyError
s.discard(4)         # 不存在也不报错
s.pop()              # 任意弹出一个（哪个不确定，也别指望是随机的）
s.clear()
len(s)
3 in s               # O(1)，非常快

a = {1, 2, 3}
b = {2, 3, 4}

a | b        # {1, 2, 3, 4}   并集     a.union(b)
a & b        # {2, 3}         交集     a.intersection(b)
a - b        # {1}            差集     a.difference(b)
a ^ b        # {1, 4}         对称差   a.symmetric_difference(b)

a <= b       # 是否是子集      a.issubset(b)
a >= b       # 是否是超集
a.isdisjoint(b)   # 是否没有交集

unique = list(set(items))          # 但会打乱顺序
unique = list(dict.fromkeys(items)) # 保持顺序

# ❌ 列表查找是 O(n)
banned = ["a", "b", "c", ...]      # 10000 个
if word in banned:  ...             # 慢

# ✅ 集合查找是 O(1)
banned = {"a", "b", "c", ...}
if word in banned:  ...             # 快

fs = frozenset([1, 2, 3])
d = {fs: "value"}     # ✅

from collections import Counter, defaultdict, deque, namedtuple, ChainMap

# Counter —— 计数
c = Counter("mississippi")
c.most_common(2)          # [('i', 4), ('s', 4)]
c["i"]                    # 4
c["z"]                    # 0（不报错）

# defaultdict —— 带默认值的字典
d = defaultdict(int)      # 默认 0
d["x"] += 1               # 不需要先初始化
d = defaultdict(list)     # 默认空列表

# deque —— 双端队列，两头增删都是 O(1)
q = deque([1, 2, 3])
q.appendleft(0)           # 列表的 insert(0, x) 是 O(n)，deque 是 O(1)
q.popleft()
q = deque(maxlen=5)       # 固定长度，超出自动丢弃最老的

# namedtuple —— 带名字的元组（更推荐用 dataclass，见第 18 章）
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
p.x                       # 3

d = {}
d[[1, 2]] = "value"

from collections import Counter

text = "the quick brown fox jumps over the lazy dog the end"
words = text.lower().split()
counts = Counter(words)

for word, count in counts.most_common(5):
    print(f"{word}: {count}")

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7}

a & b       # {4, 5}
a - b       # {1, 2, 3}
a | b       # {1, 2, 3, 4, 5, 6, 7}

from collections import defaultdict

students = [
    {"name": "张三", "class": "A"},
    {"name": "李四", "class": "B"},
    {"name": "王五", "class": "A"},
]

groups = defaultdict(list)
for s in students:
    groups[s["class"]].append(s["name"])

print(dict(groups))   # {'A': ['张三', '王五'], 'B': ['李四']}

def is_anagram(a, b):
    return sorted(a.lower()) == sorted(b.lower())

# 或者用 Counter，语义更清晰
from collections import Counter
def is_anagram(a, b):
    return Counter(a.lower()) == Counter(b.lower())

d[(1, 2)] = "value"

def get_nested(data, path, default=None):
    current = data
    for key in path.split("."):
        if not isinstance(current, dict) or key not in current:
            return default
        current = current[key]
    return current

config = {"database": {"host": "localhost", "port": 5432}}
get_nested(config, "database.host")      # 'localhost'
get_nested(config, "database.user")      # None
get_nested(config, "cache.ttl", 300)     # 300

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

# 传统写法
squares = []
for n in range(5):
    squares.append(n ** 2)

# 推导式
squares = [n ** 2 for n in range(5)]      # [0, 1, 4, 9, 16]

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

evens = [n for n in range(20) if n % 2 == 0]
long_words = [w for w in words if len(w) > 5]
valid = [int(x) for x in inputs if x.isdigit()]

# if 在后面 = 过滤（决定要不要这个元素）
[n for n in nums if n > 0]

# if...else 在前面 = 转换（每个元素都要，只是值不同）
[n if n > 0 else 0 for n in nums]

# 展平嵌套列表
flat = [x for row in matrix for x in row]

# 等价于
flat = []
for row in matrix:
    for x in row:
        flat.append(x)

pairs = [(a, b) for a in "AB" for b in [1, 2]]
# [('A', 1), ('A', 2), ('B', 1), ('B', 2)]

# 字典推导式
{k: v for ...}
squares = {n: n**2 for n in range(5)}
inverted = {v: k for k, v in d.items()}
upper_keys = {k.upper(): v for k, v in d.items()}
filtered = {k: v for k, v in d.items() if v is not None}

# 集合推导式
{表达式 for ...}
unique_lengths = {len(w) for w in words}

squares_list = [n**2 for n in range(1000000)]    # 立刻创建 100 万个元素，占几十 MB
squares_gen = (n**2 for n in range(1000000))     # 几乎不占内存，用一个算一个

sum(n**2 for n in range(100))          # 不需要写成 sum((n**2 for ...))
any(x > 100 for x in nums)
max(len(w) for w in words)
"\n".join(str(x) for x in nums)

result = [transform(x) if cond1(x) else other(x)
          for sublist in data if check(sublist)
          for x in sublist if x is not None and validate(x)]

[print(x) for x in items]     # ❌ 创建了一个没人要的 None 列表
for x in items: print(x)      # ✅

# 转换类型
[int(x) for x in strings]

# 过滤 None
[x for x in items if x is not None]

# 提取字段
[p["name"] for p in people]

# 字符串处理
[line.strip() for line in lines if line.strip()]

# 索引 + 值
[f"{i}: {v}" for i, v in enumerate(items)]

# 条件转换
[x if x > 0 else 0 for x in nums]

# 两个列表配对
[(a, b) for a, b in zip(list1, list2)]

# 嵌套展平
[x for sub in nested for x in sub]

# 构建查找字典
{item["id"]: item for item in items}

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

# 去重（无序）
{x for x in items}

[x for x in range(10) if x % 2 == 0]
[x if x % 2 == 0 else None for x in range(10)]

# 1
[n**2 for n in range(1, 21) if n % 2 == 0]

# 2
sentence = "the quick brown fox jumps"
[w.upper() for w in sentence.split() if len(w) > 3]

# 3
items = ["1", "a", "2", "b", "3"]
[int(x) for x in items if x.isdigit()]

# 4
[[i * j for j in range(1, 4)] for i in range(1, 4)]
# [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

data = {"a": 1, "b": None, "c": 3, "d": None}
cleaned = {k: v for k, v in data.items() if v is not None}
# {'a': 1, 'c': 3}

sum(n for n in range(1, 101) if n % 7 == 0)    # 735

matrix = [[1, 2, 3], [4, 5, 6]]
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
# [[1, 4], [2, 5], [3, 6]]

def greet(name):
    """打招呼。"""            # 文档字符串（docstring）
    return f"你好，{name}"

message = greet("张三")
print(message)                # 你好，张三

def check(n):
    if n < 0:
        return "负数"
    return "非负数"
    print("永远不会执行")     # 死代码

def power(base, exponent):
    return base ** exponent

power(2, 3)      # 8   按位置对应

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

greet("张三")                    # 你好，张三
greet("张三", "早上好")           # 早上好，张三

def f(a=1, b): ...       # ❌ SyntaxError

def add_item(item, items=[]):    # ❌ 危险！
    items.append(item)
    return items

add_item("a")     # ['a']
add_item("b")     # ['a', 'b']   ← 竟然记住了上次的！

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

power(exponent=3, base=2)    # 8

save(data, True, False)                    # ❌ True 和 False 是什么？
save(data, overwrite=True, backup=False)   # ✅

def total(*numbers):           # 收集任意多个位置参数，得到元组
    return sum(numbers)

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


def config(**options):         # 收集任意多个关键字参数，得到字典
    for key, value in options.items():
        print(f"{key} = {value}")

config(debug=True, port=8080)


def flexible(a, b=2, *args, **kwargs):
    print(a, b, args, kwargs)

flexible(1, 2, 3, 4, x=5)      # 1 2 (3, 4) {'x': 5}

nums = [1, 2, 3]
total(*nums)                   # 等价于 total(1, 2, 3)

opts = {"debug": True, "port": 8080}
config(**opts)                 # 等价于 config(debug=True, port=8080)

def f(a, b, /, c, d, *, e, f):
    ...
#      ↑ / 之前必须按位置传
#              ↑ * 之后必须用关键字传

def create_user(name, *, admin=False, active=True):
    ...

create_user("张三", admin=True)      # ✅
create_user("张三", True)            # ❌ TypeError

def min_max(numbers):
    return min(numbers), max(numbers)     # 实际返回一个元组

lo, hi = min_max([3, 1, 4])               # 解包
result = min_max([3, 1, 4])               # (1, 4)

def calculate_bmi(weight, height):
    """计算身体质量指数。

    Args:
        weight: 体重，单位公斤
        height: 身高，单位米

    Returns:
        BMI 值（float）

    Raises:
        ValueError: 身高为 0 或负数时
    """
    if height <= 0:
        raise ValueError("身高必须为正数")
    return weight / height ** 2

help(calculate_bmi)
calculate_bmi.__doc__

square = lambda x: x ** 2      # 等价于 def square(x): return x ** 2

sorted(people, key=lambda p: p["age"])
list(filter(lambda x: x > 0, nums))
list(map(lambda x: x * 2, nums))

square = lambda x: x ** 2      # ❌ PEP 8 明确不推荐
def square(x): return x ** 2   # ✅

map(lambda x: x * 2, nums)         →  [x * 2 for x in nums]
filter(lambda x: x > 0, nums)      →  [x for x in nums if x > 0]
sorted(d, key=lambda x: x[1])      →  sorted(d, key=itemgetter(1))

def double(x):
    return x * 2

f = double              # 赋值给变量（注意没有括号）
f(5)                    # 10

funcs = [double, abs, len]        # 放进列表
for fn in funcs:
    print(fn.__name__)

def apply(fn, value):             # 当参数传
    return fn(value)
apply(double, 5)                  # 10

def make_multiplier(n):           # 当返回值
    def multiplier(x):
        return x * n
    return multiplier

triple = make_multiplier(3)
triple(5)                         # 15

def factorial(n):
    if n <= 1:          # 基线条件（base case）—— 必须有！
        return 1
    return n * factorial(n - 1)

factorial(5)            # 120

def total_size(item):
    """递归计算嵌套列表中所有数字的和。"""
    if isinstance(item, list):
        return sum(total_size(x) for x in item)
    return item

total_size([1, [2, [3, 4]], 5])    # 15

from functools import cache

@cache
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)

fib(100)     # 瞬间返回

# ❌ 又读文件又计算又打印
def process():
    data = open("f.txt").read()
    result = complicated_math(data)
    print(result)

# ✅ 拆开，每个都可测试、可复用
def load_data(path): ...
def compute(data): ...
def report(result): ...

get_user()  calculate_tax()  is_valid()  has_permission()  send_email()

# ❌ 名字说是"计算"，实际上改了输入
def calculate_total(items):
    items.sort()          # 意外修改了调用方的列表！
    return sum(items)

# ✅ 不改输入
def calculate_total(items):
    return sum(sorted(items))

def append_log(msg, logs=[]):
    logs.append(msg)
    return logs

def is_prime(n):
    if n < 2:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n ** 0.5) + 1, 2):
        if n % i == 0:
            return False
    return True

def average(*numbers):
    if not numbers:
        return 0
    return sum(numbers) / len(numbers)

average(1, 2, 3)     # 2.0
average()            # 0

def append_log(msg, logs=None):
    if logs is None:
        logs = []
    logs.append(msg)
    return logs

import re
from collections import Counter

def word_count(text):
    words = re.findall(r"\w+", text.lower())
    return dict(Counter(words))

word_count("The cat. The DOG! the cat?")
# {'the': 3, 'cat': 2, 'dog': 1}

def retry(func, times=3):
    last_error = None
    for attempt in range(times):
        try:
            return func()
        except Exception as e:
            last_error = e
            print(f"第 {attempt + 1} 次失败：{e}")
    raise last_error

def max_depth(d):
    if not isinstance(d, dict) or not d:
        return 0
    return 1 + max(max_depth(v) for v in d.values())

max_depth({"a": {"b": {"c": 1}}})    # 3

L (Local)      —— 当前函数内部
E (Enclosing)  —— 外层函数（嵌套函数才有）
G (Global)     —— 模块顶层
B (Built-in)   —— Python 内置（print、len 这些）

x = "global"                  # G

def outer():
    x = "enclosing"           # E
    def inner():
        x = "local"           # L
        print(x)              # local
    inner()
    print(x)                  # enclosing

outer()
print(x)                      # global

counter = 0

def show():
    print(counter)    # ✅ 能读到

counter = 0

def increment():
    counter = counter + 1     # ❌ UnboundLocalError

counter = 0

def increment():
    global counter            # 声明：我要改的是全局那个
    counter += 1

def outer():
    count = 0
    def inner():
        nonlocal count        # 改的是 outer 的 count，不是全局
        count += 1
    inner()
    inner()
    return count              # 2

# ❌
total = 0
def add(x):
    global total
    total += x

# ✅
def add(total, x):
    return total + x

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

c1 = make_counter()
c1()    # 1
c1()    # 2
c1()    # 3

c2 = make_counter()
c2()    # 1  —— 独立的计数器，各自有各自的 count

def make_validator(min_len):
    def validate(text):
        return len(text) >= min_len
    return validate

check_password = make_validator(8)
check_username = make_validator(3)

check_password("abc")      # False
check_username("abc")      # True

funcs = []
for i in range(3):
    funcs.append(lambda: i)

[f() for f in funcs]     # [2, 2, 2]  ← 都是 2！

for i in range(3):
    funcs.append(lambda i=i: i)

[f() for f in funcs]     # [0, 1, 2]  ✅

def make_f(i):
    return lambda: i
funcs = [make_f(i) for i in range(3)]

x = 10
def f():
    x = 20
    def g():
        nonlocal x
        x = 30
    g()
    print(x)
f()
print(x)

total = 0
def add(n):
    total += n
    return total

fs = [lambda: i for i in range(3)]
print([f() for f in fs])

# 方法 1：用 global（不推荐）
total = 0
def add(n):
    global total
    total += n
    return total

# 方法 2：改成纯函数（推荐）
def add(total, n):
    return total + n

# 方法 3：用闭包封装状态
def make_adder():
    total = 0
    def add(n):
        nonlocal total
        total += n
        return total
    return add

def make_accumulator():
    total = 0
    def accumulate(n):
        nonlocal total
        total += n
        return total
    return accumulate

acc = make_accumulator()
acc(10)    # 10
acc(5)     # 15
acc(3)     # 18

# 方法 1：默认参数捕获
fs = [lambda i=i: i for i in range(3)]

# 方法 2：工厂函数
def make(i):
    return lambda: i
fs = [make(i) for i in range(3)]

PI = 3.14159

def circle_area(r):
    return PI * r ** 2

def circle_circumference(r):
    return 2 * PI * r

import mathtools

mathtools.circle_area(2)     # 12.56636
mathtools.PI                 # 3.14159

import math                       # 导入整个模块
math.sqrt(16)

import math as m                  # 起别名
m.sqrt(16)

from math import sqrt             # 只导入某个名字
sqrt(16)

from math import sqrt, pi, floor  # 导入多个
from math import sqrt as square_root

from math import *                # ❌ 导入所有 —— 不要这样做

myproject/
├── main.py
└── utils/
    ├── __init__.py
    ├── text.py
    └── files.py

# main.py
from utils.text import clean
from utils import files

import utils.text as text

# utils/__init__.py
from .text import clean
from .files import read_json

from .text import clean       # 同级模块
from ..config import SETTINGS # 上一级

# tools.py

def main():
    print("运行主程序")

if __name__ == "__main__":
    main()

import sys
print(sys.path)         # 查看实际生效的搜索路径（这才是准的）

# 你的目录里有 random.py
import random           # 导入的是你的文件，不是标准库！
random.randint(1, 10)   # AttributeError

import os, sys, math, random, json, re, time, datetime
import pathlib, collections, itertools, functools
import csv, sqlite3, urllib, http, socket
import unittest, logging, argparse, subprocess
import typing, dataclasses, enum, abc
import asyncio, threading, multiprocessing

myproject/
├── pyproject.toml          # 项目配置与依赖声明
├── README.md
├── .gitignore
├── src/
│   └── myproject/
│       ├── __init__.py
│       ├── main.py         # 入口
│       ├── config.py       # 配置
│       ├── models.py       # 数据结构
│       ├── services/       # 业务逻辑
│       │   ├── __init__.py
│       │   └── user.py
│       └── utils/          # 通用工具
│           ├── __init__.py
│           └── text.py
└── tests/
    ├── test_models.py
    └── test_services.py

import datetime
from datetime import datetime
from datetime import *

# calculator.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为 0")
    return a / b

if __name__ == "__main__":
    print("自测：")
    print(add(2, 3))        # 5
    print(divide(10, 2))    # 5.0

# main.py
from calculator import add, divide

print(add(1, 2))
print(divide(10, 4))

>>> 1 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Traceback (most recent call last):
  File "main.py", line 10, in <module>
    result = process(data)
  File "main.py", line 5, in process
    return int(data["value"])
KeyError: 'value'

try:
    result = 10 / 0
except ZeroDivisionError:
    print("不能除以零")

try:
    value = int(input("数字："))
    result = 100 / value
except ValueError:
    print("请输入数字")
except ZeroDivisionError:
    print("不能是 0")
except (TypeError, KeyError):        # 一次捕获多个
    print("类型或键错误")

try:
    int("abc")
except ValueError as e:
    print(f"出错了：{e}")            # invalid literal for int()...
    print(type(e).__name__)          # ValueError

try:
    f = open("data.txt")
except FileNotFoundError:
    print("文件不存在")
else:
    print("没出错时执行")            # try 成功才执行
    data = f.read()
finally:
    print("无论如何都执行")           # 清理工作放这里

BaseException
 ├── SystemExit
 ├── KeyboardInterrupt
 └── Exception          ← 你自己的异常应该继承这个
      ├── ValueError
      ├── TypeError
      ├── LookupError
      │    ├── KeyError
      │    └── IndexError
      ├── OSError
      │    ├── FileNotFoundError
      │    └── PermissionError
      └── ArithmeticError
           └── ZeroDivisionError

except LookupError:      # 同时捕获 KeyError 和 IndexError
except OSError:          # 捕获所有文件/系统相关错误

# ❌ 最糟糕的写法
try:
    do_something()
except:
    pass

# ✅ 最好：捕获具体异常
except ValueError:
    ...

# ✅ 可接受：捕获 Exception 并记录
except Exception as e:
    logger.exception("处理失败")
    raise                  # 记录后重新抛出

# ⚠️ 只在程序最外层用（防止崩溃）
except Exception:
    logger.exception("未预期的错误")

def set_age(age):
    if not isinstance(age, int):
        raise TypeError(f"年龄必须是整数，得到 {type(age).__name__}")
    if age < 0:
        raise ValueError(f"年龄不能为负数：{age}")
    ...

try:
    risky()
except ValueError:
    logger.error("记录一下")
    raise                       # 保留原始 traceback，直接写 raise

try:
    data = json.loads(text)
except json.JSONDecodeError as e:
    raise ConfigError("配置文件格式错误") from e
    # traceback 会显示 "The above exception was the direct cause of..."

class AppError(Exception):
    """本应用所有异常的基类。"""

class ConfigError(AppError):
    """配置相关错误。"""

class ValidationError(AppError):
    """数据校验失败。"""
    def __init__(self, field, message):
        self.field = field
        super().__init__(f"{field}: {message}")


try:
    ...
except AppError as e:           # 一次捕获本应用所有异常
    ...

# ❌ 忘记关文件，或者中途异常导致没关
f = open("data.txt")
data = f.read()
f.close()

# ✅ with 保证退出时一定关闭，哪怕出异常
with open("data.txt", encoding="utf-8") as f:
    data = f.read()

with open("a.txt") as fa, open("b.txt", "w") as fb:    # 同时管理多个
    fb.write(fa.read())

from contextlib import contextmanager
import time

@contextmanager
def timer(name):
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        print(f"{name} 耗时 {elapsed:.3f} 秒")


with timer("数据处理"):
    do_heavy_work()
# 数据处理 耗时 1.234 秒

class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        print(f"耗时 {time.perf_counter() - self.start:.3f} 秒")
        return False        # 返回 True 会吞掉异常，一般返回 False

# LBYL —— 其他语言的常见风格
if os.path.exists(path):
    with open(path) as f:       # ⚠️ 检查和打开之间文件可能被删（竞态条件）
        ...

# EAFP —— Python 风格
try:
    with open(path) as f:
        ...
except FileNotFoundError:
    ...

# LBYL
if "key" in d:
    value = d["key"]
else:
    value = default

# EAFP
try:
    value = d["key"]
except KeyError:
    value = default

# 最好：用现成的
value = d.get("key", default)

def divide(a, b):
    assert b != 0, "除数不能为 0"
    return a / b

assert user.is_admin        # ❌ 生产环境可能被跳过 = 安全漏洞
if not user.is_admin:       # ✅
    raise PermissionError()

f = open("data.txt")
data = f.read()
f.close()

try:
    result = compute()
except:
    pass

def safe_int(s, default=0):
    try:
        return int(s)
    except (ValueError, TypeError):
        return default

safe_int("42")     # 42
safe_int("abc")    # 0
safe_int(None)     # 0
safe_int("x", -1)  # -1

with open("data.txt", encoding="utf-8") as f:
    data = f.read()

import json
from pathlib import Path

class ConfigError(Exception):
    pass

def load_config(path, required_keys=("host", "port")):
    p = Path(path)
    try:
        text = p.read_text(encoding="utf-8")
    except FileNotFoundError:
        raise ConfigError(f"配置文件不存在：{p.absolute()}") from None

    try:
        config = json.loads(text)
    except json.JSONDecodeError as e:
        raise ConfigError(f"配置文件不是合法 JSON（第 {e.lineno} 行）：{e.msg}") from e

    missing = [k for k in required_keys if k not in config]
    if missing:
        raise ConfigError(f"配置缺少必需项：{', '.join(missing)}")

    return config

from contextlib import contextmanager

@contextmanager
def suppress_errors():
    try:
        yield
    except Exception as e:
        print(f"⚠️ 已忽略错误：{type(e).__name__}: {e}")

with suppress_errors():
    1 / 0
print("继续执行")

class ShopError(Exception):
    """商店相关异常基类。"""

class OutOfStockError(ShopError):
    def __init__(self, product):
        self.product = product
        super().__init__(f"商品缺货：{product}")

class PaymentError(ShopError):
    def __init__(self, amount, reason="未知原因"):
        self.amount = amount
        super().__init__(f"支付 {amount} 元失败：{reason}")

from pathlib import Path

p = Path("data/report.txt")

# 拼接路径用 / 运算符
base = Path("/home/user")
full = base / "documents" / "file.txt"      # /home/user/documents/file.txt

# 常用属性
p.name        # 'report.txt'   文件名
p.stem        # 'report'       不带扩展名
p.suffix      # '.txt'         扩展名
p.parent      # Path('data')   父目录
p.parts       # ('data', 'report.txt')
p.absolute()  # 绝对路径

# 判断
p.exists()      # 是否存在
p.is_file()     # 是文件
p.is_dir()      # 是目录

# 特殊位置
Path.cwd()      # 当前工作目录
Path.home()     # 用户主目录
Path(__file__).parent    # 当前脚本所在目录（写脚本时超常用）

d = Path("output")
d.mkdir()                                # 创建目录，已存在会报错
d.mkdir(parents=True, exist_ok=True)     # 递归创建，已存在不报错 ← 常用

# 遍历
for f in d.iterdir():              # 直接子项
    print(f)

for f in d.glob("*.txt"):          # 匹配当前层
    print(f)

for f in d.rglob("*.py"):          # 递归匹配所有层
    print(f)

# 只要文件
files = [f for f in d.rglob("*") if f.is_file()]

p.rename("newname.txt")
p.unlink()                    # 删除文件
p.unlink(missing_ok=True)     # 不存在也不报错
d.rmdir()                     # 删除空目录

import shutil
shutil.copy("a.txt", "b.txt")       # 复制文件
shutil.copytree("src", "dst")       # 复制整个目录树
shutil.rmtree("dir")                # 删除目录及内容 ⚠️ 危险，不可恢复
shutil.move("a", "b")               # 移动

text = Path("a.txt").read_text(encoding="utf-8")
Path("b.txt").write_text("内容", encoding="utf-8")

data = Path("img.png").read_bytes()
Path("copy.png").write_bytes(data)

with open("file.txt", mode="r", encoding="utf-8") as f:
    ...

with open("data.txt", encoding="utf-8") as f:
    content = f.read()          # 一次读全部，返回一个字符串

with open("data.txt", encoding="utf-8") as f:
    lines = f.readlines()       # 返回列表，每行一个元素（保留换行符）

with open("data.txt", encoding="utf-8") as f:
    for line in f:              # ✅ 逐行迭代，内存友好，大文件必用
        print(line.rstrip())    # rstrip 去掉行尾换行符

with open("out.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n")           # write 不会自动加换行符
    f.write("第二行\n")
    f.writelines(["a\n", "b\n"])  # 也不会自动加

# 用 print 写文件更方便（自动换行）
with open("out.txt", "w", encoding="utf-8") as f:
    print("第一行", file=f)
    print("第二行", file=f)

import json

# 写
data = {"name": "张三", "tags": ["a", "b"], "age": 25}
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
    # ensure_ascii=False → 中文正常显示而不是 \uXXXX
    # indent=2 → 缩进美化

# 读
with open("data.json", encoding="utf-8") as f:
    data = json.load(f)

# 字符串版本
s = json.dumps(data, ensure_ascii=False)
data = json.loads(s)

json.dumps(obj, default=str)             # 简单粗暴：不认识的都转字符串
json.dumps({"d": date.today().isoformat()})   # 手动转

import csv

# 写
rows = [{"name": "张三", "age": 25}, {"name": "李四", "age": 30}]
with open("out.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "age"])
    writer.writeheader()
    writer.writerows(rows)

# 读
with open("out.csv", newline="", encoding="utf-8") as f:
    for row in csv.DictReader(f):
        print(row["name"], row["age"])    # row 是字典

# 二进制序列化 Python 对象（只在信任的场景用！pickle 可执行任意代码）
import pickle
pickle.dump(obj, open("f.pkl", "wb"))

# TOML（读取，Python 3.11+ 内置）
import tomllib
with open("pyproject.toml", "rb") as f:      # 注意是 "rb"
    config = tomllib.load(f)

# YAML 需要第三方库
# pip install pyyaml
import yaml
config = yaml.safe_load(open("config.yaml", encoding="utf-8"))

from pathlib import Path

for i, f in enumerate(sorted(Path("photos").glob("*.jpg")), start=1):
    f.rename(f.parent / f"photo_{i:03d}.jpg")

total = sum(f.stat().st_size for f in Path(".").rglob("*") if f.is_file())
print(f"{total / 1024 / 1024:.2f} MB")

for py in Path("src").rglob("*.py"):
    text = py.read_text(encoding="utf-8")
    if "TODO" in text:
        print(f"{py}: 有待办事项")

from pathlib import Path

target = Path("important.json")
tmp = target.with_suffix(".json.tmp")
tmp.write_text(json.dumps(data), encoding="utf-8")
tmp.replace(target)      # 原子操作

with open("data.txt") as f:
    print(f.read())

from pathlib import Path

text = Path("data.txt").read_text(encoding="utf-8")
lines = text.splitlines()

print(f"行数：{len(lines)}")
print(f"单词数：{len(text.split())}")
print(f"字符数：{len(text)}")

from pathlib import Path

lines = Path("in.txt").read_text(encoding="utf-8").splitlines()
Path("out.txt").write_text("\n".join(reversed(lines)), encoding="utf-8")

from pathlib import Path

MB = 1024 * 1024
big = [f for f in Path(".").rglob("*") if f.is_file() and f.stat().st_size > MB]

for f in sorted(big, key=lambda p: p.stat().st_size, reverse=True):
    print(f"{f.stat().st_size / MB:8.2f} MB  {f}")

import csv, json
from pathlib import Path

contacts = json.loads(Path("contacts.json").read_text(encoding="utf-8"))

with open("contacts.csv", "w", newline="", encoding="utf-8-sig") as f:
    writer = csv.DictWriter(f, fieldnames=contacts[0].keys())
    writer.writeheader()
    writer.writerows(contacts)

with open("data.txt", encoding="utf-8") as f:
    print(f.read())

import json
from pathlib import Path

def load_json(path, default=None):
    if default is None:
        default = {}
    try:
        return json.loads(Path(path).read_text(encoding="utf-8"))
    except (FileNotFoundError, json.JSONDecodeError, UnicodeDecodeError) as e:
        print(f"⚠️ 读取 {path} 失败（{type(e).__name__}），使用默认值")
        return default

student = {"name": "张三", "scores": [85, 92, 78]}

def average(s):
    return sum(s["scores"]) / len(s["scores"])

class Student:
    def __init__(self, name):
        self.name = name
        self.scores = []

    def add_score(self, score):
        self.scores.append(score)

    def average(self):
        if not self.scores:
            return 0
        return sum(self.scores) / len(self.scores)


s = Student("张三")
s.add_score(85)
s.add_score(92)
print(s.average())      # 88.5

class Dog:
    species = "犬科"                 # 类属性：所有实例共享

    def __init__(self, name, age):   # 构造方法
        self.name = name             # 实例属性：每个实例独有
        self.age = age

    def bark(self):                  # 实例方法
        return f"{self.name} 汪汪叫"

    def birthday(self):
        self.age += 1
        return self.age


d = Dog("旺财", 3)      # 创建实例，自动调用 __init__
d.name                  # '旺财'
d.bark()                # '旺财 汪汪叫'
d.species               # '犬科'
Dog.species             # '犬科'  也可以通过类访问

d.bark()          # Python 实际执行的是 Dog.bark(d)

class Dog:
    def bark():                 # ❌ TypeError: bark() takes 0 positional arguments but 1 was given
        return "汪"

class Counter:
    total = 0                  # 类属性，所有实例共享

    def __init__(self):
        Counter.total += 1
        self.id = Counter.total   # 实例属性，各自独立

a = Counter()
b = Counter()
print(Counter.total)     # 2
print(a.id, b.id)        # 1 2

class Basket:
    items = []              # ❌ 所有实例共用一个列表！

    def add(self, x):
        self.items.append(x)

a, b = Basket(), Basket()
a.add("苹果")
print(b.items)           # ['苹果']  ← b 也受影响了

class Basket:
    def __init__(self):
        self.items = []      # ✅ 每个实例一个新列表

class Circle:
    PI = 3.14159

    def __init__(self, radius):
        self.radius = radius

    def area(self):                       # 实例方法：操作某个实例
        return self.PI * self.radius ** 2

    @classmethod
    def from_diameter(cls, d):            # 类方法：第一个参数是类本身
        return cls(d / 2)                 # 常用于"另一种构造方式"

    @staticmethod
    def is_valid_radius(r):               # 静态方法：跟类和实例都无关
        return r > 0                      # 只是逻辑上属于这个类


c1 = Circle(5)
c2 = Circle.from_diameter(10)             # 等价于 Circle(5)
Circle.is_valid_radius(-1)                # False

class Account:
    def __init__(self, balance):
        self.owner = "张三"          # 公开：随便用
        self._balance = balance      # 单下划线：内部使用，请勿直接碰（约定）
        self.__pin = "1234"          # 双下划线：名称改写，更强的"别碰"

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("金额必须为正")
        self._balance += amount

a = Account(100)
a._balance           # 能访问，但你不该这么做
a.__pin              # AttributeError
a._Account__pin      # '1234'  —— 还是能拿到，所以不是"安全"

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("低于绝对零度")
        self._celsius = value

    @property
    def fahrenheit(self):            # 只读的计算属性
        return self._celsius * 9 / 5 + 32


t = Temperature(25)
t.celsius          # 25      像属性一样访问，实际调用了方法
t.celsius = 30     # 触发 setter，会做校验
t.fahrenheit       # 86.0    计算得出
t.fahrenheit = 100 # AttributeError: 没有 setter
t.celsius = -300   # ValueError

# ❌ Java 风格，Python 里没必要
class Person:
    def get_name(self): return self._name
    def set_name(self, v): self._name = v

# ✅ Python 风格：先用普通属性
class Person:
    def __init__(self, name):
        self.name = name

class Student:
    grades = []
    def add_grade(self, g):
        self.grades.append(g)

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

    @property
    def is_square(self):
        return self.width == self.height

class Student:
    def __init__(self):
        self.grades = []
    def add_grade(self, g):
        self.grades.append(g)

class InsufficientFunds(Exception):
    pass

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance
        self._history = []

    @property
    def balance(self):
        return self._balance

    @property
    def history(self):
        return tuple(self._history)      # 返回不可变副本，防止外部篡改

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError(f"存款金额必须为正，得到 {amount}")
        self._balance += amount
        self._history.append(("deposit", amount))

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError(f"取款金额必须为正，得到 {amount}")
        if amount > self._balance:
            raise InsufficientFunds(f"余额 {self._balance} 不足以取出 {amount}")
        self._balance -= amount
        self._history.append(("withdraw", amount))

    @classmethod
    def from_dict(cls, data):
        return cls(data["owner"], data.get("balance", 0))

class Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        if self.is_empty():
            raise IndexError("空栈不能 pop")
        return self._items.pop()

    def peek(self):
        if self.is_empty():
            raise IndexError("空栈不能 peek")
        return self._items[-1]

    def is_empty(self):
        return len(self._items) == 0

    def size(self):
        return len(self._items)

    def __len__(self):              # 让 len(stack) 也能用
        return len(self._items)

    def __repr__(self):
        return f"Stack({self._items})"

class Circle:
    def __init__(self, radius):
        self.radius = radius        # 这里就会触发 setter 的校验

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value <= 0:
            raise ValueError(f"半径必须为正数，得到 {value}")
        self._radius = value

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "..."

    def describe(self):
        return f"{self.name} 说：{self.speak()}"


class Dog(Animal):              # Dog 继承 Animal
    def speak(self):            # 重写父类方法
        return "汪汪"


class Cat(Animal):
    def speak(self):
        return "喵喵"


Dog("旺财").describe()      # '旺财 说：汪汪'
Cat("咪咪").describe()      # '咪咪 说：喵喵'

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age


class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)     # 先让父类初始化
        self.breed = breed              # 再加自己的

class LoggedList(list):
    def append(self, item):
        print(f"添加：{item}")
        super().append(item)            # 调用 list 原本的 append

animals = [Dog("旺财"), Cat("咪咪"), Animal("小明")]

for a in animals:
    print(a.speak())        # 每个对象按自己的类型响应

class Duck:
    def speak(self): return "嘎嘎"

class Robot:                       # 跟 Animal 毫无关系
    def speak(self): return "滴滴"

for x in [Dog("旺财"), Robot()]:
    print(x.speak())               # 都能工作

isinstance(d, Dog)          # True
isinstance(d, Animal)       # True   —— 子类实例也是父类实例
isinstance(d, (Dog, Cat))   # True   —— 可以传元组

issubclass(Dog, Animal)     # True
type(d) is Dog              # True   —— 精确类型判断，不考虑继承

# ❌ 每加一种动物都要改这个函数
def make_sound(animal):
    if isinstance(animal, Dog):
        return "汪汪"
    elif isinstance(animal, Cat):
        return "喵喵"

# ✅ 多态：加新动物不用改这里
def make_sound(animal):
    return animal.speak()

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        ...

    @abstractmethod
    def perimeter(self):
        ...

    def describe(self):                  # 可以有普通方法
        return f"面积 {self.area()}，周长 {self.perimeter()}"


class Rectangle(Shape):
    def __init__(self, w, h):
        self.w, self.h = w, h
    def area(self):
        return self.w * self.h
    def perimeter(self):
        return 2 * (self.w + self.h)


Shape()          # TypeError: Can't instantiate abstract class Shape
Rectangle(3, 4).describe()   # '面积 12，周长 14'

class Serializable:
    def to_json(self):
        import json
        return json.dumps(self.__dict__)

class Comparable:
    def __lt__(self, other):
        return self.value < other.value

class Item(Serializable, Comparable):
    def __init__(self, value):
        self.value = value

Item.__mro__
# (Item, Serializable, Comparable, object)

# ❌ 继承：Car "是一个" Engine？不对
class Car(Engine): ...

# ✅ 组合：Car "有一个" Engine
class Car:
    def __init__(self):
        self.engine = Engine()

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def __init__(self, breed):
        self.breed = breed

dog = Dog("柴犬")
print(dog.name)

class Employee:
    def __init__(self, name, base_salary):
        self.name = name
        self.base_salary = base_salary

    def calculate_pay(self):
        return self.base_salary

    def __repr__(self):
        return f"{type(self).__name__}({self.name}, {self.calculate_pay():.0f})"


class Manager(Employee):
    def __init__(self, name, base_salary, bonus=0):
        super().__init__(name, base_salary)
        self.bonus = bonus

    def calculate_pay(self):
        return self.base_salary * 1.5 + self.bonus


class Intern(Employee):
    def calculate_pay(self):
        return self.base_salary * 0.6


staff = [Manager("张三", 20000, 5000), Intern("李四", 10000), Employee("王五", 15000)]
for e in staff:
    print(e)

import json
from abc import ABC, abstractmethod
from pathlib import Path

class Storage(ABC):
    @abstractmethod
    def save(self, key, value): ...

    @abstractmethod
    def load(self, key): ...


class MemoryStorage(Storage):
    def __init__(self):
        self._data = {}
    def save(self, key, value):
        self._data[key] = value
    def load(self, key):
        return self._data.get(key)


class FileStorage(Storage):
    def __init__(self, path):
        self.path = Path(path)
        if not self.path.exists():
            self.path.write_text("{}", encoding="utf-8")

    def _read(self):
        return json.loads(self.path.read_text(encoding="utf-8"))

    def save(self, key, value):
        data = self._read()
        data[key] = value
        self.path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")

    def load(self, key):
        return self._read().get(key)

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

class Service:
    def __init__(self, logger):
        self.logger = logger        # 组合，可以注入不同的 logger

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):                      # 开发者看的表示
        return f"Vector({self.x}, {self.y})"

    def __str__(self):                       # 用户看的表示
        return f"({self.x}, {self.y})"

    def __eq__(self, other):                 # ==
        if not isinstance(other, Vector):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):                      # 定义了 __eq__ 就要定义 __hash__
        return hash((self.x, self.y))

    def __add__(self, other):                # +
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, scalar):               # *
        return Vector(self.x * scalar, self.y * scalar)

    def __abs__(self):                       # abs()
        return (self.x ** 2 + self.y ** 2) ** 0.5

    def __len__(self):                       # len()
        return 2

    def __getitem__(self, i):                # v[0]
        return (self.x, self.y)[i]

    def __bool__(self):                      # if v:
        return bool(self.x or self.y)


v1 = Vector(1, 2)
v2 = Vector(3, 4)

v1 + v2          # Vector(4, 6)
v1 * 3           # Vector(3, 6)
abs(v2)          # 5.0
v1 == Vector(1, 2)   # True
len(v1)          # 2
v1[0]            # 1
print(v1)        # (1, 2)      —— 用 __str__
v1               # Vector(1, 2) —— REPL 里用 __repr__

__repr__(self)      # repr(x)，调试用，应该尽量能还原对象
__str__(self)       # str(x)、print(x)，给人看的
__format__(self, spec)   # f"{x:spec}"

__eq__  __ne__  __lt__  __le__  __gt__  __ge__

__add__  __sub__  __mul__  __truediv__  __floordiv__  __mod__  __pow__
__radd__ ...     # 反向运算（3 * vector 时调用 vector.__rmul__）
__iadd__ ...     # 原地运算（+=）
__neg__  __abs__

__len__(self)               # len(x)
__getitem__(self, key)      # x[key]
__setitem__(self, key, v)   # x[key] = v
__delitem__(self, key)      # del x[key]
__contains__(self, item)    # item in x
__iter__(self)              # for i in x
__next__(self)              # 迭代器协议

__call__(self, ...)         # 让实例能像函数一样调用 x()
__enter__ / __exit__        # with 语句
__hash__(self)              # 作为字典键/集合元素
__bool__(self)              # if x:
__getattr__(self, name)     # 访问不存在的属性时兜底
__slots__ = ("x", "y")      # 限制属性，省内存

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"
    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

p = Point(1, 2)
p                    # Point(x=1, y=2)      __repr__ 自动生成
p == Point(1, 2)     # True                 __eq__ 自动生成

from dataclasses import dataclass, field

@dataclass(frozen=True)      # 不可变，且自动生成 __hash__
class Config:
    host: str = "localhost"          # 带默认值
    port: int = 8080
    tags: list[str] = field(default_factory=list)   # ⚠️ 可变默认值必须用 field
    _secret: str = field(default="", repr=False)     # 不出现在 repr 里


@dataclass(order=True)       # 自动生成 < > <= >=，按字段顺序比较
class Version:
    major: int
    minor: int

@dataclass
class Rectangle:
    width: float
    height: float
    area: float = field(init=False)      # 不作为构造参数

    def __post_init__(self):
        self.area = self.width * self.height

from dataclasses import asdict, astuple, replace

asdict(p)                  # {'x': 1, 'y': 2}
astuple(p)                 # (1, 2)
replace(p, x=10)           # Point(x=10, y=2)  返回新实例

# typing.NamedTuple —— 带注解的不可变记录
from typing import NamedTuple
class Point(NamedTuple):
    x: float
    y: float

# pydantic（第三方，需 pip install pydantic）—— 会真的校验类型并转换
from pydantic import BaseModel
class User(BaseModel):
    name: str
    age: int
User(name="张三", age="25")     # age 自动转成 int 25
User(name="张三", age="abc")    # ValidationError

from enum import Enum, auto

class Status(Enum):
    PENDING = "pending"
    ACTIVE = "active"
    CLOSED = "closed"

Status.ACTIVE            # <Status.ACTIVE: 'active'>
Status.ACTIVE.value      # 'active'
Status.ACTIVE.name       # 'ACTIVE'
Status("active")         # <Status.ACTIVE: 'active'>  从值反查

for s in Status:         # 可迭代
    print(s)

class Color(Enum):
    RED = auto()         # 自动赋值 1, 2, 3
    GREEN = auto()
    BLUE = auto()

from enum import StrEnum       # Python 3.11+，成员可以直接当字符串用
class Env(StrEnum):
    DEV = "dev"
    PROD = "prod"

Env.DEV == "dev"         # True

# ❌ 魔法字符串
if order.status == "actve":     # 拼错了，静默失效

# ✅ 枚举
if order.status is Status.ACTIVE:   # 拼错会 AttributeError

def get_discount(user_type):
    if user_type == "vip":
        return 0.8
    elif user_type == "svip":
        return 0.6
    return 1.0

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, k):
        return Vector(self.x * k, self.y * k)

    __rmul__ = __mul__          # 标量乘法可交换，直接复用

from dataclasses import dataclass, field

@dataclass
class Book:
    title: str
    author: str
    year: int
    tags: list[str] = field(default_factory=list)
    isbn: str = field(default="", repr=False)

from dataclasses import dataclass
from decimal import Decimal

@dataclass(frozen=True, order=True)
class Money:
    amount: Decimal
    currency: str = "CNY"

    def __add__(self, other):
        if self.currency != other.currency:
            raise ValueError(f"币种不匹配：{self.currency} vs {other.currency}")
        return Money(self.amount + other.amount, self.currency)

    def __str__(self):
        return f"{self.amount:.2f} {self.currency}"


a = Money(Decimal("10.50"))
b = Money(Decimal("5.25"))
print(a + b)      # 15.75 CNY

class Playlist:
    def __init__(self, songs=None):
        self._songs = list(songs or [])

    def add(self, song):
        self._songs.append(song)

    def __len__(self):
        return len(self._songs)

    def __getitem__(self, i):
        return self._songs[i]

    def __iter__(self):
        return iter(self._songs)

    def __contains__(self, song):
        return song in self._songs

    def __repr__(self):
        return f"Playlist({len(self)} 首)"

from enum import Enum

class UserType(Enum):
    NORMAL = "normal"
    VIP = "vip"
    SVIP = "svip"

DISCOUNTS = {
    UserType.NORMAL: 1.0,
    UserType.VIP: 0.8,
    UserType.SVIP: 0.6,
}

def get_discount(user_type: UserType) -> float:
    return DISCOUNTS[user_type]

lst = [1, 2, 3]
it = iter(lst)         # 从可迭代对象得到迭代器

next(it)               # 1
next(it)               # 2
next(it)               # 3
next(it)               # StopIteration 异常

# for x in lst: print(x)
# 实际上等价于：
it = iter(lst)
while True:
    try:
        x = next(it)
    except StopIteration:
        break
    print(x)

it = iter([1, 2, 3])
list(it)     # [1, 2, 3]
list(it)     # []  ← 已经耗尽了

z = zip([1,2], "ab")
list(z)      # [(1, 'a'), (2, 'b')]
list(z)      # []  ← zip 返回的是迭代器！

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        return CountdownIterator(self.start)


class CountdownIterator:
    def __init__(self, current):
        self.current = current

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1


for n in Countdown(3):
    print(n)      # 3 2 1

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for x in countdown(3):
    print(x)      # 3 2 1

def demo():
    print("开始")
    yield 1
    print("中间")
    yield 2
    print("结束")

g = demo()          # 什么都不打印
next(g)             # 打印"开始"，返回 1
next(g)             # 打印"中间"，返回 2
next(g)             # 打印"结束"，抛 StopIteration

# ❌ 一次性生成 1000 万个数，占几百 MB
def squares_list(n):
    return [i ** 2 for i in range(n)]

# ✅ 用一个算一个，内存恒定
def squares_gen(n):
    for i in range(n):
        yield i ** 2

sum(squares_gen(10_000_000))    # 内存占用几乎为零

def naturals():
    n = 0
    while True:
        yield n
        n += 1

from itertools import islice
list(islice(naturals(), 5))     # [0, 1, 2, 3, 4]

def read_large_file(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.rstrip()

def filter_errors(lines):
    for line in lines:
        if "ERROR" in line:
            yield line

def parse(lines):
    for line in lines:
        yield line.split("|")

# 组成流水线，全程只占一行的内存
for parts in parse(filter_errors(read_large_file("huge.log"))):
    print(parts)

def chain(*iterables):
    for it in iterables:
        yield from it              # 等价于 for x in it: yield x

list(chain([1, 2], "ab"))          # [1, 2, 'a', 'b']

def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

list(flatten([1, [2, [3, [4]]], 5]))    # [1, 2, 3, 4, 5]

from itertools import (count, cycle, repeat, chain, islice,
                       groupby, product, permutations, combinations,
                       accumulate, takewhile, dropwhile, tee, zip_longest)

# 无限迭代器
count(10, 2)                 # 10, 12, 14, ...
cycle("ABC")                 # A B C A B C ...
repeat("x", 3)               # x x x

# 组合
chain([1,2], [3,4])          # 1 2 3 4
islice(range(100), 5, 10)    # 5 6 7 8 9   （切片，但用于任意迭代器）
zip_longest([1,2], "abc", fillvalue=None)   # (1,'a') (2,'b') (None,'c')

# 排列组合
list(product("AB", repeat=2))       # AA AB BA BB
list(permutations("ABC", 2))        # AB AC BA BC CA CB
list(combinations("ABC", 2))        # AB AC BC

# 累积
list(accumulate([1, 2, 3, 4]))            # [1, 3, 6, 10]  前缀和
list(accumulate([1, 2, 3], func=max))     # 累积最大值

# 条件截取
list(takewhile(lambda x: x < 3, [1,2,3,1]))   # [1, 2]  遇到假就停
list(dropwhile(lambda x: x < 3, [1,2,3,1]))   # [3, 1]  跳过开头

# 分组（⚠️ 必须先按相同的键排序！）
data = sorted(people, key=lambda p: p["city"])
for city, group in groupby(data, key=lambda p: p["city"]):
    print(city, list(group))

def accumulator():
    total = 0
    while True:
        value = yield total
        if value is None:
            break
        total += value

acc = accumulator()
next(acc)          # 启动，返回 0
acc.send(10)       # 10
acc.send(5)        # 15

data = zip([1,2,3], "abc")
print(list(data))
print(list(data))

sum([x**2 for x in range(10**7)])
sum(x**2 for x in range(10**7))

from itertools import islice

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

list(islice(fibonacci(), 10))    # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

from itertools import islice

def chunks(iterable, size):
    it = iter(iterable)
    while chunk := list(islice(it, size)):
        yield chunk

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

from itertools import batched
list(batched([1,2,3,4,5], 2))    # [(1, 2), (3, 4), (5,)]

data = list(zip([1,2,3], "abc"))

from itertools import islice

def error_lines(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            if "ERROR" in line:
                yield line.rstrip()

for line in islice(error_lines("app.log"), 100):
    print(line)

def my_decorator(func):
    def wrapper():
        print("调用前")
        func()
        print("调用后")
    return wrapper


@my_decorator
def say_hello():
    print("Hello")

say_hello()
# 调用前
# Hello
# 调用后

say_hello = my_decorator(say_hello)

import functools

def my_decorator(func):
    @functools.wraps(func)                    # 保留原函数的元信息
    def wrapper(*args, **kwargs):             # 接受任意参数
        print(f"调用 {func.__name__}")
        result = func(*args, **kwargs)        # 原样转发
        print(f"返回 {result}")
        return result                         # 别忘了返回！
    return wrapper


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

add(1, 2)

add.__name__     # 有 wraps → 'add'；没有 → 'wrapper'

import time, functools

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        try:
            return func(*args, **kwargs)
        finally:
            print(f"{func.__name__} 耗时 {time.perf_counter() - start:.4f}s")
    return wrapper

def retry(times=3, delay=1, exceptions=(Exception,)):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last = None
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    last = e
                    print(f"第 {attempt}/{times} 次失败：{e}")
                    if attempt < times:
                        time.sleep(delay)
            raise last
        return wrapper
    return decorator


@retry(times=3, delay=2, exceptions=(ConnectionError,))
def fetch(url):
    ...

import logging

def logged(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        logging.info("调用 %s(%r, %r)", func.__name__, args, kwargs)
        try:
            result = func(*args, **kwargs)
            logging.info("%s 返回 %r", func.__name__, result)
            return result
        except Exception:
            logging.exception("%s 抛出异常", func.__name__)
            raise
    return wrapper

from functools import cache, lru_cache

@cache                        # Python 3.9+，无上限缓存
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)

fib(100)          # 瞬间，没有缓存要算到天荒地老

@lru_cache(maxsize=128)       # 限制缓存条数，超出淘汰最久未用的
def expensive_query(user_id):
    ...

expensive_query.cache_info()      # 查看命中率
expensive_query.cache_clear()     # 清空

from functools import cached_property

class Dataset:
    @cached_property
    def stats(self):
        print("计算中...")        # 只会打印一次
        return heavy_computation(self.data)

d = Dataset()
d.stats     # 计算中... 然后返回
d.stats     # 直接返回缓存

from functools import singledispatch

@singledispatch
def describe(obj):
    return f"未知类型：{obj}"

@describe.register
def _(obj: int):
    return f"整数 {obj}"

@describe.register
def _(obj: list):
    return f"含 {len(obj)} 个元素的列表"

describe(42)        # '整数 42'
describe([1,2])     # '含 2 个元素的列表'

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        return self.func(*args, **kwargs)


@CountCalls
def hello():
    print("hi")

hello(); hello()
hello.count        # 2

def add_repr(cls):
    def __repr__(self):
        attrs = ", ".join(f"{k}={v!r}" for k, v in vars(self).items())
        return f"{cls.__name__}({attrs})"
    cls.__repr__ = __repr__
    return cls


@add_repr
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

Point(1, 2)        # Point(x=1, y=2)

@a
@b
@c
def f(): ...

# 等价于 f = a(b(c(f)))

@app.route("/users")       # 路由必须在最外层
@login_required            # 先检查登录
@timer                     # 再计时
def get_users(): ...

def logger(func):
    def wrapper(*args):
        print(f"调用 {func.__name__}")
        func(*args)
    return wrapper

def count_paths(m, n):
    if m == 1 or n == 1:
        return 1
    return count_paths(m-1, n) + count_paths(m, n-1)

import functools

def debug(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        sig = ", ".join([*map(repr, args), *(f"{k}={v!r}" for k, v in kwargs.items())])
        print(f"→ {func.__name__}({sig})")
        result = func(*args, **kwargs)
        print(f"← {func.__name__} 返回 {result!r}")
        return result
    return wrapper

def validate_positive(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        for i, a in enumerate(args):
            if isinstance(a, (int, float)) and a <= 0:
                raise ValueError(f"{func.__name__} 的第 {i+1} 个参数必须为正数，得到 {a}")
        return func(*args, **kwargs)
    return wrapper

def logger(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

import time, functools

def rate_limit(calls_per_second=2):
    min_interval = 1.0 / calls_per_second
    def decorator(func):
        last_called = 0.0
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            nonlocal last_called
            elapsed = time.perf_counter() - last_called
            if elapsed < min_interval:
                time.sleep(min_interval - elapsed)
            last_called = time.perf_counter()
            return func(*args, **kwargs)
        return wrapper
    return decorator

from functools import cache

@cache
def count_paths(m, n):
    if m == 1 or n == 1:
        return 1
    return count_paths(m-1, n) + count_paths(m, n-1)

count_paths(18, 18)    # 瞬间返回

name: str = "张三"
age: int = 25
scores: list[int] = [90, 85]

def greet(name: str, times: int = 1) -> str:
    return f"你好，{name}！" * times

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

add("x", "y")     # 'xy'  —— 照样能跑，Python 不管

from typing import Any, Optional, Union, Callable, Iterator, TypeVar

# 基本类型直接写
x: int
y: float
s: str
b: bool

# 容器（Python 3.9+ 用内置类型，不用再 from typing import List）
nums: list[int]
pairs: dict[str, int]
point: tuple[float, float]           # 固定长度、每项类型不同
row: tuple[int, ...]                 # 任意长度、同类型
tags: set[str]

# 可能为 None
name: str | None = None              # Python 3.10+ 推荐写法
name: Optional[str] = None           # 旧写法，等价

# 多种类型之一
value: int | str
value: Union[int, str]               # 旧写法

# 函数类型
handler: Callable[[int, str], bool]  # 接收 int 和 str，返回 bool
callback: Callable[..., None]        # 任意参数，返回 None

# 任意类型（相当于关掉检查，慎用）
data: Any

from typing import TypeVar

T = TypeVar("T")

def first(items: list[T]) -> T | None:
    return items[0] if items else None

first([1, 2, 3])       # 类型检查器知道返回 int | None
first(["a", "b"])      # 知道返回 str | None

def first[T](items: list[T]) -> T | None:
    return items[0] if items else None

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int
    email: str | None = None

    def is_adult(self) -> bool:
        return self.age >= 18

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> None: ...

def render(item: Drawable) -> None:      # 任何有 draw 方法的对象都行
    item.draw()

type UserId = int                        # Python 3.12+
type JsonValue = dict[str, "JsonValue"] | list["JsonValue"] | str | int | float | bool | None

UserId = int                             # 旧写法

from typing import NoReturn

def fail(msg: str) -> NoReturn:          # 永远不正常返回
    raise RuntimeError(msg)

def gen() -> Iterator[int]:              # 生成器
    yield 1

def process(user):          # IDE 不知道 user 有什么方法
    user.          # ← 没有补全提示

def process(user: User):    # IDE 知道了
    user.          # ← 弹出 name, age, is_adult...

# 不看实现能看懂吗？
def calc(a, b, c): ...

# 一目了然
def calculate_discount(price: Decimal, rate: float, is_vip: bool) -> Decimal: ...

pip install mypy
mypy your_file.py

[tool.mypy]
python_version = "3.12"
strict = true                    # 严格模式，新项目推荐
warn_return_any = true
warn_unused_ignores = true

[[tool.mypy.overrides]]
module = "some_untyped_lib.*"
ignore_missing_imports = true

result = weird_call()  # type: ignore[attr-defined]

from pydantic import BaseModel, Field, field_validator

class User(BaseModel):
    name: str = Field(min_length=1, max_length=50)
    age: int = Field(ge=0, le=150)
    email: str

    @field_validator("email")
    @classmethod
    def check_email(cls, v: str) -> str:
        if "@" not in v:
            raise ValueError("邮箱格式不正确")
        return v


User(name="张三", age=25, email="[email protected]")     # ✅
User(name="", age=200, email="bad")           # ValidationError，一次报出所有问题

def find_users(names, min_age=0, active_only=True):
    return [u for u in database if u.name in names]

def get_config() -> dict:
    return {"host": "localhost", "port": 8080}

from collections.abc import Sequence

def find_users(
    names: Sequence[str],
    min_age: int = 0,
    active_only: bool = True,
) -> list[User]:
    return [u for u in database if u.name in names]

d: dict[str, list[int]]
s: str | None
f: Callable[[str], bool]
records: list[tuple[str, int, bool]]

def get_config() -> dict[str, str | int]: ...

# 更好：用 TypedDict 或 dataclass 明确结构
from typing import TypedDict

class Config(TypedDict):
    host: str
    port: int

def get_config() -> Config: ...

from typing import Protocol, Any

class Serializable(Protocol):
    def to_dict(self) -> dict[str, Any]: ...


def save_all(items: list[Serializable]) -> None:
    for item in items:
        write(item.to_dict())

from datetime import datetime, date, time, timedelta, timezone

now = datetime.now()                    # 本地当前时间
utc = datetime.now(timezone.utc)        # UTC 时间（推荐存储用这个）
today = date.today()

# 构造
d = date(2026, 7, 26)
dt = datetime(2026, 7, 26, 14, 30, 0)

# 格式化
now.strftime("%Y-%m-%d %H:%M:%S")       # '2026-07-26 14:30:00'
now.isoformat()                         # '2026-07-26T14:30:00.123456'

# 解析
datetime.strptime("2026-07-26", "%Y-%m-%d")
datetime.fromisoformat("2026-07-26T14:30:00")

# 计算
tomorrow = today + timedelta(days=1)
delta = date(2026, 12, 31) - today
delta.days                              # 剩余天数

# 时间戳
now.timestamp()                         # 1785…
datetime.fromtimestamp(1785000000)

from zoneinfo import ZoneInfo

beijing = datetime.now(ZoneInfo("Asia/Shanghai"))
utc_time = beijing.astimezone(timezone.utc)

import time

time.time()               # Unix 时间戳（会被系统调时影响）
time.perf_counter()       # 高精度计时，测量耗时用这个
time.monotonic()          # 单调时钟，不会倒退
time.sleep(1.5)           # 暂停

# 测量代码耗时
start = time.perf_counter()
do_work()
print(f"{time.perf_counter() - start:.4f}s")

import timeit
timeit.timeit("'-'.join(str(n) for n in range(100))", number=10000)

import random

random.random()                     # [0.0, 1.0) 之间的浮点数
random.randint(1, 6)                # 1-6 之间的整数（含两端）
random.randrange(0, 10, 2)          # 0,2,4,6,8 中随机一个
random.uniform(1.5, 3.5)            # 区间内随机浮点数
random.choice(["a", "b", "c"])      # 随机选一个
random.choices(items, k=3)          # 有放回抽 3 个
random.choices(items, weights=[1,5,2], k=3)   # 带权重
random.sample(items, 3)             # 无放回抽 3 个
random.shuffle(lst)                 # 原地打乱

random.seed(42)                     # 固定种子，结果可复现（测试有用）

import secrets

secrets.token_hex(16)               # '3d8f2a...'  随机十六进制字符串
secrets.token_urlsafe(32)           # URL 安全的随机串
secrets.choice(alphabet)            # 安全的随机选择
secrets.compare_digest(a, b)        # 恒定时间比较，防时序攻击

import math

math.pi, math.e, math.inf, math.nan
math.sqrt(16)          # 4.0
math.floor(3.7)        # 3    向下取整
math.ceil(3.2)         # 4    向上取整
math.trunc(-3.7)       # -3   向零截断
math.factorial(5)      # 120
math.gcd(12, 18)       # 6    最大公约数
math.lcm(4, 6)         # 12   最小公倍数（3.9+）
math.log(100, 10)      # 2.0
math.hypot(3, 4)       # 5.0  欧几里得距离
math.isclose(a, b)     # 浮点数近似比较
math.isnan(x), math.isinf(x)
math.comb(5, 2)        # 10   组合数
math.dist((0,0), (3,4))  # 5.0

import statistics as st

st.mean([1,2,3,4])       # 2.5    平均数
st.median([1,2,3,4])     # 2.5    中位数
st.mode([1,1,2])         # 1      众数
st.stdev([1,2,3,4])      # 样本标准差
st.pstdev([1,2,3,4])     # 总体标准差
st.quantiles(data, n=4)  # 四分位数

import os, sys, platform

os.environ.get("HOME")           # 读环境变量
os.environ["MY_VAR"] = "x"       # 设置（只影响当前进程）
os.cpu_count()                   # CPU 核数
os.getpid()                      # 进程 ID

sys.argv                         # 命令行参数列表，argv[0] 是脚本名
sys.exit(1)                      # 退出，非 0 表示出错
sys.platform                     # 'darwin' / 'win32' / 'linux'
sys.version_info                 # (3, 14, 6, 'final', 0)
sys.stdout, sys.stderr, sys.stdin

platform.system()                # 'Darwin' / 'Windows' / 'Linux'

import subprocess

# 推荐写法：传列表（自动处理转义），检查返回码，捕获输出
result = subprocess.run(
    ["git", "status", "--short"],
    capture_output=True,
    text=True,                  # 输出当字符串处理而不是 bytes
    check=True,                 # 返回码非 0 时抛异常
)
print(result.stdout)

subprocess.run(f"rm {filename}", shell=True)     # ❌ filename="; rm -rf /" 就完了
subprocess.run(["rm", filename])                 # ✅

import argparse

parser = argparse.ArgumentParser(description="批量处理文件")
parser.add_argument("input", help="输入文件路径")
parser.add_argument("-o", "--output", default="out.txt", help="输出路径")
parser.add_argument("-v", "--verbose", action="store_true", help="详细输出")
parser.add_argument("-n", "--count", type=int, default=10)
parser.add_argument("--mode", choices=["fast", "safe"], default="safe")

args = parser.parse_args()
print(args.input, args.output, args.verbose)

import textwrap, string, difflib, unicodedata

textwrap.fill(long_text, width=70)       # 自动折行
textwrap.dedent(indented_text)           # 去掉公共缩进（写多行字符串很有用）
textwrap.shorten(text, width=50)         # 截断并加省略号

string.ascii_lowercase                   # 'abcdefghijklmnopqrstuvwxyz'
string.digits, string.punctuation

difflib.get_close_matches("aple", ["apple", "banana"])   # ['apple'] 模糊匹配
difflib.unified_diff(lines1, lines2)                     # 生成 diff

import json, csv, sqlite3, pickle, base64, hashlib, uuid

# 哈希
hashlib.sha256(b"hello").hexdigest()
hashlib.md5(data).hexdigest()            # ⚠️ md5 已不安全，别用于密码

# 密码存储必须用专门的算法（第三方库）
# pip install argon2-cffi  或  bcrypt

# UUID
uuid.uuid4()                             # 随机唯一 ID
str(uuid.uuid4())                        # 'f47ac10b-58cc-...'

# Base64
base64.b64encode(b"data").decode()
base64.b64decode("ZGF0YQ==")

# SQLite（零配置的本地数据库，标准库自带）
conn = sqlite3.connect("app.db")
conn.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")
conn.execute("INSERT INTO users (name) VALUES (?)", ("张三",))   # ⚠️ 一定用参数化
conn.commit()
for row in conn.execute("SELECT * FROM users"):
    print(row)
conn.close()

import urllib.request, urllib.parse

# 标准库能用，但很啰嗦
with urllib.request.urlopen("https://api.example.com/data") as r:
    data = json.loads(r.read())

urllib.parse.urlencode({"q": "python", "page": 1})    # 'q=python&page=1'
urllib.parse.quote("中文")                             # URL 编码

# pip install httpx
import httpx

r = httpx.get("https://api.example.com/data", params={"q": "python"}, timeout=10)
r.raise_for_status()
data = r.json()

# POST JSON
r = httpx.post(url, json={"name": "张三"}, headers={"Authorization": "Bearer ..."})

import functools, operator

functools.reduce(operator.add, [1,2,3,4])     # 10  （一般用 sum 就好）
functools.partial(int, base=2)("1010")        # 10  固定部分参数

operator.itemgetter(1)                        # 取索引 1，用于 key=
operator.attrgetter("name")                   # 取属性
operator.methodcaller("upper")                # 调用方法

from functools import partial

# 创建一个"预配置"的函数
save_json = partial(json.dump, ensure_ascii=False, indent=2)
save_json(data, f)      # 不用每次都写那两个参数

import copy            # deepcopy
import glob            # 文件通配（pathlib.glob 更好用）
import tempfile        # 临时文件/目录
import zipfile, tarfile, gzip     # 压缩
import shutil          # 高级文件操作
import warnings        # 发出警告
import inspect         # 运行时检查对象（写框架时用）
import weakref         # 弱引用
import decimal, fractions         # 精确数值
import heapq           # 堆/优先队列
import bisect          # 有序列表二分查找
import array           # 紧凑数值数组
import struct          # 二进制打包
import html, xml       # 标记语言
import email, smtplib  # 邮件
import calendar        # 日历
import pprint          # 美化打印嵌套结构

import heapq
heapq.nlargest(3, data, key=lambda x: x["score"])
heapq.nsmallest(3, data)

import tempfile
with tempfile.TemporaryDirectory() as tmpdir:
    path = Path(tmpdir) / "work.txt"
    ...    # 退出 with 时自动删除整个目录

import subprocess
filename = input("文件名：")
subprocess.run(f"cat {filename}", shell=True)

from datetime import date

today = date.today()
year_end = date(today.year, 12, 31)
print(f"距离 {today.year} 年底还有 {(year_end - today).days} 天")

import secrets, string

alphabet = string.ascii_letters + string.digits
password = "".join(secrets.choice(alphabet) for _ in range(12))
print(password)

import argparse
from pathlib import Path

parser = argparse.ArgumentParser(description="统计文件数量")
parser.add_argument("directory", type=Path)
parser.add_argument("--ext", default="py", help="扩展名，不带点")
args = parser.parse_args()

files = list(args.directory.rglob(f"*.{args.ext}"))
print(f"{args.directory} 下有 {len(files)} 个 .{args.ext} 文件")

import sqlite3
from contextlib import closing

def init(conn):
    conn.execute("""
        CREATE TABLE IF NOT EXISTS todos (
            id INTEGER PRIMARY KEY,
            title TEXT NOT NULL,
            done INTEGER DEFAULT 0
        )
    """)
    conn.commit()

def add(conn, title):
    conn.execute("INSERT INTO todos (title) VALUES (?)", (title,))
    conn.commit()

def list_all(conn):
    for row in conn.execute("SELECT id, title, done FROM todos ORDER BY id"):
        mark = "✓" if row[2] else " "
        print(f"[{mark}] {row[0]}. {row[1]}")

def complete(conn, todo_id):
    conn.execute("UPDATE todos SET done = 1 WHERE id = ?", (todo_id,))
    conn.commit()

with closing(sqlite3.connect("todo.db")) as conn:
    init(conn)
    add(conn, "学习 Python")
    add(conn, "写练习题")
    complete(conn, 1)
    list_all(conn)

import subprocess
filename = input("文件名：")
subprocess.run(["cat", filename], check=True)     # ✅ 不经过 shell

from pathlib import Path
print(Path(filename).read_text(encoding="utf-8"))

import re

text = "我的电话是 138-1234-5678，备用 139-8765-4321"

re.search(r"\d{3}-\d{4}-\d{4}", text)      # 找第一个匹配，返回 Match 对象或 None
re.findall(r"\d{3}-\d{4}-\d{4}", text)     # 找全部，返回列表
re.finditer(r"\d+", text)                  # 找全部，返回迭代器（能拿到位置）
re.sub(r"\d", "*", text)                   # 替换
re.split(r"[，,]", text)                    # 按模式分割
re.fullmatch(r"\d+", "123")                # 整个字符串必须匹配
re.match(r"我的", text)                     # 只从开头匹配

m = re.search(r"(\d{3})-(\d{4})", text)
if m:
    m.group()      # '138-1234'   整个匹配
    m.group(1)     # '138'        第一个捕获组
    m.group(2)     # '1234'
    m.groups()     # ('138', '1234')
    m.start()      # 匹配起始位置
    m.span()       # (6, 14)

.        任意字符（除换行）
\d       数字        \D  非数字
\w       字母数字下划线  \W  非
\s       空白字符     \S  非
[abc]    a 或 b 或 c
[^abc]   除了 abc
[a-z]    a 到 z
[0-9a-fA-F]  十六进制字符

*        0 次或多次
+        1 次或多次
?        0 次或 1 次
{3}      恰好 3 次
{2,5}    2 到 5 次
{2,}     至少 2 次
*?  +?  ??  {n,m}?    非贪婪版本（尽可能少匹配）

^        字符串开头（多行模式下是行首）
$        字符串结尾
\b       单词边界
\B       非单词边界

(...)         捕获组
(?:...)       非捕获组（只分组不捕获，效率更高）
(?P<name>...) 命名组
(?=...)       正向先行断言（后面必须是）
(?!...)       负向先行断言（后面不能是）
(?<=...)      正向后行断言（前面必须是）
(?<!...)      负向后行断言
|             或

text = "<b>粗体</b><i>斜体</i>"

re.findall(r"<.*>", text)      # ['<b>粗体</b><i>斜体</i>']  贪婪：匹配到最后
re.findall(r"<.*?>", text)     # ['<b>', '</b>', '<i>', '</i>']  非贪婪 ✅

# 邮箱（简化版，完整的邮箱正则极其复杂，实际用库校验）
r"[\w.+-]+@[\w-]+\.[\w.]+"

# 中国手机号
r"1[3-9]\d{9}"

# URL
r"https?://[^\s]+"

# IPv4
r"\b(?:\d{1,3}\.){3}\d{1,3}\b"

# 日期 YYYY-MM-DD
r"\d{4}-\d{2}-\d{2}"

# 中文字符
r"[一-鿿]+"

# HTML 标签（简单场景；解析 HTML 请用 Beautiful Soup）
r"<[^>]+>"

# 提取引号内的内容
r'"([^"]*)"'

# 命名组让代码可读得多
pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
m = re.search(pattern, "日期：2026-07-26")
m.group("year")      # '2026'
m.groupdict()        # {'year': '2026', 'month': '07', 'day': '26'}

# 替换中引用分组
re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\3/\2/\1", "2026-07-26")   # '26/07/2026'
re.sub(pattern, r"\g<day>/\g<month>/\g<year>", text)            # 用名字引用

# 替换用函数（复杂逻辑）
def upper_match(m):
    return m.group().upper()

re.sub(r"\b\w{5,}\b", upper_match, "hello world hi")   # 'HELLO WORLD hi'

re.IGNORECASE  / re.I    # 忽略大小写
re.MULTILINE   / re.M    # ^ $ 匹配每行的首尾
re.DOTALL      / re.S    # . 也匹配换行符
re.VERBOSE     / re.X    # 允许写注释和空白

re.search(r"hello", text, re.IGNORECASE)

pattern = re.compile(r"""
    (\d{3})     # 区号
    [-\s]?      # 可选分隔符
    (\d{4})     # 前四位
    [-\s]?
    (\d{4})     # 后四位
""", re.VERBOSE)

pattern = re.compile(r"\d+")

pattern.search(text)
pattern.findall(text)
pattern.sub("X", text)

# ❌ 用正则解析 HTML/XML/JSON —— 这些是嵌套结构，正则表达不了
re.findall(r"<div>(.*?)</div>", html)

# ✅ 用专门的解析器
from bs4 import BeautifulSoup      # HTML
import json                         # JSON
import csv                          # CSV

re.search(r"^abc", s)          → s.startswith("abc")
re.search(r"abc", s)           → "abc" in s
re.sub(r"abc", "x", s)         → s.replace("abc", "x")
re.split(r",", s)              → s.split(",")

r"(a+)+b"     # 对 "aaaaaaaaaaaaaaaaaaaaac" 会卡死

re.findall(r"<b>(.*)</b>", "<b>a</b> and <b>b</b>")

import re
emails = re.findall(r"[\w.+-]+@[\w-]+\.[\w.-]+", text)

re.sub(r"(\d{4})-(\d{2})-(\d{2})", r"\1年\2月\3日", text)

import re

def is_strong(password: str) -> bool:
    if len(password) < 8:
        return False
    checks = [r"[a-z]", r"[A-Z]", r"\d"]
    return all(re.search(c, password) for c in checks)

r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$"

re.findall(r"<b>(.*?)</b>", text)     # ['a', 'b']  ✅ 非贪婪

import re

log = '192.168.1.1 - [2026-07-26 14:30:00] "GET /api"\n10.0.0.5 - [2026-07-26 14:31:02] "POST /login"'

pattern = re.compile(
    r"(?P<ip>\d{1,3}(?:\.\d{1,3}){3}).*?"
    r"\[(?P<timestamp>[\d-]+ [\d:]+)\]"
)

records = [m.groupdict() for m in pattern.finditer(log)]
# [{'ip': '192.168.1.1', 'timestamp': '2026-07-26 14:30:00'}, ...]

from concurrent.futures import ThreadPoolExecutor
import httpx

urls = ["https://example.com/1", "https://example.com/2", ...]

def fetch(url):
    return httpx.get(url, timeout=10).text

# 高层 API，推荐用这个而不是直接操作 Thread
with ThreadPoolExecutor(max_workers=10) as pool:
    results = list(pool.map(fetch, urls))

from concurrent.futures import ThreadPoolExecutor, as_completed

with ThreadPoolExecutor(max_workers=10) as pool:
    futures = {pool.submit(fetch, url): url for url in urls}
    for future in as_completed(futures):        # 谁先完成先处理谁
        url = futures[future]
        try:
            print(url, len(future.result()))
        except Exception as e:
            print(f"{url} 失败：{e}")

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:              # 保证同一时刻只有一个线程能执行
            counter += 1

from concurrent.futures import ProcessPoolExecutor

def heavy_compute(n):
    return sum(i * i for i in range(n))

if __name__ == "__main__":              # ⚠️ Windows/macOS 上必须有这行
    with ProcessPoolExecutor() as pool:
        results = list(pool.map(heavy_compute, [10**7] * 4))

import asyncio
import httpx

async def fetch(client, url):            # async def 定义协程
    r = await client.get(url)            # await 处让出控制权
    return r.text

async def main():
    async with httpx.AsyncClient() as client:
        tasks = [fetch(client, url) for url in urls]
        results = await asyncio.gather(*tasks)      # 并发执行全部
    return results

asyncio.run(main())                      # 启动事件循环

await asyncio.sleep(1)                      # 异步睡眠（不阻塞其他任务）
await asyncio.gather(*coros)                # 并发运行，全部完成后返回结果列表
await asyncio.wait_for(coro, timeout=5)     # 超时控制
task = asyncio.create_task(coro)            # 创建后台任务
await task

# Python 3.11+ 的任务组（更安全，异常处理更好）
async with asyncio.TaskGroup() as tg:
    tg.create_task(work1())
    tg.create_task(work2())
# 退出时自动等待所有任务；任一失败会取消其余任务

async def a(): ...
async def b():
    await a()          # 只能在 async 函数里 await
def c():
    await a()          # ❌ SyntaxError

async def bad():
    time.sleep(1)                    # ❌ 阻塞整个事件循环，所有任务都卡住
    requests.get(url)                # ❌ 同上

async def good():
    await asyncio.sleep(1)           # ✅
    await client.get(url)            # ✅ 用异步的 HTTP 客户端

    # 必须调用阻塞函数时，扔到线程池
    result = await asyncio.to_thread(blocking_function, arg)

任务是 CPU 密集的？
├─ 是 → ProcessPoolExecutor（或者用 numpy/Rust 扩展）
└─ 否（I/O 密集）
    ├─ 并发量 < 几十 → ThreadPoolExecutor（简单，不用改代码风格）
    └─ 并发量成百上千 → asyncio（内存效率高得多）

import asyncio
import httpx
from pathlib import Path

async def download(client: httpx.AsyncClient, url: str, dest: Path,
                   sem: asyncio.Semaphore) -> str:
    async with sem:                       # 限制并发数，别把对方服务器打挂
        try:
            r = await client.get(url, timeout=30, follow_redirects=True)
            r.raise_for_status()
            dest.write_bytes(r.content)
            return f"✅ {url} → {dest.name}"
        except httpx.HTTPError as e:
            return f"❌ {url}：{e}"


async def main(urls: list[str], outdir: Path) -> None:
    outdir.mkdir(parents=True, exist_ok=True)
    sem = asyncio.Semaphore(5)            # 最多 5 个并发

    async with httpx.AsyncClient() as client:
        tasks = [
            download(client, url, outdir / f"{i:03d}.dat", sem)
            for i, url in enumerate(urls)
        ]
        for coro in asyncio.as_completed(tasks):
            print(await coro)


if __name__ == "__main__":
    asyncio.run(main(["https://example.com"] * 10, Path("downloads")))

def compute():
    return sum(i*i for i in range(10**7))

import time
def task(n):
    time.sleep(1)
    return n * 2

results = [task(i) for i in range(5)]   # 耗时 5 秒

async def fetch_all(urls):
    results = []
    for url in urls:
        results.append(await fetch(url))
    return results

from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

paths = list(Path("data").glob("*.txt"))

def read(p):
    return p.name, p.read_text(encoding="utf-8")

with ThreadPoolExecutor(max_workers=10) as pool:
    for name, content in pool.map(read, paths):
        print(name, len(content))

import asyncio

async def task(n):
    await asyncio.sleep(1)
    return n * 2

async def main():
    return await asyncio.gather(*(task(i) for i in range(5)))

results = asyncio.run(main())    # 耗时约 1 秒

async def fetch_all(urls):
    return await asyncio.gather(*(fetch(url) for url in urls))

# 创建（会生成一个 .venv 目录）
python3 -m venv .venv

# 激活
source .venv/bin/activate          # macOS / Linux
.venv\Scripts\activate             # Windows

# 激活后提示符会变成 (.venv) $
# 这时 python 和 pip 都指向虚拟环境里的版本

pip install requests
pip list

deactivate                         # 退出

pip install requests                 # 安装
pip install "django>=4.0,<5.0"       # 指定版本范围
pip install -r requirements.txt      # 从文件批量安装
pip install -e .                     # 以可编辑模式安装本项目
pip install --upgrade requests
pip uninstall requests
pip list                             # 列出已安装
pip list --outdated                  # 列出可升级的
pip show requests                    # 查看详情和依赖
pip freeze > requirements.txt        # 导出当前环境所有包及精确版本

[project]
name = "myproject"
version = "0.1.0"
description = "一句话说明"
requires-python = ">=3.12"
dependencies = [
    "httpx>=0.27",
    "pydantic>=2.0",
]

[project.optional-dependencies]
dev = [
    "pytest>=8.0",
    "ruff>=0.6",
    "mypy>=1.11",
]

[project.scripts]
mycli = "myproject.cli:main"        # 安装后可以直接敲 mycli 运行

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[tool.ruff]
line-length = 100

[tool.pytest.ini_options]
testpaths = ["tests"]

pip install -e ".[dev]"      # 安装项目本身 + dev 依赖

# 初始化项目（自动创建 pyproject.toml）
uv init myproject
cd myproject

# 加依赖（自动创建虚拟环境、更新 pyproject.toml 和 uv.lock）
uv add httpx pydantic
uv add --dev pytest ruff mypy

# 运行（自动确保环境是最新的）
uv run python main.py
uv run pytest

# 同步环境到锁文件状态
uv sync

# 管理 Python 版本
uv python install 3.14
uv python pin 3.14

# 不安装直接运行工具
uv tool run ruff check .
uvx ruff check .              # 简写

"httpx"              # ❌ 太松，将来大版本更新可能直接崩
"httpx==0.27.0"      # ❌ 太紧，收不到安全修复
"httpx>=0.27,<1.0"   # ✅ 允许小版本更新，挡住破坏性变更

pip list --outdated
pip-audit                    # 检查已知安全漏洞

dependencies = ["django", "requests==2.25.0", "numpy>=1.0"]

mkdir demo && cd demo
python3 -m venv .venv
source .venv/bin/activate
pip install httpx

cat > main.py << 'EOF'
import httpx

r = httpx.get("https://api.github.com/repos/python/cpython", timeout=10)
r.raise_for_status()
data = r.json()
print(f"{data['full_name']}: {data['stargazers_count']} stars")
EOF

python main.py
pip freeze > requirements.txt

dependencies = [
    "django>=5.0,<6.0",
    "requests>=2.31,<3.0",
    "numpy>=1.26,<3.0",
]

pip install pytest

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

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为 0")
    return a / b

import pytest
from calculator import add, divide

def test_add():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, -1) == -2

def test_divide():
    assert divide(10, 2) == 5

def test_divide_by_zero():
    with pytest.raises(ValueError, match="除数不能为 0"):
        divide(10, 0)

pytest                    # 运行所有测试
pytest -v                 # 显示每个测试的名字
pytest test_calc.py       # 只跑某个文件
pytest -k "divide"        # 只跑名字含 divide 的
pytest -x                 # 第一个失败就停
pytest --lf               # 只重跑上次失败的
pytest -q                 # 简洁输出

@pytest.mark.parametrize("a, b, expected", [
    (2, 3, 5),
    (0, 0, 0),
    (-1, 1, 0),
    (0.1, 0.2, pytest.approx(0.3)),      # 浮点数比较用 approx
])
def test_add(a, b, expected):
    assert add(a, b) == expected

import pytest

@pytest.fixture
def sample_users():
    return [
        {"name": "张三", "age": 25},
        {"name": "李四", "age": 17},
    ]

def test_adults(sample_users):            # 参数名匹配 fixture 名，自动注入
    adults = [u for u in sample_users if u["age"] >= 18]
    assert len(adults) == 1

@pytest.fixture
def temp_db(tmp_path):                    # tmp_path 是 pytest 内置 fixture
    db_path = tmp_path / "test.db"
    conn = sqlite3.connect(db_path)
    conn.execute("CREATE TABLE users (id INTEGER, name TEXT)")
    yield conn                            # 测试在这里运行
    conn.close()                          # 测试结束后清理

@pytest.fixture(scope="function")   # 默认：每个测试函数都新建
@pytest.fixture(scope="module")     # 每个文件建一次
@pytest.fixture(scope="session")    # 整个测试会话建一次（比如启动数据库）

def test_file(tmp_path):              # 临时目录（Path 对象）
    (tmp_path / "a.txt").write_text("hi")

def test_output(capsys):              # 捕获 print 输出
    print("hello")
    assert capsys.readouterr().out == "hello\n"

def test_env(monkeypatch):            # 临时修改环境变量/属性
    monkeypatch.setenv("API_KEY", "test")
    monkeypatch.setattr("mymodule.CONFIG", {"debug": True})

def test_withdraw():
    account = BankAccount("张三", 100)      # Arrange：准备
    account.withdraw(30)                   # Act：执行
    assert account.balance == 70           # Assert：断言

# ❌ 失败时不知道是哪一步坏了
def test_account():
    a = BankAccount("张三", 100)
    a.deposit(50)
    assert a.balance == 150
    a.withdraw(30)
    assert a.balance == 120
    with pytest.raises(...): a.withdraw(1000)

# ✅ 拆成三个测试
def test_deposit_increases_balance(): ...
def test_withdraw_decreases_balance(): ...
def test_withdraw_too_much_raises(): ...

def test_1():                                       # ❌
def test_withdraw_more_than_balance_raises():       # ✅

# 空输入、单元素、最大值、None、负数、超长字符串
def test_empty_list(): ...
def test_single_element(): ...
def test_none_input_raises(): ...

from unittest.mock import patch, Mock

def get_user_name(user_id):
    r = httpx.get(f"https://api.example.com/users/{user_id}")
    return r.json()["name"]


def test_get_user_name():
    fake = Mock()
    fake.json.return_value = {"name": "张三"}

    with patch("mymodule.httpx.get", return_value=fake):
        assert get_user_name(1) == "张三"

# ❌ 硬编码依赖，只能靠 mock
def get_user_name(user_id):
    r = httpx.get(...)

# ✅ 依赖作为参数传入，测试时传个假的就行
def get_user_name(user_id, client=httpx):
    r = client.get(...)

pip install pytest-cov
pytest --cov=myproject --cov-report=term-missing

Name                 Stmts   Miss  Cover   Missing
--------------------------------------------------
myproject/core.py       45      3    93%   67-69

def add(a, b):
    """返回两数之和。

    >>> add(2, 3)
    5
    >>> add(-1, 1)
    0
    """
    return a + b

pytest --doctest-modules

from hypothesis import given, strategies as st

@given(st.lists(st.integers()))
def test_sort_is_idempotent(lst):
    assert sorted(sorted(lst)) == sorted(lst)

def parse_age(text):
    age = int(text)
    if not 0 <= age <= 150:
        raise ValueError(f"年龄超出范围：{age}")
    return age

def test_everything():
    assert add(1, 2) == 3
    assert divide(10, 2) == 5
    assert multiply(3, 4) == 12

import pytest
from mymodule import parse_age

@pytest.mark.parametrize("text, expected", [
    ("0", 0),
    ("25", 25),
    ("150", 150),
    (" 42 ", 42),          # int() 会忽略两端空白
])
def test_parse_age_valid(text, expected):
    assert parse_age(text) == expected


@pytest.mark.parametrize("text", ["-1", "151", "1000"])
def test_parse_age_out_of_range(text):
    with pytest.raises(ValueError, match="超出范围"):
        parse_age(text)


@pytest.mark.parametrize("text", ["abc", "", "3.14", None])
def test_parse_age_invalid_input(text):
    with pytest.raises((ValueError, TypeError)):
        parse_age(text)

@pytest.mark.parametrize("n, expected", [
    (1, "1"),
    (3, "Fizz"),
    (5, "Buzz"),
    (15, "FizzBuzz"),
    (30, "FizzBuzz"),
    (7, "7"),
])
def test_fizzbuzz(n, expected):
    assert fizzbuzz(n) == expected

@pytest.fixture
def sample_dir(tmp_path):
    (tmp_path / "a.txt").write_text("内容 A", encoding="utf-8")
    (tmp_path / "b.txt").write_text("内容 B", encoding="utf-8")
    (tmp_path / "c.log").write_text("日志", encoding="utf-8")
    return tmp_path

def test_count_txt(sample_dir):
    assert len(list(sample_dir.glob("*.txt"))) == 2

print(f"{user=}")                  # user=User(name='张三')  —— f-string 的 = 语法
print(f"{len(items)=}, {items[:3]=}")

def process(data):
    result = transform(data)
    breakpoint()                   # Python 3.7+，程序会在这里停下
    return result

n (next)      执行下一行
s (step)      进入函数内部
c (continue)  继续运行到下一个断点
l (list)      显示当前代码上下文
p 变量名       打印变量
pp 变量名      美化打印
w (where)     显示调用栈
u / d         在调用栈中上下移动
q (quit)      退出

python -m pdb -c continue script.py     # 崩溃时停在出错的地方
pytest --pdb                            # 测试失败时进入 pdb

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    datefmt="%H:%M:%S",
)

logger = logging.getLogger(__name__)

logger.debug("详细的调试信息")
logger.info("正常的运行信息")
logger.warning("有点不对劲但还能跑")
logger.error("出错了")
logger.critical("严重错误")

try:
    risky()
except Exception:
    logger.exception("处理失败")      # 自动附带完整 traceback

logger.info("用户 %s 登录，IP %s", username, ip)     # ✅ 只在真正输出时才格式化
logger.info(f"用户 {username} 登录")                 # ⚠️ 总是格式化，DEBUG 关闭时也浪费

from logging.handlers import RotatingFileHandler

handler = RotatingFileHandler(
    "app.log", maxBytes=10_000_000, backupCount=5, encoding="utf-8"
)
handler.setFormatter(logging.Formatter(
    "%(asctime)s [%(levelname)s] %(name)s:%(lineno)d - %(message)s"
))
logging.getLogger().addHandler(handler)

# main.py
import logging

def setup_logging(verbose: bool = False):
    logging.basicConfig(
        level=logging.DEBUG if verbose else logging.INFO,
        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    )
    logging.getLogger("httpx").setLevel(logging.WARNING)   # 压低吵闹的第三方库

if __name__ == "__main__":
    setup_logging()
    main()

File "main.py", line 5
    print(items[i][j])
          ^^^^^^^^^^^
IndexError: list index out of range

print(f"{type(data)=}, {len(data)=}, {data[:2]=}")

logger.debug(f"处理数据：{expensive_serialize(data)}")

def average(nums):
    total = 0
    for n in nums:
        total += n
    return total / len(nums) - 1

import logging

def setup_logging(log_file="app.log"):
    root = logging.getLogger()
    root.setLevel(logging.DEBUG)

    fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s")

    console = logging.StreamHandler()
    console.setLevel(logging.INFO)
    console.setFormatter(fmt)

    file = logging.FileHandler(log_file, encoding="utf-8")
    file.setLevel(logging.DEBUG)
    file.setFormatter(fmt)

    root.addHandler(console)
    root.addHandler(file)

logger.debug("处理数据：%s", data)          # 只在真要输出时才格式化
# 或者
if logger.isEnabledFor(logging.DEBUG):
    logger.debug("处理数据：%s", expensive_serialize(data))

def average(nums):
    if not nums:
        return 0
    return sum(nums) / len(nums)

# 缩进：4 个空格
# 行长：79（PEP 8）或 88-100（现代实践，ruff 默认 88）

# 命名
variable_name = 1          # 变量、函数：snake_case
CONSTANT_VALUE = 1         # 常量：UPPER_CASE
class ClassName: ...       # 类：PascalCase
def function_name(): ...
_internal = 1              # 内部使用：前置下划线

# 空行
class A:              # 类和顶层函数之间空 2 行

    def method(self): # 方法之间空 1 行
        pass

# 空格
x = 1                 # ✅ 运算符两边加空格
x=1                   # ❌
f(a, b)               # ✅ 逗号后加空格
f(a,b)                # ❌
f(x=1)                # ✅ 关键字参数的 = 两边不加空格
d["key"]              # ✅ 括号内侧不加空格
d[ "key" ]            # ❌

# import 顺序：标准库 → 第三方 → 本项目，各组之间空一行
import os
import sys

import httpx
import pydantic

from myproject.utils import helper

if x is None:              # ✅ 和 None 比较用 is
if not items:              # ✅ 判断空序列
if len(items) == 0:        # ❌ 啰嗦

if isinstance(x, int):     # ✅
if type(x) == int:         # ❌

try:                       # ✅ 捕获具体异常
    ...
except ValueError:
    ...
except:                    # ❌ 裸捕获
    ...

pip install ruff

ruff check .                # 检查问题
ruff check --fix .          # 自动修复能修的
ruff format .               # 格式化代码

[tool.ruff]
line-length = 100
target-version = "py312"

[tool.ruff.lint]
select = [
    "E", "W",    # pycodestyle
    "F",         # pyflakes（未使用的变量、导入等）
    "I",         # isort（import 排序）
    "N",         # pep8-naming
    "UP",        # pyupgrade（自动用新语法）
    "B",         # bugbear（常见 bug 模式）
    "SIM",       # simplify（简化建议）
    "RUF",       # ruff 自己的规则
]
ignore = ["E501"]        # 行长交给 formatter 管

pip install pre-commit

repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.6.9              # ← 示例版本号，请用下面的命令拉取最新
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format

  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0              # ← 同上
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-added-large-files

pre-commit autoupdate    # 把所有 rev 更新到各仓库的最新 tag
pre-commit install       # 安装 git hook

d = get()                        # ❌ 什么都没说
active_users = fetch_users()     # ✅

from mymodule import *          # ❌
from mymodule import parse      # ✅

def f(*args, **kwargs): ...     # ❌ 除非真的需要
def f(name, age): ...           # ✅

# ❌ 静默失败，问题会在很远的地方以奇怪的形式冒出来
def get_config(key):
    return config.get(key)

# ✅ 缺配置就立刻报错
def get_config(key):
    if key not in config:
        raise KeyError(f"缺少配置项：{key}")
    return config[key]

优美优于丑陋
明确优于隐晦
简单优于复杂
复杂优于凌乱
扁平优于嵌套
稀疏优于稠密
可读性很重要
特殊情况不足以打破规则
但实用性胜过纯粹性
错误不应悄悄溜过
除非明确要求沉默
面对歧义，拒绝猜测
应该有一种——最好只有一种——显而易见的解决方式
虽然这方式一开始可能并不显而易见，除非你是荷兰人
现在做总比不做好
但不假思索地做，不如不做
如果实现难以解释，那是个坏主意
如果实现容易解释，那可能是个好主意
命名空间是个绝妙的主意——我们应该多用它

def calc( x,y ):
  Result=x*2+y
  if Result>10 :
    return  True
  else :
    return False

def p(d):
    r = []
    for i in d:
        if i['s'] == 1:
            if i['a'] > 18:
                if i['n'] != '':
                    r.append(i['n'].upper())
    return r

def calc(x, y):
    return x * 2 + y > 10

def get_active_adult_names(users: list[dict]) -> list[str]:
    """返回所有已激活的成年用户的名字（大写）。"""
    return [
        user["name"].upper()
        for user in users
        if user["status"] == ACTIVE and user["age"] > 18 and user["name"]
    ]

@dataclass
class User:
    name: str
    age: int
    status: Status

def get_active_adult_names(users: list[User]) -> list[str]:
    return [u.name.upper() for u in users
            if u.status is Status.ACTIVE and u.age > 18 and u.name]

uv add --dev ruff pre-commit

[tool.ruff]
line-length = 100
target-version = "py312"

[tool.ruff.lint]
select = ["E", "W", "F", "I", "N", "UP", "B", "SIM"]

repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.6.9
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format

pre-commit install

# 类型与转换
type(x)  isinstance(x, T)  issubclass(A, B)
int()  float()  str()  bool()  bytes()  complex()
list()  tuple()  dict()  set()  frozenset()

# 数学
abs()  round()  pow(a, b, mod)  divmod(a, b)
min()  max()  sum()
bin()  oct()  hex()      # 转进制字符串
ord("A")  chr(65)         # 字符 ↔ 码点

# 序列
len()  sorted()  reversed()  enumerate()  zip()
range()  slice()
all()  any()
filter(f, it)  map(f, it)
iter()  next()

# 对象
dir(x)              # 列出所有属性
vars(x)             # 返回 __dict__
getattr(x, "name", default)
setattr(x, "name", value)
hasattr(x, "name")
delattr(x, "name")
id(x)  hash(x)
callable(x)
repr(x)  format(x, spec)

# 输入输出
print()  input()  open()

# 执行
eval("1+1")         # ⚠️ 危险，永远不要对不可信输入用
exec(code)          # ⚠️ 同上
compile()

# 其他
help(x)
globals()  locals()
super()
property()  staticmethod()  classmethod()
breakpoint()

# ============ 变量与类型 ============
x = 10                      # int
y = 3.14                    # float
s = "文本"                   # str
b = True                    # bool
n = None                    # NoneType

# ============ 容器 ============
lst = [1, 2, 3]             # list   有序可变
tup = (1, 2, 3)             # tuple  有序不可变
dct = {"k": "v"}            # dict   键值映射
st  = {1, 2, 3}             # set    无序去重

# ============ 字符串 ============
f"{name} 今年 {age} 岁"
f"{pi:.2f}"  f"{n:,}"  f"{r:.1%}"  f"{x=}"
s.strip().lower().split(",")
",".join(items)
s.replace(old, new)
s.startswith(p)  s.endswith(p)
s[::-1]                     # 反转
r"原始\字符串"

# ============ 切片 ============
s[start:stop:step]          # 含头不含尾
s[:3]  s[3:]  s[::-1]  s[-3:]

# ============ 流程控制 ============
if cond:
    ...
elif other:
    ...
else:
    ...

x = a if cond else b        # 三元

for item in iterable:
    if skip: continue
    if stop: break
else:                       # 没 break 才执行
    ...

while cond:
    ...

match value:
    case pattern: ...
    case _: ...

# ============ 循环工具 ============
range(start, stop, step)
enumerate(items, start=1)
zip(a, b, strict=True)
reversed(items)  sorted(items, key=f, reverse=True)

# ============ 推导式 ============
[f(x) for x in it if cond]          # 列表
{k: v for k, v in it}               # 字典
{f(x) for x in it}                  # 集合
(f(x) for x in it)                  # 生成器

# ============ 函数 ============
def f(a, b=1, *args, key=None, **kwargs) -> int:
    """文档字符串。"""
    return a + b

lambda x: x * 2

f(*list_args, **dict_kwargs)        # 解包传参

# ============ 类 ============
class Child(Parent):
    class_attr = 0

    def __init__(self, x):
        super().__init__()
        self.x = x

    def method(self): ...

    @property
    def value(self): return self._v

    @classmethod
    def create(cls): return cls()

    @staticmethod
    def helper(): ...

@dataclass
class Point:
    x: float
    y: float = 0.0

# ============ 异常 ============
try:
    ...
except (ValueError, TypeError) as e:
    ...
except Exception:
    raise
else:
    ...
finally:
    ...

raise ValueError(f"具体信息：{value}")
raise NewError("...") from original

with open(path, encoding="utf-8") as f:
    ...

# ============ 生成器 ============
def gen():
    yield 1
    yield from other_iterable

# ============ 装饰器 ============
import functools

def deco(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@deco
def f(): ...

# ============ 类型注解 ============
def f(a: int, b: str = "") -> list[int]: ...
x: str | None = None
d: dict[str, list[int]] = {}

# ============ 文件 ============
from pathlib import Path

p = Path("dir") / "file.txt"
p.read_text(encoding="utf-8")
p.write_text(text, encoding="utf-8")
p.exists()  p.is_file()  p.name  p.stem  p.suffix  p.parent
list(p.parent.glob("*.txt"))
list(Path(".").rglob("*.py"))

# ============ 常用导入 ============
import json, re, os, sys, math, random, time
from pathlib import Path
from datetime import datetime, date, timedelta
from collections import Counter, defaultdict, deque
from dataclasses import dataclass, field
from functools import cache, wraps, partial
from itertools import chain, islice, groupby, product
from enum import Enum, auto
from typing import Any, Protocol, TypeVar

# ============ 脚本入口 ============
def main() -> None:
    ...

if __name__ == "__main__":
    main()