commit 84d96caa6ed2e1942f5c880962e37883e3afdd45
Author: zhiye.sun <zhiye.sun@sinitek.com>
Date:   Wed Jul 22 16:42:56 2026 +0800

    feat: 初始化 Python 零基础教学课程

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..7f34a53
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,16 @@
+# PyCharm 和 IntelliJ 系列编辑器生成的本地项目配置。
+# 这些文件可能包含个人路径和界面设置，不应作为通用教学范例提交。
+.idea/
+
+# Python 运行时生成的字节码缓存。
+__pycache__/
+*.py[cod]
+
+# Python 虚拟环境目录。
+.venv/
+venv/
+
+# 本地环境变量文件可能包含密码、密钥或个人配置。
+.env
+.env.*
+!.env.example
diff --git a/01_python基础/1_1_hello_world/README.md b/01_python基础/1_1_hello_world/README.md
new file mode 100644
index 0000000..a06b8b1
--- /dev/null
+++ b/01_python基础/1_1_hello_world/README.md
@@ -0,0 +1,366 @@
+# 第 1-1 课：Hello World——认识 Python 并运行第一个程序
+
+## 一、本课目标
+
+完成本课后，你应该能够：
+
+1. 用自己的话解释 Python、程序和解释器分别是什么；
+2. 在 PowerShell 中检查 Python 是否可用；
+3. 看懂一条最基础的 `print()` 语句；
+4. 使用 `python 文件名.py` 运行 Python 文件；
+5. 独立编写一个可以输出文字的 Python 程序；
+6. 根据常见错误信息检查命令、路径、引号和文件扩展名。
+
+## 二、开始前需要知道什么
+
+本课不要求你有任何编程基础。
+
+你只需要知道：电脑中的文件通常有文件名和扩展名。例如：
+
+- `README.md` 是 Markdown 文档；
+- `hello_world.py` 是 Python 源代码文件；
+- `.py` 是 Python 源代码文件常用的扩展名。
+
+“源代码”就是程序员写给计算机执行的一组文本指令。
+
+## 三、Python 是什么
+
+Python 是一种编程语言。编程语言是人与计算机沟通时使用的一套规则。
+
+人类日常使用中文、英文等自然语言交流；编写程序时，则要使用 Python 能够理解的语法。Python 以语法清晰、容易阅读著称，因此很适合作为第一门编程语言。
+
+Python 可以用于很多领域，例如：
+
+- 编写自动化脚本；
+- 处理 Excel、文本和图片；
+- 分析数据；
+- 开发网站后端；
+- 开发接口；
+- 人工智能与机器学习；
+- 编写测试工具。
+
+本项目主要沿着“Python 基础 → 数据库 → Web 后端”的路线学习。
+
+## 四、程序、编程语言和解释器
+
+### 4.1 程序
+
+程序是一组按照一定顺序执行的指令。
+
+例如，“显示一句欢迎语”虽然非常简单，但仍然是一个程序。它包含一条明确的指令：把指定文字显示在屏幕上。
+
+### 4.2 编程语言
+
+编程语言规定了源代码应该怎样书写。我们必须按照 Python 的语法规则编写代码，否则 Python 无法正确理解我们的意图。
+
+### 4.3 Python 解释器
+
+Python 解释器是一个负责读取并执行 Python 代码的软件。
+
+可以暂时把它想象成一名翻译：
+
+```text
+你编写的 Python 代码
+        ↓
+Python 解释器读取并执行
+        ↓
+计算机完成操作并显示结果
+```
+
+只创建 `.py` 文件还不够。要运行里面的代码，电脑上还需要安装 Python 解释器。
+
+## 五、检查当前 Python 环境
+
+本项目已经检查过当前电脑，结果如下：
+
+```text
+Python 版本：Python 3.13.5
+解释器位置：C:\ProgramData\miniconda3\python.exe
+可用命令：python
+不可用命令：py
+```
+
+这里的“版本”可以理解为软件的代次。`3.13.5` 分为主版本号、次版本号和修订号。本阶段暂时不需要记忆版本号的细节。
+
+### 5.1 打开 PowerShell
+
+PowerShell 是 Windows 中用于输入命令的工具，也称为命令行或终端。
+
+打开 PowerShell 后输入：
+
+```powershell
+python --version
+```
+
+正常情况下会显示：
+
+```text
+Python 3.13.5
+```
+
+命令中的 `--version` 表示“显示版本信息”。
+
+> 注意：当前电脑不能使用 `py` 命令，所以本教程现阶段统一使用 `python`。
+
+## 六、认识项目路径
+
+第一课目录是：
+
+```text
+D:\Code\Python\01_python基础\1_1_hello_world
+```
+
+在 PowerShell 中，可以使用 `cd` 命令进入该目录：
+
+```powershell
+cd D:\Code\Python\01_python基础\1_1_hello_world
+```
+
+`cd` 是 Change Directory 的缩写，意思是“切换目录”。
+
+切换后，可以输入以下命令查看当前目录中的文件：
+
+```powershell
+Get-ChildItem
+```
+
+你应该能看到：
+
+```text
+README.md
+hello_world.py
+practice.py
+```
+
+## 七、第一个 Python 程序
+
+打开本课目录中的 `hello_world.py`，可以看到最核心的一行代码：
+
+```python
+print("Hello, World!")
+```
+
+运行程序：
+
+```powershell
+python hello_world.py
+```
+
+预期输出如下：
+
+```text
+Hello, World!
+欢迎开始学习 Python！
+这是我的第一个 Python 程序。
+```
+
+## 八、逐步理解第一行代码
+
+```python
+print("Hello, World!")
+```
+
+可以把这行代码拆成四部分：
+
+### 8.1 `print`
+
+`print` 的常见中文含义是“打印”。在 Python 中，它用于把内容输出到屏幕。
+
+这里的“打印”不是让打印机打印纸张，而是在终端中显示内容。
+
+### 8.2 圆括号 `()`
+
+圆括号中放的是希望交给 `print` 处理的内容。
+
+现在可以先把它理解为：告诉 `print` 要显示什么。函数的完整概念会在后续课程中专门讲解。
+
+### 8.3 双引号 `""`
+
+双引号包围的内容是一段文字。在 Python 中，这类文字称为“字符串”（String）。
+
+例如：
+
+```python
+"Hello, World!"
+"我正在学习 Python"
+"123"
+```
+
+第三个例子虽然看起来是数字，但因为它被引号包围，所以当前应把它看作文字。数据类型会在下一课详细学习。
+
+### 8.4 感叹号和逗号
+
+引号里面的逗号和感叹号只是需要显示的文字内容，不是 Python 的特殊指令。
+
+## 九、代码是怎样执行的
+
+执行下面的命令时：
+
+```powershell
+python hello_world.py
+```
+
+大致会经历以下过程：
+
+1. PowerShell 找到名为 `python` 的解释器；
+2. Python 解释器打开 `hello_world.py`；
+3. 解释器通常从上到下读取代码；
+4. 每遇到一条 `print()` 语句，就输出对应内容；
+5. 所有代码执行结束后，程序退出，PowerShell 重新等待命令。
+
+因此，交换几条 `print()` 语句的位置，输出顺序也会发生变化。
+
+## 十、中文、英文和引号
+
+Python 3 可以直接处理中文文字：
+
+```python
+print("你好，Python！")
+```
+
+字符串也可以使用单引号：
+
+```python
+print('你好，Python！')
+```
+
+本课程初期示例统一优先使用英文双引号，保持代码风格一致。
+
+需要特别注意：代码中的引号和括号应使用英文半角符号。
+
+正确：
+
+```python
+print("你好")
+```
+
+错误：
+
+```text
+print（“你好”）
+```
+
+错误示例使用了中文全角括号和中文引号，Python 无法把它们识别为正确语法。
+
+## 十一、注释是什么
+
+Python 中以半角井号 `#` 开头的内容称为注释。
+
+```python
+# 这是一行注释，Python 不会把它当作需要执行的指令。
+print("这行代码会执行")
+```
+
+注释的主要作用是帮助人理解代码。Python 解释器运行程序时，会忽略注释内容。
+
+好的注释应解释代码的目的或容易误解的地方。后续课程中的示例会保留详细中文注释，帮助你理解代码。
+
+## 十二、常见错误与解决方法
+
+### 12.1 找不到 `python` 命令
+
+可能看到类似提示：
+
+```text
+python 不是内部或外部命令
+```
+
+这通常表示 Python 没有安装，或者解释器路径没有加入系统环境变量。当前电脑已经可以使用 `python`，正常情况下不会遇到该问题。
+
+### 12.2 找不到代码文件
+
+可能看到：
+
+```text
+can't open file 'hello_world.py'
+```
+
+常见原因是当前 PowerShell 所在目录不正确，或者文件名拼写错误。
+
+先进入正确目录，再运行文件：
+
+```powershell
+cd D:\Code\Python\01_python基础\1_1_hello_world
+python hello_world.py
+```
+
+### 12.3 `SyntaxError`
+
+`SyntaxError` 表示“语法错误”，说明代码不符合 Python 的书写规则。
+
+初学阶段常见原因包括：
+
+- 漏写右括号；
+- 漏写一侧引号；
+- 使用中文括号或中文引号；
+- 不小心输入了多余字符。
+
+### 12.4 文件实际是 `.py.txt`
+
+Windows 有时会隐藏已知文件的扩展名。看起来叫 `hello_world.py` 的文件，实际可能是 `hello_world.py.txt`。
+
+可以在文件资源管理器中开启“查看 → 显示 → 文件扩展名”，确认文件真实名称。
+
+### 12.5 不要害怕错误信息
+
+错误信息不是对学习者的批评，而是 Python 提供的排查线索。遇到错误时，可以按下面的顺序处理：
+
+1. 找到错误信息最后几行；
+2. 确认出错的文件名和行号；
+3. 检查该行及上一行的引号、括号和拼写；
+4. 修改后重新运行；
+5. 如果仍无法解决，保留完整错误信息并进行提问。
+
+## 十三、课堂练习
+
+打开 `practice.py`，根据文件中的中文注释完成以下任务：
+
+1. 输出你的名字或称呼；
+2. 输出“我正在学习 Python”；
+3. 输出你学习 Python 的一个目标；
+4. 使用一条 `print()` 输出由星号组成的分隔线；
+5. 运行程序，并观察输出顺序是否与代码顺序一致。
+
+运行练习文件：
+
+```powershell
+python practice.py
+```
+
+本次不提前提供答案。你完成后可以把代码交给我检查，我会先指出做得正确的地方，再解释可以改进的内容。
+
+## 十四、思考题
+
+请先自己思考，不需要立即查资料：
+
+1. 为什么只有 `.py` 文件，却没有 Python 解释器时，程序不能运行？
+2. `print("123")` 中的 `123` 目前应该看作数字还是文字？为什么？
+3. 如果把三条 `print()` 语句的顺序颠倒，输出会发生什么变化？
+4. 注释会不会显示在程序运行结果中？
+
+## 十五、本课小结
+
+本课最重要的知识点是：
+
+- Python 是一种编程语言；
+- Python 解释器负责读取和执行 `.py` 文件；
+- 当前电脑使用 `python` 命令运行 Python 3.13.5；
+- `print()` 可以把内容输出到终端；
+- 引号包围的文字称为字符串；
+- Python 通常按照代码从上到下的顺序执行；
+- `#` 开头的注释用于帮助人阅读代码，不会作为指令执行；
+- 遇到错误时，应关注文件名、行号和错误类型。
+
+## 十六、验收标准
+
+完成以下所有事项，即可认为通过第一课：
+
+- [ ] 能在 PowerShell 中执行 `python --version`；
+- [ ] 能进入本课目录；
+- [ ] 能成功运行 `python hello_world.py`；
+- [ ] 能解释 `print()`、圆括号和引号的大致作用；
+- [ ] 能独立完成 `practice.py` 中的练习；
+- [ ] 能成功运行练习文件；
+- [ ] 能回答四道思考题。
+
+完成后，把 `practice.py` 的内容或运行结果发给我。检查通过后，我们再进入第 1-2 课“变量与数据类型”。
diff --git a/01_python基础/1_1_hello_world/hello_world.py b/01_python基础/1_1_hello_world/hello_world.py
new file mode 100644
index 0000000..e001813
--- /dev/null
+++ b/01_python基础/1_1_hello_world/hello_world.py
@@ -0,0 +1,12 @@
+# 本文件是整个课程的第一个 Python 示例程序。
+# 以半角井号开头的内容是注释，Python 运行程序时会忽略注释。
+
+# print() 用于把圆括号中的内容输出到终端。
+# 双引号包围的内容是一段文字，在 Python 中称为字符串。
+print("Hello, World!")
+
+# Python 3 支持直接输出中文，不需要进行额外设置。
+print("欢迎开始学习 Python！")
+
+# Python 通常按照代码从上到下的顺序执行，因此这句话最后显示。
+print("这是我的第一个 Python 程序。")
diff --git a/01_python基础/1_1_hello_world/practice.py b/01_python基础/1_1_hello_world/practice.py
new file mode 100644
index 0000000..c629325
--- /dev/null
+++ b/01_python基础/1_1_hello_world/practice.py
@@ -0,0 +1,25 @@
+# 第 1-1 课课堂练习
+#
+# 完成方式：
+# 1. 阅读每道题上方的中文注释。
+# 2. 在注释下方独立编写一条 print() 语句。
+# 3. 不要删除题目注释，它们可以帮助你核对是否完成了全部任务。
+# 4. 完成后在当前目录运行：python practice.py
+
+
+# 练习一：输出你的名字或希望别人称呼你的名称。
+# 请在下一行开始编写代码。
+
+# 练习二：输出文字“我正在学习 Python”。
+# 请在下一行开始编写代码。
+
+# 练习三：输出你学习 Python 的一个目标。
+# 示例目标可以是“我希望能独立开发一个网站后端”，但请尽量写你自己的目标。
+# 请在下一行开始编写代码。
+
+# 练习四：输出一条由多个星号组成的分隔线。
+# 预期形式类似：********************
+# 请在下一行开始编写代码。
+
+# 练习五：运行本文件，观察终端中的输出顺序是否与代码顺序一致。
+# 这道题不需要新增代码，请在运行后思考并记录自己的结论。
diff --git a/01_python基础/1_2_变量与数据类型/README.md b/01_python基础/1_2_变量与数据类型/README.md
new file mode 100644
index 0000000..9dc230b
--- /dev/null
+++ b/01_python基础/1_2_变量与数据类型/README.md
@@ -0,0 +1,472 @@
+# 第 1-2 课：变量与数据类型
+
+## 一、本课目标
+
+完成本课后，你应该能够：
+
+1. 解释变量是什么，以及为什么程序需要变量；
+2. 使用赋值符号 `=` 创建变量；
+3. 区分字符串、整数、浮点数和布尔值；
+4. 使用 `type()` 查看数据类型；
+5. 遵守 Python 变量命名的基本规则；
+6. 使用变量进行简单计算和文字输出；
+7. 使用 `int()`、`float()`、`str()` 完成简单类型转换；
+8. 看懂变量重新赋值后发生的变化。
+
+## 二、前置知识
+
+开始本课前，你应该已经能够：
+
+- 使用 `python 文件名.py` 运行 Python 程序；
+- 使用 `print()` 输出文字；
+- 知道引号包围的内容是字符串；
+- 知道 `#` 开头的内容是注释。
+
+## 三、变量是什么
+
+变量（Variable）是程序中用于保存数据的名称。
+
+可以把变量想象成一个贴有标签的盒子：
+
+```text
+标签：user_name
+盒子中的数据："Bruce"
+```
+
+在 Python 中可以这样写：
+
+```python
+user_name = "Bruce"
+```
+
+这行代码表示：把字符串 `"Bruce"` 保存起来，并使用名称 `user_name` 指向它。
+
+之后只要使用变量名，就能取得对应的数据：
+
+```python
+print(user_name)
+```
+
+变量的价值在于：数据可以被保存、重复使用和修改，不必在每个地方重复写相同内容。
+
+## 四、认识赋值符号
+
+下面代码中的 `=` 称为赋值符号：
+
+```python
+age = 18
+```
+
+赋值操作按照“先看右边，再交给左边”的方式理解：
+
+1. Python 先得到右边的整数 `18`；
+2. 再让左边的变量名 `age` 指向这个数据。
+
+这里的 `=` 暂时不要理解成数学中的“左右相等”。Python 中判断两个值是否相等会使用 `==`，将在条件判断课程中学习。
+
+## 五、四种基础数据类型
+
+数据类型用于描述一个数据属于哪一类，以及它通常可以参与哪些操作。
+
+### 5.1 字符串 `str`
+
+字符串（String，类型名为 `str`）用于表示文字：
+
+```python
+user_name = "Bruce"
+learning_goal = "开发 LLM Agent"
+```
+
+字符串必须使用成对的单引号或双引号包围。
+
+即使内容看起来像数字，只要有引号，它仍然是字符串：
+
+```python
+phone_number = "13800000000"
+```
+
+电话号码通常不用于数学计算，因此使用字符串保存更合适。
+
+### 5.2 整数 `int`
+
+整数（Integer，类型名为 `int`）是不带小数部分的数字：
+
+```python
+age = 18
+course_count = 8
+temperature = -2
+```
+
+整数不需要引号，可以参加加、减、乘、除等数学运算。
+
+### 5.3 浮点数 `float`
+
+浮点数（Floating-point Number，类型名为 `float`）通常用于表示带小数部分的数字：
+
+```python
+height = 1.75
+price = 19.9
+progress = 0.25
+```
+
+“浮点数”是计算机领域的常用名称，初学阶段可以先把它理解为小数。
+
+### 5.4 布尔值 `bool`
+
+布尔值（Boolean，类型名为 `bool`）只有两个值：
+
+```python
+is_learning = True
+is_finished = False
+```
+
+- `True` 表示真、是、成立；
+- `False` 表示假、否、不成立。
+
+首字母必须大写，并且不能添加引号。`"True"` 是字符串，不是布尔值。
+
+布尔值经常用于记录某个状态，例如：
+
+- 用户是否登录；
+- 任务是否完成；
+- 数据是否有效；
+- 接口调用是否成功。
+
+## 六、使用 `type()` 查看数据类型
+
+`type()` 可以告诉我们一个数据的类型：
+
+```python
+user_name = "Bruce"
+age = 18
+
+print(type(user_name))
+print(type(age))
+```
+
+输出结果：
+
+```text
+<class 'str'>
+<class 'int'>
+```
+
+目前只需要关注最后的 `str` 和 `int`。`class` 与类的概念会在面向对象阶段详细学习。
+
+`type()` 主要用于学习和排查问题。实际开发中，不需要为每一个变量都输出类型。
+
+## 七、变量与字符串的区别
+
+请比较：
+
+```python
+user_name = "Bruce"
+
+print(user_name)
+print("user_name")
+```
+
+输出为：
+
+```text
+Bruce
+user_name
+```
+
+原因是：
+
+- `user_name` 没有引号，Python 会把它当作变量名，并读取变量保存的数据；
+- `"user_name"` 有引号，Python 会把它当作普通文字直接输出。
+
+这是初学阶段非常重要的区别。
+
+## 八、变量命名规则
+
+### 8.1 必须遵守的规则
+
+Python 变量名：
+
+1. 可以包含英文字母、数字和下划线；
+2. 不能以数字开头；
+3. 不能包含空格、连字符等符号；
+4. 区分英文字母大小写；
+5. 不能使用 Python 关键字。
+
+正确示例：
+
+```python
+user_name = "Bruce"
+age2 = 18
+course_count = 8
+```
+
+错误示意：
+
+```text
+2age = 18            # 不能以数字开头
+user name = "Bruce" # 不能包含空格
+user-name = "Bruce" # 不能使用连字符连接单词
+```
+
+错误示意放在文本代码块中，是为了避免它们被误认为可运行的 Python 代码。
+
+### 8.2 推荐的命名风格
+
+Python 普通变量通常使用蛇形命名法（snake_case）：
+
+```python
+user_name = "Bruce"
+learning_days = 1
+is_course_finished = False
+```
+
+蛇形命名法使用小写英文单词，并用下划线连接多个单词。
+
+变量名应该能说明数据的含义。推荐使用 `learning_days`，不推荐使用 `a`、`x1` 这类难以理解的名称。
+
+代码标识符使用英文，注释和教学文档使用中文。这样既符合常见开发习惯，也便于与第三方库和团队代码协作。
+
+## 九、使用变量进行计算
+
+整数和浮点数可以参与计算：
+
+```python
+completed_lessons = 1
+new_lessons = 1
+total_lessons = completed_lessons + new_lessons
+
+print(total_lessons)
+```
+
+输出：
+
+```text
+2
+```
+
+代码执行过程是：
+
+1. `completed_lessons` 保存整数 `1`；
+2. `new_lessons` 保存整数 `1`；
+3. Python 读取两个变量中的整数并相加；
+4. 计算结果 `2` 保存到 `total_lessons`；
+5. `print()` 输出结果。
+
+## 十、变量可以重新赋值
+
+变量保存的数据可以改变：
+
+```python
+learning_days = 1
+print(learning_days)
+
+learning_days = 2
+print(learning_days)
+```
+
+输出：
+
+```text
+1
+2
+```
+
+第二次赋值后，再使用 `learning_days` 时得到的是新数据 `2`。
+
+Python 变量甚至可以在运行过程中指向不同类型的数据：
+
+```python
+value = 10
+value = "十"
+```
+
+这种能力称为动态类型。它很灵活，但随意改变变量的数据类型容易让代码难以理解，所以实际开发中应让同一个变量尽量保持含义和类型稳定。
+
+## 十一、简单的类型转换
+
+有时需要把一种类型的数据转换成另一种类型。
+
+### 11.1 字符串转换为整数
+
+```python
+age_text = "18"
+age = int(age_text)
+
+print(age)
+print(type(age))
+```
+
+`int()` 会尝试把合适的内容转换为整数。
+
+### 11.2 字符串转换为浮点数
+
+```python
+price_text = "19.9"
+price = float(price_text)
+```
+
+### 11.3 数字转换为字符串
+
+```python
+course_count = 8
+course_count_text = str(course_count)
+```
+
+### 11.4 转换并不总能成功
+
+下面的转换会报错：
+
+```text
+int("十八")
+```
+
+因为 Python 不知道应该怎样把中文文字“十八”直接转换成整数。遇到无法转换的数据时，会产生错误。异常处理会在后续课程学习。
+
+## 十二、使用格式化字符串输出变量
+
+如果想把固定文字和变量数据组合起来，可以使用格式化字符串，简称 f-string：
+
+```python
+user_name = "Bruce"
+learning_days = 2
+
+print(f"{user_name} 已经学习 Python {learning_days} 天。")
+```
+
+输出：
+
+```text
+Bruce 已经学习 Python 2 天。
+```
+
+使用方法：
+
+1. 在字符串开始引号前写小写字母 `f`；
+2. 在字符串中使用花括号 `{}` 包围变量名；
+3. Python 会把花括号中的变量替换成变量保存的数据。
+
+f-string 是现代 Python 中非常常用、易读的字符串格式化方式。
+
+## 十三、当前电脑上有两个 Python 解释器
+
+第一课练习结果显示：
+
+```text
+PowerShell：Python 3.13.5
+PyCharm：Python 3.11.15
+```
+
+这说明电脑上安装了不止一个 Python 解释器。它们就像同一种工具的两个版本。
+
+目前的基础代码可以在两个版本中运行，因此不影响学习。以后安装第三方库时，需要注意“库安装到了哪个解释器”，否则可能出现已经安装但代码仍提示找不到的情况。
+
+现阶段请记住：
+
+- 在 PowerShell 中，本项目默认使用 `python` 命令；
+- 在 PyCharm 中，运行按钮会使用项目设置中选择的解释器；
+- 看到不同 Python 版本不必紧张，但提问错误时应保留完整的运行命令和解释器路径。
+
+虚拟环境和依赖管理将在 Python 进阶阶段系统学习。
+
+## 十四、运行本课示例
+
+在 PowerShell 中执行：
+
+```powershell
+cd D:\Code\Python\01_python基础\1_2_变量与数据类型
+python variables_and_types.py
+```
+
+运行时请对照代码和输出，重点观察：
+
+- 变量名与字符串的区别；
+- 四种数据类型的 `type()` 结果；
+- 变量重新赋值前后的变化；
+- f-string 如何把变量放入一句话中。
+
+## 十五、常见错误
+
+### 15.1 使用了不存在的变量
+
+```text
+NameError: name 'user_name' is not defined
+```
+
+常见原因：
+
+- 变量还没有赋值就被使用；
+- 变量名拼写错误；
+- 大小写不一致。
+
+### 15.2 忘记给字符串加引号
+
+```python
+user_name = Bruce
+```
+
+Python 会把 `Bruce` 当成变量名，而不是文字。如果这个变量不存在，就会产生 `NameError`。
+
+正确写法：
+
+```python
+user_name = "Bruce"
+```
+
+### 15.3 把赋值方向写反
+
+```text
+18 = age
+```
+
+变量名应写在赋值符号左边，数据或计算表达式写在右边。
+
+### 15.4 类型不同导致操作失败
+
+```text
+"18" + 1
+```
+
+`"18"` 是字符串，`1` 是整数。两种不同含义的数据不能直接进行这个加法操作。需要先确认业务目的，再进行合适的类型转换。
+
+## 十六、课堂练习
+
+打开 `practice.py`，按照中文注释完成练习。你将创建一组描述自己学习情况的变量，并输出一段学习档案。
+
+运行命令：
+
+```powershell
+python practice.py
+```
+
+本课仍然不提前提供答案。完成后告诉我，我会读取并运行你的代码进行验收。
+
+## 十七、思考题
+
+1. `age = 18` 和 `age = "18"` 有什么区别？
+2. 为什么 `print(user_name)` 和 `print("user_name")` 的结果不同？
+3. `True` 与 `"True"` 是同一种数据类型吗？
+4. 为什么推荐使用 `learning_days`，而不是 `a`？
+5. 如果先执行 `score = 10`，再执行 `score = 20`，最后输出的值是什么？
+
+## 十八、本课小结
+
+- 变量是程序中保存和引用数据的名称；
+- `=` 用于把右边的数据赋给左边的变量；
+- `str` 表示字符串，`int` 表示整数，`float` 表示浮点数，`bool` 表示布尔值；
+- `type()` 可以查看数据类型；
+- 变量名与带引号的字符串含义不同；
+- 变量名应清晰，并优先使用蛇形命名法；
+- 变量可以用于计算，也可以被重新赋值；
+- `int()`、`float()` 和 `str()` 可以进行基础类型转换；
+- f-string 可以清晰地组合固定文字和变量数据。
+
+## 十九、验收标准
+
+- [ ] 能解释变量和赋值的含义；
+- [ ] 能创建字符串、整数、浮点数和布尔值变量；
+- [ ] 能使用 `type()` 查看变量类型；
+- [ ] 能判断一个变量名是否符合基本规则；
+- [ ] 能使用变量完成简单计算；
+- [ ] 能使用 f-string 输出包含变量的句子；
+- [ ] 能完成并运行 `practice.py`；
+- [ ] 能回答五道思考题。
diff --git a/01_python基础/1_2_变量与数据类型/practice.py b/01_python基础/1_2_变量与数据类型/practice.py
new file mode 100644
index 0000000..2e86844
--- /dev/null
+++ b/01_python基础/1_2_变量与数据类型/practice.py
@@ -0,0 +1,41 @@
+# 第 1-2 课课堂练习：创建个人 Python 学习档案
+#
+# 完成要求：
+# 1. 根据每道题的注释，在指定位置编写代码。
+# 2. 变量名使用有意义的英文蛇形命名法。
+# 3. 字符串、整数、浮点数和布尔值的数据类型必须正确。
+# 4. 不要删除题目注释。
+# 5. 完成后运行：python practice.py
+
+
+# 练习一：创建一个字符串变量 user_name，保存你的名字或称呼。
+
+# 练习二：创建一个整数变量 learning_days，表示你已经学习 Python 的天数。
+
+# 练习三：创建一个浮点数变量 daily_learning_hours，表示你计划每天学习的小时数。
+# 例如每天学习一个半小时，可以保存为 1.5。
+
+# 练习四：创建一个布尔值变量 is_first_lesson_finished，表示你是否完成了第一课。
+
+# 练习五：分别使用 type() 输出以上四个变量的数据类型。
+# 运行后应能看到 str、int、float 和 bool。
+
+# 练习六：创建整数变量 completed_lessons，保存已经完成的课程数 1。
+# 再创建整数变量 current_lessons，保存当前正在学习的课程数 1。
+# 将两者相加，并把结果保存到变量 total_lessons 中。
+# 最后输出 total_lessons。
+
+# 练习七：使用 f-string 输出一段完整的学习档案。
+# 句子中至少包含 user_name、learning_days 和 daily_learning_hours 三个变量。
+# 预期形式类似：Bruce 已学习 Python 2 天，计划每天学习 1.5 小时。
+
+# 练习八：创建字符串变量 lesson_count_text，保存字符串 "2"。
+# 使用 int() 将它转换为整数，并把结果保存到 lesson_count 变量中。
+# 分别输出 lesson_count 的值和数据类型。
+
+
+# 完成全部练习后，请检查：
+# 1. 程序能否从头到尾运行且没有错误；
+# 2. 四种基础数据类型是否选择正确；
+# 3. 变量名是否能清楚表达数据的含义；
+# 4. f-string 中的花括号是否使用了正确的变量名。
diff --git a/01_python基础/1_2_变量与数据类型/variables_and_types.py b/01_python基础/1_2_变量与数据类型/variables_and_types.py
new file mode 100644
index 0000000..b64bc24
--- /dev/null
+++ b/01_python基础/1_2_变量与数据类型/variables_and_types.py
@@ -0,0 +1,75 @@
+# 第 1-2 课示例：变量与数据类型
+#
+# 建议先阅读本课 README.md，再从上到下阅读和运行本文件。
+# 每一段示例只演示一个主要知识点，便于对照终端输出进行理解。
+
+
+# 一、创建变量并输出变量保存的数据
+# 赋值符号右边的字符串 "Bruce" 会交给左边的变量 user_name。
+user_name = "Bruce"
+print(user_name)
+
+
+# 二、变量名与字符串不是同一个概念
+# 第一行读取变量中的数据，因此输出 Bruce。
+# 第二行直接输出引号中的文字，因此输出 user_name。
+print(user_name)
+print("user_name")
+
+
+# 三、创建四种基础数据类型
+# str：字符串，用于表示文字。
+learning_goal = "开发 LLM Agent"
+
+# int：整数，用于表示没有小数部分的数字。
+completed_lessons = 1
+
+# float：浮点数，初学阶段可以把它理解为小数。
+daily_learning_hours = 1.5
+
+# bool：布尔值，用于表示真或假、是或否。
+is_first_lesson_finished = True
+
+
+# 四、使用 type() 查看每个变量的数据类型
+print(type(learning_goal))
+print(type(completed_lessons))
+print(type(daily_learning_hours))
+print(type(is_first_lesson_finished))
+
+
+# 五、使用变量进行简单计算
+# 两个整数相加后，计算结果会保存到 total_lessons 中。
+new_lessons = 1
+total_lessons = completed_lessons + new_lessons
+print(total_lessons)
+
+
+# 六、重新给变量赋值
+# learning_days 最初保存 1，第二次赋值后改为保存 2。
+learning_days = 1
+print(learning_days)
+
+learning_days = 2
+print(learning_days)
+
+
+# 七、进行基础类型转换
+# age_text 是字符串，使用 int() 后得到整数 18。
+age_text = "18"
+age = int(age_text)
+print(age)
+print(type(age))
+
+# course_count 是整数，使用 str() 后得到字符串 "8"。
+course_count = 8
+course_count_text = str(course_count)
+print(course_count_text)
+print(type(course_count_text))
+
+
+# 八、使用 f-string 组合固定文字与变量
+# 字符串前的 f 表示这是格式化字符串。
+# 花括号中的变量会被替换成变量当前保存的数据。
+print(f"{user_name} 已经学习 Python {learning_days} 天。")
+print(f"当前目标：{learning_goal}")
diff --git a/01_python基础/1_3_输入与输出/README.md b/01_python基础/1_3_输入与输出/README.md
new file mode 100644
index 0000000..5cfdcad
--- /dev/null
+++ b/01_python基础/1_3_输入与输出/README.md
@@ -0,0 +1,378 @@
+# 第 1-3 课：输入与输出
+
+## 一、本课目标
+
+完成本课后，你应该能够：
+
+1. 解释程序的输入、处理和输出；
+2. 使用 `input()` 接收用户输入；
+3. 理解 `input()` 得到的结果始终是字符串；
+4. 将输入的数字文本转换成整数或浮点数；
+5. 使用 f-string 输出包含变量的完整句子；
+6. 使用 `print()` 的 `sep` 和 `end` 调整简单的输出格式；
+7. 编写一个能与用户进行基础交互的小程序。
+
+## 二、前置知识
+
+开始本课前，你应该已经掌握：
+
+- 使用 `print()` 输出内容；
+- 创建和使用变量；
+- 区分 `str`、`int`、`float` 和 `bool`；
+- 使用 `int()`、`float()` 和 `str()` 进行简单类型转换；
+- 使用 f-string 将变量放入字符串。
+
+## 三、程序的输入、处理和输出
+
+很多程序都可以简化成三个阶段：
+
+```text
+输入（Input） → 处理（Process） → 输出（Output）
+```
+
+例如，一个计算明年年龄的程序：
+
+1. 输入：用户输入当前年龄；
+2. 处理：当前年龄加 `1`；
+3. 输出：显示明年的年龄。
+
+第一课中的程序只有固定输出。学会输入后，程序就能根据不同用户提供的数据生成不同结果。
+
+## 四、使用 `input()` 接收输入
+
+最简单的输入代码如下：
+
+```python
+user_name = input("请输入你的名字：")
+print(f"你好，{user_name}！")
+```
+
+运行到 `input()` 时，程序会暂停并等待用户输入。用户输入内容并按下回车键后，程序才会继续向下执行。
+
+`input()` 圆括号中的字符串称为提示语，用于告诉用户应该输入什么。
+
+执行过程如下：
+
+```text
+程序显示：请输入你的名字：
+用户输入：Bruce
+用户按下回车键
+变量 user_name 保存字符串 "Bruce"
+程序显示：你好，Bruce！
+```
+
+## 五、`input()` 的结果始终是字符串
+
+无论用户输入看起来像文字、整数还是小数，`input()` 返回的结果都是字符串 `str`。
+
+```python
+age = input("请输入你的年龄：")
+print(type(age))
+```
+
+如果输入 `18`，类型仍然是：
+
+```text
+<class 'str'>
+```
+
+这是因为终端接收到的是用户键入的一串字符。Python 不会擅自判断这串字符应该表示姓名、年龄、电话号码还是其他内容。
+
+## 六、输入数字后进行类型转换
+
+如果输入内容需要参与数学计算，就要先进行类型转换。
+
+### 6.1 转换为整数
+
+```python
+age_text = input("请输入你的年龄：")
+age = int(age_text)
+next_year_age = age + 1
+
+print(f"明年你将 {next_year_age} 岁。")
+```
+
+这里特意使用两个变量：
+
+- `age_text` 保存用户输入的原始字符串；
+- `age` 保存转换后的整数。
+
+这样命名能清楚表达数据转换前后的区别。
+
+也可以写成：
+
+```python
+age = int(input("请输入你的年龄："))
+```
+
+这种写法更短，但初学阶段不容易观察每一步。建议先掌握分步写法，理解后再使用组合写法。
+
+### 6.2 转换为浮点数
+
+如果用户可能输入小数，可以使用 `float()`：
+
+```python
+daily_hours_text = input("你计划每天学习多少小时：")
+daily_hours = float(daily_hours_text)
+weekly_hours = daily_hours * 7
+
+print(f"按照计划，你每周将学习 {weekly_hours} 小时。")
+```
+
+## 七、转换失败时会发生什么
+
+如果程序执行 `int("十八")`，Python 无法把中文“十八”直接转换成整数，会产生类似错误：
+
+```text
+ValueError: invalid literal for int()
+```
+
+`ValueError` 可以理解为“数据的值不适合当前操作”。
+
+本课练习时，请按照提示输入正确格式的数据。以后学习异常处理时，我们会让程序在用户输入错误后给出友好提示，而不是直接结束。
+
+## 八、使用 f-string 组织输出
+
+从用户取得数据后，常常要把多个变量组合成容易阅读的结果：
+
+```python
+user_name = "Bruce"
+learning_days = 3
+daily_hours = 2.5
+
+print(f"{user_name} 已学习 Python {learning_days} 天，每天计划学习 {daily_hours} 小时。")
+```
+
+f-string 中：
+
+- 引号内的普通文字会原样显示；
+- 花括号中的变量会替换成变量保存的数据；
+- 花括号中也可以放简单计算。
+
+例如：
+
+```python
+print(f"一周计划学习 {daily_hours * 7} 小时。")
+```
+
+为了让代码更容易阅读，较重要或较复杂的计算通常先保存到变量中，再进行输出。
+
+## 九、一次接收多个输入
+
+程序可以连续调用多次 `input()`：
+
+```python
+user_name = input("请输入你的名字：")
+learning_goal = input("请输入你的学习目标：")
+
+print(f"学习者：{user_name}")
+print(f"学习目标：{learning_goal}")
+```
+
+每次遇到 `input()`，程序都会等待一次输入。输入顺序必须与程序询问顺序一致。
+
+## 十、进一步认识 `print()`
+
+### 10.1 一次输出多个内容
+
+`print()` 可以接收多个内容，中间使用英文逗号分隔：
+
+```python
+print("Python", "FastAPI", "Django")
+```
+
+默认输出：
+
+```text
+Python FastAPI Django
+```
+
+注意：代码中的英文逗号负责分隔多个数据，默认显示结果会使用空格连接它们。
+
+### 10.2 使用 `sep` 设置分隔符
+
+`sep` 是 separator 的缩写，表示多个输出内容之间的分隔符：
+
+```python
+print("Python", "FastAPI", "Django", sep=" -> ")
+```
+
+输出：
+
+```text
+Python -> FastAPI -> Django
+```
+
+`sep` 不是需要显示的普通内容，而是传给 `print()` 的命名参数。函数和参数将在后续课程系统讲解，本课先掌握这种常用写法。
+
+### 10.3 使用 `end` 设置结尾
+
+`print()` 默认在输出结束后换行。可以通过 `end` 改变结尾：
+
+```python
+print("正在学习", end="：")
+print("Python")
+```
+
+输出：
+
+```text
+正在学习：Python
+```
+
+第一条 `print()` 没有立即换行，因此第二条内容接在后面。
+
+现阶段不要过度使用 `sep` 和 `end`。只有当它们能让输出格式更清楚时才使用。
+
+## 十一、空字符串
+
+如果用户看到输入提示后没有输入任何内容，直接按下回车键，`input()` 会返回空字符串：
+
+```python
+""
+```
+
+空字符串是一个长度为零的字符串。它不是 `0`，也不是 `False` 本身。
+
+以后学习条件判断时，我们会检查用户是否输入了内容。本课练习时，请按提示提供非空数据。
+
+## 十二、运行本课示例
+
+在 PowerShell 中执行：
+
+```powershell
+cd D:\Code\Python\01_python基础\1_3_输入与输出
+python input_output.py
+```
+
+程序会依次要求你输入：
+
+1. 姓名或称呼；
+2. 已学习 Python 的天数；
+3. 每天计划学习的小时数；
+4. 学习目标。
+
+可以参考以下输入：
+
+```text
+Bruce
+3
+2.5
+开发 LLM Agent
+```
+
+输入整数和小数时暂时不要使用中文数字或附加单位。例如输入 `3`，不要输入 `3天`。
+
+## 十三、示例程序执行过程
+
+`input_output.py` 大致完成以下步骤：
+
+1. 接收姓名并保存为字符串；
+2. 接收学习天数的原始文本；
+3. 把学习天数转换为整数；
+4. 接收每天学习小时数的原始文本；
+5. 把学习小时数转换为浮点数；
+6. 接收学习目标；
+7. 计算每周计划学习时间；
+8. 使用 f-string 输出个人学习计划。
+
+请对照源代码，找出每一步对应的代码。
+
+## 十四、常见错误
+
+### 14.1 程序像是停止了
+
+如果最后显示输入提示但没有出现新的 PowerShell 提示符，程序通常不是卡住，而是在等待你输入内容并按回车键。
+
+### 14.2 数字后添加了单位
+
+输入：
+
+```text
+3天
+```
+
+不能直接通过 `int()` 转换。提示要求输入数字时，应只输入：
+
+```text
+3
+```
+
+单位由程序在输出时添加。
+
+### 14.3 把 `input` 写成大写
+
+Python 区分大小写。正确名称是 `input`，不是 `Input` 或 `INPUT`。
+
+### 14.4 忘记保存输入结果
+
+```python
+input("请输入名字：")
+print(user_name)
+```
+
+上面的输入没有赋给 `user_name`，之后使用该变量会产生 `NameError`。
+
+正确写法：
+
+```python
+user_name = input("请输入名字：")
+```
+
+### 14.5 字符串不能直接与整数相加
+
+```text
+age_text = input("请输入年龄：")
+next_year_age = age_text + 1
+```
+
+`age_text` 是字符串，必须先使用 `int()` 转换后再参与加法计算。
+
+## 十五、课堂练习
+
+打开 `practice.py`，编写一个“Agent 开发学习计划生成器”。程序需要接收用户输入，完成简单计算，并输出一份格式清晰的学习计划。
+
+运行命令：
+
+```powershell
+python practice.py
+```
+
+请至少使用一次：
+
+- `input()`；
+- `int()`；
+- `float()`；
+- f-string；
+- 有明确含义的英文变量名。
+
+## 十六、思考题
+
+1. 为什么用户输入 `18` 后，`input()` 返回的仍然是字符串？
+2. 什么时候应使用 `int()`，什么时候应使用 `float()`？
+3. 如果用户输入 `2.5`，能否使用 `int()` 直接转换？
+4. `print("A", "B", sep="-")` 会输出什么？
+5. 为什么输入数字时不建议让用户同时输入“天”“小时”等单位？
+
+## 十七、本课小结
+
+- 许多程序都包含输入、处理和输出三个阶段；
+- `input()` 会显示提示并等待用户输入；
+- `input()` 返回的数据始终是字符串；
+- 数字文本参与计算前，通常需要使用 `int()` 或 `float()` 转换；
+- f-string 可以将用户输入、计算结果和固定文字组合起来；
+- `print()` 可以一次输出多个数据；
+- `sep` 可以设置多个数据之间的分隔符；
+- `end` 可以设置输出结尾；
+- 转换数字时，输入内容必须符合对应格式。
+
+## 十八、验收标准
+
+- [ ] 能使用 `input()` 接收并保存用户输入；
+- [ ] 能证明 `input()` 返回的是字符串；
+- [ ] 能把数字文本转换为整数或浮点数；
+- [ ] 能使用输入的数据进行简单计算；
+- [ ] 能使用 f-string 输出完整句子；
+- [ ] 能使用 `sep` 或 `end` 调整一次输出；
+- [ ] 能完成并运行 `practice.py`；
+- [ ] 能回答五道思考题。
diff --git a/01_python基础/1_3_输入与输出/input_output.py b/01_python基础/1_3_输入与输出/input_output.py
new file mode 100644
index 0000000..7e9768a
--- /dev/null
+++ b/01_python基础/1_3_输入与输出/input_output.py
@@ -0,0 +1,52 @@
+# 第 1-3 课示例：输入与输出
+#
+# 这个程序会暂停并等待用户依次输入四项数据。
+# 输入数字时请只输入数字本身，不要添加“天”或“小时”等单位。
+
+
+# 一、接收字符串输入
+# input() 会先显示提示语，再等待用户输入并按下回车键。
+# 用户输入的内容会以字符串形式保存到 user_name 变量中。
+user_name = input("请输入你的名字或称呼：")
+
+
+# 二、接收整数输入
+# input() 得到的 learning_days_text 是字符串。
+# 这里分成两步编写，方便观察类型转换前后的数据。
+learning_days_text = input("请输入你已经学习 Python 的天数：")
+learning_days = int(learning_days_text)
+
+
+# 三、接收浮点数输入
+# 每天学习时间可能包含小数，因此使用 float() 进行转换。
+daily_hours_text = input("请输入你计划每天学习的小时数：")
+daily_hours = float(daily_hours_text)
+
+
+# 四、继续接收字符串输入
+learning_goal = input("请输入你的 Python 学习目标：")
+
+
+# 五、处理输入的数据
+# 一周有 7 天，因此每天学习时间乘以 7 可以得到每周计划时间。
+weekly_hours = daily_hours * 7
+
+
+# 六、输出分隔线
+# print() 接收三个字符串，sep="" 表示它们之间不添加默认空格。
+print("=", "个人 Python 学习计划", "=", sep="")
+
+
+# 七、使用 f-string 输出变量和计算结果
+print(f"学习者：{user_name}")
+print(f"已学习：{learning_days} 天")
+print(f"每天计划学习：{daily_hours} 小时")
+print(f"每周计划学习：{weekly_hours} 小时")
+print(f"学习目标：{learning_goal}")
+
+
+# 八、演示 end 参数
+# 第一条 print() 使用 end="："，输出后不换行，而是以中文冒号结尾。
+# 第二条 print() 会紧接着输出学习状态，之后恢复默认换行。
+print("当前状态", end="：")
+print("持续学习中")
diff --git a/01_python基础/1_3_输入与输出/practice.py b/01_python基础/1_3_输入与输出/practice.py
new file mode 100644
index 0000000..455cd36
--- /dev/null
+++ b/01_python基础/1_3_输入与输出/practice.py
@@ -0,0 +1,54 @@
+# 第 1-3 课课堂练习：Agent 开发学习计划生成器
+#
+# 完成要求：
+# 1. 根据注释依次接收用户输入。
+# 2. 对需要计算的数字文本进行类型转换。
+# 3. 使用有明确含义的英文蛇形变量名。
+# 4. 使用 f-string 输出最终学习计划。
+# 5. 不要删除题目注释。
+# 6. 完成后运行：python practice.py
+
+
+# 练习一：使用 input() 接收用户的名字或称呼。
+# 将输入结果保存到变量 user_name。
+
+# 练习二：使用 input() 接收用户计划学习 Python 的总天数。
+# input() 返回字符串，请使用 int() 转换为整数并保存到 total_days。
+# 建议分成“接收原始文本”和“转换类型”两个步骤。
+
+
+# 练习三：使用 input() 接收用户每天计划学习的小时数。
+# 使用 float() 转换为浮点数并保存到 daily_hours。
+
+# 练习四：使用 input() 接收用户想重点学习的 Agent 方向。
+# 例如：Agent 应用开发、提示词工程、RAG 或模型训练。
+# 将结果保存到 learning_direction。
+
+# 练习五：计算总计划学习小时数。
+# 计算公式：总天数 * 每天学习小时数。
+# 将计算结果保存到 total_hours。
+
+
+# 练习六：使用 print() 和 sep 参数输出标题。
+# 标题可以由 "="、"Agent 开发学习计划"、"=" 三部分组成。
+# 尝试使用 sep=""，让三部分之间不出现默认空格。
+
+# 练习七：使用 f-string 分行输出以下信息：
+# 1. 学习者；
+# 2. 计划学习总天数；
+# 3. 每天学习小时数；
+# 4. 预计总学习小时数；
+# 5. 重点学习方向。
+
+
+# 练习八：使用两条 print() 输出最终状态。
+# 第一条使用 end="：" 输出“计划状态”，使它暂时不换行。
+# 第二条输出“准备开始”。
+
+
+# 完成后进行自查：
+# 1. 输入整数时是否只输入了数字；
+# 2. 输入小数时是否使用了英文小数点；
+# 3. total_days 的类型是否为 int；
+# 4. daily_hours 和 total_hours 的类型是否为 float；
+# 5. 最终输出是否包含全部输入信息和计算结果。
diff --git a/01_python基础/1_4_运算符/README.md b/01_python基础/1_4_运算符/README.md
new file mode 100644
index 0000000..e9589ed
--- /dev/null
+++ b/01_python基础/1_4_运算符/README.md
@@ -0,0 +1,511 @@
+# 第 1-4 课：运算符
+
+## 一、本课目标
+
+完成本课后，你应该能够：
+
+1. 解释运算符和操作数是什么；
+2. 使用算术运算符完成基础计算；
+3. 区分普通除法、整除和取余；
+4. 使用比较运算符得到布尔值；
+5. 使用复合赋值运算符更新变量；
+6. 使用 `and`、`or` 和 `not` 组合或反转条件；
+7. 使用括号明确计算顺序；
+8. 编写一个包含输入、计算和判断结果的学习进度程序。
+
+## 二、前置知识
+
+开始本课前，你应该已经掌握：
+
+- 创建和使用变量；
+- 区分字符串、整数、浮点数和布尔值；
+- 使用 `input()` 接收输入；
+- 使用 `int()` 和 `float()` 转换输入；
+- 使用 f-string 输出变量和计算结果。
+
+## 三、运算符与操作数
+
+运算符（Operator）是告诉 Python 执行某种运算的符号或关键字。
+
+观察下面的代码：
+
+```python
+total_hours = daily_hours * learning_days
+```
+
+其中：
+
+- `*` 是乘法运算符；
+- `daily_hours` 和 `learning_days` 是参与运算的数据，称为操作数（Operand）；
+- 计算结果赋值给 `total_hours`。
+
+运算不只是数学计算。比较两个数据、组合两个条件，也需要使用运算符。
+
+## 四、算术运算符
+
+算术运算符主要用于数字计算。
+
+| 运算符 | 含义 | 示例 | 结果 |
+| --- | --- | --- | --- |
+| `+` | 加法 | `10 + 3` | `13` |
+| `-` | 减法 | `10 - 3` | `7` |
+| `*` | 乘法 | `10 * 3` | `30` |
+| `/` | 普通除法 | `10 / 3` | `3.333...` |
+| `//` | 整除 | `10 // 3` | `3` |
+| `%` | 取余 | `10 % 3` | `1` |
+| `**` | 幂运算 | `10 ** 3` | `1000` |
+
+### 4.1 加、减、乘
+
+```python
+completed_tasks = 5
+new_tasks = 3
+
+total_tasks = completed_tasks + new_tasks
+remaining_tasks = total_tasks - completed_tasks
+estimated_minutes = total_tasks * 20
+```
+
+这些运算与日常数学中的含义基本一致。
+
+### 4.2 普通除法 `/`
+
+```python
+average_hours = 10 / 4
+print(average_hours)
+```
+
+输出：
+
+```text
+2.5
+```
+
+Python 3 中，普通除法 `/` 的结果通常是浮点数。即使能够整除，结果也会带小数：
+
+```python
+print(10 / 2)
+```
+
+输出：
+
+```text
+5.0
+```
+
+### 4.3 整除 `//`
+
+整除会得到向下取整后的商：
+
+```python
+full_weeks = 17 // 7
+print(full_weeks)
+```
+
+输出：
+
+```text
+2
+```
+
+这表示 17 天中包含 2 个完整的 7 天周期。
+
+对于正数，可以暂时理解为“只保留能完整分出的份数”。负数整除存在额外规则，将来遇到实际场景时再详细学习。
+
+### 4.4 取余 `%`
+
+取余得到除法中没有被完整分掉的余数：
+
+```python
+remaining_days = 17 % 7
+print(remaining_days)
+```
+
+输出：
+
+```text
+3
+```
+
+因此 17 天可以表示为 2 个完整星期加 3 天。
+
+取余还常用于判断一个整数是奇数还是偶数：
+
+```python
+remainder = 8 % 2
+print(remainder)
+```
+
+结果为 `0`，说明 8 可以被 2 整除。
+
+### 4.5 幂运算 `**`
+
+```python
+result = 2 ** 3
+print(result)
+```
+
+输出为 `8`，表示 2 的 3 次方，即 `2 × 2 × 2`。
+
+注意：Python 的幂运算不是 `^`。符号 `^` 在 Python 中有其他含义，当前阶段不要用它表示乘方。
+
+## 五、字符串也能使用部分算术运算符
+
+### 5.1 字符串拼接
+
+两个字符串可以使用 `+` 连接：
+
+```python
+first_name = "Agent"
+second_name = "开发者"
+role_name = first_name + second_name
+
+print(role_name)
+```
+
+输出：
+
+```text
+Agent开发者
+```
+
+如果需要空格或其他符号，必须明确写入字符串：
+
+```python
+role_name = first_name + " " + second_name
+```
+
+### 5.2 重复字符串
+
+字符串乘以整数可以重复多次：
+
+```python
+separator = "=" * 20
+print(separator)
+```
+
+这会输出 20 个等号。
+
+字符串不能与整数直接相加：
+
+```text
+"学习天数：" + 3
+```
+
+如果确实要拼接，需要先使用 `str(3)` 转换；不过通常推荐使用更清晰的 f-string。
+
+## 六、比较运算符
+
+比较运算符用于比较两个数据，结果一定是布尔值 `True` 或 `False`。
+
+| 运算符 | 含义 | 示例 |
+| --- | --- | --- |
+| `==` | 等于 | `score == 100` |
+| `!=` | 不等于 | `score != 0` |
+| `>` | 大于 | `score > 60` |
+| `<` | 小于 | `score < 60` |
+| `>=` | 大于或等于 | `score >= 60` |
+| `<=` | 小于或等于 | `score <= 100` |
+
+示例：
+
+```python
+completed_hours = 12
+target_hours = 10
+
+is_target_reached = completed_hours >= target_hours
+print(is_target_reached)
+```
+
+输出：
+
+```text
+True
+```
+
+### 6.1 `=` 与 `==` 的区别
+
+这是初学者必须掌握的区别：
+
+- `=` 表示赋值，把右边的数据交给左边的变量；
+- `==` 表示比较，判断左右两边是否相等。
+
+```python
+learning_days = 4
+is_four_days = learning_days == 4
+```
+
+第一行创建或更新变量，第二行得到布尔值 `True`。
+
+### 6.2 不要把布尔结果写成字符串
+
+```python
+is_finished = completed_tasks == total_tasks
+```
+
+这里的 `is_finished` 保存真正的布尔值。
+
+下面写法只是保存普通文字：
+
+```python
+is_finished = "True"
+```
+
+两者的数据类型和用途不同。
+
+## 七、赋值运算符与复合赋值
+
+普通赋值使用 `=`：
+
+```python
+completed_tasks = 3
+```
+
+如果完成了一个新任务，可以这样更新：
+
+```python
+completed_tasks = completed_tasks + 1
+```
+
+Python 提供了更简洁的复合赋值写法：
+
+```python
+completed_tasks += 1
+```
+
+两种写法在这个场景中作用相同。
+
+常见复合赋值运算符：
+
+| 运算符 | 示例 | 等价写法 |
+| --- | --- | --- |
+| `+=` | `value += 2` | `value = value + 2` |
+| `-=` | `value -= 2` | `value = value - 2` |
+| `*=` | `value *= 2` | `value = value * 2` |
+| `/=` | `value /= 2` | `value = value / 2` |
+| `//=` | `value //= 2` | `value = value // 2` |
+| `%=` | `value %= 2` | `value = value % 2` |
+
+复合赋值会更新变量本身，因此执行前变量必须已经存在。
+
+## 八、逻辑运算符
+
+逻辑运算符用于组合或反转布尔条件。
+
+Python 中最常用的三个逻辑运算符是：
+
+- `and`：并且；
+- `or`：或者；
+- `not`：取反。
+
+### 8.1 `and`
+
+`and` 两边的条件都为 `True` 时，整体才为 `True`。
+
+```python
+has_completed_course = True
+has_finished_practice = True
+
+can_start_next_course = has_completed_course and has_finished_practice
+print(can_start_next_course)
+```
+
+输出为 `True`。
+
+如果其中任何一个条件为 `False`，整体就是 `False`。
+
+### 8.2 `or`
+
+`or` 两边至少有一个条件为 `True` 时，整体就是 `True`。
+
+```python
+uses_pycharm = True
+uses_vscode = False
+
+has_code_editor = uses_pycharm or uses_vscode
+print(has_code_editor)
+```
+
+输出为 `True`。
+
+### 8.3 `not`
+
+`not` 会反转布尔值：
+
+```python
+is_finished = False
+is_still_learning = not is_finished
+
+print(is_still_learning)
+```
+
+输出为 `True`。
+
+### 8.4 组合比较条件
+
+```python
+daily_hours = 2.5
+completed_tasks = 4
+
+is_plan_healthy = daily_hours >= 1 and completed_tasks >= 3
+```
+
+这个结果表示“每天至少学习 1 小时，并且至少完成 3 个任务”是否同时成立。
+
+本课只计算并输出布尔结果。下一课学习条件判断后，程序可以根据结果执行不同代码。
+
+## 九、运算优先级
+
+Python 会按照一定优先级计算表达式。
+
+最基础的规则与数学类似：
+
+1. 先计算括号；
+2. 再计算幂运算；
+3. 再计算乘、除、整除和取余；
+4. 最后计算加减。
+
+```python
+result = 2 + 3 * 4
+print(result)
+```
+
+结果是 `14`，因为先计算 `3 * 4`。
+
+加入括号：
+
+```python
+result = (2 + 3) * 4
+print(result)
+```
+
+结果是 `20`。
+
+比较和逻辑运算组合时也有优先级规则，但不要依赖记忆复杂规则。推荐使用括号明确表达意图：
+
+```python
+can_continue = (score >= 60) and (practice_finished == True)
+```
+
+上面代码中的 `== True` 可以省略，写成下面这样更自然：
+
+```python
+can_continue = (score >= 60) and practice_finished
+```
+
+括号不仅影响运算顺序，也能帮助人更快读懂代码。
+
+## 十、浮点数精度现象
+
+运行下面代码：
+
+```python
+print(0.1 + 0.2)
+```
+
+你可能看到：
+
+```text
+0.30000000000000004
+```
+
+这不是 Python 随意算错，而是计算机使用二进制保存部分小数时产生的精度限制。
+
+现阶段知道这种现象即可。涉及金额等要求精确的业务数据时，不能随意使用普通浮点数直接计算，后续数据库和项目课程会介绍合适的处理方式。
+
+## 十一、运行本课示例
+
+在 PowerShell 中执行：
+
+```powershell
+cd D:\Code\Python\01_python基础\1_4_运算符
+python operators.py
+```
+
+请边看源代码边观察输出，重点比较：
+
+- `/`、`//`、`%` 的不同结果；
+- `=` 与 `==` 的不同用途；
+- `and`、`or`、`not` 的布尔结果；
+- 添加括号前后的计算结果。
+
+## 十二、常见错误
+
+### 12.1 使用 `^` 表示乘方
+
+Python 使用 `**` 进行幂运算，不使用 `^`。
+
+### 12.2 混淆 `=` 和 `==`
+
+需要比较时使用 `==`，需要给变量保存数据时使用 `=`。
+
+### 12.3 除数为零
+
+```text
+10 / 0
+```
+
+会产生 `ZeroDivisionError`，因为普通数字不能除以零。
+
+### 12.4 字符串与数字直接相加
+
+```text
+"总数：" + 10
+```
+
+会产生 `TypeError`。推荐使用 f-string：
+
+```python
+print(f"总数：{10}")
+```
+
+### 12.5 复杂表达式没有括号
+
+即使程序结果正确，难以阅读的表达式也容易在维护时产生问题。优先使用括号和含义清晰的中间变量。
+
+## 十三、课堂练习
+
+打开 `practice.py`，完成“Agent 学习进度计算器”。它会接收计划数据，计算完成率相关信息，并输出多个布尔判断结果。
+
+运行命令：
+
+```powershell
+python practice.py
+```
+
+本课重点是自己选择正确的运算符。请先不要参考示例文件逐行照抄。
+
+## 十四、思考题
+
+1. `17 / 7`、`17 // 7`、`17 % 7` 分别表示什么？
+2. `score = 80` 与 `score == 80` 有什么区别？
+3. `True and False` 的结果是什么？
+4. `True or False` 的结果是什么？
+5. `not True` 的结果是什么？
+6. 为什么复杂表达式推荐使用括号？
+7. `2 + 3 * 4` 和 `(2 + 3) * 4` 为什么结果不同？
+
+## 十五、本课小结
+
+- 算术运算符用于数字计算；
+- `/` 是普通除法，`//` 是整除，`%` 用于取得余数；
+- `**` 用于幂运算；
+- 比较运算的结果是布尔值；
+- `=` 表示赋值，`==` 表示比较是否相等；
+- 复合赋值可以简洁地更新已有变量；
+- `and` 要求两个条件都成立；
+- `or` 要求至少一个条件成立；
+- `not` 用于反转布尔结果；
+- 括号可以改变或明确运算顺序。
+
+## 十六、验收标准
+
+- [ ] 能正确使用七种基础算术运算符；
+- [ ] 能解释 `/`、`//` 和 `%` 的区别；
+- [ ] 能使用比较运算符得到布尔值；
+- [ ] 能区分赋值与相等比较；
+- [ ] 能使用至少一种复合赋值运算符；
+- [ ] 能使用 `and`、`or` 和 `not`；
+- [ ] 能使用括号明确计算顺序；
+- [ ] 能完成并运行 `practice.py`；
+- [ ] 能回答七道思考题。
diff --git a/01_python基础/1_4_运算符/operators.py b/01_python基础/1_4_运算符/operators.py
new file mode 100644
index 0000000..083b172
--- /dev/null
+++ b/01_python基础/1_4_运算符/operators.py
@@ -0,0 +1,97 @@
+# 第 1-4 课示例：运算符
+#
+# 本文件按类别演示常用运算符。
+# 运行时请对照每段注释，观察不同运算符产生的结果和数据类型。
+
+
+# 一、算术运算符
+first_number = 17
+second_number = 7
+
+print(f"加法：{first_number + second_number}")
+print(f"减法：{first_number - second_number}")
+print(f"乘法：{first_number * second_number}")
+print(f"普通除法：{first_number / second_number}")
+print(f"整除：{first_number // second_number}")
+print(f"取余：{first_number % second_number}")
+print(f"幂运算：{2 ** 3}")
+
+
+# 二、整除与取余的实际含义
+# 17 天中包含 2 个完整星期，另外还剩 3 天。
+learning_days = 17
+full_weeks = learning_days // 7
+remaining_days = learning_days % 7
+
+print(f"{learning_days} 天等于 {full_weeks} 个完整星期加 {remaining_days} 天。")
+
+
+# 三、字符串支持的部分运算
+# 加号连接字符串，乘号让字符串重复指定次数。
+role_name = "Agent" + " " + "开发者"
+separator = "=" * 20
+
+print(role_name)
+print(separator)
+
+
+# 四、比较运算符
+completed_hours = 12
+target_hours = 10
+
+print(f"是否等于目标：{completed_hours == target_hours}")
+print(f"是否不等于目标：{completed_hours != target_hours}")
+print(f"是否超过目标：{completed_hours > target_hours}")
+print(f"是否少于目标：{completed_hours < target_hours}")
+print(f"是否达到目标：{completed_hours >= target_hours}")
+print(f"是否未超过目标：{completed_hours <= target_hours}")
+
+
+# 五、复合赋值运算符
+# completed_tasks += 1 等价于 completed_tasks = completed_tasks + 1。
+completed_tasks = 3
+completed_tasks += 1
+print(f"新增一个完成项后：{completed_tasks}")
+
+# 下面把预计时间扩大为原来的两倍。
+estimated_hours = 5
+estimated_hours *= 2
+print(f"调整后的预计时间：{estimated_hours}")
+
+
+# 六、逻辑运算符
+course_finished = True
+practice_finished = True
+uses_pycharm = True
+uses_vscode = False
+
+can_start_next_course = course_finished and practice_finished
+has_code_editor = uses_pycharm or uses_vscode
+is_still_learning = not course_finished
+
+print(f"课程和练习是否都完成：{can_start_next_course}")
+print(f"是否至少使用一种编辑器：{has_code_editor}")
+print(f"是否仍未完成课程：{is_still_learning}")
+
+
+# 七、比较运算与逻辑运算组合
+daily_hours = 2.5
+completed_tasks = 4
+
+is_plan_healthy = (daily_hours >= 1) and (completed_tasks >= 3)
+print(f"学习时长和任务数是否同时达标：{is_plan_healthy}")
+
+
+# 八、运算优先级
+# 第一个结果先计算乘法；第二个结果先计算括号中的加法。
+result_without_parentheses = 2 + 3 * 4
+result_with_parentheses = (2 + 3) * 4
+
+print(f"没有括号：{result_without_parentheses}")
+print(f"使用括号：{result_with_parentheses}")
+
+
+# 九、观察浮点数精度现象
+# 这个结果说明部分十进制小数无法用二进制浮点数精确表示。
+floating_point_result = 0.1 + 0.2
+print(f"0.1 + 0.2 的结果：{floating_point_result}")
diff --git a/01_python基础/1_4_运算符/practice.py b/01_python基础/1_4_运算符/practice.py
new file mode 100644
index 0000000..8c186d8
--- /dev/null
+++ b/01_python基础/1_4_运算符/practice.py
@@ -0,0 +1,84 @@
+# 第 1-4 课课堂练习：Agent 学习进度计算器
+#
+# 完成要求：
+# 1. 根据注释选择正确的算术、比较、赋值或逻辑运算符。
+# 2. 数字输入需要转换为合适的数据类型。
+# 3. 使用含义清晰的英文蛇形变量名。
+# 4. 使用 f-string 输出结果。
+# 5. 不要删除题目注释。
+# 6. 完成后运行：python practice.py
+
+
+# 练习一：接收计划学习总天数，转换为整数并保存到 total_days。
+
+# 练习二：接收已经完成的学习天数，转换为整数并保存到 completed_days。
+
+# 练习三：接收每天计划学习的小时数，转换为浮点数并保存到 daily_hours。
+
+# 练习四：使用减法计算剩余学习天数，保存到 remaining_days。
+
+# 练习五：使用乘法计算计划总学习小时数，保存到 planned_total_hours。
+# 计算公式：计划学习总天数 * 每天计划学习小时数。
+
+# 练习六：使用乘法计算已经完成的学习小时数，保存到 completed_hours。
+# 为了简化练习，假设每天都完成了计划学习时长。
+
+# 练习七：使用整除和取余，把计划总天数拆分成“完整星期数”和“剩余天数”。
+# 分别保存到 full_weeks 和 extra_days。
+
+# 练习八：使用比较运算符完成以下判断：
+# 1. completed_days 是否大于 0，结果保存到 has_started；
+# 2. completed_days 是否大于或等于 total_days，结果保存到 is_plan_finished；
+# 3. remaining_days 是否不等于 0，结果保存到 has_remaining_days。
+
+# 练习九：使用逻辑运算符完成以下判断：
+# 只有“已经开始”并且“尚未完成”同时成立时，is_in_progress 才为 True。
+# 提示：“尚未完成”可以使用 not 反转 is_plan_finished。
+
+# 练习十：创建 completed_tasks 变量，初始值为 3。
+# 使用 += 让它增加 1，然后输出更新后的值。
+
+# 练习十一：使用字符串乘法输出一条包含 30 个等号的分隔线。
+
+# 练习十二：使用 f-string 输出完整进度报告，至少包含：
+# 1. 计划总天数和已完成天数；
+# 2. 剩余天数；
+# 3. 完整星期数和额外天数；
+# 4. 计划总学习小时数和已完成学习小时数；
+# 5. has_started、is_plan_finished、has_remaining_days 和 is_in_progress；
+# 6. 更新后的 completed_tasks。
+
+# 建议使用以下测试数据进行第一次运行：
+# 计划总天数：30
+# 已完成天数：7
+# 每天学习小时数：2.5
+#
+# 使用这组数据时，你应该能推算出：
+# 剩余 23 天，计划总时长 75.0 小时，已完成 17.5 小时；
+# 30 天包含 4 个完整星期，额外 2 天；
+# 已经开始为 True，已经完成为 False，正在进行为 True。
+
+
+# 完成后进行自查：
+# 1. 是否正确区分了 /、// 和 %；
+# 2. 比较结果是否是真正的 bool，而不是字符串；
+# 3. 是否正确使用了 and 和 not；
+# 4. += 是否更新了原变量；
+# 5. 所有计算结果是否与手工推算一致。
+
+# 计划学习总天数：30
+# 已经完成的学习天数：7
+# 每天计划学习的小时数：2.5
+# 4
+# ==============================
+# 1. 计划总天数和已完成天数: 30,7
+# 2. 剩余天数:23
+# 3. 完整星期数和额外天数:4,2
+# 4. 计划总学习小时数和已完成学习小时数:75.0,17.5
+# has_started=True
+# is_plan_finished=False
+# has_remaining_days=True
+# is_in_progress=True
+# completed_tasks=4
+#
+# 进程已结束，退出代码为 0
diff --git a/01_python基础/1_5_条件判断/README.md b/01_python基础/1_5_条件判断/README.md
new file mode 100644
index 0000000..0db3943
--- /dev/null
+++ b/01_python基础/1_5_条件判断/README.md
@@ -0,0 +1,472 @@
+# 第 1-5 课：条件判断
+
+## 一、本课目标
+
+完成本课后，你应该能够：
+
+1. 解释条件判断为什么能让程序作出不同选择；
+2. 使用 `if` 在条件成立时执行代码；
+3. 使用 `if...else` 处理两种互斥情况；
+4. 使用 `if...elif...else` 处理多个分支；
+5. 正确书写英文冒号和四个空格缩进；
+6. 使用比较运算符和逻辑运算符组成条件；
+7. 理解条件顺序为什么会影响最终结果；
+8. 使用嵌套条件处理有先后依赖的判断；
+9. 编写一个能够根据输入给出不同结论的程序。
+
+## 二、前置知识
+
+开始本课前，你应该已经掌握：
+
+- 使用 `input()` 接收用户输入；
+- 使用 `int()` 和 `float()` 转换数据；
+- 使用比较运算符得到 `True` 或 `False`；
+- 使用 `and`、`or`、`not` 组合条件；
+- 使用 f-string 输出变量。
+
+## 三、为什么需要条件判断
+
+前面的程序会从上到下执行每一行代码。即使我们计算出了布尔结果，程序也只是把它显示出来：
+
+```python
+score = 80
+is_passed = score >= 60
+print(is_passed)
+```
+
+真实程序通常需要根据结果执行不同操作，例如：
+
+- 分数达到 60 分时显示“通过”；
+- 密码正确时允许登录；
+- 库存不足时拒绝下单；
+- 学习任务完成后进入下一课；
+- 接口调用失败时显示错误信息。
+
+条件判断让程序拥有“如果发生某种情况，就执行某段代码”的能力。
+
+## 四、最简单的 `if`
+
+`if` 的中文含义是“如果”。基本结构如下：
+
+```python
+if 条件:
+    条件成立时执行的代码
+```
+
+示例：
+
+```python
+score = 80
+
+if score >= 60:
+    print("本次考核通过。")
+```
+
+执行过程：
+
+1. Python 计算 `score >= 60`；
+2. 结果为 `True`，因此执行缩进的 `print()`；
+3. 如果结果为 `False`，缩进代码会被跳过；
+4. 程序继续执行条件结构后面的代码。
+
+## 五、冒号与缩进
+
+Python 使用缩进表示哪些代码属于某个条件分支。
+
+正确写法：
+
+```python
+if score >= 60:
+    print("通过")
+    print("可以继续下一阶段")
+
+print("评估结束")
+```
+
+两条缩进的 `print()` 都属于 `if`。最后一条没有缩进，因此无论条件是否成立都会执行。
+
+### 5.1 冒号
+
+条件末尾必须使用英文半角冒号 `:`：
+
+```python
+if score >= 60:
+```
+
+不能使用中文冒号 `：`，也不能漏写冒号。
+
+### 5.2 四个空格
+
+Python 官方风格通常使用四个空格作为一级缩进。PyCharm 按下 Tab 键时，一般会自动生成合适的缩进。
+
+同一个代码块中的代码必须保持相同缩进：
+
+```text
+if score >= 60:
+    print("通过")
+  print("缩进不一致")
+```
+
+这会产生 `IndentationError`，中文可以理解为“缩进错误”。
+
+## 六、使用 `if...else` 处理两种情况
+
+`else` 表示“否则”。当 `if` 条件不成立时，执行 `else` 分支：
+
+```python
+score = 55
+
+if score >= 60:
+    print("本次考核通过。")
+else:
+    print("本次考核未通过。")
+```
+
+`if` 与 `else` 只会执行其中一个分支，不会同时执行。
+
+执行逻辑可以表示为：
+
+```text
+条件是否成立？
+├── 是 → 执行 if 分支
+└── 否 → 执行 else 分支
+```
+
+## 七、使用 `if...elif...else` 处理多个分支
+
+`elif` 是 else if 的缩写，表示“否则如果”。
+
+```python
+score = 85
+
+if score >= 90:
+    print("优秀")
+elif score >= 80:
+    print("良好")
+elif score >= 60:
+    print("合格")
+else:
+    print("需要继续练习")
+```
+
+Python 会从上到下检查条件：
+
+1. 检查 `score >= 90`，结果为 `False`；
+2. 检查 `score >= 80`，结果为 `True`；
+3. 执行“良好”；
+4. 跳过后面的其他分支。
+
+整组结构最多执行一个分支。
+
+## 八、条件顺序非常重要
+
+错误顺序示例：
+
+```python
+score = 95
+
+if score >= 60:
+    print("合格")
+elif score >= 90:
+    print("优秀")
+```
+
+虽然 95 分符合“优秀”，但第一个条件 `score >= 60` 已经成立，后面的分支不会再检查，最终只会输出“合格”。
+
+处理分数区间时，通常从要求最高、范围最窄的条件开始：
+
+```python
+if score >= 90:
+    print("优秀")
+elif score >= 60:
+    print("合格")
+else:
+    print("未通过")
+```
+
+## 九、条件可以直接使用布尔变量
+
+如果变量本身已经是布尔值，可以直接作为条件：
+
+```python
+practice_finished = True
+
+if practice_finished:
+    print("练习已完成。")
+else:
+    print("请先完成练习。")
+```
+
+不推荐重复比较：
+
+```python
+if practice_finished == True:
+```
+
+直接写 `if practice_finished:` 更简洁，也符合 Python 常见风格。
+
+判断布尔值为假时，可以使用 `not`：
+
+```python
+if not practice_finished:
+    print("请先完成练习。")
+```
+
+## 十、组合多个条件
+
+### 10.1 使用 `and`
+
+只有课程和练习都完成时，才能进入下一课：
+
+```python
+course_finished = True
+practice_finished = True
+
+if course_finished and practice_finished:
+    print("可以进入下一课。")
+else:
+    print("当前课程尚未完成。")
+```
+
+### 10.2 使用 `or`
+
+允许使用 PyCharm 或 VS Code：
+
+```python
+uses_pycharm = True
+uses_vscode = False
+
+if uses_pycharm or uses_vscode:
+    print("已经具备代码编辑器。")
+else:
+    print("请先安装代码编辑器。")
+```
+
+### 10.3 使用括号提高可读性
+
+```python
+if (score >= 60) and practice_finished:
+    print("考核通过。")
+```
+
+简单比较周围的括号可以省略，但条件较长时，括号能帮助读者快速理解组合关系。
+
+## 十一、连续区间判断
+
+判断一个数字是否处于某个范围，可以使用 `and`：
+
+```python
+age = 20
+
+if age >= 18 and age <= 60:
+    print("年龄在 18 到 60 之间。")
+```
+
+Python 还支持更接近数学写法的链式比较：
+
+```python
+if 18 <= age <= 60:
+    print("年龄在 18 到 60 之间。")
+```
+
+两种写法表达相同含义。链式比较是 Python 中常见且清晰的写法。
+
+## 十二、嵌套条件判断
+
+一个条件分支内部还可以包含另一个条件判断，这称为嵌套（Nesting）。
+
+```python
+account_enabled = True
+password_correct = True
+
+if account_enabled:
+    if password_correct:
+        print("登录成功。")
+    else:
+        print("密码错误。")
+else:
+    print("账户已停用。")
+```
+
+这里必须先确认账户可用，才有必要继续检查密码。
+
+嵌套层级过多会让代码难以阅读。只有当第二个判断确实依赖第一个判断时才使用嵌套；能够清晰地用 `and`、`elif` 表达时，不必强行嵌套。
+
+## 十三、输入与条件判断
+
+一个完整的交互判断程序：
+
+```python
+score_text = input("请输入考核分数：")
+score = float(score_text)
+
+if score >= 60:
+    print("考核通过。")
+else:
+    print("考核未通过。")
+```
+
+输入数据参与数字比较前，仍然需要先完成类型转换。
+
+## 十四、输入范围校验
+
+分数通常应处于 0 到 100 之间。可以先检查输入范围：
+
+```python
+if score < 0 or score > 100:
+    print("分数必须在 0 到 100 之间。")
+elif score >= 60:
+    print("考核通过。")
+else:
+    print("考核未通过。")
+```
+
+无效数据的判断应放在前面。否则 `score = 120` 可能被错误地归为“通过”。
+
+当前程序仍要求用户输入能够转换为数字的内容。如何处理“abc”等完全不能转换的数据，会在异常处理课程中学习。
+
+## 十五、哪些值会被当作假
+
+条件不一定必须写比较表达式。Python 会把某些空值当作 `False`：
+
+- `False`；
+- 数字 `0` 和 `0.0`；
+- 空字符串 `""`。
+
+例如：
+
+```python
+user_name = input("请输入姓名：")
+
+if user_name:
+    print(f"你好，{user_name}！")
+else:
+    print("姓名不能为空。")
+```
+
+如果用户直接按回车，`user_name` 是空字符串，程序会执行 `else`。
+
+这种根据值判断真假的规则称为真值（Truth Value）。列表、字典等容器的真值将在学到对应数据类型后继续介绍。
+
+## 十六、运行本课示例
+
+在 PowerShell 中执行：
+
+```powershell
+cd D:\Code\Python\01_python基础\1_5_条件判断
+python conditions.py
+```
+
+示例会要求输入：
+
+1. 考核分数；
+2. 是否完成练习，用 `yes` 或 `no` 表示。
+
+建议至少运行以下几组数据：
+
+| 分数 | 是否完成练习 | 重点观察 |
+| --- | --- | --- |
+| `95` | `yes` | 优秀且允许进入下一课 |
+| `75` | `no` | 合格但不能进入下一课 |
+| `50` | `yes` | 未通过 |
+| `120` | `yes` | 输入范围无效 |
+
+## 十七、常见错误
+
+### 17.1 漏写冒号
+
+```text
+if score >= 60
+    print("通过")
+```
+
+条件末尾必须有英文冒号 `:`。
+
+### 17.2 缩进不正确
+
+属于分支的代码必须统一缩进四个空格。不要混用不一致的空格数量。
+
+### 17.3 使用 `=` 进行比较
+
+```text
+if score = 60:
+```
+
+比较是否相等应使用 `==`。
+
+### 17.4 条件顺序错误
+
+多个分数等级应从高到低判断，否则宽泛条件会提前拦截更精确的分支。
+
+### 17.5 把多个独立 `if` 当成互斥分支
+
+```python
+if score >= 60:
+    print("合格")
+
+if score >= 90:
+    print("优秀")
+```
+
+95 分会同时输出“合格”和“优秀”。如果等级只能选择一个，应使用 `if...elif...else`。
+
+### 17.6 忘记转换输入类型
+
+`input()` 返回字符串。数字范围判断前应使用 `int()` 或 `float()` 转换。
+
+## 十八、课堂练习
+
+打开 `practice.py`，完成“Agent 学习状态评估器”。程序需要根据学习时长、练习完成情况和测验成绩，输出不同等级与下一步建议。
+
+运行命令：
+
+```powershell
+python practice.py
+```
+
+完成后至少使用以下测试数据检查不同分支：
+
+| 每天学习小时 | 已完成练习 | 测验成绩 | 预期核心结果 |
+| --- | --- | --- | --- |
+| `2.5` | `yes` | `95` | 优秀，可以继续 |
+| `1.5` | `yes` | `75` | 合格，可以继续 |
+| `0.5` | `yes` | `75` | 时长不足，暂不能继续 |
+| `2` | `no` | `80` | 练习未完成，暂不能继续 |
+| `2` | `yes` | `50` | 成绩未通过 |
+| `2` | `yes` | `120` | 输入无效 |
+
+## 十九、思考题
+
+1. `if` 条件为 `False` 时，缩进代码会怎样？
+2. `if...elif...else` 最多会执行几个分支？
+3. 为什么分数等级通常从高分向低分判断？
+4. 多个独立 `if` 与一组 `if...elif...else` 有什么区别？
+5. 为什么输入范围校验应该放在成绩等级判断之前？
+6. `if practice_finished:` 为什么不必写成 `if practice_finished == True:`？
+7. 空字符串在条件中会被当作真还是假？
+
+## 二十、本课小结
+
+- `if` 在条件为真时执行对应代码；
+- `else` 处理前面条件都不成立的情况；
+- `elif` 用于增加互斥分支；
+- 分支末尾需要英文冒号，分支内部需要统一缩进；
+- 一组 `if...elif...else` 最多执行一个分支；
+- 条件顺序会影响最终结果；
+- 布尔变量可以直接作为条件；
+- `and`、`or`、`not` 可以组成更完整的判断；
+- 嵌套条件适合表达有先后依赖的判断；
+- 空字符串、数字零等值在条件中会被当作假。
+
+## 二十一、验收标准
+
+- [ ] 能正确书写 `if`；
+- [ ] 能正确书写 `if...else`；
+- [ ] 能正确书写 `if...elif...else`；
+- [ ] 能使用四个空格表示分支代码；
+- [ ] 能解释条件顺序的重要性；
+- [ ] 能组合比较运算符与逻辑运算符；
+- [ ] 能完成简单的输入范围校验；
+- [ ] 能完成并运行 `practice.py`；
+- [ ] 能使用多组测试数据覆盖所有主要分支；
+- [ ] 能回答七道思考题。
diff --git a/01_python基础/1_5_条件判断/conditions.py b/01_python基础/1_5_条件判断/conditions.py
new file mode 100644
index 0000000..9449712
--- /dev/null
+++ b/01_python基础/1_5_条件判断/conditions.py
@@ -0,0 +1,66 @@
+# 第 1-5 课示例：条件判断
+#
+# 本程序根据考核分数和练习完成状态给出不同结果。
+# 建议使用讲义中的多组数据反复运行，观察每次进入了哪个分支。
+
+
+# 一、接收考核分数
+# input() 返回字符串，因此先保留原始文本，再转换为浮点数。
+score_text = input("请输入考核分数（0 到 100）：")
+score = float(score_text)
+
+
+# 二、接收练习状态
+# 本示例约定用户输入 yes 表示已完成，输入其他内容表示未完成。
+practice_answer = input("是否完成练习（yes/no）：")
+practice_finished = practice_answer == "yes"
+
+
+# 三、先判断分数范围，再判断成绩等级
+# 条件按从特殊到一般、从高分到低分的顺序排列。
+if score < 0 or score > 100:
+    score_level = "输入无效"
+elif score >= 90:
+    score_level = "优秀"
+elif score >= 80:
+    score_level = "良好"
+elif score >= 60:
+    score_level = "合格"
+else:
+    score_level = "未通过"
+
+print(f"成绩等级：{score_level}")
+
+
+# 四、组合多个条件决定能否继续
+# 只有分数处于有效范围、达到 60 分并且完成练习时，才允许继续。
+score_is_valid = 0 <= score <= 100
+score_is_passed = score >= 60
+
+if score_is_valid and score_is_passed and practice_finished:
+    print("课程和练习均已通过，可以进入下一课。")
+else:
+    print("当前要求尚未全部完成，暂时不能进入下一课。")
+
+
+# 五、使用嵌套判断给出更具体的提示
+# 先确认分数有效，之后才进一步分析未满足的项目。
+if score_is_valid:
+    if not score_is_passed:
+        print("改进建议：重新复习知识点并再次完成测验。")
+    elif not practice_finished:
+        print("改进建议：成绩已经通过，请继续完成课堂练习。")
+    else:
+        print("学习建议：保持当前节奏，继续学习下一课。")
+else:
+    print("输入提示：分数必须位于 0 到 100 之间。")
+
+
+# 六、演示空字符串的真值
+# 如果用户没有输入姓名而直接按回车，user_name 是空字符串，条件结果为假。
+user_name = input("请输入你的名字或称呼：")
+
+if user_name:
+    print(f"本次评估学习者：{user_name}")
+else:
+    print("本次评估未填写学习者名称。")
diff --git a/01_python基础/1_5_条件判断/practice.py b/01_python基础/1_5_条件判断/practice.py
new file mode 100644
index 0000000..dcad58b
--- /dev/null
+++ b/01_python基础/1_5_条件判断/practice.py
@@ -0,0 +1,89 @@
+# 第 1-5 课课堂练习：Agent 学习状态评估器
+#
+# 完成要求：
+# 1. 根据注释使用 if、elif 和 else 编写条件分支。
+# 2. 注意英文冒号和四个空格缩进。
+# 3. 数字输入需要转换为正确类型。
+# 4. 布尔状态应使用比较结果生成，不要保存成 "True" 或 "False" 字符串。
+# 5. 不要删除题目注释。
+# 6. 完成后使用题目末尾提供的多组数据测试程序。
+
+
+# 练习一：接收用户每天学习的小时数。
+# 使用 float() 转换，并保存到 daily_hours。
+
+# 练习二：询问用户是否完成本课练习，约定输入 yes 或 no。
+# 将原始输入保存到 practice_answer。
+# 使用 == 比较 practice_answer 是否等于 "yes"，把布尔结果保存到 practice_finished。
+
+# 练习三：接收测验成绩，成绩范围为 0 到 100。
+# 使用 float() 转换，并保存到 score。
+
+# 练习四：使用 if...elif...else 判断成绩等级。
+# 必须先判断 score 是否小于 0 或大于 100：
+# - 范围无效：score_level = "输入无效"
+# - 90 分及以上：score_level = "优秀"
+# - 80 分及以上：score_level = "良好"
+# - 60 分及以上：score_level = "合格"
+# - 其余有效成绩：score_level = "未通过"
+
+# 练习五：创建三个布尔变量。
+# 1. score_is_valid：成绩是否处于 0 到 100 之间，请使用链式比较；
+# 2. score_is_passed：成绩是否大于或等于 60；
+# 3. learning_time_is_enough：每天学习时间是否大于或等于 1 小时。
+
+# 练习六：判断是否可以继续下一课。
+# 只有以下四个条件全部成立时，can_continue 才为 True：
+# - 成绩范围有效；
+# - 成绩通过；
+# - 已经完成练习；
+# - 每天学习时间达到 1 小时。
+# 请使用 and 组合条件，把结果保存到 can_continue。
+
+# 练习七：输出由 30 个等号组成的分隔线，再输出成绩等级。
+
+# 练习八：使用 if...else 根据 can_continue 输出结论。
+# - 可以继续：输出“所有要求均已达到，可以进入下一课。”
+# - 不可继续：输出“当前仍有要求未达到，请查看具体建议。”
+
+# 练习九：使用一组 if...elif...else 给出一条具体建议。
+# 建议按以下优先顺序判断：
+# 1. 成绩范围无效：提示输入 0 到 100 之间的分数；
+# 2. 成绩未通过：提示复习并重新测验；
+# 3. 练习未完成：提示完成课堂练习；
+# 4. 学习时间不足：提示每天至少安排 1 小时；
+# 5. 以上问题都不存在：提示保持节奏继续学习。
+#
+# 注意：这里使用 elif 是为了每次只输出当前优先级最高的一条建议。
+
+# 练习十：使用 f-string 输出完整评估数据，至少包括：
+# daily_hours、practice_finished、score、score_level 和 can_continue。
+
+# 完成后必须使用以下六组数据分别运行：
+#
+# 第一组：2.5、yes、95
+# 预期：优秀，可以继续。
+#
+# 第二组：1.5、yes、75
+# 预期：合格，可以继续。
+#
+# 第三组：0.5、yes、75
+# 预期：合格，但学习时间不足，不能继续。
+#
+# 第四组：2、no、80
+# 预期：良好，但练习未完成，不能继续。
+#
+# 第五组：2、yes、50
+# 预期：未通过，不能继续。
+#
+# 第六组：2、yes、120
+# 预期：输入无效，不能继续。
+
+
+# 完成后进行自查：
+# 1. 每个 if、elif、else 末尾是否都有英文冒号；
+# 2. 同一分支的代码是否统一缩进四个空格；
+# 3. 分数范围校验是否早于成绩等级判断；
+# 4. 成绩等级条件是否从高分向低分排列；
+# 5. can_continue 是否组合了全部四个条件；
+# 6. 六组测试数据是否分别进入了正确分支。
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..d4cedff
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,128 @@
+# Python 零基础教学项目协作规范
+
+## 一、项目定位
+
+本项目用于帮助没有 Python 基础的学习者，从基础语法开始，逐步掌握面向对象、数据库编程、FastAPI、Django，以及后端项目工程化与部署知识。
+
+教学过程必须循序渐进。不得在没有解释基础概念的情况下，直接使用复杂语法、框架功能或专业术语。
+
+## 二、语言要求
+
+1. 所有回答、课程文档、练习说明和代码注释必须使用中文。
+2. 变量名、函数名、类名等代码标识符使用规范的英文命名，避免使用拼音。
+3. 专业术语第一次出现时，必须同时给出中文解释和英文原词。例如：对象关系映射（Object Relational Mapping，ORM）。
+4. 错误信息可以保留英文原文，但必须补充中文解释。
+
+## 三、教学对象
+
+默认学习者是零基础新手，不假设学习者已经掌握以下知识：
+
+- 编程语言基础；
+- 命令行操作；
+- Git；
+- HTTP；
+- SQL；
+- 数据库；
+- Web 框架；
+- 软件测试与部署。
+
+讲解新知识时，应先说明“它是什么”“为什么需要它”，再说明“如何使用它”。
+
+## 四、课程组织规范
+
+每一课原则上包含以下内容：
+
+1. **本课目标**：说明完成本课后能够做什么。
+2. **前置知识**：列出学习本课需要掌握的内容。
+3. **概念讲解**：使用通俗语言解释核心概念。
+4. **示例代码**：提供可以独立运行的完整示例。
+5. **运行方法**：明确说明在哪个目录、执行什么命令。
+6. **运行结果**：展示正常情况下应看到的结果。
+7. **逐行解析**：解释关键代码的作用和执行顺序。
+8. **常见错误**：说明新手容易遇到的问题、原因和解决办法。
+9. **课堂练习**：提供由浅入深的练习题。
+10. **参考答案**：与题目适当分隔，避免学习者直接照抄。
+11. **本课小结**：回顾本课最重要的知识点。
+12. **验收标准**：提供可检查、可验证的完成条件。
+
+每次课程只引入少量新概念。引用尚未讲解的知识时，必须补充简短说明或明确标注将在后续章节学习。
+
+## 五、代码编写规范
+
+1. 示例代码必须优先保证清晰、易懂和可运行，再考虑简写或高级技巧。
+2. 编写的代码必须参考项目原有注释格式，并为新手提供详尽的中文注释。
+3. 注释应重点解释代码的目的、关键步骤和容易误解的地方，避免只把代码逐字翻译成中文。
+4. 每个示例应尽量只演示一个主要知识点。
+5. 文件名、变量名、函数名和类名应做到见名知意。
+6. Python 代码遵循 PEP 8 基本风格规范。
+7. 函数和类应根据当前课程进度逐步添加类型注解，不得在入门阶段堆叠复杂类型。
+8. 涉及密码、密钥和数据库连接信息时，必须使用环境变量或示例配置，不得提交真实敏感信息。
+9. 数据库写入、文件删除等可能产生副作用的操作，必须提前说明影响并提供安全的练习方式。
+
+## 六、变更流程
+
+1. 修改或新增文件前，必须先说明修改方案、涉及文件和预期结果。
+2. 对本教学项目范围内的常规课程文档、示例代码和练习，说明方案后可以直接执行，无需逐次等待学习者确认。
+3. 不得一次性创建大量后续课程代码，课程内容必须跟随学习者的实际进度逐课创建。
+4. 每次修改完成后，应检查文件状态，并执行与改动范围相匹配的验证。
+5. 不得擅自删除、覆盖学习者已有的练习代码。
+6. 如果学习者的代码存在问题，应先解释原因，再提出修改方案。
+7. 删除文件、覆盖学习者已有内容、大范围重构或执行其他可能难以恢复的操作前，仍须先说明影响并取得学习者确认。
+
+## 七、目录规划规范
+
+课程内容按“阶段目录 → 课程目录”的层级存放，并遵循以下统一命名规范：
+
+1. 阶段目录格式为 `两位阶段编号_阶段名称`，例如 `01_python基础`。
+2. 课程目录格式为 `阶段号_课程序号_课程主题`，例如 `1_1_hello_world`、`1_2_变量与数据类型`。
+3. 编号、单词和主题之间统一使用半角下划线 `_`，不得使用空格或连字符。
+4. 课程主题优先使用中文，例如 `变量与数据类型`、`类与对象`。
+5. Python、Web、HTTP、JSON、SQL、FastAPI、Django、Git、Docker、`hello_world` 等通用技术名或教学惯例，可以保留规范英文名称。
+6. 英文名称统一采用业界常见写法；目录中的普通英文单词使用小写，避免同一名称出现多套写法。
+7. 综合项目放在所属阶段内，不另外创建脱离阶段编号的项目目录。
+
+规划中的阶段目录如下：
+
+```text
+Python/
+├── README.md
+├── AGENTS.md
+├── 01_python基础/
+│   ├── 1_1_hello_world/
+│   └── 1_2_变量与数据类型/
+├── 02_python进阶/
+├── 03_面向对象/
+├── 04_数据库/
+├── 05_web基础/
+├── 06_fastapi/
+├── 07_django/
+└── 08_工程化与部署/
+```
+
+以上结构是课程规划示意，不代表需要提前创建全部目录。目录必须按照学习者的实际学习进度依次创建：
+
+1. 正式开始某一课时，才创建该课所属的阶段目录和课程目录。
+2. 每个课程目录应随课程一起创建中文讲义、示例代码和练习，不单独预建空目录。
+3. 当前课程尚未开始或尚未完成时，不得批量创建后续课程目录。
+4. 完成当前课程并经学习者确认继续后，才能准备下一课目录。
+5. 根目录 `README.md` 应同步记录当前学习进度和下一课内容。
+
+## 八、教学互动规范
+
+1. 默认一次推进一课，并等待学习者完成练习或确认继续。
+2. 不直接替学习者完成所有练习，应优先提供提示和思考方向。
+3. 学习者提交代码后，应从正确性、可读性和知识掌握情况三个方面反馈。
+4. 发现知识断层时，应回到对应基础内容补充讲解。
+5. 学习者说“继续”时，应先简短回顾上一课，再开始下一课。
+6. 每完成一个阶段，应安排复习、测试和综合小项目。
+
+## 九、阶段验收目标
+
+- Python 基础：能够独立编写命令行小程序。
+- Python 进阶：能够组织多文件程序并处理文件和异常。
+- 面向对象：能够用类设计一个小型业务模型。
+- 数据库：能够使用 SQL 和 Python 完成安全的增删改查。
+- Web 基础：能够解释一次 HTTP 请求和响应的基本过程。
+- FastAPI：能够开发带数据库和身份认证的 RESTful API。
+- Django：能够开发包含后台管理和用户系统的 Web 应用。
+- 工程化：能够为项目编写测试、管理配置并完成基础部署。
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..5637861
--- /dev/null
+++ b/README.md
@@ -0,0 +1,218 @@
+# Python 零基础到 Web 后端开发教程
+
+## 项目作用
+
+这是一个面向编程新手的 Python 教学项目。项目将从最基础的语法开始，通过讲解、示例、练习和阶段项目，逐步带领学习者掌握 Python 编程、面向对象、数据库开发、FastAPI、Django，以及后端项目常用的工程化知识。
+
+本项目不是只供阅读的代码示例集合，而是一套可以逐课学习、亲手练习、逐步完成项目的课程。每个知识点都会说明它是什么、为什么需要它、如何使用它，以及使用时容易出现哪些错误。
+
+## 适合人群
+
+- 从未学习过编程的零基础学习者；
+- 学过少量 Python，但基础不够系统的学习者；
+- 希望从 Python 基础过渡到 Web 后端开发的学习者；
+- 希望学习 Django 或 FastAPI，但不知道如何开始的学习者。
+
+## 最终学习目标
+
+完成全部课程后，你将能够：
+
+1. 阅读和编写常见的 Python 程序；
+2. 使用函数、模块、包和异常处理组织代码；
+3. 使用面向对象思想设计类和业务模型；
+4. 编写 SQL，并通过 Python 安全地操作数据库；
+5. 理解 HTTP、JSON 和 RESTful API 的基本原理；
+6. 使用 FastAPI 开发后端接口；
+7. 使用 Django 开发完整的 Web 管理系统；
+8. 为项目添加测试、日志、配置管理和基础部署能力；
+9. 独立完成一个包含数据库、接口和用户认证的后端项目。
+
+## 学习路线
+
+### 第一阶段：Python 基础语法
+
+- 安装 Python 和开发工具；
+- 运行第一个 Python 程序；
+- 变量与基本数据类型；
+- 输入、输出和类型转换；
+- 运算符；
+- 条件判断；
+- `for` 循环与 `while` 循环；
+- 字符串；
+- 列表、元组、字典和集合；
+- 函数；
+- 基础综合项目：命令行记账或通讯录程序。
+
+### 第二阶段：Python 进阶
+
+- 模块与包；
+- 文件和目录操作；
+- 异常处理；
+- 列表推导式等常用简化写法；
+- 迭代器与生成器；
+- 装饰器；
+- 类型注解；
+- 虚拟环境与依赖管理；
+- 进阶综合项目：多文件任务管理程序。
+
+### 第三阶段：面向对象编程
+
+- 类与对象；
+- 属性和方法；
+- 构造方法；
+- 实例属性与类属性；
+- 封装；
+- 继承；
+- 多态；
+- 常用特殊方法；
+- 面向对象综合项目：图书管理系统。
+
+### 第四阶段：数据库编程
+
+- 数据库和关系型数据库的基本概念；
+- SQL 基础语法；
+- 表、字段、主键和外键；
+- 数据的新增、查询、修改和删除；
+- 条件查询、排序、分组和关联查询；
+- 索引与事务基础；
+- Python 连接 MySQL 或 PostgreSQL；
+- 参数化查询与 SQL 注入防护；
+- SQLAlchemy 对象关系映射；
+- 数据库综合项目：持久化图书管理系统。
+
+### 第五阶段：Web 开发基础
+
+- 浏览器、客户端和服务器；
+- HTTP 请求与响应；
+- URL、请求方法和状态码；
+- JSON 数据格式；
+- RESTful API 设计；
+- 使用接口调试工具发送请求；
+- 前端与后端的基本交互过程。
+
+### 第六阶段：FastAPI
+
+- 创建 FastAPI 项目；
+- 路由和请求方法；
+- 路径参数、查询参数和请求体；
+- 使用 Pydantic 校验数据；
+- 统一响应和异常处理；
+- 依赖注入；
+- 集成 SQLAlchemy；
+- 数据库迁移；
+- 用户注册、登录和身份认证；
+- 自动生成的接口文档；
+- FastAPI 综合项目：任务管理 API。
+
+### 第七阶段：Django
+
+- 创建 Django 项目和应用；
+- Django 的项目结构；
+- URL、视图和模板；
+- Model 与 ORM；
+- 数据库迁移；
+- 表单和数据校验；
+- Admin 管理后台；
+- 静态文件和媒体文件；
+- 用户、权限和身份认证；
+- Django REST Framework；
+- Django 综合项目：内容或业务管理系统。
+
+### 第八阶段：工程化与部署
+
+- Git 基础和版本管理；
+- 单元测试与接口测试；
+- 日志记录；
+- 环境变量和多环境配置；
+- 代码格式与质量检查；
+- Docker 基础；
+- Web 服务部署入门；
+- 最终项目整理与复盘。
+
+## 建议的学习方式
+
+1. 按目录编号依次学习，不要跳过基础章节。
+2. 阅读讲解后，亲手输入示例代码，不要只复制粘贴。
+3. 先独立完成练习，再查看提示或参考答案。
+4. 遇到错误时，先阅读错误信息，并记录自己尝试过的解决办法。
+5. 每学习一小节就运行代码，避免积累大量问题后再统一调试。
+6. 每完成一个阶段，都要完成阶段测试和综合项目。
+
+## 每课的基本结构
+
+```text
+本课目标
+前置知识
+概念讲解
+完整示例
+运行方法与预期结果
+关键代码解析
+常见错误
+课堂练习
+练习提示与参考答案
+本课小结
+验收标准
+```
+
+## 目录命名规范
+
+课程采用“阶段目录 → 课程目录”的两级结构，并统一遵守以下规则：
+
+- 阶段目录使用 `两位阶段编号_阶段名称`，例如 `01_python基础`。
+- 课程目录使用 `阶段号_课程序号_课程主题`，例如 `1_1_hello_world`。
+- 目录名统一使用下划线 `_` 连接，不使用空格或连字符。
+- 课程主题优先使用中文，例如 `1_2_变量与数据类型`。
+- Python、Web、HTTP、JSON、SQL、FastAPI、Django、Git、Docker、`hello_world` 等通用技术名或教学惯例保留规范英文名称。
+- 普通英文目录名统一使用小写，避免出现不同大小写或多套命名方式。
+
+## 计划中的项目目录
+
+```text
+Python/
+├── README.md
+├── AGENTS.md
+├── 01_python基础/
+│   ├── 1_1_hello_world/
+│   ├── 1_2_变量与数据类型/
+│   └── 1_3_输入与输出/
+├── 02_python进阶/
+├── 03_面向对象/
+├── 04_数据库/
+├── 05_web基础/
+├── 06_fastapi/
+├── 07_django/
+└── 08_工程化与部署/
+```
+
+这只是目录规划示意，不会提前创建全部目录。正式开始某一课时，才会创建对应的阶段目录、课程目录、中文讲义、示例代码和练习；完成当前课程并确认继续后，再创建下一课。
+
+## 当前学习进度
+
+- 当前阶段：第一阶段——Python 基础语法。
+- 当前课程：`1_5_条件判断`。
+- 当前状态：第五课学习中。
+- 已完成课程：`1_1_hello_world`、`1_2_变量与数据类型`、`1_3_输入与输出`、`1_4_运算符`。
+- 已创建课程目录：`01_python基础/1_1_hello_world/`、`01_python基础/1_2_变量与数据类型/`、`01_python基础/1_3_输入与输出/`、`01_python基础/1_4_运算符/`、`01_python基础/1_5_条件判断/`。
+- 下一步：阅读第五课讲义、运行分支示例并完成课堂练习。
+
+## 建议环境
+
+- 操作系统：Windows 10 或 Windows 11；
+- Python：学习开始时选择当前稳定版本；
+- 编辑器：PyCharm 或 Visual Studio Code；
+- 命令行：PowerShell；
+- 数据库：前期可使用 SQLite，后期学习 MySQL 或 PostgreSQL；
+- 浏览器：Chrome、Edge 或其他现代浏览器。
+
+具体版本和安装步骤将在第一课中核对并讲解，避免因为版本变化使用过时的安装方式。
+
+## 下一步
+
+下一课将学习：
+
+1. Python 是什么；
+2. 程序、编程语言和解释器分别是什么；
+3. 如何检查电脑是否已经安装 Python；
+4. 如何安装并验证 Python；
+5. 如何创建和运行第一个 `hello_world.py` 程序；
+6. 如何理解第一行 Python 代码。