初五的小窝

序章

Mon, 29 Sep 2025 00:00:00 GMT

欢迎来到 Chuwu 的博客。

这个博客是使用 Astro 框架和基于 Fuwari 的 Charlotte主题构建的。

关于是否建立一个博客，其实我想了很久，最后还是说服了自己，希望这份热情能持续下去。

不知道我们能走多久呢……

感谢以下项目与项目开发者们：

MySQL学习笔记 (8)

Tue, 01 Sep 2026 00:00:00 GMT

:::note 基于 MySQL 26.7。数据操作 :::

INSERT INTO

INSERT INTO 语句用于向表中插入新记录。

INSERT INTO employee (emp_id, last_name, dept_no)
VALUES (201, '周七', 'D01');

一次插入多行：

INSERT INTO employee (emp_id, last_name, dept_no)
VALUES (202, '吴八', 'D01'),
       (203, '郑九', 'D02');

没有出现在列表里的列会使用默认值，或者是 NULL。

也可以把查询结果插入另一张表：

CREATE TABLE employee_archive (
    emp_id    INTEGER     NOT NULL,
    last_name VARCHAR(40) NOT NULL
);

INSERT INTO employee_archive (emp_id, last_name)
SELECT emp_id, last_name
FROM   employee
WHERE  hire_date < DATE '2020-01-01';

UPDATE

UPDATE 语句用于更新表中的记录。

UPDATE employee
SET    salary = salary * 1.05,
       dept_no = 'D02'
WHERE  emp_id = 101;

注意：省略 WHERE 会更新表中的所有行。

DELETE

DELETE 语句用于删除表中的记录。

DELETE FROM employee
WHERE  emp_id = 103;

注意：省略 WHERE 会删除表中的所有行。

TRUNCATE TABLE 也会清空表，和逐行 DELETE 不完全一样。

视图

视图是基于 SQL 语句的结果集的可视化表。

CREATE VIEW employee_public AS
SELECT emp_id, last_name, dept_no
FROM   employee;

SELECT * FROM employee_public
WHERE  dept_no = 'D01';

删除视图：

DROP VIEW employee_public;

WITH CHECK OPTION 要求通过视图插入或更新的行，仍然能被该视图查到。带聚合、DISTINCT 或多表的视图往往不能更新。

事务

事务把多条语句绑在一起：要么全部成功，要么全部取消。

CREATE TABLE account (
    id      INTEGER        NOT NULL,
    balance NUMERIC(12, 2) NOT NULL,
    CONSTRAINT account_pk PRIMARY KEY (id)
);

INSERT INTO account (id, balance)
VALUES (1, 500), (2, 200);

START TRANSACTION;

UPDATE account SET balance = balance - 100 WHERE id = 1;
UPDATE account SET balance = balance + 100 WHERE id = 2;

COMMIT;

START TRANSACTION：开始事务
COMMIT：提交
ROLLBACK：回滚，撤销还没提交的修改

许多客户端默认每条语句自动提交。需要多条语句一起提交时，先执行 START TRANSACTION。

参考

Python 札记 (8)

Mon, 31 Aug 2026 00:00:00 GMT

:::note 基于 Python 3。 :::

import

import math
print(math.sqrt(2))

from math import sqrt, pi
print(sqrt(2), pi)

import datetime as dt

模块是一个 .py 文件。import math 之后通过 math.sqrt 访问。from math import sqrt 将 sqrt 导入当前命名空间。as 用于指定别名。

同一个模块只执行顶层代码一次，结果缓存在 sys.modules 里。

from module import * 会导入模块中的全部名字，不建议使用。

命令行参数在 sys.argv：

import sys
print(sys.argv)  # [脚本路径, 后续参数...]

包与 init.py

含 __init__.py 的目录是包，可以 import pkg.mod（Packages）。__init__.py 可以为空。包内可用相对导入：from . import echo。

没有 __init__.py 的目录也可能作为 namespace package（PEP 420）。

sound/
    __init__.py
    effects/
        __init__.py
        echo.py

from sound.effects import echo 后使用 echo.surround()。包内子模块也是完整模块名：sound.effects.echo。

打包发布见 pyproject.toml。

if name == 'main'

脚本直接运行时，__name__ 为 '__main__'；被 import 时为模块名（如 'mymodule'）。常见写法：

def main():
    ...

if __name__ == "__main__":
    main()

import mymodule 不执行 main()；python mymodule.py 会执行。也可用 python -m pkg.module（-m 搜索）。

print 与 input

print 可以把对象写到文件：print(x, file=f)。input(prompt='') 从标准输入读一行，返回 str（去掉末尾换行），数值运算再 int() / float()。

pprint 用于格式化输出嵌套结构。json.dumps 用于输出 JSON。字符串格式化见 f-string / str.format。

open 读写与 with

open(file, mode='r', encoding=None, ... ) 返回 text 或 binary 流。文本模式默认编码依平台，通常显式传 encoding='utf-8'（UTF-8 模式在 3.7+ 可通过 -X utf8 或 PYTHONUTF8 影响默认行为）。

常用模式：'r' 读、'w' 写（清空）、'a' 追加、'x' 独占创建、'r+' 读写；加 'b' 为二进制（encoding 无效）。

with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n")
    f.writelines(["第二行\n", "第三行\n"])

with open("notes.txt", "r", encoding="utf-8") as f:
    whole = f.read()       # 整个文件 str
    # 或 for line in f:   # 逐行，省内存
    # 或 lines = f.readlines()

文件对象实现上下文管理器，离开 with 时会调用 close()。不使用 with 时需要调用 f.close()。

二进制：with open("img.bin", "rb") as f: data = f.read()。CSV、JSON 见 csv、json。

文本流常用方法见 io.IOBase：

方法	作用
`read` / `readline` / `readlines`	读
`write` / `writelines`	写
`seek(offset, whence=0)`	移动文件指针；`whence` 0 开头、1 当前、2 末尾
`tell()`	当前指针位置
`flush()`	刷缓冲区
`close()`	关闭（`with` 会自动调）

'w+' 写完后若要读回去，须先 seek(0)。

路径：pathlib 与 os.path

pathlib（3.4+）用面向对象路径替代字符串拼接。常用 Path：

from pathlib import Path

p = Path("data") / "logs" / "app.log"  # 跨平台拼接
p.parent.mkdir(parents=True, exist_ok=True)
p.write_text("hello\n", encoding="utf-8")
text = p.read_text(encoding="utf-8")
print(p.suffix, p.stem, p.resolve())

常用：exists()、is_file()、is_dir()、glob()、iterdir()、rename()、unlink()（删文件）。PurePath 不做 I/O，只算路径。

os.path 提供基于字符串的路径操作：os.path.join、dirname、basename、abspath、splitext。可与 pathlib 互转：Path(p)、str(path)。获取文件状态可使用 Path.stat() 或 os.stat。

当前工作目录：Path.cwd()；改变用 os.chdir（改变进程全局 cwd）。

os 常用

os 提供操作系统接口；与路径无关的常见调用：

os.environ：环境变量映射，可读可写；取值也可用 os.getenv。
os.listdir(path) / os.scandir(path)：列目录（后者更高效，可拿类型信息）。
os.mkdir / os.makedirs：建目录；makedirs(..., exist_ok=True) 类似 Path.mkdir。
os.walk(top)：递归遍历目录树（os.walk）。
os.replace：覆盖式重命名，跨平台比 rename 稳。
os.getpid()、os.cpu_count()：进程 id、CPU 数。

pathlib 与 os.environ 常一起使用。子进程见 subprocess。

class

Classes：使用 class 定义类。实例属性写在 self 上。方法的第一个参数约定为 self，调用时自动传入。

class Dog:
    kind = "canine"  # 类属性，共享

    def __init__(self, name):
        self.name = name  # 实例属性

    def bark(self):
        return f"{self.name}: woof!"

d = Dog("Rex")
print(d.bark(), Dog.kind)

__init__ 在实例创建后初始化，不是分配内存的构造器（那是 __new__）。__repr__ / __str__ 控制 repr(obj) 与 str(obj) / print(obj)。

继承：

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

class Cat(Animal):
    def __init__(self, name, indoor=True):
        super().__init__(name)  # 调父类 __init__
        self.indoor = indoor

super() 在单继承里找父类实现；多继承按 MRO（方法解析顺序）线性化。

数据 vs 方法：Python 不强制访问控制。约定 _name 表示内部使用；__name 触发名称改写（name mangling），改写后仍可通过 _类名__属性 访问。@property 把方法当属性读；@classmethod / @staticmethod 见 Class and Instance Variables。

类本身也是对象，可传参、可放入容器，见 Odds and Ends。

类型注解

PEP 484 函数注解、PEP 526 变量注解、PEP 585 内置泛型 list[int]、PEP 604 的 X | Y（3.10+）。运行时默认不强制检查；静态检查可用 mypy。

def greet(name: str, times: int = 1) -> str:
    return (name + "! ") * times

def sum_all(nums: list[float]) -> float:
    return sum(nums)

from typing import Optional

def find(items: list[str], key: str) -> Optional[str]:
    return key if key in items else None

常用 typing 名字：

Optional[T] — 等价于 T | None（3.10+ 也可写 Union 或 |）。
Union[A, B] / A | B — 多种类型之一。
list[int]、dict[str, int] — 泛型容器（3.9+ 内置泛型；旧代码见 List、Dict from typing）。
Callable[[int, str], bool] — 可调用签名。
Iterable[T]、Sequence[T] — 只读迭代 / 序列抽象。
TypedDict、Protocol、NamedTuple — 结构化数据。

变量也可注解：count: int = 0。类属性：class User: id: int; name: str。延迟解析字符串注解：from __future__ import annotations（3.7+；3.11+ 部分行为默认变化见 What's New）。

typing.get_type_hints() 可在运行时取注解。

venv：虚拟环境

venv 创建轻量隔离环境，各自拥有 python 与 pip（或 ensurepip 引导），包安装不污染系统 Python。

python -m venv .venv
# Windows PowerShell:
.\.venv\Scripts\Activate.ps1
# Unix / macOS:
source .venv/bin/activate

激活后 which python / where python 应指向 .venv。安装依赖：python -m pip install requests。冻结清单：python -m pip freeze > requirements.txt，再 python -m pip install -r requirements.txt。退出：deactivate。指定解释器版本：python3.12 -m venv .venv。

项目根常见 .venv/ 加入 .gitignore；依赖列表用 requirements.txt 或 pyproject.toml。

virtualenv 是第三方替代；conda 是另一套生态。教程：Virtual Environments and Packages。

标准库地图

Brief Tour of the Standard Library 与 stdlib index 是总入口。常用模块：

模块	一句话
os	操作系统接口：环境变量、进程 id、目录项、部分路径与权限原语。
sys	解释器相关：`argv`、`path`、`stdin/stdout/stderr`、版本与退出。
json	JSON 与 Python 对象互转（`dumps` / `loads` / `dump` / `load`），非 Python 专有类型需默认处理。
datetime	日期与时间：`date`、`time`、`datetime`、`timedelta`，时区见 `zoneinfo`（3.9+）。
pathlib	面向对象的文件系统路径与常见 I/O 快捷方法。
collections	专用容器：`Counter`、`deque`、`defaultdict`、`namedtuple` 等。
itertools	迭代器代数：无穷序列、组合、链式、分组（惰性、省内存）。
functools	高阶函数：`partial`、`reduce`、`lru_cache`、`wraps`（装饰器元数据）。
shutil	高层文件操作：`copyfile`、`move`、`rmtree`。
glob	`glob.glob('*.py')` 按通配符列文件。
argparse	命令行参数解析。

还常会用到：re、urllib / http、sqlite3、logging、unittest。

附录：import 形式速查

语句	效果
`import mod`	绑定 `mod` 模块对象
`import mod as m`	绑定别名 `m`
`from mod import a, b`	把 `a`、`b` 放入当前命名空间
`from mod import a as x`	别名导入
`from mod import *`	导入 `__all__` 或公开名字（不推荐）
`from pkg.sub import obj`	导入子模块或子模块中的名字
`from . import sibling`	包内相对导入
`importlib.import_module('mod')`	动态导入（`importlib`）

附录：open 模式与 pathlib 对照

需求	open	pathlib（3.11+ 部分 API 更早）
读文本	`open(p, encoding='utf-8').read()`	`Path(p).read_text(encoding='utf-8')`
写文本	`open(p, 'w', encoding='utf-8').write(s)`	`Path(p).write_text(s, encoding='utf-8')`
读字节	`open(p, 'rb').read()`	`Path(p).read_bytes()`
拼接路径	`os.path.join(a, b)`	`Path(a) / b`
是否存在	`os.path.exists(p)`	`Path(p).exists()`
列目录	`os.listdir(d)`	`Path(d).iterdir()`

附录：typing 常用符号（3.10+ 风格）

写法	含义
`x: int`	变量为 int
`def f() -> None`	无返回值
`list[str]`	字符串列表
`dict[str, int]`	键 str、值 int
`tuple[int, ...]`	整数可变长元组
`str \| None` / `Optional[str]`	可为 None
`int \| str`	联合类型
`Callable[[int], str]`	接受 int 返回 str 的可调用
`Literal["r", "w"]`	只能是列出的字面量
`TypeVar('T')`	泛型类型变量

运行时默认不按注解校验对象。

参考

官方文档（中文版）：

Modules — import、模块搜索路径、包、__init__.py、__name__
Input and Output — print、input、格式化、f-string、读写文件 intro
Classes — 属性、方法、继承、super、私有约定
Virtual Environments and Packages — venv 与 pip 工作流
Brief Tour of the Standard Library — 标准库导览
The import system — 导入语义、相对导入、namespace package
pathlib — Path / PurePath
os — 操作系统接口
os.path — 路径字符串函数
open() — 文件打开
io — 流基类
typing — 类型注解构造
venv — 创建虚拟环境
json — JSON
datetime — 日期时间
collections — 容器
itertools — 迭代工具
functools — 高阶函数工具
sys — 解释器
main — 主模块

PEP：

菜鸟教程：

MySQL学习笔记 (7)

Mon, 31 Aug 2026 00:00:00 GMT

:::note 基于 MySQL 26.7。JOIN :::

JOIN

JOIN 用于把两个或多个表的行结合起来。

最常见的是 INNER JOIN：只返回两个表中匹配的行。

SELECT e.last_name, d.dept_name
FROM   employee AS e
INNER  JOIN department AS d
       ON e.dept_no = d.dept_no;

连接条件写在 ON 后面。两表列名相同时，也可以用 USING (dept_no)。

列名冲突时要写成 表名.列名 或 别名.列名。

LEFT JOIN / RIGHT JOIN

LEFT JOIN 返回左表的全部行。右表没有匹配时，右表的列是 NULL。

SELECT e.last_name, d.dept_name
FROM   employee AS e
LEFT   JOIN department AS d
       ON e.dept_no = d.dept_no;

RIGHT JOIN 返回右表的全部行。左表没有匹配时，左表的列是 NULL。

OUTER 可以省略：LEFT OUTER JOIN 和 LEFT JOIN 相同。

CROSS JOIN

CROSS JOIN 返回两个表的笛卡尔积，也就是每行与另一表的每一行组合。

SELECT *
FROM employee
CROSS JOIN department;

CROSS JOIN 不写 ON。

UNION

UNION 用于合并两个 SELECT 的结果。

SELECT dept_no FROM employee
UNION
SELECT dept_no FROM department;

UNION：去掉重复行
UNION ALL：保留重复行

两边选出的列数要相同。

ORDER BY 写在整个 UNION 的最后。

还可以用 INTERSECT（交集）和 EXCEPT（差集）：

SELECT dept_no FROM employee
INTERSECT
SELECT dept_no FROM department;

SELECT dept_no FROM employee
EXCEPT
SELECT dept_no FROM department;

子查询

子查询是嵌套在另一条语句里的查询。

下面找出工资高于平均工资的员工：

SELECT last_name
FROM   employee
WHERE  salary > (SELECT AVG(salary) FROM employee);

EXISTS 判断子查询是否返回了行：

SELECT last_name
FROM   employee AS e
WHERE  EXISTS (
    SELECT *
    FROM   department AS d
    WHERE  d.dept_no = e.dept_no
    AND    d.director = '院长'
);

FROM 后面的子查询必须起别名：

SELECT dept_no, n
FROM (
    SELECT dept_no, COUNT(*) AS n
    FROM   employee
    GROUP  BY dept_no
) AS t
WHERE n >= 2;

参考

Python 札记 (7)

Sun, 30 Aug 2026 00:00:00 GMT

:::note 基于 Python 3。 :::

定义函数 def

def greet(name):
    """向 name 问好。"""
    return f"Hello, {name}!"

print(greet("Alice"))
print(greet.__name__)  # greet

def 用于定义函数。函数体在调用时执行。函数可以作为变量、参数和返回值。

函数可以 return 多个值（实际返回一个元组），也可以没有 return（等价于 return None）。Defining Functions

参数

位置参数按定义顺序传入，也可以按名字传：greet(name="Alice")。带默认值的可以省略（Defining Functions）：

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Alice"))
print(greet("Bob", greeting="Hi"))

默认值在定义时只求值一次。默认值不要使用可变对象（[]、{}），多次调用会共享同一个对象：

def good(a, items=None):
    if items is None:
        items = []
    items.append(a)
    return items

*args 收集多余的位置参数为元组，**kwargs 收集多余的关键字参数为字典：

def demo(a, *args, **kwargs):
    print(a, args, kwargs)

demo(1, 2, 3, x=4)  # 1 (2, 3) {'x': 4}
print(*(1, 2, 3))   # 等同于 print(1, 2, 3)

/ 之前的参数只能按位置传入（3.8+），* 之后的只能按关键字传入，例如 def f(pos, /, both, *, kwonly)。

return

return 结束当前函数调用，并返回表达式的值。没有表达式时返回 None。

def find_first(pred, items):
    for x in items:
        if pred(x):
            return x
    return None

lambda

lambda 创建匿名函数，语法为 lambda 参数: 表达式。函数体只能是一个表达式。较复杂的逻辑使用 def。

pairs = [(2, "b"), (1, "a"), (3, "c")]
pairs.sort(key=lambda p: p[0])

命名空间与作用域

变量按 LEGB 顺序查找：Local（当前函数）、Enclosing（外层函数）、Global（模块全局）、Built-in（内置名，如 len）。命名与绑定

x = "global"

def outer():
    x = "enclosing"

    def inner():
        x = "local"
        print(x)  # local

    inner()
    print(x)  # enclosing

outer()
print(x)  # global

函数定义时会捕获外层作用域（闭包）。内层函数可以读取外层变量；若要给外层非全局变量赋值，使用 nonlocal；给模块级变量赋值使用 global。

if / for / while / try 不会像函数那样创建局部作用域，块中赋值的变量在块外仍可使用。Naming and binding。

内置名在 builtins 模块：import builtins; dir(builtins)。

global 与 nonlocal

global 把本函数里的名字标成模块全局。nonlocal 标成最近一层外层函数里的名字（不能是全局）。

函数体内只要出现对某名字的赋值，整个函数都把它当局部。因此下面会 UnboundLocalError：

x = 1

def f():
    print(x)  # 想读全局 x
    x = 2     # 这一行让 x 在整个 f 里都是局部

要改全局就写 global x，或不要在函数里给同名赋值。

count = 0

def inc_global():
    global count
    count += 1

def make_counter():
    n = 0

    def inc():
        nonlocal n
        n += 1
        return n

    return inc

c = make_counter()
print(c(), c())  # 1, 2
inc_global()
print(count)     # 1

global 会让数据流难追踪；状态用参数、返回值或类封装。

try / except / else / finally

The try statement 与 Errors and Exceptions：

try:
    risky()
except ValueError as e:
    handle(e)
except (TypeError, OSError):
    recover()
else:
    # 仅当 try 块未抛出异常时执行
    on_success()
finally:
    # 总是执行（除非进程被杀死等）
    cleanup()

except：匹配异常类型（元组表示多个）。as e 绑定异常实例；在 Python 3 里，except 块结束后 e 会被删除，避免循环引用（PEP 3110）。
else：没有异常时运行，常把可能抛错的逻辑放在 try、成功路径放在 else，避免把 else 里的错误当成 except 能处理的同一类问题。
finally：用于释放资源；若有 return，finally 仍会在返回前执行。
顺序：try → 若异常则匹配的 except → 无异常则 else → 始终 finally。

raise 抛出异常：raise ValueError("msg")；raise 单独使用则重新抛出当前异常（常在 except 里记录后再抛）。

def parse_int(s):
    try:
        return int(s)
    except ValueError:
        raise ValueError(f"不是整数: {s!r}") from None  # 抑制异常链

Exception chaining：内层 raise ... from e 保留原因；from None 隐藏上下文。

用户自定义异常：继承 Exception（不要直接继承 BaseException，除非做系统退出类异常）。

class MyAppError(Exception):
    pass

assert 用于断言。使用 -O 优化时会被忽略，不适合作为常规错误处理。

内置异常

下列名字来自 Built-in Exceptions。

异常	典型触发场景
`Exception`	几乎所有用户可捕获异常的基类
`StopIteration`	迭代器没有更多元素（`next` / `for` 结束）
`StopAsyncIteration`	异步迭代器结束
`ArithmeticError`	算术错误分支的基类
`FloatingPointError`	浮点运算失败（极少见，依赖平台）
`OverflowError`	数值结果太大
`ZeroDivisionError`	除法或取模除零
`AssertionError`	`assert` 失败
`AttributeError`	属性不存在或无法设置
`EOFError`	`input()` 在无数据可读时（如 Ctrl+D）
`ImportError`	`import` 失败
`ModuleNotFoundError`	找不到模块（`ImportError` 子类）
`LookupError`	索引/键错误的基类
`IndexError`	序列下标越界
`KeyError`	字典键不存在
`MemoryError`	内存不足
`NameError`	未定义的名字
`UnboundLocalError`	局部名字在赋值前被引用
`OSError`	系统 / I/O 相关（`IOError` 是其别名）
`FileNotFoundError`	文件不存在
`PermissionError`	权限不足
`RecursionError`	超过最大递归深度
`ReferenceError`	弱引用对象已销毁（少见）
`RuntimeError`	一般不落在更具体类型时的运行时错误
`NotImplementedError`	抽象方法 / 待实现
`SyntaxError`	语法错误（编译期）
`IndentationError`	缩进错误
`TabError`	Tab 与空格混用
`SystemError`	解释器内部错误
`TypeError`	类型不对或参数个数不对
`ValueError`	类型对但值不合法（如 `int("abc")`）
`UnicodeError`	Unicode 编解码相关基类
`UnicodeDecodeError` / `UnicodeEncodeError`	解码 / 编码失败
`Warning`	警告类别基类（不是 `Exception` 同级习惯捕获对象）

一般不捕获 BaseException 下的 KeyboardInterrupt、SystemExit、GeneratorExit，除非在做框架级顶层处理。

with 与上下文管理器

with 语句用于管理资源：进入时 setup，离开时 teardown，即使发生异常也会清理。PEP 343 定义协议。

上下文管理器需实现：

__enter__(self)：进入 with 块前调用；返回值绑定到 as 后的变量（若无 as 则忽略返回值）。
__exit__(self, exc_type, exc_val, exc_tb)：离开 with 块时调用。若返回真值，会抑制当前异常（一般不这么做）；否则异常继续传播。

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

    def __enter__(self):
        print(f"<{self.name}>")
        return self

    def __exit__(self, exc_type, exc, tb):
        print(f"</{self.name}>")
        return False

with Tag("p") as t:
    print("body")

内置 open() 返回的文件对象、threading.Lock 等已实现该协议。自定义资源管理可用 contextlib.contextmanager 装饰生成器，或用 contextlib.AbstractContextManager。多个上下文管理器可写 with A() as a, B() as b:。

iter 与 next

迭代器实现迭代器协议：__iter__() 返回自身（或另一迭代器），该对象再提供 __next__()。内置 iter() 优先调用 __iter__()；若没有 __iter__ 但实现了从 0 开始的 __getitem__，仍可按序列方式迭代（见 iterator protocol）。自定义可迭代对象时，实现 __iter__ 即可。

next(iterator[, default]) 调用 iterator.__next__()。没有更多元素时，__next__() 抛出 StopIteration；若提供了 default，则返回 default 而不抛异常。

容器（如 list）本身通常不是迭代器，但可迭代（iterable）：__iter__() 返回一个新的迭代器。每次 for x in lst: 都会先 iter(lst) 再反复 next。

it = iter([10, 20, 30])
print(next(it))  # 10
print(next(it))  # 20
print(next(it, "没了"))  # 30
print(next(it, "没了"))  # 没了

for 循环在底层等价于：取迭代器 → 反复 next → 捕获 StopIteration 结束。实现 __iter__ 与 __next__：

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

生成器与 yield

生成器是一种迭代器，由含 yield 的函数或 yield from 表达式产生。调用生成器函数不会立刻执行函数体，而是返回一个生成器对象；每次 next() 或 for 循环驱动执行到下一个 yield，产出值并暂停。

def count_up_to(n):
    i = 1
    while i <= n:
        yield i
        i += 1

for x in count_up_to(3):
    print(x)  # 1, 2, 3

生成器表达式 (x * x for x in range(5)) 语法类似列表推导，但结果是生成器而非列表，适合大数据或流水线。Generator expressions。

yield from iterable 把产出委托给另一个可迭代对象，常用于扁平化嵌套生成器。要用 with 包一层生成器，需 contextlib.contextmanager；生成器本身不是上下文管理器。

装饰器

PEP 318 引入函数装饰器语法：@decorator 放在 def（或 class）前，等价于 func = decorator(func)。装饰器通常是接受 callable、返回 callable 的可调用对象。

def log_calls(fn):
    def wrapper(*args, **kwargs):
        print(f"calling {fn.__name__}")
        return fn(*args, **kwargs)
    return wrapper

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

add(1, 2)  # 先打印 calling add，再返回 3

被包装后 wrapper.__name__ 等元数据会丢；用 functools.wraps 拷回去：

import functools

def log_calls(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        print(f"calling {fn.__name__}")
        return fn(*args, **kwargs)
    return wrapper

带参装饰器：外层函数先接收装饰器参数，返回真正的装饰器。

def repeat(times):
    def decorator(fn):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = fn(*args, **kwargs)
            return result
        return wrapper
    return decorator

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

类也可以当装饰器（实现 __call__）。内置装饰器如 staticmethod、classmethod、property。装饰器栈从下往上应用：@a @b def f 等价于 f = a(b(f))。

附录：内置异常继承关系

Exception hierarchy。缩进表示子类。

基类	直接子类
`BaseException`	`SystemExit`, `KeyboardInterrupt`, `GeneratorExit`, `Exception`
`Exception`	`StopIteration`, `StopAsyncIteration`, `ArithmeticError`, `AssertionError`, `AttributeError`, `BufferError`, `EOFError`, `ImportError`, `LookupError`, `MemoryError`, `NameError`, `OSError`, `ReferenceError`, `RuntimeError`, `SyntaxError`, `SystemError`, `TypeError`, `ValueError`, `Warning`
`ArithmeticError`	`FloatingPointError`, `OverflowError`, `ZeroDivisionError`
`LookupError`	`IndexError`, `KeyError`
`OSError`	`BlockingIOError`, `ChildProcessError`, `ConnectionError`, `FileExistsError`, `FileNotFoundError`, `InterruptedError`, `IsADirectoryError`, `NotADirectoryError`, `PermissionError`, `ProcessLookupError`, `TimeoutError` …
`ConnectionError`	`BrokenPipeError`, `ConnectionAbortedError`, `ConnectionRefusedError`, `ConnectionResetError`
`ImportError`	`ModuleNotFoundError`
`NameError`	`UnboundLocalError`
`RuntimeError`	`NotImplementedError`, `RecursionError`
`SyntaxError`	`IndentationError` → `TabError`
`UnicodeError`	`UnicodeDecodeError`, `UnicodeEncodeError`, `UnicodeTranslateError`
`ValueError`	`UnicodeError` 等

except OSError 可捕 FileNotFoundError；except LookupError 可捕 IndexError 与 KeyError。

附录：函数参数汇总

写法	含义
`def f(a, b)`	位置或关键字
`def f(a, b=0)`	`b` 有默认值
`def f(a, /, b)`	`a` 仅位置（3.8+）
`def f(a, *, b)`	`b` 仅关键字
`def f(*args)`	多余位置 → 元组
`def f(**kwargs)`	多余关键字 → 字典
`def f(a, /, b, args, c=1, *kw)`	顺序：仅位置、`/`、位置或关键字、`args`、仅关键字、`*kwargs`

参考

官方文档（中文版）：

More Control Flow Tools — Defining Functions — 默认参数、关键字参数、*args / **kwargs、Docstring
More Control Flow Tools — Intermezzo: Coding Style — 命名与可读性
Errors and Exceptions — 异常处理、else / finally、raise、用户异常、异常链
Compound statements — Function definitions — 完整参数语法、lambda 不能替代 def 的全部能力
Compound statements — The try statement — try / except / else / finally 语义
Compound statements — The with statement — with 与 as
Data model — With Statement Context Managers — __enter__ / __exit__
Glossary — iterator / generator / iterable — 术语定义
Execution model — Naming and binding — LEGB、闭包
Simple statements — global / nonlocal / return / raise / yield
Built-in Exceptions — 异常列表与继承树
functools.wraps — 装饰器保留元数据
contextlib — 上下文管理器工具

PEP：

菜鸟教程：

MySQL学习笔记 (6)

Sun, 30 Aug 2026 00:00:00 GMT

:::note 基于 MySQL 26.7。聚合函数 :::

聚合函数

聚合函数对一组值进行计算，返回单个值。

函数	描述
`COUNT(*)`	行数
`COUNT(col)`	`col` 不是 NULL 的个数
`COUNT(DISTINCT col)`	去重后的个数
`SUM(expr)`	合计
`AVG(expr)`	平均值
`MIN(expr)`	最小值
`MAX(expr)`	最大值

SELECT COUNT(*)          AS n_emp,
       COUNT(manager_id) AS n_with_mgr,
       AVG(salary)       AS avg_sal
FROM employee;

没有 GROUP BY 时，整张表（经过 WHERE 之后）算作一组。

COUNT(phone) 只统计填了手机号的行；COUNT(*) 统计所有行。

GROUP BY

GROUP BY 用于结合聚合函数，按一个或多个列分组。

SELECT dept_no, COUNT(*) AS n, AVG(salary) AS avg_sal
FROM   employee
GROUP  BY dept_no;

SELECT 里没有用聚合函数的列，一般要出现在 GROUP BY 中。下面这样是不对的：按部门分组，却直接选出每个人的姓名。

SELECT dept_no, last_name, COUNT(*)
FROM employee
GROUP BY dept_no;

按多列分组：

GROUP BY dept_no, job_id

WHERE 在分组之前筛选行。分组之后的条件要用 HAVING。

HAVING

HAVING 用于筛选分组后的结果。

SELECT dept_no, COUNT(*) AS n
FROM   employee
WHERE  salary >= 3000
GROUP  BY dept_no
HAVING COUNT(*) >= 2
ORDER  BY n DESC;

HAVING 里可以使用聚合函数，WHERE 里不行。

NULL 和聚合

分组键是 NULL 的行会分到同一组。

某一组里 SUM 的值全是 NULL 时，结果是 NULL，不是 0。需要显示 0 时可以写成：

COALESCE(SUM(amount), 0)

参考

Python 札记 (6)

Sat, 29 Aug 2026 00:00:00 GMT

:::note 基于 Python 3。 :::

条件：if / elif / else

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 60:
    grade = "C"
else:
    grade = "F"
print(grade)

elif 可以没有或有多个，else 可有可无。空分支写 pass。

None、False、0、''、[]、{} 在条件里当假，其余一般为真。Truth Value Testing

if / for / while 中赋值的变量在代码块外仍然可以使用。函数具有独立的局部作用域。

比较与链式比较

比较运算符：== != < <= > >=，以及 is / is not（身份）、in / not in（成员）。可链式写：a < b <= c 等价于 a < b and b <= c，且 b 只算一次（Comparisons）。

三元表达式（条件表达式）

语法：value_if_true if condition else value_if_false。先计算 condition，再选择其中一个表达式：

status = "adult" if age >= 18 else "minor"

:= 可在表达式中赋值（PEP 572）：

words = ["a", "b", "c", "d"]
if (n := len(words)) > 3:
    print(n)

循环：while 与 for

while

条件为 True 时重复执行循环体。

n = 3
while n > 0:
    print(n)
    n -= 1
print("lift off")

for

for 语句依次取出元素赋给循环变量。列表、字符串、range 都可以。

words = ["Python", "is", "great"]
for w in words:
    print(w)

遍历 dict 时，默认迭代键；要键值用 .items()。

break、continue

break — 立刻跳出最内层 enclosing 循环。
continue — 跳过本次剩余 suite，进入下一轮迭代。

for x in range(10):
    if x % 2 == 0:
        continue
    if x > 5:
        break
    print(x)    # 1, 3, 5

循环的 else 子句

while / for 可以带 else：循环正常结束（没有被 break 中断）时执行 else 子句。

for n in [2, 4, 6, 8]:
    if n % 2 == 1:
        print("found odd")
        break
else:
    print("all even")

match / case（3.10+）

3.10 起可用 match / case 按值分支（PEP 636）。3.9 及更早没有这套语法。

code = 404
match code:
    case 200:
        msg = "OK"
    case 404:
        msg = "Not Found"
    case 500 | 502 | 503:
        msg = "Server Error"
    case _:
        msg = "Unknown"
print(msg)

_ 为通配模式。可解构序列、映射、对象属性。

range

range 是不可变整数序列，不占完整 list 内存。

range(stop)                    # 0 .. stop-1
range(start, stop)             # start .. stop-1
range(start, stop, step)       # step 不可为 0

print(list(range(5)))           # [0, 1, 2, 3, 4]
print(list(range(2, 8, 2)))     # [2, 4, 6]
print(list(range(0, -3, -1)))   # [0, -1, -2]

需要 list 时再 list(range(...))。

enumerate 与 zip

enumerate(iterable, start=0) — 产出 (index, item)：

for i, fruit in enumerate(["apple", "banana"], start=1):
    print(i, fruit)

zip — 并行迭代，每次得到一组值，长度取最短：

names = ["Alice", "Bob"]
scores = [90, 85]
for name, score in zip(names, scores):
    print(name, score)

长度不等时余下部分丢弃。要对齐最长一侧，用 itertools.zip_longest。

斐波那契

a, b = 0, 1
while a < 1000:
    print(a, end=", ")
    a, b = b, a + b
print()

固定项数可以用 for：

a, b = 0, 1
for _ in range(10):
    print(a, end=" ")
    a, b = b, a + b
print()

要存起来就往 list 里 append：

result = []
a, b = 0, 1
for _ in range(8):
    result.append(a)
    a, b = b, a + b
print(result)   # [0, 1, 1, 2, 3, 5, 8, 13]

列表推导式

List Comprehensions：[expression for item in iterable if condition]。

squares = [x * x for x in range(10)]
evens = [x for x in range(20) if x % 2 == 0]

嵌套循环从左到右等价于嵌套 for：

pairs = [(x, y) for x in range(3) for y in range(3) if x != y]

简单变换用推导式；副作用多或逻辑复杂时用普通 for。

保序去重

raw = [3, 1, 2, 3, 2, 1]
ordered_unique = list(dict.fromkeys(raw))
print(ordered_unique)   # [3, 1, 2]

集合与字典推导式

集合推导式 — {expr for item in iterable if cond}，花括号与 dict 字面量相同，但无冒号：

unique_lengths = {len(w) for w in ["hi", "hello", "hi"]}
print(unique_lengths)   # {2, 5}

字典推导式 — {key: value for ...}：

word_map = {w: len(w) for w in ["Python", "Java", "Go"]}
print(word_map)

生成器表达式

语法与 list 推导式类似，圆括号：(expr for item in iterable if cond)。产出 iterator，惰性求值：

total = sum(x * x for x in range(1000000))   # 外层函数吞掉括号
gen = (x * x for x in range(5))
print(next(gen))   # 0
print(list(gen))   # [1, 4, 9, 16] — 已消耗 0

单独写 (x for x in iterable) 是生成器表达式；仅 {}、[] 构成 dict / list 推导式。单层 (x for ...) 与调用写成 func(x for ...) 时，圆括号可省略一层（Generator expressions）。

推导式里的海象 := 见 PEP 572。

附录：控制流与推导式语法速查

构造	语法要点
条件	`if` / `elif` / `else` + 缩进 suite
三元	`a if cond else b`
match	`match subject:` + `case pattern:`（3.10+）
while	`while cond:`
for	`for target in iterable:`
break / continue	仅作用于最内层循环
循环 else	未 `break` 时执行
list 推导	`[e for x in it if c]`
set 推导	`{e for x in it if c}`
dict 推导	`{k: v for x in it if c}`
生成器表达式	`(e for x in it if c)`

常用内置（循环相关）

名称	作用
`range`	整数序列
`enumerate`	带索引迭代
`zip`	并行迭代
`len`	长度
`sum` / `min` / `max`	聚合（可接可迭代对象）
`sorted`	返回新排序 list
`reversed`	返回 reverse iterator

参考

官方文档（中文版）：

More Control Flow Tools — if、while、for、break/continue/else、匹配语句
First Steps Towards Programming — 斐波那契 while 示例
List Comprehensions — 列表推导与集合推导
Looping Techniques — enumerate、zip、dict 遍历
The for statement
The while statement
Generator expressions
range — 构造与步长
enumerate() / zip()
Truth Value Testing

PEP：

PEP 636 — Structural Pattern Matching — match / case

菜鸟教程：

MySQL学习笔记 (5)

Sat, 29 Aug 2026 00:00:00 GMT

:::note 基于 MySQL 26.7。比较运算符 :::

WHERE 子句

WHERE 用于筛选记录。

SELECT last_name, salary
FROM   employee
WHERE  salary >= 8000
AND    dept_no = 'D01';

运算符：

运算符	描述
`=`	等于
`<>`	不等于
`>`	大于
`<`	小于
`>=`	大于等于
`<=`	小于等于

AND、OR、NOT

AND：并且
OR：或者
NOT：非

NOT 优先于 AND，AND 优先于 OR。可以用括号改变顺序：

WHERE dept_no = 'D01' OR dept_no = 'D02' AND salary > 9000
-- D01 的全部，加上 D02 且工资大于 9000 的

WHERE (dept_no = 'D01' OR dept_no = 'D02') AND salary > 9000

IN

IN 用于在多个可能值中匹配：

WHERE dept_no IN ('D01', 'D02', 'D03')
WHERE dept_no NOT IN ('D01', 'D02')

BETWEEN

BETWEEN 选取介于两个值之间的数据，包含两端：

WHERE salary BETWEEN 5000 AND 12000

相当于 salary >= 5000 AND salary <= 12000。

LIKE

LIKE 用于在 WHERE 子句中搜索指定模式。

通配符	描述
`%`	替代 0 个或多个字符
`_`	替代一个字符

WHERE last_name LIKE '张%'
WHERE last_name LIKE '_明'
WHERE last_name NOT LIKE '%test%'

如果要匹配 % 或 _ 本身，使用 ESCAPE：

WHERE title LIKE '%10$%%' ESCAPE '$'

IS NULL

IS NULL 用于查找 NULL 值。

WHERE manager_id IS NULL
WHERE manager_id IS NOT NULL

注意：不能写成 manager_id = NULL。

CASE

CASE 根据条件返回不同的值：

SELECT last_name,
       CASE
           WHEN salary >= 12000 THEN 'high'
           WHEN salary >= 8000  THEN 'mid'
           ELSE 'low'
       END AS band
FROM employee;

也可以写成：

CASE salary WHEN 0 THEN 'zero' ELSE 'nonzero' END

没有 ELSE 时，不匹配的结果是 NULL。

参考

Python 札记 (5)

Fri, 28 Aug 2026 00:00:00 GMT

:::note 基于 Python 3。 :::

字典 dict

user = {"name": "Alice", "age": 25}
print(user["name"])
user["age"] = 26

dict 用键取值。键必须可哈希（hashable）：数字、字符串、元组可以；list、dict 不行。1、1.0、True 会当成同一个键。

创建

empty = {}
also_empty = dict()

user = {"name": "Alice", "age": 25}
from_pairs = dict([("a", 1), ("b", 2)])
from_zip = dict(zip(["a", "b"], [1, 2]))
from_keys = dict.fromkeys(["x", "y"], 0)   # 值默认为 None
from_kwargs = dict(red=1, blue=2)          # 键须为合法标识符

{} 是空 dict，不是空 set。空 set 必须写 set()。

自 3.7 起，dict 保持插入顺序；更新已有键的值不改变该键在顺序中的位置；删除后再插入的键排到末尾。

插入、查找、删除

操作	说明
`d[key] = value`	插入或更新
`value = d[key]`	取值；键不存在 → `KeyError`
`del d[key]`	删除；键不存在 → `KeyError`
`key in d` / `key not in d`	成员测试（测的是键）
`len(d)`	键值对个数
`list(d)`	键的 list（插入顺序）

scores = {"math": 90}
scores["english"] = 85
scores["math"] = 95          # 更新，顺序不变
print(scores["math"])        # 95
del scores["english"]
# print(scores["physics"])   # KeyError

get 与 setdefault

d.get(key[, default]) — 键存在则返回值，否则返回 default（省略时为 None），不抛 KeyError：

config = {"host": "localhost"}
port = config.get("port", 8080)
print(port)                  # 8080
print(config.get("host"))    # localhost

d.setdefault(key[, default]) — 键存在则返回值；不存在则插入 key: default 并返回 default（default 省略时为 None）：

cache = {}
cache.setdefault("count", 0)
cache["count"] += 1
print(cache)                 # {'count': 1}

统计词频、按 key 分组时，常用 setdefault 初始化默认值。缺省值若是新 list 这类可变对象，更常用 collections.defaultdict。

keys、values、items

三者返回视图对象（Dictionary view objects）：反映 dict 当前内容，不是静态快照。

d = {"a": 1, "b": 2}
print(list(d.keys()))        # ['a', 'b']
print(list(d.values()))      # [1, 2]
print(list(d.items()))       # [('a', 1), ('b', 2)]

for k, v in d.items():
    print(k, v)

视图支持 in、len、迭代。两个 dict.values() 视图互相比永远为 False（即使来自同一 dict）。

自 3.8 起 dict 及其视图可逆：reversed(d)、reversed(d.keys()) 等按插入顺序反序。

合并（3.9+）

defaults = {"theme": "light", "lang": "zh"}
user_pref = {"lang": "en"}
merged = defaults | user_pref    # 新 dict，右侧优先
print(merged)                    # {'theme': 'light', 'lang': 'en'}

defaults |= user_pref            # 原地更新 defaults

update、pop、copy

方法	作用
`d.update(...)`	批量更新，覆盖已有键
`d.pop(key[, default])`	删除并返回值
`d.popitem()`	删除并返回 LIFO 的 `(key, value)`
`d.clear()`	清空
`d.copy()`	浅拷贝

字典推导式

语法 {key_expr: value_expr for ... in iterable if ...}，与 list 推导式类似：

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

dict.fromkeys(iterable, value) 的 value 若用可变对象（如 []），所有键会共享同一对象；要各自独立应改用 dict 推导式。

集合 set

Set Types — set, frozenset：无序、元素不重复的可哈希对象集合。用途：成员测试、去重、交并差等。

创建与去重

empty = set()                # 不能写 {}
tags = {"python", "blog", "python"}   # {'python', 'blog'}
from_list = set([1, 2, 2, 3])         # {1, 2, 3}
from_str = set("hello")               # {'h', 'e', 'l', 'o'}

raw = [1, 2, 2, 3, 3, 3]
unique = list(set(raw))      # 顺序不保证
print(unique)

set 不支持索引、切片；元素无固定顺序，for 迭代顺序实现相关，不要依赖。

成员与长度

s = {1, 2, 3}
print(2 in s)      # True
print(len(s))      # 3

集合运算：运算符与方法

对 set ↔ set，运算符与对应方法等价；方法形式常可接受任意 iterable，运算符要求两侧为 set。

运算符	方法	含义
`s \| t`	`s.union(t, ...)`	并集
`s & t`	`s.intersection(t, ...)`	交集
`s - t`	`s.difference(t, ...)`	差集（在 s 不在 t）
`s ^ t`	`s.symmetric_difference(t)`	对称差（恰在一侧）
`s <= t`	`s.issubset(t)`	子集
`s >= t`	`s.issuperset(t)`	超集
	`s.isdisjoint(t)`	无交集为 True

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)   # {1, 2, 3, 4, 5}
print(a & b)   # {3}
print(a - b)   # {1, 2}
print(a ^ b)   # {1, 2, 4, 5}

原地更新（仅 set，非 frozenset）：

运算符	方法
`s \|= t`	`s.update(t, ...)`
`s &= t`	`s.intersection_update(t, ...)`
`s -= t`	`s.difference_update(t, ...)`
`s ^= t`	`s.symmetric_difference_update(t)`

skills = {"python", "git"}
skills |= {"docker", "python"}
print(skills)    # {'python', 'git', 'docker'}

增删元素（可变 set）

s = {1, 2}
s.add(3)
s.remove(2)      # 不存在 → KeyError
s.discard(99)    # 不存在不报错
x = s.pop()      # 任意移除一项；空 set → KeyError
s.clear()

set 与 frozenset 混合运算时，结果类型与左操作数一致。

frozenset

不可变、可哈希的集合。不能 add / remove，可作 dict 键或嵌套在 set 里：

inner = frozenset([1, 2])
outer = {inner, frozenset([3])}
print(inner in outer)   # True

# { {1, 2} }              # TypeError: set 不能作元素
registry = {frozenset("ab"): "pair"}

构造：frozenset()、frozenset(iterable)。支持与 set 相同的只读运算（union、intersection 等及对应运算符）。

容易踩的坑

{} 是 dict，set() 才是空 set。
dict 键必须可哈希 —— 数字、字符串、tuple（元素皆哈希）可以；list、dict 不行。
set 去重不保序 —— 要保留首次出现顺序：list(dict.fromkeys(seq))（3.7+ dict 保序），比 list(set(seq)) 稳。
集合元素必须可哈希 —— 同 dict 键；要存 list 可先 tuple(...)。

附录：dict 方法

Mapping Types — dict。

方法 / 操作	说明
`clear()`	清空
`copy()`	浅拷贝
`fromkeys(iterable, value=None)`	类方法，键来自 iterable
`get(key, default=None)`	安全取值
`items()`	`(key, value)` 视图
`keys()`	键视图
`values()`	值视图
`pop(key[, default])`	删除并返回
`popitem()`	LIFO 弹出一项
`setdefault(key, default=None)`	无则插入
`update([mapping,] **kwargs)`	批量更新
`d \| other` / `d \|= other`	合并（3.9+）
`reversed(d)`	逆序键（3.8+）

另有：d[key]、del d[key]、key in d、len(d)、iter(d)。

附录：set / frozenset 方法

方法	set	frozenset
`union` / `\|`	✓	✓
`intersection` / `&`	✓	✓
`difference` / `-`	✓	✓
`symmetric_difference` / `^`	✓	✓
`copy()`	✓	✓
`isdisjoint`	✓	✓
`issubset` / `<=` / `<`	✓	✓
`issuperset` / `>=` / `>`	✓	✓
`update` / `\|=` 等原地运算	✓	—
`add` / `remove` / `discard` / `pop` / `clear`	✓	—

另有：x in s、len(s)、for x in s。

参考

官方文档（中文版）：

Mapping Types — dict — 键值操作、get / setdefault、视图
Dictionary view objects
Set Types — set, frozenset — 运算符与方法
Dictionaries — 教程示例
Sets — 教程中的集合用法

菜鸟教程：

菜鸟教程 · 数据结构

MySQL学习笔记 (4)

Fri, 28 Aug 2026 00:00:00 GMT

:::note 基于 MySQL 26.7。SELECT :::

SELECT 语句

SELECT 语句用于从数据库中选取数据。

结果存放在结果表中，称为结果集。

语法：

SELECT column1, column2, ...
FROM table_name;

选取所有列：

SELECT * FROM table_name;

下面的语句从 employee 表选取姓名和入职日期：

SELECT last_name, hire_date
FROM   employee
WHERE  dept_no = 'D01'
ORDER  BY last_name;

列别名

可以用 AS 给列起别名：

SELECT emp_id,
       salary * 12 AS year_pay
FROM   employee;

AS 可以省略。

DISTINCT

SELECT DISTINCT 用于返回互不相同的值。

SELECT DISTINCT dept_no
FROM employee;

ORDER BY

ORDER BY 用于对结果集排序。

SELECT last_name, salary
FROM   employee
ORDER  BY salary DESC, last_name ASC;

ASC：升序（默认）
DESC：降序

可以按列名排序，也可以按多列排序。

注意：没有 ORDER BY 时，行的顺序不固定。

LIMIT

LIMIT 用于限制返回的行数。

SELECT last_name
FROM   employee
ORDER  BY emp_id
LIMIT  10;

跳过前面若干行再用 OFFSET：

SELECT last_name
FROM   employee
ORDER  BY emp_id
LIMIT  2 OFFSET 2;

参考

Python 札记 (4)

Thu, 27 Aug 2026 00:00:00 GMT

:::note 基于 Python 3。 :::

列表

fruits = ["apple", "banana", "cherry"]
print(fruits[0])       # apple
print(fruits[-1])      # cherry
print(fruits[1:3])     # ['banana', 'cherry']
print("banana" in fruits)
print(len(fruits))

list 有序、可变。下标从 0 起，负数从末尾数。切片左闭右开。

list、tuple、字符串都能做这些事（Common Sequence Operations）：in、+、*、[]、切片、len、min / max。

索引与切片

负索引 i 等价于 len(s) + i。切片 [i:j] 在 i >= j 时为空；省略 i 视为 0，省略 j 视为 len(s)。带步长 [i:j:k] 时，k 为负则方向反向，且 i、j 会被截断到合法范围。

nums = [0, 1, 2, 3, 4, 5]
print(nums[::2])    # [0, 2, 4]
print(nums[::-1])   # 新 list，原 list 不变
print(nums[4:1:-1]) # [4, 3, 2]

拼接与重复

s + t 与 s * n 都会产生新对象。对可变序列反复使用 += 拼接效率较低，可以使用 extend 或 str.join。

[[]] * 3 会使三个元素指向同一个内层 list，修改其中一个，其余也会变化。若需要三个独立的空 list，使用 [[] for _ in range(3)]。

count 与 index

序列还支持（部分类型对 start/stop 有限制）：

letters = ["a", "b", "c", "b"]
print(letters.count("b"))   # 2
print(letters.index("c"))   # 2
# letters.index("z")        # ValueError

列表的增删改

list 可原地增删改（Mutable Sequence Types）：

操作	效果
`s[i] = x`	替换下标 `i`
`del s[i]`	删除下标 `i`
`s[i:j] = t`	用可迭代对象 `t` 替换切片
`del s[i:j]`	删除切片（同 `s[i:j] = []`）
`s += t`	原地扩展，大致同 `s[len(s):len(s)] = t`
`s *= n`	原地重复 `n` 次

创建列表

empty = []
from_literal = [1, 2, 3]
from_iter = list("abc")          # ['a', 'b', 'c']
from_range = list(range(3))      # [0, 1, 2]

list(iterable) 若参数已是 list，会返回浅拷贝（类似 iterable[:]）。

常用方法

append(x) — 在末尾追加一个元素（不是展开可迭代对象）：

stack = [1, 2]
stack.append(3)       # [1, 2, 3]
stack.append([4, 5])  # [1, 2, 3, [4, 5]]

extend(iterable) — 把可迭代对象里的元素逐个追加：

a = [1, 2]
a.extend([3, 4])      # [1, 2, 3, 4]
# 等价于 a[len(a):len(a)] = [3, 4]

insert(index, x) — 在指定位置插入；等价于 s[index:index] = [x]。

pop([index=-1]) — 取出并删除元素，默认最后一个；空序列或越界会 IndexError。

remove(value) — 删除第一个等于 value 的项；找不到则 ValueError（按 == 比较）。

sort(*, key=None, reverse=False) — 原地排序，只使用 < 比较；返回 None。稳定排序。要新列表用内置 sorted(s)。

reverse() — 原地反转，返回 None。

copy() — 浅拷贝，等价于 s[:]（Python 3.3+）。

items = [3, 1, 4, 1, 5]
items.sort()
print(items)              # [1, 1, 3, 4, 5]
items.sort(reverse=True)
print(items)              # [5, 4, 3, 1, 1]

dup = items.copy()
dup.reverse()
print(dup)                # [1, 1, 3, 4, 5]

原地方法（sort、reverse、append 等）多数返回 None；不要写 x = lst.sort()。

浅拷贝与嵌套

copy() 与 [:] 只复制一层。内层可变对象仍共享：

matrix = [[1], [2]]
shadow = matrix.copy()
shadow[0].append(9)
print(matrix)   # [[1, 9], [2]] — 内层 list 共用

需要独立嵌套结构时，用 copy.deepcopy()。

元组 tuple：不可变序列

tuple 创建后不能通过 t[i] = x 改元素，也没有 append、sort 等原地方法。优势：可哈希（元素都哈希时）、占内存通常更小、语义上表达「固定字段组合」。

创建与「逗号才是 tuple」

empty = ()
singleton = (42,)      # 单元素必须带逗号
not_tuple = (42)     # 这是 int，括号只是分组
pair = 1, 2          # 逗号构成 tuple，括号可省略
from_iter = tuple([1, 2, 3])

真正构成 tuple 的是逗号，括号常可省略；空 tuple 必须是 ()，单元素时 (a,) 避免与表达式分组混淆。

不可变 ≠ 内容全不可变

tuple 不能换引用，但若元素是可变对象，对象内部仍可改：

t = ([1, 2], "ok")
t[0].append(3)   # 合法
print(t)         # ([1, 2, 3], 'ok')
# t[0] = []      # TypeError: 不能改 tuple 里的引用

含不可哈希元素的 tuple 不能作 dict 键或 set 元素。

哈希与 dict 键

不可变且元素均可哈希的 tuple 可 hash()，能当 dict 键：

point_index = {(0, 0): "origin", (1, 0): "east"}
print(point_index[(0, 0)])

解包

平行赋值

a, b, c = [1, 2, 3]
a, b = b, a          # 交换，无需临时变量

左右两侧个数必须一致，否则 ValueError。

带 * 的扩展解包

PEP 3132 / PEP 448：一个带 * 的目标收集「剩余」元素为 list：

first, *middle, last = [1, 2, 3, 4, 5]
print(first, middle, last)   # 1 [2, 3, 4] 5

head, *tail = "Python"
print(head, tail)            # P ['y', 't', 'h', 'o', 'n']

调用函数时，* 把列表展开成多个参数：print(*[1, 2, 3]) 相当于 print(1, 2, 3)。

忽略部分值

用 _ 作占位（约定俗成，不是语法）：

name, _, city = ("Alice", 28, "Seoul")

list 与 tuple 怎么选

场景	倾向
长度或内容会变	`list`
固定字段、函数多返回值	`tuple`
作 dict 键 / set 元素	元素可哈希的 `tuple`
大量只读数据	`tuple` 略省内存

需要「命名访问」时，官方推荐 collections.namedtuple 或 dataclass。

附录：list 可变序列方法

Mutable Sequence Types 与 Lists。list 另独有 sort()。

方法	说明	返回值
`append(value)`	末尾追加一项	`None`
`clear()`	删除全部（同 `del s[:]`）	`None`
`copy()`	浅拷贝（同 `s[:]`）	新 `list`
`extend(iterable)`	追加 iterable 中各项	`None`
`insert(index, value)`	在 index 处插入	`None`
`pop(index=-1)`	取出并删除 index 处项	被删元素
`remove(value)`	删除首个等于 value 的项	`None`
`reverse()`	原地反转	`None`
`sort(*, key=None, reverse=False)`	原地排序（仅 list）	`None`

序列共有 count(value)、index(value[, start[, stop]])。

tuple 可用操作小结

tuple 仅实现不可变序列操作：+、*、in、len、min、max、索引切片、count、index。无 append、sort 等。

参考

官方文档（中文版）：

Sequence Types — list, tuple, range — 共性操作、可变/不可变区分
Common Sequence Operations — 索引、切片、拼接、重复
Mutable Sequence Types — 原地赋值、删除、方法表
Lists — 构造、sort() 关键字参数
Tuples — 单元素逗号、括号与逗号
More on Lists
Tuples and Sequences

PEP：

菜鸟教程：

菜鸟教程 · 数据结构 — list / tuple 章节

MySQL学习笔记 (3)

Thu, 27 Aug 2026 00:00:00 GMT

:::note 基于 MySQL 26.7。CREATE TABLE :::

创建数据库

CREATE SCHEMA scoredb;

然后选中这个数据库：

USE scoredb;

以后可以用 scoredb.employee 这种写法指定库名和表名。

CREATE TABLE

CREATE TABLE 语句用于创建表。

CREATE TABLE department (
    dept_no   CHAR(3)      NOT NULL,
    dept_name VARCHAR(50)  NOT NULL,
    director  VARCHAR(50)  DEFAULT '院长',
    CONSTRAINT department_pk PRIMARY KEY (dept_no),
    CONSTRAINT department_name_un UNIQUE (dept_name)
);

CREATE TABLE employee (
    emp_id     INTEGER       NOT NULL,
    last_name  VARCHAR(40)   NOT NULL,
    first_name VARCHAR(40),
    dept_no    CHAR(3),
    hire_date  DATE,
    salary     NUMERIC(12, 2),
    manager_id INTEGER,
    is_active  BOOLEAN,
    job_id     VARCHAR(10),
    phone      VARCHAR(20),
    title      VARCHAR(50),
    CONSTRAINT employee_pk PRIMARY KEY (emp_id),
    CONSTRAINT emp_id_ck CHECK (emp_id > 0),
    CONSTRAINT employee_dept_fk
        FOREIGN KEY (dept_no) REFERENCES department (dept_no)
);

约束可以写在列后面，也可以写成 CONSTRAINT 名字 …。

先插入部门，再插入员工（因为员工的部门编号要在部门表里存在）：

INSERT INTO department (dept_no, dept_name, director)
VALUES ('D01', '教务处', '院长'),
       ('D02', '人事处', '院长'),
       ('D03', '财务处', '院长');

INSERT INTO employee (
    emp_id, last_name, first_name, dept_no, hire_date,
    salary, manager_id, is_active, job_id, phone, title
)
VALUES
    (101, '张三', '明', 'D01', DATE '2018-03-01',
     9000, NULL, TRUE, 'T01', '13800000001', '讲师'),
    (102, '李四', '华', 'D01', DATE '2019-07-15',
     12000, 101, TRUE, 'T01', NULL, '副教授'),
    (103, '王五', '强', 'D02', DATE '2021-01-10',
     7500, 101, TRUE, 'T02', '13800000003', '助教'),
    (104, '赵六', '芳', 'D02', DATE '2016-11-20',
     15000, NULL, FALSE, 'T02', '13800000004', '教授');

约束

约束用来限制表中的数据。

约束	作用
`NOT NULL`	列不能是 NULL
`UNIQUE`	列的值不能重复
`PRIMARY KEY`	主键：非空且唯一，一张表一个
`FOREIGN KEY`	外键：值必须在另一张表里存在
`CHECK`	值必须满足条件，例如 `emp_id > 0`
`DEFAULT`	插入时没给值就用默认值

外键列可以是 NULL（如果该列允许 NULL）。

ALTER TABLE

ALTER TABLE 语句用于修改表。

ALTER TABLE employee ADD COLUMN email VARCHAR(100);
ALTER TABLE employee ADD CONSTRAINT employee_email_un UNIQUE (email);
ALTER TABLE employee DROP INDEX employee_email_un;
ALTER TABLE employee DROP COLUMN email;
ALTER TABLE department ALTER COLUMN director SET DEFAULT '院长';
ALTER TABLE department ALTER COLUMN director DROP DEFAULT;

DROP TABLE

DROP TABLE 语句用于删除表。

DROP TABLE employee, department;

有外键时，先删除子表，或者先删除外键。

索引

CREATE INDEX 语句用于创建索引，加快查找。

CREATE INDEX employee_name_idx ON employee (last_name);

主键和 UNIQUE 已经带有索引。删除索引：

DROP INDEX employee_name_idx ON employee;

参考

Python 札记 (3)

Wed, 26 Aug 2026 00:00:00 GMT

:::note 基于 Python 3。 :::

数字类型总览

Python 3 内置三种数值类型（Numeric Types）：

类型	示例	说明
`int`	`0` `42` `-7`	任意精度整数，仅受内存限制
`float`	`3.14` `1e-3`	双精度浮点（实现依赖平台，通常 IEEE 754）
`complex`	`3+4j` `complex(2, -1)`	实部 + 虚部，虚部后缀 `j`

type(1)             # int
type(1.0)           # float
type(2+3j)          # complex
(3+4j).real         # 3.0
(3+4j).imag         # 4.0

bool 是 int 子类；算术里 True/False 当 1/0。精确小数用 decimal.Decimal、fractions.Fraction。

字面量与进制

int 字面量可带进制前缀（Integer literals）；数字里可用下划线分组（PEP 515）：1_000_000。

前缀	含义	示例
`0b` / `0B`	二进制	`0b1010` → 10
`0o` / `0O`	八进制	`0o12` → 10
`0x` / `0X`	十六进制	`0xFF` → 255

int("1010", 2)      # 10，任意进制字符串 → int
bin(10)             # '0b1010'
oct(10)             # '0o12'
hex(255)            # '0xff'

浮点可用科学计数：1.5e2 → 150.0。不要使用 0.1 + 0.2 == 0.3 判断浮点数是否相等；精确小数使用 decimal，或改用整数运算。

算术：//、%、**

Python 3 的 / 恒为真除，结果是 float。// 是地板除（向负无穷取整），% 与之配套。** 是幂。

7 / 3               # 2.333...，真除恒为 float
7 // 3              # 2，地板除
-7 // 3             # -3（向负无穷，不是向零）
7 % 3               # 1
-7 % 3              # 2，与 // 配套
2 ** 10             # 1024
pow(2, 8)           # 256，内置函数
pow(2, 8, 5)        # 1，模幂：2**8 % 5

divmod(a, b) 返回 (a // b, a % b) 一对。复数不支持 // 和 %。

混合类型：int 与 float 运算结果为 float；int 与 complex 得 complex。

math 模块（常用）

标准库 math 提供实数数学函数（多数要求 float，返回 float）。

import math
math.sqrt(2)          # 1.414...
math.pi               # 常量
math.e
math.floor(3.7)       # 3
math.ceil(3.2)        # 4
math.fabs(-3)         # 3.0
math.log(100, 10)     # 2.0，默认自然对数 math.log(x)
math.sin(math.pi / 2) # 1.0
math.hypot(3, 4)      # 5.0，sqrt(x*x + y*y)

math.inf、math.nan 对应浮点无穷与非数。nan 与任何值（包括自身）比较都不为真，用 math.isnan(x) 判断。

random 模块（常用）

random 提供伪随机数（非密码学安全；安全场景用 secrets）。另有分布采样如 gauss、uniform。

import random
random.random()       # [0.0, 1.0) 均匀 float
random.randint(1, 6)  # 闭区间 [1, 6] 整数
random.randrange(0, 10, 2)  # 0,2,4,6,8
random.choice(['a', 'b', 'c'])
items = [1, 2, 3, 4]
random.shuffle(items) # 原地打乱
random.sample(range(100), 5)  # 无重复抽样
random.seed(42)       # 可复现（调试）；生产环境慎固定种子

字符串：不可变文本序列

str 是 Unicode 码点序列（Text Sequence Type），不可变。引号成对即可：'、"、'''、"""；内容相同时等价。

s = "Python"
# s[0] = "p"        # TypeError
s = "python"        # 新对象

len(s) 返回字符个数。Unicode HOWTO

索引与切片

下标从 0 起；负下标从末尾计：-1 是最后一个。

s = "Python"
s[0]                # 'P'
s[-1]               # 'n'
s[1:4]              # 'yth'，左闭右开
s[:3]               # 'Pyt'
s[3:]               # 'hon'
s[::2]              # 'Pto'，步长 2
s[::-1]             # 'nohtyP'，反转

切片总是产生新 str，不修改原串。越界单下标 IndexError；切片边界可宽松（超出当作端点）。

转义与 raw 字符串

反斜杠 \ 引入转义（String and Bytes literals）：

转义	含义
`\n`	换行
`\t`	制表
`\\`	反斜杠
`\'` `\"`	引号
`\uXXXX`	Unicode 码点（16 位）
`\UXXXXXXXX`	Unicode 码点（32 位）

print("line1\nline2")
print(r"C:\new\test")   # raw：不处理转义，\\ 仍保留
# r"C:\new"  末尾 \ 可能引发语法问题，注意结尾反斜杠

路径、正则模式常用 r"..."；raw 字面量不能以奇数个 \ 结尾。

拼接与重复

"Hello, " + "World"  # 连接
"*" * 30              # 重复 30 次
# "a" + 1             # TypeError，需 str(1)

大列表拼串时，"".join(iterable) 往往比循环 + 高效。

格式化：%、str.format、f-string

% 与 str.format 仍可用；f-string（PEP 498，3.6+）把表达式写进字面量。

% 格式化（旧式）

"%.2f %s" % (3.14159, "pi")     # '3.14 pi'
"%d" % 42
"%(name)s" % {"name": "Alice"}

映射与 % 运算符见 printf-style String Formatting。

str.format

"{} + {} = {}".format(1, 2, 3)
"{1} {0}".format("world", "hello")
"{name}: {age}".format(name="Bob", age=20)
"{:.2f}".format(3.14159)
"{:>10}".format("右对齐")

格式规格见 Format String Syntax。

f-string（推荐）

name = "Alice"
age = 30
f"{name} is {age} years old"
f"{3.14159:.2f}"
f"{2 + 3}"
f"{name!r}"          # 等价于 repr(name)
f"{name.lower()=}"   # 3.8+ 调试

花括号内可以是表达式；不能嵌套同一引号未转义的花括号。3.12 起允许更自由的引号嵌套与多行（What's New in 3.12）。

常用 str 方法

split 与 join

"a,b,c".split(",")           # ['a', 'b', 'c']
"a  b  c".split()             # 默认按任意空白切
",".join(['a', 'b', 'c'])     # 'a,b,c'

strip 系列

"  hello  ".strip()           # 'hello'
"xxxhelloxxx".strip("x")      # 'hello'
"  hi".lstrip()
"hi  ".rstrip()

replace

"hello".replace("l", "L")     # 'heLLo'
"hello".replace("l", "L", 1)  # 只换 1 次

find / index

"python".find("th")           # 2，找不到 -1
"python".index("th")          # 2，找不到 ValueError
"python".count("o")           # 1

startswith / endswith

"hello.py".startswith("hello")
"hello.py".endswith(".py")
"hello.py".removesuffix(".py")  # 3.9+，'hello'

大小写与判断

"Hello".lower()
"Hello".upper()
"hello world".title()
"123".isdigit()
"abc".isalpha()
"  ".isspace()

encode

"中文".encode("utf-8")        # bytes
b"\xe4\xb8\xad".decode("utf-8")

encode/decode 可用 errors=（如 strict、replace、ignore）；编码名见 codecs。

字符串与 bytes

str 是文本，bytes 是字节序列（0–255）。网络、文件二进制读写要在二者间显式编解码，Python 3 不会自动混用。b"..." 字面量只能写 ASCII 或转义；bytes 下标得到的是 int。需要原地改用 bytearray。

text = "你好"
data = text.encode("utf-8")
text2 = data.decode("utf-8")
type(data)          # bytes
ord("中")           # 码点
chr(20013)          # '中'

附录：math 模块函数表

math — Mathematical functions：

函数 / 常量	说明
`pi`, `e`, `tau`, `inf`, `nan`	常数
`ceil(x)`, `floor(x)`, `trunc(x)`	取整方向不同
`fabs(x)`	绝对值（float）
`factorial(n)`	n!
`gcd(a, b)`, `lcm(a, b)`	最大公约数 / 最小公倍数（3.9+ lcm）
`sqrt(x)`, `pow(x, y)`	平方根 / x^y
`exp(x)`, `log(x[, base])`, `log10(x)`, `log2(x)`	指数与对数
`sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`	三角
`degrees(x)`, `radians(x)`	弧度 ↔ 角度
`hypot(x, y)`	sqrt(x²+y²)
`isfinite(x)`, `isinf(x)`, `isnan(x)`	浮点检测
`copysign(x, y)`, `fmod(x, y)`, `remainder(x, y)`	符号与余数

附录：random 模块函数表

random — Generate pseudo-random numbers：

函数	说明
`seed(a=None, version=2)`	初始化生成器
`random()`	[0.0, 1.0) float
`uniform(a, b)`	[a, b] 均匀 float
`randint(a, b)`	[a, b] 整数
`randrange(start, stop[, step])`	半开区间整数
`choice(seq)`	随机元素
`choices(population, weights=None, k=1)`	可重复抽样
`sample(population, k)`	无重复抽样
`shuffle(x)`	原地洗牌
`getrandbits(k)`	k 位随机整数
`gauss(mu, sigma)`, `normalvariate`, `expovariate` 等	常见分布

附录：str 常用方法表

Text Sequence Type — str：

方法	说明
`capitalize()`	首字母大写
`casefold()`	强大小写折叠（比较用）
`center(width[, fillchar])`	居中填充
`count(sub[, start[, end]])`	子串出现次数
`encode(encoding='utf-8', errors='strict')`	→ bytes
`endswith(suffix[, start[, end]])`	后缀判断
`expandtabs(tabsize=8)`	tab → 空格
`find(sub[, start[, end]])`	查找，失败 -1
`format(args, *kwargs)`	格式化
`format_map(mapping)`	映射格式化
`index(sub[, start[, end]])`	查找，失败 ValueError
`isalnum()`, `isalpha()`, `isdigit()`, `isspace()` …	字符类判断
`join(iterable)`	连接
`ljust`, `rjust`, `zfill`	对齐与填零
`lower()`, `upper()`, `swapcase()`, `title()`	大小写
`lstrip`, `rstrip`, `strip([chars])`	去空白或字符集
`replace(old, new[, count])`	替换
`removeprefix`, `removesuffix`	3.9+ 去前后缀
`split(sep=None, maxsplit=-1)`	拆分
`rsplit`, `splitlines`	右拆 / 按行
`startswith(prefix[, start[, end]])`	前缀判断
`partition(sep)`, `rpartition(sep)`	三分
`maketrans`, `translate`	字符映射

参考

官方文档（中文版）：

PEP：

菜鸟教程：

MySQL学习笔记 (2)

Wed, 26 Aug 2026 00:00:00 GMT

:::note 基于 MySQL 26.7。数据类型 :::

数据类型

创建表时要为每一列指定类型。常用类型：

类型	含义
`CHAR(n)`	定长字符串
`VARCHAR(n)`	变长字符串，最长 `n`
`INTEGER` / `INT`	整数
`SMALLINT`	较小整数
`BIGINT`	较大整数
`NUMERIC(p,s)` / `DECIMAL(p,s)`	精确小数
`REAL` / `DOUBLE PRECISION`	浮点数
`DATE`	日期
`TIME`	时间
`TIMESTAMP`	日期 + 时间
`BOOLEAN`	真 / 假

金额用 NUMERIC，例如 NUMERIC(12, 2) 表示最多 12 位数字，其中 2 位小数。

CHAR 不足长度时会补空格。空字符串 '' 和 NULL 不是一回事。

日期时间

日期和时间可以写成：

DATE '2026-09-01'
TIME '14:30:00'
TIMESTAMP '2026-09-01 14:30:00'

当前日期和时间：

CURRENT_DATE
CURRENT_TIME
CURRENT_TIMESTAMP

取出年份、月份：

EXTRACT(YEAR FROM hire_date)
EXTRACT(MONTH FROM hire_date)

布尔

BOOLEAN 的值是 TRUE、FALSE，也可以是 NULL。

SELECT * FROM employee WHERE is_active = TRUE;

CAST

CAST 用来转换类型：

CAST(emp_id AS CHAR(10))
CAST('2026-09-01' AS DATE)
CAST(3.14 AS NUMERIC(4, 2))

COALESCE(a, b, …) 返回第一个不是 NULL 的值。

字符串

连接字符串用 CONCAT：

SELECT CONCAT(last_name, ', ', first_name) AS full_name
FROM employee;

如果某一段是 NULL，整个 CONCAT 的结果也是 NULL。可以用 COALESCE 把 NULL 换成空字符串：

CONCAT(last_name, ', ', COALESCE(middle_name, ''))

常用函数：

函数	作用
`CHAR_LENGTH(s)`	字符个数
`SUBSTRING(s FROM start FOR len)`	截取，起点从 1 开始
`UPPER(s)` / `LOWER(s)`	大小写

SUBSTRING('abcdef' FROM 2 FOR 3)  -- 结果是 bcd

参考

Python 札记 (2)

Tue, 25 Aug 2026 00:00:00 GMT

:::note 基于 Python 3。 :::

变量与赋值

x = 10
x = "hello"   # 合法：同一个变量可以先后指向不同类型

Python 中的变量不需要声明类型。同一个变量可以先后指向不同类型的对象。= 将变量名指向一个对象。

a, b = 1, 2
a, b = b, a          # 交换
x = y = []           # 两个变量指向同一个列表，修改其中一个，另一个也会变化
x, y = [], []        # 两个独立的空列表

+=、-= 等是增强赋值运算符。对可变对象，增强赋值可能原地修改对象。

0 < x < 10 可以这么写，等价于 0 < x and x < 10。

可变与不可变

Built-in Types 里，对象分可变与不可变：

不可变（常见）	可变（常见）
`int` `float` `complex` `bool`	`list`
`str` `bytes`	`dict` `set`
`tuple`（容器本身不可变；元素若是 list 仍可改内容）	`bytearray`

不可变对象的内容不能原地修改；重新赋值会创建新对象。可变对象可以原地修改，通过其他变量也能看到变化。

s = "hello"
# s[0] = "H"        # TypeError：str 不可变
s = "Hello"         # 新字符串，变量 s 指向新对象

lst = [1, 2, 3]
lst.append(4)       # 原地改，id(lst) 不变
other = lst
other.append(5)
print(lst)          # [1, 2, 3, 4, 5] —— 同一对象

tuple 本身不可变，但其中的可变元素（如 list）仍可以修改内容：

t = ([1, 2], 3)
t[0].append(3)      # 合法
# t[0] = [9]        # TypeError：不能替换 tuple 的元素

六种内置类型（总览）

Python 常用内置类型如下（Built-in Types）：

类型	字面量示例	要点
数字 `int` / `float` / `complex`	`42` `3.14` `1+2j`	任意精度整数、浮点、复数
字符串 `str`	`'hi'` `"你好"`	不可变文本
列表 `list`	`[1, 2, 3]`	有序、可变
元组 `tuple`	`(1, 2)` `(1,)`	有序、不可变；单元素要逗号
字典 `dict`	`{'a': 1}`	键值对；空的是 `{}`
集合 `set`	`{1, 2, 3}`	元素不重复；空集合写 `set()`

此外还有 bool、NoneType（唯一值 None）、bytes / bytearray 等。

用内置函数探测类型：

type(42)            # <class 'int'>
type([]) is list    # True
isinstance(3.0, int)  # False
isinstance(True, int) # True

bool 是 int 的子类

True / False 是 bool 类型的两个实例；bool 继承自 int（Boolean Type）。

True == 1           # True
False == 0          # True
True + True         # 2
int(True)           # 1
isinstance(False, int)  # True
type(True) is int   # False —— 类型仍是 bool

因此 bool 可以参与算术。True is 1 为 False。空列表、空字符串在 if 中视为假，见 Truth Value Testing。

type 与 id

type(obj)：返回对象的类型（类）。
id(obj)：在 CPython 中通常是对象内存地址的整数，同一时刻同一对象 id 相同；对象被回收后 id 可能复用。

a = [1, 2]
b = a
c = [1, 2]
print(id(a) == id(b))   # True —— 同一对象
print(a is b)           # True
print(a is c)           # False —— 值相等，对象不同
print(a == c)           # True

is 比较对象身份（是否为同一个对象），== 比较值是否相等。判断是否为 None 应使用 x is None。小整数和字符串驻留可能导致 is 碰巧为真，这是实现细节。

:::caution 相等的整数或元组上 is 有时为真，那是 CPython 小整数缓存等实现细节。Comparisons 的语义是：is 只判断「是不是同一个对象」，相等用 ==。不要把 a is b 当成 a == b 的快捷写法。 :::

类型转换

显式转换

内置构造函数即转换函数（Built-in Functions）：

int("42")           # 42
int("1010", 2)      # 二进制字符串 → 10
float("3.14")
str(123)
list("abc")         # ['a', 'b', 'c']
tuple([1, 2])
bool(0)             # False；非零数为 True
bool("")            # False；非空串为 True

转换失败抛 ValueError；具体规则以各类型文档为准。另外还有 chr / ord / repr 等。不要用 eval 去「转换」不可信字符串。

隐式转换

混合数值运算时，Python 按 Numeric Types 拓宽类型。记忆口诀 bool → int → float → complex 只描述运算结果类型；bool 本身仍是 int 的子类（上一节）。不会把数字和字符串自动相加：

3 + 4.5             # 7.5，int 与 float 运算得 float
# "3" + 4           # TypeError
"3" + str(4)        # "34"，需显式转

布尔上下文（if / while / and / or）里会调用对象的真值测试，不是把 int 转成 bool 再存回变量。

del 语句

del 是语句，不是函数。常见用法：

x = 1
del x              # 删除变量，再访问 x 会 NameError
lst = [1, 2, 3]
del lst[0]         # 删下标 0，后面元素前移 → [2, 3]
del lst[1:]        # 删切片，lst 变成 [2]
d = {"a": 1}
del d["a"]         # 删键 "a"；键不存在则 KeyError

bytes

Binary Sequence Types：bytes 不可变，元素是 0–255 的整数；bytearray 可变。字面量 b"hello"（内容须为 ASCII 或转义）。文本 ↔ 二进制：str.encode(encoding) 得到 bytes，bytes.decode(encoding) 还原为 str，编码对不上会 UnicodeError。

b = b"hi"
b[0]                # 104，不是 'h'
bytearray(b"hi")[0] = 72
"你好".encode("utf-8")   # b'\xe4\xbd\xa0\xe5\xa5\xbd'
b"hi".decode("ascii")    # 'hi'

算术运算符

运算符	含义	备注
`+` `-` `*` `/`	加减乘真除	`/` 总是 float（3/2 → 1.5）
`//`	地板除	向负无穷取整；`-7//3` → `-3`
`%`	余数	与地板除配套：`a == (a//b)*b + (a%b)`
`**`	幂	右结合：`232` → `2(32)`
`+x` `-x`	一元正负

7 // 3              # 2
-7 // 3             # -3
7 % 3               # 1
2 ** 10             # 1024

对非数字类型，+ 可能被重载（如 str 拼接、list 合并）；其他算术若未定义则 TypeError。

比较运算符

链式比较：a < b <= c 等价于 a < b and b <= c，且 b 只求值一次。

运算符	含义
`==` `!=`	相等 / 不等
`<` `>` `<=` `>=`	大小（同类型或可比协议）

不同类型比较是否合法、如何比，以 Comparisons 与具体类型为准；不要依赖 Python 2 的旧规则。

赋值与增强赋值

形式	等价于（概念上）
`x = expr`	名字绑定
`x += y`	`x = x.__iadd__(y)` 或回退到 `x = x + y`
`x //= y` `x **= y` 等	同理

对不可变对象，+= 通常创建新对象再绑定；对 list 等，+= 往往原地扩展（extend）。若需要新列表，用 x = x + y 或切片复制，别假设所有类型行为一致。

海象运算符 :=（PEP 572）在表达式内赋值。

逻辑运算符

运算符	含义	短路
`and`	全真则取最后一值	左假则不再求右
`or`	有真则取第一个真值	左真则不再求右
`not`	逻辑非	返回 `True`/`False`

0 and 99            # 0（不是 False，是操作数本身）
"" or "default"     # "default"
not []              # True

逻辑运算返回的是操作数对象，不一定是 bool；条件语句里再按真值规则解释。

成员与身份运算符

运算符	含义
`in` / `not in`	成员测试（序列、映射、集合）
`is` / `is not`	是否同一对象（比较 `id`）

"a" in "abc"        # True
1 in {1, 2}         # True
x is None
x is not y

== 与 is 勿混：小整数缓存等实现细节不应依赖 a is b 代替 a == b。

位运算符

作用于整数二进制位（Bitwise operations）：

运算符	含义
`&` `\|` `^`	与、或、异或
`~`	按位取反
`<<` `>>`	左移、右移

0b1010 & 0b1100    # 0b1000 → 8
1 << 4              # 16

bool 参与位运算会先当 0/1 用。读标志位、权限掩码时会碰到。

运算符优先级

表达式求值顺序见 Operator precedence。记不住时加括号。官方从高到低（同级除 ** 外从左到右；** 右结合，且高于左侧的一元 +/-/~，所以 -2**2 是 -4）：

级别（高→低）	运算符
原子、订阅、调用	`(…)` `x[i]` `x()` `x.attr`
幂	`**`
一元算术 / 位	`+x` `-x` `~x`
乘除模	`*` `@` `/` `//` `%`
加减	`+` `-`
移位	`<<` `>>`
位与	`&`
位异或	`^`
位或	`\|`
比较、成员、身份	`==` `in` `is` 等
逻辑非	`not x`
逻辑与	`and`
逻辑或	`or`
条件表达式	`x if c else y`
lambda	`lambda`
海象	`:=`

2 + 3 * 4           # 14，不是 20
(not False) and True
2 ** 3 ** 2         # 512，即 2 ** (3 ** 2)

附录：内置类型速查

函数	作用
`type(x)`	类型
`isinstance(x, cls)`	是否该类型（含子类）
`id(x)`	对象标识
`len(x)`	长度（有 `__len__` 的对象）
`hash(x)`	哈希值（可哈希对象）

参数形式以 Built-in Functions 为准。另见 round() abs() divmod()。eval 会执行代码，不要对不可信输入使用。

常见构造函数：| 函数 | 作用 | | --- | --- | | int float complex | 数值 | | str repr ascii | 文本 / 可打印表示 | | chr / ord | 码点 ↔ 单字符 | | bin oct hex | 整数 → 带前缀的进制字符串 | | list tuple set frozenset | 从可迭代对象构造 | | dict | 从键值对可迭代对象或关键字参数构造 | | bytes bytearray memoryview | 二进制视图 | | bool | 真值测试 |

附录：运算符一览

类别	运算符
算术	`+` `-` `` `/` `//` `%` `*` `@`（矩阵乘，NumPy 等）
比较	`==` `!=` `>` `<` `>=` `<=`
赋值	`=` `+=` `-=` … `:=`
逻辑	`and` `or` `not`
位	`&` `\|` `^` `~` `<<` `>>`
成员	`in` `not in`
身份	`is` `is not`

参考

官方文档（中文版）：

An Informal Introduction to Python — 数字、字符串入门示例
Built-in Types — 类型分类、可变/不可变、真值测试
Built-in Functions — int / float / str / bool 等
Operator precedence
Assignment statements
Comparisons
Truth Value Testing
The del statement
Binary Sequence Types

PEP：

PEP 572 — Assignment Expressions

菜鸟教程：

MySQL学习笔记 (1)

Tue, 25 Aug 2026 00:00:00 GMT

:::note 基于 MySQL 26.7。参考手册 :::

SQL 是什么

SQL 指结构化查询语言，全称 Structured Query Language。

SQL 用来访问和处理数据库。
SQL 可以查询、插入、更新和删除数据。
SQL 可以创建数据库和表。
SQL 由 ANSI / ISO 标准化。现行标准是 ISO/IEC 9075（SQL:2023）。

本机是 MySQL Community Server 26.7.0。版本号是日历制：年.月.补丁。版本说明

不同数据库对 SQL 的支持不完全一样，但 SELECT、INSERT、UPDATE、DELETE、CREATE TABLE 这些命令用法相近。

SQL 能做什么

从数据库取回数据
在数据库中插入新的记录
更新数据库中的数据
从数据库删除记录
创建新数据库
在数据库中创建新表
在数据库中创建视图
设置表的权限

RDBMS

RDBMS 指关系型数据库管理系统（Relational Database Management System）。

数据存放在表里。表由列和行组成：一列是一个字段，一行是一条记录。

MySQL、PostgreSQL、SQLite 都属于 RDBMS。

SQL 语句

大部分工作都由 SQL 语句完成。语句通常以分号结束。

下面的语句从 employee 表选取 last_name 和 hire_date 列：

SELECT last_name, hire_date
FROM   employee
WHERE  dept_no = 'D01';

SQL 对大小写不敏感：SELECT 与 select 相同。

字符串用单引号。字符串里的单引号要写两个：

SELECT 'O''Brien';

表名、列名建议用小写字母、数字和下划线，不要用空格。

一些最重要的 SQL 命令

SELECT - 从数据库中提取数据
UPDATE - 更新数据库中的数据
DELETE - 从数据库中删除数据
INSERT INTO - 向数据库中插入新数据
CREATE SCHEMA - 创建新数据库
CREATE TABLE - 创建新表
ALTER TABLE - 修改表
DROP TABLE - 删除表
CREATE INDEX - 创建索引
DROP INDEX - 删除索引

按功能也可以分成：

DDL（数据定义）：CREATE / ALTER / DROP
DML（数据操纵）：SELECT / INSERT / UPDATE / DELETE
DCL（数据控制）：GRANT / REVOKE
事务：START TRANSACTION / COMMIT / ROLLBACK

术语

数据：库里存储的基本对象。
数据库（DB）：有组织、可共享的数据集合。
数据库管理系统（DBMS）：管理数据库的软件，例如 MySQL。
数据库系统（DBS）：数据库、DBMS、应用程序和数据库管理员合在一起。

关系模型	库里常说	含义
关系	表	列加上行
属性	列 / 字段	一列的名字和类型
元组	行 / 记录	一行上的一组值
分量	字段值	某一格里的值
域	取值范围	这一列允许哪些值

主键：用来标识一行，不能重复，也不能是 NULL。
外键：本表的值必须在另一表的主键（或唯一键）里出现，用来关联两表。
复合键：多列合在一起当一个键。
索引：加快查找的辅助结构。
冗余：同一事实存多份，更新时容易不一致。
实体完整性：主键非空、不重复。
参照完整性：外键不能指向不存在的键。

E-R 图

E-R 图用来画实体和它们之间的联系，再对应到表。

实体集：矩形
属性：椭圆
联系：菱形，边上标注 1:1、1:n、m:n

例如：学生、课程、教师、院系。多对多关系用一张单独的表来存放。

逻辑模型还有层次、网状、关系三种。关系数据库用二维表表示实体和联系：

表头是列名，一行是一条记录，格子里的值必须符合该列的类型。

注释

-- 单行注释（-- 后面要有空格）
SELECT 1;  -- 行尾注释

/* 多行注释 */

NULL

NULL 表示缺少值，不是 0，也不是空字符串 ''。

判断是否为 NULL，要用 IS NULL / IS NOT NULL：

SELECT * FROM employee WHERE salary IS NULL;
SELECT * FROM employee WHERE salary IS NOT NULL;

注意：WHERE salary = NULL 不会找出空值。

参考

Python 札记 (1)

Mon, 24 Aug 2026 00:00:00 GMT

:::note 基于 Python 3。 :::

解释器

在终端输入 python3（Windows 常用 py）进入交互式编程，提示符为 >>>：

>>> print("Hello, Python!")
Hello, Python!

退出使用 quit()。Unix 上也可用 Ctrl+D，Windows 上可用 Ctrl+Z。

将代码保存为 hello.py 后执行：

python3 hello.py

还可以使用 python -c、python -m。以 python 文件.py 运行时，文件开头的 #!/usr/bin/env python3 会被忽略。[^shebang]

详见 Using the Python Interpreter。

print

print("Hello, Python!")
print(1, 2, 3, sep="@")  # 1@2@3
print("a", end=" ")
print("b")               # a b

print 默认以空格分隔参数，并以换行结尾。sep 指定分隔符，end 指定结尾。print()

input("提示") 读取一行输入，返回字符串。

缩进

if True:
    print("True")
else:
    print("False")

Python 使用缩进表示代码块，不使用 {}。PEP 8 建议使用 4 个空格，不要与 Tab 混用，否则会触发 TabError。缩进不一致会触发 IndentationError。

if、for、def 等语句以冒号结尾，其后缩进的语句构成一个代码块。空代码块使用 pass。

多行

圆括号、方括号、花括号内可以直接换行：

total = [
    "item_one",
    "item_two",
    "item_three",
]

行末也可以使用 \ 续行。

注释

# 整行注释
print("Hello, Python!")  # 行尾注释

# 之后到行末为注释。字符串中的 # 不是注释。[^comment]

三引号 ''' / """ 用来表示字符串。单独出现的三引号字符串常被用作多行注释，但不能嵌套。

def add(a, b):
    """返回两数之和。"""
    return a + b

print(add.__doc__)

函数、模块或类的体中第一条语句如果是字符串，该字符串会保存到 __doc__，称为文档字符串。PEP 257 建议使用 """。

编码

默认情况下，Python 3 源文件以 UTF-8 编码，可以直接使用中文：

print("你好")

通常无需编写编码声明。若要指定其他编码，声明必须单独占一行，位于文件第一行；若第一行是 #!，则放在第二行（PEP 263）：

# -*- coding: utf-8 -*-

标识符

age = 25
user_name = "Alice"

第一个字符必须是字母或下划线，其余可以是字母、数字或下划线。标识符区分大小写，不能使用保留关键字（如 class、if）。Python 3 允许使用中文、π 等 Unicode 字符。可用 keyword.iskeyword() 判断是否为关键字。[^kw]

PEP 8：变量和函数使用 snake_case，类名使用 PascalCase。单下划线开头（如 _total）通常表示内部使用；全大写（如 MAX_SIZE）通常表示常量。双下划线开头会触发名称改写。

附录：保留关键字

当前版本的关键字列表：

import keyword
print(keyword.kwlist)

类别	关键字
值	`True` `False` `None`
逻辑	`and` `or` `not` `is` `in`
条件	`if` `elif` `else`
循环	`for` `while` `break` `continue`
异常	`try` `except` `finally` `raise` `assert`
函数	`def` `return` `lambda` `yield` `pass`
类	`class` `del`
模块	`import` `from` `as`
作用域	`global` `nonlocal`
异步	`async` `await`
资源	`with`

3.9 起 match / case / type 是 soft keyword，只在特定语法位置保留。

del 既是关键字，也是删除语句。

参考

官方文档（中文版）：

PEP：

菜鸟教程：

[^shebang]: Unix 可执行脚本依赖 shebang；Windows 主要靠文件关联和 py 启动器。 [^kw]: 硬关键字当变量名是 SyntaxError。 [^comment]: 词法分析里注释从 # 到物理行结束，不含字符串内的井号。

Hello 2026！

Wed, 31 Dec 2025 00:00:00 GMT

过去的一年对我来说还是跌宕起伏。

心里憋了很多话却说不出口。

脑中苦乐参半，眼睛也看不见前后的路途，未知是好事吗？

总是期待着有人来抚平创伤，却把当下也都丢掉了。

总之，2026年我会继续努力，努力成为一个更好的人。

希望大家都好!

爱你，也爱自己。

:::tip 下面是原图 :::

CAN 通信协议

Mon, 03 Nov 2025 00:00:00 GMT

CAN Protocols - BOSCH (控制器局域网络协议)

CAN 通信, 全称: 控制器局域网 (Controller Area Network), 是一种功能丰富的车用总线标准, 有效支持分布式控制系统的串行通信网络.
CAN 数据使用帧结构进行传输.
CAN 的物理层: CAN-H, CAN-L, 一般是差分信号, 根据两根线上的电位差来判断总线电平, 总线电平分为显性电平和隐性电平, 二者必居其一, 发送方通过使总线电平发生变化, 将消息发送给接收方.
CAN 总线两端有两个 $120\Omega$ 的终端电阻, 用作阻抗匹配, 抑制信号反射.
CAN 非破坏性仲裁机制（基于标识符优先级）: 多个同时的回复不会造成乱码, 高优先级消息通过, 低优先级消息被忽略.
CAN 过滤器: 对特定信息进行过滤, 只接收指定的有效信息.

特性

多主控制与仲裁:
- 所有节点都可发送 (多主).
- 非破坏性仲裁: 通过 标识符（ID）优先级 决定优先级. 高优先级消息通过, 低优先级消息主动退出并转为接收.
系统柔性与扩展性:
- 无地址信息: 报文基于内容 (ID) 发送, 而非地址.
- 易于扩展: 新增节点不影响现有节点软硬件及应用层.
高性能传输:
- 通信速率快: 最高可达 $1\text{ Mbps}$ (短距离).
- 通信距离远: 速率降低时, 最远可达 $10\text{ KM}$.
强大的错误处理:
- 具备 错误检测、通知和恢复 机制.
- 自动重发: 发送单元检测到错误后, 会强制终止并自动重新发送消息, 直到成功.
故障隔离 (封闭):
- 故障封闭功能: 能区分暂时错误和持续性故障.
- 对于持续性故障, 能将引起故障的单元 从总线上隔离, 避免影响整个网络.
连接节点数量:
- 连接节点多: 理论上无限制, 但实际数量受限于通信速率、总线延迟和电气负载.

物理层特征与时序同步

CAN 协议经过 ISO 标准化后有两个标准: ISO11898 标准和 ISO11519-2 标准. 其中 ISO11898 是针对通信速率为 $125\text{ Kbps}\sim 1\text{ Mbps}$ 的高速通信标准, 而 ISO11519-2 是针对通信速率为 $125\text{ Kbps}$ 以下的低速通信标准. 这里使用 ISO11898 标准, $450\text{ Kbps}$ 的通信速率.

位时序 (Bit Timing)

位时序是实现 CAN 网络同步的核心机制. 它将一个位时间 (Bit Time) 分解为 4 个时间段, 每个时间段由若干个时间量子 (Time Quantum, Tq) 构成. 通过设定位时序, 可以实现多个单元同时采样, 并任意设定采样点. 由发送单元在非同步的情况下发送的每秒钟的位数称为位速率 (Bit Rate).

一个位时间由以下 4 个段组成:

段名称	作用说明	Tq 数范围
同步段 (SS: Synchronization Segment):	多个连接在总线上的单元通过此段实现时序调整, 同步进行接收和发送的工作. 由隐性到显性或由显性到隐性电平的边沿最好出现在此段中.	恒定为 1Tq
传播时间段 (PTS: Propagation Time Segment):	用于吸收网络上的物理延迟 (包括发送单元的输出延迟、总线上传播延迟、接收单元的输入延迟) 的段.	1~8Tq
相位缓冲段 1 (PBS1: Phase Buffer Segment 1):	当信号边沿不能被包含于 SS 段中时, 可在此段进行补偿.	1~8Tq
相位缓冲段 2 (PBS2: Phase Buffer Segment 2):	用于吸收细微的时钟误差. 可通过对该段加减 SJW (再同步补偿宽度) 来吸收误差.	2~8Tq

关键概念:

再同步补偿宽度 (SJW: reSynchronization Jump Width): SJW 是用于补偿因时钟频率偏差、传送延迟等导致的同步误差的最大值. 其 Tq 数范围为 1~4Tq
采样点 (Sampling Point): 位于 PBS1 结束处. 它是指读取总线电平, 并将读到的电平作为位值的点.

:::tip 上图的采样点, 是指读取总线电平, 并将读到的电平作为位值的点. 位置在 PBS1 结束处. 根据这个位时序, 可以计算 CAN 通信的波特率. :::

协议核心机制

CAN 总线仲裁机制

CAN 总线仲裁机制是一种基于标识符优先级的非破坏性仲裁机制, 确保高优先级消息能够优先使用总线.

1. 仲裁基础

多主控制: 当总线处于空闲状态时, 任何连接到总线的单元 (节点) 都可以尝试开始发送消息.
非破坏性: 仲裁过程不会中断或破坏总线上正在进行的传输, 低优先级的消息会主动退出, 高优先级的消息不受影响地继续传输.

2. 优先级确定

基于标识符 (ID): 消息的标识符优先级由其在仲裁段中的标识符 (ID) 决定. ID 并不是设备的地址, 而是消息内容的标识和优先级.
优先级规则:
- 显性电平 (Dominant/逻辑 0): 具有优先权, 它会覆盖 隐性电平 (Recessive/逻辑 1).
- ID 值越低 (即 ID 前导的显性电平越多): 消息的优先级就越高.

3. 仲裁过程

逐位比较: 所有同时发送消息的单元从仲裁段的第一位开始, 逐个位地将自己发送的位电平与总线上的实际电平进行比较.
仲裁获胜:
- 当一个单元发送显性电平 (Dominant), 且总线上也为显性电平, 则该单元继续发送.
- 连续输出显性电平最多的单元将获胜, 并获得总线的控制权.
仲裁失利 (退出):
- 当一个单元发送隐性电平 (Recessive/逻辑 1), 但同时检测到总线上是显性电平 (Dominant/逻辑 0) 时, 表明总线上有更高优先级的消息正在发送.
- 该单元判定仲裁失利, 立即停止发送当前消息, 并转为接收状态, 等待总线再次空闲后重新尝试发送.

:::tip 上图中, 单元 1 和单元 2 同时开始向总线发送数据, 开始部分他们的数据格式是一样的, 故无法区分优先级, 直到 T 时刻, 单元 1 输出隐性电平, 而单元 2 输出显性电平, 此时单元 1 仲裁失利, 立刻转入接收状态工作, 不再与单元 2 竞争, 而单元 2 则顺利获得总线使用权, 继续发送自己的数据. 这就实现了仲裁, 让连续发送显性电平多的单元获得总线使用权. :::

4. 结果

仲裁段结束后, 总线上只有仲裁获胜 (标识符优先级最高) 的消息得以继续完整传输, 确保了实时性和高效性.

消息过滤机制 (Filter)

CAN 过滤器是 CAN 控制器硬件的重要组成部分, 其核心作用在于对总线上的报文 ID 进行高效筛选, 决定哪些报文需要被接收和处理, 哪些报文应该被丢弃.

1. 目的

减轻 CPU 负担: 硬件过滤器在接收消息进入 FIFO (接收缓冲区) 之前就完成 ID 匹配, 避免 CPU 被大量无关数据中断和处理, 从而专注于业务逻辑.
提高效率: 确保节点只接收与其功能相关的消息, 实现了高效的数据管理.

2. 工作原理：筛选模式

CAN 过滤器通过两个核心参数: 过滤器标识符寄存器 (ID Register) 和 过滤器屏蔽寄存器 (Mask Register) 来配置筛选规则.

模式	描述	应用场景
标识符列表模式 (List Mode)	屏蔽寄存器中的位全部设置为不关心 (0). 过滤器寄存器中存储的是完整的目标 ID. 只有当接收到的报文 ID 与过滤器 ID 完全匹配时才会被接收.	需要精确接收少数几个固定 ID 的报文时.
屏蔽模式 (Mask Mode)	屏蔽寄存器中的位用于指定 ID 中哪些位必须匹配 (设置为 1), 哪些位可以忽略 (设置为 0). 接收到的报文 ID 只有在"必须匹配"的位上与过滤器 ID 相符时才会被接收.	需要接收某一范围 ID 的报文时, 或者需要区分标准帧和扩展帧时.

3. 硬件实现（以 STM32 bxCAN 为例）

在如 STM32 等微控制器中, CAN 控制器通常集成多达 28 个（或更多）独立的过滤器组，这些过滤器组可以配置为:

16 位模式: 每个过滤器组可配置为两个 16 位的过滤器（可以容纳 11 位标准帧 ID 和部分功能位）.
32 位模式: 每个过滤器组可配置为一个 32 位的过滤器（可以容纳 29 位扩展帧 ID）.

每个过滤器最终都会将匹配成功的报文路由到指定的接收 FIFO（通常是 FIFO0 或 FIFO1）中, 等待 CPU 读取.

帧结构

CAN 协议的五种帧类型

CAN 协议通过以下 5 种类型的帧进行通信:

数据帧 (Data Frame): 用于发送单元向接收单元传送数据. (有数据段)
遥控帧 (远程帧) (Remote Frame): 用于接收单元向具有相同 ID 的发送单元请求数据. (无数据段)
错误帧 (Error Frame): 用于当检测出错误时向其他单元通知错误.
过载帧 (Overload Frame): 用于接收单元通知其尚未做好接收准备.
帧间隔 (Interframe Space): 用于将数据帧及遥控帧与前面的帧分离开来.

其中, 数据帧和遥控帧有标准格式 (11 位标识符 ID) 和扩展格式 (29 位 ID) 两种标识符长度.

数据帧 (Data Frame) 结构

CAN 数据帧是协议中最核心的帧类型, 它由以下 7 个段构成:

序号	段名称	作用说明
1	帧起始 (Start of Frame, SOF)	表示数据帧开始的段.
2	仲裁段 (Arbitration Field)	表示该帧优先级的段, 包含报文的标识符 (ID), 用于总线仲裁.
3	控制段 (Control Field)	表示数据段的字节数及保留位的段.
4	数据段 (Data Field)	数据的内容, 一帧可发送 0 到 8 个字节的数据.
5	CRC 段 (CRC Field)	用于检查帧的传输错误的段.
6	ACK 段 (Acknowledge Field)	用于表示确认正常接收的段. 接收到正确消息的单元在此段发送显性电平, 通知发送单元正常接收.
7	帧结束 (End of Frame, EOF)	表示数据帧结束的段.

:::tip 图中 D 表示显性电平, R 表示隐性电平 (下同) :::

帧起始 (Start of Frame, SOF): 标准帧和扩展帧都是由 1 个位的显性电平表示帧起始.
仲裁段 (Arbitration Field): 仲裁段, 表示数据优先级的段, 标准帧和扩展帧格式在本段有所区别.
- 标准格式的 ID 有 11 个位. 从 ID28 到 ID18 被依次发送. 禁止高 7 位都为隐性 (禁止设定: ID=1111111XXXX).
- 扩展格式的 ID 有 29 个位. 基本 ID 从 ID28 到 ID18, 扩展 ID 由 ID17 到 ID0 表示. 基本 ID 和标准格式的 ID 相同. 禁止高 7 位都为隐性 (禁止设定: 基本 ID=1111111XXXX). 其中 RTR 位用于标识是否是远程帧 (0, 数据帧; 1, 远程帧), IDE 位为标识符选择位 (0, 使用标准标识符; 1, 使用扩展标识符), SRR 位为代替远程请求位, 为隐性位, 它代替了标准帧中的 RTR 位.
控制段 (Control Field): 由 6 个位构成, 表示数据段的字节数. 标准帧和扩展帧的控制段稍有不同. r0 和 r1 为保留位, 必须全部以显性电平发送, 但是接收端可以接收显性、隐性及任意组合的电平. DLC 段为数据长度表示段, 高位在前, DLC 段有效值为 0~8, 但是接收方接收到 9~15 的时候并不认为是错误.
数据段 (Data Field): 从最高位 (MSB) 开始输出, 标准帧和扩展帧在这个段的定义都是一样的.
CRC 段 (CRC Field): 用于检查帧的传输错误的段. 由 15 个位的 CRC 顺序和 1 个位的 CRC 界定符 (用于分隔的位) 组成, 标准帧和扩展帧在这个段的格式也是相同的. 此段 CRC 的值计算范围包括: 帧起始、仲裁段、控制段、数据段. 接收方以同样的算法计算 CRC 值并进行比较, 不一致时会通报错误.
ACK 段 (Acknowledge Field): 用于表示确认正常接收的段. 由 ACK 槽 (ACK Slot) 和 ACK 界定符 2 个位组成. 标准帧和扩展帧在这个段的格式也是相同的. 发送单元的 ACK, 发送 2 个位的隐性位, 而接收到正常消息的单元在 ACK 槽 (ACK Slot) 发送显性位, 通知发送单元正常接收结束, 这个过程叫发送 ACK/返回 ACK. 发送 ACK 的是在既不处于总线关闭态也不处于休眠态的所有接收单元中, 接收到正常消息的单元 (发送单元不发送 ACK). 所谓正常消息是指不含填充错误、格式错误、CRC 错误的消息.
帧结束 (End of Frame, EOF): 标准帧和扩展帧在这个段格式一样, 由 7 个位的隐性位组成.

编程开发

CAN 协议的编程开发主要围绕微控制器（如 STM32）内部的 CAN 控制器模块（例如 bxCAN）进行. 开发的核心在于初始化和配置控制器, 使其能够正确地与物理总线同步, 并高效地处理报文.

硬件初始化与总线配置

这是 CAN 通信开始前必须完成的基础工作, 主要使用 CAN_InitTypeDef 结构体进行配置.

时钟与 GPIO 配置: 使能 CAN 控制器（如 CAN1）及相关 GPIO 口的时钟, 并配置 CAN_TX 和 CAN_RX 引脚（例如 STM32 需要配置 APB1 时钟）.
CAN 控制器初始化: 设置 CAN 工作模式、自动重传、离线管理等功能, 并配置位时序（Bit Timing）确定所需的通信波特率.

void CAN_Config(void)
{
    // 1. 配置 GPIO 时钟和引脚 (略)
    // 2. 配置 CAN 时钟 (略)

    CAN_InitTypeDef CAN_InitStructure;

    // CAN 模块工作参数配置
    CAN_InitStructure.CAN_TTCM = DISABLE;          // 非时间触发通信模式
    CAN_InitStructure.CAN_ABOM = ENABLE;           // 自动离线管理
    CAN_InitStructure.CAN_AWUM = ENABLE;           // 自动唤醒模式
    CAN_InitStructure.CAN_NART = DISABLE;          // 自动重传
    CAN_InitStructure.CAN_RFLM = DISABLE;          // 不锁定 FIFO
    CAN_InitStructure.CAN_TXFP = DISABLE;          // 优先级由 ID 决定

    // 工作模式选择:
    // CAN_Mode_Normal (正常模式) 或 CAN_Mode_LoopBack (回环模式)
    CAN_InitStructure.CAN_Mode = CAN_Mode_LoopBack; // 示例使用回环模式进行自测

    // 位时序配置 (例如: 波特率 500Kbps)
    CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;        // 再同步跳转宽度 1Tq
    CAN_InitStructure.CAN_BS1 = CAN_BS1_8tq;        // 时间段 1: 8Tq
    CAN_InitStructure.CAN_BS2 = CAN_BS2_7tq;        // 时间段 2: 7Tq
    CAN_InitStructure.CAN_Prescaler = 6;           // 预分频器 (决定 Tq 长度)

    CAN_Init(CAN1, &CAN_InitStructure);
    // ... 后续进行过滤器配置 ...
    CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE); // 开启 FIFO0 接收中断
}

消息过滤机制配置

使用 CAN_FilterInitTypeDef 结构体配置硬件过滤器, 确保接收效率.

过滤器初始化: 设置过滤器号、规模、工作模式和帧类型.
ID 和屏蔽器设置: 确定接收规则（标识符列表模式或屏蔽模式）.
FIFO 绑定: 指定匹配成功的报文进入哪个接收邮箱（FIFO0 或 FIFO1）.

// 承接上一段代码，设置过滤器结构体
CAN_FilterInitTypeDef CAN_FilterInitStructure;

CAN_FilterInitStructure.CAN_FilterNumber = 0;           // 过滤器 0
CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask; // 屏蔽模式 (用于接收某一范围 ID)
CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit; // 32 位规模

// 过滤器 ID 寄存器: 设定目标 ID
CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0120;      
CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;       

// 过滤器屏蔽寄存器: 决定 ID 中哪些位必须匹配
CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0xFFF0;  
CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;

CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_Filter_FIFO0; // 匹配消息放入 FIFO0
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;      // 激活过滤器
CAN_FilterInit(&CAN_FilterInitStructure);

数据发送流程

数据发送通过配置 CanTxMsg 结构体和调用 CAN_Transmit() 函数实现.

配置发送参数: 确定 ID、帧类型、数据长度（DLC, 0~8）和实际数据.
发送请求: 写入空闲的发送邮箱并设置发送请求标志.

void CAN_Send_Msg(u8 *buf, u8 len)
{
    CanTxMsg TxMessage;
    TxMessage.StdId = 0x12;              // 消息 ID
    TxMessage.ExtId = 0x00;
    TxMessage.IDE = CAN_Id_Standard;     // 标准帧
    TxMessage.RTR = CAN_RTR_Data;        // 数据帧 (非遥控帧)
    TxMessage.DLC = len;                 // 数据长度 (0-8)

    for (int i = 0; i < len; i++)
        TxMessage.Data[i] = buf[i];

    CAN_Transmit(CAN1, &TxMessage);      // 写入发送邮箱并设置发送请求
}

数据接收流程

数据接收通常通过中断方式实现, 需要配置 NVIC 并在中断服务函数（ISR）中调用 CAN_Receive() 读取报文.

// CAN FIFO0 接收中断服务函数 (STM32F103 的中断向量)
void USB_LP_CAN1_RX0_IRQHandler(void)
{
    CanRxMsg RxMessage;
    if (CAN_GetITStatus(CAN1, CAN_IT_FMP0) != RESET) // 检查 FIFO0 中是否有新消息
    {
        CAN_Receive(CAN1, CAN_FIFO0, &RxMessage); // 读取消息到 RxMessage 结构体

        // 在这里处理接收到的数据, 例如:
        // u32 id = RxMessage.StdId;
        // u8 data0 = RxMessage.Data[0];
        
        // 示例：将接收到的数据在 LCD 上显示 (参考文档中的逻辑)
        // LCD_ShowxNum(..., RxMessage.Data[i], ...); 
    }
    CAN_ClearITPendingBit(CAN1, CAN_IT_FMP0); // 清除中断标志位
}

模式选择

在开发和测试中, 不同的工作模式用于不同的目的:

回环模式（LoopBack Mode）: 主要用于自测试和调试. 在这种模式下, CAN 控制器将自己发送的消息当作接收消息立即回传给自己, 不涉及外部 CAN 收发器和物理总线.
正常模式（Normal Mode）: 用于正常通信, 此时 CAN 控制器将数据发送到总线, 并与其他节点进行交互.
静默模式（Silent Mode）: 主要用于总线监测和诊断.

参考:

STM32F1开发指南-库函数版本_V3.3
零死角玩转stm32
Wikipedia-控制器區域網路

NEC 红外协议笔记

Tue, 28 Oct 2025 00:00:00 GMT

NEC Protocol - 日电

NEC 红外协议是一种广泛应用于家用电器遥控器的红外通信协议。
红外对射无法穿过障碍物：红外通信是视距 (Line of Sight) 通信，会被大部分非透明障碍物阻挡。
目前广泛使用的是：NEC Protocol的PWM（脉冲宽度调制）和Philips RC-5 Protocol的PPM（脉冲位置调制）。
- PWM：红外载波的占空比表示‘0’和‘1’。发射时间固定，通过改变不发射载波的时间改变占空比。
- PPM：发射载波的位置表示‘0’和‘1’。发射载波到不发射载波位‘0’，反之位‘1’。发射载波和不发射载波的时间相同，均为0.889ms，每位时间固定。

一、核心编码规则

逻辑值	红外波形（发射端）	总时长	说明
`0`	560 µs 高（载波） + 560 µs 低	≈ 1.125 ms	短间隔
`1`	560 µs 高（载波） + 1690 µs 低	≈ 2.25 ms	长间隔

:::note

“高电平” = 发射 38kHz 载波（burst）
“低电平” = 停止载波（静默）
所有数据位均以 560 µs 高电平 开始，通过后续低电平长度区分 0/1 :::

二、完整帧结构（32位数据）

字段（中文）	FIELD (English)	位数	示例（十六进制）	说明
同步码头	Leader Pulse / Sync Header	—	9ms + 4.5ms	帧起始标志
地址码	Address Code	8位	0x12	设备地址
地址反码	Address Inverse	8位	0xED (= ~0x12)	地址校验
控制码	Command Code	8位	0x45	按键命令
控制反码	Command Inverse	8位	0xBA (= ~0x45)	命令校验

:::note 总数据位：8 + 8 + 8 + 8 = 32位
校验规则：Address ^ AddressInverse == 0xFF，Command ^ CommandInverse == 0xFF :::

示例题①

字段名称	NEC 值 (LSB First)	十六进制值
Address Code	`0000 0000`	`0x00`
Address Inverse	`1111 1111`	`0xFF`
Command Code	`0100 0101`	`0x45`
Command Inverse	`1011 1010`	`0xBA`

过程：
start: 9ms + 4.5ms
Address Code: 00000000 → 00000000 (00)
Address Inverse1: 11111111 → 11111111 (FF)
Command Code (原始波形 MSB First → NEC 值 LSB First): 10100010 (A2) → 01000101 (45)
Command Inverse (原始波形 MSB First → NEC 值 LSB First): 01011101 (5D) → 10111010 (BA)

示例题②

字段名称	NEC 值 (LSB First)	十六进制值
Address Code	`0000 0000`	`0x00`
Address Inverse	`1111 1111`	`0xFF`
Command Code	`0011 0000`	`0x30`
Command Inverse	`1100 1111`	`0xCF`

过程：
start: 9ms + 4.5ms
Address Code: 00000000 → 00000000 (00)
Address Inverse1: 11111111 → 11111111 (FF)
Command Code (原始波形 MSB First → NEC 值 LSB First): 00110000 (30) → 00001100 (0C)
Command Inverse (原始波形 MSB First → NEC 值 LSB First): 1100 1111 (CF) → 11110011 (F3)

三、位序规则：LSB First（低位在前）

所有字节（地址码、控制码等）均按 LSB First 发码：

发送顺序（时间先后）	对应位编号	在字节中的位置	权重（2ⁿ）
第1位（最先发送）	bit0	最低位（LSB）	(2^0 = 1)
第2位	bit1		(2^1 = 2)
第3位	bit2		(2^2 = 4)
第4位	bit3		(2^3 = 8)
第5位	bit4		(2^4 = 16)
第6位	bit5		(2^5 = 32)
第7位	bit6		(2^6 = 64)
第8位（最后发送）	bit7	最高位（MSB）	(2^7 = 128)

所有字节（地址码、控制码等）均按 LSB First 解码：

接收顺序（时间先后）	对应位编号	在字节中的位置	权重（2ⁿ）
第1位（最先收到）	bit0	最低位（LSB）	(2^0 = 1)
第2位	bit1		(2^1 = 2)
第3位	bit2		(2^2 = 4)
第4位	bit3		(2^3 = 8)
第5位	bit4		(2^4 = 16)
第6位	bit5		(2^5 = 32)
第7位	bit6		(2^6 = 64)
第8位（最后收到）	bit7	最高位（MSB）	(2^7 = 128)

:::tip 示例：发送序列 01000101 → 8位字节转换成16进制数 0x45 示例：接收序列 10100010 → 组合为 bit7~bit0 = 01000101 = 0x45 :::

四、NEC Protocol的 PWM （脉冲宽度调制）和 Philips RC-5 Protocol 的 PPM （脉冲位置调制）

项目	NEC 协议（PWM 标准）	Philips RC-5 协议（PPM 标准）
编码类型	脉冲宽度调制（PWM）<br>（通过改变无载波时间改变占空比）	脉冲位置调制（PPM）<br>（通过高低电平相位位置区分 0/1）
载波频率	38 kHz（典型）	36 kHz（典型）
逻辑“0”表示	560 µs 载波 + 560 µs 无载波	889 µs 低电平 + 889 µs 高电平
逻辑“1”表示	560 µs 载波 + 1690 µs 无载波	889 µs 高电平 + 889 µs 低电平
位时长	不固定（=1.12 ms 或 2.25 ms）	固定（≈1.778 ms）
帧结构	引导码 + 地址码（16位）+ 命令码（16位）	起始位（S）+ 场位（F）+ 控制位（C）+ 系统码（5位）+ 命令码（6位）
位发送顺序	LSB First（先发低位）	MSB First（先发高位）
重复按键机制	全码后发送简码（9ms + 2.25ms + 结束位），周期约 108ms	控制位（C）翻转，其余不变，无简码
校验方式	命令码与其反码配对校验	无显式反码，靠双相位和控制位防误触发
典型芯片	WD6122、uPD6121	SAA3010
应用场景	电视、空调、机顶盒等家电	Philips 音响、老式电视等

五、编程实现

1. 数据类型与存储策略

虽然协议由 4 个 8 位字段组成，但在编程中通常将其“拼装”为 32 位整数进行处理：

基本单元：uint8_t 存储地址码、命令码及其反码。
最佳实践：
- 发送时：将 4 个 uint8_t 拼装成 1 个 uint32_t，再统一进行位发送循环。
- 接收时：先接收 32 个位存入 uint32_t，接收完毕后再拆解为 4 个 uint8_t 校验和处理。

// 接收端拆解示例 (假设 rx_data 为接收到的 uint32_t 完整帧)
uint8_t address = (uint8_t)(rx_data & 0xFF);
uint8_t command = (uint8_t)((rx_data >> 16) & 0xFF);

2. 校验机制

NEC 协议通过“原码 + 反码”进行错误检测。接收端的标准校验逻辑如下：

校验公式：(原始值 ^ 反码值) == 0xFF
只有当地址码与命令码都通过校验时，才视为有效的帧。

// 校验逻辑示例
if ( (address ^ address_inv == 0xFF) && (command ^ command_inv == 0xFF) ) {
    // 通过校验，执行命令
}

3. 接收端的逻辑反相

接收端输出电平与发射端的载波逻辑是相反 (Active Low) 的：

状态	发射端动作	接收头输出引脚	软件解码逻辑
有载波	发射 38kHz 脉冲	低电平 (LOW)	对应协议中的“高”时长
无载波	静默	高电平 (HIGH)	对应协议中的“低”时长

编程关键：软件解码时，需测量的是引脚低电平的持续时间（判断是否为 560µs 载波）和随后的引脚高电平持续时间（据此判断是逻辑 0 还是 1）。

4. 时序测量方式

由于 NEC 协议对微秒级时序敏感，推荐使用硬件资源进行测量：

定时器输入捕获 (Input Capture)。由硬件自动记录引脚跳变时刻，精度最高，CPU 占用最少。
外部中断 (GPIO Interrupt)。在引脚跳变时触发中断记录时间，精度较好。
轮询 (Polling)。容易受其他程序干扰导致时序测量误差，造成解码失败。

5. 状态机实现

NEC 协议的接收端通常采用状态机结构，按顺序处理引导码、地址码、命令码、命令反码共 4 个字段。每个字段的接收过程中，根据引脚电平变化（高/低）切换状态，记录静默时间（载波时间固定为 560 µs）。

六、关键注意事项 (源自网络，注意甄别)

载波参数
- 标准频率：38 kHz（由 455 kHz 晶振 ÷12 得到）
- 推荐占空比：1:3（高电平占 1/4 周期），但 1:1 或 1:2 在多数接收头下也能工作。
帧结构完整性
- 必须包含结束位：全码和简码末尾均需发送 0.56 ms 载波，否则部分设备无法识别。
- 16 位地址码顺序：先发低字节，再发高字节，每个字节内部仍为 LSB First。
重复码（简码）机制
- 按键长按时，首帧发全码，后续每 108 ms 发送一次简码：
  9 ms 载波 + 2.25 ms 无载波 + 0.56 ms 载波（结束位）
- 若省略简码，某些设备（如空调）将无法响应长按操作。
发送间隔与时序
- 两次全码之间建议间隔 ≥110 ms，避免接收端因繁忙而丢帧。
- 连续快速发送多帧容易导致第二帧失效，应该要加入合适的延时。
- Sony、机顶盒等二次译码 MCU 在 65 ms 内就准备接收下一帧；做万能遥控可把“全码间隔”做成 60–130 ms 可配置，否则会出现“第二键无响应”。
接收端信号反相
- 一体化红外接收头输出波形与发射端逻辑相反（载波时输出低电平），解码前需注意是否需软件取反。
- 注意输出类型（开漏 / 推挽）
厂商变种的兼容性
- 部分品牌（如美的、新科）可能会用 NEC 的变种协议：帧长可能达 120 ms 甚至 500 ms。
- 通用遥控器建议支持自学习模式或动态解析引导码/位宽。
硬件设计建议
- 红外发射管驱动电流建议 ≥100 mA，推荐使用恒流电路（如射极跟随器）以维持发射强度稳定。
- 接收头电源引脚需加 ≥22 µF 滤波电容，必要时串接 330 Ω 电阻抑制电源干扰。

参考：

NEC协议
 红外遥控编码与解码
 STM32F103正点原子学习笔记系列——REMOTE
SB-Projects NEC Protocol
NEC Protocol Decoding with STM32
NEC 协议红外遥控器

Numpy学习笔记(2)

Sat, 25 Oct 2025 00:00:00 GMT

:::note 本笔记基于 Jupyter Lab :::

:::tip 均从第0个元素开始表述（第0行 / 第0列） :::

数组访问

一维数组

整数与切片索引

import numpy as np
arr = np.arange(10)
print('整数索引结果为：', arr[5]) # 索引从 0 开始；也支持负数，`-1` 表示数组最后一个元素
print('切片结果为：', arr[2:7]) # 左闭右开，获取从 `start` 到 `end` 的子数组
print('省略起始索引结果为：', arr[:5]) # 默认从数组开头开始，获取到索引为 `end-1` 的元素
print('省略结束索引结果为：', arr[5:]) # 默认获取到数组末尾，包含索引为 `start` 的元素

带步长的切片索引

arr[2:4] = 100, 101
print('索引结果为：', arr) # 左闭右开，切片修改数组元素

print('正步长索引结果为：', arr[::2]) # 左闭右开，每隔 2 个元素取一个，组成子数组
print('负步长索引结果为：', arr[5:1:-1]) # 反向切片，步长为 -1，数组倒序（开始索引必须大于结束索引）

多维数组

import numpy as np
arr = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print('创建的二维数组为：\n', arr)

单维度切片索引

arr[行索引, 列起始索引:列结束索引] 或 arr[行起始索引:行结束索引, 列索引]

print('单维度切片索引结果为：', arr[0, 3:5]) # 左闭右开，索引第0行中第3、4列的元素
print('索引结果为：', arr[:, 2]) # 索引第2列的元素

多维度切片索引

arr[行起始索引:行结束索引, 列起始索引:列结束索引]

print('多维度切片索引结果为：', arr[1:, 2:]) # 索引第1行及之后行中第2列到最后列的元素
print('索引结果为：', arr[:, 1:4]) # 左闭右开，选取所有行中，列索引从 1 到 3 的元素

整数序列切片索引

arr[(行索引序列), (列索引序列)]

print('整数序列索引结果为：', arr[(0, 1, 2), (1, 2, 3)]) # 左闭右开，索引第0、1、2行中，第1、2、3列的元素
print('索引结果为：', arr[1:, (0, 2, 3)]) # 左闭右开，索引第1行及之后行中，第0、2、3列的元素

布尔数组切片索引

arr[布尔数组, 列索引]

mask = np.array([1, 0, 1], dtype=np.bool_) # [True, False, True]
print('布尔数组索引结果为：', arr[mask, 2]) # 索引第0、2行中第2列的元素

形状操作与展平规则

import numpy as np
arr = np.arange(12)  # 创建一维数组
print('创建的一维数组为：', arr) # [0 1 2 3 4 5 6 7 8 9 10 11]

改变数组形状

数组.reshape(shape)

print('新的数组形状为：\n', arr.reshape(3, 4))  # 设置数组的形状为 3x4

查看数组维数

数组.ndim / 数组.reshape(shape).ndim

print('数组维数为：', arr.ndim) # 查看数组的维数（轴数）

数组展平

将多维数组展平为一维数组

import numpy as np
arr = np.arange(12).reshape(3, 4)
print('创建的二维数组为：\n', arr) # [[ 0  1  2  3] [ 4  5  6  7] [ 8  9 10 11]]

数组.ravel()

# 返回原数组的视图（修改展平后的数组可能会影响原数组）
print('数组展平为：', arr.ravel()) # [ 0  1  2  3  4  5  6  7  8  9 10 11]

数组.flatten()

# 返回原数组的副本（修改展平后的数组不会影响原数组）
# 支持指定展平顺序（默认按行序展平）
print('横向展平为：', arr.flatten()) # [ 0  1  2  3  4  5  6  7  8  9 10 11]
print('纵向展平为：', arr.flatten('F')) # [ 0  4  8  1  5  9  2  6 10  3  7 11]

数组组合

数组元素运算

格式示例：新数组 = 原数组 * 数值（或 原数组 + 数值 等）

运算类型	格式示例	运算逻辑	`arr1 = np.array([1, 2, 3, 4])`	运算结果（新数组）
加法	`新数组 = 原数组 + 数值`	每个元素加指定数值	`arr1 + 2`	`[3, 4, 5, 6]`
减法	`新数组 = 原数组 - 数值`	每个元素减指定数值	`arr1 - 1`	`[0, 1, 2, 3]`
乘法	`新数组 = 原数组 * 数值`	每个元素乘指定数值	`arr1 * 3`	`[3, 6, 9, 12]`
除法	`新数组 = 原数组 / 数值`	每个元素除以指定数值（结果为浮点）	`arr1 / 2`	`[0.5, 1.0, 1.5, 2.0]`
整除	`新数组 = 原数组 // 数值`	每个元素整除指定数值（丢弃小数）	`arr1 // 2`	`[0, 1, 1, 2]`
取余	`新数组 = 原数组 % 数值`	每个元素对指定数值取余	`arr1 % 2`	`[1, 0, 1, 0]`
幂运算	`新数组 = 原数组 ** 数值`	每个元素的指定次幂	`arr1 ** 2`	`[1, 4, 9, 16]`
大于比较（布尔）	`新数组 = 原数组 > 数值`	每个元素与数值比较，返回布尔值	`arr1 > 2`	`[False, False, True, True]`
小于比较（布尔）	`新数组 = 原数组 < 数值`	每个元素与数值比较，返回布尔值	`arr1 < 3`	`[True, True, False, False]`
等于比较（布尔）	`新数组 = 原数组 == 数值`	每个元素与数值比较，返回布尔值	`arr1 == 4`	`[False, False, False, True]`
不等于比较（布尔）	`新数组 = 原数组 != 数值`	每个元素与数值比较，返回布尔值	`arr1 != 2`	`[True, False, True, True]`

数组与数组的逐元素运算（形状需相同）

运算类型	格式示例	运算逻辑	`arr1 = np.array([1,2,3]), arr2 = np.array([4,5,6])`	运算结果（新数组）
数组加法	`新数组 = 数组A + 数组B`	对应位置元素相加	`arr1 + arr2`	`[5, 7, 9]`
数组减法	`新数组 = 数组A - 数组B`	对应位置元素相减	`arr1 - arr2`	`[-3, -3, -3]`
数组乘法	`新数组 = 数组A * 数组B`	对应位置元素相乘（非矩阵乘法）	`arr1 * arr2`	`[4, 10, 18]`
数组除法	`新数组 = 数组A / 数组B`	对应位置元素相除（结果为浮点）	`arr1 / arr2`	`[0.25, 0.4, 0.5]`

`np.hstack` 横向组合数组

要求待组合的数组在除水平方向外的其他维度上形状一致
np.hstack((数组1, 数组2, ...))

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
print('横向组合后的数组为：\n', np.hstack((arr1, arr2)))
#横向组合后的数组为：
 #[[ 1  2  3  7  8  9]
 #[ 4  5  6 10 11 12]]

`np.vstack` 纵向组合数组

要求待组合的数组在除垂直方向外的其他维度上形状一致
np.vstack((数组1, 数组2, ...))

print('纵向组合后的数组为：\n', np.vstack((arr1, arr2)))
#纵向组合后的数组为：
 #[[ 1  2  3]
 #[ 4  5  6]
 #[ 7  8  9]
 #[10 11 12]]

`np.concatenate` 组合数组

np.concatenate((数组1, 数组2, ...), axis=轴编号)
待组合的数组，在除 axis 指定的维度外的其他所有维度上，形状必须完全一致
- axis 用于指定数组组合的方向维度
  - axis=1 ，横向组合（水平方向，列维度方向），与 np.hstack 类似
  - axis=0 ，纵向组合（垂直方向，行维度方向），与 np.vstack 类似

print('横向组合后的数组为：\n', np.concatenate((arr1, arr2), axis=1))
#横向组合后的数组为：
 #[[ 1  2  3  7  8  9]
 #[ 4  5  6 10 11 12]]

print('纵向组合后的数组为：\n', np.concatenate((arr1, arr2), axis=0))
#纵向组合后的数组为：
 #[[ 1  2  3]
 #[ 4  5  6]
 #[ 7  8  9]
 #[10 11 12]]

数组分割

arr = np.arange(16).reshape(4, 4)
print('创建的二维数组为：\n', arr)
#创建的二维数组为：
 #[[ 0  1  2  3]
 #[ 4  5  6  7]
 #[ 8  9 10 11]
 #[12 13 14 15]]

`np.hsplit` 横向分割数组

按照列的维度，将数组平均分割成指定的份数
np.hsplit(数组, 分割份数)

print('横向分割后的数组为：\n', np.hsplit(arr, 2))
#横向分割后的数组为：
# [array([[ 0,  1],
#       [ 4,  5],
#       [ 8,  9],
#       [12, 13]]), array([[ 2,  3],
#       [ 6,  7],
#       [10, 11],
#       [14, 15]])]

`np.vsplit` 纵向分割数组

按照行的维度，将数组平均分割成指定的份数
np.vsplit(数组, 分割份数)

print('纵向分割后的数组为：\n', np.vsplit(arr, 2))
#纵向分割后的数组为：
# [array([[ 0,  1,  2,  3],
#       [ 4,  5,  6,  7]]), array([[ 8,  9, 10, 11],
#       [12, 13, 14, 15]])]

`np.split` 分割数组

np.split(数组, 分割份数, axis=轴编号)
- axis 用于指定数组分割的方向维度
  - axis=1 ，横向分割（水平方向，列维度方向），与 np.hsplit 类似
  - axis=0 ，纵向分割（垂直方向，行维度方向），与 np.vsplit 类似

print('横向分割后的数组为：\n', np.split(arr, 2, axis=1))
#横向分割后的数组为：
# [array([[ 0,  1],
#       [ 4,  5],
#       [ 8,  9],
#       [12, 13]]), array([[ 2,  3],
#       [ 6,  7],
#       [10, 11],
#       [14, 15]])]

print('纵向分割后的数组为：\n', np.split(arr, 2, axis=0))
#纵向分割后的数组为：
# [array([[ 0,  1,  2,  3],
#       [ 4,  5,  6,  7]]), array([[ 8,  9, 10, 11],
#       [12, 13, 14, 15]])]

参考：

NumPy 中文文档

Numpy学习笔记(1)

Fri, 24 Oct 2025 00:00:00 GMT

:::note 本笔记基于 Jupyter Lab :::

Numpy 是一个开源的 Python 库，它提供了高性能的数组对象，以及数学函数，用于操作这些数组, 广泛应用于科学和工程领域。

:::important 导入Numpy :::

import numpy as np

这种约定允许使用简短易识别的前缀 (np.) 访问 NumPy 功能，同时将 NumPy 功能与同名其他功能区分开来。

轴（Axis）的基本概念

在 NumPy 中，轴（axis）是描述数组维度方向的核心概念，编号从 0 开始，从“最外层”到“最内层”。
规律：轴编号 = 维度层级，轴 0 为最外层，编号越大，操作越聚焦内层结构。

一维数组（1D Array）

轴 0（axis=0）：唯一维度方向（如直线延伸）。
- 示例：[1,2,3,4]，轴 0 表示从第一个到最后一个元素的方向。

二维数组（2D Array）

轴 0（axis=0）：垂直方向（行维度）。
- 示例：[[1,2],[3,4]]，沿轴 0 求和：[1+3, 2+4] = [4,6]。
轴 1（axis=1）：水平方向（列维度）。
- 示例：[[1,2],[3,4]]，沿轴 1 求和：[1+2, 3+4] = [3,7]。

三维数组（3D Array）

轴 0（axis=0）：二维数组的堆叠方向（深度）。
- 示例：[[[1,2],[3,4]], [[5,6],[7,8]]]，沿轴 0 求和：[[1+5,2+6],[3+7,4+8]] = [[6,8],[10,12]]。
轴 1（axis=1）：二维数组内部的垂直方向（行维度）。
- 示例：上述数组，沿轴 1 求和：[[1+3,2+4], [5+7,6+8]] = [[4,6],[12,14]]。
轴 2（axis=2）：二维数组内部的水平方向（列维度）。
- 示例：上述数组，沿轴 2 求和：[[1+2,3+4], [5+6,7+8]] = [[3,7],[11,15]]。

数组属性

NumPy 的数组类名为 ndarray。它也以别名 array 著称。 :::warning 请注意，numpy.array 与标准 Python 库中的 array.array 类不同，后者只处理一维数组，功能较少。 :::

import numpy as np
arr = np.array([[[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5]]])
print(arr)          # 输出数组，注意格式：中括号，元素间无逗号（区别于列表）
print(arr.ndim)     # 数组的轴（维度）数量
print(arr.shape)    # 数组的维度，整数元组表示每个维度的大小
print(arr.size)     # 数组的元素总数，等于 shape 中元素的乘积
print(arr.dtype)    # 数组中元素的类型，可为标准 Python 类型或 NumPy 类型
print(arr.itemsize) # 数组中每个元素的字节大小，等同于 dtype.itemsize
print(arr.data)     # 包含数组实际元素的缓冲区，通常通过索引访问元素

输出结果：

数组创建

使用 `array` 函数创建

从普通的 Python 列表或元组创建数组：

import numpy as np
a = np.array([2, 3, 4])
print(a)          # array([2, 3, 4])
print(a.dtype)    # dtype('int64')

b = np.array([1.2, 3.5, 5.1])
print(b.dtype)    # dtype('float64')

参数：np.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)
- object：输入数据，可以是列表、元组或其他数组。
- dtype：数组元素的数据类型，可选。
- copy：是否复制输入数据，默认为 True。
- order：存储顺序，C 表示行优先，F 表示列优先。
- subok：默认返回基础类的数组，若为 True 则返回子类。
- ndmin：指定返回数组的最小维数。

注意：调用 array 时需提供单一序列作为参数：

a = np.array([1, 2, 3, 4])  # 正确

将序列的序列转换为二维数组：

b = np.array([(1.5, 2, 3), (4, 5, 6)])
print(b)
# array([[1.5, 2. , 3. ],
#        [4. , 5. , 6. ]])

显式指定数组类型：

c = np.array([[1, 2], [3, 4]], dtype=complex)
print(c)
# array([[1.+0.j, 2.+0.j],
#        [3.+0.j, 4.+0.j]])

重设数组的 `shape` 属性

可以通过修改数组的 shape 属性来重设数组的形状，而无需创建新数组。

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6])
arr.shape = (2, 3)  # 将一维数组重设为二维数组
print(arr)
# 输出：
# array([[1, 2, 3],
#        [4, 5, 6]])

使用占位符函数创建

创建具有初始占位符内容的数组：

np.zeros((3, 4))
# array([[0., 0., 0., 0.],
#        [0., 0., 0., 0.],
#        [0., 0., 0., 0.]])

np.ones((2, 3, 4), dtype=np.int16)
# array([[[1, 1, 1, 1],
#         [1, 1, 1, 1],
#         [1, 1, 1, 1]],
#
#        [[1, 1, 1, 1],
#         [1, 1, 1, 1],
#         [1, 1, 1, 1]]], dtype=int16)

np.empty((2, 3))
# array([[...],  # 内容可能因内存状态而异（随机）
#        [...]])

np.eye(3)
# array([[1., 0., 0.],
#        [0., 1., 0.],
#        [0., 0., 1.]])

np.diag([1, 2, 3])
# array([[1, 0, 0],
#        [0, 2, 0],
#        [0, 0, 3]])

:::tip 其余占位符函数不再列举，请参阅数组创建例程 :::

参数：
- np.zeros(shape, dtype=float, order='C')
  - shape：数组的形状，必须指定。
  - dtype：数组元素的数据类型，默认为 float。
  - order：存储顺序，C 表示行优先，F 表示列优先。
- np.ones(shape, dtype=None, order='C')
  - 参数与 np.zeros 相同。
- np.empty(shape, dtype=float, order='C')
  - 参数与 np.zeros 相同。
- np.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
  - N：行数。
  - M：列数，默认为 N。
  - k：对角线的索引，默认为 0（主对角线）。
- np.diag(v, k=0)
  - v：输入数组。
  - k：对角线的索引，默认为 0（主对角线）。

创建数字序列的数组

`arange` 函数：

np.arange(10, 30, 5)
# array([10, 15, 20, 25])

np.arange(0, 2, 0.3)
# array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])

参数：np.arange(start, stop, step)
- start：起始值（包含），若省略则默认为 0。
- stop：终止值（不包含），必须指定。
- step：步长，若省略则默认为 1；步长可为整数或浮点数，用于控制相邻元素的间隔。

`linspace` 函数：

from numpy import pi
np.linspace(0, 2, 9)
# array([0.  , 0.25, 0.5 , 0.75, 1.  , 1.25, 1.5 , 1.75, 2.  ])

参数：np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
- start：序列的起始值。
- stop：序列的终止值。
- num：生成的样本数，默认为 50。
- endpoint：是否包含终止值，默认为 True。
- retstep：是否返回样本间距，默认为 False。
- dtype：输出数组的数据类型。
- axis：结果中样本的轴，默认为 0。

`logspace` 函数

生成对数刻度的数值序列。

arr = np.logspace(1, 3, num=5)

参数：start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0
- start：对数刻度的起始值。
- stop：对数刻度的终止值。
- num：生成的样本数，默认为 50。
- base：对数的底数，默认为 10。

:::note arange 函数和 linspace 函数的区别：

arange 函数生成的序列包含起始值，不包含终止值，步长可以是整数或浮点数。
linspace 函数生成的序列包含起始值，默认也包含终止值，样本数可以自定义。 :::

数组数据类型

常见的数据类型包括：

int：整数类型，如 np.int8、np.int16、np.int32、np.int64。
float：浮点类型，如 np.float32、np.float64。
bool：布尔类型，np.bool_。
complex：复数类型，如 np.complex64、np.complex128。

数据类型转换示例

import numpy as np
print('转换结果为：', np.float64(42))   # 整数转换为浮点数（精确转换）
print('转换结果为：', np.int8(42.0))   # 浮点数转换为整数（截断小数取整）
print('转换结果为：', np.bool_(42))   # 整数转换为布尔值（非零整数均为 True）
print('转换结果为：', np.bool_(0))    # 整数转换为布尔值（0 为 False）
print('转换结果为：', np.float64(True))  # 布尔值转换为浮点数
print('转换结果为：', np.float64(False)) # 布尔值转换为浮点数

`np.dtype` 函数

np.dtype 用于定义数组元素的数据类型，支持标准 Python 类型和 NumPy 类型。

`np.dtype` 的参数

dtype：数据类型，可以是 NumPy 类型（如 np.int32）或标准 Python 类型（如 int）。
byteorder：字节顺序，可选值为 >（大端）或 <（小端）。
align：是否对齐字段，默认为 False。
subdtype：子类型，用于描述数组的维度。

创建数据类型

import numpy as np
# 定义一个数组并指定数据类型
arr = np.array([1, 2, 3], dtype=np.float64)
print(arr)
# array([1., 2., 3.])
print(arr.dtype)
# dtype('float64')

查看已有数组类型

import numpy as np
arr = np.array([1, 2, 3], dtype=np.float32)
print("数组数据类型：", np.dtype(arr.dtype))
# dtype('float32')

自定义数据类型

import numpy as np
# 定义一个自定义数据类型
df = np.dtype([('name', 'U10'), ('quantity', 'i4'), ('price', 'f4')])
itemz = np.array([('tomatoes', 42, 4.14), ('cabbages', 13, 1.72)], dtype=df)
print('数组为：', itemz)
print('自定义数据为：', itemz.dtype)
# array([('tomatoes', 42, 4.14), ('cabbages', 13, 1.72)],
#       dtype=[('name', '<U10'), ('quantity', '<i4'), ('price', '<f4')])

生成随机数

`np.random.random` 函数

生成 [0, 1) 区间的均匀分布随机数。

rand_array = np.random.random((3, 2))

参数：size：指定生成数组的形状，类型为 int 或 tuple，如 (2, 3) 表示 2x3 的数组。

`np.random.rand` 函数

生成 [0, 1) 区间的均匀分布随机数，支持直接传递形状参数。

rand_array = np.random.rand(3, 2)

参数：shape：指定生成数组的形状，类型为 int 或 tuple。

`np.random.randn` 函数

生成标准正态分布（均值为 0，标准差为 1）的随机数。

rand_normal = np.random.randn(3, 2)

参数：shape：指定生成数组的形状，类型为 int 或 tuple。

`np.random.randint` 函数

生成指定范围内的随机整数。

rand_int = np.random.randint(10, 50, size=(3, 2), dtype=int)

参数：low, high=None, size=None
- low：随机整数的下界（包含）。
- high：随机整数的上界（不包含）。
- size：生成数组的形状。
- dtype：输出数组的数据类型，默认为 int。

参考：

NumPy 中文文档

浅谈 TCP 窗口优化

Thu, 02 Oct 2025 00:00:00 GMT

TCP 窗口优化

不论宽带速度（例 500Mbps 或 1000Mbps），连接到一些海外服务器或物理距离遥远的数据中心或机房时，下载或传输速度有时特别的慢，与测试结果不符，
很大程度上是高网络延迟（RTT）与 TCP 协议的固有设计共同作用的结果。

1. 高延迟下的 TCP 吞吐量陷阱

所有基于 TCP 的网络传输（如网页浏览、文件下载、VPN 连接等）都依赖于一个叫作 TCP 窗口的机制。窗口的作用是限制发送方在收到接收方确认之前可以发送的数据量。

为什么高延迟是性能杀手？

根据 TCP 的设计，数据吞吐量受到以下公式的严格限制：

$吞吐量 ≤ 窗口大小 / 往返时间 (RTT)$

在跨越国家或大洲的长距离连接中，RTT 动辄超过 150 毫秒。而原始的 TCP 窗口大小只有 65535 字节（64 KiB - 1）。这意味着我们的发送方在发出少量数据后，必须等待漫长的时间（一个 RTT 周期）才能得到确认并发送下一批数据，导致带宽大量闲置。

长距离连接对窗口的需求：带宽时延积 (BDP)

为了完全跑满我们的带宽，TCP 窗口的大小必须能覆盖网络管道的实际容量，这被称为带宽时延积 (BDP)：

$BDP = 带宽 × RTT$

实际计算示例：假设我们的宽带是 1 Gbps，而连接到北美西海岸服务器的 RTT 是 150 毫秒 (0.15 秒)：

原始窗口（65535 字节）的最大理论吞吐量仅约为 3.49 Mbit/秒。
根据 BDP 计算，我们需要的最优 TCP 窗口大小约为 18.75 MB。只有当窗口能扩展到 18.75 MB 时，我们才有机会跑满 1 Gbps 的带宽。

2. Windows 的解法：窗口自动调优

好消息是，微软早就意识到了这个问题。自 Windows Vista 以来，Windows 系统默认启用了一项名为 “TCP 自动调优接收窗口”（Receive Window Auto-Tuning） 的功能。

自动调优的作用

启用窗口缩放：它利用 TCP 窗口缩放扩展（Window Scaling），打破了 64KB 的原始限制，允许窗口大小动态扩展到数 MB 甚至更高（最高可达 1 GiB）。
动态匹配 BDP：Windows 系统会持续监测当前的网络 RTT 和应用程序的数据处理速度，智能地将 TCP 窗口大小调整到尽可能接近 BDP 的最优值。（当然是理论上）

如何检查自动调优状态？

我们可以通过 PowerShell 或 CMD 运行以下命令，查看我们的 TCP 全局参数。请关注 “Receive Window Auto-Tuning Level” 的值。

# 在 Windows 10/11 的 PowerShell 或 CMD 中执行
netsh interface tcp show global

如果其值为 normal，则表示自动调优已开启并处于正常工作状态。如果是 disabled，执行下面的命令。

# 启用自动调优（仅在确认被禁用时使用）
netsh interface tcp set global autotuninglevel=normal

3. RFC 1323 TCP 扩展

RFC 1323（TCP Extensions for High Performance）是 TCP 的经典标准。定义了三个关键扩展，让 TCP 在高带宽、高时延（高 BDP）的情况保持一定的性能。

窗口缩放（Window Scaling）：

原始 TCP 的窗口字段只有 16 位，最多 65535 字节，在高 BDP 场景下（如 1Gbps 带宽 + 150ms RTT）根本不够用——窗口太小，数据流动缓慢。RFC 1323 引入窗口缩放选项，将窗口定义扩展到 32 位（约 4GB），通过一个缩放因子（scale factor，0-14，对应 2^0 到 2^14 倍）在 SYN 包中协商。

协商机制：连接建立时（SYN 段），发送方在 TCP 选项中声明 Window Scale（WSOPT，Kind=3，Length=3，Shift.cnt=缩放值）。接收方如果支持，也在 SYN-ACK 中回应相同的选项。
性能益处：拿我们上面的示例来说（BDP=18.75MB），如果 Shift.cnt=14（16384 倍），16 位字段只需 1146（18.75MB / 16384）就可以覆盖整个Tunnel，避免带宽闲置。

Tips：用 Wireshark 抓包查看 SYN 包的选项字段是否有 WSOPT ，确认缩放是否生效。

TCP 时间戳（Timestamps）：

高延迟网络下，RTT 估算不准会导致拥塞控制失灵，窗口调整迟钝。RFC 1323 的时间戳选项（TSOPT，Kind=8）在每个段中嵌入 32 位时间戳（TSval）和回显值（TSecr），用于两个目的：

RTT 测量（RTTM）：接收方回显发送方的 TSval，发送方计算精确 RTT（不受重传干扰），优化窗口增长和重传超时。
序列号包装保护（PAWS）：在高吞吐量的情况下，32 位序列号容易wrap around，通过时间戳检查，过时的包会被丢弃，保证序列正常。

Tips：时间戳虽然增加了 12 字节的开销，但感觉是利大于弊 —— Red Hat 等系统默认启用，能更好地估算 RTT ， Windows 也默认支持。

时间戳可能泄露系统时钟，但 RFC 建议随机偏移来防止时序攻击，要自己考量

路径 MTU 发现（Path MTU Discovery）

虽然不是 RFC 1323 核心，但1323更新了 RFC 1191 的 PMTUD，支持了 DF（Don't Fragment）位和 ICMP 反馈，动态寻找链路里最大的传输单元（MTU）。这防止了分片开销，在高延迟链路中减少重传的次数。当我们用 VPN ， MTU 也不会乱序匹配，这确保了包大小自适应，避免“黑洞”路由出现。

RFC 1323 已于 2015 年被 RFC 7323 更新（obsoleted），但核心机制不变。在 Windows 上，通过 netsh 命令来调整（比如打开 PMTUD）

4. 还有什么要说的……

常见瓶颈排查

路由器/ISP 限制：检查是否启用了 QoS 限制，或 ISP 的国际出口堵塞。可以用 tracert google.com 看看高延迟的节点。
DNS：测一下延迟，建议用低延迟的非运营商 DNS 。
连接方式：优先用有线连接，减少 Wi-Fi 信号弱导致的衰减。
MTU：默认 MTU 1500 适合大多数场景，但如果连续使用 VPN，可以试试修改：netsh interface ipv4 set subinterface "以太网" mtu=1400 store=persistent。
你在哪里：地区的不同导致出口延迟不同，建议肉身横渡。

额外优化

启用 CTCP（复合 TCP）：增强拥塞控制：netsh interface tcp set global congestionprovider=ctcp。在高带宽高延迟场景下更高效。
禁用 Nagle 算法（游戏/Live）：netsh interface tcp set global nagle=disabled。但这会增加小包开销，不适合文件传输，其实不太推荐。
VPN 优化：如果经常用 VPN，选择 WireGuard 协议，会自动处理窗口缩放。
禁用代理（ProxyEnable）：如果用不着代理服务器，那开启代理可能会增加额外延迟。通过注册表编辑器（regedit）导航到 HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings，将 ProxyEnable 的值设置为 0（DWORD 类型）。

参考：
ietf.org
knowledge.broadcom.com
cisco.com
learn.microsoft.com rfc-editor.org

2025国庆

Tue, 30 Sep 2025 00:00:00 GMT

又到国庆节了，终于放假了，但还是要学习

出去吃了顿小巷子中的火锅，味道一般，但是每道菜的量好大啊

讨厌调休

苔痕的褶皱

Wed, 05 Feb 2025 00:00:00 GMT

苔痕的褶皱

虽然村庄陈旧又腐朽，但我依旧嗅闻得到这片土地的生机勃勃。

南方的山永远苍翠，永远湿漉漉，永远带着毛绒绒的云雾。

村子总会在不经意间变得熙熙攘攘。死尸、活人、牲畜、作物、神明、鬼怪，所有的存在或是不存在都揉在一块儿，好似不存在什么界限一般。

我喜欢走在田埂与水泥路的交界处，冬天的时候枯黄的草在单薄衣服上刮着。空旷却拥塞的田野，牛从不奔跑，狗常对空吠，鸟不知在土堆上捡什么吃。

不觉地走到了村尾，便倚着驳色的墙板就地坐下了。偶能听见老伯的呛咳声伴着羊羔的嘶鸣挤出小屋。若是向屋内俯身探头，会收获那份如一的笑容吧，我想。

老伯并不住在这所小屋，他不在这吃饭睡觉，但这里有他的生活。

这样的村庄是一种复合的味道，硝烟柴火化作烟雾往天上跑。汗津津的动物们、青苔覆盖的砖瓦、陈腐了多年的木头，这种味道，说不上来。

我又去了巷子口那座破败的茅草屋，它在一堆青石砖瓦间显得那么突兀。过去的哪个时代的遗留产物因为一些历史原因无人打扰，便不受干扰地自由地荒废，成为一栋茂盛生长的房屋。

难以想象一个人留在老屋里是怎样的孤寂。

若干年前我站在累起的谷堆上，看见他扬起稻子，笑着问我要不要也试一试。谷粒粘在爷爷未曾被浸染的黑发上。

如今的爷爷，不知何时也会和剥去米粒的稻谷一起飘然化作烟尘，我看不清楚。我能看到的只有他再也挺不起来的腰。

由他保留着的、人家的那串钥匙都去哪里了呢。

我家的房顶已经长满苔藓了。

附录

AI文本检测为0%

C语言考查笔记

Thu, 23 Nov 2023 00:00:00 GMT

:::note 考查目标:

掌握 C 语言程序结构
掌握 C 语言的基本数据类型及数据运算
掌握基本语句的使用
掌握选择结构编程
掌握循环结构编程
掌握数组存储与处理批量数据.
了解模块化程序设计思想, 学会使用函数进行简单编程. :::

1、C 语言程序的结构

1.1 程序的构成, main 函数和其他函数

程序的构成: 一个 C 语言源程序由一个或多个源文件组成. 每个源文件可以由一个或多个函数组成.
主函数 (main 函数): 一个源程序有且只能有一个 main 函数, 它是主函数. 程序执行从 main 开始, 并在 main 中结束.
函数组成: 函数由两部分组成: 声明 (Declaration) 和定义 (Definition, 即函数体, 要执行的代码).

示例代码: main 函数结构

# include <stdio.h> // 预处理命令, 载入头文件
int main() // 主函数
 
{
    printf("Hello World!"); // 标准输出
    return 0;
}

1.2 头文件, 数据说明, 程序注释

头文件: 预处理命令 (以 # 开头) 通常应放在源文件或源程序的最前面.
- 例如, 使用 #include <stdio.h> 来获取标准输入输出函数.
- 系统库中的头文件使用尖括号 < > 引用; 本地目录中的头文件使用双引号 "" 引用.
数据说明（变量定义）:
- 变量在使用前必须声明. 声明方式为 类型标识符变量名列表;.
- 可以在声明时同时初始化变量.
程序注释:
- 单行注释: 使用 //.
- 多行注释（段注释符）: 使用 /* ... */.
- 注意事项: 多行注释不能嵌套, 否则会导致编译错误.

示例代码: 变量定义与注释

#include <stdio.h> // 包含头文件

// 这是一个单行注释
/* 
多行注释:
用于注释跨多行的内容 
*/

const int MAX_LENGTH = 100; // 符号常量声明

int main() 
{
    int myNum = 15;   // 定义并初始化变量 myNum
    float myFloatNum; // 声明变量
    myFloatNum = 5.99; // 初始化变量

    return 0;
}

1.3 源程序的书写格式

语句结束符: 每条语句以分号 ; 结尾. 但预处理命令、函数头和右花括号 } 之后不需要加分号 (结构除外).
大小写: C 语言区分大小写.
书写规范: 常用锯齿形书写格式. 建议花括号 {} 对齐, 一行写一个语句, 使用 TAB 缩进, 有合适的空行, 以提升程序可读性.

2、数据类型及其运算

2.1 C 语言的基本数据类型及定义方法

C 语言的数据类型可分为基本数据类型和派生 (扩展) 数据类型.

基本数据类型:
- 整型: int, short, long.
  - int: 整型, 4 个字节 (32 位), 范围约为 -2,147,483,648 到 2,147,483,647.
  - short: 短整型, 2 个字节 (16 位), 范围约为 -32,768 到 32,767.
  - long: 长整型, 通常为 4 或 8 字节 (取决于系统和编译器). 范围约为 -2,147,483,648 到 2,147,483,647.
- 实型（浮点型）: float (单精度浮点型), double (双精度浮点型), long double.
  - float: 4 个字节 (32 位), 精度约为 7 位十进制数.
  - double: 8 个字节 (64 位), 精度约为 15-16 位十进制数.
  - long double: 10、12 或 16 个字节, 具体取决于编译器, 精度更高.
- 字符型: char.
  - char: 1 个字节 (8 位), 用于存储字符 (如字母、数字、标点符号等).
  - 字符型变量可以直接赋值字符常量 (如 'A', '1', '!'), 也可以赋值对应的 ASCII 码值 (如 65, 49, 33).
- 布尔型: _Bool (0 表示 false, 1 表示 true).
  - _Bool 类型占用 1 个字节 (8 位), 只能存储 0 或 1.
  - 布尔型变量通常用于条件判断和循环控制.
派生/扩展类型: 数组、指针、枚举 (enum), 结构 (struct), 联合 (union) 等.
字符串: 不是一种独立的数据类型, 通过字符数组或字符指针来实现. 以 \0 (空字符) 为结束标志.

示例代码: 基本数据类型定义

// 定义并初始化整数变量
int myNum = 5;
// 定义并初始化浮点数变量
float myFloatNum = 5.99;
// 定义并初始化字符变量
char myLetter = 'D';
// 定义双精度浮点数
double myDouble = 3.2325467;
// 定义布尔型变量
_Bool myBool = 1;
// 定义并初始化字符串变量
char myString[] = "Hello World!";
// 定义并初始化字符数组变量
char myCharArray[] = {'H', 'e', 'l', 'l', 'o', '\0'};
// 定义并初始化指针变量
char *myPointer = "Hello World!";

2.2 C 语言运算符的种类、运算优先级和结合性

C 语言运算符的种类包括:

算术运算符: + (加), - (减), * (乘), / (除), % (取模), ++ (增量), -- (乘量/减量).
赋值运算符: = (赋值), +=, -=, *=, /=, %= 等. (a += b → a = a + b)
- 自增运算符前置与后置的区别:
- ++ 和 -- 运算符放在变量前面 (如 ++i, --i) 称为前置, 先进行自增/自减操作, 再使用变量的值
- ++ 和 -- 运算符放在变量后面 (如 i++, i--) 称为后置, 先使用变量的当前值, 再进行自增/自减操作
关系运算符（比较运算符）: == (等于), != (不等于), > (大于), < (小于), >= (大于或等于), <= (小于或等于).
逻辑运算符: && (逻辑与), || (逻辑或), ! (逻辑非). 优先级为 ! 优于 && 优于 ||.
条件运算符: ? :, 是 C 语言中唯一的三目运算符.
位运算符: 双目 & (按位与), | (按位或), ^ (异或), << (左移), >> (右移); 单目 ~ (取反).
指针运算符: 单目 * (取内容/解引用), & (取地址). 注意: * 也可作乘法 (双目), & 也可作按位与 (双目), 以具体用法为准.
求字节数运算符: sizeof.

示例代码: 重要运算符的使用

// 算术运算符和前置/后置
int a = 5, b = 3;
int sum = a + b;        // 加法

// 前置和后置自增
int x = 10;
int y = ++x;  // x 先自增为 11, 然后赋值给 y, y = 11
int z = x++;  // x 的当前值 11 赋值给 z, 然后 x 自增为 12, z = 11

// 关系运算符
int result1 = (a > b);  // result1 = 1 (true)
int result2 = (a == b); // result2 = 0 (false)

// 逻辑运算符
// 可以对表达式、单个数字或变量进行逻辑运算
int result3 = (a > 0 && b < 10);  // result3 = 1 (true)
int result4 = (a < 0 || b > 10);  // result4 = 0 (false)
int result5 = !(a == b);          // result5 = 1 (true)
int result6 = !a || b;            // result6 = 1 (true), 因为 !a 为 0, 0 || 3 为真

// 条件运算符
int max = (a > b) ? a : b;  // 条件为真返回 a, max = 5

// 位运算符
int bitwise_and = a & b;   // 按位与: 对应位都为 1 时结果为 1, 否则为 0, 这里 5 & 3 = 1 (二进制: 101 & 011 = 001)
int bitwise_or = a | b;    // 按位或: 对应位有一个为 1 时结果为 1, 否则为 0, 这里 5 | 3 = 7 (二进制: 101 | 011 = 111)
int left_shift = a << 1;   // 左移 1 位: 相当于乘以 2, 例如 5 << 1 = 10 (二进制: 101 << 1 = 1010)

// 指针运算符
int *ptr = &a;  // ptr 是一个指针变量, 它存储了变量 a 的内存地址
int value = *ptr;  // 通过指针获取 a 的值, value = 5

// sizeof 运算符
int size = sizeof(int);  // size = 4

2.3 不同类型数据间的转换与运算

自动转换（隐式转换）——考试核心原则:
- 总原则: 不同类型数据混合运算时, 系统会自动将其转换为同一类型. 转换方向通常是向精度更高、范围更大的类型进行 (即“向高转”), 以减少精度损失.
- 小整数先升级: char、short 在运算前会先被提升为 int.
- 浮点“吞”整数: float 或 double 与整数运算时, 整数会被转换为浮点型; 其中 float 参与运算通常会进一步提升为 double.
- 复杂情况: 有符号（如 int）与无符号整型（如 unsigned int）混合运算, 转换规则取决于具体数值和编译器实现, 结果类型无固定顺序, 需特别注意.
- 浮点转整型: 任何浮点型赋值给整型时, 会直接丢弃小数部分 (向零取整).
强制转换（显式转换）:
- 语法: (类型标识符)表达式.
- 类型转换是临时性的, 不会改变变量本身的数据类型.
- 运算过程中, 自动类型提升: 低精度数据类型向高精度数据类型转换.

示例代码: 类型转换

int a = 2, b = 5;
double x, y, z;

x = b / a;        // 隐式转换: b/a 先进行整型除法 (2), 然后赋值给 double 型 x, x = 2.0
y = (double)b / a; // 强制转换: 先将 b 转化为 double 型 (5.0), 然后进行浮点数除法, y = 2.5
z = (double)(b / a); // 强制转换: 先计算整型除法 (2), 然后将结果 2 转化为 double 型, z = 2.0

2.4 C 语言表达式类型和求值规则

赋值表达式: 将右侧的值赋给左侧的变量, 例如 x = 5. 赋值号具有结合性, 如 x=y=3 等价于 y=3; x=y;.
算术表达式: 使用算术运算符连接常量和变量, 例如 sum = x + y.
关系表达式: 使用关系运算符进行比较, 返回 1 (真) 或 0 (假).
逻辑表达式: 使用逻辑运算符连接表达式.
- 短路求值: 对于 &&, 如果左侧为假, 则不再计算右侧; 对于 ||, 如果左侧为真, 则不再计算右侧.
条件表达式（三元运算符）:
- 语法: (条件表达式) ? 表达式1 : 表达式2.
- 求值规则: 如果条件表达式为真, 返回表达式 1 的值, 否则返回表达式 2 的值.
逗号表达式:
- 语法: 表达式1, 表达式2.
- 求值规则: 先计算表达式 1, 再计算表达式 2, 并将表达式 2 的值作为整个表达式的结果.

示例代码: 条件表达式（三元运算符）

int time = 20;

int main() {
    (time < 18) ? printf("再会!") : printf("晚上好!"); // 输出 -> "晚上好!"
    return 0;
}

示例代码: 逗号表达式

int a = 2, b;

int main() {
    a = 3 * 5, a + 10; // a=15, 整个表达式结果是 15+10=25, 但后面的 a+10 未赋值, 丢弃
    b = (3 * 5, a + 10); // 使用括号, 3*5=15 (未赋值, 丢弃), 然后 a+10=25, b=25
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

3、基本语句

3.1 表达式语句, 空语句, 复合语句

表达式语句: 由表达式 (如赋值表达式、函数调用) 后跟分号组成.
空语句: 只有分号 ;.
复合语句: 将多个语句用花括号 {} 括起来组成的一个语句. 通常用于 if, for, while 等结构中, 作为循环体或条件体.

3.2 输入输出函数的调用, 正确输入数据并正确设计输出格式

输出函数的调用: 使用 printf().
- 语法: printf("格式控制字符串", 输出变量列表);.
输入函数的调用: 使用 scanf().
- 语法: scanf("格式控制字符串", 输入变量地址列表);. 注意最后一个参数是变量的地址列表.
格式说明符 (作用): 充当变量输出时的占位符, 用于指定变量的输出格式.
- %d 或 %i: int 整数 (10 进制).
- %u: 无符号十进制整数
- %f: float 浮点数 (小数形式).
- %.2f: 浮点数保留2位小数
- %lf: double 高精度浮点数据.
- %c: char 字符.
- %s: 字符串.
- %.5s: 字符串最多输出5个字符
输出格式设计（宽度控制）:
- 使用 %md 或 %-md 控制输出宽度 m.
  - %md: 最少占 m 个字符宽度, 默认右对齐.
  - %-md: 最少占 m 个字符宽度, 左对齐.

示例代码: 输入输出及格式控制

#include <stdio.h>

int main()
{
    int myNum;
    float f = 5.99;
    
    // 输出
    printf("Number = %d\n", (int)f); // 输出整数, 5
    printf("Value = %.2f\n", f); // 输出浮点数, 保留两位小数, 5.99
    
    // 输出格式控制（左对齐, 宽度为 9）
    int a1 = 20;
    printf("%-9d\n", a1); // 输出 20, 左对齐, 宽度为 9

    // 输入
    printf("请输入一个数字: \n");
    scanf("%d", &myNum); // 获取并保存用户输入的号码, 需要使用 & 引用运算符
    printf("您输入的数字: %d\n", myNum);
    
    return 0;
}

4、选择结构程序设计

4.1 用 if 语句实现选择结构

if 语句: 用于根据条件执行代码块.
if...else 语句: 在 if 条件不满足时执行 else 代码块.
else if 语句: 用于检查多个条件.

示例代码: if-else if-else 结构

int time = 22;
if (time < 10) {
    printf("早上好!");
} else if (time < 20) {
    printf("再会!");
} else {
    printf("晚上好!"); // 输出 -> "晚上好!"
}

4.2 用 switch 语句实现多分支选择结构

switch 语句: 根据表达式的值跳转到匹配的 case 标签.
表达式类型: switch 表达式可以是整型、字符型和枚举型.
break 语句: 匹配到 case 后执行相应代码, 并通过 break 跳出 switch.
default 语句: 如果没有匹配到任何 case, 则执行 default 语句 (如果存在). default 不是必需的.
贯穿现象: 如果没有 break, 程序会继续执行下一个 case 的代码. 这种特性被称为“贯穿” (fallthrough), 有时被故意用于让多个 case 共享同一段执行代码.

示例代码: switch 结构

int day = 4;
switch (day) {
    case 3:
        printf("周三");
        break;
    case 4:
        printf("周四"); // 匹配到 case 4
        break; // 跳出 switch
    default:
        printf("期待周末");
}
// 输出 -> "周四"

4.3 选择结构的嵌套

if 语句可以嵌套.
嵌套时, 每一层 if 都要和 else 配套, 若没有 else, 则需要将该层 if 语句用 {} 括起来.

示例代码: if 嵌套

int time = 10;
if (time > 8) {
    // 嵌套一个 if
    if (time < 12) {
        printf("中午好!"); // 输出 -> "中午好!"
    }
}

5、循环结构程序设计

5.1 for 循环结构

for 循环结构包含三个表达式: 初始化语句 (表达式 1, 只执行一次), 循环条件表达式 (表达式 2, 每次循环前检查), 调整操作 (表达式 3, 循环体执行后执行).
当条件表达式 (表达式 2) 为假时, for 循环结束.
三个表达式都不是必须的, 但分号不能省略. 如果表达式 2 为空, 则表示无限循环.

示例代码: for 循环

int i;
for (i = 0; i < 5; i++) { // i=0 (初始化), i<5 (循环条件), i++ (调整操作)
    printf("%d\n", i);
}
// 输出 -> 0 1 2 3 4

// 省略表达式1（初始化在外部进行）
int i = 0;
for (; i < 5; i++) {
    printf("%d\n", i);
}

// 省略表达式3（调整操作在循环体内进行）
for (i = 0; i < 5;) {
    printf("%d\n", i);
    i++;
}

// 省略表达式2（无限循环）
for (i = 0; ; i++) {
    if (i >= 5) break;  // 需要用break来跳出循环
    printf("%d\n", i);
}

// 三个都省略（必须有办法跳出循环）
for (;;) {
    printf("无限循环");
    break;  // 必须有退出条件
}

5.2 while 和 do-while 循环结构

特征	`while` 循环	`do-while` 循环
控制类型	入口控制循环 (Entry-Controlled)	出口控制循环 (Exit-Controlled)
条件检查	在循环体执行前检查	在循环体执行后检查
执行保证	可能执行 0 次或多次	至少执行 1 次
语法结尾	`}` 后无分号	`while(条件)` 后有分号

示例代码: while 循环

int i = 0;
while (i < 5) {
    printf("%d\n", i); // 初始条件为假时，循环体不执行
    i++;
}
// 输出 -> 0 1 2 3 4

示例代码: do-while 循环

int i = 0;
do {
    printf("%d\n", i);
    i++;
} while (i < 5); // ← 注意：分号不能省略，这是必须的
// 输出 -> 0 1 2 3 4

5.3 continue 语句和 break 语句

break 语句: 跳出当前 循环 或 switch 语句, 执行后续代码.
continue 语句: 跳过当前循环的剩余语句, 直接进入下一次循环.
通常与 if 语句配合使用.

示例代码: break 语句

int i;
for (i = 0; i < 10; i++) {
    if (i == 4) {
        break; // 当 i=4 时跳出循环
    }
    printf("%d\n", i);
}
// 输出 -> 0 1 2 3

示例代码: continue 语句

int i;
for (i = 0; i < 10; i++) {
    if (i == 4) {
        continue; // 当 i=4 时跳过本次循环的剩余部分 (即跳过 printf)
    }
    printf("%d\n", i);
}
// 输出 -> 0 1 2 3 5 6 7 8 9

5.4 循环的嵌套

循环可以嵌套.
嵌套循环的核心在于执行顺序, 外部循环每执行一次, 内部循环都要完整地执行完所有轮次.
总的循环体执行次数是: 外循环次数 × 内循环次数.

示例代码: 循环嵌套 (遍历二维数组)

int N = 5;
// 假设 A 是一个 N x N 的二维数组, 外部循环控制行, 内部循环控制列 
for(int i = 0; i < N; i++) 
{
    for(int j = 0; j < N; j++) 
    {
    printf("%d ", A[i][j]); // 循环体语句, 访问 A[i][j]
    }
}

示例代码: 循环嵌套 (九九乘法表)

for (int i = 1; i <= 9; i++) { // 外层循环控制行
    for (int j = 1; j <= i; j++) { // 内层循环控制列
        printf("%d*%d=%2d ", j, i, i*j); // %2d 表示右对齐，占两个宽度
    }
    printf("");
}

6、数组的定义和引用

6.1 一维数组的定义、初始化和数组元素的引用

定义: 一维数组的声明格式为 类型标识符数组名[n], 其中 n 是一个正整数常量, 表示数组的长度. (声明时指定长度不可省略, 但初始化时可省略长度由编译器自动推断.)
引用: 通过 数组名[k] 引用数组元素, 下标 k 的合法取值范围是从 0 到 n-1.
初始化: 可以在声明时同时赋初值.
- 当在定义时对所有元素都进行初始化时, 可以省略数组长度 [n], 编译器会根据初始化列表的元素个数自动确定数组长度.
- 可以只初始化部分元素, 未被初始化的元素将被自动赋值为 0.

示例代码: 一维数组的定义和引用

#include <stdio.h>

int main() {
    // 定义并完全初始化
    int nums1[] = {10, 20, 30, 40};  // 自动推断长度为4
    
    // 定义固定长度数组（部分初始化）
    int nums2[5] = {1, 2};           // [1,2,0,0,0]
    
    // 访问元素
    printf("第一个元素: %d\n", nums1[0]);  // 输出: 10 
    // 修改元素
    nums1[0] = 100;
    printf("修改后: %d\n", nums1[0]);     // 输出: 100
    
    // 遍历数组（需获取长度）
    // 注意：此方法仅适用于函数内定义的局部数组，不适用于函数参数（参数会退化为指针）
    int length = sizeof(nums1) / sizeof(nums1[0]);
    printf("数组长度: %d\n", length);     // 输出: 4
    
    printf("遍历数组:");
    for(int i = 0; i < length; i++) {
        printf(" %d", nums1[i]);         // 输出: 100 20 30 40
    }
    
    return 0;
}

6.2 二维数组的定义、初始化和数组元素的引用

定义: 二维数组声明格式为 类型标识符变量名[m][n], 声明一个 $m$ 行 $n$ 列的二维数组.
引用: 通过 变量名[i][j] 引用元素, 其中 $i$ 为行下标 (0 到 $m-1$), $j$ 为列下标 (0 到 $n-1$).
存储: 二维数组是按行顺序连续存储的. (一行一行)
初始化: 可以分组初始化, 也可以省略第一维 (行) 的大小 (但不能省略其他维数, 如列数).

示例代码: 二维数组的定义和引用

#include <stdio.h>

int main() {
    // 1. 定义并初始化二维数组（2行3列）
    int matrix[2][3] = { 
    // 2. int matrix2[][3] 省略行数, 自动推断为2行
        {1, 3, 5},   // 第一行
        {2, 6, 10}   // 第二行
    };
    
    // 3. 连续初始化方式
    int matrix3[2][3] = {1, 2, 3, 4, 5, 6}; // 等价于{{1,2,3},{4,5,6}}
    
    // 4. 访问元素：获取第二行第一列的元素（值为2）
    printf("matrix[1][0] = %d\n", matrix[1][0]);  // 输出: 2
    
    // 5. 修改元素：将第一行第二列的元素改为100
    matrix[0][1] = 100;
    printf("修改后: matrix[0][1] = %d\n", matrix[0][1]);  // 输出: 100
    
    // 6. 遍历二维数组
    // 注意：此方法仅适用于局部数组，不适用于函数参数
    int rows = sizeof(matrix) / sizeof(matrix[0]);     // 计算行数
    int cols = sizeof(matrix[0]) / sizeof(matrix[0][0]); // 计算列数
    
    printf("遍历matrix数组:");
    for(int i = 0; i < rows; i++) {
        for(int j = 0; j < cols; j++) {
            printf("%d\t", matrix[i][j]); // 使用制表符对齐
        }
        printf(""); // 每行结束后换行
    }
    /* 输出:
        1       100     5
        2       6       10
    */
    
    return 0;
}

6.3 字符串与字符数组

字符串本质: 在 C 语言中, 字符串是以 \0 结尾的字符数组, 而不是一种单独的数据类型. \0 是字符串结束标志符.
定义: 可以通过字符数组来表示字符串.

示例代码: 字符串定义和引用

// 单引号定义并初始化字符
char c = 'a';
printf("%c\n", c); // 输出 'a'

// 双引号定义并初始化字符串 (会自动添加 \0)
char greetings[] = "Hello World!";
printf("%s\n", greetings);

// 字符数组初始化 (手动添加, 显式包含 \0)
char greetings2[] = {'H', 'e', 'l', 'l', '\0'};
printf("%s\n", greetings2); // 输出 "Hell"

// 访问/修改字符串中的字符
char greetings3[] = "Hello";
printf("%c\n", greetings3[0]); // 访问第一个字符 'H'
greetings3[0] = 'J'; // 修改第一个字符为 'J'
printf("%s\n", greetings3); // 输出 "Jello"

6.4 使用一维数组解决批量数据查找或排序等问题

一维数组常用于批量数据的查找和排序
若数组无序, 采用顺序查找 ( 从头到尾依次比较 )

若数组有序, 采用折半查找 ( 二分查找 ), 效率更高

示例代码: 顺序查找

// a 为数组, n 为长度, num 为待查找元素
int found = 0; // 标志变量, 是否找到
for (int i = 0; i < n; i++) { // 从头到尾遍历数组
    if (a[i] == num) { // 如果找到
        found = 1;
        break; // 跳出循环
    }
}
// found==1 表示找到, 否则未找到

示例代码: 折半查找 ( 数组有序 )

// a 为有序数组, n 为长度, num 为待查找元素
int low = 0, high = n - 1, found = 0; // 初始化区间和标志
while (low <= high) { // 只要区间不为空
    int mid = (low + high) / 2; // 取中间下标
    if (a[mid] == num) { // 找到
        found = 1;
        break;
    }
    else if (num > a[mid])
        low = mid + 1; // 在右半区间查找
    else
        high = mid - 1; // 在左半区间查找
}
// found==1 表示找到, 否则未找到

排序常用选择排序、冒泡排序、插入排序, 都是基础算法, 适合小规模数据

三者核心思想都是通过循环比较和交换, 逐步将数组变为有序

示例代码: 选择排序:

// a 为数组, n 为长度
for (int i = 0; i < n - 1; i++) { // 外层循环, 控制趟数
    for (int j = i + 1; j < n; j++) { // 内层循环, 找最小值
        if (a[j] < a[i]) { // 如果有更小的值
            int t = a[j]; a[j] = a[i]; a[i] = t; // 交换元素
        }
    }
}
// 排序后数组 a 升序排列

示例代码: 冒泡排序:

// a 为数组, n 为长度
for (int i = 0; i < n - 1; i++) { // 外层循环, 控制趟数
    for (int j = 0; j < n - 1 - i; j++) { // 内层循环, 相邻元素比较
        if (a[j] > a[j + 1]) { // 如果前面的比后面大
            int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t; // 交换元素
        }
    }
}
// 排序后数组 a 升序排列

示例代码: 插入排序:

// a 为数组, n 为长度
for (int i = 1; i < n; i++) { // 从第二个元素开始
    int k = a[i]; // 待插入元素
    int j = i - 1; // 比较的元素下标
    while (j >= 0 && k < a[j]) { // 向前查找插入位置
        a[j + 1] = a[j]; // 后移
        j--; // 继续向前比较
    }
    a[j + 1] = k; // 插入到合适位置
}
// 排序后数组 a 升序排列

7、函数定义与调用

7.1 库函数的正确调用

C 语言的系统库中提供了几百个函数可供程序员直接使用.
使用库函数时, 要包含相应的头文件. 例如:
- <stdio.h>: printf() (格式化输出), scanf() (格式化输入) .
- <math.h>: sqrt() (平方根), pow() (幂运算), fabs() (绝对值) .
- <stdlib.h>: rand() (伪随机整数), srand() (设置种子) .
- <string.h>: strlen() (字符串长度), strcpy() (字符串复制) .
- <time.h>: time() (获取当前时间), clock() (获取处理器时间) .

示例代码: 调用库函数

#include <stdio.h>
#include <math.h> // 需要包含 math.h 头文件

int main()
{
    // 调用库函数 sqrt (平方根)
    printf("%f", sqrt(16)); // 输出 4.000000
    return 0;
}

7.2 用户自定义函数的定义、类型与返回值

函数定义: 由函数头和函数体组成.
- 函数头: 类型标识符函数名(形式参数列表).
- 函数体: 包含要执行的代码.
函数类型与返回值:
- 函数的类型 (即返回值的类型) 由函数头前的“类型标识符”指明.
- 若没有返回值, 则使用 void.
- 函数返回值通过 return 语句给出. 若函数无返回值, 可以不写 return.

示例代码: 自定义函数定义与返回值

// 函数定义: 返回 int 类型, 接受两个 int 参数
int myFunction(int x, int y) 
{
    return x + y; // 返回 x 和 y 的和
}

// 无返回值函数定义 (使用 void)
void greetUser(char name[]) 
{
    printf("Hello %s\n", name);
}

7.3 函数的正确调用、参数的值传递

函数调用: 语法为 函数名(实际参数列表).
形式参数 (形参): 在函数定义时列出的参数, 它们本质上是局部变量, 仅在函数体内有效. 例如 void fun(int k) 中的 k.
实际参数 (实参): 在函数调用时传入的值或表达式, 例如 fun(i) 中的 i, 实参可以是局部变量、全局变量、常量/表达式.
值传递: 将实参的值传递给对应的形参.
- 形参是局部变量, 在函数被调用时分配存储单元, 调用结束即被释放.
- 对形参的任何改变都不会对实参产生任何影响 (单向传递).
地址传递（数组）: 将整个数组传递给被调函数时, 传递的是数组的首地址.
- 在函数中对形参数组的任何修改都会影响到实参数组.

示例代码: 形参 (局部) 与实参的来源

// fun 的 k 是形参（局部变量）
void fun(int k) {
    printf("fun received %d\n", k);
}

int main() {
    int i = 5; // main 内部的局部变量
    fun(i);    // i 作为实参传入
    fun(10);   // 常量 10 作为实参传入
    return 0;
}

示例代码: 函数调用与值传递

// 假设 myFunction 已定义为 int myFunction(int x, int y) { return x + y; }
int main() 
{
    // 调用函数并将结果打印
    printf("结果: %d", myFunction(5, 3)); // 传递 5 和 3 的值作为实参

    int result = myFunction(5, 3); // 将结果存储在变量中

    return 0;
}

7.4 函数的嵌套调用、递归调用

嵌套调用: 函数可以嵌套调用, 但不能嵌套定义.
递归调用: 函数可以直接或间接调用自己.

示例代码: 嵌套调用（简单加法）

#include <stdio.h>

int add(int a, int b);

int main() 
{
    printf("结果: %d", add(add(1, 2), 3)); // 嵌套调用 add 函数
    return 0;
}

int add(int a, int b) 
{
    return a + b;
}

示例代码: 递归调用（简单递归求和）

#include <stdio.h>

int sum(int n);

int main() 
{
    printf("结果: %d", sum(5)); // 计算 1+2+3+4+5
    return 0;
}

int sum(int n) 
{
    if (n == 0) {
        return 0; // 基础情况
    } else {
        return n + sum(n - 1); // 递归调用自身
    }
}

7.5 局部变量与全局变量

局部变量: 在函数 (如形参和函数中定义的变量) 或语句块 (如循环体内定义的变量) 内有效 (可见).
全局变量: 在所有函数外定义, 其作用域为整个程序; 在它后面定义的函数中均可使用.
同名变量的屏蔽: 若局部变量与全局变量同名, 则优先使用局部变量 (屏蔽全局变量) .
外部变量声明: 若要在其他文件中使用未定义的全局变量, 则需声明其为外部变量, 使用 extern 数据类型名变量名.

示例代码: 局部变量与全局变量

#include <stdio.h>

int k_global = 2; // 全局变量

int main() 
{
    int i = 5; // 局部变量
    int x; 
    x = i + k_global; 
    printf("x=%d\n", x); // 使用全局变量 k_global, x = 7

    {
        int k_global = 16; // 语句块内的局部变量 (与全局变量同名)
        x = i + k_global;
        printf("x=%d\n", x); // 优先使用局部变量, x = 5 + 16 = 21
    }
    
    x = i + k_global;
    printf("x=%d\n", x); // 语句块结束后, 恢复使用全局变量 k_global, x = 7

    return 0;
}

示例代码: 外部变量声明

// 示例：
// file1
int globalVar = 10; // 定义全局变量

// file2
#include <stdio.h>

extern int globalVar; // 声明外部变量
void printGlobalVar() {
    printf("%d\n", globalVar);
}

Charlotte-Markdown

Tue, 30 Oct 2018 00:00:00 GMT

Charlotte-Markdown 使用说明

本文直接参考Fuwari的相关指南

~~其实是为了防止未来的自己忘了该怎么写Post~~

封面： Collector by Ashima

创建文章

文章元数据

---
title: Charlotte-Markdown
published: 2018-10-30
description: 'Charlotte-Markdown 是 Charlotte 主题的 Markdown 语法说明文档'
image: './Markdown.webp'
tags: [Charlotte, 公告, Markdown]
category: '公告'
draft: false 
lang: ''
---

属性名	描述
`title`	文章标题
`published`	文章发表时间
`description`	文章简介。会显示在主页上
`image`	文章封面图 1. 以 `http://` or `https://`开头: 使用网络图片 2. 以 `/`: 开头来使用 `public` 中的图片 3. 没有任何前缀：使用相对于Markdown文件的图片
`tags`	文章的标签
`category`	文章的分类
`draft`	`true`或者`false`。是否为草稿。如果为`true`，则不会显示在主页上。

发布文章的存放位置

你发布的文章应当在 src/content/posts/ 目录下. 你也可以创建一个子目录，用来存放文章和文章中的资源。

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown 语法

这是一个 h1 标题

这是一个 h2 标题

这是一个 h3 标题

段落之间用空行分隔。（或双空格+换行进行内部换行）

这是第二段斜体、粗体和 代码行。

无序列表

这是一项
这是一项
这是另一项

有序列表

第一项
第二项
第三项

嵌套列表

首先有这两个对象
- 你
- 我
一定要记住
不能忘

找到我

说晚安

链接和脚注

这里有一个链接到一个网站、本地文档和当前文档中的某个章节标题。这里有一个脚注^1。

图片引用

Markdown 语法引入图片

示例：

![头像图片](/favicon/icon_256.webp "我的头像")

HTML 标签引入图片

示例：

<img src="/favicon/icon_256.webp" alt="头像图片" width="256" height="256" />

路径说明

图片路径有以下几种方式：

网络图片：以 http:// 或 https:// 开头

![网络图片](https://example.com/image.jpg)

公共目录图片：以 / 开头，相对于 public 目录
```
![公共图片](/favicon/icon_256.webp)
```
相对路径图片：相对于当前 Markdown 文件的位置
```
![相对图片](./images/photo.jpg)
```

数学公式

行内数学公式是这样写的：$\omega = d\phi / dt$。

显示数学公式应该独占一行，用双美元符号包裹：

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;\ldots \end{equation*} $$

GitHub 仓库卡片

你可以添加一个链接到一个 GitHub 仓库的动态卡片。当页面加载时，将从 GitHub API 获取仓库信息。

::github{repo="ChuwuYo/Charlotte"}

创建一个 Github 仓库卡片，只需在 Markdown 文件中添加一行 ::github{repo="<owner>/<repo>"}。

::github{repo="ChuwuYo/Charlotte"}

警告

支持这些类型的警告: note tip important warning caution

:::note 突出显示用户在浏览时也应考虑的信息。 :::

:::tip 可选的信息，以帮助用户更顺利地理解。 :::

:::important 用户完成任务所必需的关键信息。 :::

:::warning 关键内容，由于潜在风险需要用户立即关注。 :::

:::caution 行动的负面潜在后果。 :::

基本语法

:::note
突出显示用户在浏览时也应考虑的信息。
:::

:::tip
可选的信息，以帮助用户更顺利地理解。
:::

自定义标题

警告的标题可以自定义。

:::note[自定义标题] 这是一个带有自定义标题的提示。 :::

:::note[自定义标题]
这是一个带有自定义标题的提示。
:::

GitHub 语法

[!TIP] 同时也支持 GitHub 语法。

> [!NOTE]
> 也支持 GitHub 语法。

> [!TIP]
> 也支持 GitHub 语法。

剧透内容

你可以为文本添加剧透。文本也支持 Markdown 语法。

内容 :spoiler[被隐藏起来了哈哈]！

内容 :spoiler[被隐藏起来了 **哈哈**]！

视频卡片

只需从 YouTube 或其他平台复制嵌入代码，然后将其粘贴到 markdown 文件中。

YouTube

只需从 YouTube 复制嵌入代码，然后粘贴到 Markdown 文件中即可。

杂项

特殊符号

长破折号：使用三个破折号 --- 表示长破折号（——）
范围符号：使用两个破折号 -- 表示范围（例如，"第 12—14 章"）
省略号：三个点 ... 将被转换为省略号（……）

Unicode 支持

支持 Unicode 字符，例如表情符号：☺ ★ ♥ ♦ ♣ ♠ ● ○ ◇ ◆ □ ■ △ ▲ ※ → ← ↑ ↓

转义字符

如果需要显示特殊字符的原样，可以使用反斜杠 \ 进行转义：

\_ 显示为 _（而不是斜体）
\* 显示为 *（而不是粗体）
\`` 显示为 `` （而不是代码）

缩进

缩进始终保持为四个空格的距离，你也可以使用制表符（Tab）。

行块

| 第一行 | 第二行 | 第三行

初五的小窝

序章

欢迎来到 Chuwu 的博客。

这个博客是使用 Astro 框架和基于 Fuwari 的 Charlotte主题 构建的。

不知道我们能走多久呢……

MySQL学习笔记 (8)

INSERT INTO

UPDATE

DELETE

视图

事务

参考

Python 札记 (8)

import

包与 init.py

if name == 'main'

print 与 input

open 读写与 with

路径：pathlib 与 os.path

os 常用

class

类型注解

venv：虚拟环境

标准库地图

附录：import 形式速查

附录：open 模式与 pathlib 对照

附录：typing 常用符号（3.10+ 风格）

参考

MySQL学习笔记 (7)

JOIN

LEFT JOIN / RIGHT JOIN

CROSS JOIN

UNION

子查询

参考

Python 札记 (7)

定义函数 def

参数

return

lambda

命名空间与作用域

global 与 nonlocal

try / except / else / finally

内置异常

with 与上下文管理器

iter 与 next

生成器与 yield

装饰器

附录：内置异常继承关系

附录：函数参数汇总

参考

MySQL学习笔记 (6)

聚合函数

GROUP BY

HAVING

NULL 和聚合

参考

Python 札记 (6)

条件：if / elif / else

比较与链式比较

三元表达式（条件表达式）

循环：while 与 for

while

for

break、continue

循环的 else 子句

match / case（3.10+）

range

enumerate 与 zip

斐波那契

列表推导式

保序去重

集合与字典推导式

生成器表达式

附录：控制流与推导式语法速查

常用内置（循环相关）

参考

MySQL学习笔记 (5)

WHERE 子句

AND、OR、NOT

这个博客是使用 Astro 框架和基于 Fuwari 的 Charlotte主题构建的。