学点| Python 入门（三） ​

evens2 = []
for x in range(20):
    if x % 2 == 0:
        evens2.append(x)

# 基本形式：[表达式 for 变量 in 可迭代对象 if 条件]
evens = [x for x in range(20) if x % 2 == 0]
# [0, 2, 4, ..., 18]

squares = [x * x for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 双重循环
pairs = [(x, y) for x in range(3) for y in range(3)]

# 实战应用：清洗字符串
names = ["  Alice ", "BOB", " carol "]
clean = [n.strip().title() for n in names]
# ['Alice', 'Bob', 'Carol']

# 字典推导式：{键表达式: 值表达式 for ...}
squares_dict = {x: x * x for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 过滤 + 键值变换
scores = {"A": 90, "B": 60, "C": 40}
passed = {k: v for k, v in scores.items() if v >= 60}
# {'A': 90, 'B': 60}

# 集合推导式：自动去重
unique = {x % 3 for x in range(10)}
# {0, 1, 2}

words = ["apple", "banana", "apple"]
lens = {len(w) for w in words}
# {5, 6}

gen = (x * x for x in range(10))
print(gen)          # <generator object ...>，不是列表！
print(next(gen))    # 0，逐个产生
print(sum(gen))     # 剩余元素求和

# 大范围数据优先用生成器
total = sum(x for x in range(1_000_000))   # 全程不占内存

lst = [1, 2, 3]
it = iter(lst)          # iter() 获取迭代器
print(next(it))         # 1
print(next(it))         # 2
print(next(it))         # 3
# next(it) 再调 → StopIteration 异常

# for 循环的本质：自动调用 iter() 和 next()，遇到 StopIteration 就停
for x in lst:
    print(x)

class CountDown:
    def __init__(self, n):
        self.n = n

    def __iter__(self):
        return self

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

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

def count_down(n):
    while n > 0:
        yield n      # 每次迭代暂停并返回 n
        n -= 1

gen = count_down(3)
print(next(gen))   # 3，执行到第一个 yield 后暂停
print(next(gen))   # 2，从上次暂停处继续
print(next(gen))   # 1
# 再调用 → StopIteration

for x in count_down(3):   # 配合 for 自动处理 StopIteration
    print(x)

def fibonacci():
    a, b = 0, 1
    while True:
        yield a        # 无限序列，不占内存
        a, b = b, a + b

fib = fibonacci()
for _ in range(10):
    print(next(fib))   # 0 1 1 2 3 5 8 13 21 34

def fib_list(n):
    result = []
    a, b = 0, 1
    for _ in range(n):
        result.append(a)
        a, b = b, a + b
    return result      # 全部放进内存

def flatten(nested):
    for sub in nested:
        yield from sub    # 等价于：for x in sub: yield x

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

# 链式管道：yield from 拼接多个生成器
def combine(gen1, gen2):
    yield from gen1
    yield from gen2

def read_lines(file_path):
    with open(file_path, encoding="utf-8") as f:
        for line in f:
            yield line.strip()        # 逐行产出

def non_empty(lines):
    for line in lines:
        if line:
            yield line

# 惰性串联，任意环节都不占额外内存
clean = non_empty(read_lines("data.txt"))

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("调用前")
        result = func(*args, **kwargs)
        print("调用后")
        return result
    return wrapper

@my_decorator
def greet(name):
    return f"Hello, {name}!"

# @ 只是语法糖，等价于：greet = my_decorator(greet)
print(greet("Alice"))
# 调用前
# Hello, Alice!
# 调用后

from functools import wraps

def log(func):
    @wraps(func)          # 保留原函数元信息，就加这一行
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log
def add(a, b):
    """两数相加"""
    return a + b

print(add.__name__)   # add（不用 wraps 会变成 wrapper）
print(add.__doc__)    # 两数相加

from functools import wraps

def repeat(times):            # 第 1 层：收装饰器参数
    def decorator(func):      # 第 2 层：收函数
        @wraps(func)
        def wrapper(*args, **kwargs):   # 第 3 层：实际执行
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def hello():
    print("hi")

hello()   # hi hi hi

import time
from functools import wraps

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

@timer
def slow_task():
    time.sleep(0.1)

from functools import wraps

def memoize(func):
    cache = {}
    @wraps(func)
    def wrapper(n):
        if n not in cache:
            cache[n] = func(n)
        return cache[n]
    return wrapper

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

print(fib(10))   # 没有缓存的话，这个递归是指数级的

# 不用 with
f = open("data.txt")
try:
    content = f.read()
finally:
    f.close()

# 用 with（等价且更简洁）
with open("data.txt") as f:
    content = f.read()
# 离开 with 自动 close，即使中途异常

class Timer:
    def __enter__(self):
        print("开始计时")
        import time
        self.start = time.perf_counter()
        return self            # 返回值绑定给 as 变量

    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        print(f"耗时 {time.perf_counter() - self.start:.4f}s")
        # 返回 False/None → 异常继续抛出；返回 True → 吞掉异常
        return False

with Timer() as t:
    print("执行任务")
# 开始计时
# 执行任务
# 耗时 0.0000s

from contextlib import contextmanager

@contextmanager
def timer():
    import time
    print("开始")
    start = time.perf_counter()
    try:
        yield          # 这里执行 with 块内代码
    finally:
        print(f"结束，耗时 {time.perf_counter() - start:.4f}s")

with timer():
    print("任务进行中")

# 数据库连接：自动提交/回滚并关闭
import sqlite3

class Database:
    def __enter__(self):
        self.conn = sqlite3.connect("test.db")
        return self.conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            self.conn.rollback()
        else:
            self.conn.commit()
        self.conn.close()
        return False

with Database() as conn:
    conn.execute("CREATE TABLE IF NOT EXISTS t(id)")

# 线程锁：自动获取和释放
import threading
lock = threading.Lock()
with lock:
    pass   # 临界区代码

from contextlib import suppress, redirect_stdout

# suppress：静默忽略指定异常
with suppress(FileNotFoundError):
    open("不存在.txt")    # 不报错

# redirect_stdout：临时重定向输出
import io
buffer = io.StringIO()
with redirect_stdout(buffer):
    print("这段输出被捕获")
print(buffer.getvalue())

from pathlib import Path

p = Path("data/report.txt")
print(p.name)          # report.txt
print(p.stem)          # report
print(p.suffix)        # .txt
print(p.parent)        # data
print(p.exists())      # 是否存在

# 用 / 拼接路径，跨平台无忧
f = Path("data") / "report.txt"
f.write_text("hello", encoding="utf-8")
text = f.read_text(encoding="utf-8")

# 遍历目录
for file in Path(".").glob("*.py"):
    print(file)

import json

data = {"name": "Alice", "age": 25, "tags": ["py", "web"]}

json_str = json.dumps(data, ensure_ascii=False, indent=2)
# ensure_ascii=False 保留中文，indent 美化输出

obj = json.loads(json_str)          # 字符串 ↔ 对象

# 与文件交互：dump/load 直接读写文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
with open("data.json", encoding="utf-8") as f:
    obj = json.load(f)

import re

text = "我的电话是 138-1234-5678，邮箱 test@example.com"

phones = re.findall(r"\d{3}-\d{4}-\d{4}", text)   # 查找所有匹配

m = re.search(r"(\d{3})-(\d{4})-(\d{4})", text)   # 提取分组
if m:
    print(m.group(0))   # 完整匹配
    print(m.group(1))   # 第一个分组 138

new = re.sub(r"\d{3}-\d{4}-\d{4}", "***", text)   # 替换

is_email = re.match(r"^[\w.]+@[\w.]+\.\w+$", "test@example.com") is not None

from collections import Counter, defaultdict, namedtuple, deque

# Counter：计数神器
cnt = Counter("abracadabra")
print(cnt.most_common(2))   # [('a', 5), ('r', 2)]

# defaultdict：带默认值的字典，告别 KeyError
d = defaultdict(list)
d["a"].append(1)      # 键不存在自动建空 list，无需先初始化

# namedtuple：有名字的元组，轻量版"只读对象"
Point = namedtuple("Point", ["x", "y"])
p = Point(1, 2)
print(p.x, p.y)       # 1 2

# deque：双端队列，两端增删都是 O(1)
q = deque([1, 2, 3])
q.appendleft(0)
q.pop()

from datetime import datetime, date, timedelta

now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))   # 格式化

dt = datetime.strptime("2026-09-08", "%Y-%m-%d")   # 解析字符串

tomorrow = date.today() + timedelta(days=1)         # 时间运算
diff = datetime(2026, 12, 31) - datetime.now()
print(diff.days)              # 距年末还有多少天

import itertools

list(itertools.chain([1, 2], [3, 4]))        # 串联：[1, 2, 3, 4]

# islice：惰性切片，可以截取无限迭代器
for x in itertools.islice(itertools.count(), 5):
    print(x)              # 0 1 2 3 4

list(itertools.permutations("ABC", 2))   # 排列
list(itertools.combinations("ABC", 2))   # 组合

# groupby：分组（必须先按 key 排序！）
data = [("a", 1), ("a", 2), ("b", 3)]
for key, group in itertools.groupby(data, key=lambda x: x[0]):
    print(key, list(group))

list(itertools.product([1, 2], ["x", "y"]))   # 笛卡尔积