CloudyMount's blog

live2D全栈制作教程/避坑

Wed, 08 Apr 2026 20:26:49 +0800

本文是一份针对 Live2D 制作全链路的进阶手册，浓缩了作者疯狂踩坑总结出来的心酸血泪史，几近全部排雷，旨在帮助读者从零构建一套完整的虚拟形象驱动方案。通过阅读本文，你将建立起从高精度图层拆分、多模态网格布点到多层级变形器架构，面部表情、头部、身体九轴动画，配置物理效果的核心技术认知。文章更深度复盘了跨平台文件兼容性处理与模型稳定性调优的实战经验，通过这篇教程，你将学会一套高效、稳定的 Live2D 开发工作流。

live2D全栈制作教程

参考了一些教程，大部分用自己语言重写了

拆分

前言

拆分很重要！！！基本决定了你后续做出的效果，拆分的好可以让你后续的效率大大提升！

重视拆分！！

做live2D之前，你需要有一个包含图层信息的绘画工程文件

因为煮啵自己是画师，所以使用了自己绘制的立绘

由于煮啵是画完立绘之后才想做个live2D的，就导致即使有过程文件也得痛苦的手动拆分

立绘绘制花了约7小时，然后拆分拆了14个小时（）笑晕了

什么坑全被煮啵踩了一遍/泪

立绘的注意事项

建议画正面对称的角色，可动性会高一点
关于颜色：不要把背景色扣除的颜色全用上了（）
最好是在画的时候就把每个部件分图层绘制和上色

拆分原则

完整性： 遮挡部分必须补全（例如：由于头发遮挡看不见的额头、由于手遮挡看不见的衣服）。
独立性： 所有需要独立变形的部件必须分层。
图层命名： 使用清晰的命名。

拆分层级结构

├── 头
│   ├── 脸（补全发际线，画完整）
│   ├── 鼻
│   ├── 左眉
│   ├── 右眉
│   ├── 左耳（长的耳环等饰品需要单独做物理摆动效果的，要单独拆分）
│   ├── 右耳（耳朵要多画出正面看不到的部分）
│   ├── 左眼
│   │   ├── 上眼皮
│   │   ├── 下眼皮+下睫毛
│   │   ├── 上睫毛(睫毛也可以一根一根拆出)
│   │   ├── 外眼角
│   │   ├── 眼白
│   │   ├── 眼珠
│   │   ├── 瞳孔
│   │   └── 高光
│   ├── 右眼（具体同上）
│   └── 嘴
│       ├── 上嘴唇（要带一点皮肤，要盖的住嘴巴内部）
│       ├── 下嘴唇
│       ├── 嘴巴（建议画张开状态）
│       ├── 上牙
│       ├── 下牙
│       └── 嘴的整体纯色蒙版
├── 头发
│   ├── 刘海（根据不同角色发型，要拆出每个发片，如左右中刘海）
│   ├── 鬓发
│   ├── 后发 （一定要补全脑壳地方的头发！！！发旋也可以画出来，头发的内面可以用暗色）
│   ├── （呆毛）
│   └── 其他
└── 身体
    ├── 脖子（要画够长）
    ├── 上半身
    ├── 胸（左右）（看个人爱好hhhhh）
    ├── 下半身（在腰处相交）
    ├── （两个胳膊）（想旋转更大可拆）
    ├── 衣服（可拆前后，动的幅度不同）
    └── 角色特色的饰品（你想让它动起来）

小贴士

live2D中可实现的图层效果：正片叠底，剪切蒙版
其他发光/叠加等图层效果带不进去

保存PSD

一定要有序命名图层！！并可以打好图层组
文件格式：PSD

踩坑总结

这是极其影响煮啵编辑体验感的几个坑呜呜呜

问题一

一定要先确认拆分没问题了再开始布点和打变形器！！！
虽然可以导入更新后的PSD文件，并且理论上它会将新增的图层识别并放进另一个文件夹，但是就我的使用来说
如果图层顺序发生了更改，或是新增/删除了图层，都有概率出现新导入的PSD图层和布点/变形器对不上的问题！！！
关于这个问题，我询问了很久的ai，寻找了很久的解决方案，最后还是没能解决，卡了非常久最后放弃了。
ai老是编造软件的功能，实际上软件里没有这个选项
后来我发现即使图层名完全一致，没有顺序和数量的不同，导入一个新的也会出现问题/泪
不知道是不是我的图层命名是中文可能被识别成乱码的原因，没有排查

问题二

procreate在导出PSD文件的时候
尽管关闭了背景的显示，成为了透明底
但是由于它不能删除背景这个图层，导致每个图层默认大小都是整个画布大小，而不是贴合在图像四周的
首先就是导致布点的时候，每个图层的画布的最边上四个角莫名其妙都各有一个点，导致用不了自动连接布点
其次就是导致变形器不会贴合在图像四周
当时因为已经做了很多布点了，并且因为问题一想要重新导入一直失败，最后的解决办法是一个一个图层手动擦，增加了很多工作量
应该可行的解决方案是将PSD文件在Photoshop里打开，删除背景图层后再导入live2D

感触

问ai很难解决这类问题，一个是他们并非这方面的专家，一个是他们会一直编造软件的功能，或是可能是因为他们检索到的文章使用的软件版本不同？不清楚，反正困难重重

布点

导入

将整理好的 PSD 文件直接拖入 Live2D Cubism Editor。
或者在文件->打开文件
如果要替换：模型设定->选择当前模型->选择要运行或替换当前的psd文件->替换
新增图层在文件夹(未找到对应)里面,本来就有的图层会叠加更新

开始布点

形状: 三角形
网格越密集,变形越精细

自动布点： 初学者可全选图层使用“自动生成网格”,参数可以自己看情况试一试
后续手动布点：
1. 眼睛、嘴唇等需要细腻变形的部位，需手动增加网格密度（点越细，变形越平滑）。
2. 自动布点有缺漏的地方需要手动补上

tips

没有被布点圈住的图像在live2D中不会显示
改变笔刷大小只能使用快捷键B
重要：建议先大概了解一下布点工具栏中的工具都有什么用途，提高效率。可以自己摸索或者网上找教程学习。
还有这里的工具

重要

保护线不被拉扯变形，要在线上和线的上下两侧都布点

可以使用一个快捷的工具

绘制顺序

数值越大，图层越靠前。头发和饰品根据前后关系上下浮动。

动画制作

图层属性

参数与关键帧

和剪辑有点像，在参数的轴上打关键帧，之后再调整变形器，软件会自动计算出关键帧之间的变形器是怎么移动的、

不打关键帧就会白给！！！！一定要记得！！！

变形器

层级结构

必须遵循“父子关系”。例如：【头旋转】控制【五官曲面】控制【具体器官】
建议旋转变形器永远套在曲面变形器外面

其他

ctrl可改变形器⼤⼩，注意要在打关键帧前做
按住ctrl可以选中多个图层，然后给多个图层打变形器，注意不能跨父子层级
移动变形器的上下顺序，不影响图层的顺序
可以把不同图层组的图层放在同⼀个变形区中⼀起做变形
因为变形器就像个图层组，所以不能把同个图层同时放在多个组⾥，要放的话只能⼀个组套⼀个组
套两个及以上的变形器，外⾯的变形器扭曲的是⾥⾯的变形器，⽽不是作⽤图层，所以⾥⾯那层变形器⼀定要覆盖图层所有⾯积,不然外⾯的变形区就⽆法精准控制⾥⾯的物体
如果打错了变形器，可以先把变形器调到初始状态，将内⾥的图层取出。如果没有回到初始就取出，图层会保持变形状态
变形器也要做好清晰命名！！

制作

建议按照表情制作->头部旋转(即鼎鼎大名的九轴)->身体旋转

把参数里有的东西都做一遍就好了（）

这里挑几个讲一下

踩坑点

我看很多教程基本上没讲,但是我觉得知道这个很重要

在这里也踩了大量坑/泪，因为这个前提条件做错就只能重做了

当时不知道这个，简直狠狠地难住我了，后来由于尝试强行删除关键帧，直接把眼睛弄的睁不开了！！！！

但是由于眼睛闭上几乎把所有眼睛图层压缩成一条线了，还原几乎不可能，只能找以前版本，可是我没保存！！！！

点撤销也没用（live2D在做完某些操作时候不能撤回）

最后研究了很久回退，好在救回来了

血泪经验：做一点保存一点，最好使用另存
不到万不得已不要删关键帧，会把一整个环境弄坏

一个变形器或者图层绑多个参数的不同关键帧的时候,会出现优先级问题

就是：

一个变形器先做了一个参数的动画
在对同一个变形器做下一个操作的时候
上一个做好的参数放在哪个关键帧，会成为下一个动画生效的前提条件
举个例子：如果你做完了X轴，还没有和Y轴链接，但做Y的时候你把X放在最左边的位置，
你会发现当你把X移到中间的关键帧的时候，移动Y轴没反应
这是因为X放在最左边变成了Y参数生效的前提条件
利用这个特性可以实现一些东西，比如由于面捕软件对眼睛微笑很不明显
所以可以将微笑绑定到: 嘴巴抿起 和 眼睛闭上 这两个前提下触发
live2D在同一个东西绑定了2个以上的参数的时候会报提示，也不建议这样
解决方法有：链接两个参数, 分别绑参数在变形器和原图层…

眼球移动

先打变形器
分开做完X、Y轴（建议两边严谨点平行移动等距离，煮啵拿尺子量的）
- （这也是一个踩坑点hhh因为第一遍用目测的实在是太不准了，而且做X的时候Y也发生了偏移hhh，最后调了非常久效果还是不满意直接用尺子量重做了，快了好多，浪费了两个小时呜呜）
- （眼球可以稍微偏出去一点，因为最后导入面捕的时候灵敏度可以调，幅度太小会变化不明显，同样适用后面）
- （上面那点也是踩坑点hhh煮啵怎么这么命苦）
注意做Y轴的时候X轴要放在正中间！！！！很重要，做后面的也是一样
在左侧列表点链接
感觉有点不自然？右上角三横线->四角形状合成
微调9个关键帧的位置，链接之后的是ai帮你计算的

剪贴蒙版

用途： 实现“眼珠不超出眼白”等效果。
操作： 复制眼白的图层 ID，粘贴到瞳孔图层的“剪贴蒙版”栏目中。
眨眼： 设置参数值 1 为睁眼，0 为闭眼。利用变形器微调网格，确保闭眼时睫毛覆盖眼眶。

睁眼闭眼

做这些形状没什么讲究的，怎么好看怎么调，这里略写，如果调不好看可能是布点布的不够好，可以重新布一下
善用软件操作和工具
眼睛动画自动生成的如果不满意，就多K⼀个点调整
同理，闭眼的时候只要把所有东西压成一条线藏进睫毛就好了，微笑也是

嘴巴

同理，以下形状可供参考

进阶版可做9个点

眉毛

建议不要做，live2D诡异的给了很多参数，但是其实都不明显，面捕可能会抽搐

微笑

接刚刚所说，由于面捕软件对眼睛微笑很不明显

所以可以将微笑绑定到: 嘴巴抿起 和 眼睛闭上 这两个前提下触发

可以直接ctrl多选闭上的眼睛的所有图层，打上曲线并整体移动曲线

（煮啵尝试失败了，自己手动k的，此为理论方法）

踩坑点

如果不知道0和1分别对应的是什么（不要相信中文翻译的语序！！我就被骗了呜呜呜）

可以点参数界面右上角的三个横线->参数设定

另外!!!做反了或者绑错参数了不要急着重做(是的呜呜呜我就是直接重做了，煮啵踩了无数的坑真的)

点反映可以交换参数轴 选择： 选中轴绑定的所有物体 反映： 是将整个参数轴翻转（是把左右数值搞反⽤的，注意跟动作反转是完全不⼀样的东西） 调整： 可以把关键Z互换，不⼩⼼个别打错的换⼀下 变更： 将该参数转移到正确的轴上

还有这个可以比较方便的做另一边，但是建议还是手动k

感悟

在做一件事之前先详细的了解工具有什么功能,可以大大提高效率/泪

反正我是印象深刻了

头部九轴

也是同理，就是工作量比较大

对透视没信心，可以网上找一些参考图叠放在后面做参考

调⼀条轴时，另⼀条轴的状态要在正中间（就是初始状态），不然之后可能会重做

记得打关键帧

身体

⾝体的旋转变形器中⼼要放在腰上（按ctrl改）然后在做⾝体Z轴时，外⾯建多⼀层⼀个曲⾯变形器，来做⾝体旋转时⾐服不⾃然的地⽅最后，是⾝体跟头部的旋转其实是做相同⽅向绑定的，所以在调整时，可以把头部调到相应的⽅向再做调整

物理效果

此处直接引用教程，讲的很清楚

下面引用的是小小巡山的总结

来模拟做一个头发（前额发）跟随头动产生的物理：

1.新建摇动变形器

2绑定参数

3可以增加按下面的按钮增加想要的参数

4调整名称和参数

5做好参数后，调出

6追加组

**5，物理 P5 - 01:05

接下来先介绍下摆锤

7添加摆锤节数

这里听讲解吧

**5，物理 P5 - 01:39

然后介绍物理系统的输入和输出

输入系统

**5，物理 P5 - 02:25

8这里介绍下我们要输入的物理动力的来源（头的摆动，输入角度X，和角度Z）

这里的类型（位置X和角度）是指对摆锤的影响

设置成位置X时，摆锤上方的点在X轴的位置，

这样摆动幅度大，最后会恢复状态（感觉转动时的跟随？？）

设置成角度时，则影响摆锤处坐标轴的变化

这样摆动幅度小，最后不会回到原位（感觉像重力？？）

输入物理动力的多个参数可以组合起来，控制一个摆锤时使用

影响度不一样动起来才自然

9然后输出

追加我们要的输出素材

可以改是哪一节，是摆锤数指第几节

**5，物理 P5 - 03:44

10如何让头发运动更自然

**5，物理 P5 - 04:28

蒙皮：

用曲线工具给头发图层加一条控制线

12然后蒙皮

13重新打开：

建模—物理场景混合面板

14追加摆锤

15在输出追加

16勾选

17调整影响度

就可以模拟多段的摆动啦

小技巧：

把物理分为

惯性：角度X影响的左右摆动，用物理系统做

重力：新建一个重力变形器，绑定角度Z轴进行调整

**5，物理 P5 - 05:03

变形器的顺序：从外到内是

导出

导出具体观看的是这个教程，讲的听清楚的

纹理集

导出前必须点击“编辑纹理图集”，将所有部件排列在正方形画布内（通常为 2048x2048 或 4096x4096px）。

文件清点

模型文件： .moc3（核心数据）。

导入VTube Studio，调整细节参数

观看的是这个教程

软件是免费的，在steam可以下载

踩坑点

VTube一直识别不出我的模型，应该是导出过程抽风了导致文件损坏吧，最后导出了三遍后重启电脑重新导出成功了（）

另外，用ipad驾驶模型会明显精细度更好，但是导入ipad中也是困难重重，因为苹果这该死的文件管理系统（怒）导入竟然又研究了我两小时

在直播中使用

同样也是这个教程的末尾有讲，有不明白的可以去额外搜索一些教程

VScode设置图片粘贴路径

Wed, 08 Apr 2026 19:49:56 +0800

本文针对 Markdown 写作中静态资源管理的碎片化痛点，提供了 VS Code 自动化图床化配置方案，有效解决了默认路径混乱与同名覆盖风险，是构建结构化博客文档流的硬核提效手段。

VScode中如何配置粘贴入的图像的默认位置

需求由来

因为在写博客的时候需要大量插入图片

默认的图片插在同目录下，直接命名为image-?，它会在md文件中命名为[!alt](image-?.png)

但是因为我的博客的文件目录管理是统一将图片放在images里的，所以需要加一个前缀./images/…

方法

ctrl + ,打开设置
搜索markdown.copyFiles.destination
添加键值对：键**/*.md（匹配所有.md文件，对所有markdown生效），值${documentDirName}/images/image-${unixTime}.${fileExtName}

注：unixtime:毫秒级时间戳，防止重名

VScode多文件编译方法

Wed, 08 Apr 2026 19:49:33 +0800

本文针对 VS Code 环境下 C++ 多文件编译报错的痛点，提供了两种维度的硬核解决方案：一是通过魔改 tasks.json 中的 args 参数，将单一文件编译重定向为路径通配符编译；二是引入 CMake Tools 扩展，利用 CMakeLists.txt 构建工程化的声明式编译流，旨在帮助开发者实现多模块代码的顺畅协同。

VScode 多文件编译解决方法

way 1 修改config文件

按下 Ctrl + Shift + P
输入 Tasks: Configure Task
选择 g++.exe build active file。

这会自动生成或打开 .vscode/tasks.json

找到 args（参数）数组
把 "${file}" 修改为 "${fileDirname}\\*.cpp"

原理：改为多文件编译

way 2 使用cmake扩展

对于大型项目或需要跨平台的开发需求，使用 CMake 是更硬核且通用的选择。

安装插件：在 VS Code 扩展市场搜索并安装 CMake Tools。

创建 CMakeLists.txt：在项目根目录下新建该文件，写入基础配置：

cmake_minimum_required(VERSION 3.10)
project(MyProject)
# 自动搜集目录下所有源文件
aux_source_directory(. DIR_SRCS)
add_executable(main ${DIR_SRCS})

构建与运行：
- 点击底部状态栏的 Build 进行编译。
- 点击 三角形图标 (Run) 或 小虫子图标 (Debug) 即可运行或调试。
优点：无需手动修改 JSON 配置文件，支持复杂的库依赖管理。

linux入门/快速上手命令行

Wed, 08 Apr 2026 19:39:42 +0800

本文是我自用总结的常用的 Bash 命令行技巧，旨在帮助新手快速上手终端的使用，离一名帅气的极客更进一步。内容涵盖基础路径跳转与增删改查,系统与网络监控, 高效进阶技巧, 开发工具联动等，适合linux新手入门，大部分同时也可用于windows系统的windows powershell。

Bash命令行编程

文件夹跳转

1. 看当前所在位置

pwd

（Windows是cd，Linux是pwd看路径）

2. 进入文件夹

cd 文件夹名
# 举例
cd Desktop
cd /home/用户名   # 绝对路径

3. 返回上一级

cd ..

4. 直接回自己家目录（主页）

cd ~

5. 回到上一次所在文件夹

cd -

二、查看文件/列表

1. 列出当前所有文件、文件夹

ls          # 简单列表
ls -l       # 详细信息（权限、大小、时间）
ls -a       # 显示隐藏文件（带 . 的文件）
ls -la      # 详细+隐藏，最常用

三、新建 & 删除 & 复制（谨慎删！）

1. 建文件夹

mkdir 文件夹名
mkdir test

2. 建空文件

touch 文件名.txt
touch note.md
vim 文件名

3. 复制

cp 源文件 目标
cp note.txt /home/备份/
cp -r 文件夹A 文件夹B   # 复制整个文件夹

4. 移动/重命名

mv 旧名字 新名字       # 重命名
mv 文件 /目标路径/     # 移动

5. 删除（⚠️ Linux删了很难找回！）

rm 文件名.txt          # 删文件
rm -r 文件夹名         # 删文件夹+里面所有
rm -rf 文件夹名        # 强制彻底删除（慎用！）

四、查看文件内容

cat 文件名.txt        # 直接全打印
less 文件名.txt       # 分页看（上下翻）
head 文件名.txt       # 看开头几行
tail 文件名.txt       # 看结尾几行（看日志神器）
tail -f 日志.log      # 实时刷新日志

五、系统 & 网络常用

1. 看IP

ifconfig
# 新版也用
ip a

2. 测试网络通不通

ping www.baidu.com

3. 看当前正在运行的程序

ps aux
top        # 实时看进程、占用

4. 清屏

clear

六、解压/压缩

# 解压 zip
unzip 压缩包.zip

# 解压 tar.gz（Linux标配）
tar -zxvf 压缩包.tar.gz

# 压缩成 tar.gz
tar -zcvf 打包名.tar.gz 要打包的文件夹

七、实用快捷键

Tab：自动补全文件名/命令，救命神器
↑ ↓：调出之前输过的命令
Ctrl + L：快速清屏（等于clear）
Ctrl + C：强制停止当前运行的程序
vim ... 启动vim编辑器
code .在当前工作区打开vscode
·Ctrl + Shift + E：聚焦到左侧文件资源管理器（用上下键选文件）。
Ctrl + P：快速搜索文件（输入文件名直接跳转，不需要去文件夹里翻）。
任意位置win + x + i -> 唤起终端(我已配置默认目录为D盘)

这份 Bash 命令行笔记已经非常扎实，涵盖了最常用的基础操作。为了让它更完整、更符合“从入门到进阶”的逻辑，我为你补充了文件搜索、权限管理、管道与重定向这三个核心板块，并提供了一个适合博客首页的 Summary。

八、查找与搜索

# 1. 在当前目录及子目录下查找文件名
find . -name "test.txt"

# 2. 在文件中搜索特定文本内容
grep "error" server.log        # 在 log 中找包含 error 的行
grep -i "error" server.log     # 忽略大小写
grep -r "function" ./src       # 在文件夹内递归搜索

# 3. 查找命令的可执行文件路径
which python

九、权限管理（遇到 Permission Denied 时看这里）

# 1. 修改文件权限
chmod 755 script.sh      # 赋予执行权限
chmod +x script.sh       # 简单直接地赋予执行权限

# 2. 临时提升为管理员权限执行
sudo apt update          # 以 root 权限运行

# 3. 修改文件所属用户
chown user:group file.txt

十、管道与重定向（将命令组合起来）

# 1. 重定向：将结果保存到文件
ls > files.txt           # 覆盖写入
ls >> files.txt          # 追加写入

# 2. 管道符 | ：把前一个命令的结果交给下一个
ps aux | grep "python"   # 在所有进程中过滤出包含 python 的行
cat log.txt | wc -l      # 统计 log 文件有多少行

AI 驱动的技术书“脱水”学习流分享

Tue, 07 Apr 2026 23:04:24 +0800

别再死磕技术书全文了。这套流派的核心是 “先搭骨架，后填血肉”：利用 AI 将原书强行拆解为知识切片、讲义正文和动态验收题，构建一个结构化的 e-book 知识库。引入 “零基础可读性自检” ，通过规约强制 AI 有计划的输出带有直觉解释、边界说明和逻辑自洽的干货讲义。这不仅是一套 Prompt 技巧，更是一次对传统阅读习惯的底层重构，让 AI 真正承担起知识压缩与逻辑重组的任务。

如何用AI做技术书籍速读学习

你会得到什么

一套快速落地的技术书学习流程，再也不用“硬啃全文”。
一套“讲义优先”的产出结构：读完就能复习、能自测、能复用。
一套质量控制机制：防止 AI 只会“总结漂亮话”。

适用对象：要快速掌握一本技术书主线、但不想陷入低效摘抄的人。

一、核心原则：先搭框架，再填细节

我的思路是: 先规范好ai需要做什么，将需要做的事情拆分为很多个子任务，每一步做好规定好的事：下面的思路可供参考：

想清楚整体学习工作流 (做一个大致的plan，和ai制定规约)
抽取全书结构（目录级、章节级、小节级）
再做知识切片（按小标题拆成可讲单元）
再写讲义正文（不是模板笔记）
最后做验收题（按当天学到的内容动态生成）

先有地图，再走路。

二、目录结构

建议用下面这套结构：

/
├─ lectures/
│  ├─ 00-overall-5day-plan.md
│  └─ day?-???.md
├─ hangouts/
│  ├─ 00-overview.md
│  └─ day?-???.md
└─ knowledge-slices/
   ├─ ch01-...-slices.md
   ├─ ch02-...-slices.md
   └─ ...

职责分工：

knowledge-slices/：知识切片底稿（按原书小节）
hangouts/：讲义正文（真正学习材料）
lectures/：学习安排 + 验收题 + 参考答案

三、质量闸门：零基础可读性检查

这是整套流程中最值钱的一步。

每次讲义生成后，强制跑一遍检查：

这份根据原文提取出的脱水讲义是否逻辑自洽？

即作为一名什么都不知道的小白，我能不能通过这篇讲义弄懂这个知识点？

可以检查以下几点:

这一段是否先解释术语，再讲结论？
是否默认读者已经懂前置概念（但文中没解释）？
不查外部资料，能否理解这段主旨？

示例（错误写法）：

“词袋模型优点是简单，缺点是忽略上下文。”

示例（可读写法）：

“词袋模型是把文本当作‘词频统计表’，只看词出现次数，不看顺序。
因此它快、好实现，但像‘我喜欢你/你喜欢我’这类句子会被误判为很像，语义区分能力有限。”

四、建议学习步骤

可以固定学习步骤和节奏，便于更加科学的学习

但是不要精确到分钟，保持灵活的时间安排

以下是我的学习步骤：

复习昨天的学习内容
- 只需要大概看一遍
阅读slice
- 形成一个大概的印象
- 明确要掌握那些概念
- 便于后续脑中建模知识点的联系
阅读lecture
- 了解学习重点，防止阅读时死扣没那么重要的细节
- 有的内容读到后面和后面的东西联系起来自然就懂了
阅读hangout
- 期间有不懂的直接新建对话问ai
- 并对hangout(现在是你的note)进行补充
复盘（很重要）
- 并在脑中建模知识点间的联系
- 为什么要引入这个概念？我学到了什么？有哪些思想可以复用？
完成课后习题，进行查漏补缺
- 不懂的继续实时做笔记

五、参考规约

下面贴出我的参考规约

# 《图解大模型》学习总体规约

## 规约定位
这是后续生成高质量讲义的总控文档。核心目标是：
- 严格对齐原书知识范围（第1-12章 + DeepSeek-R1附录）；
- 先把知识点切分清楚，再生成易懂讲义；
- 每天的验收提问完全根据当天实际学习内容动态调整，文末给参考答案。
- 不要死板于制定优美的计划，应该更专注于知识点本身的提取和学习的质量，深耕hangout文档的生成

## 学习目标
- 所有内容以 `e-book.pdf` 为唯一知识源，禁止编造书外关键结论。
- 讲义按原书章节和小标题组织，尽可能覆盖原书知识点。
- 讲义正文必须可直接学习，不使用同质化空模板。
- 每天验收题只围绕当天学过的小节，文末提供可核对的参考答案。
- 目标是快速概览与建立框架，不追求一次性吃透全部推导细节。
- 便于用户少做重复整理工作，ai负责把内容压缩成可读、可学、可复习的讲义正文。
- 讲义质量优先于流程形式：强调概念清晰、边界清晰、应用场景清晰。

## 全书主线（与原书一致）
- 第一部分：理解语言模型（第1-3章）
- 第二部分：使用预训练语言模型（第4-9章）
- 第三部分：训练和微调语言模型（第10-12章）
- 附录：图解 DeepSeek-R1

## 5天学习主线（保持高密度但不僵化）
- Day 1：第1-3章（基础概念、分词嵌入、Transformer内部机制）
- Day 2：第4-6章（文本分类、聚类主题、提示工程）
- Day 3：第7-9章（链路与记忆、Agent、RAG、多模态）
- Day 4：第10-11章（嵌入模型构建、表示模型微调）
- Day 5：第12章 + 附录（生成模型微调、偏好优化、DeepSeek-R1）

## 文件职责
- `knowledge-slices/`：按章节沉淀知识点切片，作为讲义生成底稿。
- `notes/`：每日讲义正文（学习材料本体）。
- `lectures/`：每日安排、验收题、参考答案、复盘。

## 讲义撰写标准
- 结构：按知识点切片展开。
- 允许结构化重写与通俗化解释，但必须保留原书知识逻辑。
- 风格：优先用直觉解释复杂概念，必要时再补技术术语。
- 目标：读完即可复述主线，遇到任务能做初步方法选型。

## 零基础可读性检查
- 每次生成讲义后，都要用“完全零基础学习者”视角自检一次。
- 自检问题可以包括：
  - 这一段是否先解释了术语本身，再讲优缺点或结论？
  - 有没有默认读者已知前置概念（如 BoW、token、embedding）却未解释？
  - 读者是否能在不查外部资料的情况下理解本段主旨？
- 若答案是否定，则立即补充相关解释，如：
  - 一句话定义（这是什么）
  - 一个直觉例子（像什么）
  - 一句边界说明（它不能做什么）
- 允许 AI 在不偏离原书事实的前提下补充通俗化解释，优先保证“读得懂”。

## 执行顺序
1. 先维护 `knowledge-slices/` 的章节切片。
2. 基于切片生成当日讲义正文到 `notes/`。
3. 基于当日讲义生成验收题到 `lectures/`，文末附答案。
4. 生成当日复盘（高频误区 + 第二天预热）。

## 完成标准
- 全书已有章节级知识切片。
- 每天有可直接学习的讲义正文。
- 每天有与内容强绑定的验收题与答案。

powertoys快速上手/windoews开发人员手册/辅助讲解工具zoomlt

Mon, 06 Apr 2026 11:17:15 +0800

本文精炼了 PowerToys 与 ZoomIt 两大极客工具的好用指令集，涵盖窗口常驻、全局 OCR 提取、像素级取色以及演示级的屏幕缩放与动态标注技巧。通过映射核心快捷键位，实现对系统底层交互逻辑的深度重塑，旨在打造一套极简、高效的 Windows 开发者工作流。

windows开发人员工具手册

~~用来装逼~~

安装powertools

windows开发人员工具手册：

我整理出的实用工具：

ctrl + win + t可以固定或取消固定所选窗口，使其始终位于所有其他窗口的顶部，哪怕焦点丢失
ctrl + win + c可以打开颜色选择器，在任何应用程序中选取颜色并复制可配置文件到剪贴板
win + shift + t可以打开文本提取器
win + shift + /可以打开快捷键指南
两次ctrl寻找鼠标
win + shift + h鼠标荧光笔

zoomlt

ctrl + 1 激活缩放：按鼠标滚轮或向上/向下箭头键放大或缩小。按 Esc 或鼠标右键退出缩放模式。按 Ctrl + C 捕获缩放视图，按 Ctrl + S 保存它。按 Ctrl + Shift 在复制或保存之前裁剪。
ctrl + 4 激活实时缩放:按 Ctrl + Shift + 4 激活实时绘图，按 Esc 清除批注或退出。按Ctrl + 向上/向下调整缩放级别。
ctrl +２屏幕绘制：放大时，按鼠标左键切换绘图模式，按鼠标右键退出。按 Ctrl + Z 撤消，按 E 清除绘图，按空格键使光标居中。笔控制按 Ctrl + 鼠标滚轮或 Ctrl + 向上/向下调整笔宽度。颜色按 R(红色)、G(绿色)、B(蓝色)、O(橙色)、Y(黄色)或 P(粉色)切换颜色。高亮和模糊按 Shift + 颜色键表示半透明高亮，按 X 表示模糊，按 Shift + X 表示更强的模糊。形状按 Shift 表示线，按 Ctrl 表示矩形，按 Tab 表示椭圆形，按 Shift + Ctrl 表示箭头。屏幕按 W 或 K 表示白色或黑色素描本。按 Ctrl + C 复制，按 Ctrl + S 保存，按 Ctrl + Shift 裁剪。按t进入文本编辑

Claude Code 终端集成与 API 中转避坑

Sat, 04 Apr 2026 17:00:04 +0800

本文深度还原了在 Windows 环境下部署 Claude Code 终端工具的实战历程，针对初次配置中常见的环境变量冲突、网络受限及 API 连通性等痛点提供了硬核解决方案。文章总结了通过第三方中转站绕过地理限制、优化模型路由分组以及利用脚本跳过冗长初始化流程的进阶调优经验，旨在帮助开发者快速打通 Claude 与本地终端的交互链路，构建高效的命令行 AI 开发环境。

Claude Code 安装与配置

找了好几个教程，历经艰难险阻终于装上了，，，但是发现费用不菲啊，，，

教程

好不容易找到的可以用的教程

跟着几个不同的教程做都失败了，，一直在解决各式各样的报错我有统计工作时长的习惯，花了我5个小时wc（泪）

###　更换不同api中转站配置

最后总结出来的配置三件套(因为我一直换各个不同的api中转站hhh)

（适用于windows powershell）

修改环境变量（这个好像是单进程生效）

$env:ANTHROPIC_API_KEY = "your_api_key"
$env:ANTHROPIC_BASE_URL = "中转站网址，大部分情况是网址，一般中转站有文档会写出"

检查是否成功输入（不要多括号和引号什么的）

echo $env:ANTHROPIC_API_KEY

echo $env:ANTHROPIC_BASE_URL

notice: don’t use both api_key and token，他们本质上作用是一样的，因为我看了不同的教程用了不同的东西导致我两个都设置了，然后就报错了，，

改长期配置（其实我不知道这个必不必要，但是在解决报错的过程中ai叫我这么做hhh）

notepad $PROFILE

创建新的文件是正常现象，然后把上一步的两行环境变量粘进去

改~/.claude/setting.json

有的教程又叫我用config,,,乱七八糟的

粘贴一些基础配置（同样我也不知道必不必要hhh，ai说的）

可以参考我的

{
"primaryModel": "claude-sonnet-4-5-20250929",
"apiBaseUrl": "https://api.cphone.vip/",
"env": {
	"ANTHROPIC_BASE_URL": "同上",
	"ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-sonnet-4-5-20250929",
	"ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-sonnet-4-5-20250929",
	"ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-5-20250929",
	"ANTHROPIC_MODEL": "claude-sonnet-4-5-20250929"
	},
"preferences": {
	"language": "zh-CN",
	"showCost": true,
	"showTokenCount": true,
	"autoComplete": true
		},
	"hasCompletedOnboarding": true
}

在历经艰难险阻之后我的claude终于能在终端说话了/泪目

###　修复错误的简单历程

似乎是没有成功设置url，claude一直走官网拉取，报网络问题：您所在国家不能使用，开代理也不行就是这一步诞生了上面一堆修复的尝试hhh，但是其实都没奏效，卡了很久之后选择换教程，换了两三个教程看找到了上面贴的那个教程，通过一个windows power shell脚本绕开了初始的新手教程，拉取和配置，终于成功连上了
连上了之后开始报503错误：account not exist,问ai半天后选择去找客服，客服不理我
尝试换api中转站，找到这篇博客

换了api易之后，进去是进去了，但是开始报model not support，换了几个分组都不行

上一个中转站客服终于理我了，说是那个分组的号最近被封的厉害让我换个分组，我照做终于好了

补充：现在用的中转站

省钱tips

多用 claude ignore：把不需要扫描的文件夹（如 node_modules, dist）排除掉，减少 Context 消耗。
控制对话深度：定时输入 /clear 或者重新开启对话，防止上下文堆叠导致单次请求 Token 爆炸。
别跟风加一堆rules，那些也烧token

vim配置分享/快速上手指南

Sat, 04 Apr 2026 00:44:45 +0800

本文将 Vim 视为一种高度可组合的“编程语言”，深度解析了“动词+名词”的核心交互逻辑与多模态操作架构。内容涵盖从基础位移到宏录制、修饰符等进阶技巧，并集成了 CapsLock 改键映射及 .vimrc 生产力配置实战。通过打通从终端到浏览器的全域 Vim 生态，旨在帮助开发者彻底摆脱鼠标依赖，重塑极致的文本编辑效率。

Vim Note

学习目标

避免离开键盘热键，避免使用鼠标，提高开发效率

学习资源

配置

键位映射
插件配置

特色

多模态编辑器：
- <ESC>正常模式：在文件中四处移动光标进行修改
- i 插入模式：插入文本
- r 替换模式：替换文本
- v 可视化模式（一般，V 行，<C-v>块）：选中文本块
- : 命令模式：用于执行命令
Vim的接口是一种编程语言： Vim 的接口本身也是一个程序语言：键入操作（以及其助记名）是命令，这些命令也是可组合的。

基本操作

一、缓存，标签页，窗口

Vim 会维护一系列打开的文件，称为 “缓存”。一个 Vim 会话包含一系列 标签页，每个标签页包含一系列窗口（分隔面板）。每个窗口显示一个缓存
跟网页浏览器等其他你熟悉的程序不一样的是，缓存和窗口不是一一对应的关系； 窗口只是缓冲区的视图。一个缓存可以在多个窗口打开，甚至在同一个标签页内的多个窗口打开。这个功能其实很好用，比如可以 查看同一个文件的不同部分。

分屏： :sp (水平) | :vsp (垂直)。窗口只是缓存的视图，可同时查看同文件的不同部分。

二、命令行

:q 退出（关闭窗口）
:w 保存（写）
:wq 保存然后退出
:e {文件名} 打开要编辑的文件
:ls 显示打开的缓存
:help {标题} 打开帮助文档
- :help :w 打开 :w 命令的帮助文档
- :help w 打开 w 移动的帮助文档

三、指令组成

1. 名词 - Noun

尽量放弃方向键，使用 hjkl 保持手指在主键区。

基础： h(左) j(下) k(上) l(右)
单词： w (下个词首) | b (词初) | e (词尾)
行内： 0 (绝对行初) | ^ (第一个非空字符) | $ (行尾)
垂直： gg (文件头) | G (文件尾) | {行数}G (跳至指定行)
查找： f{字符} (行内向前找字符) | t{字符} (找字符前一个位置)
搜索： /{正则表达式} (向下搜索) | ? (向上搜索) | n/N (跳至下/上一个匹配)

2. 动词 - Verb

i 进入插入模式 | o / O 在下方/上方新开一行并进入插入模式
d{移动} 删除（如 dw 删词, d$ 删至行尾）
c{移动} 改变（删除并进入插入模式，如 cw 改写单词）
y 复制 (Yank) | p 粘贴 (Paste)
u 撤销 | <C-r> 重做
x 删除单个字符 | s 替换单个字符

在 Visual (可视) 模式下：选中一段文字后按 U，选中的内容会全部变大写。

三、 Vim 编程语言

Vim 的强大源于这个公式：[数字] + [修饰符] + [动词] + [名词]

1. 计数 (Count)

3w 向后移动 3 个单词。
5j 向下移动 5 行。
10dd 删除 10 行。

2. 修饰符 (Modifiers)

用于定义操作范围：i (inner - 内部) 或 a (around - 周围)。

ci( 改变当前括号 () 内部的内容。
di" 删除双引号内的字符串。
da{ 删除整个花括号块（含花括号本身）。

3. 宏 (Macro)

宏录制：
1. q{a} 开始录制到寄存器 a。
2. 执行一系列复杂操作。
3. q 停止录制。
4. @{a} 重放操作（配合数字如 100@a 批量处理）。

四、个人配置与扩展

1. 配置文件 `.vimrc`

Vim 的灵魂在于自定义。

可以说，一个好的配置决定了vim是古老编辑器还是现代实用工具（）

建议手动维护，不要盲目复制他人配置。

必改映射： 建议将 <CapsLock> (大小写锁定) 映射为 <ESC>，极大缓解手指压力。

（后文附修改方法）

核心插件推荐：
- ctrlp.vim：模糊搜索文件。
- NERDTree：树形文件浏览器。
- vim-easymotion：远距离光标“瞬移”。

2. 生态延伸

Shell： set -o vi 让命令行支持 Vim 快捷键。
浏览器： 安装 Vimium (Chrome) 或 Tridactyl (Firefox) 实现纯键盘冲浪。

~~(但是我还是贴出我的配置hhh大家按需选用)~~

首先就是我改了windows系统设置,把大写锁定映射成了esc

方法如下

下载并安装 Microsoft PowerToys 如果你还没有安装，可以通过以下几种方式获取：

官方下载： 前往 GitHub PowerToys 发布页面下载最新的 .exe 安装包。
应用商店： 在 Windows 11 的 Microsoft Store 中搜索 “PowerToys” 并安装。
命令行安装： 打开终端（PowerShell），输入：
```
winget install Microsoft.PowerToys
```

安装完成后，按以下步骤操作：

打开 PowerToys 设置： 在任务栏右下角找到 PowerToys 图标并双击，或从开始菜单搜索打开。
进入键盘管理器： 在左侧菜单栏中找到 键盘管理器 (Keyboard Manager)，确保顶部的开关处于“开启”状态。
重新映射键： 点击中间部分的 重新映射键 (Remap a key)。
添加映射关系：
- 点击左侧的加号 +。
- 在左侧的 选择 (Select) 下拉框中找到 Caps Lock（或者直接点击“按下”，然后在键盘上按一下大写锁定键）。
- 在右侧的 发送 (To send) 下拉框中选择 Esc（同理可以点击“按下”后按一下 Esc 键）。
保存设置： 点击右上角的“确定”。


" --- 基础设置 ---
set nocompatible      " 关闭 Vi 兼容模式，解锁 Vim 更多功能
syntax on             " 开启语法高亮
set shortmess+=I      " 启动时不显示欢迎界面（捐赠提示等）
set number            " 显示行号
set relativenumber    " 显示相对行号（方便 5j, 10k 这种跳转）
set laststatus=2      " 总是显示状态栏
set ruler                                 " 打开状态栏标尺
set backspace=indent,eol,start  " 允许在自动缩进、行尾、插入点前使用退格键
set hidden            " 允许在未保存当前文件的情况下切换缓冲区（Buffer）
set mouse+=a          " 开启鼠标支持

set smartindent                           " 智能自动缩进
set autoindent                            " 新行自动继承上一行的缩进
set shiftwidth=4                          " 设置自动缩进时，每一级缩进4个空格的宽度
set tabstop=4                             " 设定 tab 长度为 4 
set hlsearch                              " 搜索时高亮匹配项
" 输入 :noh 可以临时关闭高亮
set autochdir                             " 自动切换当前目录为当前文件所在的目录

set showcmd         " 在右下角显示当前输入的命令（比如输入 d 时会显示）
set wildmenu        " 命令行模式下的补全增强（以列表形式展示选项）

set nobackup           " 不生成备份文件 (~ 文件)
set noswapfile         " 不生成交换文件 (.swp 文件)

" --- 搜索优化 ---
set ignorecase        " 搜索时忽略大小写
set smartcase         " 如果搜索词包含大写，则自动转为大小写敏感
set incsearch         " 边输入边显示匹配结果

" --- 快捷键与行为调整 ---
" 禁用 Q 键，防止误入容易卡住的 Ex 模式
nmap Q <Nop>
let mapleader=" "      " 设置空格为 Leader 键

" 按空格 + w 保存，按空格 + q 退出
nnoremap <leader>w :w<CR>
nnoremap <leader>q :q<CR>

" 按空格 + nh 取消搜索高亮
nnoremap <leader>nh :nohlsearch<CR>

" 禁用声音提示（报错时不会发出叮叮声）
set noerrorbells visualbell t_vb=

将vimrc文件保存到~/.vimrc文件中（~指的是c:/）

在命令行唤起vim，输入`:echo $MYVIMRC`可以检查识别出的配置文件的路径

五、练习建议

初级： 运行终端指令 vimtutor（或 :Tutor），完成 30 分钟互动教学。
中级： 强制在所有编辑任务（笔记、代码、README）中使用 Vim，忍受最初 20 小时的低效期。
高级： 当你觉得某个操作太慢时，去搜“Vim better way for…”，永远有新命令等着你。

如何面对绩点和“过时的”科班教育

Wed, 01 Apr 2026 21:39:26 +0800

我要我的青春洋洋洒洒。

所有，或一无所有。

如何面对绩点和“过时的”科班教育

所有人在上大学后都会怀疑的问题

我为什么要学这门课！！！

这门课有什么用吗！！！

纠结

我仔细思考过花大量时间学好这些过时的，以后很可能用不上的课程对于长远的发展实际意义。

尤其是ai时代，我感觉自己根本没有必要学习这些知识，我的学习速度比起ai简直是尾灯都看不见。

学习这些知识，更像是为了卷绩点保研，卷果酱，卷出国。

走这些主流的大路。

大抵是这么多年根深蒂固的学生思维吧。

在听学长们提到各种东西究竟卷的有多可怕的时候，我真真切切的想：好累呀，不然别卷了？

我们都知道路有很多条，人生是旷野，可是。真的那么容易放得下吗？

至少我真的在这个怪圈里纠缠了非常久。感觉学这些没有意义，想做的事情有很多，想把这些事件腾出来做自己感兴趣的事情，和可能真的跟上时代，对就业后的能力有意义的事情。但是又会在哪个突如其来的小测考得很差，或者说看到绩点很低，排名很差，忍不住有点怀疑自己的选择，忍不住焦虑

人就是既要又要。

我大一上就是做好了不想卷这些的想法，但是最后回顾一整个大一上，发现不被push着学其实我也不会干其他的事情，最后绩点没有，其他事也什么都没干成，好像我的决策是错的。这让我产生了怀疑。

为什么放不下绩点

我想，究其本质，可能是因为。

我没有冒险的勇气。

我们习惯了在稳妥的路上走，稳妥其实并非真正的稳妥，是主流、大众和熟悉给自己带来了安全感。

当你做出了一个和大众相背的结论后，你真的需要足够有勇气，足够有信心，来说服自己：“我做的选择是对的。”

否则，你很有可能陷入"fear of missing out"。

所以我不敢完全的放弃绩点，或者说一直在反复纠结的原因，可能就是：

我不敢抛弃一切去做没有很大把握的事情，不敢“疯狂”一点，也做不到坚信自己的决策。尽管我知道

“高风险，高回报。”

所以

我想钻出我的乌龟壳了。

做一些疯狂一点的事吧。

我相信人的心态会慢慢变得开放，观念也会渐渐转变。

我要想清楚自己想要的是什么，为此我已经下定决心舍弃什么，不能因为这些东西而后悔，也不要因为一时的挫败怀疑自己的选择。

我要我的青春洋洋洒洒。

成功了，那就成一段佳话。失败了，其实也没那么过不去嘛，办法总比困难多，再想办法给过去的自己擦屁股就好了。

学着勇敢。

“所有，或一无所有。”

批判性思维

虽然可能只是目前的知识有限目光短浅还感受不到这门课的真正作用

我怀疑过这种想法是不是急功近利急于求成的快节奏和焦虑带来的，也怀疑过这样会不会学不到真的硬核的东西。

但是，正如前面所说的，我现在想相信自己的选择。

SICP系列笔记汇总

Wed, 01 Apr 2026 21:14:48 +0800

本系列为《计算机程序的构造和解释》（SICP，CS61A 南大引进版）核心笔记，聚焦程序设计的底层逻辑与核心思想，旨在帮助学习者搭建“知其然更知其所以然”的编程认知框架。适合正在学习 CS61A 课程的学习者梳理知识体系，也可作为编程入门者夯实基础、理解程序设计本质的参考资料。

课程主页

一些碎碎念

大一上的我的笔记真是青涩啊（）

记得一开始刚进入大学真的是措手不及

期中前感觉什么都没学，快要考试了才开始疯狂抱佛脚

一个星期抱了半个学期的佛脚，

（最后期中还是喜提不及格hhh，好在平均分也没及格()）

课程评价

总的来说，这门课的氛围真的很好！

真的很少能有机会遇到这么好的老师和助教了！还有交流群里的氛围也很好，现在都还挺活跃hhh

这门课真的是让你学习编程背后的思想

（你能真切的感受到编程的有趣（？），而不像国内很多其他的编程课程一样扣语法，像在做脑筋急转弯题）

当然我的笔记是脱水版了hhh可能没有这些有趣的东西，还是有点干的

最高兴的是初学者也能一上来就工程化的完成了四个代码量很多的大作业！真的受益匪浅！

遗憾的是我没能逼自己适应全英阅读，每次写作业就够痛苦了还要读英文真的要很强大毅力了

——沉浸式翻译启动！（）

上了一学期，我想我真的能说是收获良多！

一些建议

除去一些老生常谈的认真学习的学习方法

不到万不得已不要用ai写作业！！！！

打基础的时候用ai真的会基础很不扎实/泪

学会自己解决问题 STFW RTFW ATFAI()

学会自己debug，不要写出代码跑不过没耐心就丢给ai问问题在哪！！！

(大一下机测我才意识到我已经被ai养的debug都不会了，还得痛苦学习)

逼自己全英阅读！！！逼自己逼自己！！要有决心！！

SICP_interpreter_笔记

Sat, 03 Jan 2026 15:47:49 +0800

摘要

本文为《计算机程序的构造和解释》（SICP，CS61A 南大引进版）用python实现scheme解释器部分课程核心笔记，聚焦程序设计的底层逻辑与核心思想，旨在帮助学习者搭建“知其然更知其所以然”的编程认知框架。适合正在学习 CS61A 课程的学习者梳理知识体系，也可作为编程入门者夯实基础、理解程序设计本质的参考资料。

使用python实现scheme解释器 (Interpreters)

Hangout

翻译与解释器基础 (Translation and Interpreter Basics)

主题概述

计算机只能理解二进制 (Binary) ，而高级编程语言需要被翻译成二进制才能运行。解释器 (Interpreter) 实现了即时 (on-the-fly) 翻译和执行。

核心概念 (Core Concepts)

1. 翻译类型 (Types of Translation)

编译 (Compiled): 一次性全部翻译，稍后运行。

解释 (Interpreted): 边运行边翻译。

2. 解释器语言 (Interpreter Languages)

实现语言 (Implementation Language): 用来编写解释器本身的语言（如 Scheme 解释器可能是用 Python 实现的）。

被实现语言 (Implemented Language): 用户输入的语言（即 Scheme）。

被实现语言被翻译成实现语言。

3. 读-求值-打印循环 (Read-Eval-Print Loop, REPL)

解释器核心的三个步骤:

读 (Read): 读取用户输入（字符串）。
求值 (Eval): 将输入翻译成计算机可读的形式并求值。
打印 (Print): 打印结果给用户。

读取阶段 (The Read Phase)

主题概述

读取阶段将原始输入字符串转换为一种在实现语言（Python）中可操作的表达式表示 (Expression Representation) 。

核心概念

1. 词法分析/提词器(Lexical Analysis / Lexer)

将输入字符串转化为标记 (Tokens) 集合。
分割+提取+初步处理(按照规则转化为放在python列表里的python语法的东西)

标记 (Token): 输入字符串的单个有意义单元，如字面量(literals)、名称(names)、关键字(keywords)、分隔符(delimiters)等。
注：

分隔符：用于分割不同语法单元，如括号，分号，引号关键字：即special form和standard procedures,如define,lambda,if,begin,quote 名称：即标识符，如函数名，变量名字面量：表示直接值的语法元素，如数字，字符串，字符(#\a)，符号('symbol)，布尔值，列表、向量字面量('(1 2 3)、#(a b c))

2. 语法分析 (Syntactic Analysis / Parser)

将标记转化为实现语言中表达式的表示形式(Representation)。

基本表达式的表示:
- 自求值表达式 (Self-Evaluating Expressions) (#t, 5.2): 使用 Python 对应的布尔值或数字。
- 符号 (Symbols) (cons): 使用 Python 字符串。
注： scheme 表达式种类：
- 自求值表达式(self-evaluatingexpressions)
- 符号(symbols)
- 调用表达式(call expressions)
- 特殊表达式(special form expressions)

3. 表示组合 (Representing Combinations)

Scheme 的组合表达式 (<operator> <operand1> ...) 在内部被表示为包含操作符和操作数的Scheme 链表 (Linked Lists) 。

scm> (define expr '(+ 2 3)) ; Create the expression (+ 2 3)
expr
scm> (eval expr) ; Evaluate the expression
5
scm> (car expr) ; Get the operator
+
scm> (cdr expr) ; Get the operands
(2 3)

在 Python 中，Scheme 列表通过自定义的 Pair 类和全局 nil 实例来精确表示:

Python Pair 和 nil 类:

class Pair:
    def __init__(self, first, second):
        self.first = first # 相当于 Scheme 的 car
        self.second = second # 相当于 Scheme 的 cdr
    def __repr__(self):
        return 'Pair({0}, {1})'.format(self.first, self.second)

class nil:
    def __repr__(self):
        return 'nil'

nil = nil()
# 让所有的nil都是同一个nil,防止每次都创建一个instance,出现不同的instance不能进行相等的运算

4. 特殊情况：引用 (`quote`)

特殊语法 ‘<expr> 在读取时会被转换成一个完整的 quote 表达式。

例题

(+ 2 3) 被表示为: Pair('+', Pair(2, Pair(3, nil)))
(define (f) 3)表示为 Pair('define', (Pair(Pair('f', nil), Pair(3, nil))))
4.67 -> 4.67
#t -> True
list -> 'list'
(cons 2 3) -> Pair('cons', Pair(2, Pair(3, nil)))
(if (< x 0) 1 (+ x 1)) -> Pair('if', Pair(Pair('<', Pair('x', Pair(0, nil))), Pair(1, Pair(Pair('+', Pair('x', Pair(1, nil))), nil))))

遇到括号套一层pair

'hello -> Pair('quote', Pair('hello', nil))

求值阶段 (The Eval Phase)

复习：怎么画环境图来着？

(define (make-adder x)
    (lambda (y) (+ x y)))
(define add-three (make-adder 3))
(add-three 5)
(add-three 10)

主题概述

求值阶段 (Eval) 是解释器的核心，它接收表达式的表示形式和一个环境 (Environment) ，并返回求值结果（值）。Eval 和 Apply 是相互递归 (mutually-recursive) 的。

核心概念

1. 环境与框架 (Environments and Frames)

环境 (Environment): 由当前框架、其父框架及其所有祖先框架直到全局框架组成。
框架 (Frame): 在解释器中由 Frame 类实例表示。 Frame有两个实例属性： bindings: 字典，将 Scheme 符号 (Python 字符串) 绑定到 Scheme 值。 parent: 指向父框架（另一个frame实例）

2. 求值基本表达式 (Evaluating Primitive Expressions)

自求值表达式: 它们求值结果就是自身。
符号 (Symbols):

从当前框架开始查找符号的绑定值。
如果未找到，递归地向父框架查找，直到全局框架 。
如果全局框架仍未找到，抛出错误 (SchemeError) 。

3. 求值组合 (Evaluating Combinations)

组合表达式分为特殊形式和调用表达式，取决于其运算符。

特殊形式 (Special Forms): 运算符是特殊的符号（如 define, if, lambda），有其自身的求值规则。
调用表达式 (Call Expressions):
1. 求值运算符，得到一个过程 (Procedure) 。
2. 从左到右求值所有操作数，得到参数值。
3. 应用 (Apply) 过程到参数值。

前两步递归的调用eval喵

应用阶段 (The Apply Phase)

主题概述

应用阶段 (Apply) 将一个过程 (Procedure) 应用于一组参数 (Arguments)。过程有两种类型：内置过程和用户定义过程。

核心概念

1. 内置过程 (Built-In Procedures)

例如 +, list, modulo 。
在解释器中，它们是 BuiltinProcedure 类的实例。

应用规则: 直接调用对应的实现语言（Python）函数，并将参数值传入。

2. 用户定义过程 (User-Defined Procedures)

通过 lambda 或 define 定义。
在解释器中，它们是 LambdaProcedure 类的实例，包含形式参数列表、函数体和父框架 (Parent Frame) 。

应用规则 (Application Rules):

打开一个新框架 (New Frame)，其父框架是该过程的父框架（即创建该过程时的环境）。
将形式参数 (Formal Parameters) 绑定到参数值 (Arguments) 上，存储在新框架中。
在新框架中求值过程的函数体。

3. Eval/Apply 计数 (Counting Eval/Apply Calls)

Eval 和 Apply 是相互调用的：

1. Eval（求值）

Eval 的任务是接收一个表达式（代码）和当前环境，并返回它的值。

基础情况 (Base Cases): 这是递归的终点。
- 自求值表达式 (Self-evaluating expressions): 比如数字（5）或字符串（"hello"），它们的值就是它们本身。
- 符号查找 (Look up values): 比如变量名 x。求值器会去内存（环境）中查找 x 对应的值。
递归情况 (Recursive Cases):
- Eval(operator) 和 Eval(o): 当遇到一个函数调用时，它先分别求出“函数名”和“所有参数”的具体数值。
- Apply(proc, args): 一旦参数准备好了，它就会把这些参数交给 Apply 去实际执行。
- 特殊形式 (Special Form): 比如 if 语句或 define。这些不是普通函数，需要特殊的处理逻辑

2. Apply（应用）

Apply 的任务是接收一个“函数”和一组“参数”，并执行这个函数。

基础情况 (Base Cases):
内置过程 (Built-in procedures): 比如加法 + 或减法 -。这些是由底层硬件或底层语言（如 C 或 Python）直接实现的，不需要再拆解。
递归情况 (Recursive Cases):
- Eval(body) of user defined procedures: 对于用户自己定义的函数，Apply 会打开函数体（Body），然后在这一组新参数的环境下，**重新调用 Eval** 来处理函数体里的代码。

这种相互递归 (Mutual Recursion) 形成了一个闭环。通过这个循环，解释器可以处理极其复杂的嵌套代码：

Eval 负责“拆解”结构。
Apply 负责“执行”动作。

例题

SICP_SQL_笔记

Sat, 03 Jan 2026 12:48:01 +0800

摘要

本文为《计算机程序的构造和解释》（SICP，CS61A 南大引进版）SQL部分课程核心笔记，聚焦程序设计的底层逻辑与核心思想，旨在帮助学习者搭建“知其然更知其所以然”的编程认知框架。适合正在学习 CS61A 课程的学习者梳理知识体系，也可作为编程入门者夯实基础、理解程序设计本质的参考资料。

SQL 数据库查询(Structured Query Language)

注意事项

句末记得加分号!
记得所有的字符串都要加""!
SQL中的中的取等不用==!用=即可!!
审清楚题干!!

主题 1：声明式编程与 SQL 基础 (Declarative Programming & SQL Basics)

主题概述

SQL 是一种声明式语言 (Declarative Language)。与传统的命令式编程（如 Python，需分步指明“怎么做”）不同，声明式编程只需告诉计算机“想要什么”，由解释器决定如何执行。

核心概念

1. 数据库结构 (Database Structure)

表 (Table)：存储数据的核心单元，由固定数量的列 (Columns) 和多行数据条目 (Rows/Records) 组成。
列 (Column)：具有特定的名称和描述。
行 (Row)：为每一列提供具体的值。

2. 创建表

在 SQL 中，可以通过组合已有的数据或从头定义来创建表：

使用 SELECT 创建的是临时数据行,用于展示给用户看而不存储
使用CREATE TABLE <NAME> AS存储数据
使用 UNION 将多个 SELECT 语句连接起来,创建多行。
语法示例：

CREATE TABLE dogs AS
  SELECT "abraham" AS name, "long" AS fur UNION
  SELECT "barack", "short" UNION
  SELECT "clinton", "long";

3. 选择数据 (The SELECT Statement)

最基本的查询结构，用于从表中提取特定数据。

SELECT会做什么?
- 无FROM: 可以制造单行,用逗号将同一行内不同列的内容隔开多用于CREATE中;可以用AS 取名作为一列的列名称
- 有FROM: 从FROM的TABLE中用列名称把一列拿出来(即列名称会被evaluate成为多个行的值)
- SELECE始终决定了列规模
- SELECT * FROM选择全部

语法顺序：SELECT [列名] FROM [表名] WHERE [过滤条件] ORDER BY [排序方式] LIMIT [数量];
WHERE 关键字：用于根据布尔条件过滤行。(输入表的行子集(subset of the rows of the input table))
ORDER BY 关键字：对结果进行排序（ASC 升序，默认；DESC 降序）。
LIMIT关键字: 限制输出行数

4. `SELECT`语句中的算术(Arithmetic)

-> 直接使用运算符号

CREATE TABLE restaurant AS
SELECT 101 AS table, 2 AS single, 2 AS couple UNION
SELECT 102 , 0 , 3 UNION
SELECT 103 , 3 , 1;

sqlite> SELECT table, single + 2 * couple AS 
total FROM restaurant;

主题 2：连接与别名 (Joins & Aliasing)

主题概述

连接 (Join) 允许我们组合多个表的数据。当我们连接两个表时，结果是一个新表，其中包含原始表行之间的每一种可能组合（笛卡尔积）。

核心概念 (Core Concepts)

1. 连接表 (Joining Tables)

语法：在 FROM 子句中列出多个表名，用逗号分隔。

SELECT * FROM parents, dogs WHERE child = name;

2. 别名 (Aliasing)

当连接同一个表两次（Self-join）或多个表有重名列时，必须使用别名。

语法：使用 AS 关键字（可省略）。
作用：消除歧义。
示例：寻找所有兄弟姐妹（拥有共同父母的两个孩子）：

SELECT a.child AS first, b.child AS second
  FROM parents AS a, parents AS b
  WHERE a.parent = b.parent AND a.child < b.child;
*注意：使用 `a.child < b.child` 是为了去除重复项并避免自己与自己配对。*

扩展: 显式连接 -> JOIN ON语句

使用显式语句连接,使表格连接更清晰明了

Why JOIN?

数据库中的表通常是为了消除冗余而拆分的（例如：一张表存学生信息，一张表存班级信息）。连接 (Join) 的目的就是根据两个表之间的公共列（通常是 ID），将分散的数据重新组合成一行。

CS61A 风格: 隐式连接 (Implicit Join)

这是 PPT 中主要演示的方法。它实际上是先做笛卡尔积（Cross Join），然后用 WHERE 过滤。

语法：在 FROM 子句中用逗号分隔表名，在 WHERE 子句中指定连接条件。
示例：

SELECT name, course 
FROM students, enrollments 
WHERE students.sid = enrollments.sid;

现代标准风格: 显式连接 (Explicit JOIN)

这是更推荐的写法，语义更清晰，将“连接逻辑”和“过滤逻辑”分开了。

语法：使用 JOIN 关键字，并用 ON 指定连接条件。
示例：

SELECT name, course 
FROM students 
INNER JOIN enrollments 
ON students.sid = enrollments.sid;

常见的连接类型 (Types of Joins)

为了演示，假设我们有两张表：

Table A (Students): {1: 'Alice', 2: 'Bob', 3: 'Charlie'}
Table B (Grades): {1: 'A', 2: 'B', 4: 'C'} (注意：Charlie 没有成绩，ID 4 的成绩属于不存在的学生)

(1) 内连接 (INNER JOIN)

定义：只保留两个表中都存在匹配关系的行（交集）。
CS61A 写法：FROM A, B WHERE A.id = B.id
标准写法：FROM A INNER JOIN B ON A.id = B.id
结果：Alice (A), Bob (B)。(Charlie 和 ID 4 被丢弃)

(2) 左连接 (LEFT OUTER JOIN)

定义：保留左表（FROM 后的表）的所有行。如果右表没有匹配，右表的列显示为 NULL。
标准写法：FROM A LEFT JOIN B ON A.id = B.id
结果：
Alice - A
Bob - B
Charlie - NULL (因为 Charlie 在左表，但右表没成绩)
注：SQLite 支持 LEFT JOIN，但不支持 RIGHT JOIN。

(3) 交叉连接 (CROSS JOIN / Cartesian Product)

每一行 A 与每一行 B 配对，产生所有可能的组合。

在输出中连接string使用||

主题 3：聚合与分组 (Aggregation & Grouping)

主题概述

聚合函数允许我们对一组行执行操作并返回单个值，通常与分组配合使用。

核心概念 (Core Concepts)

1. 聚合函数 (Aggregate Functions)

COUNT(*)：计算行数。
SUM(col)：求某一列的和。(注:求行的值需要使用多个+运算符)
MIN(col) / MAX(col)：某一列中的最小值/最大值。
AVG(col)：某一列的平均值。

2. 分组查询 (GROUP BY)

GROUP BY <expression>后表达式求值结果相同被化为同一组,表达式中可以使用多个列名和运算符

作用：将结果集划分为多个组，对每个组分别应用聚合函数。
HAVING 过滤：用于过滤组，类似于 WHERE 过滤行。
示例：统计每种毛发类型的狗的数量，且只显示数量大于 1 的组：

SELECT fur, COUNT(*) FROM dogs GROUP BY fur HAVING COUNT(*) > 1;

主题 4：修改表记录 (Modifying Records)

主题概述

除了查询，SQL 还提供了创建空表及增删改查记录的语句。

核心概念 (Core Concepts)

1. 表的生命周期

CREATE TABLE：创建一个没有初始数据的空表。
CREATE TABLE [name]([column_defs]);
DROP TABLE：从数据库中永久删除表。
DROP TABLE [IF EXISTS] [name];

例:

CREATE TABLE parents(parent, child);
CREATE TABLE dogs(name, fur, phrase DEFAULT 'woof');
DROP TABLE dogs;
DROP TABLE IF EXISTS parents;

2. 数据操作 (DML)

INSERT：插入新行。

INSERT INTO [table]([columns]) VALUES([values]), ([values]);

e.g.
INSERT INTO dogs(name, fur) VALUES('fillmore', 'curly');
INSERT INTO dogs VALUES('delano', 'long', 'hi!');
INSERT INTO dogs(fur, phrase) VALUES('curly', 'bark');

UPDATE：修改现有记录。

UPDATE [table] SET [column] = [expression] WHERE [condition];

e.g.
UPDATE dogs SET phrase = 'WOOF' WHERE fur = 'curly';

DELETE：删除现有行。

DELETE FROM [table] WHERE [condition];

e.g.
DELETE FROM dogs WHERE name = 'herbert';

做题技巧

确定输入,输出,一列一列join
有时可创建辅助表来帮助思考(FROM后面加括号,写一串SELECT语句)

SICP_scheme_笔记

Sat, 03 Jan 2026 12:47:38 +0800

摘要

本文为《计算机程序的构造和解释》（SICP，CS61A 南大引进版）scheme部分课程核心笔记，聚焦程序设计的底层逻辑与核心思想，旨在帮助学习者搭建“知其然更知其所以然”的编程认知框架。适合正在学习 CS61A 课程的学习者梳理知识体系，也可作为编程入门者夯实基础、理解程序设计本质的参考资料。

SICP Note -> Scheme

主题一：Scheme 基础与求值 (Scheme Basics and Evaluation)

主题概述

Scheme 是一种 Lisp 方言，其核心特点是程序由表达式 (Expressions) 构成，并且代码与数据结构高度统一。理解 Scheme 的求值规则，尤其是调用表达式 (Call Expressions) 和特殊形式 (Special Forms) 的区别，是关键。

核心概念

1. 表达式的分类 (Types of Expressions)

Scheme 程序由两种表达式构成：

原子表达式 (Atomic Expressions / Atoms) ：不可再分割的基本值。
- 自求值 (Self-evaluating): 数字 (3, -10)、布尔值 (#t, #f) 。
- 符号 (Symbols): 绑定到值的名称 (+, modulo, x) 。
组合 (Combinations) ：形如 (<operator> <operand1> <operand2> ...) 。它们是调用表达式或特殊形式表达式 。

2. 调用表达式求值 (Call Expression Evaluation)

调用表达式将一个过程 (Procedure) 应用于一组参数 (Arguments) 。

求值三步法:

对 运算符 (Operator) 求值，得到一个过程。

从左到右对所有 操作数 (Operands) 求值，得到参数。

将过程应用于参数。

例：

scm> (- (+ 7 (* 4 6)) (* 3 5))
; 1. (* 4 6) -> 24
; 2. (+ 7 24) -> 31
; 3. (* 3 5) -> 15
; 4. (- 31 15) -> 16
16

3. 特殊形式 (Special Forms)

特殊形式的求值规则不同于标准的调用表达式，它们的运算符（如 define, if, lambda）不一定先求值，且操作数不一定全部求值。

特殊形式	英文标注	语法	求值规则
定义	define	`(define <name> <expr>)`	1. 求值 `<expr>` 。 2. 将结果值绑定到当前框架的 `<name>` 上。
条件	if	`(if <predicate> <if-true> <if-false>)`	1. 求值 `<predicate>` 。 2. 如果结果不是 `#f` (唯一 Falsy 值) ，求值并返回 `<if-true>` ；否则求值并返回 `<if-false>` 。
过程	lambda	`(lambda (<params>) <body>)`	创建并返回一个 lambda 过程 (Procedure) 。不求值函数体 `<body>`，函数体在过程被调用时才求值。

define 简化形式 (Function Shorthand): (define (square x) (* x x)) 等同于 (define square (lambda (x) (* x x))) 。

主题二：数据抽象：Pairs 与 Lists (Data Abstraction: Pairs and Lists)

主题概述

Scheme 中唯一的序列类型是链表 (Linked List) 。链表是通过基本的构建块对 (Pairs) 构成的。

核心概念 (Core Concepts)

1. 对 (Pairs)

对是使用 cons 表达式创建的基本结构。

cons: 构造一个对。
- (cons <first> <second>)
car: 选择对中的第一个元素 (Head) 。
cdr: 选择对中的第二个元素 (Tail) 。

2. 链表 (Linked Lists)

链表是通过递归地使用 cons 构造对，并以特殊符号 nil (空列表) 终止而形成的序列结构。

nil: 表示空列表 (Empty List) 。
链表结构：第二个元素 (cdr) 必须是另一个对或 nil 。

例题：链表构造

scm> (cons 1 (cons 2 nil))
(1 2) ; 列表的表示形式

scm> (define x (cons 1 (cons 2 nil)))
scm> (car x)
1
scm> (cdr x)
(2) ; 结果仍然是一个列表 (一个对，其 car 是 2，cdr 是 nil)

主题三：符号编程与引用 (Symbolic Programming and Quotation)

主题概述

在 Scheme 中，符号 (Symbols) 通常求值为其绑定的值。引用 (Quotation) 允许我们直接引用符号本身，而不是它的值。这对于将 Scheme 代码结构作为数据处理（符号编程）至关重要。

核心概念 (Core Concepts)

1. 引用 (`quote` 或 `'`)

作用: 阻止表达式被求值，而是将表达式本身作为值返回。
使用方式:
- 长形式: (quote <expr>)
- 短形式: '<expr>

例题：引用符号

scm> (define a 1)
scm> (list a 2)
(1 2) ; a 被求值为 1

scm> (list 'a 2)
(a 2) ; 'a 被引用，求值为符号 a 本身

2. 引用组合 (Quoting Combinations)

引用也可以应用于组合表达式，使其成为一个列表数据结构。

例题：引用列表

scm> '(a b c)
(a b c) ; 返回列表 (a b c)
scm> (car '(a b c))
a       ; car 选择列表的第一个元素
scm> (cdr '(a b c))
(b c)   ; cdr 选择列表的剩余部分

主题四：尾递归 (Tail Recursion)

主题概述

Scheme 语言不内置迭代 (Iteration) 结构，循环通常通过递归 (Recursion) 实现。尾递归 (Tail Recursion) 是一种特殊的递归形式，支持尾调用优化 (Tail Call Optimization)，能像迭代一样高效运行，使用常数 (Constant) 数量的帧 (Frames) 。

核心概念

1. 尾上下文与尾调用 (Tail Context and Tail Call)

尾上下文 (Tail Context): 表达式在尾上下文中，意味着它是在函数调用中求值的最后一步。在它求值/应用之后，没有其他操作会进行。
尾调用 (Tail Call): 发生在尾上下文中的函数调用。
尾递归 (Tail Recursion): 尾调用调用了函数自身 。

2. 尾调用优化 (Tail Call Optimization, TCO)

如果 Scheme 语言支持 TCO，一个尾递归函数只会开启常数数量的帧，从而避免栈溢出，效率等同于迭代。

3. 识别尾上下文 (Identifying Tail Contexts)

是尾上下文 (Tail Contexts):
- lambda（函数）的最后一个 body 子表达式。
- if 中的 <if-true> 和 <if-false> (前提是 if 表达式本身在尾上下文中)。
- and, or, begin, let 中的最后一个子表达式。
不是尾上下文 (Non-Tail Contexts):
- 在 *, +, - 等操作符下作为操作数 (Operand) 的递归调用。因为操作数求值后，还需要进行操作符的运算。

例题：非尾递归阶乘 (Non-Tail Recursive Factorial)

(define (fact n)
  (if (= n 0)
      1
      # 递归调用 (fact (- n 1)) 的结果必须和 n 相乘
      # 因此 (fact ...) 不在尾上下文，需要保留帧 f1, f2, ...
      (* n (fact (- n 1)))))

4. 编写尾递归函数 (Writing Tail Recursive Functions)

要将非尾递归函数转换为尾递归，通常需要引入一个辅助函数 (Helper Function) 和一个累加器 (Accumulator) 参数。

目标: 将所有等待的计算（例如上面的 * n）作为参数，传递给下一次递归调用。
累加器 (Accumulator): 存储到目前为止的计算结果。

例题：尾递归阶乘 (Tail Recursive Factorial)

(define (fact n)
  # 引入辅助函数 fact-tail
  (define (fact-tail n result) ; result 就是累加器
    (if (<= n 1)
        result
        # 最后一步操作是 (fact-tail ...)，
        # 这是一个尾调用，无需保留当前帧。
        (fact-tail (- n 1) (* n result)))) 
  (fact-tail n 1)) # 初始调用，累加器从 1 开始

主题五：表达式作为数据 (Expressions As Data)

主题概述

Scheme 的核心理念是代码即数据 (Code as Data)。由于 Scheme 表达式（组合）本身就是列表，我们可以将代码结构当作普通数据来操作。

核心概念

1. 表达式的表示与求值 (Representation and Evaluation)

表达式的类型: 在 Scheme 中，表达式要么是原始表达式 (primitive expressions)，要么是列表 (lists)。
引用 (Quoting): ‘<expr> 或 (quote <expr>) 阻止表达式求值，返回表达式本身（即一个数据结构）。
eval 函数: 接收一个未求值 (unevaluated) 的表达式（数据），并对其进行求值。
例题:

scm> '(+ 1 2) ; 引用，返回列表数据
(+ 1 2)
scm> (eval '(+ 1 2)) ; 对该列表进行求值
3

表达式的操作: 我们可以将表达式赋值给变量、作为参数传递给函数、甚至在函数内创建并返回新的表达式。

主题六：辅助特殊形式 (Auxiliary Special Forms)

主题概述

begin 和 let 是 Scheme 中常用的特殊形式，用于控制求值顺序和局部变量的创建。

核心概念

1. `begin` (顺序执行)

作用: begin 接收任意数量的子表达式。它会按顺序 (in order) 求值这些子表达式，并以最后一个子表达式的值作为整个 begin 表达式的值。
用途: 当你需要在一个预期只有一个表达式的位置（如函数体）执行多个带有副作用的操作时，begin 非常有用。
例题:

scm> (begin (define x 2) (define x (+ x 1)) x)
3 ; 返回最后一个表达式 x 的值

2. `let` (局部绑定)

作用: let 用于创建临时的局部变量绑定，仅在 let 的主体 (body) 中有效。
绑定规则: 所有的 symbol 都与其对应的 expr 的值并行 (in parallel) 绑定。这意味着一个绑定不能引用同一 let 表达式中定义的其他绑定。
语法:

(let ((symbol1 expr1)
      (symbol2 expr2)
      ...)
  <body>)

主题七：宏原理 (Macro Principles)

主题概述

宏 (Macros) 是一种元编程 (Metaprogramming) 工具，它允许用户在程序求值之前转换程序的代码结构，从而扩展语言的语法。

核心概念

1. 定义宏 (`define-macro`)

语法: (define-macro (<name> <params>) <body>)。
宏与过程的区别:
过程 (Procedure): 接收值 (values) 作为参数，返回值。
宏 (Macro): 接收表达式 (expressions) 作为参数，返回表达式（代码）。

2. 宏的求值流程 (Macro Evaluation) 【核心考点】

宏调用的求值流程有别于普通函数调用：

不求值操作数 (Operands Not Evaluated): 宏的操作数不会像普通函数调用那样被求值。
传递表达式: 操作数（表达式本身）作为参数传递给宏过程。
宏转换: 宏过程执行，返回一个新的表达式 (a new expression)。
再次求值: 解释器会立即对宏返回的新表达式进行求值 (evaluated)。

3. 宏的用途 (Writing Macros)

编写宏时，关键是思考具有等效行为的表达式是什么。宏的目的是将自定义的语法转换为等效的 Scheme 基本语法。

例题：for 宏: 转换 (for x in '(1 2 3 4) do (* x x)) 为 (map (lambda (x) (* x x)) '(1 2 3 4))。

(define-macro (for sym in vals do expr)
  (list 'map (list 'lambda (list sym) expr) vals))

主题八：准引用 (Quasi-Quotation)

主题概述

在宏中，我们经常需要构造新的列表（表达式）。准引用 (Quasi-Quotation) 允许在引用 (Quoting) 表达式的同时，有选择地对其中的部分子表达式进行求值，大大简化了代码生成。

核心概念

符号	英文标注	名称	作用
```	Quasiquote	准引用	允许列表中的大部分内容被视为字面值（像 `quote` 一样）。
`,`	Unquote	取消引用	必须出现在准引用 ```` 内部。紧跟其后的表达式会被求值，然后将其值插入到构造的列表中。

例题：使用准引用重写 for 宏

(define-macro (for sym vals expr)
  ; 整个结构是准引用的 (`)，大部分是字面值
  ; ,sym, ,expr, ,vals 在宏应用时会被求值并替换到相应位置
  `(map (lambda (,sym) ,expr) ,vals))

( 和 map 是字面符号。
,sym 求值结果是符号 x，被插入到 lambda 的参数列表中。
,expr 求值结果是表达式 (* x x)，被插入到 lambda 的函数体中。
,vals 求值结果是表达式 '(1 2 3 4)，被插入到 map 的第二个参数位置。

函数1:twice
方式1:正常函数
scm> (define (twice exp) (list 'begin exp exp))
twice
scm> (eval (twice '(print 2)))
2
2
方式2:macro
scm> (define-macro (twice exp) (list 'begin exp exp))
twice
scm> (twice (print 2))
2
2
即macro只是相当于省略了调用时需要的eval 和'
方式3:准引用(suger)
scm> (define-macro (twice exp) `(begin ,exp ,exp))
twice
scm> (twice (print 2))
2
2

函数2
scm> (define-macro (add-to sym exp) (list 'define sym (list '+ sym exp)))
add-to
scm> (add-to 'x (+ x 2))
x
scm> x
30

scm> (define-macro (add-to sym exp) `(define ,sym (+ ,sym ,exp)))
add-to
scm> (add-to x (+ x 2))
x
scm> x
62

函数3
scm> (define-macro (for sym in val do exp) `(map (lambda (,sym) ,exp) ,val))
for
scm> (for i in (list 1 2 3) do (print i))
1
2
3
(undefined undefined undefined)
(上面这行是map的返回值,即None,None,None)

主题九：惰性求值与流基础 (Lazy Evaluation & Stream Basics)

主题概述

流 (Streams) 是 Scheme 中处理序列的一种方式。它与链表（List）非常相似，但核心区别在于：流的“剩余部分”（tail）只有在被显式要求时才会进行计算。这种机制被称为惰性求值 (Lazy Evaluation)。

核心概念

1. 为什么需要流？

Python 对比: Python 使用迭代器（Iterators）和生成器（Generators）来实现惰性求值，可以表示无限序列。
Scheme 链表的局限: 在标准链表中，cons 的第二个参数总是会被立即求值。如果尝试递归定义无限链表，会导致 maximum recursion depth exceeded（达到最大递归深度）。
流的优势: 流允许我们表示巨大的甚至无限长 (infinitely long) 的列表，因为它只在需要时计算下一个元素。

2. 流的构造与基本操作

cons-stream: 构造一个流。其第二个参数是一个承诺 (Promise)，不会立即求值。
car: 获取流的第一个元素（与 List 相同）。
cdr-stream: 获取流的剩余部分。这是关键操作：它会强制 (Force) 履行承诺，计算并返回流的下一个部分。
例题：流的表示

scm> (define s (cons-stream 1 (cons-stream 2 nil)))
s
scm> s
(1 . #[promise (not forced)])  ; 第二部分显示为尚未强制的承诺
scm> (car s)
1
scm> (cdr-stream s)
(2 . #[promise (not forced)])

主题十一：无限流 (Infinite Streams)

主题概述

由于流是惰性求值的，我们可以定义一个在逻辑上永远不会结束的序列。

核心概念

1. 定义无限流

通过在 cons-stream 的第二个参数中进行递归调用，可以创建一个无限序列。

例题：整数流 (Integer Stream)

(define (ints first)
  (cons-stream first (ints (+ first 1))))

scm> (define s (ints 1))
scm> (car s)
1
scm> (car (cdr-stream s))
2

2. 使用高阶函数操作流

我们可以像操作 List 一样编写流的操作函数，只需将 cons 替换为 cons-stream，将 cdr 替换为 cdr-stream。

map-stream (流映射):

(define (map-stream fn s)
  (if (null? s)
      nil
      (cons-stream (fn (car s))
                   (map-stream fn (cdr-stream s)))))

filter-stream (流过滤): 只有当满足条件的元素被找到时，才会构造流的下一个 car。

主题十二：流的高级应用 (Advanced Stream Applications)

核心概念 (Core Concepts)

1. 递归定义的流 (Self-referencing Streams)

流可以引用自身来定义复杂的序列。

全 1 流 (Ones): (define ones (cons-stream 1 ones))
整数流 (Integers): 通过将“全 1 流”与“当前整数流”相加得到下一个整数。

(define ones (cons-stream 1 ones))
(define ints (cons-stream 1 (add-stream ones ints)))

2. 流与列表的转换

stream-to-list: 为了查看流的内容，通常需要将其转换为列表，并指定获取元素的数量（避免死循环）。

SICP_python_期中后笔记

Sat, 03 Jan 2026 12:47:27 +0800

摘要

本文为《计算机程序的构造和解释》（SICP，CS61A 南大引进版）python部分期中后课程核心笔记，聚焦程序设计的底层逻辑与核心思想，旨在帮助学习者搭建“知其然更知其所以然”的编程认知框架。适合正在学习 CS61A 课程的学习者梳理知识体系，也可作为编程入门者夯实基础、理解程序设计本质的参考资料。

SICP_python_期中后笔记

拓展

1. Imperative Programming（命令式编程）

核心思想

通过一系列指令（statements）改变程序的状态（state）来完成计算。关注 HOW（具体步骤）。

特征

有可变变量（variables）
通过赋值（assignment）改变状态
使用控制结构（control flow）：if / for / while
程序表现为逐步执行的过程

常见语言

C、C++、Java、Python、JavaScript、Go、Rust

适用场景

操作系统、游戏开发、需要精确流程控制或高性能的系统

2. Functional Programming（函数式编程）

核心思想

以数学函数为基础，不依赖可变状态，通过函数组合完成计算。关注 WHAT（要做什么）。

特征

不可变性（immutability）
纯函数（pure functions），无副作用（side effects）
函数是一等公民（first-class functions）
常用递归（recursion）
map / filter / reduce 是典型操作

常见语言

Haskell、Lisp、OCaml、F#；Python/JavaScript 可写函数式风格

示例（Python）

numbers = [1, 2, 3]
result = list(map(lambda x: x + 1, numbers))

适用场景

数学计算、并行计算、金融系统、需要高可预测性的程序

3. Logic Programming（逻辑式编程）

核心思想

使用事实（facts）和规则（rules）描述问题，由系统进行自动推理（inference）。关注 WHAT（描述规则），系统决定 HOW（如何推导）。

特征

程序由 facts + rules + queries 组成
基于一阶逻辑（first-order logic）
使用分辨率（resolution）进行推理
强调声明式描述

常见语言

Prolog（代表性语言）

示例（Prolog）

parent(tom, bob).
parent(bob, ann).

grandparent(X, Y) :- parent(X, Z), parent(Z, Y).

适用场景

人工智能、知识库、规则引擎、专家系统

4. 三种范式对比总结

范式	核心思想	状态 State	特征关键词	示例语言
命令式 Imperative	通过指令改变状态（HOW）	可变	assignment, loops, control flow	C, Java, Python
函数式 Functional	用函数组合描述计算（WHAT）	不可变	pure functions, immutability, recursion	Haskell, Lisp
逻辑式 Logic	用规则推理得到结果（WHAT）	无显式状态	facts, rules, queries, inference	Prolog

编译器理解: 词法 -> 语法 -> 语义

Lexical（词法）

把字符拆成最小有意义单位（token）。 识别：变量名、关键字、数字、字符串、运算符、符号等。作用：告诉编译器“这串字符是什么词”。

Syntax（语法）

检查 token 是否能组成合法的结构。 作用：决定一句代码的结构是否符合语言规则（是否“通顺”）。

Semantics（语义）

代码表达的实际含义与执行效果。 作用：定义语句运行后会做什么、得到什么结果。

代码风格:类型提示(type hint)

检查 Python 版本：

import platform
print(platform.python_version())
3.12.7

安装 MyPy ：

$ python -m pip install mypy

使用 MyPy 进行类型检查：

$ mypy program.py

1. 变量 (Variables)

声明变量类型 使用冒号 : 来声明变量类型。

age: int = 1

未初始化的变量注解 不需要立即给变量赋值即可添加注解。这在条件分支赋值中非常有用（运行时直到赋值前没有具体值）。

a: int  # 合法

# 示例：在条件分支中使用
child: bool
if age < 18:
    child = True
else:
    child = False

2. 常用的内置类型 (Useful Built-In Types)

基本类型 大多数情况下，直接使用类型名称即可。 注意：mypy 通常能推断出变量类型，因此显式注解在技术上是冗余的，但有助于代码清晰。

x: int = 1
x: float = 1.0
x: bool = True
x: str = "test"
x: bytes = b"test"

集合类型 (Collections) - Python 3.9+ 集合内元素的类型放在方括号 [] 中。

列表 (List): x: list[int] = [1]
集合 (Set): x: set[int] = {6, 7}

映射类型 (Mappings) 需要同时指定键 (Key) 和值 (Value) 的类型。

字典 (Dict): x: dict[str, float] = {"field": 2.0}

元组 (Tuples)

固定大小: 需要指定所有元素的类型。 x: tuple[int, str, float] = (3, "yes", 7.5)
可变大小: 使用一种类型加上省略号 ...。 x: tuple[int, ...] = (1, 2, 3)

联合类型 (Union Types) - Python 3.10+ 当值可能是多种类型之一时，使用 | 运算符。

x: list[int | str] = [3, 5, "test", "fun"]

可选类型 (Optional Types) 对于可能为 None 的值，使用 X | None。

x: str | None = "something" if some_condition() else None

# 类型缩窄 (Type Narrowing)
if x is not None:
    print(x.upper())  # Mypy 知道此处 x 不为 None

# 如果逻辑上确定不为 None 但 mypy 无法推断，可使用 assert
assert x is not None
print(x.upper())

3. 函数 (Functions)

函数定义注解 使用 -> 指定返回类型。

def stringify(num: int) -> str:
    return str(num)

多个参数

def plus(num1: int, num2: int) -> int:
    return num1 + num2

无返回值 如果函数不返回值，返回类型使用 None。

默认值: 参数的默认值写在类型注解之后。

def show(value: str, excitement: int = 10) -> None:
    print(value + "!" * excitement)

动态类型 (Dynamic Typing)

未指定类型的参数会被视为 Any（动态类型）。
没有任何注解的函数不会被类型检查器检查。

def untyped(x):
    x.anything() + 1 + "string"  # 不会报错

可调用对象 (Callables) 用于注解函数作为参数传递的情况（需要从 collections.abc 导入）。格式：Callable[[参数类型列表], 返回类型]

from collections.abc import Callable

def f(x: int, y: float) -> float:
    return x + y

x: Callable[[int, float], float] = f

生成器 (Generators) 生成器函数实际上是返回一个迭代器，因此使用 Iterator 进行注解。

from collections.abc import Iterator

def gen(n: int) -> Iterator[int]:
    i = 0
    while i < n:
        yield i
        i += 1

多行函数注解 当参数较多时，可以将注解拆分为多行。

def send_email(
    address: str | list[str],
    sender: str,
    cc: list[str] | None,
    bcc: list[str] | None,
    subject: str = '',
    body: list[str] | None = None,
) -> bool:
    ...

主题 1：面向对象编程基础 (Object-Oriented Programming, OOP)

主题概述

OOP 是一种组织程序的方法，将数据（属性 Attributes）和行为（方法 Methods）捆绑在一起。每个对象拥有自己的局部状态 (Local State)，不同对象之间通过方法调用进行交互。
这是一种以“对象（objects）”为中心的程序设计方法。对象把数据（属性 attributes）和操作这些数据的行为（方法 methods）封装在一起，通过对象之间的交互来完成程序的功能。
每个对象都有两个特点：

它有什么（属性 / 数据）
它能做什么（行为 / 方法）

OOP 的三要素（经典版本）

封装（Encapsulation）：把数据与操作封在对象内部，对外提供有限接口。
继承（Inheritance）：子类可以继承父类的属性和方法，实现代码复用。
多态（Polymorphism）：同一方法名在不同对象上有不同实现，运行时动态决定调用哪个版本。

一句话总结

正经版：OOP = 用对象来组织程序，数据 + 行为一起封装，通过继承复用，通过多态扩展。
形象版：OOP = 把程序写成一堆“现实世界中的小东西”，每个东西都有属性、有行为，它们互相合作，程序就跑起来了。

创建对象，让对象自己按照规则做事

核心概念 (Core Concepts)

1. 类与实例 (Classes and Instances)

类 (Class): 对象的模板。定义了所有实例共享的属性和行为。
实例 (Instance): 类的具体实现。例如，Account 是类，tom_account 是一个实例。
构造函数 (__init__): 当创建一个新实例时自动调用的方法，用于初始化实例属性。
self: 指向当前正在被操作的实例。在类内部定义方法时，第一个参数通常是 self。

2. 属性查找机制 (Attribute Lookup)

当我们求值 <expression>.<name> 时，解释器遵循以下顺序：

求值点号左边的 <expression>，得到一个对象。
查找实例属性: 在该对象的实例属性中查找 <name>。如果找到，返回其值。
查找类属性: 如果实例中没找到，去创建该对象的类中查找。
查找父类: 如果类中没找到，沿着继承链向上查找。
如果找到的是一个函数，则返回一个绑定方法 (Bound Method)。

注意： 赋值操作 (obj.x = 1) 总是会在实例上创建或修改属性，而不会修改类属性。

3. 点表达式的评估（Evaluation of Dot Expression）

<expression>.<name>

求值点号左侧expression，返回对象
将与该对象的实例属性进行匹配；如果存在具有该名称的属性，则返回其值。
否则，在类中一层一层向上查找，这将产生一个类属性值（如果不存在这样的类属性，则会报告 AttributeError）。
不是函数 -> 返回该值；
是函数 -> 返回绑定方法，且将self传入第一个参数。

例题

例1: 封装（Encapsulation）
Why we need Encapsulation:
- Protect data security
- Reduce coupling

例1
    # class attribute
    interest = 0.02

    # constructor
    def __init__(self, account_holder): 
        self.balance = 0 # instance attribute
        self.holder = account_holder
    
    # methods
    def deposit(self, amount): 
        self.balance += amount
        return self.balance
    
    def withdraw(self, amount):
        if amount > self.balance:
            return 'Insufficient funds'
        self.balance -= amount
        return self.balance

jacy = Account('Jacy') 
"""
>>> jacy.balance
0
>>> jacy.deposit(10)
10
>>> jacy.withdraw(5)
5
"""

例2：类属性查找（Class attribute lookup）

If it names an attribute in the class, return the attribute value. 如果它指定了类中的一个属性，则返回该属性的值。

Otherwise, look up the name in the base class, if there is one. 否则，在基类中查找该名称（如果有的话）。


例2
class A:
    z = -1
    def f(self, x):
        return B(x - 1)
    def __repr__(self):
        return 'A()'
    
class B(A):
    n = 4
    def __init__ (self, y):
        if y:
            self.z = self.f(y)
        else:
            self.z = C(y + 1)
    def __repr__(self):
        return f'B(z={self.z})'

class C(B):
    def f(self, x):
        return x
    def __repr__(self):
        return f'C(z={self.z})'

a = A()
b = B(1)
b.n = 5

>>> C(2).n
4
>>> a.z == C.z
True
>>> a.z == b.z
False
>>> b
B(z=B(z=C(z=1)))

#为什么C的z是1呢？
#B中的z是一个instance attribute，理论上C在B中找不到不应该去A中找然后得到z=-1吗？
#因为C没有init！！！所以C在创建instance 的时候就会调用一次B的init，
#从而在执行init的时候获得一个z！
#C 继承 B 的 init ，所以走 B.init：
# y = 1   非零
# self.z = self.f(1)
# 但这次 self 是 C 的实例，所以调用的是 C.f：
# C.f(self, 1) → return 1
# 因此：
# C(1).z = 1

>>> b.z
B(z=C(z=1))
>>> b.z.z
C(z=1)
>>> b.z.z.z
1
>>> b.z.z.z.z
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'z'

拓展:LSP: 里氏替换原则：

凡是出现基类的地方，都可以用子类替换它，而不会影响程序的功能。
这意味着子类可以使用基类的所有操作而不出现问题

>>>class T:
...    pass
...class S(T): # inheritance creats subtypes
...    pass
>>>t = T()
>>>s = S()	
>>>isinstance(t, T)	
True	
>>>isinstance(s, S)	
True
>>>isinstance(s, T)	
True

3. 方法 (Methods)

函数 (Function): 也就是普通的 Python 函数。
绑定方法 (Bound Method): 将函数与特定对象（实例）“绑定”在一起。调用时，Python 会自动将该对象作为第一个参数 (self) 传入。
Account.deposit 是函数 (Function)。
tom.deposit 是方法 (Method)。

主题 2：继承与组合 (Inheritance & Composition)

主题概述

继承允许我们基于已有的类创建新类，实现代码复用和特化。组合则是通过将其他对象作为属性来实现复杂功能。

核心概念 (Core Concepts)

1. 继承 (Inheritance)

子类 (Subclass) 继承 基类 (Base Class) 的所有属性和方法。
重写 (Overriding): 子类可以重新定义与父类同名的方法，从而改变行为。
super(): 用于在子类中调用父类的方法，常用于扩展 __init__ 或复用父类逻辑。
代码示例：

class CheckingAccount(Account): # 继承 Account
    withdraw_fee = 1
    interest = 0.01

    def withdraw(self, amount):
        # 复用父类的 withdraw 方法，加上手续费
        return Account.withdraw(self, amount + self.withdraw_fee)

2. 多重继承 (Multiple Inheritance)

一个类可以继承自多个父类。
拓展：菱形问题 (Diamond Problem): 当多个父类继承自同一个祖先时，Python 使用 C3 线性化算法 确定 方法解析顺序 (MRO)，确保每个类只被访问一次。

3. 继承 vs. 组合 (Inheritance vs. Composition)

这是面向对象设计的核心权衡：

继承 (“Is-a” 关系): CheckingAccount 是一个 Account。用于特化。
组合 (“Has-a” 关系): Bank 有一个 Account 列表。用于通过聚合现有组件来构建复杂对象。

主题 3：多态(Ploymorphism)

分类

特设多态（Ad Hoc Ploymorphism）：同名methon但是不同实现规则
- 操作符重载（operator overloading）: 同样运算符，不同操作方式
  
  e.g. x + y 本质上是 x.__add__(y) 。
  
  x == y 本质上是 x.__eq__(y) 。
- 多态函数（polymorphism）: 函数根据输入类型改变行为
参数多态（parametric polymorphism）: 泛型多态（拓展）

from typing import TypeVar, List
T = TypeVar('T')

def first(lst: List[T]) -> T:
    return lst[0]

包含多态（inclusion polymorphism）: 继承多态，子类代替父类使用

主题 4：特殊方法 (Special Methods)

主题概述

特殊方法（也称魔术方法，以双下划线开头和结尾）允许自定义对象表现得像 Python 的内置类型。这是实现 多态 (Polymorphism) 的关键。

核心概念 (Core Concepts)

1. 字符串表示(repr & str)

区别

方法	英文	目标受众	触发方式	默认行为
`__str__`	String	人类 (Human)	`print()`, `str()`	如果没定义，会调用 `__repr__`。
`__repr__`	Representation	解释器 (Interpreter)	交互式环境, `repr()`	返回对象的规范字符串表示，理想情况下 `eval(repr(obj)) == obj`。

例题：

class Fraction:
    def __init__(self, n, d): self.n, self.d = n, d
    def __repr__(self): return f"Fraction({self.n}, {self.d})"
    def __str__(self): return f"{self.n}/{self.d}"

f = Fraction(1, 2)
print(f)       # 输出: 1/2 (调用 __str__)
f              # 输出: Fraction(1, 2) (调用 __repr__)

[易错]关于引号…

str和repr的区别

函数	目的	面向对象	输出特点	是否显示引号
`str(obj)`	面向用户（友好展示）	用户	可读性强、简洁	❌ 不显示引号
`repr(obj)`	面向开发、调试	程序员	尽可能准确、可复现	✅ 显示引号（字符串时）

示例

s = "hello"
print(str(s))   # hello
print(repr(s))  # 'hello'

repr 的目标是 让结果能用于重新构造对象：

eval(repr(s)) == s  # True

print()和交互式解释器输出的区别

方式	内部调用	引号是否显示
`print(obj)`	`str(obj)`	❌ 不显示引号
在交互式解释器直接输入表达式	显示 `repr(obj)` 的结果	✅ 显示引号（字符串时）

示例：

在 REPL 中：

>>> "hello"
'hello'

>>> print("hello")
hello

自定义类的 __str__ 和 __repr__

如果类同时定义了 __str__ 和 __repr__：

调用者	优先使用的方法
`print(obj)`	`__str__`
解释器直接显示	`__repr__`

eval() 是 Python 内置函数，用来将字符串当作 Python 表达式求值，然后返回表达式的结果。 示例：

class A:
    def __str__(self):
        return "str display"
    def __repr__(self):
        return "repr display"

a = A()
print(a)   # str display
a          # repr display
#没有引号!!

repr函数会将接收到的参数变成一个字符串交给交互式解释器,然后交互式解释器去掉最外一层引号的内容把字符串里的内容显示出来

>>> a = 1
>>> a
1
>>> repr(a)
'1'
>>> repr('1')
"'1'"
>>> eval(repr('1'))
'1'
>>> eval(repr(a))
1
>>> eval(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    eval(a)
    ~~~~^^^
TypeError: eval() arg 1 must be a string, bytes or code object

检验理解!

>>> class A:
...     def __init__(self, x):
...         self.x = x
...     def __repr__(self):
...         return self.x
...     def __str__(self):
...         return self.x * 2
>>> class B:
...     def __init__(self):
...         print('boo!')
...         self.a = []
...     def add_a(self, a):
...         self.a.append(a)
...     def __repr__(self):
...         print(len(self.a))
...         ret = ''
...         for a in self.a:
...              ret += str(a)
...         return ret
>>> A('one')
? one

>>> print(A('one'))
? oneone

>>> repr(A('two'))
? 'two'

>>> b = B()
? boo!

>>> b.add_a(A('a'))
>>> b.add_a(A('b'))
>>> b

(line 1)? 2
(line 2)? aabb

repr() 的用途总结

用途	示例
调试	显示数据结构的真实内容
可复现性	`eval(repr(obj)) == obj`
字符串包含特殊字符时的转义展示	`'hello\n'`

2. 运算符重载 (Operator Overloading)

__add__: 定义 + 操作符的行为。例如 obj1 + obj2 会变成 obj1.__add__(obj2)。
多态 (Polymorphism): 同一个操作符（如 +）可以根据操作数类型的不同（如整数相加 vs. 字符串拼接）表现出不同的行为。

主题 4：递归数据结构 (Linked Lists & Trees)

主题概述

链表和树是基于递归 (Recursion) 定义的数据结构。它们是 CS61A 中处理复杂数据的基石。

核心概念 (Core Concepts)

1. 链表 (Linked Lists)

链表要么是空的，要么由一个元素 (first) 和剩余链表 (rest) 组成。

处理技巧:
递归处理: Base case 通常是 lnk is Link.empty。
迭代处理: while lnk is not Link.empty: ... lnk = lnk.rest。
常用操作: map (映射), filter (过滤) 在链表上的实现。注意链表通常是可变 (Mutable) 的。

#链表结构实现
class Link:
    empty = ()
    def __init__(self, first, rest=empty):
        assert rest is Link.empty or isinstance(rest, Link)
        self.first = first
        self.rest = rest

    def __repr__(self):
        """返回链表的可读字符串（如 <1 2 3>）"""
        def helper(lnk):
            if lnk is Link.empty:
                return []
            first_str = helper(lnk.first) if isinstance(lnk.first, Link) else [str(lnk.first)]
            rest_str = helper(lnk.rest)
            return first_str + rest_str
        elements = helper(self)
        return f"<{' '.join(elements)}>"
#链表操作方式
#求和
def sum_links(lnk):
    if self is Link.empty:
            return 0
        current = self.first.sum_links() if isinstance(self.first, Link) else self.first
        rest_sum = self.rest.sum_links() if isinstance(self.rest, Link) else 0
        return current + rest_sum

#表示
def display_link(link):
    str_num = ''
    while link is not Link.empty:
        if isinstance(link.first, Link):
            elem = display_link(link.first)
        elif isinstance(link.first, int):
            elem = str(link.first)
        str_num += elem
        link = link.rest
    print(f'<{' '.join(str_sum)}>')

#映射
def map(f, lnk):
    if lnk is Link.empty:
        return Link.empty
    
    return Link(f(lnk.first), map(f, lnk.rest))

2. 树 (Trees)

树由一个根标签 (Root Label) 和一组分支 (Branches) 组成。每个分支本身也是一棵树。

Tree 类定义：

class Tree:
    def __init__(self, label, branches=[]):
        self.label = label
        # 确保每个分支都是 Tree 的实例，并复制列表以防副作用
        for b in branches:
            assert isinstance(b, Tree)
        self.branches = list(branches)

    def is_leaf(self):
        return not self.branches

核心术语:
Node (节点): 树中的任何位置。
Leaf (叶子): 没有分支的节点 (branches 为空)。
递归处理模式:
处理当前节点的 label。
使用 for b in t.branches: 循环递归处理每个分支。

30min用Hugo创建个人博客网站

Sat, 27 Dec 2025 21:45:10 +0800

本文是一篇从零开始的无比详细的Hugo 建站实战保姆级教程。通过对 Ladder 主题的配置，你将收获一个具备极简美学且功能大满贯的个人站：它不仅支持 Giscus 异步评论、留言板、社交媒体账号跳转、多维标签云与自动归档，还免费集成了一套完全自主掌控的Umami 私有化流量分析看板，并能学会无需服务器将整个静态网站免费部署到github page上的方法。github page配置失败，遭遇 Vercel 风控、Netlify 数据库连接及 IPv6 不兼容等一系列的硬核报错, 尝试Netlify + Supabase，作者建站的过程历经千辛万苦，主要都是在解决各式各样的报错，而现在将踩出来的坑为后人一一铺平。

Hugo 搭建个人博客

情况概述：

大一上完成了基础的网站搭建，其实就是跟着教程一步一步做，再在遇到文中没有提到的问题的时候通过开源社区/阅读配置文件/问ai解决问题，由于当时并没有做出记录，现在很多东西也不记得了（），但是记得似乎是困难重重

看的教程

文后附转载

请先跟着贴出的教程链接或者我在文后的转载完成初步的建站，然后再阅读我的配置教程进行进一步的配置。

在看后面的教程的时候，如果遇到问题，可以在我前面的配置文档里寻找答案，找不到的话可以ATFAI()/去技术社区搜索关键词/去B站搜教程/或者在下方评论区留言

配置

研究怎么配置使用到的tools：配置说明 + gemini(问每个配置有啥用)

修改hugo.toml 文件

（官方文档中使用的是yml，我把它转成了toml）

baseURL = "https://hugo-ladder.pages.dev" #网站发布后的网址
title = "LADDER" #浏览器标签页上显示的网站名称
theme = "hugo-theme-ladder"
license = "MIT"
licenselink = "https://github.com/guangzhengli/hugo-theme-ladder/blob/master/LICENSE"
description = "A fast, clean Hugo theme" #网站的简短描述,SEO（搜索引擎优化）的关键
homepage = "https://hugo-ladder.pages.dev"
defaultContentLanguage = "en"
googleAnalytics = "G-xxx" #Google 统计（GA4）的衡量 ID,有谷歌analyticas账号可以用这个抓取
[pagination]
  pagerSize = 10  #控制首页或列表页每页显示的文章数量，超过 10 篇将自动分页

补充：解决html报错

[markup]
  [markup.goldmark]
    [markup.goldmark.renderer]
      unsafe = true

1. 基础资料与全局样式 (`[params]`)

这一部分控制网站侧边栏或页脚展示的个人名片信息。

[params]
brand = "HOME"                      # 网站左上角的文字 Logo/品牌名称
avatarURL = "/images/avatar.png"    # 头像图片路径（存放在 static/images/ 目录下）
author = "Hugo Ladder"              # 作者姓名
authorDescription = "..."           # 作者简短描述（通常显示在头像下方）
info = "..."                        # 网站或个人的详细介绍信息
favicon = "/images/avatar.png"      # 浏览器标签页的小图标
darkModeTheme = "data-dark-mode"    # 夜间模式的主题属性名称，该主题内有两个，一个是默认的 data-dark-mode 主题，另一个是 icy-dark-mode 深色主题

  [params.options]
  showDarkMode = true               # 是否在页面上显示“昼夜模式”切换按钮
  enableImgZooming = true           # 是否开启文章内图片的点击放大功能
  enableMultiLang = true            # 是否开启多语言支持功能

2. 评论系统配置 (`[params.comments]`)

主题支持多种评论插件，这里主要配置了 Giscus。

Giscus 是将评论存储在 GitHub 仓库的 Discussions 中。

1. 外部准备工作

准备仓库：创建一个公开（Public）的 GitHub 仓库（或者使用你存放博客代码的仓库）。
开启 Discussions：进入该仓库的 Settings -> 勾选 Discussions。
安装 Giscus App：访问 giscus.app，安装并授权它访问你的这个仓库。
获取参数：在 giscus.app 页面向下滚动，输入 所有者/仓库名，页面会自动生成以下关键值：
- repo-id
- category (建议选 Announcements)
- category-id

2. 修改 `hugo.toml` 配置

将获取的值填入hugo.toml的以下对应位置：

[params.comments.giscus]
enable = true                       # 是否启用 Giscus 评论（基于 GitHub Discussions）
repo = "username/repo"              # 存放评论的 GitHub 仓库名
repo_id = "xxx"                     # 仓库的唯一 ID
category = "Announcements"          # 评论存放的讨论区分类
category_id = "xxx"                 # 讨论区分类的 ID
mapping = "pathname"                # 评论与文章的对应关系（按页面路径匹配）
position = "top"                    # 评论输入框相对于评论列表的位置（顶部）
lang = "en"                         # 评论区的界面语言

补充

如果你坚持要用基于 Issues 的 Utterances，配置方式类似：

在 GitHub 仓库中开启 Issues 功能。
在 utteranc.es 获取 repo。
在 hugo.toml 中将 params.comments.giscus.enable 设为 false，将 params.comments.utteranc.enable 设为 true 并填入仓库名。

[params.comments.utteranc]
enable = false                      # 是否启用 Utterances 评论（目前设为关闭）
repo = "username/xxx"               # 存放评论的 GitHub 仓库
issueTerm = "pathname"              # 评论映射方式

原理解释

关于映射方式，对于 Hugo 博客，建议保持 pathname：

它会把每一篇文章的路径（如 /blog/first-post/）作为 ID。这样每篇文章下面都会有自己独立的评论区，互不干扰。

在 “Discussion 分类” 这一栏，下拉选择 Announcements（推荐）。选择后，下方的 <script> 代码会自动更新。将新生成的 data-category-id（一串长字符）复制出来，填到 hugo.toml 的 category_id 中。

建议选这个是因为在 GitHub 上，只有仓库管理员能在这个分类发主帖。这样可以防止乱发无关的讨论，保证只有通过你的博客页面才能创建新的评论区。
repo_id 和 category_id：是 GitHub 内部的唯一标识符。即使你以后改了仓库名字，只要 ID 对，评论就不会丢。

3. 数据统计与分析 (`[params.analytics]`)

见ummami免费使用

[params.analytics.google]
SiteVerificationTag = "xxx"         # Google 搜索控制台（Search Console）的验证代码

[params.analytics.umami]
enable = true                       # 是否启用 Umami 网站统计分析
website_id = "xxx"                  # Umami 提供的网站唯一识别 ID
url = "https://xxx"                 # 部署好的 Umami 服务地址

获取 Umami 访问地址

等待大约 1-2 分钟，直到 Umami 的状态变为“运行中”。
点击进入 Umami 服务页面。
在 “域名” (Domain) 栏目下，点击 “生成域名” (Generate Domain)。
你可以输入一个你喜欢的二级域名。
访问该域名，使用默认账号密码登录：
- 用户名：admin
- 密码：umami
- 登录后记得第一时间在设置里修改密码！

接入你的 Hugo 博客

这步和你之前看的教程一致：

在 Umami 后台点击 “添加网站” (Add Website)。
输入你的博客名称和域名，获取 data-website-id。

回到你的 Hugo 项目，打开 hugo.toml，填入信息：

[params.analytics.umami]
  enable = true
  website_id = "你在 Zeabur 获取的 ID"
  url = "https://你在 Zeabur 生成的域名.zeabur.app"

由于我的手机号通不过vercel,最终的部署我选择了netlify,步骤供参考

1. 创建数据库

见后

Umami 自身不存储数据，它需要一个 PostgreSQL 数据库。

访问 Supabase 官网，使用 GitHub 登录。
点击 New Project，填入项目名称和数据库密码（务必记下密码）。
等待几分钟数据库创建完成。
进入左侧菜单的 Project Settings -> Database。
找到 Connection string，选择 URI 模式。
复制那串以 postgres:// 开头的地址。
- 注意：将其中的 [YOUR-PASSWORD] 替换为你刚才设置的真实密码。
- 注意：如果你的密码里含有特殊的标点符号（比如 !、@、: 等），直接放在 URL 里会破坏格式，导致 Netlify 部署时报错“Invalid URL”。

2. 在 Netlify 部署 Umami

Fork 项目：在 GitHub 上访问 umami-software/umami，点击右上角的 Fork，将其克隆到你的账号下。
登录 Netlify：访问 Netlify，使用 GitHub 登录。
新建站点：点击 Add new site -> Import an existing project。
连接 GitHub：选择 GitHub，找到并选中你刚才 Fork 的 umami 仓库。
配置构建参数（非常重要）：
- Build command: yarn build
- Publish directory: .next。
配置环境变量 (Environment variables)：点击 Add variable，依次添加以下四项：
- DATABASE_URL: 填入你在第一阶段获取并修改好的 Supabase 连接字符串。
- APP_SECRET: 随便输入一串长随机字符串（用于加密，例如 yunsanwu789_secret_key）。
- DATABASE_TYPE: 填入 postgresql。
- SKIP_DB_CHECK：填入 true // 绕过检查，IPv4和IPv6协会不兼容
开始部署：点击 Deploy site。 // 中间遇到了很多困难，比如我建站之后想登录老是报Unexpected end of JSON input，最后放弃了（）

3.初始化 Umami

部署完成后，Netlify 会给你一个 xxx.netlify.app 的域名。点击访问。
默认登录信息：
- 用户名: admin
- 密码: umami
修改密码：登录后第一时间点击右上角头像 -> Settings -> Profile 修改密码。
添加网站：在 Settings -> Websites 中点击 Add website，填入你的 Hugo 博客信息。
获取代码：点击该网站条目旁的 Edit -> Tracking code，复制那一串 <script> 代码。

4.回到 Hugo 配置

打开你的 hugo.toml，将获取到的信息填入：

[params.analytics.umami]
  enable = true
  website_id = "从 Umami 拿到的 UUID"
  url = "https://你的名字.netlify.app" # 填入你的 Netlify 访问地址

4. 留言板与社交链接配置

在 Ladder 主题中，留言板实际上是一个开启了评论功能的特殊页面。

1. 创建留言板页面

在你的博客根目录下运行：

hugo new guestbook/_index.md

2，编辑页面内容

打开 content/guestbook/_index.md，确保其 Front Matter（开头）如下：

---
title: "留言板"
layout: "guestbook"
---

注意：layout: "guestbook" 会告诉主题这个页面不需要显示文章正文，而是直接加载评论插件。

3. 关联菜单与配置

确保你的 hugo.toml 中有以下设置，以便用户能找到它：

[params.guestbook]
title = "留言板"
description = "欢迎在这里留下你的足迹。"

[[languages.en.menu.main]] # 或者 [[menu.main]]
name = "留言板"
url = "/guestbook"
weight = 4

社交媒体配置


  [[params.social]]                 # 社交媒体配置（GitHub）
  name = "GitHub"                   # 链接名称
  pre = '<svg ...>...</svg>'        # 显示在名称前的图标代码（SVG 格式）
  url = "https://github.com/..."    # 社交账号的跳转链接

  [[params.social]]                 # 其他链接（如数据仪表盘）
  name = "Dashboard"
  pre = '<svg ...>...</svg>'
  url = "https://xxx"               # 对应页面的跳转链接

图标可以在 feathericons.com 这个网站上找到

5. 语言与导航菜单 (`[languages.en]`)

如果开启了多语言，菜单需要在对应的语言块下进行配置。

[languages.en]
languageName = "EN"                  # 该语言在切换菜单中显示的名称

[[languages.en.menu.main]]           # 顶部导航栏：文章/博客
name = "Blog"                        # 菜单显示的文字
url = "/blog"                       # 点击后跳转的路径（对应 content/blog 目录）
weight = 1                          # 排序权重，数字越小越靠前（左）

[[languages.en.menu.main]]           # 顶部导航栏：标签
name = "Tags"
url = "/tags"                       # 跳转到标签聚合页
weight = 2

[[languages.en.menu.main]]           # 顶部导航栏：归档
name = "Archive"
url = "/archives"                   # 跳转到文章归档页
weight = 3

[[languages.en.menu.main]]           # 顶部导航栏：留言板
name = "Guestbook"
url = "/guestbook"                  # 跳转到留言页面
weight = 4

6. 分类法配置 (`[taxonomies]`)

定义 Hugo 如何对你的文章内容进行逻辑归类。

[taxonomies]
series = "series"                   # 开启“系列文章”分类功能
tag = "tags"                         # 开启“标签”分类功能

其他：导航栏

目前该博客支持 4 个默认页面、博客列表、标签、历史记录和留言簿。可以通过修改 menu.main 来调整 name ；如果想在导航栏中添加新页面，请记住在根目录的 content 下添加相应的 markdown 文件。

其他：写帖子

如果要创建新帖子，建议填写配置信息，具体如下：

命令如下：

hugo new blog/<name>.md

title: 
date: {{ .Date }}
tags: []
series: [] # 文章将在内容下方显示相关帖子
featured: true # 是否在首页精选文章中

补充：series填写文章名即可，用双引号包含，不同文章用逗号分隔,tags同理 date格式如2025-03-31T20:00:00+08:00

其他：SEO

前提是使用了geogle analytica来分析网站，配置这个可以使你的网站在geogle可以被搜索到。该主题已针对搜索引擎优化 SEO 进行了优化，包括完善的 meta 标签信息等。此外，默认支持 Google Search Console ，可以根据文档生成 google-site-verification 到 params. analytics.google.SiteVerificationTag 。

使用Github Page免费部署站点

在这一步配置的时候我遇到了很多问题，在技术论坛和教程，ai间反复辗转之后，最后摸索出了自己的方式

我会先贴出官方配置的教程，看不懂的也可以去搜b站的教学，然后在后面给出我自己的解决方案hhh，事实证明前者在我这里可以跑不通但是后者可以（感觉到自己解决问题的能力有所提升！）

在gitbub创建以<username>.github.io为名称的仓库

在本地成功建站（终端运行hugo server）

使用 GitHub Pages 部署博客有两种方法，一种是直接推送到 GitHub Pages ，另一种是在 gh-pages 分支上生成静态页面代码。代码可在 https://github.com/guangzhengli/hugo-ladder-exampleSite/tree/master/.github/workflows 获取。

如果您没有克隆已配置的仓库： https://github.com/guangzhengli/hugo-ladder-exampleSite ，则需要创建一个新的文件夹 .github/workflows 并添加新的文件 gh-pages.yml 。

name: generate github pages to gh-pages branch

on:
  push:
    branches:
      - main ## Set a branch name to trigger deployment

jobs:
  deploy:
    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v2
        with:
          submodules: true  # Fetch Hugo themes (true OR recursive)
          fetch-depth: 0    # Fetch all history for .GitInfo and .Lastmod

      - name: Setup Hugo
        uses: peaceiris/actions-hugo@v2
        with:
          hugo-version: 'latest'
          extended: true

      - name: Build
        run: hugo --minify

      - name: Deploy
        uses: peaceiris/actions-gh-pages@v3
        # If you're changing the branch from main, 
        # also change the `main` in `refs/heads/main` 
        # below accordingly.
        if: github.ref == 'refs/heads/main'
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./public

在项目根目录下输入以下命令。

git remote add origin https://github.com/username/username.github.io.git

git add .

git commit -m "feat: init blog site"

git push origin main

一旦我们确认推送成功，它会自动将代码构建到 GitHub Pages in Actions 所需的文件中，因此您可以访问此地址检查 workflow 是否成功运行。请务必将地址中的 username 替换为您的帐户名。 https://github.com/username/username.github.io/actions

如果 Actions 工作流成功，我们将创建一个名为 gh-pages 新分支。然后，前往仓库的设置中心，选择 Settings ”，然后选择 Pages ，再选择 Build and deployment -> Source ，并选择 Deploy from a branch 。之后，选择 gh-pages Branch 即可完成配置。

我当时应该是怎么试怎么问ai都找不到gh-pages分支hhh(好像是因为我的action实际没有构建成功)，当时还懂的比较少，问ai问了很久，最后还是没能解决这个问题

所以最后，我研究出来并采用了另一种方式 3. 将public文件夹中的内容上传到这个仓库

4. 关注github上的actions，问ai解决里面的报错 由于当时没有记录，我现在已经不记得自己当时做了什么了，大家可以自行解决（）

5. actions显示成功后，可以输入地址并浏览自己的网页啦！！

至此，大获成功！！

部署过程中有什么疑问可以在评论区留言

初步建站教程

回到文初

以下为引用和转载的教程，未作修改

hugo 介绍

Hugo 是一个快速且灵活的静态网站生成器，使用 Go 语言编写，代码仓库。

极快的构建速度：Hugo 是同类产品中最快的工具，平均每个页面构建时间小于1毫秒，即使是大型网站也能在几秒钟内完成构建。
强大的模板系统：内置预制模板，可快速完成SEO、评论、统计等功能，一行配置即可实现。同时，其基于Go的模板提供了足够的逻辑支持，能够构建从简单到复杂的各种网站。
多语言支持：原生支持多语言，为多语言站点提供了完整的i18n支持，与单语言站点具有相同的开发体验。
丰富的主题库：拥有300多个主题，涵盖多种风格和功能，用户可以根据自己的需求选择合适的主题，快速搭建出美观且功能强大的网站。

安装

参考文档

查看版本/验证安装成功：

hugo version

安装 Git：

由于后续下载 hugo 主题，以及部署的过程，均需使用到 Git，这里要求必须完成相关环境的安装。

git version

Ladder 主题

hugo-ladder 是一个简约的 hugo 主题，也是这个博客使用的主题，由 Ladder 这个 Git 仓库的作者维护，如果后续你有任何有趣的想法，可以为仓库贡献代码。

# 这个命令用于创建一个新的Hugo站点
hugo new site my-site
cd my-site
git init
# 这个命令用于将Hugo主题作为一个Git子模块添加到当前的Git仓库中，并克隆代码
git submodule add https://github.com/guangzhengli/hugo-theme-ladder themes/hugo-theme-ladder
echo "theme = 'hugo-theme-ladder'" >> hugo.toml
# 本地启动 hugo 服务
hugo server

接着会在默认的 1313 端口启动 hugo 的站点（我本地的1313被占用了，则随机分配了另一端口），当前站点内没有任何的内容。

自定义配置

首先我们来熟悉一下 hugo 的文件目录，也就是通过命令创建的 my-site 这个文件夹。

.
|-- archetypes
|-- assets
|-- content # 内容，后续博客文章将放置在这里
|-- data
|-- hugo.toml # 配置文件，菜单、评论、网站统计等所有功能，均可以通过直接配置进行开启
|-- i18n # 多语言
|-- layouts
|-- public
|-- resources
|-- static # 静态文件，如头像图片等
|-- themes # 所有主题以子文件夹的形式存放

文章

首先我们找到根目录下 archetypes 文件夹中的 default.md 文件，用下面的文件替代其中内容，这是用于控制创建新博客时的模板。

---title: 博客标题date: {{ .Date }}tags: []series: []featured: true---这是摘要 <!--more--> 这是内容

在根目录下通过如下命令，创建一篇博客：

hugo new blog/first.md

则会自动生成 content/blog/first.md 这篇博客。

菜单

接下来继续配置根目录下的 hugo.toml，创建几个菜单管理不同类目的博客。事实上，hugo 支持 toml 和 yaml 格式的配置文件，如果你并不习惯使用 toml，可以删除根目录的 hugo.toml，并创建 hugo.yml 进行相同配置的录入，也是可以生效的。

baseURL = 'https://example.org/'
languageCode = 'en-us'
title = 'My New Hugo Site'
theme = 'hugo-theme-ladder'

[[menu.main]]
  name = "文章"
  url = "/blog/"
  weight = 1

[[menu.main]]
  name = "归档"
  url = "/archive/"
  weight = 2

[[menu.main]]
  name = "联系"
  url = "/contact/"
  weight = 3

[[menu.main]]
  name = "网站统计"
  url = "/xx/"
  weight = 4

这时候，你会发现，当点击文章的时候，可以看到博客列表，但是点击其他目录看不到，因为 content/blog 是第一篇文章的存放路径，所以文章菜单可以看到，所以后续文章的管理，只需要在创建的时候，指定对应生成的目录即可。

这时候，你看到 localhost:1313/ 目录下也能看到这篇博客，Featured Posts 表示的是主页的推荐文章，所有标志了 featured: true 的文章都可以在这里展示，而 featured: false 的文章，则只会在对应目录展示。

所以尝试将 /content/blog/first.md 这篇文章的 featured 设置为 false，你将无法在首页看到它了，但 localhost:1313/blog 依旧可以看到。

---title: 博客标题date: 2025-01-12T20:44:21+08:00tags: []series: []featured: false---这是摘要 <!--more--> 这是内容

Umami 网站数据统计

这是一个有趣的内容，当你完成接入之后，将获得如下的访客信息统计看板。

包括区域和设备分布：

工作原理

Umami 是一个简单、快速且开源的分析工具，用于跟踪网站的访问数据。它的工作原理主要包括以下几个步骤：

数据收集：

当用户访问你的网站时，Umami 通过在网页中嵌入的JavaScript代码来收集数据。这些数据包括页面浏览量、访问时长、用户地理位置、设备信息等。
每次页面加载时，嵌入的JavaScript代码会发送一个请求到Umami服务器，携带收集到的数据。

数据存储：

Umami 服务器接收到数据后，会将其存储在数据库中。Umami 使用PostgreSQL作为其默认数据库，但也可以配置为使用其他数据库。
数据存储在数据库中，以便后续进行查询和分析。

数据处理：

Umami 服务器会对收集到的数据进行处理，生成各种统计信息，如页面浏览量、独立访客数、访问时长等。
这些统计信息会定期更新，以反映最新的访问数据。

数据展示：

Umami 提供一个管理界面，用户可以通过这个界面查看和分析网站的访问数据。
管理界面展示了各种图表和报告，帮助用户了解网站的访问情况。

Umami 免费部署

创建数据库

数据库用的是 supabase 提供的有限额的 postgres 数据库，创建一个 supabase 账号，新建一个项目，输入 Datebase password 即可创建数据库服务。

进入 database 菜单，点击 Connect。

记录下这里通过 Session pooler 接入数据库的方式（DATABASE_URL），下文 Umami 接入 DB 时注意替换密码为你创建的密码。

部署 umami

首先 umami 是开源的，访问它的 GitHub 仓库，将其 fork 为自己的 repo。

vercel 是一个现代的云平台，专注于前端开发和无服务器函数（Serverless Functions），提供快速部署、自动缩放和全球 CDN 支持。它特别适合部署静态网站、单页应用（SPA）、以及需要无服务器后端的项目。

vercel 提供了免费计划，虽然有一些限制（具体限额大家可以自行参考官网信息），目前支撑我们的网站分析功能是够用的。

编辑构建命令：

yarn build && yarn update-db

添加环境变量：

DATABASE_URL: 上一步从 supabase 获取
TRACKER_SCRIPT_NAME: baize

点击部署并等待：

在 vercel 部署完成 umami 后会得到一个 <deploy-id>.vercel.app ，默认登陆的账号密码是 admin 和 umami。

完成基础帐号配置后，点击侧边栏网站 Tab，点击添加网站。填写网站基本信息，可以勾选 enable share URL，这样任何人都可以访问这个数据看板。

Umami 接入 Hugo

在 Tracking code 中，我们拿到对应的 data-website-id 和 src 。

<script defer src="https://umami-jlwf.vercel.app/hugo-ladder" data-website-id="ec55b2da-4f55-45ef-8aed-26e57078fd15"></script>

将其填入主题配置中的 params.analytics.umami.website_id 和 params.analytics.umami.url 即可。

[params.analytics.umami]
  enable = true
  website_id = "ec55b2da-4f55-45ef-8aed-26e57078fd15"
  url = "https://umami-jlwf.vercel.app/hugo-ladder"

不要忘记将你的网站统计查看地址配置给菜单：

[[menu.main]]
  name = "网站统计"
  url = "https://umami-jlwf.vercel.app/share/ZKhEVgh56RlSfAMa/baize1998.github.io"
  weight = 4

至此你的站点在被访问的时候，会向部署的 vercel 的 umami 上报数据，任何人都可以跳转看到统计数据。

以上我们完成了本地博客的搭建以及网站数据统计能力的接入

SICP_python_期中前笔记

Thu, 11 Dec 2025 17:02:23 +0800

摘要

本文为《计算机程序的构造和解释》（SICP，CS61A 南大引进版）python部分期中前课程核心笔记，聚焦程序设计的底层逻辑与核心思想，旨在帮助学习者搭建“知其然更知其所以然”的编程认知框架。适合正在学习 CS61A 课程的学习者梳理知识体系，也可作为编程入门者夯实基础、理解程序设计本质的参考资料。

SICP_python_期中前笔记

易错提醒

记得初始化参数！
记得每个函数接受多少个输入！
记得return！
lambda函数要在被()调用的时候才会执行！
被next拿出来的会在可变序列中消失！pop也是！可变序列在一处被修改后，所有对它的引用都会随之改变！！！

易忘函数

all(iterable)

功能：如果 iterable 中所有元素为 True，返回 True，否则返回 False。
注意：会短路，即遇到第一个 False 时立即返回 False。

any(iterable)

功能：如果 iterable 中至少有一个元素为 True，返回 True，否则返回 False。
注意：会短路，即遇到第一个 True 时立即返回 True。

enumerate(iterable, start=0)

功能：返回一个枚举对象，包含可迭代对象的索引和值。
注意：start 参数指定索引的起始值。

filter(function, iterable)

功能：根据 function 函数过滤 iterable 中的元素，只有 function 返回 True 的元素会被保留。
注意：返回一个迭代器，需要转换为列表等容器查看结果。

pow(x, y, z=None)

功能：返回 x 的 y 次幂。如果提供了 z，则返回 (x ** y) % z。
注意：该函数在处理大数时效率较高。

zip(*iterables)

功能：将多个可迭代对象按元素配对，返回一个包含元组的迭代器。
注意：如果输入可迭代对象长度不一致，按最短长度配对。需要转换为列表等容器查看结果。

错题：

#1
f1 = print(2 + 3)
f2 = lambda: print(2 + 3)
print(f1, f2, f2())
>>>5, 5, None, Function, None

#2
print("hello") and print("world")
>>>hello
"""and只对左边求值，右边被短路，返回左边的值为None，而REPL遇到None不输出内容"""

#3 神秘斐波那契数列
def mystery():
    yield 1
    yield 1
    iter1 = mystery()
    iter2 = mystery()
    next(iter2)
    yield from map(lambda pair: pair[0] + pair[1], zip(iter1, iter2))

series1 = mystery()
series2 = filter(lambda n: n % 2 != 0, series1)
>>>[next(series1) for _ in range(2)]
>>>[next(series1) for _ in range(2)]
>>>[next(series2) for _ in range(2)]
>>>next(series1)

>>>[1, 1]
>>>[2, 3]
>>>[5, 13]
>>>21

#4




"""抽象的猜出一个函数的作用！
    存在递归调用的生成器一般是无限的！
    注意赋值语句在赋值的时候是不求值的！被使用的时候才会求值"""

Functions & Control

Expression & Value

An expression describes a computation and evaluates to a value

include : function call notation, operators and operands
order : evaluate operater subexpression > operand ~ > apply
types : primitive(numbers, strings, names), arithmetic, call

Programs manipulate values

types: 4
Expressions evaluate to values in one or more steps

Name & Assignment

Values can be assigned to names to make referring to them easier.

A name can only be bound to a single value.
One way to introduce a new name in a program is with an assignment statement.
Statements affect the program, but do not evaluate to values.

Function Definition

function : abstraction

Execution rule for def Statements

Create a function with signature ()
Set the body of that function to be everything indented after the first line
Bind to that function in the current frame

Function Call (Eval & Apply)

Procedure for calling/applying user-defined functions (for now)

Create a new environment frame
Bind the function’s parameters to its arguments in that frame
Execute the body of the function in the new environment

Pure / Non-Pure Functions (Print vs Return, None)

The special value None represents nothing in Python
A function that does not explicitly return a value will return None
Careful: None is not displayed by the interpreter as the value of an expression

Pure Functions just return values

Non-Pure Functions have side effects

Conditional Control (If-Statement)

Execution Rule for Conditional Statements:

Each header is considered in order

Evaluate the header’s conditional expression if the header is not an else
If the expression evaluates to true or the header is an else, execute the suite and skip the remaining headers

要特别注意!有的语句前不该用elif/ else, 会导致被短路，只是检查条件的话，可以只用一个if就好了

Boolean Expressions & Short Circuiting

boolean contexts: False values in Python: False, None, 0, ‘’ (more to come)
True values: everything else
special operators and and and … Evaluate to the first false value. If none are false, evaluates to the last expression or or or … Evaluate to first true value. If none are true, evaluates to the last expression not Evaluates to True if if a false value and False if is a true value

返回的是操作数的值！不是True or False！

notice: Short-Circuiting —— avoid side-effect and error

Iterative Control (While-Statement)

Execution Rule for While Statements:

Evaluate the header’s expression
If it is a true value, execute the (whole) suite, then return to step 1

"""斐波那契数列"""
def fib(n):
    """Compute the nth Fibonacci number, for N >= 1"""
    pred, curr = 0, 1  # 0th and 1st Fibonacci numbers
    k = 1              # curr is the kth Fibonacci number
    while k < n:
        pred, curr = curr, pred + curr
        k += 1
    return curr

Error Messages

见后

Environment Diagrams

A visual tool to keep track of bindings & state of a computer program

A frame keeps track of variable-to-value bindings.
Every call expression has a corresponding frame.
Global, a.k.a(又名). the global frame, is the starting frame. It doesn’t correspond to a specific call expression.
Parent frames The parent of a function is the frame in which it was defined. If you can’t find a variable in the current frame, you check it’s parent, and so on. If you can’t find the variable, NameError

Assignment Statements

bind variable to value

Def Statements

Create a function value: in current frame

func <name>(<formal parameters>) [parent=<label>] #Its parent is the current frame.

Bind <name> to the function value in the current frame

Call Expressions

Add a local frame, titled with the of the function being applied.
Copy the parent of the function (not always the current frame) to the local frame: [parent=]
Bind the to the arguments in the local frame.
Execute the body of the function in the environment that starts with the local frame

Variable Lookup

Variable Lookup:

Lookup name in the current frame
Lookup name in parent frame, its parent frame, etc..
Stop at the global frame
If not found, an error is thrown

注意：函数的parent frame 取决于def的环境，而不是调用的环境
只能寻找并使用，若要修改则需要用nonlocal or global 声明

区别函数传参：若使用而未改变传入参数，则若外部参数发生变化，内部参数也会随之发生变化；若改变了该参数，相当于在内部框架对参数进行重新赋值，不会改变外部参数的值，称为闭包，并且此后外部参数再发生变化不会影响内部参数

求值（Evaluation）：是对表达式的求解和计算过程。应用（Apply）：是指函数调用，即将一个函数和它的参数结合在一起并执行。当你调用一个函数时，首先会求值参数，接着应用函数。

Lambda Expressions

evaluate to functions !

Only the def statement gives the function an intrinsic name

notice: lambda for loop

如果你在循环中使用 lambda 函数时，要注意变量绑定的问题。通常，这种情况会导致 lambda 函数在创建时捕获的变量值是循环结束后的最终值。

示例：
fs = [lambda: i for i in range(5)]
print([f() for f in fs])  # [4, 4, 4, 4, 4]

原因：

lambda 捕获的是外部的 i 变量，而不是 i 在每次迭代中的值。所以，在迭代完成后，i 的值是 4，因此所有的 lambda 函数最终都返回 4。

解决方案：
fs = [(lambda i: lambda: i)(i) for i in range(5)]
print([f() for f in fs])  # [0, 1, 2, 3, 4]

通过为每个 lambda 函数创建一个局部作用域，确保每个 lambda 捕获当前 i 的值。

Recursion

The same function fact is called multiple times, each time solving a simpler problem
All the frames share the same parent - only difference is the argument
What n evaluates to depends upon the current environment（在每个frame中修改n的时候实现重新赋值，而不会因为其他frame而改变当前frame的n的值）
执行顺序是从最末情况到base case开始创建frame，返回值是从base case得到的值回到最末层

Lists

Box and Poinger Notation

Lists in Lists in Lists

point to another list

Default Arguments

Higher order functions

takes a function as an argument value, and/or returns a function as a return value(often defined locally)

use: Abstraction and Generalization! Give each function exactly one job, but make it apply to many related situations(分步进行的计算)
1. Generalize over different form of computation
2. Helps remove repetitive segments of code

Lambda Expressions vs. Def Statements

见这里

Function Design & Generalization

函数泛化，提高可读性、可维护性和扩展性，在不同情景保持复用性

Functions As Arguments

eg. 常见的高阶函数：

map()：对一个可迭代对象的每个元素应用一个函数。

filter()：根据给定的条件过滤一个可迭代对象。

reduce()：累积地应用一个二元函数到一个可迭代对象上。

Functions That Return Functions

常常用于构建闭包（closures），在其中返回的函数使用外部函数的环境变量来执行任务。

Function Currying

函数柯里化（Currying）是将接受多个参数的函数转化为一系列接受单一参数的函数的技术。换句话说，柯里化的过程是将一个多参数的函数分解成多个单参数的函数序列。

函数柯里化使得你可以部分应用函数参数，即先提供部分参数，得到一个新的函数，等待剩余的参数。

部分应用：通过柯里化，你可以将一个多参数的函数转化为一系列单一参数的函数，这有助于代码的简化和模块化。
函数链：柯里化可以链式调用，允许更流畅的表达式。

Self Reference

自我引用是指一个对象、函数或变量引用自己。在函数编程中，自我引用通常用于递归函数的实现，它允许函数在其内部调用自己来解决问题。

自我引用常常出现在递归中，其中函数调用自身来逐步解决子问题，直到达到一个基本情况。

Recursion

means: solving problems with a naturally repeating structure - they are defined in terms of themselves
It requires you to find patterns of smaller problems, and to define the smallest problem possible

Function Abstraction

核心：隐藏复杂性，提供简洁的接口

Definition of Recursion

递归是一种通过函数调用自身来解决问题的方法。递归的核心在于问题能被分解成更简单的子问题，且每次递归都会接近基础情况（base case）。

基础情况：递归停止的条件，通常是最简单的情况，比如 n == 0 或 n == 1。
递归情况：问题通过递归调用被分解成更小的子问题，最终汇总得到答案。

Structure of a Recursive Function

Divide - Conquer - Combine 递归函数通常遵循以下结构：

分解（Divide）：将问题分解成一个或多个子问题。(多种情况or多个步骤)

解决（Conquer）：解决更小的子问题，通常是递归地调用函数。

合并（Combine）：将子问题的解合并，得到问题的最终解。

递归结构的关键是将一个复杂的问题通过逐步减小问题的规模，最终解决最小的子问题。

知道上个子问题的答案，可以怎样解决下一个问题？
base case是什么？

Tree Recursion & Recursion Tree

树状递归是指递归函数的调用图呈树状结构。每次递归调用都会产生多个子调用，类似树的分支。递归树的深度取决于递归的层数，广度取决于每一层的调用数

Mutual Recursion

互相递归是指两个或更多的函数互相调用对方来完成任务。这种递归结构通常在两个函数的行为依赖于彼此时出现。

def is_odd(n):
    if n == 0:
        return False
    else:
        return is_even(n - 1)

def is_even(n):
    if n == 0:
        return True
    else:
        return is_odd(n - 1)

Iteration vs. Recursion

递归可以更清晰地表示分解问题的过程，尤其是当问题的结构天然适合分解时。

迭代通常更高效，因为每次递归调用都要维护栈帧，而迭代只需要更新变量。

Recursion Examples:

When learning to write recursive functions, put the base case/s first

注意考虑边界情况! eg.Count Partitions Goal: Count the number of ways to give out n ( > 0) pieces of chocolate if nobody can have more than m (> 0) pieces.

If n is negative, then we cannot get to a valid partition
If n is 0, then we have arrived at a valid partition
If the largest piece we can use is 0, then we cannot get to a valid partition

Sum-Digits

def sum_digits(n):
    if n == 0:
        return 0
    else:
        return n % 10 + sum_digits(n // 10)

Cascade(级联)

级联递归指的是将多个函数或操作按顺序组合，每个函数的输出作为下一个函数的输入

#从高位开始输出每位数字
def cascade(n):
    if n < 10:
        print(n)
    else:
        cascade(n // 10)
        print(n % 10)
"""在递归函数中，通常会在每一次递归调用时暂停当前函数的执行，直到递归结束并返回"""

#从低位开始输出每位数字
def cascade(n):
    if n < 10:
        print(n)
    else:
        print(n % 10)
        cascade(n // 10)

Fibonacci

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

Count-Partitions

def count_partitions(n):
    if n == 0:
        return 1
    count = 0
    for i in range(1, n + 1):
        count += count_partitions(n - i)
    return count

If Time - Speeding Up Recursion

store some values that had already calculated

SUMMERY

Recursion has three main components

Base case/s: The simplest form of the problem
Recursive call/s: Smaller version of the problem
Use the solution to the smaller version of the problem to arrive at the solution to the original problem

When working with recursion, use functional abstraction: assume the recursive call gives the correct result
Tree recursion makes multiple recursive calls and explores different choices
Use doctests and your own examples to help you figure out the simplest forms and how to make the problem smaller

Sequence

Sequence Abstraction

All sequences have finite length. Each element in a sequence has a discrete integer index.

Sequence Operation (Expression)

#### Get Item
get the ith element <seq>[i]

#### Slicing
##### Slicing Creates New Values
create a copy of the sequence from i to j  <seq>[i:j:skip]

#### Check Membership
check if the value of <expr> is in <seq>  <expr> in <seq>


#### Concatenate
combine two sequences into a single sequence  <s1> + <s2>

Sequence Processing (Statement)

#### Iterating
For each element in <seq>:
   1) Bind it to <name>
   2) Execute <body>

Unpacking

Range

range(<start>, <end>, <skip>)

List

List Comprehensions

[<expr> for <name> in <seq> if <cond>]

String

String Literals (Three Forms)

Python 中有三种常见的字符串字面量表示形式：

单引号： ‘Hello’

双引号： “Hello”

三引号： ‘‘‘Hello’’’ 或 “““Hello””” 三引号用于表示多行字符串，或者在字符串中包含引号时可以避免转义。

Sequence Aggregation (Sum, Max / Min, All / Any)

Dictionary

Data abstraction and Tree

Compound values combine other values together Data abstraction lets us manipulate compound values as units e.g. 有理数由分子（numerator）和分母（denominator）组成，是分数的精确表示形式，以整数对形式存在。常规表达进行除法运算，可能会丢失精确表示。 so:

# 基础构造与选择器
def rational(n, d): return [n, d]  # 构造有理数（列表形式）
def numer(x): return x[0]  # 获取分子
def denom(x): return x[1]  # 获取分母

# 运算实现
def mul_rational(x, y): return rational(numer(x)*numer(y), denom(x)*denom(y))  # 乘法
def add_rational(x, y):
    nx, dx = numer(x), denom(x)
    ny, dy = numer(y), denom(y)
    return rational(nx*dy + ny*dx, dx*dy)  # 加法
def print_rational(x): print(numer(x), '/', denom(x))  # 打印
def rationals_are_equal(x, y): return numer(x)*denom(y) == numer(y)*denom(x)  # 相等判断

# 最简形式优化（引入最大公约数）
from math import gcd
def rational(n, d):
    g = gcd(n, d)
    return [n//g, d//g]  # 返回最简分数形式的有理

Abstraction Barrier (between Representation & Use)

def: 将数据的表示和使用分开的一种设计思想。
通过抽象屏障，可以使得数据的表示方式对外部用户隐藏，从而保护数据的结构，使其不容易受到外部代码的直接修改。把底层的数据结构和功能封装起来，使得使用者可以通过抽象接口来操作数据，而不需要理解内部的实现。
表示：指的是数据的内部结构，如何在计算机中存储这些数据。
使用：指的是外部代码与数据进行交互的方式，用户与数据的交互不关心数据的具体实现，只关心如何操作数据。

Constructor & Selectors

Constructor（构造函数）是用于创建数据对象的函数，它定义了如何通过一些基本组件来构造出复杂的数据结构。
Selectors（选择器）是用于从已构建的数据结构中提取信息的函数。它们允许用户访问数据结构中的元素或属性。
break: 过度依赖数据的内部实现，或者在外部代码中直接修改、访问类和数据结构的私有部分或底层细节

Abstract Data Type

指数据结构和操作的组合 e.g.

列表（List）：一个抽象数据类型，可以进行元素添加、删除、查找等操作，具体实现可以是动态数组、链表等。
栈（Stack）：一种抽象数据类型，具有push()和pop()等操作，可以通过不同的实现方式（例如数组或链表）来实现。

Closure

指函数不仅能够访问其自己的局部变量，还能够访问外部函数的局部变量。闭包使得函数能够“记住”它被创建时的环境，即使外部函数已经返回，内部函数仍然能够访问外部函数的变量。

Tree Abstraction

递归描述（木质树视角）树由一个根（root）和一组分支（branches）组成。每个分支本身也是一棵树。零个分支的树称为叶子（leaf）。
- Label：节点的值
- Branches：子节点或子树，是一个列表，其中每个元素表示一个子节点。
相对描述（家族树视角）树中每个位置称为节点（node）。每个节点有一个标签值（label value）。节点间存在父子关系（parent/child）。常根据节点位置描述值的关系

树包含标签值和分支列表的结构，分支列表可为空（对应叶子）

Tree Implementation

Constructor: tree

def tree(label, branches=[]):
    for branch in branches:
        assert is_tree(branch)
    return [label] + list(branches)

Selectors: label, branches

def label(tree):
    return tree[0]

def branches(tree):
    return tree[1:]

Convinence Functions: is_tree, is_leaf

def is_tree(tree):
    if type(tree) != list or len(tree) < 1:
        return False
    for branch in branches(tree):
        if not is_tree(branch):
            return False
    return True

def is_leaf(tree):
    return not branches(tree)

Tree Processing (using Recursion)

def count_leaves(t):
    """统计树的叶子节点总数"""
    if is_leaf(t):
        return 1  # 叶子节点返回1
    else:
        # 递归计算每个分支的叶子数，求和聚合
        branch_counts = [count_leaves(b) for b in branches(t)]
        return sum(branch_counts)


def increment_leaves(t):
    """返回叶子节点标签递增1的新树"""
    if is_leaf(t):
        return tree(label(t) + 1)  # 叶子节点标签+1
    else:
        # 递归处理每个分支，保留非叶子节点标签
        bs = [increment_leaves(b) for b in branches(t)]
        return tree(label(t), bs)


def increment(t):
    """返回所有节点标签递增1的新树"""
    # 根节点标签+1，递归处理所有分支
    return tree(label(t) + 1, [increment(b) for b in branches(t)])

Mutablility

指对象在创建后是否可以改变其内容或状态，它们影响了对象的行为、存储方式、以及如何处理对象的引用

Objects

对象是程序中所有数据的基本单位。每个对象都有两个主要属性：身份（Identity）和值（Value）。对象的身份由它的内存地址决定，而值则是对象所包含的数据。对象的行为通过其类型（如列表、字典、整数等）决定

Mutable Objects

Lists

append()：向列表末尾添加元素。

pop()：移除并返回列表的最后一个元素，或指定索引的元素。

remove()：移除列表中第一个匹配的指定元素。

extend()：将一个可迭代对象中的元素添加到列表末尾。

Slice Assignment：通过切片语法修改列表中的部分元素。

Dictionaries

由键（key）和值（value）对组成的映射。字典允许通过键来查找对应的值，可以进行修改、删除或添加新的键值对。

Mutate with Functions

由于 Python 中的可变对象是通过引用传递的，修改可变对象会影响原始对象

Immutable Objects

Tuple, str, int, float 可变仅指元组本身的元素绑定不可变，若元组包含可变元素（如列表），该可变元素的内容可被修改。

Identity & Equality

Identity 指的是对象在内存中的位置，通常由 id() 函数来查看。同一性（is运算符）：判断两个表达式是否指向同一个对象。
Equality 则是指对象的内容是否相等。对于可变对象，修改对象的内容不会改变对象的身份；而对于不可变对象，任何修改都需要创建一个新对象。同一对象必然值相等，但值相等的对象不一定是同一对象。相等性（==运算符）：判断两个表达式的值是否相等。

Default Arguments

函数的默认参数值是函数定义的一部分，仅在函数定义时创建一次，而非每次调用时重新生成。若默认参数是可变对象（如列表），多次调用函数会共享该对象，导致意外的状态累积。

def append_to_list(value, lst=[]):  # 注意：默认值是可变的
    lst.append(value)
    return lst

print(append_to_list(1))  # 输出 [1]
print(append_to_list(2))  # 输出 [1, 2]，因为默认的列表是共享的

要避免这种情况，使用不可变的默认参数（例如 None）并在函数体内初始化：

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

print(append_to_list(1))  # 输出 [1]
print(append_to_list(2))  # 输出 [2]，避免了共享同一个列表的问题

Mutable Functions (Nonlocal)

nonlocal 关键字用于修改外层函数作用域中的变量，而不是创建一个局部变量
tip:
1. 如果外层函数的变量是可变的（例如列表、字典等），你可以修改它的内容，而无需使用 nonlocal。但如果你想直接对变量本身（例如赋值为一个新对象）进行修改，就需要使用 nonlocal。
2. 如果外层函数的变量是不可变的（例如整数、字符串、元组等），则即使使用 nonlocal 关键字，你也只能修改它的引用，而不能直接改变它的值（因为不可变对象的值一旦创建就无法修改）。

UnboundLocalError

当你在函数内部引用一个变量，并且该变量在局部作用域中没有声明时，Python 会抛出 UnboundLocalError 错误。这通常发生在试图在函数中修改局部变量时，而没有明确声明该变量为 nonlocal 或 global。

Mutate Mutable Values wihout Nonlocal

如果一个变量是可变的且位于外部作用域，你可以在内部函数中修改它的内容，而不必使用 nonlocal

#嵌套列表
t = [1, 2, 3]
t[1:3] = [t]
t.extend(t)

t = [[1, 2], [3, 4]]
t[0].append(t[1:2])

Iterable

Iterable 是任何能够逐个返回其成员的对象。它包括序列类型（如列表、字符串、元组）以及非序列类型（如字典）。

Iterators (iter & next)

iter(iterable)：此函数返回一个迭代器(iterator)，它可以逐个遍历可迭代对象(iterable)的元素。可以把它理解为一本书的书签，从书的前面开始。
next(iterator)：此函数返回迭代器的下一个元素，并将书签移动到下一页。迭代器会记住它的当前位置。如果当前位置已经是书的结尾，它会抛出一个错误。

Views of a Dictionary (keys & values)

字典及其键(keys)、值(values)和项(items)都是可迭代对象。

d.keys()：返回字典键的可迭代视图。
d.values()：返回字典值的可迭代视图。
d.items()：返回字典键值对的可迭代视图。

Built-in Functions for Iteration

map(func, iterable)：对可迭代对象中的每个元素应用指定的函数。
filter(func, iterable)：过滤可迭代对象中的元素，保留通过函数判断为真的元素。
zip(first_iter, second_iter)：将两个或多个可迭代对象中的元素按顺序组成元组返回。
reversed(sequence)：返回一个反向迭代器，逐个遍历序列中的元素。

Create Iterators

这些函数允许我们创建迭代器：

map：将一个函数应用到每个元素。
filter：根据一个条件函数筛选元素。
zip：将两个可迭代对象的元素按顺序组成元组。
reversed：创建一个反向遍历序列的迭代器。

View Iterators

这些函数将可迭代对象转换为不同的数据结构视图：

list(iterable)：将可迭代对象转换为列表。
tuple(iterable)：将可迭代对象转换为元组。
sorted(iterable)：将可迭代对象排序后返回一个新的列表。

# Example of iterators and map function
def naturals():
    x = 0
    while True:
        yield x
        x += 1

>>> nats = naturals()
>>> next(nats)
0
>>> next(nats)
1
>>> nats1, nats2 = naturals(), naturals()
>>> [next(nats1) * next(nats2) for _ in range(5)]
[0, 1, 4, 9, 16]  # Squares the first 5 natural numbers

Generators and Generator Functions

Generators：生成器是通过调用生成器函数自动创建的迭代器。它使用yield关键字逐个返回值，并保持函数的状态，以便后续调用next()时继续执行。
Generator Functions：生成器函数包含一个或多个yield语句。与普通函数不同，生成器函数在每次yield时返回一个值，而不是一次性返回。

`yield` value

yield关键字用于生成一个值，并挂起函数的执行，之后可以继续执行。

`yield from iterator / iterable`

yield from语法用于将另一个迭代器或可迭代对象的所有值逐个返回。它简化了代码，在需要将值传递给另一个生成器或可迭代对象时非常有用。

Generators Representing Infinite Sequences

生成器可以表示无限序列。例如，上述的naturals()函数生成一个从0开始的无限自然数序列。

Exception

Exception 是程序在运行时遇到的错误，会打断程序的正常执行流程。

中文名	英文名	说明
异常	Exception	程序运行时检测到的错误，会中断当前代码的正常执行流程。
抛出异常	Raise an Exception	使用 `raise` 语句主动触发异常。
捕获异常	Catch / Handle Exception	使用 `try...except` 捕获并处理异常，防止程序崩溃。
异常传播	Exception Propagation	如果当前作用域未捕获异常，异常会沿着调用栈往上层传递，直到被捕获或导致程序终止。
异常对象	Exception Object	每个异常都是一个类的实例，包含错误类型、信息、堆栈信息等。
异常类层级结构	Exception Hierarchy	Python 中所有异常都是从 `BaseException` 类继承而来的一棵树。

Built-in Exceptions

Python提供了多个内建异常，每种异常用于不同类型的错误。

异常名	英文说明	常见触发场景
`SyntaxError`	Syntax error	语法错误（代码结构非法）
`IndentationError`	Indentation error	缩进错误
`NameError`	Undefined variable	使用了未定义的变量
`TypeError`	Type mismatch	类型不兼容（如把字符串加到整数上）
`ValueError`	Invalid value	值类型正确但取值非法（如 `int("abc")`）
`IndexError`	Index out of range	列表索引越界
`KeyError`	Missing dictionary key	字典中查找不存在的键
`AttributeError`	Missing attribute	对象没有该属性或方法
`ZeroDivisionError`	Division by zero	除以零错误
`IOError` / `OSError`	Input/Output error	文件或系统操作失败（如找不到文件）
`FileNotFoundError`	File not found	打开不存在的文件
`ImportError` / `ModuleNotFoundError`	Import error	模块导入失败
`RuntimeError`	Generic runtime error	运行时检测到其他异常情况
`RecursionError`	Maximum recursion depth exceeded	递归层数太深
`AssertionError`	Assertion failed	断言失败（`assert`）
`StopIteration`	Iterator finished	迭代器结束（由迭代协议内部抛出）
`StopAsyncIteration`	Async iterator finished	异步迭代结束

Exception Mechanism

Detection (发现错误): 错误会在程序执行时被发现。
Raising (raise): 可以通过raise关键字显式地抛出错误。
Propagation (异常传播): 如果当前作用域没有捕获异常，异常会沿着调用栈向上传播，直到被捕获或导致程序终止。
Catching (捕获): 错误可以使用try/except块进行捕获。
Else (无异常时执行): 如果try块没有抛出异常，则执行else块。
Finally (始终执行): 无论是否发生异常，finally块总是会执行。

`raise` Syntax

raise <expression>  # <expression> 必须是一个异常对象

Example

def divide(a, b):
    try:
        assert b != 0, "Divider cannot be zero"
        result = a / b
    except AssertionError as e:
        print("Assertion failed:", e)
    except ZeroDivisionError as e:
        print("Caught division error:", e)
    else:
        print("Result is:", result)
    finally:
        print("Computation ended.")

divide(10, 0)

Output:

Assertion failed: Divider cannot be zero
Computation ended.