Python基础

第 1 节

1.1 初识 Python

Python 是当下最流行、最易用的编程语言之一，被广泛应用于人工智能、数据分析、Web 开发、自动化办公等领域，也是编程入门的首选语言。

1.1 一、起源

Python 由荷兰计算机科学家 吉多・范罗苏姆（Guido van Rossum） 在 20 世纪 90 年代初设计。它的诞生源于对早期教学语言 ABC 的改进：ABC 语言是吉多参与设计的、专为非专业程序员打造的入门语言，但因使用门槛、兼容性等问题并未普及。吉多以此为基础，优化设计出了更简洁灵活的 Python，让编程变得更简单。1991 年，第一个 Python 解释器正式诞生，由 C 语言实现，这也为 Python 后续的跨平台、高性能打下了基础。

1.1 二、核心优点

1. 简单纯粹：Python 秉持简单主义设计思想，代码语法贴近自然英语，阅读优质的 Python 代码，就像读普通文字一样易懂。你无需纠结复杂的语言语法，能直接专注于解决实际问题。

2. 极易上手：作为入门级编程语言，Python 学习曲线平缓，官方提供清晰简洁的文档，零基础也能快速掌握基础用法。

3. 易读、易维护：Python 强制代码缩进对齐，语法风格统一规范，无论是自己写的代码，还是团队协作开发，都能轻松阅读、修改和维护。

4. 运行效率出色：Python 底层由 C 语言编写，大量标准库和第三方库也基于 C 语言开发，兼顾了简洁语法和优秀的运行速度，满足绝大多数开发场景。

5. 生态库极其丰富：Python 拥有庞大的标准库 + 第三方库生态，无需重复造轮子：

   • 处理文本：正则表达式；文件操作：读写各类文件；开发工具：单元测试、多线程；业务场景：数据库连接、网络请求、人工智能、数据分析等

6. 开发效率极高：简洁的语法 + 强大的库，让 Python 能以极短的代码实现复杂功能，大幅缩短开发周期。

1.2 Python 可以做什么？

Python 是一门全能型编程语言，零基础小白、职场办公人士、专业技术人员，都能用它解决实际问题，应用场景几乎覆盖所有行业。

1.2 一、IT 领域

1. 网络爬虫：自动抓取网页数据、批量采集信息，用于数据分析、资料整理等。
2. Web 后端开发：搭建网站、小程序、APP 的后台服务（如 Django、Flask 框架）。
3. 自动化测试：自动运行测试用例，解放双手，提升测试效率。
4. 运维自动化：自动部署服务器、监控系统、批量处理运维任务。

1.2 二、职场办公

1. 自动化办公：批量处理 Excel、Word、PDF 等文件，自动生成报表、发送邮件、整理数据，大幅提升办公效率，告别重复机械工作。

1.2 三、前沿领域

1. 人工智能 & 机器学习：AI 开发首选语言，用于图像识别、语音识别、大模型训练等。
2. 大数据处理：清洗、分析海量数据，生成数据可视化图表。

1.3 Python 环境安装

想要运行 Python 代码，第一步必须安装 Python 解释器。

1.3 一、下载 Python

1. 打开 Python 官方下载页
2. 根据你的电脑系统（Windows/macOS/Linux），选择对应版本下载（推荐稳定版，如 Python 3.10+）。

1.3 二、安装步骤（Win）

1. 运行下载好的安装包。

2. 最关键一步：一定要勾选底部的 Add python.exe to PATH（添加到系统环境变量）。

3. 可以选择：

   • 默认安装：直接安装到 C 盘（适合新手）。
   • 自定义安装：可修改安装路径，安装到其他磁盘。

4. 一路点击下一步，等待安装完成即可。

1.3 三、验证安装

1. 打开终端：

   • 按 Win + R → 输入 cmd → 回车。

2. 在终端输入：python

   • 出现 Python 版本号 + >>> 提示符，说明安装成功！

1.3 四、常见问题

如果输入 python 出现以下提示，说明环境变量配置失败：

1. 提示不是内部或外部命令
2. 自动打开 Windows 应用商店

解决方法

1. 最简单：卸载已安装的 Python，重新安装，务必勾选 Add python.exe to PATH。
2. 进阶：手动配置系统环境变量（新手推荐第一种方法）。

1.4 Hello World

编程界有一个经典传统——所有语言的入门第一课，都是写出 Hello World（你好，世界），这个习惯源自经典的《C 程序设计语言》，后来成为所有程序员的起点仪式。

1.4 一、交互模式

进入交互模式

1. 打开终端（Win + R → 输入 cmd → 回车）
2. 输入 python 命令进入 Python 交互环境
3. 看到 >>> 符号，就代表可以开始写代码了！

退出交互模式

• 命令：exit()
• 快捷键：Ctrl + D
• 直接输入 exit 也能看到官方退出提示

1.4 二、编写程序

直接在 >>> 后面输入代码，按回车就能运行：

# 输出 hello world
print("hello world")

# 输出自定义内容
print("hello hsiwf")

运行后会直接显示：

hello world
hello hsiwf

1.4 三、注意事项

1. 引号必须是 英文引号

• ✅ 正确："hello" 或 'hello'（单双引号都可以）
• ❌ 错误：“hello”（中文引号会直接报错）

2. 所有标点符号都必须是英文

• 逗号、句号、括号、冒号……一律用英文！

3. 新手防错小技巧（强烈推荐）

• Windows 系统设置 → 时间和语言 → 语言与区域 → 首选语言（中文）→ 选项 找到键盘，开启：中文输入时使用英文标点 。打开后，再也不会因为中文符号导致代码报错！

1.5 Python 解释器

我们写的 Python 代码，计算机根本看不懂，必须靠一个翻译工具把代码转成计算机能识别的指令，这个工具就是 Python 解释器。

1.5 一、什么是解释器？

简单说：解释器 = 逐行翻译官。会把你写的高级语言代码，一行一行实时翻译成计算机能执行的二进制指令，边翻译边运行。

1.5 二、编译型 vs 解释型

编程语言分为两大类，核心区别在于翻译方式不同：

1. 编译型语言（一次性翻译）

• 代表：C、C++、Go
• 翻译过程：源代码 → 编译器（一次性全部翻译） → 生成可执行文件 → 直接运行
• 特点：一次翻译，多次运行，速度快；调试麻烦，改代码必须重新编译。

2. 解释型语言（逐行翻译）

• 代表：Python、JavaScript、PHP
• 翻译过程：源代码 → 解释器（逐行翻译 + 逐行执行） → 直接运行
• 特点：写完就能运行，调试方便、开发快；运行速度比编译型稍慢。

1.5 三、Python 运行流程

Python 是标准的解释型语言，运行流程非常清晰：

1. 你写好 .py 代码文件
2. 交给 Python 解释器
3. 解释器逐行读取、逐行翻译
4. 转成计算机能识别的二进制指令
5. 交给操作系统 → 最后由 CPU 执行

总结：Python 代码 → Python 解释器 → 逐行翻译 → 二进制 → 运行；我们之前安装的 Python 环境，本质上就是在安装 Python 解释器。没有解释器，你的代码一行都跑不了。

参考文章：一文了解解释型语言和编译型语言之区别

1.6 认识 Bug

在编程学习中，Bug 是再正常不过的伙伴——几乎没有人写代码从不犯错。认识 Bug、学会面对 Bug，也是编程入门的重要一课。

1.6 一、什么是 Bug？

简单来说：程序无法正常运行，或者运行结果和你想要的不一样，这就是 Bug。它不是电脑坏了，只是代码写得不对。

1.6 二、为什么会出 Bug？

出现 Bug 不代表你笨，只代表你在真实学习。新手最常见的 3 个原因：

1. 粗心失误：拼写错单词、用了中文符号、少打括号、多打空格…… 都是最常见的小错误。
2. 知识点没理解透：不知道语法规则、不清楚代码该怎么写、逻辑搞错了。
3. 经验不足：不知道哪里容易错，也不知道怎么排查。

1.6 三、产生 Bug 的操作

1. 单词拼写错误（最常见）

# 错误  解释器会直接报错：找不到这个名字
prnt("hello world")
prit("hello world")
pint("hello world")

2. 使用了中文符号

# 错误  解释器完全不认识中文符号，一定会报错
print("hello world")   # 如果你用了中文引号 “ ”
print(“hello world”)

3. 代码前面乱加空格（缩进错误）

# 错误（前面多打了空格）  Python 对缩进非常严格，不该空格的时候乱空格，也会报错
 print("hello world")

4. 括号不配对

# 错误（少了右边括号）
print("hello world"

1.6 四、面对 Bug 的心态

1. 不要慌，报错不是灾难，只是提示你 “哪里写错了”。
2. 先看报错信息，它会告诉你错误位置。
3. 检查拼写、符号、缩进，90% 的新手 Bug 都在这里。
4. 慢慢改，一点点排查。

1.7 Python 开发环境

安装好 Python 解释器后，我们还需要一个专业的代码编辑器来写代码。就像写文章需要 Word、写表格需要 Excel 一样，写 Python 代码，最专业、最常用的工具就是 PyCharm。

1.7 一、为什么选 PyCharm？

PyCharm 是目前最主流、最强大的 Python 专用开发工具，由著名的 JetBrains 公司开发。

1. 代码自动提示：不用死记硬背单词，敲几个字母就能自动补全。
2. 自动纠错：写错代码会立刻标红，提前帮你发现 Bug。
3. 界面美观易用：适合新手，也适合专业开发者。
4. 一键运行：写完代码点一下就能运行，不用敲命令。

1.7 二、下载 PyCharm

1. 打开官网下载地址
2. 现在 PyCharm 官网已不再单独提供社区版安装包，所有用户统一下载「Unified Product（统一版）」即可，它包含了原社区版和专业版的全部功能，你只需直接安装，不激活付费授权就能永久免费使用原社区版的全部功能，完全满足学习和基础开发需求，安装后还会附赠 1 个月的专业版功能试用，试用期结束后会自动降级回免费模式，无需额外操作。

1.7 三、安装步骤

1. 运行下载好的安装包，点击 Next。

2. 选择安装路径（可以自定义到 D 盘，不占 C 盘空间）。

3. 勾选配置选项（建议全选）：

   • .py 关联
   • 加入环境变量
   • 创建桌面快捷方式

4. 一路点击下一步，最后点击 Install 等待安装完成。

5. 安装完成后，重启电脑，打开 PyCharm 即可开始写代码。

1.7 四、安装完成

打开 PyCharm，创建新项目，就能开始编写、运行你的 Python 代码了！有了它，你就拥有了专业级的 Python 开发环境。

第二节

2.1 字面量(Literal)

2.1 一、什么是字面量？

• 专业定义：用于表达源代码中一个固定值的表示法。
• 通俗理解：直接写在代码里的、实实在在的值，就叫做字面量，你写什么，它就是什么。

2.1 二、常见的 3 种类型

1. 整数（int）：就是我们数学中的整数，没有小数点。例如：666、100、-5、0
2. 浮点数（float）：就是我们数学中的小数。例如：3.14、0.5、-10.8
3. 字符串（str）：用来表示文字信息，必须用英文单引号 ' ' 或英文双引号 " " 包裹起来。例如："Hello World"、'编程入门'、"123"

2.2 注释

2.2 一、注释的作用

1. 解释代码：告诉别人这段代码是干嘛的。
2. 提示自己：过段时间再看代码，能快速回忆思路。
3. 调试代码：暂时让某行代码不运行。
4. 提高可读性：让代码更易懂、易维护。

2.2 二、两种注释方式

1. 单行注释（最常用）：使用 # 井号 开头，# 右边的所有内容都会被忽略；可以独占一行，也可以放在代码后面。

# 这是单行注释，用来解释下面的代码
print("Hello")  # 这是行尾注释，解释当前这行代码

2. 多行注释：使用 三对英文单引号 或 三对英文双引号 包裹；适合写长篇说明、文件头部介绍、函数功能等。

"""
这是多行注释
可以写很多行文字
用来解释一大段代码
"""

'''
这也是多行注释
'''

# TODO(小明): 2026-07-01 增加参数非空判断
def login(username):
    print(username)  # FIXME: 用户名为空时报错

2.2 三、注释的规范（PEP8）

1. 序言性注释：放在文件 / 函数开头，说明功能、作者、参数、返回值、编写时间、修改记录。
2. 功能性注释：放在代码段上方 / 后方，说明局部逻辑、特殊业务、复杂运算。
3. 不要过度注释：代码本身简单易懂时，无需重复添加解释性注释。
4. # 后必须空一格再写文字，行尾注释与代码之间至少空两格。
5. 文件顶部可添加编码注释兼容中文：# -*- coding: utf-8 -*-

2.3 变量

2.3 一、什么是变量？

• 数学定义：能存储计算结果或表示值的抽象概念。

• 通俗理解：程序运行时，用来记录、存储数据的 “盒子”。

• 你可以把变量想象成带名字的储物盒：

  • 盒子里装数据（数字、文字等）
  • 盒子有名字，方便你随时取用

2.3 二、Python 中变量的特点

1. 不用提前声明类型：写其他语言需要先说明是整数 / 字符串，Python 直接赋值就行。
2. 值可以随时修改：变量不是一成不变的，随时可以赋新值。
3. 可以重复使用：定义一次，后面代码能反复调用。

2.3 三、变量的定义格式

变量名 = 值

• = 不是等于号，是赋值符号
• 作用：把右边的值，装进左边的变量里

示例

# 定义整数变量
age = 18

# 定义字符串变量
name = "小明"

# 定义浮点数变量
height = 1.75

2.3 四、变量两大核心特征

1. 变量的值可以改变

num = 10
num = 20  # 变量值被修改为 20

2. 变量可以重复使用

name = "小红"
print(name)  # 使用变量
print(name)  # 再次使用

2.3 五、变量命名规则

1. 只能由 字母、数字、下划线 组成（约定，并不强制）
2. 不能以数字开头，可以数字结尾
3. 区分大小写：age、Age、AGE 是三个不同变量
4. 不能用 Python 关键字（如 if、for、print、class 等）

规范建议（遵守代码更专业）

1. 见名知意：用 name 不用 a、n1
2. 小写字母 + 下划线：user_name、student_score
3. 不使用中文、特殊符号

正确示例

# 定义变量
name = "hsiwf"
age = 20

# 使用变量
print(name)
print(age)

# 运行后可查看当前版本全部关键字，列表内无print
import keyword
print(keyword.kwlist)

2.4 数据类型

在 Python 中，每一个数据都有自己的类型，就像给数据贴上了身份标签，不同类型的数据用途完全不同。

2.4 一、常见数据类型

2.4 二、现阶段重点掌握 3 种

1. 字符串（str）

   • 作用：存储文字、文本
   • 规则：必须用 英文单 / 双引号 包裹

2. 整型（int）

   • 作用：存储整数
   • 规则：没有小数点，直接写数字

3. 浮点型（float）

   • 作用：存储小数
   • 规则：带小数点

2.4 三、查看数据的类型？

Python 提供了内置函数 type()，可以直接查看任意数据的类型。

使用示例：

# 查看字符串类型
print(type("Hello"))  # 结果：<class 'str'>

# 查看整数类型
print(type(10))       # 结果：<class 'int'>

# 查看小数类型
print(type(3.14))     # 结果：<class 'float'>

# 运行后，控制台会直接告诉你这是哪种数据类型。

第三节

3.1 数据类型相互转换

实际编程中，经常需要把一种数据类型转为另一种，Python 提供了专属转换函数，操作简单。

3.1 一、常用转换函数

3.1 二、各类转换规则

1. 转为字符串 str() ：所有数据类型都可以无损转为字符串，不会报错。

num1 = 10
num2 = 3.14

# 整型转字符串
print(str(num1), type(str(num1)))  # '10' <class 'str'>
# 浮点型转字符串
print(str(num2), type(str(num2)))  # '3.14' <class 'str'>

2. 整型 ↔ 浮点型

（1）整型转浮点型 float() ：整数会自动补上 .0，不丢失数据。

a = 20
b = float(a)
print(b, type(b))  # 20.0 <class 'float'>

（2）浮点型转整型 int() ：直接舍去小数部分，会丢失精度，不会四舍五入。

c = 3.99
d = int(c)
print(d, type(d))  # 3 <class 'int'>

3. 字符串转数字（重点易错点）

不是所有字符串都能转成整型 / 浮点型，仅纯数字格式的字符串可转换。

（1）字符串转整型 int() ：仅支持纯整数字符串，含小数、文字、符号都会报错。

# 合法
s1 = "666"
print(int(s1))  # 666

# 非法（含小数点，运行报错）
# s2 = "12.34"
# print(int(s2))

（2）字符串转浮点型 float() ：支持整数字符串、小数字符串。

s3 = "88"
s4 = "9.9"
print(float(s3))  # 88.0
print(float(s4))  # 9.9

补充：包含汉字、字母、特殊符号的字符串，无法转为数字，代码会直接报错。

3.1 三、转换规则总结

1. str()：万能转换，任意类型都能转字符串。

2. int()：

   • 浮点型转整型：截断小数，丢失精度；
   • 字符串转整型：只允许纯整数字符串。

3. float()：

   • 整型转浮点型：末尾补 .0；
   • 字符串转浮点型：允许整数、小数格式的数字字符串。

3.2 算数运算符

算术运算符主要用于数字间的数学运算，其中 + 和 * 还可作用于字符串，下面结合用法、示例逐一讲解。

3.2 一、运算符总表

3.2 二、补充注意点

1. + 和 * 支持字符串操作，但 -、/、//、%、** 只适用于数字，作用在字符串上会报错。
2. 整除 // 和取余 % 常搭配使用：被除数 = 除数 × 整除结果 + 余数。
3. 除法 / 结果固定为浮点型，若想要整数结果，可配合 int() 转换。

3.3 赋值运算符

赋值运算符主要用来给变量赋值，还能结合算术运算简化代码写法，是日常编码高频使用的语法。

3.3 一、运算符总表

3.3 三、补充说明

1. 复合赋值运算符（+=、-= 等）只能作用于变量，不能单独写常量。
2. += 也可用于字符串，实现拼接并赋值：

s = "hello"
s += " python"
print(s)  # hello python

3. 这类运算符可以精简代码，在循环、数值累加 / 累乘场景中使用频率极高。

第四节

4.1 字符串

字符串是 Python 里使用频率极高的数据类型，被英文引号包裹的内容，就是字符串。

4.1 一、创建字符串的方式

1. 单引号 ' ' ：适用于内容简短、不含引号的文本。

str1 = 'Hello Python'
print(str1)
print(type(str1))  # <class 'str'>

2. 双引号 " " ：用法和单引号完全相同，二者可以灵活搭配。

str2 = "编程入门"
print(str2)
print(type(str2))  # <class 'str'>

# 内容包含单引号，外层用双引号
str3 = "I'm a student"
print(str3)

3. 三引号 ''' ''' / """ """ ：分为三单引号、三双引号，支持换行书写，用来定义多行字符串。

之前学过三引号可当作多行注释，本质原因是：三引号包裹的内容本身就是字符串。

• 不赋值给变量：充当多行注释，解释器不会执行；
• 赋值给变量：就是标准的多行字符串。

# 多行字符串
str4 = '''
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。
'''
print(str4)
print(type(str4))  # <class 'str'>

# 三双引号写法
str5 = """
Python
Java
C++
"""
print(str5)

4.1 二、补充要点

1. 无论使用哪种引号定义，最终数据类型都是 str（字符串）。
2. 单引号和双引号不支持直接换行，强行换行代码会报错；多行文本优先使用三引号。
3. 引号必须成对出现，且统一使用英文标点，中文引号会直接触发 Bug。

4.2 字符串的编码

编码是字符在计算机中的存储规则，Python 3 对字符串编码做了统一优化，能完美支持中英文、多国语言。

4.2 一、Python3 编码规则

1. Python 3 中字符串（str 类型）默认使用 Unicode 编码，天然支持中文、英文、各国语言，日常使用无需额外设置。
2. UTF-8 是基于 Unicode 设计的变长编码，也是目前互联网最通用的编码格式，主要作用是节省存储空间。

UTF-8 存储规则

• 英文字母、符号：占用 1 个字节
• 常用汉字：占用 3 个字节
• 生僻字符、特殊文字：最多占用 4 个字节

4.2 二、编码与解码

字符串在网络传输、文件读写时，需要转为字节数据，这就用到编码、解码两个核心方法：

1. 编码 encode ()：字符串(str) → 字节(bytes)

语法：字符串.encode(编码格式)，常用格式为 utf-8

# 定义字符串
text = "Python 编程"

# 按照 utf-8 编码，转为字节类型
byte_data = text.encode("utf-8")
print(byte_data)
print(type(byte_data))  # <class 'bytes'>

2. 解码 decode ()：字节(bytes) → 字符串(str)

语法：字节数据.decode(编码格式)，解码格式必须和编码格式保持一致，否则会乱码 / 报错。

# 将字节数据解码回字符串
str_data = byte_data.decode("utf-8")
print(str_data)
print(type(str_data))  # <class 'str'>

4.2 三、关键注意事项

1. 编码解码格式必须统一：用 utf-8 编码，就必须用 utf-8 解码，混用格式会出现乱码。
2. str 类型是给人阅读的文本，bytes 类型是计算机底层传输 / 存储的数据。
3. 仅 Python 3 字符串默认 Unicode；Python 2 编码规则不同，现阶段无需了解。

参考文章：Unicode 和 UTF-8 有什么区别？

4.3 转义字符

转义字符以反斜杠 \ 开头，用来表示特殊功能字符，可以实现换行、空格、回车等效果，常用于字符串中。

4.3 一、常用转义字符说明

4.3 二、代码示例

1. 换行符 \n ：最常用，实现文本换行展示

print("第一行\n第二行\n第三行")

输出：

第一行
第二行
第三行

2. 制表符 \t ：制作对齐格式，常用于排版

print("姓名\t年龄\t性别")
print("小明\t18\t男")
print("小红\t17\t女")

输出：

姓名	年龄	性别
小明	18	男
小红	17	女

3. 回车符 \r ：光标回到行首，后续内容会覆盖前面的文字

print("12345\rabc")

输出：

abc

4. 续行符 \ ：代码过长时，在行尾加 \，将一行代码拆分成多行书写，逻辑上仍为同一行

str1 = "这是一段很长的字符串，\
使用续行符拆分代码行"
print(str1)

输出：

这是一段很长的字符串，使用续行符拆分代码行

4.3 三、补充小知识

1. 如果想让 \ 不具备转义功能，可以使用原始字符串，在字符串前加 r/R：

# 原始字符串，\ 仅作为普通字符
print(r"路径：D:\python\note")

2. 转义字符仅在引号包裹的字符串内生效。

4.4 字符串的拼接

4.4 一、基础用法：+

语法：字符串1 + 字符串2 + ...

# 简单拼接
s1 = "Hello"
s2 = "Python"
res = s1 + " " + s2
print(res)  # Hello Python

4.4 二、注意事项

1. + 只能拼接字符串类型，不能直接和数字、其他类型混用，否则会报错。

name = "小明"
age = 18
# 错误写法：字符串 + 数字
# print(name + age)

# 正确写法：先把数字转为字符串
print(name + str(age))  # 小明18

2. 支持连续拼接多个字符串

a = "今天"
b = "学习"
c = "Python"
print(a + b + c)  # 今天学习Python

4.4 三、拓展：快速拼接

多个 无变量（常量字符串） 的字符串挨在一起，可省略 + 直接拼接：

print("我""爱""编程")  # 我爱编程

4.5 字符串的格式化

当需要拼接大量变量时，单纯用 + 拼接又繁琐又容易报错，这时就可以使用字符串格式化。它能灵活嵌入不同类型数据，是项目中主流的字符串拼接方案。Python 常用三种格式化方式：% 占位符、format()、f-string。

4.5 一、% 占位符

1. 基础占位符

示例

name = "小李"
age = 20
score = 95.5

# %s 通用占位
print("姓名：%s，年龄：%s，分数：%s" % (name, age, score))

# %d 接收整数、%f 接收浮点数
print("姓名：%s，年龄：%d，分数：%f" % (name, age, score))

2. 数字精度控制 m.nf

格式：%m.nf

• m：整体数字宽度，小于数字本身长度时不生效（日常很少用）
• .n：保留 n 位小数，会自动四舍五入

num = 3.1415926
# 保留 2 位小数
print("圆周率：%.2f" % num)  # 圆周率：3.14

# 保留 4 位小数
print("圆周率：%.4f" % num)  # 圆周率：3.1416

3. 多个变量格式

多个占位符时，变量需要放在 () 中，顺序必须和占位符一一对应。

4.5 二、format () 方法

• 使用 {} 作为占位符，语法更简洁，兼容性强。
• 语法："字符串{}字符串{}".format(变量1, 变量2)

基础用法

name = "小张"
age = 19
print("姓名：{}，年龄：{}".format(name, age))

小数精度控制

格式：{:.nf}，同样实现保留 n 位小数、四舍五入

pi = 3.1415926
print("圆周率：{:.2f}".format(pi))  # 圆周率：3.14

4.5 三、f-string

• 目前最简洁、最高效的写法，日常开发首选。（推荐，Python3.6+ 新特性）
• 语法：在字符串前加 f，{} 内部直接写入变量 / 表达式。

1. 基础用法

name = "小王"
age = 22
print(f"姓名：{name}，年龄：{age}")

2. 小数精度控制

格式：{变量:.nf}

price = 12.345
print(f"价格：{price:.2f}")  # 价格：12.35

3. 支持直接运算

{} 中可以直接写计算表达式，运行时自动求值

a = 10
b = 20
print(f"两数之和：{a + b}")  # 两数之和：30

4.5 四、三种方式对比

1. % 占位符：老旧写法，语法繁琐，适合老项目维护。
   • %s 通用、%d 整数、%f 小数，%.nf 控制小数位数。
2. format()：兼容性好，写法规范，通用场景都可用。
3. f-string：语法最简单、运行效率最高，新手优先掌握。

4.5 五、核心注意点

1. 格式化可以直接嵌入数字、字符串，无需手动用 str () 转换。
2. 小数精度控制 .n 都会自动执行四舍五入。
3. 新项目优先使用 f-string。

4.6 原生字符串

原生字符串英文为 raw strings，作用是让字符串内的转义字符失效，内容原样输出。

4.6 一、基本语法

在字符串引号前添加修饰符 r 或 R，格式：

r'字符串内容'
r"字符串内容"

4.6 二、使用场景

日常路径、正则表达式中常会出现 \，它默认是转义符，容易引发异常，这时就可以使用原生字符串。

1. 普通字符串（\ 触发转义）

# \n 被识别为换行符
print("D:\new_folder")

输出：

D:
ew_folder

2. 原生字符串（原样输出）

加上 r 后，\ 仅作为普通字符，不再转义：

print(r"D:\new_folder")
print(R"C:\Users\Python\笔记")

输出：

D:\new_folder
C:\Users\Python\笔记

3. 包含其他转义符

\t、\r、\n 等所有转义字符，在原生字符串里都会原样展示：

# 普通字符串：\t 生成制表空格
print("hello\tpython")

# 原生字符串：\t 原样输出
print(r"hello\tpython")

输出：

hello	python
hello\tpython

4.6 三、补充说明

1. 原生字符串仅关闭转义功能，引号规则和普通字符串一致，仍需成对使用英文引号。
2. 常用场景：文件路径、网址、正则表达式。
3. 简写：r 和 R 效果完全相同，日常多用小写 r。

第五节

5.1 输入函数 input ()

input() 是 Python 用于接收用户键盘输入的内置函数。

5.1 一、基本特性

1. Python 3 中，input() 无论输入数字、文字，最终返回结果一律是字符串（str）类型。
2. 执行代码后，程序会暂停，等待用户在控制台输入内容，按下回车结束输入。

5.1 二、基础语法

变量 = input()

示例 1：输入数字

a = input()
# 控制台输入：123
print(a)
print(type(a))  # <class 'str'>

即便输入整数 123，变量 a 依旧是字符串类型。

示例 2：输入中文 / 文本

a = input()
# 控制台输入：张三
print(a)
print(type(a))  # <class 'str'>

5.1 三、带提示语的用法

可以在括号内写入提示文字，引导用户输入，语法：

变量 = input("请输入内容：")

示例：

name = input("请输入你的姓名：")
print("你好，" + name)

5.1 四、重点：输入运算

由于 input() 结果默认是字符串，不能直接和数字运算，需要手动转换类型。

示例：实现数字相加

# 接收输入并转为整型
num1 = int(input("请输入第一个数字："))
num2 = int(input("请输入第二个数字："))

# 正常数学运算
res = num1 + num2
print("两数之和：", res)

如果是小数运算，使用 float() 转换：

num = float(input("请输入小数："))
print(num, type(num))

5.2 字符串的常用方法

字符串自带大量内置方法，可实现大小写转换、统计、查找、分割、替换、类型判断等功能，下面分类讲解并附实战示例。

5.2 一、大小写转换

1. upper() ：将字符串所有小写字母转为大写

s = "Hello Python"
print(s.upper())  # HELLO PYTHON

2. lower() ：将字符串所有大写字母转为小写

s = "Hello Python"
print(s.lower())  # hello python

5.2 二、长度与计数

1. len(字符串) ：获取字符串总字符个数（空格、符号都算）

s = "Python 编程"
print(len(s))  # 8

2. count(子串) ：统计子字符串在原字符串中出现的次数

s = "aabbbcc"
print(s.count("a"))  # 2
print(s.count("b"))  # 3

5.2 三、查找位置

两者作用一致，查找子串首次出现的索引位置，核心区别：

• find()：找不到子串，返回 -1（不报错）
• index()：找不到子串，直接抛出异常

s = "hello world"
print(s.find("world"))   # 6
print(s.index("world"))  # 6

print(s.find("abc"))     # -1
# print(s.index("abc"))  # 代码报错

拓展用法（指定查找范围）：find(子串, 起始索引, 结束索引) / index(子串, 起始索引, 结束索引)

5.2 四、去除首尾空格

删除字符串首尾的空格、换行、制表符等空白字符，中间内容不受影响

s = "  学习Python  "
print(s.strip())  # 学习Python

5.2 五、字符串分割

按照指定字符拆分字符串，返回列表

• 不传分隔符：默认以空白（空格、换行、tab）分割
• num 为分割次数，最终得到 num+1 段内容

s = "苹果,香蕉,橘子,葡萄"
# 以逗号分割
print(s.split(","))  # ['苹果', '香蕉', '橘子', '葡萄']

# 只分割2次
print(s.split(",", 2))  # ['苹果', '香蕉', '橘子,葡萄']

5.2 六、内容替换

将字符串中所有指定旧子串，替换为新内容

s = "今天天气很好"
print(s.replace("很好", "晴朗"))  # 今天天气晴朗

5.2 七、开头 / 结尾判断

1. startswith(子串) ：判断字符串是否以指定内容开头，返回布尔值 True/False

s = "https://www.xxx.com"
print(s.startswith("https"))  # True

2. endswith(子串) ：判断字符串是否以指定内容结尾，返回布尔值

s = "demo.jpg"
print(s.endswith("jpg"))  # True

支持指定检索范围：startswith(x, 起始下标, 结束下标)

5.2 八、字符类型判断方法

这类方法会检测字符串组成，统一返回 True / False

示例

print("123".isdecimal())    # True
print("abc".isalpha())      # True
print("Abc".istitle())      # True
print("hello".islower())    # True
print("HELLO".isupper())    # True
print("   ".isspace())      # True

5.3 字符串下标与切片

下标（索引）用于获取单个字符，切片用于截取一段字符，是字符串高频用法。

5.3 一、下标（索引）

字符串每个字符都有专属下标，从 0 开始计数，同时支持负数下标（从末尾倒数）。

规则

• 正下标：从左往右，0、1、2、3……
• 负下标：从右往左，-1、-2、-3……，-1 代表最后一个字符

示例

name = 'abcdef'
# 正下标取值
print(name[0])  # a
print(name[1])  # b
print(name[2])  # c
print(name[3])  # d
print(name[4])  # e
print(name[5])  # f

# 负下标取值
print(name[-1]) # f（最后一位）
print(name[-2]) # e

5.3 二、切片

切片可以截取字符串中的一段内容，字符串、列表、元组都支持切片。

基础语法

字符串[起始下标:结束下标:步长]

1. 左闭右开：包含起始下标，不包含结束下标

2. 三大参数均可省略：

   • 省略起始：默认从开头截取
   • 省略结束：默认截取到末尾
   • 省略步长：默认步长为 1（逐个取值）

基础示例

name = 'abcdef'

# 0~2 下标（不包含3）
print(name[0:3])   # abc

# 0~4 下标（不包含5）
print(name[0:5])   # abcde

# 3~4 下标（不包含5）
print(name[3:5])   # de

# 从下标2截取到末尾
print(name[2:])    # cdef

# 下标1 到 倒数第2位
print(name[1:-1])  # bcde

步长用法

步长表示取值间隔，步长为正数从左向右取，负数从右向左取。

name = 'abcdef'
# 步长为2，隔1个字符取1个
print(name[0:6:2])  # ace

# 倒序截取（步长为-1）
print(name[::-1])   # fedcba

5.3 三、总结

1. 下标：取单个字符，正索引从 0 开始，-1 表示最后一位。

2. 切片格式：[起始:结束:步长]，遵循左闭右开。

3. 省略参数技巧：

   • [x:]：从 x 取到末尾
   • [:y]：从开头取到 y 前一位
   • [::-1]：快速实现字符串反转。

第五节 作业

第一题：将字符串 "abcd" 转成大写

print("abcd".upper())

第二题：计算子串 "cd" 在 "abcd" 中的位置

# 两种写法均可
print("abcd".find("cd"))
print("abcd".index("cd"))

第三题：用逗号分割 "a,b,c,d"，判断结果类型

string = "a,b,c,d"
res = string.split(',')
print(res)
print(type(res))

第四题：修复 "{}-喜欢-{}".format("张三") 报错问题

print("{}喜欢{}".format("张三", "嘉乐"))

第五题：把 "Python is good" 中 Python 改为 python

string = "Python is good"
print(string.lower())

string = "Python is good"
print(string.replace('P', 'p'))

第六题：截取 python字符串学习.py 中 .py 前面的内容

string = "python字符串学习.py"
print(string[:-3])

string = "python字符串学习.py"
print(string[:-len(".py")])

string = "python字符串学习.py"
lst = string.split('.')
end = len(lst[-1]) + 1
print(string[:-end])

第七题：将 "this is python" 中的 python 替换为 apple

string = "this is python"
list = string.split(" ")
print(string.replace(list[-1], "apple"))

string = "this is python"
print(string.replace("python", "apple"))

第八题：判断字符串是否以 this 开头

string = "this is python"
print(string.startswith("this"))

第九题："this is python" 每个单词首字母大写

string = "this is python"
print(string.title())

第十题：删除末尾换行符 "\n"

string = "this is a book\n"
print(string.strip())

第十一题：只删除开头换行符，保留末尾换行

string = "\nthis is a book\n"
print(dir("string"))
print(string.lstrip())

第六节

6.1 布尔类型(bool)

布尔类型是专门用来表示真、假的数据类型，仅包含两个字面量：True 和 False。

6.1 一、布尔字面量

• True：代表真、成立、是
• False：代表假、不成立、否

print(type(True))   # <class 'bool'>
print(type(False))  # <class 'bool'>

定义布尔变量

bool_true = True
bool_false = False
print(bool_true)   # True
print(bool_false)  # False

6.1 二、布尔与数字的关系

Python 中布尔类型是数字的子类型：

• True 等价于整数 1
• False 等价于整数 0

支持数学运算：

print(True + 1)    # 1 + 1 = 2
print(False + 1)   # 0 + 1 = 1

6.1 三、bool() 函数

使用 bool(数据) 可以得到任意数据对应的布尔结果。

1. 数字的真假规则

• 非 0 数字：结果为 True（正数、负数都成立）
• 数字 0、0.0：结果为 False

print(bool(1))      # True
print(bool(0))      # False
print(bool(-1))     # True
print(bool(0.00))   # False

2. 字符串的真假规则

• 非空字符串（包含字母、数字、空格）：True
• 空字符串 ""：False

print(bool("a"))     # True
print(bool(" "))     # True（空格也算有效字符）
print(bool(""))      # False（空字符串）
print(bool("True"))  # True
print(bool("False")) # True

6.1 四、通用总结（现阶段）

1. 数字：0 / 0.0 为假，其余数字为真
2. 字符串：空串为假，有内容（含空格）为真
3. True 本质是 1，False 本质是 0，可参与加减运算

6.2 比较运算符

比较运算符用来对比两个数据，运算结果只有布尔值 True / False。

6.2 一、运算符汇总

6.2 二、基础用法示例

a = 10
b = 5

print(a > b)   # True
print(a < b)   # False
print(a == b)  # False
print(a >= b)  # True
print(a <= b)  # False
print(a != b)  # True

6.2 三、== 和 is 的区别（重点）

1. ==：只对比两个变量的值是否相等
2. is：对比两个变量内存地址是否完全一致（是否为同一个对象）

示例演示

# 值相等、地址也相同
num1 = 20
num2 = 20
print(num1 == num2)  # True
print(num1 is num2)  # True

# 值相等，但内存地址不同
s1 = [1, 2, 3]
s2 = [1, 2, 3]
print(s1 == s2)      # True（值一样）
print(s1 is s2)      # False（不是同一个对象）

6.2 四、补充说明

1. 比较运算符可以连续使用

x = 8
print(5 < x < 10)  # True，等价于 5 < x 并且 x < 10

2. 支持数字、字符串等类型比较：字符串会按字符编码顺序对比大小。

print("abc" < "abd")  # True

3. 所有比较运算结果，都可以直接赋值给布尔变量：

res = 3 > 1
print(res, type(res))  # True <class 'bool'>

第七节

7.1 if-else 条件语句

7.1 一、基础语法

if 判断条件:
    # 条件为 True 时执行，必须缩进（默认4个空格）
    pass
else:
    # 条件为 False 时执行，必须缩进
    pass

关键字说明：

1. 判断条件：最终会转为布尔值，True 条件成立，False 条件不成立。
2. 英文冒号 :：if、else 行末尾必须加英文冒号，漏写直接报错。
3. 缩进：冒号下方的代码块，统一缩进 4 个空格，Python 靠缩进区分代码范围。
4. pass：空占位语句，不执行任何操作，仅用来补全语法结构，防止报错。
5. else：可选部分，条件不成立时无逻辑要执行，可以省略 else。

7.1 二、基础示例

示例 1：完整 if-else 结构

age = 18
if age >= 18:
    print("已成年")
else:
    print("未成年")

示例 2：只使用 if（省略 else）

条件不成立时无需操作，直接去掉 else

score = 90
if score >= 60:
    print("考试及格")

示例 3：pass 占位用法

暂时不确定代码逻辑，先用 pass 占位，保证程序正常运行

num = 10
if num > 5:
    pass  # 后续再补充代码
else:
    print("数字小于等于5")

7.1 三、常用判断条件

条件可以是比较运算、布尔值、变量等，只要能得到布尔结果即可：

# 1. 直接使用布尔值
if True:
    print("条件成立")

# 2. 使用比较运算符
a = 20
if a != 10:
    print("a 不等于 10")

# 3. 直接判断数据本身真假
s = "hello"
if s:  # 非空字符串 → True
    print("字符串不为空")

7.1 四、核心注意事项

1. 冒号必须是英文 :，中文冒号会报错。
2. 代码块必须统一缩进（4 个空格），缩进混乱程序报错。
3. else 不能单独使用，必须搭配 if。
4. pass 仅占位，无实际功能，常用于临时预留代码位置。

7.1 五、单 if 语句

if 条件:
    代码

适用场景：只处理条件成立的情况，不关心条件不成立的结果。

7.2 if-elif-else 多分支语句

当存在多种判断场景时，使用 if-elif-else 多分支结构，依次匹配条件，只会执行第一个满足的分支。

7.2 一、语法格式

if 判断条件1:
    # 条件1成立执行
    pass
elif 判断条件2:
    # 条件2成立执行
    pass
elif 判断条件3:
    # 条件3成立执行
    pass
# 可继续添加多个 elif
else:
    # 所有条件都不成立时执行
    pass

7.2 二、核心规则

1. elif 可以有多个，根据实际场景增减。
2. 判断有序、互斥：从上到下依次判断，一旦某个条件成立，执行对应代码后，整个分支直接结束，后续 elif、else 不再执行。
3. else 可选：所有条件都不满足时才执行，不需要兜底逻辑可以省略。
4. 每行末尾必须加英文冒号，内部代码保持 4 空格缩进。

7.2 三、代码示例

示例 1：分数等级判断（经典用法）

score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("中等")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# 运行结果：良好

逻辑：满足 score >=80，后面所有分支都不再判断。

示例 2：省略 else

只处理已知条件，无兜底逻辑：

num = 2
if num == 1:
    print("数字1")
elif num == 2:
    print("数字2")
elif num == 3:
    print("数字3")

示例 3：pass 占位

暂时不编写分支代码，用 pass 保证语法合法：

age = 22
if age < 18:
    pass
elif age < 30:
    print("青年")
else:
    pass

7.2 四、补充要点

1. 判断顺序很重要：范围大的条件尽量放在后面，否则会出现逻辑错误。
2. 整个结构中，最多只会执行一个分支。
3. elif 不能单独使用，必须依附于前面的 if。

7.3 if 语句的嵌套

if 嵌套就是在一个 if 代码块内部，再写另一个 if 判断，用来实现先满足大前提，再做二次 / 多次判断的场景。

7.3 一、基础语法

核心依靠缩进区分层级，内层 if 必须在外层 if 的缩进范围内。

if 判断条件1:
    # 外层条件1成立，执行这里
    pass
    if 判断条件2:
        # 同时满足条件1 + 条件2，才执行这里
        pass

完整嵌套（搭配 else）

if 判断条件1:
    print("外层条件成立")
    if 判断条件2:
        print("内层条件成立")
    else:
        print("内层条件不成立")
else:
    print("外层条件不成立")

7.3 二、代码示例

示例 1：简单两层嵌套

# 判断是否成年，成年后再判断年龄是否大于 22
age = 23
if age >= 18:
    print("已是成年人")
    # 内层判断
    if age > 22:
        print("可以参加征兵")
else:
    print("未成年")

示例 2：多层嵌套 + elif/else

age = 20
gender = "女"

if age >= 18:
    print("成年")
    if gender == "男":
        print("男性成年人")
    elif gender == "女":
        print("女性成年人")
    else:
        print("性别未知")
else:
    print("未成年")

7.3 三、核心要点

1. 缩进决定层级：每多一层判断，就多一次缩进（统一 4 个空格），缩进错误会直接导致逻辑错乱、代码报错。
2. 执行顺序：必须先满足外层 if 条件，才会进入内层继续判断；外层不成立，内层代码完全不会执行。
3. 支持多层嵌套：if 里面套 if，还可以继续往下嵌套，实际开发中一般不建议嵌套过深。

第七节 作业

第一题：判断正整数是否为回文数，输入正整数，判断正序和倒序数字是否一致（回文数）。

num = input("请输入一个正整数：")
# 利用字符串切片 [::-1] 实现字符串反转
num1 = num[::-1]
if num1 == num:
    print(f'{num}是一个回文数')
else:
    print(f'{num}不是一个回文数')

num = input("请输入一个正整数：")
if not num.isdigit() or int(num) <= 0:
    print("输入不是合法正整数")
else:
    if num == num[::-1]:
        print(f'{num}是一个回文数')
    else:
        print(f'{num}不是一个回文数')

第二题：判断输入数字是否为偶数，接收正整数，判断奇偶。

num = int(input("请输入一个正整数："))
if num % 2 == 0:
    print(f'{num}是一个偶数')
else:
    print(f'{num}不是一个偶数')

第三题：猜数字游戏（3 次机会猜 1~10 幸运数字），随机生成 1~10 数字，共 3 次猜测机会，猜中则提示 7 折，3 次全错则提示机会用完。

import random

num = str(random.randint(1, 10))
# 第一次猜测
num1 = input("请输入一个幸运数字：")
if num1 == num:
    print("恭喜，您非常好运，第一次就猜中幸运数字，可以获得全场 7 折的福利。")
else:
    # 第二次猜测
    num2 = input("很遗憾，第一次没有猜中，您还有 2 次机会，请第二次输入一个幸运数字：")
    if num2 == num:
        print("恭喜，您运气还不错。第二次就猜中幸运数字，可以获得全场 7 折的福利。")
    else:
        # 第三次猜测
        num3 = input("很遗憾，前 2 次没有猜中，您还有 1 次机会，请第三次输入一个幸运数字：")
        if num3 == num:
            print("恭喜，好运最后还是选择了您，可以获得全场 7 折的福利。")
        else:
            print("您机会用完了，欢迎下次再来。")

import random

num = str(random.randint(1, 10))
num1 = input("请输入一个幸运数字：")
if num1 == num:
    print("恭喜，您非常好运，第一次就猜中幸运数字，可以获得全场 7 折的福利。")
elif input("很遗憾，第一次没有猜中，您还有 2 次机会，请第二次输入一个幸运数字：") == num:
    print("恭喜，您运气还不错。第二次就猜中幸运数字，可以获得全场 7 折的福利。")
elif input("很遗憾，前 2 次没有猜中，您还有 1 次机会，请第三次输入一个幸运数字：") == num:
    print("恭喜，好运最后还是选择了您，可以获得全场 7 折的福利。")
else:
    print("您机会用完了，欢迎下次再来。")

第八节

8.1 逻辑运算符

逻辑运算符用于连接多个判断条件，结合布尔值使用，一共三种：and、or、not。

8.1 一、基础规则

8.1 二、基础布尔值演示

a = True
b = False

print(a and b)   # False  一假则假
print(a or b)    # True   一真则真
print(not (a and b)) # True  对 False 取反

8.1 三、结合比较运算

逻辑运算符常搭配比较运算符，实现多条件判断

a = 3
b = 4
c = 5

print(a > b and b < c)   # False and True → False
print(a > b or b < c)    # False or True → True
print(not (a > b))       # not False → True
print(not (a > b) and b > c)  # True and False → False

8.1 四、数字运算（重点）

Python 中 and / or 不一定只返回布尔值，遵循短路取值规则：

1. and 规则 从左向右判断：

• 遇到第一个假值，直接返回该假值；
• 全部为真值，返回最后一个值。

a = 20 
b = 30
print(a and b)  # 20、30 都是真值，返回最后一个：30
print(b and a)  # 30、20 都是真值，返回最后一个：20

2. or 规则 从左向右判断：

• 遇到第一个真值，直接返回该真值；
• 全部为假值，返回最后一个假值。

a = 20 
b = 30
print(a or b)   # 20 是真值，直接返回 20

8.1 五、复杂表达式运算

运算顺序：先算 not，再算 and，最后算 or

示例 1

print(not 3 > 2 and 3 < 4 or 4 > 5 and 9 < 8)
# 分步拆解：
# 1. 比较运算：not True and True or False and False
# 2. not 优先：False and True or False and False
# 3. 计算 and：False or False
# 4. 计算 or：False？修正原题运行结果：原式最终为 False

示例 2

print(3 > 1 and 2 or 2 < 3 and 3 and 4 or 3 > 2)
# 分步拆解：
# 比较运算：True and 2 or True and 3 and 4 or True
# 逐个计算 and：2 or 4 or True
# 逐个计算 or：返回第一个真值 2

8.1 六、总结

1. 基础逻辑

   • and：全真才真，一假即假
   • or：一真即真，全假才假
   • not：结果取反

2. 短路取值（核心考点）

   • and：遇假返假，全真返最后一个
   • or：遇真返真，全假返最后一个

3. 优先级：not > and > or，多层表达式按此顺序计算。

4. 日常开发多用于 if 多条件判断：

age = 20
if age >= 18 and age < 60:
    print("青壮年")

8.2 成员运算符

成员运算符用来判断某个元素是否存在于序列（字符串、列表等） 中，结果返回布尔值 True / False。

8.2 一、运算符说明

8.2 二、代码示例

1. 作用于字符串：字符串按字符 / 子串匹配，区分大小写

hello_string = "Hello Python"

# 判断子串 "Hello" 是否存在
print("Hello" in hello_string)    # True
# 判断子串 "python" 是否不存在（原串是大写P）
print("python" not in hello_string)  # True

2. 作用于列表：逐个匹配列表内的完整元素

fruits = ['apple', 'orange', 'banana']

print('purple' in fruits)    # False，列表无该元素
print('apple' not in fruits) # False，列表存在该元素

8.2 三、补充要点

1. 区分大小写：字符串匹配严格区分大小写，Hello 和 hello 视为不同内容。
2. 适用范围：除字符串、列表外，元组、集合、字典等序列 / 容器也支持 in / not in。
3. 常用场景：搭配 if 做条件判断

s = "learn python"
if "python" in s:
    print("字符串包含 python")

8.3 条件表达式

条件表达式是 if-else 的简写形式，一行代码完成二选一赋值，也叫三元表达式。

8.3 一、基础语法

# variable = <expr1> if <condition> else <expr2>
变量 = 表达式1 if 条件 else 表达式2

执行逻辑：

1. 先判断条件；
2. 条件为 True → 返回表达式 1；
3. 条件为 False → 返回表达式 2。

8.3 二、示例对比

1. 传统 if-else 写法

a = 3
b = 4
if a > b:
    max_num = a
else:
    max_num = b
print(max_num)  # 4

2. 条件表达式简写（等价功能）

a = 3
b = 4
max_num = a if a > b else b
print(max_num)  # 4

8.3 三、更多实战例子

例 1：判断奇偶

num = 7
res = "偶数" if num % 2 == 0 else "奇数"
print(res)  # 奇数

例 2：判断是否成年

age = 17
tip = "成年" if age >= 18 else "未成年"
print(tip)  # 未成年

8.3 四、关键说明

1. 它属于表达式，不是流程控制语句，整体会产生一个返回值，可直接赋值、打印。
2. 仅适合简单二选一场景，不建议嵌套多层（可读性会变差）。
3. 结构固定：真值表达式 + if 条件 + else + 假值表达式，if 和 else 不能省略。

第八节 作业

第一题：判断闰年（必考点）

闰年规则

1. 普通闰年：能被 4 整除 并且 不能被 100 整除
2. 世纪闰年：能被 400 整除
3. 满足以上任意一种即为闰年

year = int(input("请输入一个年份："))
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f'您输入的年份{year}是闰年')
else:
    print(f'您输入的年份{year}不是闰年')

第二题：判断三位数各位数字是否连续，输入三位数，判断百位、十位、个位是否为连续数字（正序 123、234 或倒序 321、543 都算）。

num = int(input("请输入一个正整数："))
# 拆分百位、十位、个位
a = num // 100        # 百位
b = (num // 10) % 10  # 十位
c = num % 10          # 个位

# 正序连续 / 倒序连续
if a + 2 == b + 1 == c or a == b + 1 == c + 2:
    print(f'{num}是一个连续的数')
else:
    print(f'{num}不是一个连续的数')

num = input("请输入一个正整数：")
a = int(num[0])  # 第0位：百位
b = int(num[1])  # 第1位：十位
c = int(num[2])  # 第2位：个位

if a + 2 == b + 1 == c or a == b + 1 == c + 2:
    print(f'{num}是一个连续的数')
else:
    print(f'{num}不是一个连续的数')

第九节

9.1 while 循环

while 是条件循环，只要判断条件结果为 True，就会重复执行内部代码；条件为 False 时，循环终止。

9.1 一、基本语法

while 条件:
    # 循环体代码（必须缩进4个空格）
    执行语句

核心规则

1. 行尾必须加英文冒号，循环体统一缩进。
2. 条件为 True → 执行循环体；条件为 False → 跳出循环。
3. 必须设置循环终止条件，否则会造成无限死循环。

9.1 二、案例讲解

案例 1：打印 10 行直角三角形（星号），逐行输出 *，第 1 行 1 个，第 10 行 10 个

i = 1
while i <= 10:
    print('*' * i)
    i += 1  # 计数器自增，逐步靠近终止条件

逻辑

• 初始 i=1，满足 i <= 10，打印对应数量星号；
• 每次循环 i += 1，直到 i=11 时条件不成立，循环结束。

案例 2：求 1-100 的累加和

i = 1
total = 0  # 定义变量存储累加结果
while i <= 100:
    total = total + i
    i = i + 1
print(total)

逻辑

1. i 从 1 开始逐个递增；
2. 每次把 i 累加到 total；
3. i 超过 100 退出循环，最后打印总和。

案例 3：while 实现整数反转

思路：把输入当作字符串，从后往前逐个拼接字符

num = input("请输入一个正整数：")
new_num = ""
i = len(num)  # 获取字符串总长度

while i >= 1:
    new_num += num[i - 1]
    i -= 1

print(new_num)

逻辑拆解（以输入 12345 为例）

1. len(num) = 5，初始 i=5；
2. 依次取 num[4]、num[3]…num[0] 拼接到新字符串；
3. i 不断减 1，直到 i=0，条件不成立，循环结束。

9.1 三、关键补充

1. 死循环：条件永远为 True 时，循环永不停止：

while True:
    print("死循环")

开发中慎用，可配合后续 break 手动终止。

2. 计数器规范写法：i = i + 1 可简写为 i += 1，二者完全等价，日常优先使用简写。

3. 执行顺序：先判断条件 → 成立则执行循环体 → 再回到条件判断，往复循环。

9.2 while 循环的嵌套

在一个 while 循环内部再嵌套另一个 while 循环，就是while 循环嵌套，外层循环每执行一次，内层循环会完整跑完一轮。

9.2 一、基础语法

while 条件1:
    # 外层循环体代码
    while 条件2:
        # 内层循环体代码
    # 外层循环后续代码

注意事项

1. 依靠缩进区分内外层循环层级，缩进必须规范。
2. 执行逻辑：外层循环触发 → 内层循环从头到尾执行完毕 → 外层循环计数器更新，再次判断条件，往复执行。
3. 多层嵌套会增加运算量，非必要不使用。

补充知识点：print 结尾控制

默认 print() 执行后会自动换行，通过 end='' 可以自定义结尾字符，实现同行输出：

# 不换行，结尾为空
print("内容", end='')
# 结尾为制表符（空格间隔）
print("内容", end='\t')

案例 1：打印 99 乘法表

i = 1
# 外层循环：控制行数（一共9行）
while i <= 9:
    j = 1
    # 内层循环：控制每行的列数，列数 ≤ 当前行数
    while j <= i:
        print(f'{j}×{i}={j * i}', end='\t')
        j += 1
    # 一行内容打印完成，换行
    print('')
    i += 1

逻辑解析

1. 外层变量 i：代表乘法表第二个数，同时控制总行数，从 1 到 9。
2. 内层变量 j：代表乘法表第一个数，每行的列数等于当前行数 i。
3. end='\t'：让同一行的算式用制表符分隔，排版整齐。
4. 内层循环结束后执行空 print('')，实现换行，开始下一行。

案例 2：模拟买彩票（嵌套循环实战）

需求说明

1. 中奖号码范围：0~999；
2. 购彩规则：第 1 天买 1 注，第 2 天买 2 注…… 第 day 天买 day 注；
3. 单注彩票 2 元，中奖奖金 1000 元；
4. 模拟购彩，直到中奖为止，最终计算总盈亏。

import random

day = 1
is_win = True   # 循环标记，控制外层循环
total_ticket = 0 # 统计总购买注数

while is_win:
    print(f'第{day}天买彩票。')
    # 每日开奖的中奖号码
    luck_num = random.randint(0, 999)
    print(f'第{day}天的开奖号码为{luck_num}。')

    i = 1
    # 内层循环：当天逐注购买彩票
    while i <= day:
        total_ticket += 1
        ticket = random.randint(0, 999)
        if ticket == luck_num:
            print(f'第{day}天的第{i}注彩票中奖啦！购买号码：{ticket}，开奖号码：{luck_num}')
            is_win = False  # 关闭外层循环标记
            i = day         # 提前结束当天购彩
        else:
            print(f'第{day}天的第{i}注彩票未中奖，购买号码：{ticket}，开奖号码：{luck_num}')
        i += 1
    day += 1

# 计算盈亏：奖金 - 总花费
cost = total_ticket * 2
profit = 1000 - cost
print(f"总共购买彩票：{total_ticket} 注")
print(f"总花费：{cost} 元")
print(f"最终盈亏：{profit} 元")

逻辑拆解

1. 外层 while：按天数循环，day 代表当前天数，每天购彩注数 = 天数。

2. 内层 while：遍历当天每一注彩票，生成随机号码并和开奖号比对。

3. 中奖逻辑：一旦某一注中奖，修改循环标记 is_win=False，终止外层大循环。

4. 盈亏计算：

   • 总花费 = 总注数 × 2
   • 盈亏 = 奖金 1000 − 总花费

第九节 作业

第 1 题：计算 1~100 所有偶数的和，使用 while 循环，求 1 到 100（含）中全部偶数累加和。

i = 1
total = 0
while i <= 100:
    if i % 2 == 0:
        total += i
    i += 1

print(total)

i = 2
total = 0
while i <= 100:
    total += i
    i += 2
print(total)

第 2 题：求两个正整数的最小公倍数，最小公倍数 (LCM)：能同时被两个数整除的最小正整数。

解题思路：从两数中较大的值开始向上遍历，第一个能同时整除两数的数，就是最小公倍数。

a = int(input("请输入数字 1："))
b = int(input("请输入数字 2："))

max_num = max(a, b)
min_num = min(a, b)

i = max_num
# 不能同时整除就继续 +1
while not (i % max_num == 0 and i % min_num == 0):
    i += 1
print(i)

a = int(input("请输入数字1："))
b = int(input("请输入数字2："))
i = a
while True:
    if i % a == 0 and i % b == 0:
        break
    i += 1
print(i)

第 3 题：猜数字游戏（1~100，无限次猜测 + 大小提示）

1. 随机生成 1~100 幸运数字；
2. 用户反复猜测，猜错提示 猜大了 / 猜小了；
3. 猜中则结束游戏。

import random

num = str(random.randint(1, 100))

i = 1
sign = True
while sign:
    luck_num = input(f'请第{i}次输入一个幸运数字：')
    if luck_num == num:
        sign = False
    elif int(luck_num) > int(num):
        print("大了")
    else:
        print("小了")
    i += 1

import random

num = str(random.randint(1, 100))
i = 1

while (luck_num := input(f'请第{i}次输入一个幸运数字：')) != num:
    if int(luck_num) > int(num):
        print("大了")
    else:
        print("小了")
    i += 1

print(f'恭喜您第{i}次就猜中幸运数字。')

第十节

10.1 range 函数

range() 是 Python 内置函数，用于生成一系列整数序列，常搭配 for 循环使用。

10.1 一、语法格式

range(start, stop[, step])

参数说明：

1. start：起始数字，可选，默认值为 0
2. stop：结束数字，必传；生成的序列不包含 stop 本身（左闭右开）
3. step：步长（数字间隔），可选，默认值为 1

10.1 二、基础用法示例

1. 只传 stop（省略 start、step）：默认从 0 开始，步长为 1

# 生成 0,1,2,3,4
r = range(5)
print(list(r))  # [0, 1, 2, 3, 4]

2. 传 start + stop（省略 step）：步长默认 1

# 生成 1,2,3,4
r = range(1, 5)
print(list(r))  # [1, 2, 3, 4]

3. 完整传参 start + stop + step：自定义数字间隔

# 从 2 开始，到 10 结束（不含10），步长 2
r = range(2, 10, 2)
print(list(r))  # [2, 4, 6, 8]

10.1 三、重点注意事项

1. 左闭右开：序列包含 start，一定不包含 stop。
2. 起始等于结束：range(3, 3) 无法生成任何数字，结果为空序列。

print(list(range(3, 3)))  # []

3. 步长可以为负数，用于生成倒序序列：

# 从 5 到 1，步长 -1
print(list(range(5, 0, -1)))  # [5, 4, 3, 2, 1]

10.1 四、课堂练习

需求：构建包含 1~100 全部偶数 的列表

# 从2开始，到101结束（保证包含100），步长2
a_list = list(range(2, 101, 2))
print(a_list)

解析：

• start=2：第一个偶数为 2
• stop=101：因为不包含 stop，所以写到 101 才能取到 100
• step=2：每次递增 2，依次取出所有偶数

10.1 五、补充说明

1. range 本身不是列表，是一个可迭代对象，用 list() 转换后才能直观看到全部数字。
2. 优势：占用内存极小，即便 range(0, 1000000) 也不会一次性生成全部数字，运行高效。
3. 核心用途：配合 for 循环实现固定次数遍历、数值遍历。

10.2 for 循环

for 循环也叫遍历循环，专门用来逐个读取可迭代对象（字符串、列表、range、元组等）中的元素，遍历完毕循环自动结束。

10.2 一、基础语法

for 临时变量 in 可迭代对象:
    # 循环体代码（缩进 4 个空格）

• 执行逻辑：依次把可迭代对象里的每个元素赋值给临时变量，执行一次循环体；全部元素遍历完，循环终止。
• 作用域：临时变量在循环内部可使用，不建议在循环外部依赖该变量。

10.2 二、for 与 while

1. 适用场景

   • for：已知遍历范围 / 元素个数，遍历序列、可迭代对象，无需手动维护计数器。
   • while：依靠条件判断循环，适合循环次数不确定的场景，需要手动写终止条件、更新计数器。

2. 写法差异

   • for 自动迭代元素，代码更简洁；
   • while 必须手动控制条件与自增，灵活性更高。

10.2 三、案例实操

案例 1：遍历字符串（for /while 对比）

python_string = 'hello python'

# for 循环（简洁推荐）
for i in python_string:
    print(i)

# while 循环（需下标+计数器）
i = 0
while i < len(python_string):
    print(python_string[i])
    i += 1

案例 2：统计字符串中字母 i 的个数

a_string = "life is short, i use python"
count = 0
for char in a_string:
    if char == "i":
        count += 1
print(f"字母i一共出现：{count} 次")

案例 3：遍历列表

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

案例 4：打印 100 次 hello python

搭配 range() 控制循环次数

# range(100) 生成 0~99，一共100个数字，循环执行100次
for _ in range(100):
    print("hello python")

案例 5：for 循环实现 1~100 累加和

total = 0
# range(1, 101) 生成 1 ~ 100
for num in range(1, 101):
    total += num
print(total)

10.2 四、补充要点

1. 可迭代对象：字符串、列表、元组、集合、range() 等都可以被 for 遍历。
2. range() 配合 for 是最常用组合，用来控制固定循环次数。
3. 循环内部可嵌套 if、else、甚至其他 for/while 循环。

10.3 continue 和 break

continue 和 break 用于中途控制循环流程，for、while 循环都可以使用。

10.3 一、关键字说明

1. continue：跳过当前这一轮循环剩余代码，直接进入下一轮循环，不会终止整个循环。
2. break：直接跳出并终止整个循环，后续所有循环不再执行。

案例 1：for 循环 + continue 打印 10 以内奇数

需求：输出 1~10 所有奇数，遇到偶数使用 continue 跳过。

# 1~10
for i in range(1, 11):
    # 如果是偶数，跳过本轮
    if i % 2 == 0:
        continue
    print(i)

执行逻辑

• 偶数触发 continue，print 不执行，直接进入下一次循环；
• 奇数不触发，正常打印。

案例 2：死循环 + break 打印 1~10 整数

利用 while True 构造死循环，配合 break 实现循环终止。

i = 1
while True:  # 死循环
    print(i)
    i += 1
    # 数字大于10，跳出整个循环
    if i > 10:
        break

执行逻辑

• while True 无限循环；
• 当 i > 10 时执行 break，彻底结束循环。

案例 3：求和列表中大于 3 的数字

列表：numbers = [2, 5, 3, 7, 8, 4, 1, 9, 10]

思路：小于等于 3 的数字跳过，只累加大于 3 的数。

numbers = [2, 5, 3, 7, 8, 4, 1, 9, 10]
total = 0

for num in numbers:
    if num <= 3:
        continue  # 不满足条件，跳过本轮
    total += num

print(total)

10.4 for 循环的嵌套

在一个 for 循环内部再编写另一个 for 循环，就是 for 循环嵌套。外层循环每执行一次，内层循环会完整遍历一轮。

10.4 一、基础语法

for 变量1 in 可迭代对象1:
    # 外层循环代码
    for 变量2 in 可迭代对象2:
        # 内层循环代码

基础演示代码

for i in range(10):
    print(f"外层循环i:{i}")
    for j in range(10):
        print(f"内层循环j:{j}")

执行逻辑

1. 外层 i 从 0~9 逐个取值；
2. i 每取一个值，内层 j 就完整跑完 0~9 一轮；
3. 内层全部执行完毕后，外层 i 再取下一个值，往复执行。

10.4 二、经典案例

# 外层循环：控制行数（1 ~ 9 行）
for i in range(1, 10):
    # 内层循环：控制每行的列数，列数 ≤ 当前行数
    for j in range(1, i + 1):
        print(f"{j}×{i}={j*i}", end="\t")
    # 一行输出完成，换行
    print()

解析

1. 外层变量 i：代表乘法式子中第二个数，同时控制总行数。
2. 内层变量 j：代表乘法式子中第一个数，取值范围 1 ~ i。
3. end="\t"：让同一行的算式横向排列，制表符分隔，排版整齐。
4. 内层循环结束后执行空 print()，实现换行，开始下一行。

10.4 三、控制循环范围

示例演示

for i in range(10):
    print(f"外层循环i:{i}")
    for j in range(10):
        print(f"内层循环j:{j}")
        break  # 仅跳出【内层循环】
    print(f'哈哈哈哈{i}')

运行说明

1. 内层循环第一次执行就遇到 break，内层直接终止，不会继续遍历；
2. break 无法跳出外层循环，外层 i 依然会从 0~9 正常循环；
3. continue 同理：仅跳过当前内层本轮循环，对外层无影响。

10.4 四、总结

1. 执行规则：外层走一次，内层走完整一轮。
2. 常用场景：打印表格、图形、九九乘法表等行 + 列类需求。
3. 跳转语句：break / continue 仅作用于当前层级循环，嵌套结构中无法跨层终止 / 跳过。
4. 格式要求：严格依靠缩进区分内外层循环层级。

第十节 作业

1. 将一个全英文的字符串中的所有的元音字母替换为 * 。并输出新的字符串。

2. 如果 a + b + c = 1000，且 a^2 + b^2=c2（a，b，c 为自然数），如何求出所有 a、b、c

3. 求 1- 200 之间所有的质数。