背景 & 原理

在使用命令行的过程中，我们经常遇到一个需求，那就是让程序在退出当前终端后保持运行。在以往，我们可能会使用 nohup 加让程序后台运行的方式，比如：

➜  ~ nohup ping 127.0.0.1 &
[1] 89083
nohup: ignoring input and appending output to 'nohup.out'
➜  ~ ps -elf |grep ping
0 S yfy        89083   88672  0  85   5 -  3352 -      11:39 pts/0    00:00:00 ping 127.0.0.1

这样在断开终端连接后，重新登陆到服务器，可以发现 ping 进程仍然在运行。nohup 默认将程序输出追加到 nohup.out 文件中，可以通过 tail 检验这一点。

➜  ~ tail -f nohup.out
64 bytes from 127.0.0.1: icmp_seq=7 ttl=64 time=0.024 ms
64 bytes from 127.0.0.1: icmp_seq=8 ttl=64 time=0.027 ms
64 bytes from 127.0.0.1: icmp_seq=9 ttl=64 time=0.023 ms
64 bytes from 127.0.0.1: icmp_seq=10 ttl=64 time=0.035 ms
➜  ~ ps -elf |head -n1
F S UID          PID    PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
➜  ~ ps -elf |grep ping
0 S yfy        89083       1  0  85   5 -  3352 -      11:39 ?        00:00:00 ping 127.0.0.1

正常情况下，当终端退出时（如关闭终端窗口，或者 ssh 网络中断），shell 进程会给所有子进程发送一个 SIGHUP 信号，从而导致进程结束。而 nohup 可以让进程忽略掉 SIGHUP 信号，从而在后台保持运行。

Tip: ps 输出还可以观察到 ping 进程父进程变为了 1，这是因为原本的父进程 shell 已经退出，Linux 内核会将孤儿进程交由 init/systemd 进程托管。

nohup 在简单场景比较有用，但是不适用更复杂的场景。比如用户无法再对后台进程进行输入操作，并且同时维护多个进程也很不方便。不过我们其实还有更优雅、更强大的方案，那就是 tmux。

tmux 是一个终端复用器（Terminal MUltipleXer）。简单来说，tmux 的功能可以概括成一句话：在一个终端里创建多个窗口，并且将窗口分割成多个窗格，每个窗格都运行独立的 shell 进程。这样你就可以让多个应用程序同时运行，而无需打开多个终端模拟器窗口（terminal emulator，如 Xshell、PuTTY、Windows Terminal 等）。下图展示了使用 tmux 创建了一个窗口，并将窗口上下分屏成两个窗格，每个窗格都运行一个 zsh。

更重要的是，tmux 将终端和会话（session）进行了分离。我们把创建的窗口和窗格（和其中创建的所有 shell 进程及子进程）看成一个会话，用户可以随时退出（detach）当前会话，会话会在服务器后台保持运行。在之后，用户可以重新连接上（attach）这些会话，从而继续之前的工作。

原理上，tmux 采用了客户端和服务器分离的架构（C/S 架构）。用户看到和交互的是 tmux client，tmux client 中创建的窗口（和 shell 进程）连接在 tmux server 进程上。因此，当用户退出 tmux client 后，会话内容可以在后台运行。 通过 pstree 命令，可以看到上图中运行的两个 zsh 的父进程是 tmux: server。而和用户交互的其实是 tmux: client，其下面并无其他子进程。

➜  ~ pstree -u yfy|less
sshd---zsh---tmux: client
tmux: server-+-zsh-+-less
             |     `-pstree
             `-zsh---ping

在简单了解了下 tmux 的原理后，马上开始 tmux 的上手体验吧。tmux 基础使用非常简单，花 10 分钟就可以完全了解。

tmux quick start

大部分 Linux 发行版都提供 tmux 包，可以通过包管理器安装。其他安装方式（如编译安装）也可以参考官方文档：Installing · tmux/tmux Wiki。

在安装 tmux 后的第一步，我们首先创建一个 tmux 会话。运行 tmux 命令后，会进入 tmux 并创建第一个窗口，在这里你可以像往常一样执行命令。

tmux

接着我们介绍最重要的退出话会话和重连会话的方法。按下 Ctrl-B 后，再按 d 可以退出（detach）当前会话。这样会回到输入 tmux 前的 shell。

通过 tmux list-sessions 或者 tmux ls 可以查看当前所有的会话信息。

➜  ~ tmux ls
0: 1 windows (created Thu Jul  3 14:06:05 2025)

通过 tmux attach 可以连接回第一个会话。

tmux a  # attach

接下来介绍 tmux 最关键的多窗口管理功能，有了它就可以大大提升多任务操作的效率。 tmux 有 session（会话）, window（窗口）, pane（窗格）三个粒度。session 是 tmux 最大的一个粒度，session 下可以创建多个 window，window 可以分割成多个 pane。这里重点介绍窗口和窗格相关的快捷键。

窗口操作

# 创建
Ctrl-B c # 创建新的窗口
Ctrl-B & # 删除当前窗口

# 切換
Ctrl-B Tab        # 切换到刚刚的窗口
Ctrl-B p          # 切换上一个
Ctrl-B n          # 切换下一个
Ctrl-B 数字编号    # 切换到指定一个窗口

# 修改窗口名字
Ctrl-B ,          # 修改当前窗口名字

窗格操作

# 创建
Ctrl-B \"     # 上下切分
Ctrl-B %      # 左右切分
Ctrl-B x      # 删除

# 切换
Ctrl-B 方向键      # 方向键上下左右
Ctrl-B [hjkl]     # 使用 vi 风格的 hjkl 键切换，分别对应左上下右

Ctrl-B z      #  切换全屏

相信你操作了这些快捷键后，已经可以感觉到 tmux 的方便和强大了。tmux 也是一个像 vim 那样灵活性很高的软件，很多时候一个你不知道的快捷键就能极大体验。因此需要去更多尝试。tmux list-keys 可以查看 tmux 的所有快捷键绑定。

本文只介绍了 tmux 的快捷键使用方法，tmux 的软件设计非常简洁高效，以上所有快捷键都有对应它的一个子命令，比如垂直划分窗格对应 tmux split-window -v 命令。如果记不住快捷键，可以直接使用 tmux 命令。tmux man 手册的 COMMAND 章节提供了所有命令的详细解释。另外本文没有介绍 tmux 的 vi copy 模式，使用该模式可以方便查找、复制程序输出内容，该内容比较进阶，感兴趣的读者可以自行了解。

常用配置分享

tmux 像 vim 一样支持高度定制化，可以通过修改 ~/.tmux.conf 配置各种快捷键，网络上也有 oh-my-tmux 这样的项目来帮你做一些配置。接下来分享一些我长期使用下来，感觉很有必要的配置，完整配置见我的 github 仓库。

Bonus：在 ~/.bashrc 或 ~/.zshrc 中设置 alias t="tmux"，tmux attach 效率立刻提升 300%！

t      # 创建 sessin
t a    # attach 到第一个 session

修改快捷键前缀

Ctrl-B 按起来距离比较远，很不方便。可以修改成 Ctrl-X。

# prefix
set -g prefix C-x
unbind-key C-b        # disable default prefix
bind C-x send-prefix

划分窗格快捷键

窗格左右划分和上下划分快捷键比较难记。修改为下划线 _ 是上下分屏，- 是左右分屏。

# @ pane
# split current window horizontally
bind _ split-window -v -c "#{pane_current_path}"

# split current window vertically
bind - split-window -h -c "#{pane_current_path}"

鼠标操作

tmux 默认没有启用鼠标，导致无法使用鼠标滚动历史记录。启用鼠标后，还可以直接点击切换不同窗格，以及拖动选择文字复制。

set-option -g mouse on # open mouse scroll

打开窗口时默认路径

tmux 打开新窗口时，shell 的默认路径是启动 tmux 客户端时的路径。可以通过以下配置实现：

• Ctrl-X Alt-C ：更改默认路径为当前路径
• 创建 panel 时，使用当前路径（-c 参数）

bind M-c attach-session -c "#{pane_current_path}" # Alt-C, to change current path

# @ pane
# split current window horizontally
bind _ split-window -v -c "#{pane_current_path}"

# split current window vertically
bind - split-window -h -c "#{pane_current_path}"

移动窗口顺序

Ctrl-Shift 加方向键左右，可以调整 window 的顺序。

bind -n C-S-Left swap-window -t -1\; select-window -t -1
bind -n C-S-Right swap-window -t +1\; select-window -t +1

session 操作

虽然 window 和 pane 已经足够进行多任务管理了。但是 tmux 提供的多 session 操作也有其用处。适合管理若干完全不相关的任务。

修改快捷键，使其和 window 快捷键类似：Ctrl-C 创建新 session，N/P （大写）切换上一个和下一个 session。

# create session
bind C-c new-session

# session navigation
# (/)   #move to prev/next session
bind -r BTab switch-client -l  # move to last session
bind -r N switch-client -n
bind -r P switch-client -p

复制文字后不自动跳到结尾

tmux 鼠标选中文字会自动复制，但是会自动跳到结尾。有时在查看一些很长的输出历史时，并不想回到结尾，可以通过以下配置禁用跳转：

# copy select text, and don't jump to end
# https://stackoverflow.com/questions/32374907/tmux-mouse-copy-mode-jumps-to-bottom
bind -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-selection

鼠标选中文字后会进入 tmux 的 copy 模式，无法输入命令，此时可以按 q 退出。

tmux in tmux

有时候想要在 tmux 内再连接另一台服务器，然后也使用 tmux。正常情况下 tmux 快捷键只会传递给外层的 tmux 因此无法工作，但是可以使用以下配置实现按 F12 在内外 tmux 间切换。

# 按 F12 切换到内嵌 tmux，在 macos 里需要系统设置中取消 F12 占用
# 1. prefix 为 None，不再拦截快捷键
# 2. key-table 为 off，下面再绑定 off 下的 F12，使之能退出内嵌模式
# 3. 改变 statusbar 颜色，以便知道已进入内嵌模式
# 4. 如果处于特殊模式，退出
unbind -T root F12
bind -T root F12 \
  set prefix None \;\
  set key-table off \;\
  set status-style bg=colour235 \;\
  if -F '#{pane_in_mode}' 'send-keys -X cancel' \;\
  refresh-client -S

# 在 off 表里绑定 F12，恢复之前的设置，以退出该模式
bind -T off F12 \
  set -u prefix \;\
  set -u key-table \;\
  set -u status-style \;\
  refresh-client -S

另一个小技巧是：连续按两次 Ctrl-B 时快捷键会传递给内部 tmux。

参考资料

• Tmux 使用教程 - 阮一峰的网络日志
• Ham Vocke — A Quick and Easy Guide to tmux - Ham Vocke
• tmux 内联使用方法

背景

USTC Hackergame 长期以来使用 Docker 及 Docker Compose 来部署和管理各种题目。对于 nc 类题目，我们使用一个简单的 Python 管理程序来为每个已验证的传入连接创建一个单独的题目运行环境容器，以保证选手之间的隔离。为了动态创建容器，我们将 /var/run/docker.sock 暴露给这个 Python 程序，以便它可以调用 Docker API 来创建容器。由于这个 Python 程序足够简单，我们认为这样做是安全的。而对于 Web 类题目，我们要求出题人在题目内部做好隔离，然而这样带来了额外的心智负担，而且容易出错，可能导致非预期解或出现能够干扰其他选手的情况。

在 2024 年 Hackergame 中，我们决定实现 Web 类题目的容器隔离方案，北京大学 GeekGame 基于我们的 nc 容器管理方案实现了一个简单的 Web 类题目容器管理方案，该方案同样通过透传 Docker Socket 实现对 Web 题目的容器管理。然而，Web 题目的反向代理比 nc 复杂得多，这使得我们对该方案的安全性存在较大的担忧，一旦该管理程序被攻破，攻击者可以直接控制整个服务器。因此，我们需要一个更安全的方案，使得即使 Web 题目的容器管理程序被攻破，攻击者也无法轻易控制整个服务器，这就需要在隔离的、低权限的环境中运行 Docker Daemon。

Rootless Docker-in-Docker

Rootless Docker 是在低权限环境中运行 Docker 的一种方案。Docker 官方提供了一种 Rootless Docker in Docker 的方案，只需要一行命令即可启动：

docker run -d --name dind-rootless --privileged docker:25.0-dind-rootless

该方案在容器中以非 root 用户（UID 1000）创建用户命名空间，并分离其他命名空间和运行 Docker Daemon。然而，该方案存在一些问题：

1. 该方案需要 --privileged 选项，以禁用 seccomp、AppArmor 和 mount masks，但这意味着容器将获得更高的权限，可能导致安全问题。
2. 该方案无法使用 cgroup 来限制容器资源使用，因为 Rootless Docker 需要 systemd 将 cgroup 路径委托给 Docker Daemon 才能执行资源限制。虽然可以用 rlimit 等方案来限制资源，但其工作在进程粒度而非容器粒度，而且可以被轻松禁用。由于 Hackergame 需要强制执行容器资源限制，该问题是致命的。

基于 Systemd User Instance 的 Rootless Docker-in-Docker

为了解决上述问题，我们采用了一个基于 Systemd User Instance 的 Rootless Docker-in-Docker 方案。该方案在 Systemd User Instance 中运行 Rootless Docker Daemon，以实现资源限制和更好的安全性。

Systemd in Docker

为了实现该方案，首先需要在容器中运行 systemd。systemd 的网站上列出了在容器中运行 systemd 的要求，对于 Docker 来说，主要有以下几点：

1. 保留 CAP_SYS_ADMIN 特权。
2. 启用私有 cgroup 命名空间，并将 /sys/fs/cgroup 挂载为可写。
3. 将 /tmp, /run, /run/lock, /var/lib/journal 挂载为 tmpfs。
4. 将 stop_signal 设置为 SIGRTMIN+3，以便 systemd 可以正确关闭。
5. 禁用 AppArmor 或 SELinux。

我们在 docker-compose.yml 中添加了以下内容来实现这些要求：

cap_add:
  - SYS_ADMIN
  - NET_ADMIN
cgroup: private
devices:
  - /dev/net/tun:/dev/net/tun
tmpfs:
  - /tmp
  - /run
  - /run/lock
  - /var/lib/journal
stop_signal: SIGRTMIN+3
tty: true
security_opt:
  - seccomp=seccomp.json
  - apparmor=unconfined
  - systempaths=unconfined

其中 seccomp.json 可以从这里获取，该文件在 Docker 默认 seccomp 配置的基础上允许了 keyctl 和 pivot_root 系统调用，这些系统调用是 Docker 所需要的。此外，该配置还一并禁用了 mount masks (systempaths=unconfined)，因为 Docker 启动容器时需要重新挂载 /sys。此外，我们还保留了 NET_ADMIN 特权，因为一些 systemd 的组件需要该特权。

需要注意的是，cgroup: private 并不会将 /sys/fs/cgroup 挂载为可写，因此我们需要在容器启动时手动处理，可以通过一个自定义的 entrypoint.sh 来实现：

#!/bin/bash

set -euo pipefail

mount --make-rshared /

# Remount cgroup
umount /sys/fs/cgroup
mount -t cgroup2 -o rw,relatime,nsdelegate cgroup2 /sys/fs/cgroup

exec /lib/systemd/systemd

Rootless Docker Daemon in Systemd User Instance

在容器中以非 root 身份运行 Docker Daemon 非常简单，只需要在容器中安装带 Rooeless 支持的 Docker：

RUN apt-get install -y ca-certificates curl && \
    install -m 0755 -d /etc/apt/keyrings && \
    curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc && \
    chmod a+r /etc/apt/keyrings/docker.asc && \
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian bookworm stable" > /etc/apt/sources.list.d/docker.list && \
    apt-get update && \
    apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin uidmap && \
    systemctl disable docker.service docker.socket containerd.service

并创建一个用户，假设名为 rootless，然后使用 machinectl shell rootless@ 切换到该用户，并运行 dockerd-rootless-setuptool.sh install 即可安装 Rootless Docker Daemon，安装程序会自动创建 ~/.config/systemd/user/docker.service 并将其安装到 default.target。设置环境变量 DOCKER_HOST=unix:///run/user/$UID/docker.sock 即可通过 Docker CLI 工具访问该 Rootless Docker Daemon。

Wrapping Up

将 Rootless Docker Daemon 安装脚本生成的 ~/.config/systemd/user/docker.service 文件复制出来，并创建 ~/.config/systemd/user/default.target.wants 中的相对路径符号链接，并在 Dockerfile 中添加创建用户和将这些文件到用户目录中的内容，最后通过在 /var/lib/systemd/linger 目录下创建名为用户名的空文件来使对应的 Systemd User Instance 自动启动，即可实现自动启动 Rootless Docker Daemon。

该方案最终版本代码位于 USTC-Hackergame/web-docker-manager 仓库的 rootless 目录，其中添加了一些用于持久化数据和暴露一些目录到主机的内容。

安全性分析

Rootless Docker 通过 RootlessKit 分离用户命名空间，来实现非特权用户的特权操作以创建容器，因此该方案的容器（命名空间）层次结构如下：

Host (Full Privilege)
└── systemd in Docker (UID 0, CAP_SYS_ADMIN, CAP_NET_ADMIN)
        └── RootlessKit (UID 0 in inner user namespace, with ALL capabilities; UID 1000 in outer user namespace, with no capabilities)
            └── Manager Container
            └── Web Challenge Container 1
            └── Web Challenge Container 2

若管理程序被攻破，则攻击者可以取得 RootlessKit 所创建的用户命名空间中的特权，但由于 RootlessKit 在外层用户命名空间是非特权用户，且运行在容器中，因此攻击者无法直接控制整个服务器，也无法直接访问 Host 的文件系统其他部分。

总结

通过基于 Systemd User Instance 的 Rootless Docker in Docker 方案，我们成功地实现了在隔离的、低权限的环境中运行 Docker Daemon，以实现 Web 类题目的容器隔离。该方案强制执行了容器的资源限制，并通过隔离 Docker Daemon 提高了安全性，使得即使 Web 题目的容器管理程序被攻破，攻击者也无法轻易控制整个服务器。该方案已经在 2024 年 USTC Hackergame 中应用于数道 Web 类题目并稳定运行。

尽管如此，该方案仍有改进空间，如当前外层容器仍需 SYS_ADMIN 特权，这实际上是相当大的权限，而 Sysbox 容器运行时可以在创建容器时直接分离用户命名空间，提供了一种不需要这些特权的替代方案，是一个可以探索的方向。此外，我们的方案为了方便直接禁用了 AppArmor Profile，但实际上只需要创建自定义的 AppArmor Profile 放松一些限制（如允许 mount 和放松一些路径下的限制），而不需要将其完全置于 unconfined 状态，这样可以进一步提升安全性，但仍需要进一步探索。

目的

某些课程作业附带的代码示例会通过 HTTP 的方式获取运行需要的输入数据，但是如果这个数据不巧放在某台访问速率很低的服务器上（例如不少用 .edu 域名的国外大学的课程网站上），则会使得作业的运行时间大大加长——通过只有几 KB/s 的网络下载数十 MB 的数据总不是个好主意。更有可能的是，根据作业内容，样例代码还需要做一些修改，这时候每次调试运行代码时都要去下载一次输入数据，简直难以忍受。本文将针对 Windows 用户，讲解如何在手工下载一次相关的文件后，在本地快速搭建一个 HTTP 服务器提供数据文件，以避免反复访问慢速的源地址。对于不能修改访问地址的情况，也提供了相应的对策。

为何不写针对 Linux 用户的教程呢？这是因为，由于有 Apache 和 Nginx 这类成熟好用的服务器软件，再加上 Linux 操作系统优秀的包管理器，结合网上的教程，用几分钟的时间在 Linux 平台上快速建立并运行一个 HTTP 服务器应该不是难事。而在 Windows 上，配置 IIS 这类大而笨重的服务器非常麻烦，使用 Apache/Nginx 之类的服务器软件又由于操作习惯的不同，也不方便。

使用 Python http.server

对比下面的（老旧的）EasyWebSvr，使用 Python 很容易完成一个简单的 HTTP 服务器搭建。

如果你已经安装了 Python，则可以直接使用

python3 -m http.server <port>

来以当前目录为根目录，<port> 为端口运行一个 HTTP 服务器。

如果需要指定别的目录 <path> 作为 HTTP 服务的根目录，可以使用

python3 -m http.server <port> --directory <path>

如果需要 bind 到特定的地址（对于本地服务而言，应该使用 127.0.0.1），可以使用下面的命令。bind 是指将一个网络地址（IP 和端口）与服务器软件中的套接字关联的过程，使得该服务器能接收指定地址上的网络数据。Python 的 http.server 默认值为 0.0.0.0，代表所有人都可以访问。如果只需要本地访问，则可以使用本地回环地址 127.0.0.1。

python3 -m http.server <port> --bind 127.0.0.1

使用 EasyWebServer

获取一个 HTTP 服务器

首先当然是要获取一个 HTTP 服务器了，这里我们选择的是 EasyWebSvr。这个服务器是一个体积超小（只有数十 KB）、单文件、几乎不需要配置的小型 HTTP 服务器，甚至支持 CGI 和 PHP。EasyWebSvr 是一个历史久远的开源项目，使用 MSVC 作为开发环境，而且很容易下载到它的编译好的版本（搜索 EasyWebSvr 就可以了）。下载后你将得到一个 EasyWebSvr.exe 和一些其他的文件。不用理会其他的文件（事实上它们是不必要的），直接将 EasyWebSvr.exe 复制到一个空文件夹里面就可以了。

提示：根据代码，EasyWebSvr 会 bind 到 0.0.0.0，这可能会导致安全问题。如果需要 bind 到 127.0.0.1，可能需要修改代码并重新构建。

准备数据

• 从原始的地址上手工下载一份要被访问的数据，放到上面所说的那个空文件夹里面。
• 运行 EasyWebSvr.exe，可以看到一个小窗口。
• 点击右下角的锤子按钮（菜单），选择最下面的 设置 一项。
• 在弹出的设置对话框里面，选择 主目录 为当前 EasyWebSvr.exe 所在的目录。
• 在 文档 选项卡里面勾选 允许目录浏览 和 总是显示目录内容。
• 点击 确定 结束并保存配置。
• 然后在主窗口里面点击右下方的红色按钮（在菜单按钮的边上），正常应该看到它变成蓝绿色（这时候如果有 Windows 防火墙提示，请选择允许）。
• 此时服务器就配置好了，打开浏览器输入 http://localhost 即可看到文件列表。

修改原先的代码

• 例如原先提供的代码中数据文件的 URL 是 http://some.site.edu/path/to/file/data.csv，而这份数据就和 EasyWebSvr.exe 在同一文件夹下，则将代码中的地址修改为 http://localhost/data.csv 就可以使用本地的文件服务了！
• 服务器最小化后会显示一个小托盘图标，右键点击它可以显示各种选项，包括重新显示主窗口。
• 使用完后，点击蓝绿色图标，它会变成红色，此时服务器就关闭了。

特殊情况

代码不支持修改地址

如果代码不支持修改地址（这很少见），那么也可以按照原来的 URL 在本地建立文件夹，类似下面这样：

EasyWebSvr.exe
path/                -> 建立这个目录
    to/              -> 建立这个目录
        file/        -> 建立这个目录
            data.csv -> 数据文件在这里

然后修改 hosts 文件（一般在 C:\Windows\System32\drivers\etc 里面，需要管理员权限，具体请看相关教程），加上一句

127.0.0.1 some.site.edu

然后以管理员权限运行

ipconfig /flushdns

即可。可以通过浏览器访问 http://some.site.edu/path/to/file/data.csv 来确认。这一操作会修改所有对 some.site.edu 的请求，因此用完后请删去在 hosts 中加入的那一行，然后再运行一次 ipconfig /flushdns。

原地址有非 80 的端口号

如果你拿到的地址使用了别的端口（例如 some.site.edu:8080）且不能修改，那么请在 EasyWebServer 的设置页面 端口号 处输入对应的端口号 8080，对应的访问地址就是 localhost:8080。

提示端口已被占用

这可能是因为有其他应用在使用 80 端口。通过 netstat -ano 命令可以查看机器上正被使用的端口号和对应的进程 ID。如果不希望关闭占用 80 端口的程序，那么和上面非 80 端口一样，将我们的 HTTP 文件服务器换到一个别的端口就好了，例如 8080 或者 8000，然后再次点红色圆球图标开启服务器。这时候记得访问地址也要加上对应的端口号。

本文另有英文版及在南京大学分享时使用的幻灯片。

背景

由中科大 Linux 用户协会维护的中科大开源软件镜像站是中国大陆高校访问量最大、收录最全的开源软件镜像之一。 在 2024 年 5 月至 6 月期间，我们的镜像站服务的流量大约是每天 36 TiB，主要分为以下两大类：

• HTTP/HTTPS 流量 19 TiB，请求量 1700 万
• Rsync 流量 10.3 TiB，请求量 2.18 万（如果算上一个异常的客户端，那么总数是 14.78 万）

多年以来，随着现有镜像仓库容量的增加和新镜像仓库的加入，我们的服务器硬盘容量已经十分紧张了。目前¹提供镜像服务的两台服务器的磁盘容量都已经接近极限了：

• 主（HTTP）服务器采用 XFS 文件系统，在 2023 年 12 月 18 日达到了 63.3 TiB（总容量 66.0 TiB，使用率 96%）；
• 副（Rsync）服务器采用 ZFS 文件系统，在 2023 年 11 月 21 日达到了 42.4 TiB（总容量 43.2 TiB，使用率 98%）。

两台服务器的配置分别如下：

HTTP 服务器

• 2020 年秋季搭建
• 第二代至强可扩展处理器（Cascade Lake）和 256 GB DDR4 内存
• 12 块 10 TB HDD + 一块 2 TB SSD
• 在硬件 RAID 上使用 LVM 和 XFS
• 由于 XFS（截至本次重建时）不支持压缩，因此为了应对其他分区的潜在的扩容需求，我们在 LVM VG 层面保留了 free PE

Rsync 服务器

• 2016 年底搭建
• 至强 E5 v4 处理器（Broadwell）和 256 GB DDR4 内存
• 12 块 6 TB HDD 和一些小容量 SSD 用来装系统和当缓存
• 组建了 ZFS RAID-Z3 阵列，分为 8 块数据盘 + 3 块校验盘，最后一块留作热备
• 全默认参数（仅修改了 zfs_arc_max）

这两台服务器的磁盘负载非常高，日常维持在 90% 以上，以至于即使从科大校园网内下载镜像，速度也很难达到 50 MB/s。 显然对于镜像站这种专用于存储用途的机器来说，这样的性能表现是不尽人意的。

ZFS

ZFS 以“单机存储的终极解决方案”著称。 它集 RAID、逻辑卷管理和文件系统于一体，具有包括快照、克隆、发送/接收等高级功能。 ZFS 内的所有数据都有校验，可以在硬盘出现比特翻转等极端情况下尽可能确保文件系统的完整性。 对于专用于存储的服务器来说，ZFS 看起来是个可以“开箱即用”的解决方案，但当你看到它有如此多的可调节参数之后，你马上就不会这么想了。

作为前期学习和实验，我在自己的工作站上增加了一批额外的硬盘并把它们组成了两个 ZFS pool，然后注册了一些 PT 站开始刷流来制造一些磁盘负载以便学习研究。 在 PT 站的刷流成果十分可观：这个单机的 seed box 在两年半间产生了 1.20 PiB 的上传量。

这两年刷 PT 站刷下来，我总结出来几个重要的 ZFS 学习资料来源：

• UToronto 的 Chris Siebenmann 的博客：https://utcc.utoronto.ca/~cks/space/blog/
• OpenZFS 的官方文档：https://openzfs.github.io/openzfs-docs/
• 我自己攒出的一篇博客：Understanding ZFS block sizes
  • 以及这篇博客底部列出的参考文献

经过多年的 ZFS 学习，我意识到镜像站服务器上的配置其实有很大的优化空间，方法就是 all-in ZFS 并正确地调节一些参数。

镜像站

在开工重建 ZFS pool 之前，我们需要正确地理解和分析镜像站的负载类型。简而言之，镜像站的特点是：

• 提供文件下载服务
• 也（被迫）提供“家庭宽带上下行流量平衡服务”

  （责任全在 PCDN 方）

• 读多写少，且大部分读取都是全文件顺序读取
• 能够容忍少量的数据丢失，毕竟镜像内容可以轻易地从上游重新同步回来

基于以上思考，我们分析了镜像站上存储的内容。从上图中可以看出，镜像站上总文件数超过 4000 万，其中一半的文件大小不到 10 KiB，并且 90% 的文件大小不到 1 MiB。 尽管如此，所有文件的平均大小仍然达到了 1.6 MiB。

重建 Rsync 服务器

Rsync 服务器的流量较少，但磁盘使用率较为极端，加上我们认定 Rsync 服务的重要性较低，因此在今年 6 月，我们先动手重建了这台服务器。 我们制定了如下的重建计划：

• 首先，考虑到镜像站上一半的文件都不到 10 KiB（注意我们的磁盘的物理扇区大小是 4 KiB），RAID-Z3 的开销过高，因此我们决定将其重建为 RAID-Z2 并且拆成两组 vdev。这样做还有一个额外的好处，即期望情况下我们还可以在这个 ZFS pool 中获得两倍的 IOPS，毕竟文件的每个“块”只存储在一个 vdev 上。

• 然后我们仔细研究了如何为镜像站场景调优 ZFS dataset 参数：

  • recordsize=1M：尽可能优化顺序读写性能，同时减少碎片化。

  • compression=zstd：开点压缩来试试能节约多少磁盘空间。

    • OpenZFS 2.2 开始将 early-abort 机制引入了 Zstd 压缩算法（Zstd-3 以上的等级）。该机制会首先尝试使用 LZ4 和 Zstd-1 来压缩数据以便评估数据的可压缩性，如果数据不可压缩（熵太大），则不再尝试用设定的 Zstd 等级压缩，而是直接原样写入磁盘上，避免在不可压缩的数据上浪费 CPU。

      我们已知镜像站上的大部分内容都是已经压缩过的，因此 early-abort 算是给我们兜了个底，让我们可以放心地开 Zstd。

  • xattr=off：镜像站上的文件不需要扩展属性。
  • atime=off：镜像站上的文件不需要记录，也不需要更新 atime，可以省掉不少写入。
  • setuid=off、exec=off、devices=off 也是我们不需要的挂载选项（也是一个更安全的做法）。
  • secondarycache=metadata 让 L2ARC 仅缓存 ZFS 内部的元数据。这是因为 Rsync 服务器上的文件访问模式更加均匀，而不像面向终端用户的 HTTP 服务器上冷热分明，因此仅缓存元数据可以节约 SSD 寿命。

• 以及一些可能有潜在（但我们认为我们可以容忍的）风险的选项：

  • sync=disabled：禁用同步写入语义（open(O_SYNC)、sync() 和 fsync() 等）以让 ZFS 能够充分发挥写缓冲区的意义，如降低碎片率等。
  • redundant_metadata=some：（OpenZFS 2.2）减少元数据的冗余度来获得更好的写入性能。

  我们认为这两个选项符合我们对镜像站仓库内容的数据安全和完整性需求的理解，它们在其他场景下不一定“安全”。

• 对于 ZFS 模块层面的参数，光是 290+ 的数量就已经很劝退了。 此处感谢 Debian ZFS 维护者兼北京外国语大学镜像站管理员 @happyaron 的帮助，我们快速找出了十几个常用的参数进行针对性调节。

  # 设置 ARC 大小范围为 160-200 GiB，并为操作系统保留 16 GiB 空闲
  options zfs zfs_arc_max=214748364800
  options zfs zfs_arc_min=171798691840
  options zfs zfs_arc_sys_free=17179869184
  
  # 设置元数据对用户数据优先级的权重为 20x (OpenZFS 2.2+)
  options zfs zfs_arc_meta_balance=2000
  
  # 允许 dnode 占用至多 80% 的 ARC 容量
  options zfs zfs_arc_dnode_limit_percent=80
  
  # 以下几行参见 man page 中的 "ZFS I/O Scheduler" 一节
  options zfs zfs_vdev_async_read_max_active=8
  options zfs zfs_vdev_async_read_min_active=2
  options zfs zfs_vdev_scrub_max_active=5
  options zfs zfs_vdev_max_active=20000
  
  # 避免因内存压力降低 ARC 读写速度
  options zfs zfs_arc_lotsfree_percent=0
  
  # L2ARC 参数
  options zfs l2arc_headroom=8
  options zfs l2arc_write_max=67108864
  options zfs l2arc_noprefetch=0
  

  另外还有 zfs_dmu_offset_next_sync，但由于它从 OpenZFS 2.1.5 开始已经默认启用了，因此我们将其从本列表中略去。

将 Rsync 服务暂时转移到由 HTTP 服务器兼任之后，我们 destroy 了原有的 ZFS pool 并重新组建了一个新的 pool，然后再从外面（上游或 TUNA、BFSU 等友校镜像站）把原有的仓库同步回来。 令我们感到惊讶的是，把总共近 40 TiB 的仓库同步回来只花了 3 天，比我们预想的要快得多。 其他的一些数据看起来也令人振奋：

• ZFS 压缩率：39.5T / 37.1T (1.07x)

  需要特别指出的是，ZFS 只显示压缩率小数点后两位，所以更高的精度，需要通过原始数据自己计算：

  zfs list -po name,logicalused,used
  

  我们更精确的压缩率是 1 + 6.57%，即压掉了 2.67 TB（2.43 TiB），约等于 9 份微信数据（不是

• 最关键的是更合理的 I/O 负载：

  

可以看出，经过几天的预热之后，I/O 负载维持在了 20% 左右，而在重建之前一直维持在 90% 以上。

重建 HTTP 服务器

我们的 HTTP 服务器是在 2020 年秋季搭建的，并且当时也有一些不同的背景。 申请这台服务器正是因为 Rsync 服务器容量过满且性能不佳，加上当时社团内也没有熟悉 ZFS 的同学，我们对 ZFS 的印象很差，所以我们决定完全避开 ZFS，使用硬件 RAID、LVM 和 XFS，其中使用 LVM 的原因是 RAID 卡不支持跨两个控制器组 RAID。 对于“内存做缓存”这部分，我们决定直接使用内核的 page cache；而对于 SSD 缓存，我们则率先吃了 LVMcache 的螃蟹。

然而这些过于“新鲜”的技术并没有带来比（现在的 ZFS）更好的体验：

• XFS 无法缩小，因此我们不得不在 LVM VG 层面保留了 free PE。同时我们也不能把 XFS 文件系统用满，因此这里就有了两层无法利用的空闲空间。
• 我们最初分配了 1.5 TB 的 SSD 缓存，但 LVMcache 又建议我们不要超过 100 万个 chunk，我们当时也没有足够的精力和知识水平去研究这个建议背后的技术细节，因此我们最终只分配了 1 TiB（1 MiB chunk size * 1 Mi chunks）的 SSD 缓存。
• SSD 缓存策略不可调，多年以后我们翻了 kernel 源码才发现它是一个 64 级的 LRU。
• 配好 cache 之后 GRUB 立刻挂了（难绷），我们调查发现原因是 GRUB 有一套自己的解析 LVM metadata 的代码，它并没有正确处理（或者说根本没处理）VG 中有 cache volume 的情况，我们不得不自己 patch 了 GRUB 才能正常开机。
• 由于我们对 LVMcache 的 chunk 不够了解，我们的 SSD 在不到 2 年的时间里就严重超过了标称的写入寿命，我们被迫申请换新。

在 SSD 换新之后，即使我们认为我们对 LVMcache 做出了稍微合理一点的调参，坚持忽略警告采用 128 KiB 的 chunk size 和 800 万个 chunk 之后，它的性能（命中率）也并不可观：

这些年来我们已经踩够了 LVMcache 的坑了，加上 Rsync 服务器重建的巨大成功，我们重新开始相信 ZFS 是天下第一的存储方案了。 所以一个月之后，我们又制定了一个相似的重建计划准备重建 HTTP 服务器，但是有一些微小的差别：

• 我们的 Rsync 服务器采用原生的 Debian kernel + zfs-dkms，但根据我们使用 PVE 的经验，我们准备在 HTTP 服务器上直接用 6.8.8-3-pve kernel，它打包了 zfs.ko，这样我们就不用在 DKMS 上浪费时间了。
• 由于磁盘数目相同（12 块），我们也采用了两个 6 盘 RAID-Z2 vdev 的组合。
  • 考虑到这台服务器直接向用户提供 HTTP 服务，磁盘的访问模式会比 Rsync 服务器更加冷热分明，因此我们保持了 secondarycache=all 的设置（采用默认值，不动）。
  • 这台新服务器的 CPU 更新更好，因此我们把压缩等级提高到了 zstd-8 来试试能否获得更好的压缩比。
• 我们在 Rsync 服务器上已经有了一个完整的、经过 ZFS 优化过的仓库，因此我们可以直接用 zfs send -Lcp 把数据倒过来。我们最终只花了 36 小时就把超过 50 TiB 的数据都倒回来了。
• 由于两台服务器上存储的镜像仓库有所不同，HTTP 服务器上的压缩比略低一些，为 1 + 3.93%（压掉了 2.42 TB / 2.20 TiB）。

我们把两台服务器的 I/O 负载放在一张图里对比：

上图左半部分为重建前的情况，中间部分为仅重建了 Rsync 服务器的情况，右半部分为两台服务器都重建完毕后的情况。

ZFS ARC 的命中率也十分可观：

稳定下来之后，两台服务器的 I/O 负载还更低了：

杂项

ZFS 透明压缩

我们并没有想到这么多仓库的压缩率都还不错：

有些数字看着不太对劲（比如第一个），我们认为是这个问题造成的： openzfs/zfs#7639

如果我们按照压缩量排序，结果如下：

debian-cdimage 一个仓库就占了总压缩量的 1/4。

Grafana for ZFS I/O

重建后，我们也修了一个显示 ZFS I/O 的 Grafana 面板。 因为 ZFS 的 I/O 统计数据是通过 /proc/spl/kstat/zfs/$POOL/objset-$OBJSETID_HEX 获取的，并且是分“object set”（即 dataset）累计统计的，所以我们需要先对每个 dataset 的数据做差分，再按 pool 加起来。 也就是说，一个 InfluxQL subquery 是跑不掉的。

SELECT
  non_negative_derivative(sum("reads"), 1s) AS "read",
  non_negative_derivative(sum("writes"), 1s) AS "write"
FROM (
  SELECT
    first("reads") AS "reads",
    first("writes") AS "writes"
  FROM "zfs_pool"
  WHERE ("host" = 'taokystrong' AND "pool" = 'pool0') AND $timeFilter
  GROUP BY time($interval), "host"::tag, "pool"::tag, "dataset"::tag fill(null)
)
WHERE $timeFilter
GROUP BY time($interval), "pool"::tag fill(linear)

由于 subquery 的存在，这个 query 确实有点慢，但我们也没啥能优化的。

如果要显示读写速率的话，直接把内层查询的 reads 和 writes 换成 nread 和 nwritten 就行了。

令 UC 震惊部出动的是，一个机械盘阵列竟然能跑出平均 15k、最高 50k 的 IOPS。 我们发现这个统计数字算上了 ARC hit，也就是只有一小部分 I/O 请求是真正落盘的，那就好解释了。

AppArmor

换上先进的 PVE kernel 之后，我们很快就发现同步任务全挂了（） 排查发现 rsync 在调用 socketpair(2) 的时候冒出了 EPERM，这是我们从来没遇到过的情况。 实际上这些系统调用都被 AppArmor 拦下来了，最终查到是 Ubuntu 在 kernel 里加的私货 security/apparmor/af_unix.c 导致的。 由于 Proxmox VE 的 kernel 是从 Ubuntu fork 过来的，这个私货也就被夹带到我们服务器上了。

我们发现 PVE 也打包了自己的 AppArmor features 配置，就把它直接拉过来用：

dpkg-divert --package lxc-pve --rename --divert /usr/share/apparmor-features/features.stock --add /usr/share/apparmor-features/features
wget -O /usr/share/apparmor-features/features https://github.com/proxmox/lxc/raw/master/debian/features

文件级去重

我们注意到个别仓库有大量的重复的、内容相同的目录，怀疑可能是同步方法（HTTP）的限制导致目录的符号链接变成了完整内容的拷贝。

我们想到了 ZFS 的 deduplication，于是在 ZeroTier 仓库上做了一个初步的测试：

zfs create -o dedup=on pool0/repo/zerotier
# 导入数据

# zdb -DDD pool0
dedup = 4.93, compress = 1.23, copies = 1.00, dedup * compress / copies = 6.04

结果十分可观，但考虑到 ZFS dedup 一向来糟糕的名声，我们还是不太想在镜像站上启用。 所以我们重新找了个更灵车的方案：

# post-sync.sh
# Do file-level deduplication for select repos
case "$NAME" in
  docker-ce|influxdata|nginx|openresty|proxmox|salt|tailscale|zerotier)
    jdupes -L -Q -r -q "$DIR" ;;
esac

这个用户态的文件去重工具十分好用，效果堪比 ZFS，而且没有性能损失。 我们对几个明显有重复内容的仓库跑了一下 jdupes，结果如下：

参考上述表格，我们排除了 mysql-repo，因为它的去重比例太低，不值得花费跑一遍去重产生的 I/O 负载。

总结

ZFS 解决了我们镜像站上的一大堆问题，并且有了此次调参经验，我们现在宣布 ZFS 天下第一（不是）

有了 ZFS 之后：

• 我们不再担心分区问题，ZFS 可以灵活分配。
• 我们的机械盘比别人的固态盘跑得还快，这非常 excited！
  • 我们成为了第一个不再羡慕 TUNA 的全闪服务器的镜像站！
• 零成本获得额外容量，由 ZFS 透明压缩和去重联合赞助！

思考

虽然我们的 ZFS 配置看起来非常高效，但我们也知道 ZFS 在长期运行中可能会因为碎片化而导致性能下降的问题。 我们会持续关注我们的服务器，监控长期的性能变化。

Rclone 简介

Rclone 是一个命令行工具，用于同步文件和目录到和从云存储服务。它支持 Google Drive、Amazon S3、Dropbox、Microsoft OneDrive、Yandex Disk、Box 和其他一些云存储服务。Rclone 是一个 Go 程序，可以在 Windows、macOS、Linux 和其他操作系统上运行。

安装 Rclone

Rclone 官方的下载链接在 这里。你可以根据自己的操作系统下载对应的版本。

部分常见的包管理工具也提供了 Rclone 的安装方式，例如：

• 在 Windows 上，你可以使用 Chocolatey 安装 Rclone：

  choco install rclone
  

• 在 Windows 上，你也可以使用 Winget 安装 Rclone：

  winget install Rclone.Rclone
  

• 在 macOS 上，你可以使用 Homebrew 安装 Rclone：

  brew install rclone
  

• 在 Ubuntu 上，你可以使用 apt 安装 Rclone：

  sudo apt install rclone
  

• 更多包管理器的安装方法可以参考 Rclone 官方文档。

运行 rclone --version 来检查 Rclone 是否安装成功，如果正常，你应该类似看到如下输出：

$ rclone --version
rclone v1.66.0
- os/version: darwin 14.5 (64 bit)
- os/kernel: 23.5.0 (arm64)
- os/type: darwin
- os/arch: arm64 (ARMv8 compatible)
- go/version: go1.22.1
- go/linking: dynamic
- go/tags: none

配置 Rclone

我们在这里以 mail.ustc.edu.cn 为例，做一个 step-by-step 的教程：

rclone config

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q>

输入 n，然后回车。

Enter name for new remote.
name>

输入一个名字，这里我们输入 onedrive，然后回车。

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
 1 / 1Fichier
   \ (fichier)
 2 / Akamai NetStorage
   \ (netstorage)
 3 / Alias for an existing remote
   \ (alias)
 4 / Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Minio, Netease, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu and others
   \ (s3)

...

33 / Microsoft OneDrive
   \ (onedrive)

...

Storage>

输入 onedrive，然后回车。

Option client_id.
OAuth Client Id.
Leave blank normally.
Enter a value. Press Enter to leave empty.
client_id>

Option client_secret.
OAuth Client Secret.
Leave blank normally.
Enter a value. Press Enter to leave empty.
client_secret>

Option region.
Choose national cloud region for OneDrive.
Choose a number from below, or type in your own string value.
Press Enter for the default (global).
 1 / Microsoft Cloud Global
   \ (global)
 2 / Microsoft Cloud for US Government
   \ (us)
 3 / Microsoft Cloud Germany
   \ (de)
 4 / Azure and Office 365 operated by Vnet Group in China
   \ (cn)
region>

Edit advanced config?
y) Yes
n) No (default)
y/n>

Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.

y) Yes (default)
n) No
y/n>

这里我们都直接回车，不输入任何内容。(五次回车)

在这其中会弹出一个网页，让你登录你的 OneDrive 账号，然后授权 Rclone 访问你的 OneDrive 账号。

Option config_type.
Type of connection
Choose a number from below, or type in an existing string value.
Press Enter for the default (onedrive).
 1 / OneDrive Personal or Business
   \ (onedrive)
 2 / Root Sharepoint site
   \ (sharepoint)
   / Sharepoint site name or URL
 3 | E.g. mysite or https://contoso.sharepoint.com/sites/mysite
   \ (url)
 4 / Search for a Sharepoint site
   \ (search)
 5 / Type in driveID (advanced)
   \ (driveid)
 6 / Type in SiteID (advanced)
   \ (siteid)
   / Sharepoint server-relative path (advanced)
 7 | E.g. /teams/hr
   \ (path)
config_type>

这里我们直接回车，不输入任何内容。

Option config_driveid.
Select drive you want to use
Choose a number from below, or type in your own string value.
Press Enter for the default (b!****************************************************************).
 1 / OneDrive (business)
   \ (b!****************************************************************)
config_driveid>

Drive OK?

Found drive "root" of type "business"
URL: https://mailustceducn-my.sharepoint.com/personal/tiankaima_mail_ustc_edu_cn/Documents

y) Yes (default)
n) No
y/n>

Configuration complete.
Options:
- type: onedrive
- token:
***
- drive_id: b!****************************************************************
- drive_type: business
Keep this "onedrive" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d>

依旧是直接回车，不输入任何内容。

Current remotes:

Name                 Type
====                 ====
onedrive             onedrive

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q>

输入 q，然后回车。现在我们已经配置好了 Rclone。

将文件从 OneDrive 备份到本地

rclone copy onedrive: /path/to/local/folder -P

总结

Rclone 是个非常强大的工具，支持的云存储服务也非常多，你可以通过 rclone config 来配置其他的云存储服务。

限于篇幅和时间关系，本文只介绍了 Rclone 的基本使用方法，更多的功能和用法请参考 Rclone 官方文档。

如果您对这篇内容有任何问题或建议，欢迎 联系我们。

教程说明

本教程只介绍最基本的操作和游戏刚刚开始阶段的策略，帮助新手活过第一层。引用内容为补充或 Fun facts，可以忽略。图中游戏“截图”均为字符界面的直接复制——虽然没有了颜色或加粗效果，但还是觉得这样更合适一些。

关于

NetHack 是一款历史悠久的 Roguelike 游戏，基于龙与地下城规则，也有着 Roguelike 典型特征：随机生成地图，永久死亡，难度和复杂度非常高。同时，游戏中也融合了各种文化和领域的元素，并且有多种有趣的提示信息和死亡方式。

总有一二十年才通关的老玩家说 NetHack 不难——或许和某些其他 Roguelike 相比确实如此，但这和你有什么关系呢？

此游戏默认只有字符界面，以下为一个游戏画面，可以感受一下：

This kobold corpse tastes terrible!--More--

                                                       --------
                      ----------                       |......-
                      |........|`######################-......|
                      |........|     -----------       |<.....|
                      |........|     |.........|  #####.....{.|
                      |........-#####|.........-###    --------
                      |........|    #..........|
                      --------|-     -------.---
                             ##
                              ##
                              #
                             #
                     --------.--
                     |$........|
                     |.........|
    ------------    #..........|
    |.....@.d..|    #|..........
    |.....^.....#####|....>....|
    ------------     -----------

Petergu the Stripling          St:15 Dx:14 Co:18 In:9 Wi:7 Ch:10 Lawful
Dlvl:1 $:11 HP:7(16) Pw:1(2) AC:6 Xp:1

贴图模式也是有的，但是不如字符模式经典

安装和配置

如果你使用 Linux 等操作系统，那么 NetHack 多半可以直接从软件源中安装：包名通常为 nethack 或 nethack-console。如果使用 Windows，可以在官方网站下载。建议使用默认的英文版。

为了更好地游戏体验，在 Linux 上推荐将以下内容添加至 ~/.nethackrc 配置文件（这也是 Ubuntu 中自带的配置）。

#
# System-wide NetHack configuration file for tty-based NetHack.
#

OPTIONS=windowtype:tty,toptenwin,hilite_pet
OPTIONS=fixinv,safe_pet,sortpack,tombstone,color
OPTIONS=verbose,news,fruit:potato
OPTIONS=dogname:Slinky
OPTIONS=catname:Rex
OPTIONS=pickup_types:$
OPTIONS=nomail

# Enable this if you want to see your inventory sorted in alphabetical
# order by item instead of by index letter:
# OPTIONS=sortloot:full
# or if you just want containers sorted:
# OPTIONS=sortloot:loot

#
# Some sane menucolor defaults
#

OPTIONS=menucolors
MENUCOLOR=" blessed "=green
MENUCOLOR=" holy "=green
MENUCOLOR=" uncursed "=yellow
MENUCOLOR=" cursed "=red
MENUCOLOR=" unholy "=red
MENUCOLOR=" cursed .* (being worn)"=orange&underline

开局

运行 NetHack 后将看到以下提示：

NetHack, Copyright 1985-2020
         By Stichting Mathematisch Centrum and M. Stephenson.
         Version 3.6.6 Unix, built Mar 18 18:21:43 2020.
         See license for details.


Shall I pick character's race, role, gender and alignment for you? [ynaq]

你可以按 n 然后自己选择人物的种族（人类，矮人，精灵，地精，兽人）、角色（考古学家、骑士、游客等 13 种）、性别（男、女）和阵营（守序、中立、混乱），或者按 y 让系统随机选一个。对于新手，女武神（Valkyrie）、野蛮人（Barbarian）和武士（Samurai）是开局较为容易的角色，虽然我觉得巫师（Wizard）的游戏体验比较有趣。

性别和阵营可以在游戏中因道具改变

每个角色的每个阵营对应一个不同的神。其中僧侣（Monk）的神是中国神话传说中的”人物”：山海经、赤松子和黄帝

选好之后根据提示按 y 开始。出现 --More-- 时说明提示未显示完，按空格到下一句话。

被怪打一下后出现 --More--，下一句话基本是 You die...

Hello petergu, welcome to NetHack!  You are a neutral male human Wizard.
--More--




  -----
  |..@|
  |.f(|
  |x..|
  |...|
  |?..+
  -----









Petergu the Evoker             St:9 Dx:8 Co:16 In:17 Wi:14 Ch:11 Neutral
Dlvl:1 $:0 HP:12(12) Pw:7(7) AC:9 Xp:1

图中，@ 是你，身边白底（复制出来看不到了）的 f 是你的宠物猫，x 是一只怪（grid bug），+ 是关着的门。各种字符代表什么需要慢慢记忆，或者按 / 然后根据提示再按 /，移动光标查看地图上的信息，结束按 ESC。

无论任何时候都要仔细阅读提示。这和学习 Linux 命令行是一样的。

底栏是各种状态。新手主要要关注的就是 HP，即生命值；AC，Armor Class，代表防御，越低越好；以及可能出现在底栏的其他临时状态，比如失明（Blind）。其他属性的含义可在 Wiki 上查询。

HP 降为 0 只是最无聊的死亡方式

按 i 可以打开装备栏查看自己的物品。空格返回。

 Weapons
 a - a blessed +1 quarterstaff (weapon in hands)
 Armor
 b - an uncursed +0 cloak of magic resistance (being worn)
 Scrolls
 i - an uncursed scroll of magic mapping
 j - an uncursed scroll of enchant weapon
 k - an uncursed scroll of remove curse
 Spellbooks
 l - a blessed spellbook of force bolt
 m - an uncursed spellbook of create monster
 Potions
 f - an uncursed potion of gain ability
 g - an uncursed potion of monster detection
 h - an uncursed potion of healing
 Rings
 d - an uncursed ring of fire resistance
 e - an uncursed ring of invisibility
 Wands
 c - a wand of magic missile (0:4)
 Tools
 n - a magic marker (0:55)
 o - an uncursed blindfold
 (end)

按 Ctrl-X 可以查看自身可以查看的属性。空格翻页和返回。

更多的属性不能自我感觉到，只有特殊情况下才会显示出来

 Petergu the Wizard's attributes:

 Background:
  You are an Evoker, a level 1 male human Wizard.
  You are neutral, on a mission for Thoth
  who is opposed by Ptah (lawful) and Anhur (chaotic).
  You are in the Dungeons of Doom, on level 1.
  You entered the dungeon 9 turns ago.
  There is a full moon in effect.
  You have 0 experience points.

 Basics:
  You have all 12 hit points.
  You have all 7 energy points (spell power).
  Your armor class is 9.
  Your wallet is empty.
  Autopickup is on for '$' plus thrown.

 Current Characteristics:
  Your strength is 9.
  Your dexterity is 8.
  Your constitution is 16.
  Your intelligence is 17.
 (1 of 2)

“静态”操作就这些：因为 NetHack 是回合制游戏，你可以随时查看这些信息并在进行动作前充分思考。

那么接下来的任务就是活下去了。毕竟，游戏的目的是在地牢深处找到炎多的护符（Amulet of Yendor）并将其献给自己的神，而不是原地不动。

游戏开始

首先是移动。推荐的移动方式是和 Vim 操作类似的 8 个方向的 hjklyubn，当然新手用四个方向键也未尝不可。

事实上，用方向键移动 as good as dead。按下一个移动键不松手也是常见的死亡原因。

可以用大写的 HJKLYUBN 向一个方向长距离移动

比如说，按下箭头或 j 移动到门边上。移动途中，x 被猫杀死了。

Rex misses the grid bug. Rex bites the grid bug.

Rex bites the grid bug. The grid bug is killed!

按 Ctrl-P 可以查看之前的消息。

前期，宠物比你战斗力强也是常有的事

 -----
 |..<|
 |..(|
 |..f|
 |...|
 |..@+
 -----

开门才能出去。按 ol 开右侧（l 移动方向）的门。之后就可以向右探险了。沿着过道（#）走了一段，发现没有路了。

-----
|..<|
|..(|
|...|
|...|
|...-#
-----#
     ###
       #
       #
       ###f
          @

这也是常见操作：需要搜索以下才能找到路。按 s 搜索，或者更常用的，按 10s 搜索 10 次。如果没有路就再来 10 次。发现了隐藏的门，于是继续开门走进屋子。

You find a hidden door.





  -----
  |..<|
  |..(|
  |...|
  |...|
  |...-#
  -----#
       ###
         #
         #
         ###f
            @+

屋子里有一个 [ ，走到物品上方并按 , 捡起。p - a splint mail.。这是一件盔甲，按 w 穿戴，再按 ？ 选择可穿戴的物品，p 选择新捡到的盔甲。You cannot wear armor over a cloak.，先把外套脱下。按 T，看提示已经脱掉了，再穿盔甲，然后再次 W 穿上外套。这是可以看见 AC 降为 3，盔甲不错。

我们的运气不错。如果发现 AC 上升，多半是盔甲被诅咒（cursed），并且被诅咒的兵器和物品无法脱下。

                                             ----------------
                                            #@d.............|
  -----                                     f|...............           ....
  |..<|                                  #### ..............|
  |..(|                                  ####+ .............+
  |...|                                  ##    --------- ----
  |...|                                  ##
  |...-#                                 ##
  -----#     ---------                   ##
       ###   |.......|      -----+----  ###
         #   |.......|      |.........###
         #   |.......|      |.......{|####
         ####|........######-........|
            #-.......|      |........|
             |.......|      |..>.....|
             ---------      |........|
                            ----------

Petergu the Evoker             St:9 Dx:8 Co:16 In:17 Wi:14 Ch:11 Neutral
Dlvl:1 $:0 HP:10(12) Pw:7(7) AC:3 Xp:1

继续探险，开门看见一只豺狼。直接按向右移动的键（l）攻击它。几步之后，狼被打死，你也只剩 8 HP 了。

当然，见到怪不掂量一下自己的能力就直接攻击并不是好的策略。

比如如果正面击打一个冰冻之眼（Frozen eye），你会被冻住若干回合，然后被旁边路过的小怪打死。

可以按 . 原地休息，这会缓慢回复失去的 HP。

You kill the jackal!  You hear water falling on coins.



                                             ----------------
                                            f@%.............|
  -----                                     #|...............           ....
  |..<|                                  #### ..............|
  |..(|                                  ####+ .............+
  |...|                                  ##    --------- ----
  |...|                                  ##
  |...-#                                 ##
  -----#     ---------                   ##
       ###   |.......|      -----+----  ###
         #   |.......|      |.........###
         #   |.......|      |.......{|####
         ####|........######-........|
            #-.......|      |........|
             |.......|      |..>.....|
             ---------      |........|
                            ----------

Petergu the Evoker             St:9 Dx:8 Co:16 In:17 Wi:14 Ch:11 Neutral
Dlvl:1 $:0 HP:8(12) Pw:7(7) AC:3 Xp:1

可以看到提示狼被打死。同时你听到一些声音。

You hear water falling on coins. 的意思是本层有喷泉（中间屋子里的 {）

地上的 % 是狼的尸体。杀死怪物后你多半希望吃掉尸体，否则没有食物会饿死。移动到 % 上方并按 e，选择 y 吃掉。

You see here a jackal corpse.

There is a jackal corpse here; eat it? [ynq] (n) y

This jackal corpse tastes okay. You finish eating the jackal corpse.

当然，不是什么都能吃。有些怪的尸体会让你中毒。如果因此呕吐，你会变得更饿。然而有些尸体可以让你获得某些能力（比如抵抗中毒、抵抗寒冷等）。如果触摸鸡头蛇怪（cockatrace）的尸体，会变成石头。

这时，可以看到我们吃饱了，变得 Satiated。

这时继续大量吃东西可能会被噎死。

同时发现，有一扇锁着的门。我们目前没有撬锁工具，只能踢开。按 Ctrl-D 然后方向 h 踢门几次。

This door is locked.



                                             ----------------
                                            #-..............|            -----
  -----                                     #|.f.............           .....|
  |..<|                                  ####|..............|
  |..(|                                  ####+@.............+
  |...|                                  ##  ----------- ----
  |...|                                  ##
  |...-#                                 ##
  -----#     ---------                   ##
       ###   |.......|      -----+----  ###
         #   |.......|      |.........###
         #   |.......|      |.......{|####
         ####|........######-........|
            #-.......|      |........|
             |.......|      |..>.....|
             ---------      |........|
                            ----------

Petergu the Evoker             St:9 Dx:8 Co:16 In:17 Wi:14 Ch:11 Neutral
Dlvl:1 $:0 HP:9(12) Pw:7(7) AC:3 Xp:1

我们踢门多次门才打开，中途来了两只狼，第一只被猫一击咬死，第二只也被猫一击咬死。

This door is locked.

WHAMMM!!! Rex misses the jackal.

WHAMMM!!! Rex bites the jackal. The jackal is killed!

WHAMMM!!!

WHAMMM!!!

WHAMMM!!!

As you kick the door, it crashes open! The jackal bites!

Rex misses the jackal.

You miss the jackal. The jackal bites! Rex bites the jackal.

The jackal is killed!

注意到图右边部分显示的房间了吗？因为从隔壁房间的门口“路过”，视野所限只能看到屋内的一部分。字符界面不代表没有光照的处理。

一层探险结束后，捡到了一些其他护身符和戒指等。因为捡东西过多，处于 Burdened 状态。走到 > 的位置，按 > 下行到下一层地牢。

负重是非常不好的，但本人就是不想扔东西。

You fall down the stairs.

下楼的时候宠物如果在你身边一格以内，会和你一起下去。否则会被留在原地，并逐渐野化

这时候，背包里已经有一些不知道是什么的装备了。

r - a sapphire ring

t - a pyramidal amulet

鉴定物品（Identification）是 NetHack 中重要而困难的。最基础的方法就是亲自体验：P - ? - t 戴上护身符。好像没什么变化，仍然不知道是什么。按 R 移除。戒指也一样，什么也没鉴定成。只能作罢。

鉴定物品的高级技巧有很多，比如在商店观察卖出价格。

NetHack 中每种戒指、护身符和卷轴有不同的外观。每一局游戏中外观和功能的对应保持不变，但不同局游戏的这种对应是随机的。这一点并不是 trivial 的，因为，比如说，戒指的材质（金属、石头等）不一样，从而决定了每一局中玩家能通过变身（polymorph）并吃掉戒指获得何种永久属性。

继续同样的探险。看到商店，但我们没有钱，只好离开。

"Hello, petergu! Welcome to Akhalataki's used armor dealership!"

攻击商店老板是非常不明智的行为。但是，如果店内有死亡魔杖（Wand of death），可以用其将老板杀死并获得所有的物品。如果有许愿魔杖（Wand of wishing），可以许愿得到死亡魔杖。这二者的基础价格都是 1200，很容易被认出。

如果你是游客（Tourist），并且穿着夏威夷 T 恤（Hawaiian shirt），会被商店老板加价“宰客”。

宠物可以捡起商店中的物品并在店门外放下—— shoplifting。

You hear someone cursing shoplifters.

         #
        ##
        #
        #
--------|--
|.......@.|
|[[[[[[f@[|
|[[[[[)[[)|
|))[[.[[[[|
-----------

捡到并戴上一枚红宝石戒指后，发现这是被诅咒的——摘不下来了。然而还不知道它是干什么的，但多半不是什么好东西。

E - a cursed ruby ring (on right hand)

You see here a blindfold.  You faint from lack of food.--More--

                                       ------
                                       |....|
                                      #......###
                           ------######|....|  ##     ------
      ----------------     |....-######|....|   ###   |....|
      |..............-     |....|#     |....|     ####....F|
      .......@..F....|     |....|      |....|         |....-##
      |......f.......|     |..^..      --)---         ------ ###  ------------
      ---.------------     -|-.--        #                     ###..{........|
         ###                #            #####                    |..........|
           ####             #                ##                   |........>.|
             -.----      ---.-      ----------.--                 ------------
             |....|      |...|      ............|
             |....|      |...|      |...........|
             |....|      |...|      |.<.........+
             |.....######-...|      |...........|
             ------      -----      -------------



Petergu the Evoker             St:8 Dx:8 Co:16 In:17 Wi:14 Ch:11 Neutral
Dlvl:3 $:28 HP:15(15) Pw:23(23) AC:1 Xp:2 Fainted Burdened Deaf

不久之后，因饥饿晕倒。戴上的戒指多半是 Ring of hunger。按 e 吃一个鸡蛋，回过神来。正好背包里有解除诅咒的卷轴，读一个：按 r - ? - k。

As you read the scroll, it disappears.--More--

You feel like someone is helping you. Rex misses the lichen.--More--

然后，戒指就可以摘下来了。

又饿了，吃个鸡蛋结果变质了。

Blecch! Rotten food! The world spins and goes dark.

又走了一阵，没有吃的了（因为尸体都让猫吃了），已经晕倒，怎么办？只有神能救我们了。

Wizard Needs Food, Badly!

#pray

You begin praying to Thoth. You are surrounded by a shimmering light.--More--

You finish your prayer. You feel that Thoth is well-pleased.--More--

Your stomach feels content.

祈祷是非常强大的——看，这就饱了。但是如果频繁祈祷，神会对我们生气。

原地祈祷三次，就会被雷劈死。

                                                 --------
                            ---------------######........#
           --------         |..@>.........|#     |......|#     -----
           |......|         |.............|#    #-..B...|#     |...|
           |...:..|         ---|-----------#    #|......|#     |...|
           |......|            #   ##   ####    #|.......##    |...|
           |......|         ##*##########       #.......| #####....|
           |......|        ##  #    #####     ###-------- #    |...|
           -----|--       ##   #        #     # #         #    -|---
                #         #  ###        ##    ##          #     #
                #        ##  #           #    #           #     #
                #        #---.------     #    #           #     #
                #        #|........|    -|----#           ##    ##
                #       ##|........|    |..|>|#            ####--|---------
               ##     ### |........|    |....|#               #...........|
           ----.-     #   |<.......|    |....-#                |..........|
           |.....######   |........|    ------                 |..........|
           |...{| ######  .........|                           ------------
           ------         ----------

Petergu the Evoker             St:9 Dx:8 Co:16 In:17 Wi:14 Ch:11 Neutral
Dlvl:4 $:62 HP:15(15) Pw:23(23) AC:1 Xp:2 Burdened

发现，本层有两个下楼梯。这是因为有一个是通往支线任务地精矿洞（Gnomish Mines）的。这个支线较难，如果不是女武神等前期强角色基本不要擅自进入。支线地图是这种风格，周围都是地精 G。稍微进去一下，立刻被围攻。幸亏猫比较强打死几只怪。还剩 7 HP 逃了出来。当然，矿洞里装备也很多，我们换了双鞋子，现在 AC 是 0，而代价是沉重的盔甲和行动不便。

b - an uncursed +0 cloak of magic resistance (being worn)

p - a +0 splint mail (being worn)

B - a +0 iron skull cap (being worn)

I - a +0 pair of hard shoes (being worn)

   ---
   |..--
 ---....- -
 |.......|.
  .........-
   -.......|
    -......|
     -..f..--
     --.....|
      -..G..|
   |....|...| ---
   | ----.......|
       -.@......|
      |.........|
      |.......---
      ..*.G.....
     ------------

下一层看到一个箱子。可以 #loot 抢劫。但箱子上锁了，所以可以踢几脚把锁打开。

这么做的代价是箱内的药水和易碎的魔杖会损坏。

THUD! You break open the lock!

You see here a large box.


                                                           -----
                  -----------     #########################....|
                  |.........|    ###########        #      |...|
                  |.........|    #------      ------       .....
                  |.........|    #.....| #####...<.|       |...|
                #`|..f..>...|    #|.....##    |...)|       --.--
                 #-...@.....+     |....|      |...)|         #
                 #-----------    #-.----      |....|         #
                 #####        ##  ##          |....|###      #
                   # ################        #---.--##############
                              #              `############ --.-+-|----
                   .                               ###     ..........|
                  |.                                       |.........|
                  |.                                       |...... ..|
                  |.                                       |.........|
                  ---                                      |.........|
                                                           -----------


Petergu the Conjurer           St:9 Dx:8 Co:16 In:17 Wi:14 Ch:11 Neutral
Dlvl:5 $:75 HP:25(25) Pw:31(31) AC:0 Xp:3 Burdened

然而箱子是空的。

你也可以往箱子里放一些东西。

下一层看到了一些类似宫殿的东西。中间有先知，可以花 50 块钱向它咨询（#chat）。

You see here a statue of a plains centaur.


                                                   -------
             ------------           ###############-....*|
             |..........|        ####              |.....|
             ...........| ############        #####-.^....
             |.....<....|##     #-----|-------#    -------
             -|----------#       |C.........C.#
              ############       |.....C.....|#
                                 |...-----...|
                                 |...|.{.|...|
                                 |..@|{.{|C..|
                                 |.....{.|...|
                                 |..f-----...|
                                 |.....C.....|
                                 |C.........C|
                                 -------------




Petergu the Conjurer           St:9 Dx:8 Co:16 In:17 Wi:14 Ch:11 Neutral
Dlvl:6 $:75 HP:25(25) Pw:31(31) AC:0 Xp:3 Burdened

下一层，遇到一只巨大的蝙蝠（Giant bat），被咬到残血后我们逃跑，但是它追了过来，狭路相逢。

The giant bat bites!--More--

                                          -----                       -----
                                          |...|                #######-...|
                                         #|....#################      |...|
                                         #-...|#                      |...|
                                         #|...|                       -...|
                                         #|...|                       |.>.|
                                         #-----                       ---.-
                                         ##                              #
                                         #                               *
                                        ###                              #
                                         # #                             #
                                         ###                             #
                                           #                          -|-|-
                                           #                          |...|
                                           #                          |...|
                                          +######B@######`            ...<|
                                         .|#                          -----
                                         .-#
                                         --#

Petergu the Conjurer           St:9 Dx:8 Co:16 In:17 Wi:14 Ch:11 Neutral
Dlvl:7 $:88 HP:5(29) Pw:43(43) AC:0 Xp:4 Burdened

You die...--More--

Do you want your possessions identified? [ynq] (n)

于是毙命此地。

死后游戏会问你要不要看看你的东西到底是什么。你可以看一眼。

 L - 3 uncursed scrolls of blank paper
 R - an uncursed scroll of fire
 Spellbooks
 l - a blessed spellbook of force bolt
 m - an uncursed spellbook of create monster
 x - an uncursed spellbook of slow monster
 Potions
 f - an uncursed potion of gain ability
 g - an uncursed potion of monster detection
 h - an uncursed potion of healing
 G - an uncursed potion of sickness
 O - an uncursed potion of water
 S - a blessed potion of sleeping
 Rings
 d - an uncursed ring of fire resistance
 e - an uncursed ring of invisibility
 r - an uncursed ring of cold resistance
 E - an uncursed ring of aggravate monster
 H - an uncursed ring of sustain ability
 Wands
 c - a wand of magic missile (0:4)
 Tools
 n - a magic marker (0:55)
 (2 of 3)

通常，如果看了，就会发现背包有至少一件能避免死亡的物品（比如残血之后喝个药之类的，或者这个 magic missile 看起来很 promising）。然而生命只有一次，这就是 Roguelike。

                       ----------
                      /          \
                     /    REST    \
                    /      IN      \
                   /     PEACE      \
                  /                  \
                  |     petergu      |
                  |      88 Au       |
                  |   killed by a    |
                  |    giant bat     |
                  |                  |
                  |                  |
                  |       2021       |
                 *|     *  *  *      | *
        _________)/\\_//(\/(/\)/\//\/|_)_______


Goodbye petergu the Wizard...

You died in The Dungeons of Doom on dungeon level 7 with 704 points,
and 88 pieces of gold, after 3310 moves.
You were level 4 with a maximum of 29 hit points when you died.

尾声

通过本菜鸡的一局典型游戏流程，希望你已经了解了 NetHack 的基本操作，并能够在地下城中跌跌撞撞地存活一段有限大的时间。仍然有非常多重要的机制和操作本教程中没有提及（甚至 BUC 都没有说），这就要各位自己寻找了。对于一般玩家，要胜任这种游戏，作弊、剧透甚至是阅读源代码都是有必要而并不可耻的行为。

参考资料

• https://nethackwiki.com
• https://www.zhihu.com/question/40177337
• https://www.melankolia.net/nethack/nethack.guide.html
• https://nethack.org/
• https://github.com/regymm/nethackassistant
• https://alt.org/nethack/

开始

大一的时候讲座推荐的软件是 Origin，画图、拟合等虽然方便，但完全鼠标操作，并且只有 Windows 上能运行，Wine 上有时会遇到个别功能不好用，很影响体验（当时我的电脑配置不好，玩不起虚拟机）。思来想去，还是觉得 Python 比较自然，于是故事就这样开始了。

在一级、二级大物中，需求基本是：散点画图（有时是对数）、线性拟合、组合的画图，以及不确定度计算和一般的数值计算。输入输出方面，要手工输入有时候多达几页的手写数据，画出来的图打印上交、计算出的结果手写进实验报告。

Python 做这些事情其实都不困难。画图用 Matplotlib 非常方便，也可以直接保存图片。数据计算自然是 NumPy。线性拟合的话，最初选择了 SciPy。输入输出还是比较基本，从文件读入。

于是，第一个实验「自由落体」的数据和处理就是这样：

#光电门间距 H cm
#数量级
e -2
90.0	90.0	90.0	80.0	80.0	80.0	70.0	70.0	70.0	60.0	60.0	60.0	50.0	50.0	50.0	40.0	40.0	40.0	30.0	30.0	30.0	20.0	20.0	20.0
#时间差 t ms
e -3
331.6	331.5	331.8	307.9	307.9	307.9	282.9	282.8	282.9	255.8	255.7	255.7	226.9	227.0	226.9	195.2	195.2	195.2	159.9	159.9	159.8	119.2	119.1	119.2

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import math
#avoid font problem
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
#read data
data = []
#order of magnitude
oom = 0
fin = open('./data.txt', 'r')
for i in fin.readlines():
    if i[0] == '#':
        #line start with # is comment
        pass
    elif i[0] == 'e':
        oom = int(i.split()[1])
    else:
        data.append(np.array([float(x) * pow(10, oom) for x in i.split()]))
        oom = 0
# print(data)
### main processing ###
l = len(data[0])
x = data[1]
y0 = data[0]
data.append(y0 / x)
y1 = data[2]
slope, intercept, r_value, p_value, std_err = stats.linregress(x, y1)
# z = np.polyfit(x, y1, 1)
s_slope = slope * math.sqrt((r_value ** -2 - 1) / (l - 2))
s_intercept = s_slope * math.sqrt(np.mean(x ** 2))
print('linear regression:' )
print('slope:', slope)
print('intercept:', intercept)
print('r-value:', r_value)
print('p-value:', p_value)
print('std-err:', std_err)
print('r-squared:', r_value ** 2)
print('斜率标准差：', s_slope)
print('截距标准差：', s_intercept)
print('算得重力加速度：', 2 * slope)
#plot
plt.scatter(x, y1, marker='*', color='black', label='原始数据')
# plt.plot(x, y1, '--', color='green', label='光滑曲线')
plt.plot(x, intercept + slope * x, 'r', label='拟合直线')
plt.xlabel('时间 t/s')
plt.ylabel('平均速度 H/t / m/s')
plt.legend(loc=4)
plt.title('小球下落平均速度与时间关系图')
plt.savefig('pic.png')
plt.show()

只是画了张图就这么麻烦，很明显，除了练习了 Python 之外，和 Origin 相比生产力负提升。

之后的问题就是简化这些过程了。

两年之后

经过一年多的开发，我将一些常用的画图和数据处理操作打包成库，并添加了方便的文件输入和自动生成 docx 文件的功能。同时将 Python 包 physicsexp 发布到了 PyPI（和 AUR 一样，在 PyPI 发布包的门槛几乎没有）。

这里以三级大物 β 射线吸收为例。现在，读入文件只需要这样：

fin = open('./data.txt', 'r', encoding='utf-8')
pos = readoneline(fin)
N = readoneline(fin)
Al_num = readoneline(fin)
Cnt = readoneline(fin)
fin.close()

数据做图也只要一行代码，一张图上多个曲线也只是一个参数的事，比如这是一张有三条线的图：

simple_plot(Momentum, Emeasure, show=0, issetrange=0, dot='+', lab='测量动能')
simple_plot(Momentum, Eclassic, show=0, issetrange=0, dot='*', lab='经典动能')
simple_plot(Momentum, Erela, dot='o', save='1.png', issetrange=0, xlab='$pc/MeV$', ylab='$E/MeV$', title='电子动能随动量变化曲线', lab='相对论动能')

画图并线性拟合也是非常常见的操作，于是也加入了库：

slope, intercept = simple_linear_plot(Al_Real, CntLn, xlab='质量厚度$g/cm^{-2}$', ylab='选区计数率对数 (射线强度)', title='半对数曲线曲线', save='3.png')
print(-slope)
print(math.log(1e4) / (-slope))
print((math.log(Cnt[0]) - 4 * math.log(10) - intercept) / slope)

最后，一行代码将所有的数据和图片生成直接可以打印的 docx 文件，包含名字和日期：

gendocx('gen.docx', '1.png', '2.png', '3.png', 'slope, intercept: %f %f' % (slope, intercept))

文件如图所示，可以直接拿去打印了：

下面是整体代码：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from physicsexp.mainfunc import *
from physicsexp.gendocx import *

# read data
fin = open('./data.txt', 'r', encoding='utf-8')
pos = readoneline(fin)
N = readoneline(fin)
Al_num = readoneline(fin)
Cnt = readoneline(fin)
fin.close()

# data process

# calculated calibration values in class
a = 2.373e-3
b = -.0161
dEk = .20

c0 = 299792458.
MeV = 1e6 * electron

Emeasure = a * N + b + dEk
x0 = .10
R = (pos - x0) / 2
B = 640.01e-4
Momentum = 300 * B * R
Eclassic = ((Momentum * MeV)**2 / (2 * me * c0**2)) / MeV
Erela = np.array([math.sqrt((i * MeV)**2 + (me * c0**2)**2) - me * c0**2 for i in Momentum]) / MeV
print('pos\t', pos)
print('R\t', R*100)
print('pc\t', Momentum)
print('N\t', N)
print('Eclas\t', Eclassic)
print('Erela\t', Erela)
print('Emes\t', Emeasure)

simple_plot(Momentum, Emeasure, show=0, issetrange=0, dot='+', lab='测量动能')
simple_plot(Momentum, Eclassic, show=0, issetrange=0, dot='*', lab='经典动能')
simple_plot(Momentum, Erela, dot='o', save='1.png', issetrange=0,
            xlab='$pc/MeV$', ylab='$E/MeV$', title='电子动能随动量变化曲线', lab='相对论动能')

Len = 150
Cnt = Cnt / Len
simple_plot(Al_num, Cnt, xlab='铝片数', ylab='选区计数率 (射线强度)',
            title='$\\beta$射线强度随铝片数衰减曲线', save='2.png')
CntLn = np.log(Cnt)
# d = 50 mg / cm^2
d = 50
Al_Real = Al_num * d
slope, intercept = simple_linear_plot(Al_Real, CntLn, xlab='质量厚度$g/cm^{-2}$', ylab='选区计数率对数 (射线强度)',
                                      title='半对数曲线曲线', save='3.png')
print(-slope)
print(math.log(1e4) / (-slope))
print((math.log(Cnt[0]) - 4 * math.log(10) - intercept) / slope)

gendocx('gen.docx', '1.png', '2.png', '3.png', 'slope, intercept: %f %f' % (slope, intercept))

整个代码不含空行和注释共 46 行，而上面的自由落体代码 45 行。可见包装程度还是不错的。先计算然后画这三张图，写上面的代码和 Origin 相比哪个更快呢？还是看个人习惯，反正我是比较习惯代码。至少，这说明了大物实验需要的数据处理还是有很多相似点的，以至于打包一些函数可以提高一些生产力。

当然，这只是一个例子，对于个别实验，不管怎么处理都是要多花写时间的（直流辉光等离子体，说的就是你）。

你可能会问，为什么没有误差分析的功能。这确实是一个问题：计算 A 类和 B 类不确定度等不同实验差别很大，水平有限，我能做的除了将常数打表提供最基础的功能外，好像就没什么了。并且，开发得差不多时已经到二级中期了，算不确定度也不常见了（所以，别被一级吓怕了），所以这部分也没怎么测试过，属于 TODO。

迟到的 Jupyter Notebook

以上还是标准的 Python，但五级大物时，我尝试了仅一次就发现明显 Jupyter Notebook 更适合做类似的工作——尽管它不能用 Vim 编辑代码！这下子，数据直接输入在 Notebook 里就好了，画图也是所见即所得，不用等一张一张弹出来了。而进行临时的运算也不必影响正常流程。如图：

既然都到了 Jupyter，如果多人合作的话，JupyterHub 是非常不错的选择，可以多个人在一台服务器上使用 Jupyter Notebook。我之前配置的是每个用户一个隔离的 Docker 容器，里面的 Python 已经装好了包，可以直接使用，同时挂载了一个共享空间可以分享写好的 Notebook。其实 JupyterHub 有用 Github 帐号登录之类的权限管理功能，但当时我们是几个认识的人合作，就没有管这些。

具体的代码在我的 GitHub 上，如果有人在写大物实验报告的过程中无聊了想找个地方摸鱼浪费点时间，不妨来看看。

总结

如果您想尝试用 Python 处理大物实验数据，我可以比较负责地说对于 95% 以上的实验是完全没有问题的。使用 NumPy 和 SciPy 计算，Matplotlib 做图，配以 docx 生成、Jupyter Notebook 或 JupyterHub 团队合作，可以比较轻松（但不意味着节省时间）地完成所有需要的操作，并可以通过包装库提高效率。

之前也有学长学姐尝试过类似的大物实验自动化项目，但因为暂时无法全部找到并对比，这里就不说了。大一的时候确实是想搞一套自动化程度很高的东西，但水平实在有限，并且不同的实验处理过程不太一样，一己之力完成每一个实验专属的程序也不太现实，所以结果就是自己挖了个坑并跳进去出不来：有时想想，或许还是左手卡西欧 991 右手座标纸来得快一些呢！

注：由于原本目的是用于 LLVM IR，所以使用了 clang 来编译内核，没有这种需求可以完全无视 clang。

编写内核模块

超简单的内核模块编写方法

为了创建内核线程，我们可以构建一个内核模块，由它来执行相关的函数。构建一个基础的内核模块非常简单，这里我们 参考 The Linux Kernel Module Programming Guide：

/*
 *  hello_mod.c - The simplest kernel module.
 */
#include <linux/module.h>	/* Needed by all modules */
#include <linux/kernel.h>	/* Needed for KERN_INFO */

int init_module(void)
{
	printk(KERN_INFO "Hello world.\n");

	/*
	 * A non 0 return means init_module failed; module can't be loaded.
	 */
	return 0;
}

void cleanup_module(void)
{
	printk(KERN_INFO "Goodbye world.\n");
}

然后再加上一个简单的 Makefile：

# obj-m 告诉构建系统以模块编译，编译目标是 hello.ko
obj-m += hello.o
hello-objs := hello_mod.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

这样，一个超简单的内核模块就完成啦！

为了编译内核模块，我们需要有头文件，在 Ubuntu 上可以安装 linux-headers-<version> 来实现。又或者你像我一样需要用到 clang ，那就下载 Linux 源码重新编译安装（PS：如果全量编译搭配 VSCode 补全体验很好）。在这之后，运行 sudo make CC=/path/to/clang 就可以编译这个模块了。编译完成后，会发现目录下多出来一个叫 hello.ko 的文件，它就是我们编译得到的内核模块。

在这个模块中，init_module 会在模块被载入时调用，而 cleanup_module 会被模块被卸载时被调用。通过 insmod hello.ko，可以载入它，而 rmmod hello 可以卸载这个模块。printk会将日志打印到内核的日志中，调用 dmesg 可以看到模块打印的欢迎和告别信息。

Tic-Toc …

虽然已经编写了一个模块，但是它啥都干不来，我们还得实现计时功能。在编写用户态程序时，语言库里通常有获取当前时间的函数，内核也一样。我们可以通过ktime.h 中的 ktime_get 来获取时间，大概的逻辑如下：

ktime_t start, end;
u64 dur_ns;
start = ktime_get();
foo(); // 被测试的函数
end = ktime_get();
dur_ns = ktime_to_ns(ktime_sub(end, start));
printk(KERN_INFO "foo runtime: %lluns", dur_ns);

看得出来，内核里的函数接口也很平易近人，简单几行就把我们最核心的算法实现完了。

怎么使用它？

现在，我们已经知道了如何统计时间，还得设计一个接口来让人触发相关的功能。虽然让模块在初始化时运行也不是不行，但是扩展性就变得太糟糕了。我决定用 procfs 来设计一个接口。Procfs 来源于 UNIX 哲学中一切皆文件的思想，它把系统运行时的一些信息用文件目录的形式展示出来，这样可以通过简单的文件操作（比如 cat、管道等）来访问和控制系统相关的参数，你可以通过 /proc/ 目录访问里面的内容。

在初始化的时候，我们通过 proc_mkdir 和 proc_create 可以像普通的文件系统一样在 /proc/ 目录下创建目录和文件：

// 在 /proc/ 下创建一个目录
if ((root = proc_mkdir(proc_dirname, NULL)) == NULL)
    return -EEXIST;
// 在 /proc/<proc_dirname>/ 目录下创建一个文件，并让该文件使用 bench_fops
if (proc_create(filename, 0444, root, &bench_fops) == NULL)
    return -ENOMEM;

这里的 bench_fops 是一个类型为 struct file_operations 的结构体。它能为这个文件注册功能，比如 open、read、write 等。在内核中设计一个文件系统也需要实现类似的操作，万幸的是，procfs 下不需要实现 POSIX 语义。在这里，我希望只要有 write 被调用时，就会运行我的测试程序，这样我只要在 shell 中用 echo 和管道重定向就能调用它了：

// 所有参数都用不到，我们只希望触发一次测试
ssize_t run_bench(struct file *filp, const char __user *buf,
                  size_t len, loff_t *ppos) {
    // 测试相关的函数
    foo();
    // 返回长度和参数一样代表写入成功
    return len;
}

// 这是 C99 加入的结构体指定初始化，其它成员默认为空。
// 这意味着该文件只支持写
static const struct file_operations bench_fops = {
	.owner		= THIS_MODULE,
	.write		= run_bench
}

模块功能已经完成了，最后得给模块取个好听的名字。我把英文中表示时间流逝的 tic-toc（tick-tock）和表示内核的 kernel 合在一起，就变成了 tiktok。

链接函数

我本以为编写了寥寥数行 tiktok，将 LLVM IR 编译到目标文件再链接到模块上便可以了。然而经过测试，这样做会导致进程一直无法返回。经过反汇编比较了同一段代码在内核模块里编译的结果和外部产生的结果后，我才理解是因为编译选项不同导致了内存布局的差别，这使得默认参数编译的代码无法在内核中使用。由于内核编译选项繁杂，根据不同架构也会产生不同的选项，我们必须把代码放置进内核的构建系统内来让它产生内核想要的汇编（现在的内核中禁用了浮点数，所以浮点计算就无法测试了）。对于普通的 c 文件，只需要在 Makefile 中加上几句，比如：

hello-objs := hello_mod.o another_file.o

但是 LLVM IR 还需要一些技巧来骗过编译系统才行。我把自制编译器产生的 IR 文件改成了 .c 文件，并修改了 Makefile：

hello-objs := hello_mod.o another_file.o
CFLAGS_another_file.o := -O0 -x ir

内核编译系统会在产生 another_file.o 时将这里的 -O0 -x ir 传给编译器，这让编译器知道接下来要读的语言是 LLVM IR，并且关掉大部分优化（这样才能体现出自制编译器中的优化效果）。由于 LLVM IR 编译时会忽略一些选项，所以我让编译器在产生中间代码时就加上了属性来确保编译正确。

虽然知道了怎么链接函数，但是内核是无法链接库函数的，而 IO 函数也无法直接在内核中使用。对此，我们可以修改相关的函数，在 tiktok 实现相似的功能。比如， printf 可以转换成 printk，而 exit 可以换成内核中的 do_exit。malloc 和 free 比较复杂，内核中的内存可没有进程那样退出就自动释放这么好的待遇。所以，在内核中必须得手动维护每一次分配和释放，避免出现事故导致 panic 或者内存泄漏（当然我很懒，课程不需要我就都没实现）。

一个小测试

既然实现完了，我们进行一个测试来检验 tiktok 的功能：

#define OUT_LOOP 100
int main(void){
    int i;
    int a;
    int j;

    a = 2;
    j = 0;
    while (j < OUT_LOOP){
        i = 0;
        while(i < 1000000) {
            a = a * i + 1;
            i = i + 1;
        }
        j = j + 1;
    }
    return a;
}

上面是一段进行一些无意义计算的代码，我们修改 OUT_LOOPS 的大小（100、99、98）来比较不同方法的灵敏度。除了普通的 time 测量，我还加入了一组使用 taskset(1) 的对照组。 taskset 控制了程序的亲核性，这使得程序总能被调度到同一个核上，减少了跨核导致的缓存失效开销。为了减少随机误差，每种配置我都运行进行了 100 次函数得到虚列。实验数据可以在这里查看。要反映灵敏度，我们无法直接拿不同方法的结果进行比较，而是要在同一个方法内看看能否显著区分出不同循环次数带来运行时间差距（约为 1%~%2）。短暂尝试了复习概率论和数理统计后，我谷歌到了 K-S 检验 （Kolmogorov-Smirnov test），对于两组输入数据它可以检验它们是否同分布。这里我们假设实际运行时间是固有的，而调度等开销造成的是一个均匀同分布的随机误差。如果测量工具对两种配置得到的两组数据无法拒绝同分布假设，我们可以认为它无法准确得检测出程序性能的差异（统计全忘光了，我不知道我在说啥，如果有误欢迎指正）。我使用了 scipy.stat.kstest 来进行了 K-S 检验，结果如下表（p 值小于 0.05 拒绝同分布假设）：

gg，完全没有用，连同一个配置都分不清楚。虽然占据了一个核，但是虚拟机本身也在被调度，这个误差并不满足我们的假设。但是，还不能放弃，还可以抢救一下，我把 tiktok 放裸机上测试了一下，得到的结果如下：

在裸机上，tiktok 的优势就体现了出来，它比 taskset 要更加灵敏一点。然而裸机上使用 perf stat就可以看到更加精确的指令数结果…

小结

虽然 tiktok 被证明没有太多实际价值，但是研究的过程中我还是学到了挺多 Linux 内核编译系统的知识。我想分享一下这个过程，是因为我觉得这很有趣。如果你对 tiktok 感兴趣，它在我的 Github 上，它比本文介绍的要稍微复杂一丢丢。如果你想要了解更多关于 Linux 内核的内容，网络上有许多很好的资料。至于编译课程，我估计细小的差距是没法在虚拟机里准确测量了，还是要尽量避开这种测试样例（Windows 上应该也有工具，但是不太方便）。

偶尔看到了复式记账这个概念，对精细记账的我而言很受用，选择 Beancount 这样的开源工具的原因莫过于账本数据完全由自己掌握，而不是被各大 APP 所保管。本文从一次个人实践的角度来说明一下复式记账的使用。

本篇文章是一个从零开始的个人实践记录，涵盖 文件组织 -> 基本账本书写 -> 爬取一卡通数据并自动记录，供同样使用 Beancount 的同学做参考，但此实践并不一定完全合乎其他人的使用习惯，如果有其它记录策略也是可以的。本文内容基于读者对复式记账和 Beancount 语法有一定了解的情况下撰写的，关于复式记账的概念和一些诸多基本功能介绍，可以参考阅读以下文章：

• 文本记账综述、复式记账开源工具比较
• Beancount 复式记账（一）：为什么

开始！

安装使用

Beancount 是一个 Python 实现的开源工具，在本地即可运行，首先从 PyPI 获取：

pip install beancount fava

其中 beancount 是核心包，包含核心的命令行工具；fava 是网页可视化工具。 这里有一个fava 示例账本 ，对应的 Beancount 源代码可以在 Bitbucket 上下载。 本文的示例账本以及可视化可以在该仓库查看。

克隆该仓库，在命令行中使用 fava main.beancount。

$ fava main.beancount
Running Fava on http://localhost:5000

打开浏览器即可看到可视化账本。

文件结构

Beancount 支持 include 语法来拓展账簿，个人采用按时间划分文件，辅之特殊事件（比如旅游）单独记录的方法，目录结构如下：

.
├── 2018
│   └── ...
├── 2019
│   └── 01.beancount
│   └── 02.beancount
│   └── 03.beancount
│   └── 04.beancount ; 注释用分号
│   └── xx.event.beancount ; 单独针对某一特别事件的账本，比如旅游
│   └── 05.beancount
│   └── 06.beancount
│   └── 07.beancount
├── accounts.beancount ; 记录初始账户信息
├── main.beancount ; 主文件

账本书写

账户信息设置

首先要定义账户，即文件 accounts.beancount，Beancount 系统中预定义了五个分类：

• Assets 资产：本人按照账户类型:国家:金融机构名字:具体账户的策略划分，时间是开户时间，比如：

  2017-01-01 open Assets:CN:Bank:BoC:C1234 CNY ; 学校银行卡
  2017-01-01 open Assets:CN:Card:USTC CNY ; 一卡通
  2017-01-01 open Assets:CN:Web:AliPay CNY ; 支付宝
  2017-01-01 open Assets:CN:Web:WeChatPay CNY ; 微信支付
  

  有一类针对 AA 付款或者个人向自己借款的账户，需要专门记录。

  2017-01-01 open Assets:Receivables:X ; 对 X 的应收款项
  

• Liabilities 负债：本人主要是信用卡和向他人借款的账户，比如：

  2017-01-01 open Liabilities:Payable:X ; 对 X 的债务
  2017-01-01 open Liabilities:CreditCard:CN:BoC:C1111 CNY ; 信用卡
  2017-01-01 open Liabilities:CreditCard:CN:Huabei CNY ; 花呗
  

• Equity 权益（净资产）：目前只有一个用于平衡开户的时候账户资金的权益。

  1990-01-01 open Equity:Opening-Balances
  

• Expenses 支出：支出就非常的多样化，可以根据自己需求分门别类，比如：

  2017-01-01 open Expenses:Clothing ; 包括上衣，裤子和装饰，袜子，围巾，帽子
  2017-01-01 open Expenses:Shoes ; 鞋
  2017-01-01 open Expenses:Food:Dinner
  2017-01-01 open Expenses:Food:Lunch
  2017-01-01 open Expenses:Food:Breakfast
  2017-01-01 open Expenses:Food:Fruits
  2017-01-01 open Expenses:Food:Nightingale ; 校门口夜宵
  2017-01-01 open Expenses:Food:Drinks
  2017-01-01 open Expenses:Food:Snack ; 杂食、零食
  

  等等……

• Income 收入：收入也可以根据自己的实际收入来源来建立账户，比如：

  2017-01-01 open Income:Salary:XXX
  2017-01-01 open Income:Salary:Others
  2017-01-01 open Income:Others
  

主文件设置

然后设置主文件 main.beancount 内容，主文件任务是设置全局变量，然后去涵盖各个子账本：

option "title" "取个霸气的名字吧" ; 账簿名称
option "operating_currency" "CNY" ; 账簿主货币
option "operating_currency" "USD" ; 可以添加多个主货币

include "accounts.beancount" ; 包含账户信息

; 每个月的账本
include "2020/06.beancount"
include "2020/07.beancount"

账户初始余额设置

在开始记账前，要设置每个账户的余额信息，采用以下方法来给每个账户设置余额/借记账单：

2019-01-01 pad Assets:Bank:CN:BoC:C1111 Equity:Opening-Balances ; 从 Opening-Balances 中划取 XX 帐到银行卡中
2019-01-02 balance Assets:Bank:CN:BoC:C1111    +xxx.xx CNY ; 银行卡余额为 xxx.xx

该语句的含义是无论 Assets:Bank:CN:BoC:C1111 之前余额多少，在 2019 年 1 月 2 日开始之前都调整到 xxx.xx CNY，差额从 Equity:Opening-Balances 来。注意两行之间差一天的时间，balance 断言界定为当天开始；一般储蓄卡余额为正，信用卡余额为负。

记账

• 基本记账，记账语法为：

  YYYY-mm-dd * ["Payee"] "Narration"
    posting 1
    posting 2
    posting 3
    ...
  

  比如：

  2019-01-01 * "Walmart" "在超市买两件衣服和晚餐"
    Expenses:Clothing 20 USD
    Expenses:Clothing 10 USD
    Expenses:Food:Dinner 10 USD
    Liabilities:CreditCard:US:Discover -40 USD
  

• 多货币转换使用 @@ 作为货币转换即可，货币 Beancount 会进行汇率计算，比如：

  2019-01-01 * "日本航空" "纽约 - 东京"
    Expenses:Transport:Airline 1000 USD @@ 110000 JPY
    Liabilities:CreditCard:JP:Rakuten -110000 JPY
  

• 账户结息：账户的利息肯定难以每日都记录，本人采用 pad+balance 断言，每隔一段时间结算一下。

• 分期付款：这是个常见的购买方式，需要单独设置开一个 Liabilities Account，手续费记利息支出，每个月账单出现的时候转移一下。Beancount 提供了一个插件 plugin "beancount.plugins.forecast 专门用来处理分期、订阅情况，可以用于每月费用的自动生成。

核账

本人选择每个月还款日核实一下账本，在 Fava 左侧 Balance Sheet 或者 Holdings 里可以看到各个账户当前的状况，如果和实际的账户金额有出入的话就需要点进对应账户查看每笔交易的情况，看看是否漏记或者错记。

用 Importer 自动记录一卡通消费

综述

Importer 个人理解的作用是将整理好的账单文本转化为 Beancount 记录的形式，即格式化 (表格，JSON 等) 账单 -> Importer -> Beancount 记录，Importer 在其中起到一个消费记录格式转化作用。

Beancount 作者对 Importer 有详细的文档叙述，即 Importing External Data in Beancount。Beancount 官方也有基于机器学习的智能 importer beancount/smart_importer。

而本人的需求是：

1. 利用校园一卡通门户系统获取每日的一卡通使用记录，并生成 CSV 记录。
2. 基于 CSV 的账单生成 beancount 文件。
3. 能够自行定制规则来实现对不同消费的分类。

将当日的一卡通消费生成为 CSV

爬取一卡通数据的代码为 crawler.py ，其作用为爬取当日的一卡通消费记录，并自定义规则区分早、午、晚餐，生成符合 Beancount 格式的 CSV。（代码可以直接运行）

import requests
from datetime import datetime
from bs4 import BeautifulSoup
import json
import codecs
import csv

name = 'XXX'  # 姓名
stu_no = 'PBXXXXXXXX'  # 学号
pwd = 'user_pwd'  # 统一身份认证密码

if __name__ == '__main__':
    # 利用统一身份认证登陆校园一卡通门户系统
    casurl = 'https://passport.ustc.edu.cn/login?service=http%3A%2F%2Fecard.ustc.edu.cn%2Fcaslogin'
    caspost = {'username': stu_no, 'password': pwd}  # 统一身份认证
    msg = ''
    s = requests.session()
    try:
        r = s.post(casurl, caspost)
    except Exception as e:
        msg = '{0} - INFO: USTC ecard CAS 登陆失败 {1}'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e)
    remaining = 0
    if not name in r.text:
        msg = '{0} - INFO: USTC ecard CAS 登陆失败 NOOOOOOOO!!!!!!!!'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
        print(msg)
    else:
        msg = '{0} - INFO: USTC ecard CAS 登陆成功'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
        print(msg)
        paylist = s.get('https://ecard.ustc.edu.cn/paylist')
        b = BeautifulSoup(paylist.text, features="lxml")
        token = b.findAll('input')[-1].get_attribute_list('value')[0]
        data = s.post(url='https://ecard.ustc.edu.cn/paylist/ajax_get_paylist', data={'date': '', 'page': ''}, headers={'origin': 'https://ecard.ustc.edu.cn', 'referer': 'https://ecard.ustc.edu.cn/paylist', 'sec-fetch-mode': 'cors', 'sec-fetch-site': 'same-origin', 'x-csrf-token': token, 'x-requested-with': 'XMLHttpRequest'})
        b = BeautifulSoup(data.text, features="lxml")
        table = b.find('table')
        th_index = []
        for th in table.findAll('th'):
            th_index.append(th.getText())
        year, month, day = datetime.now().year, datetime.now().month, datetime.now().day
        # 根据自己定义的规则判定早餐、午餐、晚餐
        payinfo = {'breakfast': {'loc': '', 'type': '科大餐饮', 'value': 0.0, }, 'lunch': {'loc': '', 'type': '科大餐饮', 'value': 0.0, }, 'dinner': {'loc': '', 'type': '科大餐饮', 'value': 0.0, }, 'transferin': {'loc': '一卡通充值', 'type': '', 'value': 0.0, } }
        flag = True
        for tr in table.findAll('tr'):
            line = []
            for td in tr.findAll('td'):
                line.append(td.getText())
            if line and flag:
                remaining = float(line[3])
                flag = False
            if not line:
                pass
            elif line[0] == '圈存机充值' and int(line[1]) == 0:
                payinfo['transferin']['value'] = float(line[4])
            elif line[0] == '消费':
                linetime = datetime.strptime(line[5], '%Y-%m-%d %H:%M:%S')
                if linetime > datetime(year, month, day, 6) and linetime < datetime(year, month, day, 10): # 判定为早餐
                    if line[6] in payinfo['breakfast']['loc']:
                        pass
                    else:
                        payinfo['breakfast']['loc'] += (line[6] + ' ')
                    payinfo['breakfast']['value'] += float(line[4])
                elif linetime > datetime(year, month, day, 10) and linetime < datetime(year, month, day, 14): # 判定为午餐
                    if line[6] in payinfo['lunch']['loc']:
                        pass
                    else:
                        payinfo['lunch']['loc'] += (line[6] + ' ')
                    payinfo['lunch']['value'] += float(line[4])
                elif linetime > datetime(year, month, day, 16) and linetime < datetime(year, month, day, 20): # 判定为晚餐
                    if line[6] in payinfo['dinner']['loc']:
                        pass
                    else:
                        payinfo['dinner']['loc'] += (line[6] + ' ')
                    payinfo['dinner']['value'] += float(line[4])
                elif linetime < datetime(year, month, day, 0):
                    break
                else:
                    mtmp = '{0} - INFO: 未知消费 {1}'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), line)
                    print(mtmp)
            else:
                mtmp = '{0} - INFO: 异常消费 {1}'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), line)
                print(mtmp)
        mtmp = '{0} - INFO: 卡内余额 {1}'.format(
            datetime.now().strftime('%Y-%m-%d %H:%M:%S'), remaining)
        print(mtmp)

        # CSV Part
        today = datetime.now().strftime('%Y-%m-%d')
        headers = ['记账日期', '收款人', '交易摘要', '人民币金额', '类别']
        csvinfo = []
        if payinfo['transferin']['value'] > 0:
            csvinfo.append({headers[0]: today, headers[1]: payinfo['transferin']['type'], headers[2]: payinfo['transferin']
                            ['loc'], headers[3]: "%.2f" % -payinfo['transferin']['value'], headers[4]: 'Transferin'})
        if payinfo['breakfast']['value'] > 0:
            csvinfo.append({headers[0]: today, headers[1]: payinfo['breakfast']['type'], headers[2]: payinfo['breakfast']
                            ['loc'], headers[3]: "%.2f" % payinfo['breakfast']['value'], headers[4]: 'Breakfast'})
        if payinfo['lunch']['value'] > 0:
            csvinfo.append({headers[0]: today, headers[1]: payinfo['lunch']['type'], headers[2]: payinfo['lunch']['loc'], headers[3]: "%.2f" % payinfo['lunch']['value'], headers[4]: 'Lunch'})
        if payinfo['dinner']['value'] > 0:
            csvinfo.append({headers[0]: today, headers[1]: payinfo['dinner']['type'], headers[2]: payinfo['dinner']
                            ['loc'], headers[3]: "%.2f" % payinfo['dinner']['value'], headers[4]: 'Dinner'})
        with open(today+'.csv', 'w') as f:
            f_csv = csv.DictWriter(f, headers)
            f_csv.writeheader()
            f_csv.writerows(csvinfo)

代码执行完毕后会生成 20XX-XX-XX.csv，例如 2020-07-02.csv：

准备 Importer Config

Beancount Importer Config 文件为 importers/ustc_card_importer.py。

#!/usr/bin/env python
import os
import sys
import beancount.ingest.extract
from beancount.ingest.importers import csv

beancount.ingest.extract.HEADER = ''

def dumb_USTCecard_categorizer(txn):
    # At this time the txn has only one posting
    try:
        posting1 = txn.postings[0]
    except IndexError:
        return txn

    # Guess the account(s) of the other posting(s)
    if 'breakfast' in txn.narration.lower():
        account = 'Expenses:Food:Breakfast'
    elif 'lunch' in txn.narration.lower():
        account = 'Expenses:Food:Lunch'
    elif 'dinner' in txn.narration.lower():
        account = 'Expenses:Food:Dinner'
    elif 'transferin' in txn.narration.lower():
        account = 'Assets:CN:Bank:BoC:C1234'
    else:
        return txn
    # Make the other posting(s)
    posting2 = posting1._replace(
        account=account,
        units=-posting1.units
    )
    # Insert / Append the posting into the transaction
    if posting1.units < posting2.units:
        txn.postings.append(posting2)
    else:
        txn.postings.insert(0, posting2)
    return txn

CONFIG = [
    # USTC canteen
    csv.Importer(
        {
            csv.Col.DATE: '记账日期',
            csv.Col.PAYEE: '收款人',
            csv.Col.NARRATION1: '交易摘要',
            csv.Col.AMOUNT_DEBIT: '人民币金额',
            csv.Col.NARRATION2: '类别'
        },
        account='Assets:CN:Card:USTC',
        currency='CNY',
        categorizer=dumb_USTCecard_categorizer,
    ),
]

语法说明参见 Beancount 系列二：Importer 设置。

执行命令生成 beancount 账单。

bean-extract ustc_card_importer.py 2020-07-02.csv

得到账单：

**** /path/to/2020-07-02.csv

2020-07-02 * "科大餐饮" "一卡通充值; Transferin"
    Assets:CN:Card:USTC        200.00 CNY
    Assets:CN:Bank:BoC:C1234  -200.00 CNY

2020-07-02 * "科大餐饮" "西区芳华园餐厅; Breakfast"
    Assets:CN:Card:USTC      -5.00 CNY
    Expenses:Food:Breakfast   5.00 CNY

2020-07-02 * "科大餐饮" "西区芳华园餐厅; Lunch"
    Assets:CN:Card:USTC  -10.00 CNY
    Expenses:Food:Lunch   10.00 CNY

2020-07-02 * "科大餐饮" "西区芳华园餐厅; Dinner"
    Assets:CN:Card:USTC   -10.00 CNY
    Expenses:Food:Dinner   10.00 CNY

校园卡消费可以直接使用该 importer。支付宝账单、信用卡账单等也可以通过导出 CSV 账单的方式利用自己编写的 importer 导入。

自动化

上述过程需要执行多个命令和脚本，利用 crontab 在每日睡前 (23:30) 执行一遍代码即可自动化记录消费。

$ python crawler.py>>log.log
$ cd importers
$ python ustc_card_importer_pipeline.py # 注意这里需要修改要记录的账本文件

Done!

Fava

• Fava 可视化网页中提供了编辑功能，对于多文件的编辑，默认打开的是主文件，要想修改编辑器默认打开的文件，需将 2019-07-11 custom "fava-option" "default-file" 这个设置放在想要设定的文件里。
• Fava 系统中也提供了添加记录的功能，但添加的记录默认写入了主文件里，根据Fava insert-entry options, default-file could also set the insertion file 作者似乎不 care 添加在哪个文件里这个问题，但依然可以利用 insert-entry 关键字变相设置一下，比如将 2019-01-01 custom "fava-option" "insert-entry" ".*" 断言写在 2019/01.bean 文件的末尾，所有在 2019-01-01 之后的记录，通过 Fava 添加记录的话，该记录会 write 在这个断言之前。
• Fava 是不带有密码功能的，根据 Make fava password-protected 作者认为这不应该是 Fava 应该做的工作；利用 Apache 或者 Nginx 的认证功能可以满足这个需求。

• 可视化工具 Fava 也支持 Importer，可以通过设置：

  2017-01-01 custom "fava-option" "import-config" "./importers/path/to/importer.py"
  2017-01-01 custom "fava-option" "import-dirs" "./importers/path/to/csv_tmp/"
  

  在 Fava 界面侧栏看到 Importer，并手动导入数据。注：Importer 在 Fava 中使用的时候 metadata 会被去除。

• Fava 还支持自定义 side bar link，即：

  2099-01-01 custom "fava-sidebar-link" "This Week" "/jump?time=day-6+-+day"
  2099-01-01 custom "fava-sidebar-link" "This Month" "/jump?time=month"
  2099-01-01 custom "fava-sidebar-link" "3 Month" "/jump?time=month-1+-+month%2B1"
  2099-01-01 custom "fava-sidebar-link" "Year-To-Date" "/jump?time=year+-+month"
  2099-01-01 custom "fava-sidebar-link" "All dates" "/jump?time="
  

前段时间，我终于拿到了自己心念的树莓派 4（4 GB 的型号），之后我就忍不住试了试，看看它在报道中提到的改进与提升究竟是什么样子的。

我自己的树莓派 3B+ 有个外壳，所以这次购买树莓派 4 的同时，我也订了个铝制的外壳，以减轻发热给树莓派带来的压力。与之前的外壳不同的是，它还配备了两个小风扇，能够大幅度提高散热效率。

就让我们来看一看吧。

概览

新的树莓派 4 装在了类似 3B+ 的包装中，包装正面是树莓派 4 的红底白线的结构图，与本体大小相同。与树莓派 3B 不同的是，3B+ 和 4 都没有用防静电袋包好。当然，这不是什么问题。

它的结构与前几代类似，不过有一些明显的变化。比如说，你肯定会最先注意到那几个 USB 3.0 接口——因为它们是蓝色的。在你观察那几个接口的同时，你很可能也注意到了，有可能是因为千兆网口的升级的缘故，以太网接口换了位置。

有一些小接口，即供电口和视频输出，也有一些变化。树莓派 4 现在需要一根 Type-C 线供电，并且需求提升到了 5V / 3A。目前尚且不知树莓派 4 是否支持类似于高通快充或者 USB PD 这样的快充技术，但是从用户反馈来看，是没有的。旧款上标准大小的 HDMI 也被 micro-HDMI 口替换——而且变成了两个：它们都支持 4K 60fps 输出，而且可以同时输出！尽管我打算把树莓派当无头（无显示的）服务器来用，用树莓派配桌面环境的人可能会喜欢这个特性。

内存条也从树莓派的背面移到了正面，现在在 SoC 旁边。SoC 长得和 3B+ 的一样，但是内部却完全不同。Wi-Fi 屏蔽罩和天线没有变化，另外在千兆网口的前面又多出了一个额外的芯片。

参数

新的树莓派 4 带来了大量激动人心的更新，包括了：

• 博通 BCM2711 SoC, 四核 1.5 GHz Cortex-A72 CPU
• 有 1 GB, 2GB 和 4 GB RAM 四种版本（4 GB 就是我手中的这款）
• 博通 VideoCore VI GPU
• 真正的千兆以太网口
• 蓝牙 5.0
• 原生 USB 3.0 支持，包含了 2 个 Type-A 的接口
• 双 HDMI 口，支持同时 4K 60fps 输出
• 更快的 microSD 卡插槽

在之后的基准测试中，你可以看到这些更新参数意味着什么。以下是一张对比表：

在我买到 3B+ 之后，我就把 3B 卖（给了译者），所以那个树莓派 3B 就没法参与接下来的评测了。（译者注：那个 3B 现在被我放在家里吃灰……对不起……）

我的设置

正如你看到的那样，两个树莓派都是无头的服务器，只连接了电源和以太网。你可能在疑惑，为什么它们看起来这么诡异，这是因为我所在的实验室有很多标称 5V / 6A 的电源供应线，所以我就拿了一个来通过 GPIO 给这两个树莓派供电。这两个树莓派峰值标称 5V / 2.5A 和 5V / 3A，所以一根供电线就够了。

基准测试

两个树莓派被分配了静态 IP，所有的操作都通过 SSH 完成。操作系统是最新版的 Raspbian Buster Lite。

SysBench CPU 测试

SysBench 是一个可以快速获取系统性能的测试套件。这里我使用 SysBench 来测试 CPU 与内存。

sysbench --test=cpu run
sysbench --test=cpu --num-threads=4 run
sysbench --test=cpu --num-threads=8 run

如表中显示的那样，在 CPU 性能方面，树莓派 4 相比 3B+ 而言有巨大提升，在所有情况中都少花了 19.3% 的时间。

SysBench 内存测试

内存测试有点复杂，并且我发现了一些意料之外的结果。

sysbench --test=memory --memory-block-size=1K --memory-total-size=2G --memory-oper=read run
sysbench --test=memory --memory-block-size=1K --memory-total-size=2G --memory-oper=write run
sysbench --test=memory --memory-block-size=1K --memory-total-size=2G --memory-oper=read --num-threads=4 run
sysbench --test=memory --memory-block-size=1K --memory-total-size=2G --memory-oper=write --num-threads=4 run
sysbench --test=memory --memory-block-size=1M --memory-total-size=2G --memory-oper=write --num-threads=4 run

新的 DDR4 内存竟然比老古董 DDR2 内存慢，而且在多线程情况下差距进一步拉大了！唯一一点合理的是，当单个块大小到 1 MiB 的时候，树莓派 4 要小幅好于 3B+。

一件有意思的事情是，我没有包含“1 MiB Read MT”（1 MiB 单块，读取，多线程）这一列。SysBench 在两块树莓派上都给我返回了超过 200 GB/s 的结果，有时候结果还高达 500 GB/s。这显然太滑稽了，所以我直接忽略了那个结果。

FIO microSD 卡速度测试

此测试结果依赖于 microSD 卡本身，所以我拿出了我拥有的最快的 SD 卡：Lexar 667x 128 GB microSD 卡，外观类似下面这张图：

我使用 fio 作为磁盘（microSD 卡）I/O 性能测试工具。因为我更熟悉 Crystal DiskMark，我调整了 fio 的参数，以与其一致。

fio --loops=5 --size=500m --filename=fiotest.tmp --stonewall --ioengine=libaio --direct=1 \
  --name=SeqRead --bs=1m --rw=read \
  --name=SeqWrite --bs=1m --rw=write \
  --name=512Kread --bs=512k --rw=randread \
  --name=512Kwrite --bs=512k --rw=randwrite \
  --name=4KQD32read --bs=4k --iodepth=32 --rw=randread \
  --name=4KQD32write --bs=4k --iodepth=32 --rw=randwrite \
  --name=4Kread --bs=4k --rw=randread \
  --name=4Kwrite --bs=4k --rw=randwrite

从结果来看，树莓派 4 的性能有巨大提升，在许多测试中都比 3B+ 快出 50%。这可能是树莓派 4 最有用的更新，因为性能的瓶颈几乎都在缓慢的磁盘 I/O 上。

p7zip 基准测试

7-zip 有个自带的基准测试工具，当然 p7zip（7-zip 的 POSIX 移植）也有。我使用这个工具来测试树莓派的压缩与解压性能。

7zr b -mmt1
7zr b

如此帮助文档所言，压缩更依赖于内存的吞吐量与延迟，这可能是两块树莓派间在压缩测试中差距增大的原因。总之，树莓派 4 在 p7zip 测试中有 1/3 的性能提升。

OpenSSL 速度测试

OpenSSL 是目前最流行的密码学软件库，它也包含了一个内置的速度测试。结果是在所有块大小中最快的那个——在 4 个测试中大小都是 16,384 字节。

openssl speed -evp aes-256-cbc
openssl speed -evp aes-256-gcm
openssl speed -evp sha1
openssl speed -evp sha256

网络速度测试

树莓派 4 将 300 Mbps 以太网升级到了真正的千兆网口，如果你打算用它来当离线下载器或者 NAS 的话，这是极好的。这里我跑了两个测试，看看网络究竟如何。

CURL 文件下载测试

这项测试非常简单：使用 cURL 从局域网机器下载文件，查看速度。

结果不如预想那么好：树莓派 4 没能跑出千兆的速度，而我旁边的 x86 Linux 盒子就做到了。

NGINX 性能测试

另一个常见的场景是：使用 NGINX 提供网页服务（对不起，这里没有 Apache 的位置）。我在两块树莓派上都安装了 NGINX，设置了 access_log off，并在我的 x86 盒子上使用 Siege 4.0.4 对树莓派服务器进行基准测试。

siege -c 10 -r 1000 [host]
siege -c 25 -r 400 [host]

在 CPU 性能与网络速度的双重提升下，新的树莓派 4 速度接近 3B+ 的两倍。如果你想用树莓派搭个网站的话，这是个好消息。

应用程序性能

我选择了两个我最熟悉的编程语言环境：Python 和 Ruby（我对 Node 不熟）来进行测试。

Python 测试使用了此 Stack Overflow 回答中的那个蠢极了的脚本，运行时间作为结果。

def test():
    """Stupid test function"""
    lst = []
    for i in range(100):
        lst.append(i)

if __name__ == '__main__':
    import timeit
    print(timeit.timeit("test()", setup="from __main__ import test"))

Ruby 测试就简单很多：使用 Jekyll 构建我的站点，查看消耗的时间。

Ruby 测试比 Python 测试更加均衡，因为它主要测试的是纯计算性能，结果 Ruby 测试中性能差距就要小一些。

不过等等，这不代表树莓派 4 对大型的 Python 或者 Ruby 项目来说是个好的选择。相同的测试在我的 x86 盒子（i7-8850H, 32 GB DDR4, NVMe SSD）上快了 10 倍，其仅使用 5 秒运行 Python 脚本，4 秒构建我的 Jekyll 站点。毕竟，你不能期望一个只卖 55 美元的板子能够有毁天灭地的性能，不是吗？

USB I/O 性能

我拿出了我的 USB 3.1 SSD（由 LiteOn L9M 512 GB 和一个包含了 VL716 SATA 转 USB 芯片的硬盘盒组装而成）。但是，我一把 SSD 插上树莓派，它就没电了。之后我发现这是因为供电不足（GPIO 针脚无法提供足够的电力），所以一天之后，我从 MicroUSB / Type-C 接口重新供电。这一次，3B+ 很顺利，但是树莓派 4 在测试时再一次因为电力问题出错。最后，我只能同时从 Type-C 和 GPIO 给树莓派供电，以便在不断电的情况下完成 SSD 测试。

这次的供电问题真的很严重，但先不去管它。让我们看看结果。

fio --loops=5 --size=1g --filename=fiotest.tmp --stonewall --ioengine=libaio \
  --direct=1 --name=SeqRead --bs=1m --rw=read --name=SeqWrite --bs=1m --rw=write

结果很棒！升级后的 USB 3.0 接口，即使没有跑到最高速，也比前代树莓派高出很多。但在享受高速 USB 之前，再让我强调一次：请特别关注你的 USB 外设，特别是那些有点儿耗电的设备，像机械硬盘和 SSD。如果电力得以保证，利用那两个高速 USB 接口对于 NAS 或者其他存储扩展来说好处多多。

总结

在体验过 3B 到 3B+ 的小小提升后，新的树莓派 4 对于大多数树莓派爱好者来说，都是一场盛宴。价格不变，即使你已经有个 3B+，树莓派 4 也可以说是必买的。尽管在供电和散热上有缺点，如果你不插太多外设，不在树莓派上放太多重型任务的话，也没什么关系。