3509 lines
102 KiB
Markdown
3509 lines
102 KiB
Markdown
# 🐍 Python 程序设计基础
|
||
|
||
## 1.1 编程世界初探
|
||
|
||
> "程序是一系列执行特定任务或解决问题的指令集合，类似于烹饪中的步骤流程。"
|
||
|
||
### 程序的定义
|
||
|
||
在计算机科学中，程序是指令的集合，用于描述计算机如何完成特定任务。程序的核心在于**指令的顺序**，错误的顺序可能导致任务失败。
|
||
|
||
### 程序设计语言的分类
|
||
|
||
程序设计语言分为**低级语言**和**高级语言**：
|
||
|
||
- **低级语言**：
|
||
- **机器语言**：由二进制代码（0 和 1）组成，直接由计算机硬件执行。
|
||
- **汇编语言**：使用助记符（如 `MOV`, `ADD`）代替二进制代码，需要通过汇编器转换为机器语言。
|
||
|
||
- **高级语言**：更接近自然语言，易于阅读和维护，需要通过编译器或解释器转换为机器语言。常见的高级语言包括：
|
||
- **C 语言**：面向过程，适合系统编程和嵌入式开发。
|
||
- **C++**：面向对象，适合游戏开发和高性能应用。
|
||
- **Python**：跨平台、易读性强，适合 Web 开发、数据科学和自动化。
|
||
- **Java**：跨平台，适合企业级应用和安卓开发。
|
||
- **JavaScript**：Web 开发核心，支持前后端开发。
|
||
- **C#**：与 .NET 框架紧密集成，适合 Windows 应用和游戏开发。
|
||
|
||
### 程序设计语言的应用领域
|
||
|
||
| 编程语言 | 主要特点 | 常见的应用领域 |
|
||
| ---------- | ---------------------- | -------------------------- |
|
||
| C 语言 | 高效、控制能力强 | 系统编程、嵌入式开发 |
|
||
| C++ | 面向对象、性能强 | 游戏开发、高性能应用 |
|
||
| Python | 易读、库支持丰富 | Web 开发、数据科学、自动化 |
|
||
| Java | 跨平台、生态系统强大 | 企业级应用、安卓开发 |
|
||
| JavaScript | Web 开发核心 | 前端开发、部分后端应用 |
|
||
| C# | 面向对象、与 .NET 集成 | Windows 应用、游戏开发 |
|
||
|
||
### 程序设计中的顺序逻辑
|
||
|
||
程序设计中的指令顺序至关重要，类似于烹饪中的步骤流程。例如，番茄炒蛋的步骤必须按特定顺序执行，否则会影响最终结果。
|
||
|
||
#### 示例：番茄炒蛋的步骤
|
||
1. 准备材料
|
||
2. 切割番茄
|
||
3. 打蛋
|
||
4. 烹饪番茄
|
||
5. 烹饪鸡蛋
|
||
6. 混合炒制
|
||
7. 出锅装盘
|
||
|
||
## 1.2 初识 Python 语言
|
||
|
||
### Python 的特点
|
||
|
||
- **简洁语法**：Python 的语法简洁明了，易于学习和使用。
|
||
- **动态类型系统**：变量类型在运行时自动推断，无需显式声明。
|
||
- **多种编程范式**：支持面向对象、过程式和函数式编程。
|
||
- **丰富的标准库**：提供了大量内置模块，简化开发流程。
|
||
- **解释型语言**：代码无需编译，直接解释执行，加快了测试和调试过程。
|
||
|
||
### Python 的应用领域
|
||
|
||
- **数据分析**：Python 是数据科学领域的首选语言，拥有强大的数据处理和分析库（如 Pandas、NumPy）。
|
||
- **机器学习**：Python 在机器学习领域广泛应用，支持多种机器学习框架（如 TensorFlow、PyTorch）。
|
||
- **Web 开发**：Python 的 Web 框架（如 Django、Flask）简化了 Web 应用的开发。
|
||
- **自动化**：Python 可以用于自动化任务，如文件处理、网络爬虫等。
|
||
|
||
### Python 的开发环境
|
||
|
||
- **PyCharm**：Python 开发者常用的集成开发环境（IDE），提供代码编辑、调试、运行等功能。
|
||
- **Jupyter Notebook**：交互式编程环境，适合数据分析和可视化。
|
||
- **VS Code**：轻量级代码编辑器，支持多种编程语言，包括 Python。
|
||
|
||
### Python 的历史
|
||
|
||
Python 由 Guido van Rossum 于 1989 年创建，1991 年首次发布。Python 的设计哲学强调代码的可读性和简洁性，因此它成为了初学者和专业开发者的首选语言。
|
||
|
||
---
|
||
|
||
# 📚 练习巩固
|
||
|
||
## 一、单项选择题
|
||
|
||
1. 机器语言是由（）组成的。
|
||
- A. 助记符
|
||
- B. 高级编程语法
|
||
- C. 二进制代码
|
||
- D. 文本指令
|
||
- **答案：C**
|
||
|
||
2. 以下选项中，Python 语言最适合的项目是（）。
|
||
- A. 系统底层开发
|
||
- B. 数据科学和 Web 开发
|
||
- C. 高性能游戏开发
|
||
- D. 直接控制硬件
|
||
- **答案：B**
|
||
|
||
3. 汇编语言与机器语言相比，其主要优势是（）。
|
||
- A. 更高的执行效率
|
||
- B. 更易于阅读和编写
|
||
- C. 跨平台兼容性
|
||
- D. 自动内存管理
|
||
- **答案：B**
|
||
|
||
4. 高级语言的一个主要特点是（）。
|
||
- A. 直接由硬件执行
|
||
- B. 需要手动管理内存
|
||
- C. 提供丰富的语法结构和高层次抽象
|
||
- D. 无须通过编译器或解释器
|
||
- **答案：C**
|
||
|
||
5. JavaScript 主要用于（）的开发。
|
||
- A. 嵌入式系统
|
||
- B. 桌面应用
|
||
- C. Web 前端
|
||
- D. 系统底层编程
|
||
- **答案：C**
|
||
|
||
6. C# 语言主要与（）相关联。
|
||
- A. .NET 框架
|
||
- B. JRE
|
||
- C. Linux 系统
|
||
- D. Apache 服务器
|
||
- **答案：A**
|
||
|
||
## 二、填空题
|
||
|
||
1. 在计算机程序中，$\qquad$ 是由程序员编写的，用来指示计算机执行特定任务的指令集合。
|
||
- **答案：程序**
|
||
|
||
2. $\qquad$ 是一种低级编程语言，其代码使用助记符表示，更接近于人类语言。
|
||
- **答案：汇编语言**
|
||
|
||
3. Java 语言以其 $\qquad$ 能力而闻名，这使得基于 Java 的程序可以在多种不同的平台上运行。
|
||
- **答案：跨平台**
|
||
|
||
4. 高级编程语言通常具有强大的 $\qquad$，极大地简化了编程过程和问题解决。
|
||
- **答案：抽象能力**
|
||
|
||
# 🐍 Python 的应用领域与面向对象编程（OOP）
|
||
|
||
## 📊 Python 的应用领域
|
||
|
||
### 1. 网络爬虫
|
||
> **网络爬虫**（Web Crawler）是一种自动化程序，用于从互联网上抓取数据。Python 提供了强大的库如 **BeautifulSoup** 和 **Scrapy**，使得数据抓取和处理变得更加便捷。
|
||
|
||
**示例：**
|
||
在新闻和舆情分析中，Python 可以快速收集新闻内容并进行分析，帮助企业了解市场动向和公众情绪。
|
||
|
||
### 2. 数据处理
|
||
Python 在数据处理方面表现出色，尤其是在数据分析和科学计算领域。常用的库包括 **NumPy**、**Pandas** 和 **Matplotlib**。
|
||
|
||
**示例：**
|
||
学校可以通过 Python 程序统计学生的跑步成绩，计算平均成绩、最高成绩和最低成绩。
|
||
|
||
### 3. Web 开发
|
||
Python 的 **Django** 和 **Flask** 框架为 Web 开发提供了强大的支持，简化了用户认证、表单处理、数据库交互等常见任务。
|
||
|
||
**示例：**
|
||
知名网站如豆瓣、美团、知乎等均采用了 Python 作为其技术开发的基础设施。
|
||
|
||
### 4. 人工智能
|
||
Python 配合 **TensorFlow** 和 **PyTorch** 等深度学习框架，极大地促进了机器学习模型的开发，成为人工智能领域的主流语言。
|
||
|
||
### 5. 游戏开发
|
||
虽然 Python 在大型游戏开发中不是主流选择，但通过 **Pygame** 等库，它为 2D 游戏的制作提供了支持，适合教育、原型设计和独立游戏开发。
|
||
|
||
## 🧩 面向对象编程（OOP）
|
||
|
||
### 1. 类（Class）
|
||
> **类** 是对象的模板，定义了一组对象共有的属性和方法。
|
||
|
||
**示例：**
|
||
在描述小明时，类可以定义他的基本特征（如名字、年龄、身高）和行为（如说话、跑步）。
|
||
|
||
### 2. 对象（Object）
|
||
> **对象** 是类的实例，拥有类中定义的属性和方法。
|
||
|
||
**示例：**
|
||
小明是一个对象，他拥有类中定义的属性（名字、年龄、身高）和行为（说话、跑步）。
|
||
|
||
### 3. 属性（Attributes）
|
||
> **属性** 是用来描述对象特征或状态的信息。
|
||
|
||
**示例：**
|
||
小明的名字、年龄和身高是他的属性。
|
||
|
||
### 4. 行为（Methods）
|
||
> **行为** 是对象可以执行的动作或方法。
|
||
|
||
**示例：**
|
||
小明的行为包括说话、跑步等。
|
||
|
||
### 5. 其他 OOP 特性
|
||
- **继承**：子类可以继承父类的属性和方法。
|
||
- **封装**：隐藏对象的内部实现细节，只暴露必要的接口。
|
||
- **多态**：同一个方法在不同对象中可以有不同实现。
|
||
|
||
## 📜 Python 的发展历史
|
||
|
||
| 年份 | 事件描述 |
|
||
| :--: | :-----------------------------------------------------: |
|
||
| 1989 | 吉多・范罗苏姆开始创建 Python 编程语言。 |
|
||
| 1991 | Python 0.9.0 版本首次发布。 |
|
||
| 2000 | Python 2.0 版本发布，引入列表推导、垃圾回收等特性。 |
|
||
| 2008 | Python 3.0 版本发布，引入 Unicode 支持、新的 I/O 库等。 |
|
||
| 2020 | Python 2.7.18 版本为 Python 2.x 的最后一个版本。 |
|
||
|
||
## 🌟 Python 的特点
|
||
|
||
1. **语法简洁**：Python 的语法设计简洁、清晰，强调代码的可读性。
|
||
2. **免费开源**：Python 是一个免费开源的编程语言，拥有庞大的开发者社区。
|
||
3. **跨平台性**：Python 可以在多种操作系统上运行，如 Windows、Linux 和 Mac OS。
|
||
4. **强大的库**：Python 拥有丰富的内置库和第三方库，如 **NumPy**、**Pandas**、**Matplotlib** 等。
|
||
5. **解释型语言**：Python 是解释型语言，程序在执行时由解释器逐行将源代码转换为机器码。
|
||
|
||
|
||
|
||
# 📐 流程图与海龟绘图
|
||
|
||
## 1. 流程图基础
|
||
|
||
### 流程图符号与含义
|
||
| 符号 | 含义 |
|
||
| ---------- | ----------- |
|
||
| 矩形 | 处理框 |
|
||
| 菱形 | 判断框 |
|
||
| 平行四边形 | 输入/输出框 |
|
||
| 圆角矩形 | 开始/结束框 |
|
||
|
||
### 判断直角三角形
|
||
- **条件**：判断三边是否满足勾股定理，即 $a^2 + b^2 = c^2$。
|
||
- **输出**：
|
||
- 如果满足，输出“是直角三角形！”
|
||
- 否则，输出“不是直角三角形！”
|
||
|
||
### 绘制正方形与正五边形
|
||
- **正方形**：重复 4 次，每次前进 100 像素，左转 90 度。
|
||
- **正五边形**：重复 5 次，每次前进 100 像素，左转 72 度。
|
||
|
||
## 2. 海龟绘图（turtle）
|
||
|
||
### 基本概念
|
||
- **turtle 模块**：Python 中用于绘图的模块，通过控制“海龟”在画布上移动来绘制图形。
|
||
- **默认方向**：海龟初始方向为向右（x 轴正方向），左转和右转基于当前方向。
|
||
|
||
### 常用指令
|
||
| 指令 | 功能描述 |
|
||
| ----------------------- | --------------------------- |
|
||
| `turtle.forward(n)` | 前进 n 像素 |
|
||
| `turtle.backward(n)` | 后退 n 像素 |
|
||
| `turtle.left(angle)` | 左转 angle 度 |
|
||
| `turtle.right(angle)` | 右转 angle 度 |
|
||
| `turtle.color(m, n)` | 设置画笔颜色 m 和填充颜色 n |
|
||
| `turtle.begin_fill()` | 开始填充颜色 |
|
||
| `turtle.end_fill()` | 结束填充颜色 |
|
||
| `turtle.circle(radius)` | 绘制半径为 radius 的圆 |
|
||
| `turtle.pensize(n)` | 设置画笔宽度为 n 像素 |
|
||
| `turtle.done()` | 结束绘图并保留结果 |
|
||
|
||
### 示例代码
|
||
#### 绘制红色边框的圆
|
||
```python
|
||
import turtle
|
||
turtle.color("red")
|
||
turtle.circle(50)
|
||
turtle.done()
|
||
```
|
||
|
||
#### 绘制五角星
|
||
```python
|
||
import turtle
|
||
turtle.color("red", "yellow")
|
||
turtle.begin_fill()
|
||
for i in range(5):
|
||
turtle.forward(200)
|
||
turtle.right(144)
|
||
turtle.end_fill()
|
||
turtle.done()
|
||
```
|
||
|
||
#### 绘制螺旋线
|
||
```python
|
||
import turtle
|
||
turtle.pensize(5)
|
||
for x in range(20):
|
||
turtle.forward(10 * x)
|
||
turtle.left(90)
|
||
turtle.done()
|
||
```
|
||
|
||
#### 绘制同心圆
|
||
```python
|
||
import turtle
|
||
turtle.color("red")
|
||
turtle.begin_fill()
|
||
turtle.circle(100)
|
||
turtle.end_fill()
|
||
turtle.penup()
|
||
turtle.goto(0, 40)
|
||
turtle.pendown()
|
||
turtle.color("yellow")
|
||
turtle.begin_fill()
|
||
turtle.circle(65)
|
||
turtle.end_fill()
|
||
turtle.done()
|
||
```
|
||
|
||
#### 绘制正六边形
|
||
```python
|
||
import turtle
|
||
turtle.hideturtle()
|
||
turtle.pensize(8)
|
||
turtle.color("blue", "pink")
|
||
turtle.penup()
|
||
turtle.goto(-50, -50)
|
||
turtle.pendown()
|
||
turtle.begin_fill()
|
||
for x in range(6):
|
||
turtle.forward(100)
|
||
turtle.left(60)
|
||
turtle.end_fill()
|
||
turtle.done()
|
||
```
|
||
|
||
## 3. 练习题
|
||
|
||
### 单项选择题
|
||
1. 常用流程图的输入输出框形状是（）。
|
||
- A. 圆形
|
||
- B. 菱形
|
||
- C. 平行四边形
|
||
- D. 矩形
|
||
**答案：C**
|
||
|
||
2. 流程图中表示“处理”的图形是（）。
|
||
- A. 矩形
|
||
- B. 菱形
|
||
- C. 圆角矩形
|
||
- D. 平行四边形
|
||
**答案：A**
|
||
|
||
3. 在流程图中，菱形表示算法的（）。
|
||
- A. 判断
|
||
- B. 处理
|
||
- C. 输入
|
||
- D. 输出
|
||
**答案：A**
|
||
|
||
4. 流程图中图形表示的是（）。
|
||
- A. 处理框
|
||
- B. 判断框
|
||
- C. 开始/结束框
|
||
- D. 输入/输出框
|
||
**答案：B**
|
||
|
||
5. 人们将这种运用信息技术解决问题的一系列计算步骤称为（）。
|
||
- A. 过程
|
||
- B. 流程
|
||
- C. 处理
|
||
- D. 算法
|
||
**答案：D**
|
||
|
||
### 绘制流程图题
|
||
1. **等腰直角三角形**：已知直角边长为 100 像素，斜边长为 141 像素，思考每次左转的度数并绘制流程图。
|
||
2. **平行四边形**：要求相邻两边长从键盘输入，锐角夹角为 6 度，思考钝角的角度并绘制流程图。
|
||
3. **同心圆**：已知外圆半径为 120 像素，内圆半径为 60 像素，外圆边框为蓝色，内圆边框为红色，绘制流程图。
|
||
|
||
# 🐢 海龟绘图与Python基础
|
||
|
||
## 绘制正六边形
|
||
|
||
> "通过修改重复次数，可以实现不同形状的绘制。"
|
||
|
||
### 代码解析
|
||
|
||
1. **隐藏海龟图标**：`turtle.hideturtle()`
|
||
2. **定位起始坐标**：`turtle.goto($-50, -50$)`
|
||
3. **重复6次**：
|
||
- 前移100像素：`turtle.forward(100)`
|
||
- 左转60度：`turtle.left(60)`
|
||
4. **填充内容**：`"penup()"`、`"pendown()"`、`"begin_fill()"`、`"end_fill()"`
|
||
|
||
###
|
||
## 绘制交通停止指示
|
||
|
||
### 代码解析
|
||
|
||
1. **隐藏海龟图标**：`turtle.hideturtle()`
|
||
2. **设置颜色**：`turtle.color("red")`
|
||
3. **绘制外圆**：
|
||
- 提笔：`turtle.penup()`
|
||
- 定位：`turtle.goto(0, -60)`
|
||
- 落笔：`turtle.pendown()`
|
||
- 开始填充：`turtle.begin_fill()`
|
||
- 绘制圆：`turtle.circle(60)`
|
||
- 结束填充：`turtle.end_fill()`
|
||
4. **绘制内圆**：
|
||
- 提笔：`turtle.penup()`
|
||
- 定位：`turtle.goto(0, -50)`
|
||
- 落笔：`turtle.pendown()`
|
||
- 设置颜色：`turtle.color("blue")`
|
||
- 开始填充：`turtle.begin_fill()`
|
||
- 绘制圆：`turtle.circle(50)`
|
||
- 结束填充：`turtle.end_fill()`
|
||
5. **绘制斜线**：
|
||
- 提笔：`turtle.penup()`
|
||
- 定位：`turtle.goto(-35, 35)`
|
||
- 落笔：`turtle.pendown()`
|
||
- 设置画笔宽度：`turtle.pensize(10)`
|
||
- 右转45度：`turtle.right(45)`
|
||
- 开始填充：`turtle.begin_fill()`
|
||
- 前移100像素：`turtle.forward(100)`
|
||
- 结束填充：`turtle.end_fill()`
|
||
6. **结束绘图**：`turtle.done()`
|
||
|
||
|
||
|
||
## Python基础：常量与变量
|
||
|
||
### 常量与变量的定义
|
||
|
||
- **常量**：程序运行过程中值不变的量，通常用大写字母表示。
|
||
- **变量**：程序运行过程中值可变的量，需先赋值后使用。
|
||
|
||
### 变量命名规则
|
||
|
||
1. 只能包含字母、数字和下划线。
|
||
2. 不能以数字开头。
|
||
3. 区分大小写。
|
||
4. 建议使用“见名知意”的原则命名。
|
||
|
||
### 赋值语句
|
||
|
||
- **赋值符号**：`=`，将右边的值赋给左边的变量。
|
||
- **示例**：`a = 1`
|
||
|
||
### 输入与输出
|
||
|
||
- **输入**：`input("提示文字")`
|
||
- **输出**：`print(输出内容)`
|
||
|
||
## 练习巩固
|
||
|
||
### 单项选择题
|
||
|
||
1. 导入turtle库的正确方式：`import turtle`
|
||
2. `turtle.forward(90)`的含义：向前移动90像素长度
|
||
3. `turtle.right(90)`的含义：顺时针旋转90度
|
||
4. `turtle.begin_fill()`的含义：开始填充颜色
|
||
5. 正确的代码写法：`turtle.penup()`
|
||
6. 使绘图窗口不自动关闭的函数：`turtle.done()`
|
||
7. 设置画笔宽度的函数：`turtle.pensize`
|
||
8. 画出最大圆的代码：`circle(300, 360)`
|
||
9. 绘制直线的函数：`turtle.fd()`
|
||
10. 左转45度的语句：`left(45)`
|
||
|
||
### 程序填空题
|
||
|
||
1. 绘制正方形：
|
||
```python
|
||
for i in range(4):
|
||
turtle.fd(200)
|
||
turtle.left(90)
|
||
```
|
||
2. 绘制图形：
|
||
```python
|
||
for i in range(4):
|
||
turtle.circle(200, 90)
|
||
turtle.left(90)
|
||
turtle.circle(200, 90)
|
||
turtle.left(180)
|
||
```
|
||
3. 绘制螺旋图形：
|
||
```python
|
||
import turtle
|
||
turtle.pensize(3)
|
||
for j in range(40):
|
||
turtle.fd(5 * j)
|
||
turtle.left(91)
|
||
turtle.done()
|
||
```
|
||
|
||
## 常见数据标识与语句
|
||
|
||
### 标识符
|
||
|
||
1. **常量**：如`1`、`2.0`、`True`、`"周长为"`。
|
||
2. **变量**：需先赋值后使用，命名规则严格。
|
||
|
||
### 赋值、输入、输出语句
|
||
|
||
- **赋值**：`$a = 1$`
|
||
- **输入**：`name = input("请输入姓名")`
|
||
- **输出**：`print(name)`
|
||
|
||
## 举一反三
|
||
|
||
### 例1：判断变量名是否合格
|
||
|
||
- 合格变量：`a`、`my_Boolean`、`Obj2`、`_test`
|
||
- 不合格变量：`123`、`1.0`、`"周长为"`、`2ndObj`、`My words`、`jack&rose`、`break`
|
||
|
||
### 例2：绘制45度角
|
||
|
||
```python
|
||
import turtle
|
||
turtle.left(45)
|
||
turtle.forward(100)
|
||
```
|
||
|
||
### 例3：绘制等边三角形
|
||
|
||
```python
|
||
import turtle
|
||
m = 200
|
||
n = 120
|
||
turtle.forward(m)
|
||
turtle.left(n)
|
||
turtle.forward(m)
|
||
turtle.left(n)
|
||
turtle.forward(m)
|
||
turtle.left(n)
|
||
```
|
||
|
||
## 练习巩固
|
||
|
||
### 单项选择题
|
||
|
||
1. 不正确的变量名：`1_value`
|
||
2. 不是Python关键字：`final`
|
||
3. 变量命名不能以数字开头。
|
||
4. 查看变量类型的函数：`type`
|
||
5. 小驼峰命名的变量名：`myStudentCount`
|
||
|
||
### 判断题
|
||
|
||
1. 已知`$x = 3$`，执行`$x = 'abc'$`不会出错。
|
||
2. 变量长度没有限制，但不能使用关键字作为变量名。
|
||
3. 变量必须以字母或下划线开头，区分大小写。
|
||
4. 注释不会影响程序结果，但建议写注释。
|
||
|
||
### 上机调试题
|
||
|
||
1. 调试代码：
|
||
```python
|
||
a = 3
|
||
b = 5
|
||
print(4)
|
||
print(b)
|
||
print(a + b)
|
||
```
|
||
2. 绘制五边形：
|
||
```python
|
||
import turtle
|
||
for i in range(5):
|
||
turtle.forward(100)
|
||
turtle.right(72)
|
||
```
|
||
|
||
## 程序编写规范：命名与注释
|
||
|
||
编写程序时，注意命名规范和注释，提高代码可读性。
|
||
|
||
# 🐍 Python 程序编写规范与常见错误
|
||
|
||
## 关键术语与学习建议
|
||
|
||
| 关键术语 | 学习建议 |
|
||
| ---------------------- | ------------------------------------------------------------ |
|
||
| 注释、缩进、换行、并行 | 通过常见错误案例，掌握程序编写规范，养成良好编程习惯 |
|
||
| 常见出错信息诊断 | 识别并修正名称出错、类型出错、缩进出错等问题，确保程序正常运行 |
|
||
|
||
## 示例代码与错误分析
|
||
|
||
### 示例 1：`import` 大写出错
|
||
|
||
```python
|
||
Import turtle # 错误：import 应为小写
|
||
turtle.forward(200)
|
||
turtle.done()
|
||
```
|
||
|
||
**错误信息**：`invalid syntax`（无法的语法）
|
||
|
||
**解析**：`import` 关键字必须小写，否则会导致语法错误。
|
||
|
||
### 示例 2：变量大小写不一致
|
||
|
||
```python
|
||
import turtle
|
||
R = 200 # 定义变量 R
|
||
turtle.circle(r) # 错误：r 未定义
|
||
turtle.done()
|
||
```
|
||
|
||
**错误信息**：`NameError: name 'r' is not defined`（名称错误：变量 r 没有被定义）
|
||
|
||
**解析**：变量名大小写不一致，`R` 和 `r` 被视为不同的变量。
|
||
|
||
### 示例 3：缩进错误
|
||
|
||
```python
|
||
import turtle
|
||
x = 100
|
||
for 1 in range(4): # 错误：循环体未缩进
|
||
turtle.fd(x)
|
||
```
|
||
|
||
**错误信息**：`expected an indented block`（未找到预期的缩进块）
|
||
|
||
**解析**：`for` 循环的循环体必须缩进，否则会导致语法错误。
|
||
|
||
## 注释与代码缩进
|
||
|
||
### 注释
|
||
|
||
> 注释是对代码的解释和说明，目的是让使用者能够轻松地了解代码的功能，增加代码的可读性。
|
||
|
||
- **单行注释**：以 `#` 开头，到换行为止。
|
||
```python
|
||
print("绿灯行") # 输出交通安全提示
|
||
```
|
||
- **多行注释**：以三个单引号 `'''` 或三个双引号 `"""` 作为开始和结束符号。
|
||
```python
|
||
"""
|
||
版权所有:XXX 同学 @ 版权所有
|
||
创建日期:2024年5月1日
|
||
创建人:XXX
|
||
"""
|
||
```
|
||
|
||
### 代码缩进
|
||
|
||
> Python 采用代码缩进和冒号来区分代码块之间的层次。
|
||
|
||
- 缩进的空格数可以是 4 格、8 格或 tab 键。
|
||
- 同一个代码块的语句必须包含相同的缩进空格数。
|
||
|
||
```python
|
||
if a > 60:
|
||
print("合格。") # 缩进 4 个空格
|
||
else:
|
||
print("不合格。") # 缩进 4 个空格
|
||
```
|
||
|
||
## 常见错误与修正
|
||
|
||
### 例 1：缩进出错
|
||
|
||
```python
|
||
print("Hello, World!")
|
||
a = 5
|
||
b = 6
|
||
if a > b:
|
||
print("结果为 True")
|
||
print("a 大于 b") # 错误：未缩进
|
||
else:
|
||
print("结果为 False")
|
||
print("a 小于 b")
|
||
```
|
||
|
||
**修正**：将 `print("a 大于 b")` 缩进，使其属于 `if` 语句块。
|
||
|
||
### 例 2：多行注释与缩进出错
|
||
|
||
```python
|
||
if True:
|
||
print("张三")
|
||
else:
|
||
print("李四")
|
||
print("王五")
|
||
""" # 错误：多行注释未正确结束
|
||
for i in range(1, 101):
|
||
print(i)
|
||
```
|
||
|
||
**修正**：确保多行注释正确结束，并调整缩进。
|
||
|
||
### 例 3：变量赋值与注释
|
||
|
||
```python
|
||
a = 1
|
||
b = 2
|
||
c = 3
|
||
# 以下代码不执行
|
||
a = 3
|
||
b = 4
|
||
c = 5
|
||
# c = 6
|
||
print(a)
|
||
print(b)
|
||
print(c)
|
||
```
|
||
|
||
**输出**：`1 2 5`
|
||
|
||
### 例 4：`turtle` 模块错误
|
||
|
||
```python
|
||
import turtle
|
||
for i in range(6): # 错误：缺少冒号
|
||
turtle.forward(100)
|
||
turtle.left(60)
|
||
turtle.Penup() # 错误：应为 penup
|
||
turtle.goto(50, 57)
|
||
turtle.Pendown() # 错误：应为 pendown
|
||
turtle.circle(30)
|
||
turtle.done # 错误：缺少括号
|
||
```
|
||
|
||
**修正**：补充冒号，修正大小写，补充括号。
|
||
|
||
## 实践挑战
|
||
|
||
### 实战 1：绘制五星红旗
|
||
|
||
```python
|
||
import turtle
|
||
|
||
# 绘制旗面
|
||
turtle.color("red")
|
||
turtle.begin_fill()
|
||
for _ in range(2):
|
||
turtle.forward(800)
|
||
turtle.right(90)
|
||
turtle.forward(500)
|
||
turtle.right(90)
|
||
turtle.end_fill()
|
||
|
||
# 绘制五角星
|
||
turtle.color("yellow")
|
||
turtle.penup()
|
||
turtle.goto(100, 200)
|
||
turtle.pendown()
|
||
turtle.begin_fill()
|
||
for _ in range(5):
|
||
turtle.forward(100)
|
||
turtle.right(144)
|
||
turtle.end_fill()
|
||
|
||
turtle.done()
|
||
```
|
||
|
||
### 实战 2：计算圆的周长与面积
|
||
|
||
```python
|
||
import math
|
||
|
||
PI = math.pi
|
||
r = 6
|
||
s = PI * r * r
|
||
print("圆的面积:", s)
|
||
```
|
||
|
||
## 单元自测
|
||
|
||
### 单项选择题
|
||
|
||
1. Python 中单行注释使用符号（）。
|
||
- A. `#`
|
||
- B. `"""`
|
||
- C. `*`
|
||
- D. `@`
|
||
**答案**：A
|
||
|
||
2. Python 采用（）来区分程序之间的层次。
|
||
- A. `||`
|
||
- B. `[]`
|
||
- C. `()`
|
||
- D. 缩进
|
||
**答案**：D
|
||
|
||
3. 关于 Python 代码的缩进，下列说法错误的是（）。
|
||
- A. Python 使用缩进来划分代码块。
|
||
- B. 错误的缩进，会使程序输出不同，但不会造成程序报错
|
||
- C. 同一个代码块的语句必须包含相同的缩进空格数。
|
||
- D. 建议在每个缩进层次使用单个制表符或两个空格或四个空格
|
||
**答案**：B
|
||
|
||
# 🐪 命名法与流程图符号
|
||
|
||
## 命名法
|
||
|
||
1. **大驼峰命名法**：每个单词首字母大写，如 `MyVariableName`。
|
||
2. **中驼峰命名法**：第一个单词首字母小写，后续单词首字母大写，如 `myVariableName`。
|
||
3. **小驼峰命名法**：与中驼峰命名法相同，如 `myVariableName`。
|
||
4. **下划线命名法**：单词之间用下划线连接，如 `my_variable_name`。
|
||
|
||
## 流程图符号
|
||
|
||
- **矩形**：表示“处理”或“操作”。
|
||
- **菱形**：表示“判断”或“条件”。
|
||
- **圆角矩形**：通常表示“开始”或“结束”。
|
||
- **平行四边形**：表示“输入”或“输出”。
|
||
|
||
# ✔️ 是非题
|
||
|
||
1. **已知 x=3 ，那么执行 x=' abc ' 将出错。**
|
||
- **错误**：Python 允许变量重新赋值，即使类型不同。
|
||
2. **在 Python 中变量的长度没有限制，但不能使用关键字作为变量名。**
|
||
- **正确**：变量名不能与 Python 关键字冲突。
|
||
3. **Python 的变量必须以字母或下划线开头，并区分字母的大小写。**
|
||
- **正确**：变量名规则要求首字符为字母或下划线，且区分大小写。
|
||
4. **在使用 Python 语言编写程序时，注释不会影响程序结果，所以没有必要写。**
|
||
- **错误**：注释有助于代码的可读性和维护性。
|
||
5. **Python 程序代码第一行的语句前面留有空格。**
|
||
- **错误**：Python 代码的第一行通常不应有缩进。
|
||
|
||
# 🧩 运行填空题
|
||
|
||
1. **执行以下代码，输出结果为 $\qquad$。**
|
||
```python
|
||
price = 1500
|
||
price = 1200
|
||
print(price)
|
||
```
|
||
- **输出结果**：`1200`
|
||
|
||
2. **判断下列代码的输出结果， a 、 b 、 c 的值分别是（）、（）、（）。**
|
||
|
||
```python
|
||
a = 1
|
||
b = 2
|
||
c = 3
|
||
a = 3
|
||
b = 4
|
||
c = 5
|
||
print(a) # 打印 a 的值
|
||
print(b) # 打印 b 的值
|
||
print(c) # 打印 c 的值
|
||
```
|
||
- **输出结果**：`a = 3`, `b = 4`, `c = 5`
|
||
|
||
# 🖥️ 上机调试题
|
||
|
||
1. **绘制一个菱形（边长 200 像素，夹角锐角 60 度），画出流程图，并填空，运行调试。**
|
||
```python
|
||
import turtle
|
||
for i in range(2):
|
||
turtle.forward(200)
|
||
turtle.right(60)
|
||
turtle.forward(200)
|
||
turtle.right(120)
|
||
turtle.done()
|
||
```
|
||
|
||
2. **计算圆的周长和面积（半径为 $r$ ，通过键盘输入），画出流程图，并填空，运行调试。**
|
||
```python
|
||
r = int(input("请输入半径 r: "))
|
||
c = 2 * 3.14 * r
|
||
s = 3.14 * r * r
|
||
print("周长=", c, "面积=", s)
|
||
```
|
||
|
||
# 📚 程序世界中的数据奥秘
|
||
|
||
## 数据类型
|
||
|
||
数据类型是程序中对数据的分类，使得代码更加清晰易懂，提高了代码的可读性和可维护性。Python 中的基本数据类型包括：
|
||
|
||
1. **数值**：整数、浮点数、复数。
|
||
2. **字符串**：文本数据。
|
||
3. **列表**：有序且可变的序列。
|
||
4. **元组**：有序且不可变的序列。
|
||
5. **集合**：无序且不重复的元素集合。
|
||
6. **字典**：键值对的无序集合。
|
||
|
||
## 学习目标
|
||
|
||
- 理解并应用数据类型的概念。
|
||
- 掌握不同数据类型的基本使用方法。
|
||
- 理解数据类型之间的转换方法。
|
||
|
||
# 🎭 单元情景
|
||
|
||
通过 Python 程序编写，深入研究数据类型在编程中的应用。例如，整理和分类中国传统语言文化中的诗词、成语和对联等信息。
|
||
|
||
## 3.1 生活中的编码：数据类型的概念
|
||
|
||
### 数据类型的作用
|
||
|
||
- **组织数据**：使数据更易于管理和操作。
|
||
- **提高效率**：减少冗余和混乱，优化内存占用。
|
||
- **增强可读性**：使代码更易于理解和维护。
|
||
|
||
### Python 中的数据类型
|
||
|
||
- **数值**：整数、浮点数、复数。
|
||
- **字符串**：文本数据。
|
||
- **列表**：有序且可变的序列。
|
||
- **元组**：有序且不可变的序列。
|
||
- **集合**：无序且不重复的元素集合。
|
||
- **字典**：键值对的无序集合。
|
||
|
||
# 📝 体验预备
|
||
|
||
## 示例代码
|
||
|
||
```python
|
||
name = "王阳明"
|
||
era = "明朝"
|
||
birthYear = 1472
|
||
deathYear = 1529
|
||
writings = ["传习录", "大学问", "王阳明全集"]
|
||
achievements = {"平定宸康之乱", "创立心学", "教育家", "军事家", "政治家"}
|
||
lifeSpan = (birthYear, deathYear)
|
||
otherInfo = {
|
||
"称号": ["阳明先生", "王文成公", "乐山居士"],
|
||
"籍贯": "浙江绍兴府余姚县",
|
||
"主要成就": achievements,
|
||
"著作": writings
|
||
}
|
||
print(name)
|
||
print(era)
|
||
print(birthYear)
|
||
print(deathYear)
|
||
print(writings)
|
||
print(achievements)
|
||
print(lifeSpan)
|
||
print(otherInfo)
|
||
```
|
||
|
||
## 解析
|
||
|
||
- **变量保存的数据形式**：数值、字符串、列表、元组、集合、字典。
|
||
- **单个数据的变量**：`name`, `era`, `birthYear`, `deathYear`。
|
||
- **多个数据的变量**：`writings`, `achievements`, `lifeSpan`, `otherInfo`。
|
||
|
||
# 📚 知识点拨
|
||
|
||
## 1. Python 中常用的数据类型
|
||
|
||
1. **数值**：整数、浮点数、复数。
|
||
2. **字符串**：文本数据。
|
||
3. **列表**：有序且可变的序列。
|
||
4. **元组**：有序且不可变的序列。
|
||
5. **集合**：无序且不重复的元素集合。
|
||
6. **字典**：键值对的无序集合。
|
||
|
||
## 2. 数据类型的分类方式
|
||
|
||
1. **按存值个数分类**：
|
||
- 单个值：数值、字符串。
|
||
- 多个值：列表、字典、元组、集合。
|
||
2. **按有序或无序分类**：
|
||
- 有序：字符串、列表、元组。
|
||
- 无序：字典、集合。
|
||
3. **按可变或不可变分类**：
|
||
- 可变：列表、字典、集合。
|
||
- 不可变：数值、字符串、元组。
|
||
4. **按访问类型分类**：
|
||
- 直接访问：数值。
|
||
- 顺序访问：字符串、列表、元组。
|
||
- 键值访问：字典。
|
||
|
||
# 📖 举一反三
|
||
|
||
## 例 11
|
||
|
||
1. **《全唐诗》的简要介绍内容**：使用字符串类型保存。
|
||
2. **诗人数及作品数**：使用数值类型保存。
|
||
3. **代表诗人**：使用列表类型保存。
|
||
|
||
## 代码
|
||
|
||
```python
|
||
poetry = "《全唐诗》是汇集唐代诗歌的总集，是中国规模最大的一部诗歌总集。"
|
||
poetNum = 2529 # 数值保存诗人数量
|
||
poemsNum = 42863 # 数值保存诗歌数量
|
||
poetRep = ["李白", "杜甫", "王勃", "王维", "孟浩然"] # 列表保存代表诗人
|
||
```
|
||
|
||
# 📝 练习巩固
|
||
|
||
## 一、单项选择题
|
||
|
||
1. **Python 中，哪种数据类型一旦创建就不能更改（）。**
|
||
- **B. 元组**
|
||
2. **在 Python 中，整数和浮点数属于哪种数据类型（）。**
|
||
- **B. 数值类型**
|
||
3. **在 Python 中，字符串是由什么组成的（）。**
|
||
- **C. 字符**
|
||
4. **在 Python 中，以下哪个数据类型是有序且可变的（）。**
|
||
- **C. 列表**
|
||
5. **在 Python 中，哪种数据类型可以用来表示一系列有序且可以包含不同类型的元素（）。**
|
||
- **B. 列表**
|
||
|
||
## 二、判断题
|
||
|
||
1. **列表是 Python 中的一种有序且可变的序列类型。**
|
||
- **正确**
|
||
2. **集合是由不重复元素组成的有序集合，适合进行数学上的集合操作。**
|
||
- **错误**：集合是无序的。
|
||
3. **字符串在 Python 中是不可变的，不能更改一个字符串中的某个特定字符。**
|
||
- **正确**
|
||
|
||
# 📊 数值型
|
||
|
||
## 数值类型的分类
|
||
|
||
1. **整数**：没有小数部分的数字。
|
||
2. **浮点数**：带有小数部分的数字。
|
||
3. **复数**：包含实部和虚部的数字。
|
||
|
||
## 数值的运算
|
||
|
||
1. **算术运算**：加法、减法、乘法、除法等。
|
||
2. **比较运算**：等于、不等于、大于、小于等。
|
||
3. **逻辑运算**：与、或、非。
|
||
|
||
## 数值的函数
|
||
|
||
1. **绝对值**：`abs(x)`。
|
||
2. **最大值**：`max()`。
|
||
3. **最小值**：`min()`。
|
||
4. **平方根**：`sqrt(x)`。
|
||
5. **幂运算**：`pow(x, y)`。
|
||
|
||
## 数值类的转换
|
||
|
||
1. **转换成整数型**：`int()`。
|
||
2. **转换成浮点型**：`float()`。
|
||
|
||
# 📖 举一反三
|
||
|
||
## 例 1
|
||
|
||
**成语是中国传统文化的一大特色，多为四字，亦有三字，五字甚至七字以上。**
|
||
- **解析**：使用字符串类型保存成语内容。
|
||
|
||
# 📊 成语统计与计算
|
||
|
||
## 成语数据统计
|
||
|
||
根据《成语词典》的统计结果：
|
||
|
||
- **成语总数**：$10000$ 个
|
||
- **四字成语**：$9274$ 个，占总数的 $92.74\%$
|
||
- **三字成语**：$53$ 个，占总数的 $0.53\%$
|
||
- **成语总字数**：$41881$ 个字
|
||
|
||
## 计算任务
|
||
|
||
1. **超过四字的成语个数**：
|
||
- 计算方法：总数减去三字成语个数，再减去四字成语个数。
|
||
- 公式：
|
||
$$
|
||
\text{moreFourWords} = \text{idiomNum} - \text{threeWords} - \text{fourWords}
|
||
$$
|
||
|
||
- 结果：
|
||
$$
|
||
\text{moreFourWords} = 10000 - 53 - 9274 = 673
|
||
$$
|
||
|
||
|
||
2. **成语平均字数**：
|
||
- 计算方法：成语总字数除以成语总个数。
|
||
- 公式：
|
||
$$
|
||
\text{wordRate} = \frac{\text{totalWords}}{\text{idiomNum}}
|
||
$$
|
||
|
||
- 结果：
|
||
$$
|
||
\text{wordRate} = \frac{41881}{10000} = 4.1881
|
||
$$
|
||
|
||
|
||
## 代码实现
|
||
|
||
```python
|
||
idiomNum = 10000 # 成语总个数
|
||
fourWords = 9274 # 四字成语个数
|
||
threeWords = 53 # 三字成语个数
|
||
totalWords = 41881 # 成语总字数
|
||
|
||
# 计算超过四字的成语个数
|
||
moreFourWords = idiomNum - threeWords - fourWords
|
||
|
||
# 计算成语平均字数
|
||
wordRate = totalWords / idiomNum
|
||
|
||
print("超过四字的成语个数为:", moreFourWords)
|
||
print("成语平均字数为:", wordRate)
|
||
```
|
||
|
||
---
|
||
|
||
# 🔢 成语中数字的出现次数
|
||
|
||
## 数字出现次数统计
|
||
|
||
根据《成语词典》的统计结果，成语中数字的出现次数如下：
|
||
|
||
| 数字 | 出现次数 |
|
||
| :--: | :------: |
|
||
| 一 | $367$ |
|
||
| 二 | $57$ |
|
||
| 三 | $147$ |
|
||
| 四 | $55$ |
|
||
| 五 | $65$ |
|
||
| 六 | $42$ |
|
||
| 七 | $41$ |
|
||
| 八 | $54$ |
|
||
| 九 | $46$ |
|
||
| 十 | $64$ |
|
||
| 百 | $90$ |
|
||
| 千 | $124$ |
|
||
| 万 | $117$ |
|
||
|
||
## 判断任务
|
||
|
||
1. **"三"出现的次数比"二"出现的次数多**：
|
||
- 判断：
|
||
$$
|
||
\text{num3} > \text{num2}
|
||
$$
|
||
|
||
- 结果：
|
||
$$
|
||
147 > 57 \rightarrow \text{True}
|
||
$$
|
||
|
||
|
||
2. **"四"出现的次数比"七"出现的次数的两倍还多**：
|
||
- 判断：
|
||
$$
|
||
\text{num4} > 2 \times \text{num7}
|
||
$$
|
||
|
||
- 结果：
|
||
$$
|
||
55 > 2 \times 41 \rightarrow 55 > 82 \rightarrow \text{False}
|
||
$$
|
||
|
||
|
||
3. **奇数的次数和比偶数的次数和大，并且比"百"、"千"、"万"的和更大**：
|
||
- 奇数次数和：
|
||
$$
|
||
\text{num1} + \text{num3} + \text{num5} + \text{num7} + \text{num9} = 367 + 147 + 65 + 41 + 46 = 666
|
||
$$
|
||
|
||
- 偶数次数和：
|
||
$$
|
||
\text{num2} + \text{num4} + \text{num6} + \text{num8} + \text{num10} = 57 + 55 + 42 + 54 + 64 = 272
|
||
$$
|
||
|
||
- "百"、"千"、"万"的和：
|
||
$$
|
||
\text{num100} + \text{num1000} + \text{num10000} = 90 + 124 + 117 = 331
|
||
$$
|
||
|
||
- 判断：
|
||
$$
|
||
666 > 272 \text{ 且 } 666 > 331 \rightarrow \text{True}
|
||
$$
|
||
|
||
|
||
## 代码实现
|
||
|
||
```python
|
||
num1 = 367 # 一
|
||
num2 = 57 # 二
|
||
num3 = 147 # 三
|
||
num4 = 55 # 四
|
||
num5 = 65 # 五
|
||
num6 = 42 # 六
|
||
num7 = 41 # 七
|
||
num8 = 54 # 八
|
||
num9 = 46 # 九
|
||
num10 = 64 # 十
|
||
num100 = 90 # 百
|
||
num1000 = 124 # 千
|
||
num10000 = 117 # 万
|
||
|
||
# 判断三个说法
|
||
print("三"出现的次数比"二"出现的次数多--->", num3 > num2)
|
||
print("四"出现的次数比"七"出现的次数的两倍还多--->", num4 > 2 * num7)
|
||
print("奇数的次数和比偶数的次数和大，并且比"百"、"千"、"万"的和更大--->",
|
||
num1 + num3 + num5 + num7 + num9 > num2 + num4 + num6 + num8 + num10 and
|
||
num1 + num3 + num5 + num7 + num9 > num100 + num1000 + num10000)
|
||
```
|
||
|
||
---
|
||
|
||
# 📝 字符串操作与格式化
|
||
|
||
## 字符串的表示与操作
|
||
|
||
1. **字符串的表示**：
|
||
- 可以使用单引号 `'` 或双引号 `"` 表示字符串。
|
||
- 多行字符串可以使用三重引号 `'''` 或 `"""` 表示。
|
||
|
||
2. **字符串的重复与连接**：
|
||
- 使用 `*` 进行字符串重复，例如 `"鹅" * 3` 结果为 `"鹅鹅鹅"`。
|
||
- 使用 `+` 进行字符串连接，例如 `"Hello" + "World"` 结果为 `"HelloWorld"`。
|
||
|
||
3. **字符串的切片与索引**：
|
||
- 字符串索引从 `0` 开始，负数索引从末尾开始。
|
||
- 切片语法：`str[start:stop:step]`，其中 `start` 为起始索引，`stop` 为结束索引（不包含），`step` 为步长。
|
||
|
||
4. **字符串的格式化**：
|
||
- 使用 `format` 方法进行字符串格式化，例如 `"{}年".format(2023)` 结果为 `"2023年"`。
|
||
- 可以使用位置参数或关键字参数进行格式化。
|
||
|
||
## 代码示例
|
||
|
||
```python
|
||
# 字符串重复与连接
|
||
str1 = "鹅" * 3
|
||
str2 = ",曲项向"
|
||
str3 = "天歌。白毛浮绿水，红掌"
|
||
str4 = "拨清波。"
|
||
print(str1 + str2 + str3 + str4)
|
||
|
||
# 字符串切片
|
||
str = "辛苦遭逢起一经，干戈寥落四周星。山河破碎风飘絮，身世浮沉雨打萍。惶恐滩头说惶恐，零丁洋里叹零丁。人生自古谁无死？留取丹心照汗青。——宋代・文天祥《过零丁洋》"
|
||
print(str[48:64]) # 输出：人生自古谁无死？留取丹心照汗青。
|
||
print(str[-12:]) # 输出：宋代・文天祥《过零丁洋》
|
||
|
||
# 字符串格式化
|
||
name = "李白"
|
||
birth = 701
|
||
death = 762
|
||
hao = "青莲居士"
|
||
print("诗仙{}（{}年—{}年），字太白，号{}，唐朝浪漫主义诗人。".format(name, birth, death, hao))
|
||
print("存世诗文千余篇，有《李太白集》传世。{}年病逝，享年{}岁。".format(death, death - birth))
|
||
```
|
||
|
||
---
|
||
|
||
# 📚 字符串函数
|
||
|
||
## 常用字符串函数
|
||
|
||
| 函数名 | 描述 | 示例 | 结果 |
|
||
| :---------: | :------------------------: | :-------------------------: | :-----: |
|
||
| `len()` | 返回字符串长度 | `len("Hello")` | $5$ |
|
||
| `max()` | 返回字符串中最大的字符 | `max("Hello")` | `o` |
|
||
| `min()` | 返回字符串中最小的字符 | `min("Hello")` | `H` |
|
||
| `replace()` | 替换字符串中的子串 | `"Hello".replace("H", "J")` | `Jello` |
|
||
| `find()` | 查找子串的位置 | `"Hello".find("e")` | $1$ |
|
||
| `join()` | 将序列中的元素连接成字符串 | `",".join(["a", "b", "c"])` | `a,b,c` |
|
||
|
||
## 代码示例
|
||
|
||
```python
|
||
# 字符串函数示例
|
||
strUp = "一支粉笔两袖清风，三尺讲台四季晴雨，加上五脏六腑七嘴八舌九思十想，教必有方，滴滴汗水诚滋桃李芳天下"
|
||
strDown = "十卷诗书九章勾股，八索文思七纬地理，连同 6 艺五经四书三字两雅一心，海而不倦，点点心血勤育英才泽神州"
|
||
|
||
chrCount = len(strUp) # 上联的字符数
|
||
wordPos = strUp.find("七嘴八舌") # 七嘴八舌出现的位置
|
||
strDown = strDown.replace('6', '六') # 把数字 6 替换为中文六
|
||
|
||
print("该对联上下联分别有{}个字符，该对联使用了很多数字及关于数字的成语，其中七嘴八舌出现在上联的第{}个字符。".format(chrCount, wordPos))
|
||
print("上联: " + strUp)
|
||
print("下联: " + strDown)
|
||
```
|
||
|
||
# 📚 字符串操作与列表处理
|
||
|
||
## 字符串操作
|
||
|
||
### 字符串方法
|
||
|
||
| 方法 | 描述 | 示例 | 结果 |
|
||
| -------------- | ------------------------------------- | -------------------------- | ----------------------- |
|
||
| `str.upper()` | 将字符串中的小写字母转为大写字母 | `"HelloPython".upper()` | `"HELLOPYTHON"` |
|
||
| `str.lower()` | 将字符串中的大写字母转为小写字母 | `"HelloPython".lower()` | `"hellopython"` |
|
||
| `str.count(x)` | 统计字符串里某个字符 ($x$) 出现的次数 | `"HelloPython".count('o')` | `2` |
|
||
| `str.split(x)` | 指定分隔符 ($x$) 对字符串进行切片 | `"HelloPython".split('o')` | `['Hell', 'Pyth', 'n']` |
|
||
|
||
### 字符串转换
|
||
|
||
> 字符串类的转换是将字符串型数据（如整数、浮点数）转换为字符串型的常见操作。
|
||
|
||
- 使用 `str()` 函数可以将整数、浮点数转换为字符串。
|
||
- `str(123)` 将整数 `123` 转换为字符串 `"123"`。
|
||
- `str(12.3)` 将浮点数 `12.3` 转换为字符串 `"12.3"`。
|
||
|
||
## 字符串应用实例
|
||
|
||
### 回文诗生成
|
||
|
||
**示例代码：**
|
||
|
||
```python
|
||
words = "静思伊久阻归期忆别离时间漏转"
|
||
line1 = words[0:7] + "，" # 产生第一句
|
||
line2 = words[7:14] + "。" # 产生第二句
|
||
line3 = words[14:21] + "，" # 产生第三句
|
||
line4 = words[21:28] + "。" # 产生第四句
|
||
print(line1)
|
||
print(line2)
|
||
print(line3)
|
||
print(line4)
|
||
```
|
||
|
||
**输出结果：**
|
||
|
||
```
|
||
静思伊久阻归期，
|
||
久阻归期忆别离。
|
||
忆别离时间漏转，
|
||
时间漏转静思伊。
|
||
```
|
||
|
||
### 《爱莲说》分析
|
||
|
||
**任务：**
|
||
1. 统计《爱莲说》正文的总字数。
|
||
2. 统计全文中“爱”字出现的次数。
|
||
3. 将“桔”替换为“菊”。
|
||
|
||
**示例代码：**
|
||
|
||
```python
|
||
poem = "爱莲说 宋 周敦颐\n水陆草木之花，可爱者甚蕃。晋陶渊明独爱桔。自李唐来，世人甚爱牡丹。予独爱莲之出淤泥而不染，濯清涟而不妖，中通外直，不蔓不枝，香远益清，亭亭净植，可远观而不可亵玩焉。\n予谓桔，花之隐逸者也；牡丹，花之富贵者也；莲，花之君子者也。噫！桔之爱，陶后鲜有闻。莲之爱，同予者何人？牡丹之爱，宜乎众矣！"
|
||
countWords = len(poem) # 获取字符串总字数
|
||
countAi = poem.count('爱') # 统计"爱"的个数
|
||
poem = poem.replace('桔', '菊') # 把"桔"替换成"菊"
|
||
print("整篇《爱莲说》的正文总共有{}字".format(countWords))
|
||
print("全文中总共出现了{}次'爱'字".format(countAi))
|
||
print(poem)
|
||
```
|
||
|
||
**输出结果：**
|
||
|
||
```
|
||
整篇《爱莲说》的正文总共有155字
|
||
全文中总共出现了8次'爱'字
|
||
爱莲说 宋 周敦颐
|
||
水陆草木之花，可爱者甚蕃。晋陶渊明独爱菊。自李唐来，世人甚爱牡丹。予独爱莲之出淤泥而不染，濯清涟而不妖，中通外直，不蔓不枝，香远益清，亭亭净植，可远观而不可亵玩焉。
|
||
予谓菊，花之隐逸者也；牡丹，花之富贵者也；莲，花之君子者也。噫！菊之爱，陶后鲜有闻。莲之爱，同予者何人？牡丹之爱，宜乎众矣！
|
||
```
|
||
|
||
### 地名识别
|
||
|
||
**示例代码：**
|
||
|
||
```python
|
||
poem = "剑外忽传收蓟北，初闻涕泪满衣裳。\n却看妻子愁何在，漫卷诗书喜欲狂。\n白日放歌须纵酒，青春作伴好还乡。\n即从巴峡穿巫峡，便下襄阳向洛阳。"
|
||
placeName1 = poem[0:2] # 截取第1个地名
|
||
placeName2 = poem[8:10] # 截取第2个地名
|
||
placeName3 = poem[53:55] # 截取第3个地名
|
||
placeName4 = poem[57:59] # 截取第4个地名
|
||
placeName5 = poem[64:66] # 截取第5个地名
|
||
placeName6 = poem[69:71] # 截取第6个地名
|
||
print("杜甫的《闻官军收河南河北》中，一共包含了6个地名，分别是：{}、{}、{}、{}、{}、{}".format(placeName1, placeName2, placeName3, placeName4, placeName5, placeName6))
|
||
```
|
||
|
||
**输出结果：**
|
||
|
||
```
|
||
杜甫的《闻官军收河南河北》中，一共包含了6个地名，分别是：剑外、蓟北、巴峡、巫峡、襄阳、洛阳
|
||
```
|
||
|
||
## 列表操作
|
||
|
||
### 列表的定义与访问
|
||
|
||
> 列表是一种可变的有序集合，用于存储一系列的元素。这些元素可以是任意类型，包括数字、字符串、布尔值，甚至是其他列表或复杂对象。
|
||
|
||
**示例代码：**
|
||
|
||
```python
|
||
poem = ["两个黄鹂鸣翠柳", "一行白鹭上青天", "窗含西岭千秋雪", "门泊东吴万里船"]
|
||
dufuInfo = ['杜甫', '唐', (712, 770), ["《登高》", "《春望》", "《北征》"]]
|
||
print(poem)
|
||
print(dufuInfo)
|
||
```
|
||
|
||
**输出结果：**
|
||
|
||
```
|
||
['两个黄鹂鸣翠柳', '一行白鹭上青天', '窗含西岭千秋雪', '门泊东吴万里船']
|
||
['杜甫', '唐', (712, 770), ['《登高》', '《春望》', '《北征》']]
|
||
```
|
||
|
||
### 列表的修改与运算
|
||
|
||
**示例代码：**
|
||
|
||
```python
|
||
dufuInfo = ['杜甫', '唐', '712年2月12日', (712, 770), 58, ['杜少陵', '杜工部', '杜草堂', '诗圣'], "《登高》", "《春望》", "《北征》"]
|
||
dufuInfo[4] = 59 # 修改杜甫的享年
|
||
print(dufuInfo)
|
||
print(dufuInfo[2]) # 获取杜甫的出生日期
|
||
print(dufuInfo[6:]) # 获取杜甫的作品
|
||
print(dufuInfo[5][-1]) # 获取杜甫的尊称
|
||
```
|
||
|
||
**输出结果：**
|
||
|
||
```
|
||
['杜甫', '唐', '712年2月12日', (712, 770), 59, ['杜少陵', '杜工部', '杜草堂', '诗圣'], '《登高》', '《春望》', '《北征》']
|
||
712年2月12日
|
||
['《登高》', '《春望》', '《北征》']
|
||
诗圣
|
||
```
|
||
|
||
### 列表的拼接与重复
|
||
|
||
**示例代码：**
|
||
|
||
```python
|
||
list1 = ['奋发图强', '勇往直前']
|
||
list2 = ['自强不息']
|
||
list3 = ['积极进取']
|
||
list4 = list1 + list2 + list3 * 2
|
||
print(list4)
|
||
print("志存高远" in list4)
|
||
```
|
||
|
||
**输出结果：**
|
||
|
||
```
|
||
['奋发图强', '勇往直前', '自强不息', '积极进取', '积极进取']
|
||
False
|
||
```
|
||
|
||
### 列表的增删改查
|
||
|
||
**示例代码：**
|
||
|
||
```python
|
||
wordList = ['一帆风顺', '三心二意', '八仙过海', '五湖四海', '千锤百炼', '七上八下']
|
||
wordList.append("一举两得") # 把"一举两得"添加到列表中
|
||
wordList.remove('千锤百炼') # 把"千锤百炼"移除列表
|
||
wordCount = len(wordList) # 统计输入的成语个数
|
||
print("成语列表为:", wordList)
|
||
print("总共有", wordCount, "个成语")
|
||
wordList.sort() # 对输入的成语进行排序
|
||
print("排序后:", wordList)
|
||
```
|
||
|
||
**输出结果：**
|
||
|
||
```
|
||
成语列表为: ['一帆风顺', '三心二意', '八仙过海', '五湖四海', '七上八下', '一举两得']
|
||
总共有 6 个成语
|
||
排序后: ['一举两得', '一帆风顺', '七上八下', '三心二意', '五湖四海', '八仙过海']
|
||
```
|
||
|
||
### 列表函数
|
||
|
||
| 函数名 | 描述 | 示例 |
|
||
| ----------- | ------------------------------------------------ | -------------------- |
|
||
| `append()` | 向列表末尾添加一个元素 | `lst.append(4)` |
|
||
| `extend()` | 将另一个列表的元素添加到当前列表的末尾 | `lst.extend([5, 6])` |
|
||
| `insert()` | 在指定位置插入一个元素 | `lst.insert(1, 'b')` |
|
||
| `remove()` | 移除列表中第一个出现的指定元素 | `lst.remove('a')` |
|
||
| `pop()` | 移除列表中的指定元素（默认是最后一个），并返回它 | `lst.pop(0)` |
|
||
| `index()` | 返回指定元素在列表中的索引（如果找到） | `lst.index('a')` |
|
||
| `count()` | 返回列表中指定元素出现的次数 | `lst.count('a')` |
|
||
| `sort()` | 对列表中的元素进行排序（原地排序） | `lst.sort()` |
|
||
| `reverse()` | 反转列表中的元素（原地反转） | `lst.reverse()` |
|
||
|
||
### 列表的转换
|
||
|
||
> 可以通过内置的 `list()` 函数将其他类型（元组、集合、字符串）的数据转换成列表。
|
||
|
||
- `list("123")` 将字符串 `"123"` 转换成列表 `['1', '2', '3']`。
|
||
- `list((1, 2, 3))` 将元组 `(1, 2, 3)` 转换成列表 `[1, 2, 3]`。
|
||
- `list({1, 2, 3})` 将集合 `{1, 2, 3}` 转换成列表 `[1, 2, 3]`。
|
||
|
||
# 🧩 列表操作与 Python 编程
|
||
|
||
## 📝 列表切片与操作
|
||
|
||
> "列表切片是 Python 中强大的功能，允许我们通过指定索引范围来提取列表中的子集。"
|
||
|
||
### 例 1：提取诗人名
|
||
|
||
给定一个包含诗人名和诗歌名的列表 `poems`，通过列表切片提取所有诗人名。
|
||
|
||
```python
|
||
poems = ['钗头凤', '白居易', '辛弃疾', '青玉案', '李白', '登鹳雀', '江城子', '过零丁洋', ['陆游', '文天祥', '赋得古原草送别'], '王之渔', '苏轼']
|
||
poetName = poems[1:3] + [poems[4]] + poems[8][:2] + poems[-2:]
|
||
print("诗人列表:", poetName)
|
||
```
|
||
|
||
**解析：**
|
||
1. `poems[1:3]` 提取索引 1 到 2 的元素：`['白居易', '辛弃疾']`。
|
||
2. `[poems[4]]` 提取索引 4 的元素：`['李白']`。
|
||
3. `poems[8][:2]` 提取子列表的前两个元素：`['陆游', '文天祥']`。
|
||
4. `poems[-2:]` 提取最后两个元素：`['王之渔', '苏轼']`。
|
||
|
||
**输出：**
|
||
```
|
||
诗人列表：['白居易', '辛弃疾', '李白', '陆游', '文天祥', '王之渔', '苏轼']
|
||
```
|
||
|
||
---
|
||
|
||
## 📖 背诵诗歌校验
|
||
|
||
### 例 2：校验《静夜思》背诵
|
||
|
||
通过用户输入校验背诵的《静夜思》是否正确。
|
||
|
||
```python
|
||
recite = input("请背诵李白的《静夜思》，每句以，隔开：")
|
||
poem = recite.split(',')
|
||
print("第一句是否正确:", poem[0] == '床前明月光')
|
||
print("第二句是否正确:", poem[1] == '疑是地上霜')
|
||
print("第三句是否正确:", poem[2] == '举头望明月')
|
||
print("第四句是否正确:", poem[3] == '低头思故乡')
|
||
```
|
||
|
||
**输出示例：**
|
||
```
|
||
请背诵李白的《静夜思》，每句以，隔开：床前明日光，疑是地上雪，举头望明月，低头思故乡
|
||
第一句是否正确：False
|
||
第二句是否正确：False
|
||
第三句是否正确：True
|
||
第四句是否正确：True
|
||
```
|
||
|
||
---
|
||
|
||
## 📊 诗人作品统计
|
||
|
||
### 例 3：统计《唐诗三百首》入选次数
|
||
|
||
统计诗人作品入选《唐诗三百首》的次数，并进行排序和剔除操作。
|
||
|
||
```python
|
||
poet = ["李白", "杜甫", "白居易", "王维", "孟浩然", "李商隐"]
|
||
poemCounts = [29, 39, 6, 29, 15, 24]
|
||
poet.append("杜牧")
|
||
poemCounts.append(9)
|
||
m = min(poemCounts)
|
||
i = poemCounts.index(m)
|
||
print("剔除诗人：{}, 该诗人作品数为：{}".format(poet[i], poemCounts[i]))
|
||
poet.pop(i)
|
||
poemCounts.pop(i)
|
||
poemCounts.sort(reverse=True)
|
||
print("入选次数从大到小为:", poemCounts)
|
||
```
|
||
|
||
**输出：**
|
||
```
|
||
诗人：['李白', '杜甫', '白居易', '王维', '孟浩然', '李商隐', '杜牧']
|
||
入选次数：[29, 39, 6, 29, 15, 24, 9]
|
||
剔除诗人：白居易，该诗人作品数为：6
|
||
入选次数从大到小为：[39, 29, 29, 24, 15, 9]
|
||
```
|
||
|
||
---
|
||
|
||
## 🎯 练习巩固
|
||
|
||
### 一、单项选择题
|
||
|
||
1. **A** `list = [1, 2, 3]`
|
||
2. **B** `append()`
|
||
3. **C** `len(lst)`
|
||
4. **D** 以上都可以
|
||
5. **A** `lst[0] = [1, 2, 3]`
|
||
|
||
### 二、判断题
|
||
|
||
1. **正确**
|
||
2. **错误**（索引从 0 开始）
|
||
3. **错误**（`append()` 只能在末尾添加）
|
||
|
||
### 三、上机调试题
|
||
|
||
1. **计算参赛者最终得分**
|
||
|
||
```python
|
||
scores = [90, 85, 88, 92, 87]
|
||
scores.sort()
|
||
scores = scores[1:-1]
|
||
finalScore = sum(scores) / len(scores)
|
||
print("参赛者的最终得分是{:.2f}".format(finalScore))
|
||
```
|
||
|
||
**输出：**
|
||
```
|
||
参赛者的最终得分是88.33
|
||
```
|
||
|
||
2. **学生身高体重排序**
|
||
|
||
```python
|
||
studentInfo = [[175, 65], [160, 50], [180, 70]]
|
||
heights = [studentInfo[0][0], studentInfo[1][0], studentInfo[2][0]]
|
||
weights = [studentInfo[0][1], studentInfo[1][1], studentInfo[2][1]]
|
||
heights.sort(reverse=True)
|
||
weights.sort()
|
||
print("排序后的身高列表（从高到低）：", heights)
|
||
print("排序后的体重列表（从低到高）：", weights)
|
||
```
|
||
|
||
**输出：**
|
||
```
|
||
排序后的身高列表（从高到低）：[180, 175, 160]
|
||
排序后的体重列表（从低到高）：[50, 65, 70]
|
||
```
|
||
|
||
---
|
||
|
||
## 🛡️ 实践挑战
|
||
|
||
### 案例一：军事情报翻译
|
||
|
||
```python
|
||
infoList = ['请弓', '请箭', '请刀', '请甲', '请枪旗', '请锅幕', '请马', '请衣赐', '请粮料', '请草料', '请车牛', '请船', '请攻城守具', '请添兵', '请移营', '请进军', '请退军', '请固守', '未见贼', '见贼讫', '贼多', '贼少', '贼相敌', '贼添兵', '贼移营', '贼进兵', '贼退兵', '贼固守', '围得贼城', '解围城', '被贼围', '贼围解', '战不胜', '战大胜', '战大捷', '将士投降', '将士叛', '士卒病', '都将病', '战小胜']
|
||
pwdStr = '单车欲问边属国过居延征蓬出汉塞归雁人胡天大漠孤烟直长河落日圆萧关逢候骑都护在燕然'
|
||
secretWords = '单骑过边关'
|
||
realInfo = ""
|
||
for c in secretWords:
|
||
i = pwdStr.find(c)
|
||
if i != -1:
|
||
realInfo += " " + infoList[i]
|
||
print("最终的军情是:" + realInfo)
|
||
```
|
||
|
||
**输出：**
|
||
```
|
||
最终的军情是：请马 战大捷 请衣赐 请枪旗 贼围解
|
||
```
|
||
|
||
### 案例二：成语接龙
|
||
|
||
```python
|
||
flag = True
|
||
idiomList = ["八仙过海"]
|
||
print("开始的成语是:", idiomList[0])
|
||
while flag:
|
||
idiom = input("请接下一个成语:")
|
||
if idiom not in idiomList:
|
||
lastIdiom = idiomList[-1]
|
||
if lastIdiom[-1] == idiom[0]:
|
||
idiomList.append(idiom)
|
||
else:
|
||
print("上一个成语是:{}, 你接的是{}, 接龙失败!".format(lastIdiom, idiom))
|
||
flag = False
|
||
else:
|
||
print("你接的成语已经存在! 接龙失败")
|
||
flag = False
|
||
print("接的成语有:", idiomList)
|
||
```
|
||
|
||
**输出示例：**
|
||
```
|
||
开始的成语是：八仙过海
|
||
请接下一个成语：海阔天空
|
||
请接下一个成语：空无一人
|
||
请接下一个成语：人山人海
|
||
请接下一个成语：海阔天空
|
||
你接的成语已经存在！接龙失败
|
||
接的成语有：['八仙过海', '海阔天空', '空无一人', '人山人海']
|
||
```
|
||
|
||
# 🧠 Python 数据类型与流程控制
|
||
|
||
## 一、判断题
|
||
|
||
1. **Python 中的整数类型总是可以精确地表示任意大小的整数。**
|
||
- **正确**：Python 的整数类型支持任意大小的整数，不会溢出。
|
||
|
||
2. **Python 中的浮点数类型可以精确地表示所有的小数。**
|
||
- **错误**：浮点数在计算机中是以二进制形式存储的，因此无法精确表示所有小数，例如 $0.1$。
|
||
|
||
3. **字符串在 Python 中是不可变的，这意味着字符串对象一旦被创建就不能被修改。**
|
||
- **正确**：字符串是不可变类型，任何修改操作都会生成一个新的字符串对象。
|
||
|
||
4. **列表在 Python 中是一种可变的数据类型，可以添加、删除或修改元素。**
|
||
- **正确**：列表是可变类型，支持动态修改。
|
||
|
||
5. **在 Python 中，+运算符既可以用于数值相加，也可以用于字符串连接。**
|
||
- **正确**：+运算符在 Python 中具有多态性，支持数值相加和字符串连接。
|
||
|
||
6. **Python 中的整数除法运算符是/，它会返回商的整数部分。**
|
||
- **错误**：/运算符返回浮点数结果，//运算符才返回商的整数部分。
|
||
|
||
7. **在 Python 中，%运算符只能用于整数之间的取模运算。**
|
||
- **错误**：%运算符可以用于浮点数取模。
|
||
|
||
8. **len() 函数在 Python 中只能用于获取字符串的长度。**
|
||
- **错误**：len() 函数可以用于获取字符串、列表、元组等序列类型的长度。
|
||
|
||
9. **min() 函数在 Python 中可以返回列表中的最小值，也可以比较多个数值。**
|
||
- **正确**：min() 函数支持列表和多个参数的最小值比较。
|
||
|
||
10. **sum() 函数在 Python 中只能计算列表中所有元素的和。**
|
||
- **错误**：sum() 函数可以计算任何可迭代对象中元素的和。
|
||
|
||
## 二、填空题
|
||
|
||
1. **在 Python 中，$\qquad$是不可变的数据类型，而 $\qquad$是可变的数据类型。**
|
||
- **字符串**，**列表**
|
||
|
||
2. **整数和浮点数都属于 Python 中的 $\qquad$数据类型。**
|
||
- **数值**
|
||
|
||
3. **Python 中的字符串是通过单引号、 $\qquad$、 $\qquad$符号来定义的。**
|
||
- **双引号**，**三引号**
|
||
|
||
4. **Python 中列表的元素可以是任何数据类型，包括 $\qquad$、 $\qquad$、 $\qquad$等。**
|
||
- **整数**，**字符串**，**列表**
|
||
|
||
5. **Python 中，整数除法运算符是 $\qquad$，它返回商的整数部分。**
|
||
- **//**
|
||
|
||
6. **Python 中的 $\qquad$运算符用于计算两个数相除的余数。**
|
||
- **%**
|
||
|
||
7. **要获取一个字符串或列表的长度，可以使用内置的 $\qquad$函数。**
|
||
- **len()**
|
||
|
||
8. **将一个浮点数转换为整数时，可以使用内置的 $\qquad$函数，但需要注意这可能会丢失小数部分。**
|
||
- **int()**
|
||
|
||
## 三、上机调试题
|
||
|
||
1. **输入两个数 $a, b$，求两数之和 $(a+b)$，两数之差 $(a-b)$，两数之积 $(a \cdot b)$，两数的平方差 $(a^2 - b^2)$。**
|
||
```python
|
||
a = float(input("请输入a: "))
|
||
b = float(input("请输入b: "))
|
||
print(f"和: {a + b}")
|
||
print(f"差: {a - b}")
|
||
print(f"积: {a * b}")
|
||
print(f"平方差: {a**2 - b**2}")
|
||
```
|
||
|
||
2. **编写程序，根据本金 $b$，年利率 $r$，年数 $n$，计算最终的收益 $v = b(1 + r)^n$。提示输入本金、年利率和年数，结果保留两位小数。**
|
||
```python
|
||
b = float(input("请输入本金: "))
|
||
r = float(input("请输入年利率: "))
|
||
n = int(input("请输入年数: "))
|
||
v = b * (1 + r) ** n
|
||
print(f"最终收益: {round(v, 2)}")
|
||
```
|
||
|
||
3. **已知三角形三条边的边长，求三角形的面积。为简单起见，假设三角形的三条边能够构成三角形，附三角形面积公式: $S = \sqrt{p(p - a)(p - b)(p - c)}$，其中 $p = \frac{a + b + c}{2}$。**
|
||
```python
|
||
import math
|
||
a = float(input("请输入边长a: "))
|
||
b = float(input("请输入边长b: "))
|
||
c = float(input("请输入边长c: "))
|
||
p = (a + b + c) / 2
|
||
S = math.sqrt(p * (p - a) * (p - b) * (p - c))
|
||
print(f"三角形面积: {S}")
|
||
```
|
||
|
||
## 四、流程控制结构
|
||
|
||
### 1. 顺序结构
|
||
顺序结构是程序中最基本的程序结构，按照代码语句的先后顺序，从左到右，从上到下依次执行。
|
||
|
||
### 2. 选择结构
|
||
选择结构用于根据条件决定程序的执行流程，分为单分支、双分支和多分支结构。
|
||
|
||
- **单分支**：
|
||
```python
|
||
if 条件:
|
||
代码段
|
||
```
|
||
|
||
- **双分支**：
|
||
```python
|
||
if 条件:
|
||
代码段1
|
||
else:
|
||
代码段2
|
||
```
|
||
|
||
- **多分支**：
|
||
```python
|
||
if 条件1:
|
||
代码段1
|
||
elif 条件2:
|
||
代码段2
|
||
else:
|
||
代码段3
|
||
```
|
||
|
||
### 3. 循环结构
|
||
循环结构用于重复执行某段代码，常见的循环结构有 `for` 循环和 `while` 循环。
|
||
|
||
## 五、示例代码
|
||
|
||
### 示例 1：天气决定出行
|
||
```python
|
||
weather = input("请输入天气: ")
|
||
if weather in ["晴", "多云"]:
|
||
print("周日去景区游玩")
|
||
```
|
||
|
||
### 示例 2：人数决定出行方式
|
||
```python
|
||
n = int(input("人数: "))
|
||
if n <= 4:
|
||
print("自驾去景区")
|
||
else:
|
||
print("乘地铁去景区")
|
||
```
|
||
|
||
### 示例 3：年龄决定门票价格
|
||
```python
|
||
age = int(input("年龄: "))
|
||
if age <= 12:
|
||
print("免票")
|
||
elif 12 < age < 65:
|
||
print("全价票")
|
||
elif 65 <= age < 70:
|
||
print("半价票")
|
||
else:
|
||
print("免票")
|
||
```
|
||
|
||
## 六、练习题
|
||
|
||
### 1. 单项选择题
|
||
1. **以下是双分支选择结构的是( )。**
|
||
A. if
|
||
B. if...else...
|
||
C. if...elif...else...
|
||
D. for...
|
||
**答案：B**
|
||
|
||
2. **当输入值为 100 时，运行下列程序，输出结果为( )。**
|
||
```python
|
||
x = input("x: ")
|
||
if len(x) >= 3:
|
||
print(x + "1")
|
||
else:
|
||
print(x + "2")
|
||
```
|
||
**答案：C**
|
||
|
||
### 2. 填空题
|
||
1. **运行以下程序，输出结果为 $\qquad$。**
|
||
```python
|
||
a = 4
|
||
b = 3
|
||
c = a
|
||
if a > b:
|
||
c = 1
|
||
elif a == b:
|
||
c = 0
|
||
else:
|
||
c = -1
|
||
print(c)
|
||
```
|
||
**答案：1**
|
||
|
||
2. **运行以下代码后，x 的值变为 $\qquad$。**
|
||
```python
|
||
x = 5
|
||
if x >= 5:
|
||
x = 1
|
||
elif x == 5:
|
||
x = 0
|
||
```
|
||
**答案：1**
|
||
|
||
# 🖥️ 代码解析与循环结构
|
||
|
||
## 1. 条件判断与输入输出
|
||
|
||
### 示例代码 1
|
||
```python
|
||
x = input("请输入成绩:")
|
||
if x < 60:
|
||
print("不及格")
|
||
else:
|
||
print("及格")
|
||
```
|
||
- **输入**：用户输入成绩，程序根据成绩判断是否及格。
|
||
- **输出**：如果成绩小于 60，输出“不及格”；否则输出“及格”。
|
||
|
||
### 示例代码 2
|
||
```python
|
||
a, b = 10, 20
|
||
if a < b:
|
||
a, b = b, a
|
||
else:
|
||
a, b = 2 * b, 3 * a
|
||
print(b)
|
||
```
|
||
- **逻辑**：如果 `a < b`，交换 `a` 和 `b` 的值；否则，`a` 变为 `2 * b`，`b` 变为 `3 * a`。
|
||
- **输出**：最终输出 `b` 的值。
|
||
|
||
## 2. 分段函数与条件判断
|
||
|
||
### 分段函数
|
||
|
||
$$
|
||
y=\begin{cases}
|
||
2x+1 \& x \geqslant 0 \\
|
||
-1 \& x < 0
|
||
\end{cases}
|
||
$$
|
||
|
||
- **输入**：用户输入 `x` 的值。
|
||
- **输出**：根据 `x` 的值计算 `y` 并输出。
|
||
|
||
### 示例代码 3
|
||
```python
|
||
time = int(input("请输入时间:"))
|
||
if time < 10:
|
||
print("去城中湖")
|
||
else:
|
||
print("去古楼")
|
||
```
|
||
- **输入**：用户输入时间。
|
||
- **输出**：如果时间小于 10，输出“去城中湖”；否则输出“去古楼”。
|
||
|
||
## 3. 循环结构
|
||
|
||
### for 循环
|
||
```python
|
||
import random
|
||
password = ""
|
||
for i in range(1, 7):
|
||
c = random.randint(0, 9)
|
||
password = password + str(c)
|
||
print("随机生成的密码为:", password)
|
||
```
|
||
- **功能**：生成一个 6 位随机数字密码。
|
||
- **逻辑**：使用 `for` 循环生成 6 个随机数字，拼接成密码。
|
||
|
||
### while 循环
|
||
```python
|
||
import random
|
||
password = ""
|
||
while len(password) < 6:
|
||
c = random.randint(0, 9)
|
||
if str(c) not in password:
|
||
password = password + str(c)
|
||
print("随机生成的密码为:", password)
|
||
```
|
||
- **功能**：生成一个不重复的 6 位随机数字密码。
|
||
- **逻辑**：使用 `while` 循环生成不重复的随机数字，直到密码长度为 6。
|
||
|
||
### 无限循环与 break
|
||
```python
|
||
import random
|
||
password = ""
|
||
while True:
|
||
c = random.randint(0, 9)
|
||
password = password + str(c)
|
||
if len(password) == 5:
|
||
break
|
||
password = password + "!"
|
||
print("随机生成的密码为:", password)
|
||
```
|
||
- **功能**：生成一个 5 位随机数字密码，并在末尾添加“!”。
|
||
- **逻辑**：使用 `while True` 无限循环生成随机数字，当密码长度为 5 时，使用 `break` 退出循环。
|
||
|
||
## 4. 循环结构的关键概念
|
||
|
||
### for 循环
|
||
- **格式**：`for 变量 in 序列:`
|
||
- **功能**：遍历序列中的每个元素，执行循环体。
|
||
|
||
### while 循环
|
||
- **格式**：`while 条件:`
|
||
- **功能**：当条件为真时，重复执行循环体。
|
||
|
||
### break 与 continue
|
||
- **break**：终止当前循环。
|
||
- **continue**：跳过当前循环的剩余部分，进入下一次循环。
|
||
|
||
## 5. 应用示例
|
||
|
||
### 示例 1：清点人数
|
||
```python
|
||
tourists = ['张三', '李四', '王五', '赵六', '孙七']
|
||
arrived = ['李四', '赵六', '张三']
|
||
notArrived = []
|
||
for tourist in tourists:
|
||
if tourist not in arrived:
|
||
notArrived.append(tourist)
|
||
print("未到人数:", len(notArrived))
|
||
print("他们是:", notArrived)
|
||
```
|
||
- **功能**：清点未到集合地的旅客。
|
||
- **逻辑**：遍历所有旅客名单，检查是否在已到名单中，若不在则添加到未到名单。
|
||
|
||
### 示例 2：检测车辆
|
||
```python
|
||
cars = 0
|
||
while True:
|
||
n = int(input("当前检测到的车辆数:"))
|
||
if n < 0:
|
||
print("高峰时段结束")
|
||
print("该时段检测到的汽车总数为:", cars)
|
||
break
|
||
cars += n
|
||
```
|
||
- **功能**：统计高峰时段通过的车辆总数。
|
||
- **逻辑**：使用 `while True` 无限循环检测车辆数，当输入负数时，输出总车辆数并退出循环。
|
||
|
||
### 示例 3：购物清单
|
||
```python
|
||
total = {"梨": 15, "香蕉": 8, "苹果": 12, "西红柿": 5, "橙子": 15, "西瓜": 5, "樱桃": 50, "猕猴桃": 5, "草莓": 36, "葡萄": 39}
|
||
selectShopping = ["西红柿", "草莓", "葡萄", "橙子", "香蕉"]
|
||
limitShopping = ["梨", "草莓", "葡萄", "苹果", "香蕉"]
|
||
price = 0
|
||
others = []
|
||
for fruit in selectShopping:
|
||
if fruit not in limitShopping:
|
||
print(fruit, "不在您的购买计划中，没有结算，请分开放置")
|
||
others.append(fruit)
|
||
else:
|
||
price += total[fruit]
|
||
limitShopping.remove(fruit)
|
||
print("已选购商品:", selectShopping)
|
||
print("总价:", price)
|
||
print("还需选购:", limitShopping)
|
||
print("不在购买计划表中的商品", others, "，目前没有结算，如要购买要单独付费！")
|
||
```
|
||
- **功能**：实时追踪购物进度，显示已购商品、总价、还需购买的商品及不在计划内的商品。
|
||
- **逻辑**：遍历已选购商品，检查是否在购物清单中，计算总价并更新购物清单。
|
||
|
||
# 🖥️ Python 循环与流程控制
|
||
|
||
## 1. 循环结构
|
||
|
||
### **`for` 循环**
|
||
- **语法**：
|
||
```python
|
||
for 变量 in 可迭代对象:
|
||
循环体
|
||
```
|
||
- **示例**：
|
||
```python
|
||
for i in range(10):
|
||
print(i)
|
||
```
|
||
- `range(10)` 生成从 0 到 9 的整数序列。
|
||
|
||
### **`while` 循环**
|
||
- **语法**：
|
||
```python
|
||
while 条件:
|
||
循环体
|
||
```
|
||
- **示例**：
|
||
```python
|
||
i = 0
|
||
while i < 10:
|
||
print(i)
|
||
i += 1
|
||
```
|
||
|
||
### **循环控制语句**
|
||
- **`break`**：立即终止循环。
|
||
- **`continue`**：跳过当前迭代，进入下一次循环。
|
||
- **`else`**：循环正常结束后执行。
|
||
|
||
## 2. 流程嵌套
|
||
|
||
### **嵌套循环**
|
||
- 在一个循环内部嵌套另一个循环。
|
||
- **示例**：
|
||
```python
|
||
for i in range(3):
|
||
for j in range(2):
|
||
print(i, j)
|
||
```
|
||
- 输出：
|
||
```
|
||
0 0
|
||
0 1
|
||
1 0
|
||
1 1
|
||
2 0
|
||
2 1
|
||
```
|
||
|
||
### **循环与条件嵌套**
|
||
- 在循环内部嵌套条件语句。
|
||
- **示例**：
|
||
```python
|
||
for i in range(5):
|
||
if i % 2 == 0:
|
||
print(f"{i} 是偶数")
|
||
else:
|
||
print(f"{i} 是奇数")
|
||
```
|
||
|
||
## 3. 枚举算法
|
||
|
||
### **枚举算法**
|
||
- 遍历所有可能的解，检查是否满足条件。
|
||
- **示例**：
|
||
```python
|
||
for i in range(1, 10):
|
||
for j in range(1, 10):
|
||
if i * j == 24:
|
||
print(f"{i} * {j} = 24")
|
||
```
|
||
|
||
## 4. 冒泡排序
|
||
|
||
### **冒泡排序**
|
||
- 通过重复遍历列表，比较相邻元素并交换位置，将最大（或最小）元素“冒泡”到列表末尾。
|
||
- **示例**：
|
||
```python
|
||
lst = [23, 19, 5, 32, 18]
|
||
n = len(lst)
|
||
for i in range(n - 1):
|
||
for j in range(n - 1 - i):
|
||
if lst[j] > lst[j + 1]:
|
||
lst[j], lst[j + 1] = lst[j + 1], lst[j]
|
||
print(lst)
|
||
```
|
||
- 输出：`[5, 18, 19, 23, 32]`
|
||
|
||
## 5. 程序调试
|
||
|
||
### **调试工具**
|
||
- **断点**：在代码行号左侧单击设置断点，程序运行到断点时会暂停。
|
||
- **单步执行**：逐行执行代码，观察变量值的变化。
|
||
- **监视变量**：添加变量到监视窗口，实时查看其值。
|
||
|
||
### **调试示例**
|
||
```python
|
||
heights = [167, 178, 172, 180, 172, 175]
|
||
for i in range(6):
|
||
for j in range(6 - i):
|
||
if heights[j] > heights[j + 1]:
|
||
heights[j], heights[j + 1] = heights[j + 1], heights[j]
|
||
print(heights)
|
||
```
|
||
- 设置断点后，单步执行观察 `heights` 列表的变化。
|
||
|
||
## 6. 练习题解析
|
||
|
||
### **选择题**
|
||
1. **以下代码执行后，输出结果是（）**：
|
||
```python
|
||
s = 0
|
||
for i in range(1, 5):
|
||
s += i
|
||
i += 2
|
||
print(s)
|
||
```
|
||
- **答案**：B. 9
|
||
|
||
2. **下列不属于 Python 循环结构的关键词的是（）**：
|
||
- **答案**：D. `elif`
|
||
|
||
3. **`range(1, 22, 3)` 产生的整数个数有（）个**：
|
||
- **答案**：C. 7
|
||
|
||
4. **运行下列代码，屏幕输出的值为（）**：
|
||
```python
|
||
lst = ["a", "b", "c", "d", "e"]
|
||
for i in range(5):
|
||
lst[i] = lst[i] * i
|
||
if i == 2:
|
||
continue
|
||
if i == 3:
|
||
break
|
||
s = " ".join(lst)
|
||
print(len(s))
|
||
```
|
||
- **答案**：B. 7
|
||
|
||
### **填空题**
|
||
1. **`range(1, 10, 3)` 产生的整数序列为**：
|
||
- **答案**：`1, 4, 7`
|
||
|
||
2. **执行以下代码，依次输入 80, 90，屏幕输出值为**：
|
||
```python
|
||
lst1 = []
|
||
for i in [1, 2]:
|
||
score = eval(input("请输入成绩:"))
|
||
if score >= 90:
|
||
lst1.append("优秀")
|
||
elif score >= 75:
|
||
lst1.append("良好")
|
||
elif score >= 60:
|
||
lst1.append("及格")
|
||
else:
|
||
lst1.append("不及格")
|
||
print(lst1)
|
||
```
|
||
- **答案**：`['良好', '优秀']`
|
||
|
||
3. **要产生整数序列: 20, 15, 10, 5，用 `range` 函数写出相关式子**：
|
||
- **答案**：`range(20, 0, -5)`
|
||
|
||
4. **执行下列代码，写出屏幕输出结果**：
|
||
```python
|
||
s = 0
|
||
for k in range(10):
|
||
if k == 5:
|
||
continue
|
||
if k == 8:
|
||
break
|
||
s += 1
|
||
print(s)
|
||
```
|
||
- **答案**：7
|
||
|
||
### **上机调试题**
|
||
1. **编写程序进行求和: $s=2+4+6+\cdots+100$**：
|
||
```python
|
||
s = 0
|
||
for i in range(2, 101, 2):
|
||
s += i
|
||
print(s)
|
||
```
|
||
- **输出**：2550
|
||
|
||
2. **一张纸对折几次后，其高度理论上可以超过珠峰（8848 米）**：
|
||
```python
|
||
thickness = 0.104 # 毫米
|
||
count = 0
|
||
while thickness <= 8848 * 1000:
|
||
thickness *= 2
|
||
count += 1
|
||
print(count)
|
||
```
|
||
- **输出**：27
|
||
|
||
3. **小明多少岁时，其所种植树木的累计总数会首次超过 100 棵**：
|
||
```python
|
||
trees = 2
|
||
age = 6
|
||
while trees <= 100:
|
||
age += 1
|
||
trees += 2
|
||
print(age)
|
||
```
|
||
- **输出**：56
|
||
|
||
# 🖥️ 代码填空与算法分析
|
||
|
||
## 冒泡排序与代码填空
|
||
|
||
### 冒泡排序原理
|
||
**冒泡排序**是一种简单的排序算法，它通过重复地遍历列表，比较相邻的元素并交换它们的位置，直到列表完全有序。
|
||
|
||
### 代码填空示例
|
||
根据题目描述，以下是需要填空的代码：
|
||
|
||
```python
|
||
names = ['A','B','C','D','E','F','G','H']
|
||
tourists = [1210, 980, 3300, 3650, 2450, 4414, 5300, 3880]
|
||
print("八家美食店:", names)
|
||
for i in range(len(names) - 1):
|
||
for j in range(len(names) - 1 - i):
|
||
if tourists[j] > tourists[j + 1]:
|
||
tourists[j], tourists[j + 1] = tourists[j + 1], tourists[j]
|
||
names[j], names[j + 1] = names[j + 1], names[j]
|
||
```
|
||
|
||
### 解释
|
||
- `for i in range(len(names) - 1)`：外层循环控制遍历的次数，每次遍历会将最大的元素“冒泡”到列表的末尾。
|
||
- `for j in range(len(names) - 1 - i)`：内层循环负责比较相邻元素并交换位置。
|
||
- `if tourists[j] > tourists[j + 1]`：如果前一个元素大于后一个元素，则交换它们的位置。
|
||
|
||
## 🚗 智能充电站推荐
|
||
|
||
### 问题描述
|
||
用户需要选择最近的 2 个充电站。充电站名称和距离分别存储在列表 `name` 和 `d` 中。
|
||
|
||
### 代码填空示例
|
||
```python
|
||
name = [1,2,3,4,5,6,7]
|
||
d = [1,0.6,3,2.5,2,1,0.5]
|
||
n = len(name)
|
||
for i in range(n - 1):
|
||
for j in range(n - 1 - i):
|
||
if d[j] > d[j + 1]:
|
||
d[j], d[j + 1] = d[j + 1], d[j]
|
||
name[j], name[j + 1] = name[j + 1], name[j]
|
||
print("离您最近的两个充电站:")
|
||
print(f"充电站: {name[0]}，距离: {d[0]}")
|
||
print(f"充电站: {name[1]}，距离: {d[1]}")
|
||
```
|
||
|
||
### 解释
|
||
- `if d[j] > d[j + 1]`：比较相邻充电站的距离，如果前一个距离大于后一个，则交换它们的位置。
|
||
- `name[j], name[j + 1] = name[j + 1], name[j]`：在交换距离的同时，交换充电站的名称。
|
||
|
||
## 📊 选择题与填空题
|
||
|
||
### 选择题示例
|
||
1. 下列 Python 代码执行后，屏幕输出结果为（）。
|
||
```python
|
||
lst1 = [7,4,3,2,8,7,4,3,1,9]
|
||
m = lst1[0]
|
||
for i in lst1[1:11]:
|
||
if i < m:
|
||
m = i
|
||
print(m)
|
||
```
|
||
**答案：C. 1**
|
||
|
||
### 填空题示例
|
||
1. 写出下列程序执行后的屏幕输出。
|
||
```python
|
||
a = [0] * 11
|
||
for k in range(1,11):
|
||
a[k] = 10 - k
|
||
x = 6
|
||
y = 5
|
||
print(a[(x + y) // 2], a[y // 3], a[1 + a[x]])
|
||
```
|
||
**答案：4 8 1**
|
||
|
||
## 🏋️ BMI 指数计算
|
||
|
||
### 问题描述
|
||
根据用户输入的体重和身高，计算 BMI 指数并给出健康评价。
|
||
|
||
### 代码填空示例
|
||
```python
|
||
weight = eval(input("请输入体重(kg):"))
|
||
height = eval(input("身高(cm):"))
|
||
height = height / 100
|
||
bmi = weight / (height ** 2)
|
||
if bmi < 18.5:
|
||
print("体重过低")
|
||
elif 18.5 <= bmi < 24:
|
||
print("正常范围")
|
||
elif 24 <= bmi < 27:
|
||
print("超重")
|
||
elif 27 <= bmi < 29.9:
|
||
print("I 度肥胖")
|
||
elif 30 <= bmi < 34.9:
|
||
print("II 度肥胖")
|
||
elif 35 <= bmi < 39.9:
|
||
print("III 度肥胖")
|
||
else:
|
||
print("IV 度肥胖")
|
||
lowWeight = int(18.5 * height * height)
|
||
upperWeight = int(24 * height * height)
|
||
print(f"您的理想体重范围：{lowWeight}kg-{upperWeight}kg")
|
||
```
|
||
|
||
### 解释
|
||
- `height = height / 100`：将身高从厘米转换为米。
|
||
- `bmi = weight / (height ** 2)`：计算 BMI 指数。
|
||
- 根据 BMI 值的范围，输出相应的健康评价。
|
||
|
||
## 🔐 密码强度判断
|
||
|
||
### 问题描述
|
||
根据密码中包含的字符类型（数字、大写字母、小写字母、特殊字符），判断密码的强度。
|
||
|
||
### 代码填空示例
|
||
```python
|
||
password = input("请输入密码:")
|
||
x1 = x2 = x3 = x4 = 0
|
||
for char in password:
|
||
if char.isupper():
|
||
x1 = 1
|
||
elif char.islower():
|
||
x2 = 1
|
||
elif char.isdigit():
|
||
x3 = 1
|
||
else:
|
||
x4 = 1
|
||
strength = x1 + x2 + x3 + x4
|
||
if strength == 1:
|
||
print("密码强度: 弱")
|
||
elif strength == 2:
|
||
print("密码强度: 中")
|
||
else:
|
||
print("密码强度: 强")
|
||
```
|
||
|
||
### 解释
|
||
- `x1, x2, x3, x4` 分别表示密码中是否包含大写字母、小写字母、数字和特殊字符。
|
||
- `strength = x1 + x2 + x3 + x4`：根据包含的字符类型数量，判断密码的强度。
|
||
|
||
## 📝 单元自测
|
||
|
||
### 选择题示例
|
||
1. 键盘输入 5，运行下面代码，输出结果是（）。
|
||
```python
|
||
n = int(input("n:"))
|
||
s = 0
|
||
if n >= 5:
|
||
s += 5
|
||
elif n < 5:
|
||
s = 3
|
||
elif n == 10:
|
||
s += 1
|
||
else:
|
||
s += 10
|
||
print(s)
|
||
```
|
||
**答案：C. 5**
|
||
|
||
### 填空题示例
|
||
1. 运行下列代码，屏幕输出内容为：。
|
||
```python
|
||
lst = [12,11,45,34,5,3,2,24,9]
|
||
n = len(lst)
|
||
for i in range(1):
|
||
for j in range(n - 1 - i):
|
||
if lst[j] < lst[j + 1]:
|
||
lst[j], lst[j + 1] = lst[j + 1], lst[j]
|
||
print(lst)
|
||
```
|
||
**答案：[45, 34, 24, 12, 11, 9, 5, 3, 2]**
|
||
|
||
# 📝 循环结构与代码分析
|
||
|
||
## 循环代码执行分析
|
||
|
||
### 代码片段 1
|
||
|
||
```python
|
||
s = 0
|
||
while True:
|
||
t = 0
|
||
while t < 5:
|
||
s += t
|
||
t += 1
|
||
if s > 20:
|
||
break
|
||
print(s)
|
||
```
|
||
|
||
**执行过程：**
|
||
1. 初始化 `s = 0`。
|
||
2. 进入外层 `while True` 循环。
|
||
3. 初始化 `t = 0`。
|
||
4. 进入内层 `while t < 5` 循环，执行 `s += t` 和 `t += 1`，直到 `t` 达到 5。
|
||
5. 内层循环结束后，检查 `s > 20`，如果为真则跳出外层循环。
|
||
6. 如果 `s` 不大于 20，则打印 `s` 的值。
|
||
7. 重复上述过程。
|
||
|
||
**输出分析：**
|
||
- 每次内层循环结束后，`s` 的值增加 10（0+1+2+3+4）。
|
||
- 当 `s` 超过 20 时，循环结束。
|
||
- 因此，屏幕输出 **1 行**。
|
||
|
||
### 代码片段 2
|
||
|
||
```python
|
||
s = 0
|
||
t = 0
|
||
while True:
|
||
while t < 5:
|
||
s += t
|
||
t += 1
|
||
if s > 20:
|
||
break
|
||
print(s)
|
||
```
|
||
|
||
**执行过程：**
|
||
1. 初始化 `s = 0` 和 `t = 0`。
|
||
2. 进入外层 `while True` 循环。
|
||
3. 进入内层 `while t < 5` 循环，执行 `s += t` 和 `t += 1`，直到 `t` 达到 5。
|
||
4. 内层循环结束后，检查 `s > 20`，如果为真则跳出外层循环。
|
||
5. 如果 `s` 不大于 20，则打印 `s` 的值。
|
||
6. 重复上述过程。
|
||
|
||
**输出分析：**
|
||
- 内层循环结束后，`s` 的值增加 10（0+1+2+3+4）。
|
||
- 由于 `t` 在第一次内层循环后已经达到 5，后续外层循环中内层循环不会执行。
|
||
- 因此，屏幕输出 **1 行**。
|
||
|
||
# ✔️ 判断题
|
||
|
||
1. **双分支选择结构肯定有 `if` 关键词。**
|
||
**答案：A（对）**
|
||
|
||
2. **双分支选择结构一般有 `else` 关键词。**
|
||
**答案：A（对）**
|
||
|
||
3. **多分支选择结构肯定有 `elif` 关键词。**
|
||
**答案：B（错）**
|
||
**解释：多分支选择结构可以使用 `if` 和 `else` 实现，不一定需要 `elif`。**
|
||
|
||
4. **顺序结构语句中不能嵌套循环结构。**
|
||
**答案：B（错）**
|
||
**解释：顺序结构中可以嵌套循环结构。**
|
||
|
||
5. **Python 中循环结构只有 `for` 循环。**
|
||
**答案：B（错）**
|
||
**解释：Python 中还有 `while` 循环。**
|
||
|
||
6. **`for` 循环中可以有 `break` 和 `continue` 语句。**
|
||
**答案：A（对）**
|
||
|
||
7. **`range(1,2,1)` 可以写成 `range(1,2)`，功能一样。**
|
||
**答案：B（错）**
|
||
**解释：`range(1,2,1)` 和 `range(1,2)` 功能相同，但步长参数不同。**
|
||
|
||
8. **`while` 循环执行过程中，碰到 `break` 语句，循环结束。**
|
||
**答案：A（对）**
|
||
|
||
9. **`for` 循环内可以嵌套 `while`，`while` 循环中不能嵌套 `for`。**
|
||
**答案：B（错）**
|
||
**解释：`for` 和 `while` 循环可以互相嵌套。**
|
||
|
||
10. **PyCharm 中可以设置断点。**
|
||
**答案：A（对）**
|
||
|
||
# 🔍 填空题
|
||
|
||
1. **Python 无限循环（死循环）`while True` 的循环体中可用 `break` 语句退出循环。**
|
||
2. **`continue` 可以略过后续的语句，回到循环的开始处，继续进行循环操作。**
|
||
3. **通过 `break` 跳出循环，不能执行循环中 `else` 后面的语句块。**
|
||
4. **冒泡排序是排序的一种，通过相邻两个元素俩俩比较找最大值（最小值）。**
|
||
5. **有以下 8 个数据存放在 `lst1` 中，`lst1 = [87,82,81,70,47,30,25,19]`。**
|
||
- **从小到大冒泡排序法，第一次交换的一对数为：87 和 82。**
|
||
- **第一趟排序后的数据序列顺序：`[82,81,70,47,30,25,19,87]`。**
|
||
- **第二趟排序后的数据序列顺序：`[81,70,47,30,25,19,82,87]`。**
|
||
6. **`for` 循环可以遍历任何序列的元素，序列可以是列表、元组、字典等。**
|
||
7. **循环语句中经常用到计数器，计数器变量 `n` 加 1 的相关代码：`n += 1`。**
|
||
8. **循环语句中经常用到累加器，累加器变量 `s` 加值 `y` 的相关代码：`s += y`。**
|
||
|
||
# 💻 上机调试题
|
||
|
||
1. **完备数判断：**
|
||
```python
|
||
n = int(input("n: "))
|
||
sum_factors = sum([i for i in range(1, n) if n % i == 0])
|
||
if sum_factors == n:
|
||
print(f"{n} 是完备数")
|
||
else:
|
||
print(f"{n} 不是完备数")
|
||
```
|
||
|
||
2. **随机数生成与排序：**
|
||
```python
|
||
import random
|
||
numbers = [random.randint(10, 99) for _ in range(10)]
|
||
print("排序前:", numbers)
|
||
for i in range(len(numbers) - 1):
|
||
for j in range(len(numbers) - i - 1):
|
||
if numbers[j] < numbers[j + 1]:
|
||
numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]
|
||
print("排序后:", numbers)
|
||
```
|
||
|
||
3. **打印金字塔：**
|
||
```python
|
||
for i in range(4):
|
||
print(chr(65 + i) * (2 * i + 1))
|
||
```
|
||
|
||
4. **钢筋截取问题：**
|
||
```python
|
||
n = int(input("钢筋长度（米）："))
|
||
length = n * 100
|
||
a, b, c = 69, 39, 29
|
||
min_remainder = float('inf')
|
||
best_a, best_b, best_c = 0, 0, 0
|
||
for i in range(1, length // a + 1):
|
||
for j in range(1, (length - i * a) // b + 1):
|
||
k = (length - i * a - j * b) // c
|
||
remainder = length - (i * a + j * b + k * c)
|
||
if remainder < min_remainder:
|
||
min_remainder = remainder
|
||
best_a, best_b, best_c = i, j, k
|
||
print(f"{a} 厘米: {best_a} 根, {b} 厘米: {best_b} 根, {c} 厘米: {best_c} 根")
|
||
print(f"剩余: {min_remainder} 厘米")
|
||
|
||
# 🧮 BMI 指数计算与健康评估
|
||
|
||
> "BMI（Body Mass Index，体质指数）是目前国际上常用的衡量人体胖瘦程度以及是否健康的一个标准。"
|
||
|
||
## BMI 计算公式
|
||
|
||
BMI 的计算公式为：
|
||
|
||
$$
|
||
bmi = \frac{\text{体重 (kg)}}{\text{身高 (m)}^2}
|
||
$$
|
||
|
||
|
||
### 中国成年人 BMI 标准
|
||
|
||
| BMI 范围 | 健康状况 |
|
||
| ------------------------- | -------- |
|
||
| $bmi < 18.5$ | 体重过低 |
|
||
| $18.5 \leqslant bmi < 24$ | 体重正常 |
|
||
| $24 \leqslant bmi < 28$ | 超重 |
|
||
| $bmi \geqslant 28$ | 肥胖 |
|
||
|
||
## Python 实现 BMI 计算
|
||
|
||
使用 Python 的 `random` 模块生成随机身高和体重数据，并计算 BMI 指数。
|
||
|
||
```python
|
||
import random
|
||
|
||
height = random.uniform(1.6, 1.8) # 身高在 1.6 到 1.8 米之间
|
||
weight = random.uniform(50, 80) # 体重在 50 到 80 公斤之间
|
||
bmi = weight / (height ** 2)
|
||
|
||
if bmi < 18.5:
|
||
msg = "体重过低"
|
||
elif 18.5 <= bmi < 24:
|
||
msg = "体重正常"
|
||
elif 24 <= bmi < 28:
|
||
msg = "超重"
|
||
else:
|
||
msg = "肥胖"
|
||
|
||
print(f"身高: {height:.1f} 米, 体重: {weight:.1f} 公斤")
|
||
print(f"BMI 指数: {bmi:.2f} (kg/m^2)")
|
||
print(f"身体状况: {msg}")
|
||
```
|
||
|
||
# 🏃 运动安全提示
|
||
|
||
利用 Python 的 `time` 和 `random` 模块，编写代码实现每隔 5 秒随机显示一条校园运动安全提示。
|
||
|
||
```python
|
||
import time
|
||
import random
|
||
|
||
safetyWarnings = [
|
||
"校园运动时，请穿着合适的运动装备。",
|
||
"在进行激烈运动前，请做好充分的热身准备。",
|
||
"注意运动场地的安全，避免在湿滑或不平整的场地进行运动。",
|
||
"在进行团队运动时，请遵守规则，避免发生碰撞和冲突。",
|
||
"如有身体不适或伤病，请及时停止运动并寻求医疗帮助。"
|
||
]
|
||
|
||
while True:
|
||
currentWarning = random.choice(safetyWarnings)
|
||
print(currentWarning)
|
||
time.sleep(5)
|
||
```
|
||
|
||
# ❤️ 运动心率监控
|
||
|
||
利用 Python 的 `time` 和 `random` 模块，编写代码实现运动心率的监控。
|
||
|
||
```python
|
||
import time
|
||
import random
|
||
|
||
sport = input("请输入运动项目: ")
|
||
startTime = time.time()
|
||
print(f"开始 {sport}...")
|
||
|
||
while True:
|
||
heartRate = random.randint(60, 180)
|
||
print(f"当前心率: {heartRate} BPM")
|
||
if heartRate > 160:
|
||
break
|
||
time.sleep(2)
|
||
|
||
endTime = time.time()
|
||
dur = endTime - startTime
|
||
durMinutes = int(dur / 60)
|
||
durSeconds = int(dur % 60)
|
||
|
||
sportFeedback = input("请输入运动之后的状态(如:感觉良好/有些累/非常累): ")
|
||
|
||
localTime = time.localtime(endTime)
|
||
formattedTime = time.strftime("%Y-%m-%d %H:%M:%S", localTime)
|
||
|
||
print(f"当前日期和时间是：{formattedTime}")
|
||
print(f"{sport}结束|")
|
||
print(f"本次运动时长：{durMinutes} 分钟 {durSeconds} 秒")
|
||
print(f"运动之后的状态：{sportFeedback}")
|
||
```
|
||
|
||
# 📊 自定义函数与代码复用
|
||
|
||
## 自定义函数语法
|
||
|
||
```python
|
||
def 函数名(参数1, 参数2, ...):
|
||
# 函数体
|
||
return 返回值
|
||
```
|
||
|
||
### 示例：考试规则函数
|
||
|
||
```python
|
||
def exam_rules(subject):
|
||
print(f"{subject}期末考试规定如下:")
|
||
print("本次考试时长: 90 分钟")
|
||
print("1. 考生需携带有效证件进入考场。")
|
||
print("2. 考试开始后 15 分钟不得进入考场。")
|
||
print("3. 考试期间不得使用手机等通信设备。")
|
||
print("4. 禁止抄袭、交头接耳等作弊行为。")
|
||
print("5. 请按时提交试卷并离开考场。")
|
||
|
||
exam_rules('语文')
|
||
exam_rules('数学')
|
||
```
|
||
|
||
## 参数分类
|
||
|
||
| 分类 | 描述 |
|
||
| ---------- | ------------------------------------------------------------ |
|
||
| 位置参数 | 在调用函数时，传递的参数必须与函数定义的参数一一对应 |
|
||
| 关键字参数 | 在调用时，采用"参数名=值"的方式，可以无需考虑函数定义中参数的位置顺序 |
|
||
| 默认参数 | 在函数定义的时候，为参数设置默认值，调用时未传值则使用默认值 |
|
||
| 不定长参数 | 传递任意数量参数值的参数格式为：函数名(*参数) |
|
||
|
||
# 📝 练习巩固
|
||
|
||
## 一、单项选择题
|
||
|
||
1. 下列函数不属于 `math` 模块的是( )。
|
||
- A. `max`
|
||
- B. `len`
|
||
- C. `min`
|
||
- D. `abs`
|
||
|
||
2. 下列函数可以生成一个在 5 和 10 之间的随机整数的是( )。
|
||
- A. `random`
|
||
- B. `uniform`
|
||
- C. `choice`
|
||
- D. `randint`
|
||
|
||
3. 下列不需要参数的函数是( )。
|
||
- A. `random`
|
||
- B. `uniform`
|
||
- C. `choice`
|
||
- D. `randint`
|
||
|
||
4. 下列可以暂停程序运行的函数是( )。
|
||
- A. `time`
|
||
- B. `sleep`
|
||
- C. `localtime`
|
||
- D. `strftime`
|
||
|
||
5. 运行 `random.uniform(3, 20)` 的结果可能是( )。
|
||
- A. 3.6
|
||
- B. 8
|
||
- C. 16
|
||
- D. 21.3
|
||
|
||
6. 运行 `sum([23, 12, 2, 5, 43])` 之后的结果是（）。
|
||
- A. 85
|
||
- B. `TypeError`
|
||
- C. 2
|
||
- D. 43
|
||
|
||
## 二、判断题
|
||
|
||
1. `math` 模块的常用函数有 `sum`, `max`, `abs`, `min`。
|
||
2. `math.pow(a, 3)` 相当于 `a * a * a`，也相当于 `a ** 3`，运行结果相同。
|
||
3. `random` 模块的 `randint` 函数是从序列中随机选择 1 个元素。
|
||
4. `time` 模块中的 `time` 函数可以返回当前时间的时间戳。
|
||
|
||
## 三、上机调试题
|
||
|
||
1. 学生成绩统计程序调试：
|
||
|
||
```python
|
||
lst = []
|
||
while True:
|
||
score = int(input("请输入学生成绩:"))
|
||
if score == -1:
|
||
break
|
||
lst.append(score)
|
||
print(f"最高分为: {max(lst)}")
|
||
print(f"最低分为: {min(lst)}")
|
||
print(f"平均分为: {sum(lst)/len(lst):.1f}")
|
||
```
|
||
|
||
2. 猜数字小程序调试：
|
||
|
||
```python
|
||
import random
|
||
a = random.randint(1, 20)
|
||
b = int(input("请输入整数:"))
|
||
while True:
|
||
if b > a:
|
||
print("偏大")
|
||
elif b < a:
|
||
print("偏小")
|
||
else:
|
||
print("恭喜你,猜对了!")
|
||
break
|
||
b = int(input("请输入整数:"))
|
||
```
|
||
|
||
3. 每隔 3 秒输出 5 到 12 之间的随机数：
|
||
|
||
```python
|
||
import random
|
||
import time
|
||
while True:
|
||
n = random.randint(5, 12)
|
||
print(n)
|
||
time.sleep(3)
|
||
```
|
||
|
||
# 🧩 参数传递与变量作用域
|
||
|
||
## 参数传递
|
||
|
||
在 Python 中，参数传递的方式取决于参数的数据类型。以下是两类参数的传递方式：
|
||
|
||
| 参数类型 | 数据类型 | 描述 |
|
||
| :--: | :--: | :--: |
|
||
| **不可变参数** | 字符串、数字、键值、元组 | 当这些数据类型的值作为参数传递到函数内时，相当于复制了一个变量。函数内对该变量的操作不会影响函数外的值。 |
|
||
| **可变参数** | 列表、字典 | 当这些数据类型的值作为参数传递到函数内时，函数内对该变量的操作将直接影响该变量本身的值，因为它们指向同一个内存位置。 |
|
||
|
||
## 变量作用域
|
||
|
||
Python 中的变量作用域分为**局部变量**和**全局变量**：
|
||
|
||
| 变量类型 | 作用域 | 访问情况 |
|
||
| :--: | :--: | :--: |
|
||
| **局部变量** | 局部作用域 | 局部变量只能在被定义的函数内访问。 |
|
||
| **全局变量** | 全局作用域 | 全局变量在自定义赋值之后，可供后续的代码进行访问。 |
|
||
|
||
### 修改全局变量
|
||
|
||
全局变量一般只能在函数内进行读取，不能修改。如需修改，必须使用 `global` 关键字进行声明（不可变参数除外）。例如：
|
||
|
||
```python
|
||
def showname():
|
||
global name
|
||
name = "李四"
|
||
name = "张三"
|
||
print(name)
|
||
showname()
|
||
print(name)
|
||
```
|
||
|
||
**输出结果：**
|
||
|
||
```
|
||
张三
|
||
李四
|
||
```
|
||
|
||
# 🛠️ 自定义函数举例
|
||
|
||
## 例 1：输出欢迎词
|
||
|
||
```python
|
||
def welcome():
|
||
print("志存高远，脚踏实地，欢迎新生！")
|
||
print("梦想照亮未来，开启美好篇章！")
|
||
```
|
||
|
||
**调用方式：**
|
||
|
||
```python
|
||
welcome()
|
||
```
|
||
|
||
## 例 2：找出 n 以内的偶数
|
||
|
||
```python
|
||
def selectnum(n):
|
||
for i in range(n):
|
||
if i % 2 == 0:
|
||
print(i, end=",")
|
||
print()
|
||
```
|
||
|
||
**调用方式：**
|
||
|
||
```python
|
||
selectnum(21)
|
||
selectnum(35)
|
||
```
|
||
|
||
## 例 3：两数相加
|
||
|
||
```python
|
||
def add(x, y):
|
||
z = x + y
|
||
return z
|
||
```
|
||
|
||
**调用方式：**
|
||
|
||
```python
|
||
k = add(1, 2)
|
||
print(k)
|
||
```
|
||
|
||
# 🔐 随机生成密码
|
||
|
||
利用 Python 自定义函数，编写代码实现随机生成长度为 `n` 且内部字符互不相同的密码。
|
||
|
||
```python
|
||
import random
|
||
import string
|
||
|
||
def createPwd(n):
|
||
chars = string.ascii_letters + string.digits
|
||
lst = []
|
||
while len(lst) < n:
|
||
c = random.choice(chars)
|
||
if c not in lst:
|
||
lst.append(c)
|
||
return "".join(lst)
|
||
|
||
while True:
|
||
n = int(input("请输入 n 值:"))
|
||
print("长度为 {} 的随机密码为：{}".format(n, createPwd(n)))
|
||
```
|
||
|
||
# 📏 计算圆柱体底面积和体积
|
||
|
||
利用 Python 的 `math` 模块和自定义函数，编写代码实现计算圆柱体底面积和体积。
|
||
|
||
```python
|
||
import math
|
||
|
||
def getDmj(r):
|
||
return math.pi * r ** 2
|
||
|
||
def getTj(s, h):
|
||
return s * h
|
||
|
||
while True:
|
||
r = int(input("请输入半径 r 的值:"))
|
||
h = int(input("请输入高 h 的值:"))
|
||
dmj = getDmj(r)
|
||
print("底面半径为 {} 的圆柱体底面积是 {:.2f}".format(r, dmj))
|
||
tj = getTj(dmj, h)
|
||
print("底面半径为 {}，高为 {} 的圆柱体体积是 {:.2f}".format(r, h, tj))
|
||
```
|
||
|
||
# 🐇 斐波那契数列
|
||
|
||
利用 Python 的 `time` 模块，编写代码实现输入 `n` 值，获取斐波那契数列第 `n` 项的值。
|
||
|
||
```python
|
||
def fib(n):
|
||
if n == 1:
|
||
return 1
|
||
elif n == 2:
|
||
return 1
|
||
else:
|
||
return fib(n - 1) + fib(n - 2)
|
||
|
||
while True:
|
||
n = int(input("请输入 n 值:"))
|
||
print("斐波那契数列第 {} 项的值:{}".format(n, fib(n)))
|
||
```
|
||
|
||
# 🧠 练习巩固
|
||
|
||
## 一、单项选择题
|
||
|
||
1. 在 Python 中，可以使用关键字（ ）来自定义函数。
|
||
- A. def
|
||
- B. dim
|
||
- C. if
|
||
- D. abs
|
||
2. 在自定义函数中，可以使用关键字（）来返回数据。
|
||
- A. def
|
||
- B. return
|
||
- C. ret
|
||
- D. randint
|
||
3. 在自定义函数中，以下哪个是错误的函数名（）。
|
||
- A. xyz
|
||
- B. $a b C$
|
||
- C. if
|
||
- D. ak
|
||
4. 当函数体为空时，可以输入（）用于占位。
|
||
- A. pass
|
||
- B. break
|
||
- C. continue
|
||
- D. else
|
||
5. 自定义函数中的参数以（）进行分隔。
|
||
- A. 逗号
|
||
- B. 句号
|
||
- C. 顿号
|
||
- D. 空格
|
||
6. 现有自定义函数 `check(n)`，调用 `check(5)` 之后，输出结果为（）。
|
||
- A. 奇数
|
||
- B. 偶数
|
||
- C. 1
|
||
- D. 2
|
||
|
||
## 二、判断题
|
||
|
||
1. 自定义函数中的参数是内部向外部传递的值。
|
||
2. 在自定义函数中，当没有参数的时候，可以去掉括号和冒号。
|
||
3. 函数体开始于 `def` 之后一行，无须缩进。
|
||
4. 自定义函数也属于函数，所以必须有返回值。
|
||
|
||
## 三、上机调试题
|
||
|
||
1. 编写自定义函数，实现输入梯形的上底、下底和高，计算出梯形的面积。
|
||
|
||
```python
|
||
def getS(top, bottom, height):
|
||
s = (top + bottom) * height / 2
|
||
return s
|
||
|
||
while True:
|
||
top = int(input("请输入梯形的上底:"))
|
||
bottom = int(input("请输入梯形的下底:"))
|
||
height = int(input("请输入梯形的高:"))
|
||
print("梯形的面积为 {}".format(getS(top, bottom, height)))
|
||
```
|
||
|
||
2. 编写自定义函数，实现从列表中筛选出偶数的元素并返回只有偶数的列表。
|
||
|
||
```python
|
||
def getValue(lst):
|
||
lst1 = []
|
||
for i in lst:
|
||
if i % 2 == 0:
|
||
lst1.append(i)
|
||
return lst1
|
||
|
||
print(getValue([4, 2, 1, 6, 5, 7, 9, 3]))
|
||
print(getValue([8, 2, 6, 5, 1, 2]))
|
||
print(getValue([6, 2, 4, 3, 1, 5, 7]))
|
||
```
|
||
|
||
3. 完善代码，实现输入 `n` 值，输出 `n * n` 乘法表。
|
||
|
||
```python
|
||
def printMultiplicationTable(n):
|
||
for i in range(1, n + 1):
|
||
for j in range(1, n + 1):
|
||
print("{} * {} = {}".format(i, j, i * j), end="\t")
|
||
print()
|
||
|
||
n = int(input("请输入 n 值:"))
|
||
printMultiplicationTable(n)
|
||
```
|
||
|
||
# 🛡️ 异常处理
|
||
|
||
## 示例 1：除法运算
|
||
|
||
```python
|
||
while True:
|
||
a = int(input("请输入被除数 a:"))
|
||
b = int(input("请输入除数 b:"))
|
||
if b == 0:
|
||
print("提示:除数不可以为 0")
|
||
continue
|
||
c = a / b
|
||
print("{}除以{}的商是:{}".format(a, b, c))
|
||
print("== 本次除法运算结束，开始下一题 ==")
|
||
```
|
||
|
||
## 示例 2：包含异常处理的除法运算
|
||
|
||
```python
|
||
while True:
|
||
try:
|
||
a = int(input("请输入被除数 a:"))
|
||
b = int(input("请输入除数 b:"))
|
||
if b == 0:
|
||
print("提示:除数不可以为 0")
|
||
continue
|
||
c = a / b
|
||
except Exception as err:
|
||
print("代码运行出现异常，错误原因：{}".format(err))
|
||
else:
|
||
print("{}除以{}的商是：{}".format(a, b, c))
|
||
finally:
|
||
print("== 本次除法运算结束，开始下一题 ==")
|
||
```
|
||
|
||
## 示例 3：优化异常处理
|
||
|
||
```python
|
||
while True:
|
||
try:
|
||
a = int(input("请输入被除数 a:"))
|
||
b = int(input("请输入除数 b:"))
|
||
c = a / b
|
||
except ValueError:
|
||
print("输入错误：输入的不是数值类型，请重新输入。")
|
||
except ZeroDivisionError:
|
||
print("除数不能为零，请重新输入。")
|
||
except Exception as err:
|
||
print("代码运行出现其他错误，错误原因：{}".format(err))
|
||
else:
|
||
print("{}除以{}的商是:{}".format(a, b, c))
|
||
```
|
||
|
||
# 📚 知识点拨
|
||
|
||
## 1. `os` 模块的部分函数使用
|
||
|
||
| 函数名 | 函数功能 | 举例 | 运行结果 |
|
||
| :-------------: | :------------------------------------: | :-----------------------------: | :---------------------------------: |
|
||
| `system` | 调用应用程序 | `os.system('cmd')` | 打开 cmd 窗口 |
|
||
| `name` | 返回当前使用平台的代表字符 | 在 Windows 系统下运行 `os.name` | `nt` |
|
||
| `getcwd` | 返回当前工作目录 | `os.getcwd()` | `c:\test` |
|
||
| `listdir(path)` | 返回 `path` 所指定目录下的文件和目录名 | `os.listdir()` | `['dlls', 'doc', 'include', 'lib']` |
|
||
|
||
## 2. 什么是程序异常
|
||
|
||
在编写 Python 代码并运行过程中，时常会遇到各类错误。其中一部分错误源于程序代码本身的语法问题，如缺少冒号、关键字拼写错误或未进行缩进等。这类错误导致代码无法顺利运行，可以通过修改代码来解决。另一部分错误则与用户输入有关，如除数不能为零，或试图获取超出索引下标的列表元素等，这些错误可以通过检查并结合判断结构来解决。此外，还有一些难以预料的错误，如在要求输入整数的位置提供了字符，或读取不存在的文件等。这类错误被称为异常，在程序中必须加以处理，否则，程序可能会因各种问题而终止退出。
|
||
|
||
## 3. 什么是异常处理
|
||
|
||
异常处理是指程序在运行时，对不属于正常业务逻辑的意外或异常情况进行处理的过程。Python 中，可以用 `try...except...else...finally` 的错误处理机制来处理异常。基本的异常处理语法结构如下：
|
||
|
||
```python
|
||
try:
|
||
# 可能存在异常的代码
|
||
except:
|
||
# 当代码发生异常的时候，会执行
|
||
|
||
# 🐍 Python 异常处理机制
|
||
|
||
## 1. try-except 语句的基本结构
|
||
|
||
> "在 Python 中，`try-except` 语句用于捕获和处理代码执行过程中可能出现的异常。"
|
||
|
||
### 基本语法
|
||
|
||
```python
|
||
try:
|
||
# 可能引发异常的代码
|
||
except:
|
||
# 异常处理代码
|
||
else:
|
||
# 没有异常时执行的代码
|
||
finally:
|
||
# 无论是否有异常，都会执行的代码
|
||
```
|
||
|
||
### 各部分的作用
|
||
|
||
- **try**: 包含可能引发异常的代码块。
|
||
- **except**: 捕获并处理异常。
|
||
- **else**: 当 `try` 块中的代码没有引发异常时执行。
|
||
- **finally**: 无论是否发生异常，都会执行的代码块。
|
||
|
||
## 2. 异常处理举例
|
||
|
||
### 例 1: 除数不能为 0
|
||
|
||
```python
|
||
try:
|
||
a = 10
|
||
b = 0
|
||
c = a / b
|
||
except:
|
||
print("除数不能为 0")
|
||
```
|
||
|
||
### 例 2: 列表插入异常
|
||
|
||
```python
|
||
try:
|
||
lst1 = ["apple", "orange"]
|
||
lst1.insert(4, "banana")
|
||
except:
|
||
print("数据插入错误")
|
||
else:
|
||
print("数据插入成功")
|
||
finally:
|
||
print(lst1)
|
||
```
|
||
|
||
### 例 3: 列表索引异常
|
||
|
||
```python
|
||
lst1 = ["apple", "orange", "banana"]
|
||
while True:
|
||
try:
|
||
i = int(input("请输入整数 i:"))
|
||
s = lst1[i]
|
||
except ValueError:
|
||
print("i 要求是整数, 请检查输入")
|
||
except IndexError:
|
||
print("i 超出了 lst1 列表的下标, 请检查输入")
|
||
except Exception as err:
|
||
print("代码运行出现其他错误, 错误原因: {}".format(err))
|
||
else:
|
||
print(s)
|
||
finally:
|
||
print("程序运行完毕")
|
||
```
|
||
|
||
## 3. 成绩录入功能
|
||
|
||
### 要求
|
||
|
||
1. 当录入成绩为 `-1` 时，录入结束，输出成绩列表。
|
||
2. 当录入成绩小于 `0` 时，提示成绩小于 `0`，请重新录入。
|
||
3. 当录入成绩大于 `100` 时，提示成绩大于 `100`，请重新录入。
|
||
4. 当录入成绩非整数时，进行异常处理，显示录入错误，请重新录入。
|
||
|
||
### 代码实现
|
||
|
||
```python
|
||
i = 1
|
||
scorelist = []
|
||
while True:
|
||
try:
|
||
score = float(input("请输入第 {} 位同学的成绩:".format(i)))
|
||
if score == -1:
|
||
break
|
||
if score < 0:
|
||
print("第 {} 位成绩小于 0，请重新录入".format(i))
|
||
continue
|
||
if score > 100:
|
||
print("第 {} 位成绩大于 100，请重新录入".format(i))
|
||
continue
|
||
except Exception as err:
|
||
print("第 {} 位成绩录入错误，请重新录入".format(i))
|
||
print("错误原因: {}".format(err))
|
||
else:
|
||
scorelist.append(score)
|
||
i = i + 1
|
||
print("当前共 {} 位学生，成绩列表：{}".format(i - 1, scorelist))
|
||
```
|
||
|
||
## 4. 文件查找功能
|
||
|
||
### 要求
|
||
|
||
1. 输入学生姓名，读取以该学生命名的作业文件。
|
||
2. 如果文件不存在，提示文件不存在。
|
||
|
||
### 代码实现
|
||
|
||
```python
|
||
import os
|
||
path = os.getcwd()
|
||
while True:
|
||
try:
|
||
filename = input("请输入学生姓名:")
|
||
filepath = path + "/学生作业/" + filename + ".txt"
|
||
with open(filepath, "r", encoding='utf8') as f:
|
||
s = f.read()
|
||
except FileNotFoundError:
|
||
print("文件未找到，请重新输入学生姓名")
|
||
except Exception as err:
|
||
print("代码运行出现其他错误，请重新输入学生姓名")
|
||
print("错误原因: {}".format(err))
|
||
else:
|
||
print("学生 [{}] 的作业如下: {}".format(filename, s))
|
||
```
|
||
|
||
## 5. 学生信息查询功能
|
||
|
||
### 要求
|
||
|
||
1. 输入学生学号，显示学生信息。
|
||
2. 如果学号不存在，提示学号不存在。
|
||
|
||
### 代码实现
|
||
|
||
```python
|
||
def getInfoById(id, students):
|
||
try:
|
||
id = int(id)
|
||
stuinfo = students[id - 1]
|
||
except ValueError:
|
||
return "学号要求是整数, 请检查输入"
|
||
except IndexError:
|
||
return "学号不存在, 请检查输入"
|
||
except Exception as err:
|
||
return "代码运行出现其他错误, 错误原因: {}".format(err)
|
||
else:
|
||
return stuinfo
|
||
|
||
students = [
|
||
[1, "张三", "男", "住宿", "非团员", "唱歌,看书"],
|
||
[2, "李四", "女", "走读", "团员", "游泳,画画"],
|
||
[3, "王五", "男", "住宿", "非团员", "打篮球,编程"],
|
||
[4, "赵六", "女", "走读", "团员", "跳舞,写作"],
|
||
[5, "陈七", "男", "住宿", "非团员", "摄影,旅行"],
|
||
[6, "刘八", "女", "走读", "团员", "做饭,看电影"]
|
||
]
|
||
|
||
while True:
|
||
id = input("请输入学号:")
|
||
info = getInfoById(id, students)
|
||
print(info)
|
||
```
|
||
|
||
## 6. 练习巩固
|
||
|
||
### 单项选择题
|
||
|
||
1. 在 Python 中，`try` 块中的代码执行时，如果发生了异常，那么会立即跳到哪个块执行？
|
||
- A. Else
|
||
- B. finally
|
||
- C. except
|
||
- D. pass
|
||
**答案: C**
|
||
|
||
2. 在 `try...except` 结构中，如果 `try` 块中的代码执行成功，没有发生异常，那么 `except` 块中的代码会执行吗？
|
||
- A. 会执行
|
||
- B. 不会执行
|
||
- C. 取决于 `except` 块中的条件
|
||
- D. 总是执行
|
||
**答案: B**
|
||
|
||
3. 在 Python 中，`finally` 块中的代码在什么情况下会执行？
|
||
- A. 只有当 `try` 块中的代码成功执行时
|
||
- B. 只有当 `try` 块中的代码引发异常时
|
||
- C. 无论 `try` 块中的代码是否成功执行或引发异常，`finally` 块中的代码都会执行
|
||
- D. `finally` 块在 Python 中不存在
|
||
**答案: C**
|
||
|
||
### 判断题
|
||
|
||
1. 在 Python 中，`try` 块中的代码发生异常时，`else` 块中的代码会被执行。
|
||
**答案: 错误**
|
||
|
||
2. `finally` 块中的代码总是在 `try` 和 `except` 块之后执行，无论是否发生异常。
|
||
**答案: 正确**
|
||
|
||
3. 在 Python 的异常处理结构中，`except` 块必须指定要捕获的异常类型。
|
||
**答案: 错误**
|
||
|
||
4. `try` 块中发生异常时，程序将立即跳到 `finally` 块执行，然后跳到 `except` 块执行。
|
||
**答案: 错误**
|
||
|
||
# 🧮 随机数与标识符命名规则
|
||
|
||
## 随机数生成
|
||
|
||
> "`random.randint(a, b)` 用于生成 $\lbrack a, b\rbrack $ 之间的随机整数，包括 $a$ 和 $b$。"
|
||
|
||
- 示例：`$n = \text{random.randint}(3, 8)$` 生成 $3$ 到 $8$ 之间的随机整数。
|
||
|
||
## 标识符命名规则检查
|
||
|
||
### 自定义函数 `checkid`
|
||
|
||
```python
|
||
def checkid(idx):
|
||
keywords = keyword.kwlist # 获取所有的关键字列表
|
||
ret = [1, "标识符正确无误"]
|
||
# 判断标识符首字母是否是英文字母或下划线
|
||
s = idx[0]
|
||
if not("a" <= s <= "z" or "A" <= s <= "Z" or s == "_"):
|
||
ret[0] = 0
|
||
ret[1] = "首字母不是英文字母或下划线"
|
||
# 判断标识符中包含有非字母,数字,或下划线的字符
|
||
for i in idx:
|
||
if not("a" <= i <= "z" or "A" <= i <= "Z" or "0" <= i <= "9" or i == "_"):
|
||
ret[0] = 0
|
||
ret[1] = "标识符中包含有非字母,数字,或下划线的字符"
|
||
break
|
||
# 判断标识符是否是关键字
|
||
if idx in keywords:
|
||
ret[0] = 0
|
||
ret[1] = "标识符是关键字"
|
||
# 返回判断结果
|
||
return ret
|
||
```
|
||
|
||
### 函数功能
|
||
|
||
1. **首字母检查**：标识符首字母必须是英文字母或下划线。
|
||
2. **字符检查**：标识符中只能包含字母、数字或下划线。
|
||
3. **关键字检查**：标识符不能是 Python 的关键字。
|
||
|
||
# 📊 得分计算与交互
|
||
|
||
## 得分计算
|
||
|
||
```python
|
||
score = 0
|
||
while True:
|
||
id = createid()
|
||
ret = checkid(id)
|
||
try:
|
||
print("标识符: [{}]".format(id))
|
||
n = int(input("请指出以上标识符是否正确(正确:1,错误:0):"))
|
||
except:
|
||
print("输入错误")
|
||
else:
|
||
if n == ret[0]:
|
||
score += 1
|
||
print("答对了!")
|
||
else:
|
||
print("答错了")
|
||
print("提示: {}".format(ret[1]))
|
||
finally:
|
||
print("当前得分: {}".format(score))
|
||
print("=" * 20)
|
||
```
|
||
|
||
### 流程
|
||
|
||
1. 生成随机标识符。
|
||
2. 用户判断标识符是否正确。
|
||
3. 根据用户输入与函数返回值比对，更新得分。
|
||
|
||
# 📚 单元自测
|
||
|
||
## 选择题
|
||
|
||
1. **计算绝对值的函数**：`abs`
|
||
2. **计算平方根的函数**：`sqrt`
|
||
3. **生成指定范围内随机整数的函数**：`randint`
|
||
4. **从列表中随机选择元素的函数**：`choice`
|
||
5. **暂停程序执行的函数**：`sleep`
|
||
6. **不属于 `math` 模块的函数**：`cell`
|
||
7. **`random.uniform(a, b)` 的作用**：生成 $(a, b)$ 之间的随机浮点数
|
||
8. **`time.strftime` 函数的作用**：格式化时间
|
||
9. **导入 `math` 模块的正确方式**：`import math`
|
||
10. **`time.localtime()` 返回的数据类型**：结构体类型的时间对象
|
||
|
||
## 判断题
|
||
|
||
1. **`math.sum()` 函数用于计算一组数的和**：错误
|
||
2. **`random.randint(a, b)` 生成的随机数包括 $a$ 和 $b$**：正确
|
||
3. **`time.time()` 返回的是从 1970 年 1 月 1 日 $00:00:00$ 到现在的秒数**：正确
|
||
4. **`time.sleep()` 函数的参数可以是小数**：正确
|
||
5. **`random.choice()` 函数可以用于从任意可迭代对象中选择一个随机元素**：正确
|
||
6. **`string.asciiLetters` 包含了所有 ASCII 字符集中的字母，无论大小写**：正确
|
||
7. **`string.digits` 是一个包含所有数字字符的字符串常量**：正确
|
||
8. **自定义函数名可以包含 Python 的关键字**：错误
|
||
9. **函数可以没有返回值，此时默认返回 `None`**：正确
|
||
|
||
## 填空题
|
||
|
||
1. **计算最大值的函数**：`max`
|
||
2. **`random()` 函数生成的随机浮点数范围**：$\lbrack 0, 1\rbrack $
|
||
3. **将时间戳转换为本地时间的函数**：`localtime`
|
||
4. **导入 `math` 模块的方式**：`import math`
|
||
5. **`asciiUppercase` 的值**：`"ABCDEFGHIJKLMNOPQRSTUVWXYZ"`
|
||
6. **`myFunction` 是函数的**：标识符
|
||
7. **函数没有使用 `return` 语句时默认返回**：`None`
|
||
8. **捕获异常的关键字**：`except`
|
||
9. **没有异常时执行的块**：`else`
|
||
10. **无论是否发生异常都会执行的块**：`finally`
|
||
|
||
## 程序设计题
|
||
|
||
1. **判断素数的函数 `isPrime`**：
|
||
```python
|
||
import random
|
||
def isPrime(n):
|
||
if n <= 1:
|
||
return False
|
||
for i in range(2, int(n**0.5) + 1):
|
||
if n % i == 0:
|
||
return False
|
||
return True
|
||
num = random.randint(1, 100)
|
||
print(f"{num} 是素数" if isPrime(num) else f"{num} 不是素数")
|
||
```
|
||
|
||
2. **格式化当前时间**：
|
||
```python
|
||
import time
|
||
current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
|
||
print(current_time)
|
||
```
|
||
|
||
3. **检查字符串是否仅包含字母和数字**：
|
||
```python
|
||
def isAlphanumeric(s):
|
||
return all(c.isalnum() for c in s)
|
||
testString1 = "hello123"
|
||
testString2 = "hello_123"
|
||
print(isAlphanumeric(testString1)) # 应输出 True
|
||
print(isAlphanumeric(testString2)) # 应输出 False
|
||
```
|
||
|
||
4. **移除字符串中的标点符号**：
|
||
```python
|
||
import string
|
||
def removePunctuation(s):
|
||
return ''.join(c for c in s if c not in string.punctuation)
|
||
```
|
||
|
||
5. **捕获文件未找到异常**：
|
||
```python
|
||
try:
|
||
with open("123.txt", "r") as file:
|
||
content = file.read()
|
||
except FileNotFoundError:
|
||
print("文件未找到: [Errno 2] No such file or directory: '123.txt'")
|
||
```
|
||
|
||
# 🧱 区块链技术
|
||
|
||
## 核心特性
|
||
|
||
- **去中心化**：无需信任中介，实现点对点交易。
|
||
- **不可篡改**：通过密码学算法确保数据安全。
|
||
- **透明开放**：所有交易记录公开透明。
|
||
- **安全可信**：通过共识机制保障数据可靠性。
|
||
|
||
## 应用领域
|
||
|
||
- **金融**：降低交易成本，提高效率。
|
||
- **供应链管理**：追踪商品来源和流转信息。
|
||
- **身份认证**：确保身份信息真实可靠。
|
||
- **版权保护**：保护数字内容的版权。
|
||
|
||
## 发展现状
|
||
|
||
- **政策环境**：持续优化，标准体系逐步完善。
|
||
- **产业规模**：不断扩大，技术创新能力提升。
|
||
- **应用场景**：金融、供应链管理、物联网等领域广泛应用。 |