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。

参考

1. MySQL 26.7 · INSERT
2. MySQL 26.7 · UPDATE
3. MySQL 26.7 · DELETE
4. MySQL 26.7 · CREATE VIEW
5. MySQL 26.7 · START TRANSACTION
6. ISO/IEC 9075（SQL:2023）

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：

'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 是总入口。常用模块：

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

附录：import 形式速查

附录：open 模式与 pathlib 对照

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

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

参考

官方文档（中文版）：

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

PEP：

1. PEP 484 — Type Hints
2. PEP 526 — Syntax for Variable Annotations
3. PEP 585 — Type Hinting Generics In Standard Collections
4. PEP 604 — Allow writing union types as X | Y
5. PEP 420 — Implicit Namespace Packages
6. PEP 8 — Style Guide — import 顺序等

菜鸟教程：

1. 菜鸟教程 · Python3 模块
2. 菜鸟教程 · Python3 输入和输出
3. 菜鸟教程 · Python3 文件方法
4. 菜鸟教程 · OS 文件/目录
5. 菜鸟教程 · Python3 面向对象
6. 菜鸟教程 · 虚拟环境
7. 菜鸟教程 · 类型注解
8. 菜鸟教程 · 标准库概览

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;

参考

1. MySQL 26.7 · JOIN
2. MySQL 26.7 · Set Operations
3. MySQL 26.7 · Subqueries
4. MySQL 26.7 · EXISTS
5. ISO/IEC 9075（SQL:2023）

定义函数 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。

一般不捕获 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。缩进表示子类。

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

附录：函数参数汇总

参考

官方文档（中文版）：

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

PEP：

1. PEP 318 — Decorators for Functions and Methods
2. PEP 343 — The "with" Statement
3. PEP 3102 — Keyword-Only Arguments
4. PEP 3110 — Catching exceptions in Python 3000

菜鸟教程：

1. 菜鸟教程 · Python3 函数
2. 菜鸟教程 · Python3 迭代器与生成器
3. 菜鸟教程 · Python3 装饰器
4. 菜鸟教程 · Python3 错误和异常
5. 菜鸟教程 · Python3 命名空间/作用域
6. 菜鸟教程 · Python3 with
7. 菜鸟教程 · Python3 lambda

聚合函数

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

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)

参考

1. MySQL 26.7 · Aggregate Functions
2. MySQL 26.7 · GROUP BY
3. MySQL 26.7 · SELECT
4. ISO/IEC 9075（SQL:2023）

条件：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。

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

常用内置（循环相关）

参考

官方文档（中文版）：

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

PEP：

1. PEP 636 — Structural Pattern Matching — match / case

菜鸟教程：

1. 菜鸟教程 · 条件控制
2. 菜鸟教程 · 循环语句

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 子句中搜索指定模式。

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。

参考

1. MySQL 26.7 · Comparison Operators
2. MySQL 26.7 · Logical Operators
3. MySQL 26.7 · LIKE
4. MySQL 26.7 · CASE
5. ISO/IEC 9075（SQL:2023）

字典 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 保持插入顺序；更新已有键的值不改变该键在顺序中的位置；删除后再插入的键排到末尾。

插入、查找、删除

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

字典推导式

语法 {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。

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）：

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 等及对应运算符）。

容易踩的坑

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

附录：dict 方法

Mapping Types — dict。

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

附录：set / frozenset 方法

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

参考

官方文档（中文版）：

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

菜鸟教程：

1. 菜鸟教程 · 数据结构

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;

参考

1. MySQL 26.7 · SELECT
2. MySQL 26.7 · SELECT … DISTINCT
3. MySQL 26.7 · Sorting Rows
4. ISO/IEC 9075（SQL:2023）

列表

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）：

创建列表

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 怎么选

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

附录：list 可变序列方法

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

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

tuple 可用操作小结

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

参考

官方文档（中文版）：

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

PEP：

1. PEP 3132 — Extended Iterable Unpacking
2. PEP 448 — Additional Unpacking Generalizations

菜鸟教程：

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

创建数据库

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', '教授');

约束

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

外键列可以是 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;

参考

1. MySQL 26.7 · CREATE SCHEMA
2. MySQL 26.7 · CREATE TABLE
3. MySQL 26.7 · Constraints
4. MySQL 26.7 · FOREIGN KEY
5. MySQL 26.7 · ALTER TABLE
6. MySQL 26.7 · CREATE INDEX
7. ISO/IEC 9075（SQL:2023）

数字类型总览

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

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。

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）：

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：

附录：random 模块函数表

random — Generate pseudo-random numbers：

附录：str 常用方法表

Text Sequence Type — str：

参考

官方文档（中文版）：

1. Numeric Types — int, float, complex
2. Text Sequence Type — str
3. printf-style String Formatting
4. An Informal Introduction to Python — Numbers, Strings
5. Using Python as a Calculator — Strings
6. Format String Syntax
7. math — Mathematical functions
8. random — Generate pseudo-random numbers
9. Lexical analysis — Literals

PEP：

1. PEP 498 — Literal String Interpolation (f-strings)
2. PEP 515 — Underscores in Numeric Literals

菜鸟教程：

1. 菜鸟教程 · Number
2. 菜鸟教程 · 字符串
3. 菜鸟教程 · 格式化

数据类型

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

金额用 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, ''))

常用函数：

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

参考

1. MySQL 26.7 · Data Types
2. MySQL 26.7 · Date and Time Types
3. MySQL 26.7 · CAST
4. MySQL 26.7 · String Functions
5. MySQL 26.7 · COALESCE
6. ISO/IEC 9075（SQL:2023）

变量与赋值

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 里，对象分可变与不可变：

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

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）：

此外还有 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'

算术运算符

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 的旧规则。

赋值与增强赋值

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

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

逻辑运算符

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

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

成员与身份运算符

"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）：

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

附录：内置类型速查

参数形式以 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 | 真值测试 |

附录：运算符一览

参考

官方文档（中文版）：

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

PEP：

1. PEP 572 — Assignment Expressions

菜鸟教程：

1. 菜鸟教程 · 数据类型
2. 菜鸟教程 · 数据类型转换
3. 菜鸟教程 · 运算符

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。

登录

mysql -u root -p

查看版本：

mysql --version

也可以写成 mysql -V（大写 V）。远程连接加上 -h 主机。

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 - 删除索引

按功能也可以分成：

1. DDL（数据定义）：CREATE / ALTER / DROP
2. DML（数据操纵）：SELECT / INSERT / UPDATE / DELETE
3. DCL（数据控制）：GRANT / REVOKE
4. 事务：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 不会找出空值。

参考

1. MySQL 26.7 · SQL Standards
2. MySQL 26.7 · SQL Statement Syntax
3. MySQL 26.7 · Language Structure
4. MySQL 26.7 · Working with NULL
5. MySQL 26.7 · What Is New
6. ISO/IEC 9075（SQL:2023）

解释器

在终端输入 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)

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

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

参考

官方文档（中文版）：

1. Using the Python Interpreter
2. Lexical analysis
3. Compound statements
4. keyword
5. print()
6. Unicode HOWTO

PEP：

1. PEP 8 — Style Guide
2. PEP 257 — Docstring Conventions
3. PEP 263 — Defining Python Source Code Encodings

菜鸟教程：

1. 菜鸟教程 · 基础语法
2. 菜鸟教程 · 注释
3. 菜鸟教程 · 解释器

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

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

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

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

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

希望大家都好!

爱你，也爱自己。

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

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

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

特性

1. 多主控制与仲裁:

   • 所有节点都可发送 (多主).
   • 非破坏性仲裁: 通过 标识符（ID）优先级 决定优先级. 高优先级消息通过, 低优先级消息主动退出并转为接收.

2. 系统柔性与扩展性:

   • 无地址信息: 报文基于内容 (ID) 发送, 而非地址.
   • 易于扩展: 新增节点不影响现有节点软硬件及应用层.

3. 高性能传输:

   • 通信速率快: 最高可达 $1\text{ Mbps}$ (短距离).
   • 通信距离远: 速率降低时, 最远可达 $10\text{ KM}$.

4. 强大的错误处理:

   • 具备 错误检测、通知和恢复 机制.
   • 自动重发: 发送单元检测到错误后, 会强制终止并自动重新发送消息, 直到成功.

5. 故障隔离 (封闭):

   • 故障封闭功能: 能区分暂时错误和持续性故障.
   • 对于持续性故障, 能将引起故障的单元 从总线上隔离, 避免影响整个网络.

6. 连接节点数量:

   • 连接节点多: 理论上无限制, 但实际数量受限于通信速率、总线延迟和电气负载.

物理层特征与时序同步

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 个段组成:

关键概念:

• 再同步补偿宽度 (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) 来配置筛选规则.

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

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

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

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

帧结构

CAN 协议的五种帧类型

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

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

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

数据帧 (Data Frame) 结构

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

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

1. 帧起始 (Start of Frame, SOF): 标准帧和扩展帧都是由 1 个位的显性电平表示帧起始.
2. 仲裁段 (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 位.
3. 控制段 (Control Field): 由 6 个位构成, 表示数据段的字节数. 标准帧和扩展帧的控制段稍有不同. r0 和 r1 为保留位, 必须全部以显性电平发送, 但是接收端可以接收显性、隐性及任意组合的电平. DLC 段为数据长度表示段, 高位在前, DLC 段有效值为 0~8, 但是接收方接收到 9~15 的时候并不认为是错误.
4. 数据段 (Data Field): 从最高位 (MSB) 开始输出, 标准帧和扩展帧在这个段的定义都是一样的.
5. CRC 段 (CRC Field): 用于检查帧的传输错误的段. 由 15 个位的 CRC 顺序和 1 个位的 CRC 界定符 (用于分隔的位) 组成, 标准帧和扩展帧在这个段的格式也是相同的. 此段 CRC 的值计算范围包括: 帧起始、仲裁段、控制段、数据段. 接收方以同样的算法计算 CRC 值并进行比较, 不一致时会通报错误.
6. ACK 段 (Acknowledge Field): 用于表示确认正常接收的段. 由 ACK 槽 (ACK Slot) 和 ACK 界定符 2 个位组成. 标准帧和扩展帧在这个段的格式也是相同的. 发送单元的 ACK, 发送 2 个位的隐性位, 而接收到正常消息的单元在 ACK 槽 (ACK Slot) 发送显性位, 通知发送单元正常接收结束, 这个过程叫发送 ACK/返回 ACK. 发送 ACK 的是在既不处于总线关闭态也不处于休眠态的所有接收单元中, 接收到正常消息的单元 (发送单元不发送 ACK). 所谓正常消息是指不含填充错误、格式错误、CRC 错误的消息.
7. 帧结束 (End of Frame, EOF): 标准帧和扩展帧在这个段格式一样, 由 7 个位的隐性位组成.

编程开发

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

硬件初始化与总线配置

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

1. 时钟与 GPIO 配置: 使能 CAN 控制器（如 CAN1）及相关 GPIO 口的时钟, 并配置 CAN_TX 和 CAN_RX 引脚（例如 STM32 需要配置 APB1 时钟）.
2. 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 结构体配置硬件过滤器, 确保接收效率.

1. 过滤器初始化: 设置过滤器号、规模、工作模式和帧类型.
2. ID 和屏蔽器设置: 确定接收规则（标识符列表模式或屏蔽模式）.
3. 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() 函数实现.

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

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

一、核心编码规则

:::note

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

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

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

示例题①

过程：
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)

示例题②

过程：
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 发码：

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

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

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

五、编程实现

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) 的：

编程关键：软件解码时，需测量的是引脚低电平的持续时间（判断是否为 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 协议红外遥控器

:::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]

数组组合

数组元素运算

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

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

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 是一个开源的 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 中文文档

不论宽带速度（例 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

出去吃了顿小巷子中的火锅，味道一般，但是每道菜的量好大啊

讨厌调休

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

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

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

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

• saicaca-Fuwari
• afoim(二叉树树)-Fuwari
• yuki(松坂有希)-Mizuki
• enhanced-FaaS-in-China
• Vercel CDN

虽然村庄陈旧又腐朽，但我依旧嗅闻得到这片土地的生机勃勃。

南方的山永远苍翠，永远湿漉漉，永远带着毛绒绒的云雾。

村子总会在不经意间变得熙熙攘攘。死尸、活人、牲畜、作物、神明、鬼怪，所有的存在或是不存在都揉在一块儿，好似不存在什么界限一般。

我喜欢走在田埂与水泥路的交界处，冬天的时候枯黄的草在单薄衣服上刮着。 空旷却拥塞的田野，牛从不奔跑，狗常对空吠，鸟不知在土堆上捡什么吃。

不觉地走到了村尾，便倚着驳色的墙板就地坐下了。偶能听见老伯的呛咳声伴着羊羔的嘶鸣挤出小屋。若是向屋内俯身探头，会收获那份如一的笑容吧，我想。

老伯并不住在这所小屋，他不在这吃饭睡觉，但这里有他的生活。

这样的村庄是一种复合的味道，硝烟柴火化作烟雾往天上跑。汗津津的动物们、青苔覆盖的砖瓦、陈腐了多年的木头，这种味道，说不上来。

我又去了巷子口那座破败的茅草屋，它在一堆青石砖瓦间显得那么突兀。过去的哪个时代的遗留产物因为一些历史原因无人打扰，便不受干扰地自由地荒废，成为一栋茂盛生长的房屋。

难以想象一个人留在老屋里是怎样的孤寂。

若干年前我站在累起的谷堆上，看见他扬起稻子，笑着问我要不要也试一试。谷粒粘在爷爷未曾被浸染的黑发上。

如今的爷爷，不知何时也会和剥去米粒的稻谷一起飘然化作烟尘，我看不清楚。我能看到的只有他再也挺不起来的腰。

由他保留着的、人家的那串钥匙都去哪里了呢。

我家的房顶已经长满苔藓了。

附录

• AI文本检测为0%

1. 掌握 C 语言程序结构
2. 掌握 C 语言的基本数据类型及数据运算
3. 掌握基本语句的使用
4. 掌握选择结构编程
5. 掌握循环结构编程
6. 掌握数组存储与处理批量数据.
7. 了解模块化程序设计思想, 学会使用函数进行简单编程. :::

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 循环

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);
}

本文直接参考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: ''
---

发布文章的存放位置

你发布的文章应当在 src/content/posts/ 目录下. 你也可以创建一个子目录，用来存放文章和文章中的资源。

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown 语法

这是一个 h1 标题

这是一个 h2 标题

这是一个 h3 标题

段落之间用空行分隔。（或双空格+换行进行内部换行）

这是第二段 斜体、粗体和 代码行。

无序列表

• 这是一项
• 这是一项
• 这是另一项

有序列表

1. 第一项
2. 第二项
3. 第三项

嵌套列表

1. 首先有这两个对象

   • 你
   • 我

2. 一定要记住

3. 不能忘

   找到我

   说晚安

链接和脚注

这里有一个链接到 一个网站、本地文档 和 当前文档中的某个章节标题。这里有一个脚注^1。

图片引用

Markdown 语法引入图片

示例：

![头像图片](/favicon/icon_256.webp "我的头像")

HTML 标签引入图片

示例：

<img src="/favicon/icon_256.webp" alt="头像图片" width="256" height="256" />

<img src="/favicon/icon_256.webp" alt="头像图片" width="256" height="256" />

路径说明

图片路径有以下几种方式：

1. 网络图片：以 http:// 或 https:// 开头

   ![网络图片](https://example.com/image.jpg)
   

2. 公共目录图片：以 / 开头，相对于 public 目录

   ![公共图片](/favicon/icon_256.webp)
   

3. 相对路径图片：相对于当前 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 文件中即可。

<iframe width="560" height="315" src="https://www.youtube.com/embed/1MsuXjTlCGE?si=KykaK5Bgvq1W1hXI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

杂项

特殊符号

• 长破折号：使用三个破折号 --- 表示长破折号（——）
• 范围符号：使用两个破折号 -- 表示范围（例如，"第 12—14 章"）
• 省略号：三个点 ... 将被转换为省略号（……）

Unicode 支持

支持 Unicode 字符，例如表情符号：☺ ★ ♥ ♦ ♣ ♠ ● ○ ◇ ◆ □ ■ △ ▲ ※ → ← ↑ ↓

转义字符

如果需要显示特殊字符的原样，可以使用反斜杠 \ 进行转义：

• \_ 显示为 _（而不是斜体）
• \* 显示为 *（而不是粗体）
• \`` 显示为 `` （而不是代码）

缩进

缩进始终保持为四个空格的距离，你也可以使用制表符（Tab）。

行块

| 第一行 | 第二行 | 第三行