Python基础（一）

第1章：Python介绍

Python 是一种始于 1991 年的高级编程语言，由荷兰程序员吉多·范罗苏姆开发，其核心设计理念为“简洁、可读性强和高度通用”。

从特点上看，Python 使用清晰的语法结构，去除了多余的符号冗余（例如强制分号、大括号），通过缩进规范代码逻辑，使代码更接近自然语言，降低了学习与阅读的难度，即便是非专业开发者也能迅速掌握。同时，它具备庞大且活跃的生态系统，内置丰富的标准库，并且第三方库覆盖了各行各业——从数据分析（Pandas、NumPy）、人工智能（TensorFlow、PyTorch）、Web 开发（Django、Flask），到自动化运维、爬虫开发、科学计算和教育科研等领域，都有成熟的工具支持，实现了“一种语言，多种应用场景”。

从应用价值来看，Python 兼具易用性和强大的功能：既适合编程初学者巩固基础，也能满足企业级项目的开发需求。目前已被谷歌、亚马逊、字节跳动等科技公司广泛应用于核心业务中，同时也是高校计算机教育和科研机构数据处理的主流选择，在全球编程语言流行度排行榜上长期名列前茅，是兼具实用性和发展潜力的主要编程语言之一。

第2章：Python基础

2.1 代码格式：Python 的 “语法规范”

与其他语言不同，Python 的代码格式本身就是其语法的一部分，不正确的格式会导致程序出错。

2.1.1 注释：代码的“说明文本”

注释用于解释代码的功能，不会参与程序的实际运行，分为单行注释和多行注释。

1. 单行注释

以

#

开始，可以单独占一行或跟在代码后面。
• 规范要求：在

  #

  之后加空格；如果与代码同处一行，则代码和注释间至少留两个空格。

# 单行注释：打印Hello,Python（单独占一行）
print("Hello,Python")  # 单行注释：与代码共行（至少2个空格分隔）

2. 多行注释（文档说明）

使用三对双引号

"""

或三对单引号

'''

包裹。

主要用于解释函数、类或代码块的总体功能，因此也称为文档说明。

'''
多行注释：BMI指数计算程序
功能：接收用户身高体重，计算BMI并判断体重范围
height = input("请输入您的身高（单位为米）：")
print("您的身高：",height)
weight = input("请输入您的体重（单位为公斤）：")
print("您的体重：",weight)
bmi = float(weight)/(float(height)*float(height))
print("您的BMI指数：",bmi)
if bmi < 18.5:
    print("您的体重过轻！")
if bmi >= 18.5 and bmi <24.9:
    print("正常范围，继续保持！")
if bmi >= 24.9 and bmi <29.9:
    print("您体重过重！")
if bmi >= 29.9:
    print("该减肥了！")
'''

扩展：选中你想要注释的代码段，然后按Ctrl+/ 即可全部被注释掉。

2.1.2 缩进：代码的“层级关系”

作用：区分不同的代码块（如循环、条件判断中的内部代码）。

• 规范要求：Python3 推荐使用 4 个空格作为一级缩进（不建议使用 Tab 键）；不允许混合使用 Tab 和空格；同一代码块必须保持相同的缩进量，否则会报错。

错误示例及提示：

if True:
    print ("True")
else:
    print ("False")
print (”hello”)  # 缩进量不匹配，导致错误
# 报错信息：`IndentationError: unindent does not match any outer indentation level`（缩进不匹配）

正确示例：

if True:
    print("True")
else:
    print("False")
print("False")

2.1.3 语句换行：长代码的“适当拆分”

规范：建议每行代码不超过 79 个字符。

• 技巧：在圆括号

  ()

  、中括号

  []

  或大括号

  {}

  内的语句可以直接换行（隐式连接），无需额外添加括号。

# 字符串换行（圆括号内隐式连接）
string = ("Python是一种面向对象、解释型计算机程序设计语言，"
          "由Guido van Rossum于1989年底发明。"
          "第一个公开发行版发行于1991年，"
          "Python源代码同样遵循GPL(GNU General Public License)协议。")
# 列表换行（中括号内隐式连接）
number = ["one", "two",
          "three", "four"]
print(number)

2.2 标识符和关键字：Python 的 “合法命名” 与 “保留字”

2.2.1 标识符：自定义的 “名字”

用于命名变量、函数、类等的符号，需遵循以下规则：

• 组成：字母（a-z/A-Z）、下划线（_）、数字（0-9），且不能以数字开头
• 大小写敏感：

  tom

  和

  Tom

  是不同的标识符
• 不能使用 Python 关键字

命名规范（建议）：

• 见名知意：如姓名用

  name

  、年龄用

  age

• 常量名：全大写，多单词用下划线连接（如

  ORDER_LIST_LIMIT

  ）
• 模块 / 函数名：全小写，多单词用下划线连接（如

  low_with_under

  ）
• 类名：每个单词首字母大写（如

  Cat

  、

  Person

  ）

2.2.2 关键字：Python 的 “保留字”

关键字是 Python 已经使用的、不允许开发人员重复定义的标识符。Python3 中一共有 35 个关键字，每个关键字都有不同的功能。

• 1）Python3 关键字列表（共 35 个）

  import keyword
  print(keyword.kwlist)

  输出结果：

  ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break',
  'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for',
  'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
  'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

• 2）查看关键字用法

  import keyword
  print(help("for"))  # 查看 for 关键字的详细功能

2.3 变量和数据类型：Python 的 “数据容器”

2.3.1 变量：可变化的 “数据标识”

定义：用标识符关联内存中的数据，通过变量名快速访问数据

语法：

变量名 = 值

=

示例：

data = 100  # 变量 data 关联内存中的数据 100

2.3.2 数据类型

Python 数据类型分为基础类型（数字）和组合类型，可通过

type()

101

-239

3.1415

4.2E-10

3.12+1.23j

-1.23-93j

True

False

True

False

'Python123'

"abc&%"

'''hello'''

[]

[1, 2, 'hello']

()

(1, 2, 'hello')

{}

{'apple', 'orange', 1}

key:value

{}

{"name": "zhangsan", "age": 18}

查看数据类型示例:

info = {"name": "zhangsan", "age": 18}
print(type(info))  # 输出 <class 'dict'>（字典类型）

扩展：

# 在 Python 中，集合（set）是一种无序、可变的数据类型，主要功能体现在以下几个方面：

• 去重：集合中的元素具有唯一性，会自动去除重复值。例如：

  lst = [1, 2, 2, 3, 3, 3]
  s = set(lst)  # 结果为 {1, 2, 3}

• 集合运算：支持数学中的集合操作，如交集（&）、并集（|）、差集（-）、对称差集（^）等，方便处理元素间的关系。例如：

  a = {1, 2, 3}
  b = {3, 4, 5}
  print(a & b)  # 交集：{3}
  print(a | b)  # 并集：{1, 2, 3, 4, 5}
  print(a - b)  # 差集：{1, 2}

• 高效的成员判断：判断元素是否存在于集合中（in 操作）的时间复杂度为 O (1)，远快于列表的 O (n)，适用于频繁做成员检查的场景。
• 存储无序唯一元素：当不需要关注元素的顺序，只需要确保唯一性时，集合是比列表更合适的选择。
• 集合的元素必须是不可变类型（如整数、字符串、元组等），且自身是可变的（可添加、删除元素）。如果需要不可变的集合，可以使用 frozenset。

2.3.3 变量的输入与输出：人机交互基础

1）输入：

input()

input([prompt])

prompt

示例：

number = input("请输入数字：")

        print(type(number))  # 不论输入任何值，返回的都是 str 类型
        运行结果：
        
请输入数字：10
<class 'str'>
        输出：
        
print()
        函数
        功能：将数据输出到控制台，支持所有类型的数据
        语法：
        
print(*objects, sep=' ', end='\n', file=sys.stdout)
        
objects
        ：需要输出的对象（可以是多个，用逗号分隔）
        
sep
        ：对象之间的分隔符，默认为空格
        
end
        ：输出的结尾字符，默认为换行符
        
\n
        
file
        ：输出的目标（默认是控制台）
        示例：
        zh_name = "张三"
        en_name = "Tom"
        info = "年龄18岁，毕业于南京大学，兴趣爱好广泛"
        print(zh_name, en_name, info, sep="\n")  # 使用换行符分隔多个对象
        运行结果：
        
张三
tom
年龄18岁，毕业于南京大学，兴趣爱好广泛
        2.4：数字类型：Python 中的数值表示
        Python 提供了四种核心数字类型，分别适用于不同的数值场景，支持进制转换、类型转换等灵活操作。
        2.4.1 整型（int）：整数的表示与进制转换
        定义
        ：用于表示整数，支持以下四种进制表示：
        二进制：以
        
0b
        或
        
0B
        开头（例如
        
0b101
        ）
        八进制：以
        
0o
        或
        
0O
        开头（例如
        
0o12
        ）
        十进制：默认表示方式（例如
        
10
        ）
        十六进制：以
        
0x
        或
        
0X
        开头（例如
        
0xA
        ）
        进制转换函数
        ：
        函数
        功能
        示例
        结果
        
bin(x)
        十进制转二进制
        
bin(10)
        
'0b1010'
        
oct(x)
        十进制转八进制
        
oct(10)
        
'0o12'
        
int(x)
        其他进制转十进制（base 指定原进制）
        
int(0b1010)
        或
        
int('1010', 2)
        
10
        
hex(x)
        十进制转十六进制
        
hex(10)
        
'0xa'
        示例代码
        ：
        number = 10
        print("10的二进制：", bin(number))    # 10的二进制： 0b1010
        print("10的八进制：", oct(number))    # 10的八进制： 0o12
        print("0b1010的十进制：", int(0b1010)) # 0b1010的十进制： 10
        print("10的十六进制：", hex(number))  # 10的十六进制： 0xa
        2.4.2 浮点型（float）：实数与科学计数法
        定义：用于表示带有小数部分的实数（如3.14、0.9），也支持科学记数法（e或E表示 10 的幂）：
        示例：
        
-3.14e2
        （等同于
        
-314
        ）、
        
3.14e-3
        （等同于
        
0.00314
        ）
        存储特性：
        占用 8 字节（64 位），遵循 IEEE 标准
        取值范围：
        
-1.8e308 ~ 1.8e308
        ，超出此范围将被视为
        
inf
        （正无穷大）或
        
-inf
        （负无穷小）
        2.4.3 复数型（complex）：实部与虚部的组合
        定义：由实部和虚部构成，格式为real + imagj（其中 j 是虚数单位）：
        示例：
        
1 + 2j
        （实部 1，虚部 2）、
        
2j
        （实部 0，虚部 2）
        属性访问：通过
        
real
        获取实部，
        
imag
        获取虚部（返回浮点型）：
        complex_num = 1 + 2j
        print(complex_num.real)  # 运行结果 1.0
        print(complex_num.imag)  # 运行结果 2.0
        2.4.4 布尔型（bool）：特殊的整型
        定义
        ：表示逻辑值，仅有两个取值：
        
True
        （真）和
        
False
        （假）
        本质
        ：布尔型是整型的一个子类，
        
True
        等同于
        
1
        ，
        
False
        等同于
        布尔值判断规则
        ：以下情况会被判定为
        
False
        ，其他情况下则为
        
True
        ：
        
None
        、
        
False
        所有数字类型的 0（
        、
        
0.0
        、
        
0j
        ）
        空序列（
        
''
        、
        
()
        、
        
[]
        ）
        空字典（
        
{}
        ）
        示例代码
        ：
        print(bool(0))    # False
        print(bool(''))   # False
        print(bool(1))    # True
        print(bool([1,2]))# True
        2.4.5 数字类型转换：强制类型转换函数
        Python 提供了三个核心转换函数，支持数字类型之间的灵活转换：
        函数
        功能
        示例
        结果
        
int(x)
        转换为整型（舍去小数部分）
        
int(2.2)
        
2
        
float(x)
        转换为浮点型
        
float(2)
        
2.0
        
complex(x)
        转换为复数（虚部为 0）
        
complex(2)
        
(2+0j)
        示例代码
        ：
        num_one = 2
        num_two = 2.2
    

print(int(num_two))      # 执行结果 2
print(float(num_one))    # 执行结果 2.0
print(complex(num_one))  # 执行结果 (2+0j)
2.5：运算符：Python 中的运算核心
运算符是用于执行数据计算的特殊符号，按功能可分为七大类，支持单目 / 双目操作，遵循明确的优先级规则。
2.5.1 算术运算符：数值计算的基础
用于执行加减乘除等数学计算，支持相同 / 不同类型数值的混合计算。
运算符
功能
示例（a=2，b=8）
结果
+
加法
a + b
10
-
减法
b - a
6
*
乘法
a * b
16
/
除法（返回浮点型）
b / a
4.0
//
整除（向下取整）
9 // 2
4
%
取余（模运算）
9 % 2
1
**
幂运算（a 的 b 次方）
a ** 3
8
混合运算类型转换规则：
整型与浮点型混合计算时：整型 → 浮点型（如
10 / 2.0 = 5.0
）
其他类型与复数混合计算时：其他类型 → 复数（如
10 - (3+5j) = (7-5j)
）
2.5.2 赋值运算符：变量赋值与复合操作
用于将值或表达式结果赋给变量，支持简单赋值、多变量赋值和复合赋值。
（1）基础赋值
简单赋值：
num = 3
（将 3 赋值给变量
num
）
多变量赋值：
x = y = z = 1  # 多个变量赋同一值（x、y、z 均为 1）
a, b = 1, 2    # 解包赋值（a=1，b=2）
（2）复合赋值运算符（操作 + 赋值）
运算符
等价形式
示例（num=1）
结果
+=
num = num + x
num += 2
3
-=
num = num - x
num -= 1
*=
num = num * x
num *= 3
3
/=
num = num / x
num /= 2
0.5
//=
num = num // x
num //= 2
%=
num = num % x
num %= 2
1
**=
num = num **x
num **= 2
1
（3）海象运算符（Python 3.8+）
符号：
:=
，用于
表达式内部赋值
，简化代码逻辑：
num_one = 1
# 表达式中为 num_two 赋值，同时参与操作
result = num_one + (num_two := 2)
print(result)  # 3（等价于 1 + 2）
print(num_two) # 2（变量已被赋值）
2.5.3 比较运算符：数值关系判断
用于比较两个数值的关系，结果仅为
True
（真）或
False
（假）。
运算符
功能
示例（x=2，y=3）
结果
==
等于（判断值是否相等）
x == y
False
!=
不等于
x != y
True
>
大于
x > y
False
<
小于
x < y
True
>=
大于等于
x >= 2
True
<=
小于等于
y <= 2
False
2.5.4 逻辑运算符：布尔值逻辑操作
用于组合多个布尔表达式，返回
True
或
False
，关键字为
and
（与）、
or
（或）、
not
（非）。
运算符
功能
示例（x=10，y=20）
结果
and
全为真则真，否则假
x > 5 and y < 25
True
or
任一为真则真，全假则假
x < 5 or y > 15
True
not
取反（真变假，假变真）
not (x == y)
True
短路特性：
and
：左侧为
False
时，直接返回
False
，不计算右侧
or
：左侧为
True
时，直接返回
True
，不计算右侧
2.5.5 成员运算符：序列元素判断
用于判断元素是否存在于序列（字符串、列表、元组等）中，关键字为
in
和
not in
。
运算符
功能
示例（x=“Python”，y=‘t’）
结果
in
元素在序列中返回
True
y in x
True
not in
    

元素不在序列中返回

True

y not in x

False

示例代码：

x = "Python"
y = 't'
print(y in x)       # True（'t' 是 "Python" 的字符）
print('z' not in x) # True（'z' 不是 "Python" 的字符）

2.5.6 位运算符：二进制位级运算

用于对整数的二进制位进行直接操作，仅支持整型操作数。

<<

a << b

>>

a >> b

&

a & b

^

a ^ b

~

~a

关键说明：

• 左移

  n

  位 ≈ 乘以

  2^n

  （如

  8 << 2 = 32

  ，即

  8*2?

  ）
• 右移

  n

  位 ≈ 除以

  2^n

  （如

  8 >> 2 = 2

  ，即

  8/2?

  ）

按位取反：

~x = -(x+1)

~9 = -10

详解：

按位左移(<<)是指将二进制形式操作数的所有位全部左移n位，高位丢弃，低位补0。以十进制9为例，9转为二进制后是00001001，将转换后的二进制数左移4位。

按位右移(>>)是指将二进制形式操作数的所有位全部右移n位，低位丢弃，高位补0。以十进制8为例，8转换为二进制后是00001000，将转换后的二进制数右移2位。

按位与(&)是指将参与运算的两个操作数对应的二进制位进行“与”操作。当对应的两个二进制位均为1时，结果位就为1，否则为0。以十进制9和3为例，9和3转换为二进制后分别是00001001和00000011。

按位或(|)是指将参与运算的两个操作数对应的二进制位进行“或”操作。若对应的两个二进制位有一个为1时，结果位就为1。若参与运算的数值为负数，参与运算的两个数均以补码出现。以十进制8和3为例，8 和3转换为二进制后分别是00001000和00000011。

按位异或(^)是指将参与运算的两个操作数对应的二进制位进行“异或”操作。当对应的两个二进制位中有一个为1，另一个为0时，结果位为1，否则结果位为0。以十进制8和4为例，8和4转换为二进制后分别是00001000和00000100。

按位取反(~)是指将二进制的每一位进行取反，0取反为1，1取反为0。按位取反操作首先会获取这个数的补码，然后对补码进行取反，最后将取反结果转换为原码，例如，对9按位取反的计算过程如下：

2.5.7 运算符优先级：运算顺序规则

当表达式包含多个运算符时，按优先级从高到低执行（优先级相同则从左到右），小括号

()

优先级从高到低 （核心常用类）：

• 括号：

  ()

• 幂运算：

  **

• 位运算：

  ~

• 算术运算：

  *

  、

  /

  、

  //

  、

  %

  →

  +

  、

  -

• 位运算：

  <<

  、

  >>

  →

  &

  →

  ^

  →

  |

• 比较运算：

  ==

  、

  !=

  、

  >

  、

  <

  、

  >=

  、

  <=

• 逻辑运算：

  not

  →

  and

  →

  or

• 赋值运算：

  =

  、

  +=

  、

  -=

  等（优先级最低）

示例代码：

a = 20
b = 2
c = 15
result_01 = (a - b) + c  # 先算括号内：18 + 15 = 33
result_02 = a / b % c    # 先除后取余：10 % 15 = 10.0
result_03 = c ** b * a   # 先幂后乘：225 * 20 = 4500
print(result_01, result_02, result_03)  # 33 10.0 4500

第3章：Python流程控制

程序默认按自上而下的顺序执行，而流程控制语句能改变执行顺序，实现分支、循环等复杂逻辑。Python 中的流程控制主要分为条件语句、循环语句和跳转语句。

3.1：条件语句

条件语句是程序的 “决策器”，它根据判断条件的真假，让程序有选择地执行不同代码块。就像生活中：

12306 在购票前需要进行身份验证（通过后→进入购票页面，未通过→重新验证）
高铁进站之前需先检票（成功→安检），然后经过安检（成功→进站）
Python 提供了 4 种核心条件语句结构，涵盖从简单到复杂的决策场景。
3.1.1 单分支：if 语句
语法格式
if 条件表达式:
代码块 # 条件为真时执行（注意缩进，通常4个空格）
执行逻辑
若

条件表达式

True

False

小明的成绩评估：合格

良好

2024年2月有29天

isdigit()

根据成绩判断优良中差，90以上是优秀，80-89是良好，70-79是中等，60-69是合格，59以下不合格

score = input('请输入成绩：')
# 判断输入是否为数值类型的字符串
if score.isdigit() and 0<=float(score)<=100:
    # 类型转换
    score = float(score)
    # 内嵌条件语句（多分支语句）
    if score >= 90:
        print('优秀')
    elif score >= 80 and score < 90:
        print('良好')
    elif score >= 70 and score < 80:
        print('中等')
    elif score >= 60 and score < 70:
        print('合格')
    else:
        print('不合格')
else:
    print('输入不合法')

关键说明:

isdigit()

：仅判断字符串是否为非负整数（如 "88"→True，"88.5"→False，"abc"→False）；

3.2 循环语句

Python 提供了两种核心循环语句：

while

for

3.2.1 while 语句：条件满足时循环

while

语法格式

while 条件表达式:
    # 循环体（需重复执行的代码块）
    代码语句1
    代码语句2
    ...

注意：Python 使用缩进（通常是4个空格）来区分代码块，循环体必须缩进，否则会引发错误。

实战案例：1~10 求和

需求：计算 1+2+3+…+10 的结果。

# 初始化变量：i 用于遍历 1~10，result 用于存储总和
i = 1
result = 0
# 循环条件：i 小于等于 10 时继续循环
while i <= 10:
    result += i  # 等价于 result = result + i，累计当前 i 的值
    i += 1       # i 自增 1，防止无限循环
# 循环结束后打印结果
print("1~10 的和为：", result)

运行结果：

1~10 的和为： 55

特殊场景：无限循环

如果

while

True

break

示例：简单的无限循环

# 条件始终为 True，循环将持续执行
while True:
    print("这是无限循环，按 Ctrl+C 可终止")

运行结果（将不断输出，需手动停止）：

这是无限循环，按 Ctrl+C 可终止
这是无限循环，按 Ctrl+C 可终止
...

3.2.2 for 语句：遍历可迭代对象

for

语法格式

for 临时变量 in 可迭代对象:
    # 循环体：处理当前临时变量对应的元素
    代码语句1
    代码语句2
    ...

可迭代对象：指可以「逐一访问」的对象，包括字符串、列表、元组、字典以及 range() 函数生成的序列等。

临时变量：每次循环会自动接收可迭代对象的下一个元素，变量名可根据需要自定义（如

i

word

item

实战案例 1：遍历字符串

需求：逐个打印字符串 “Python” 中的每个字符。

# 遍历字符串 "Python"，将每个字符依次赋值给临时变量 word
for word in "Python":
    print(word)

运行结果：

P
y
t
h
o
n

实战案例 2：搭配 range() 函数

range()

for

range() 函数的三种用法

示例：循环 5 次打印数字

# range(5) 生成 0~4 的序列，循环执行 5 次
for i in range(5):

        print("当前数字：", i)
        运行结果：
        
当前数字： 0
当前数字： 1
当前数字： 2
当前数字： 3
当前数字： 4
        3.2.3 循环嵌套：实现复杂逻辑
        循环之间可以互相包含（
        
while
        包含
        
while
        、
        
for
        包含
        
for
        、
        
while
        包含
        
for
        等），用于实现更复杂的重复逻辑（比如打印图形、多维数据处理等）。
        核心原则：
        外层循环执行一次，内层循环完整运行一轮。
        while 循环嵌套
        语法格式：
        while 外部条件表达式:
        # 外部循环体
        外部代码语句
        while 内部条件表达式:
        # 内部循环体
        内部代码语句
        实战案例：打印由 “*” 组成的直角三角形
        需求：打印 5 行直角三角形，第 1 行 1 个 “
        ”，第 2 行 2 个”
        ”，…，第 5 行 5 个"*"。
        # 外部循环：控制行数（1~5 行）
        row = 1
        while row <= 5:
        # 内部循环：控制每行的 "*" 数量（每行的 "*" 数 = 当前行数）
        col = 1
        while col <= row:
        print("*", end="")  # end="" 表示不换行，默认 end="\n"（换行）
        col += 1
        print()  # 每行结束后换行
        row += 1
        运行结果：
        
*
**
***
****
*****
        for 循环嵌套
        语法格式：
        for 外部临时变量 in 外部可迭代对象:
        # 外部循环体
        外部代码语句
        for 内部临时变量 in 内部可迭代对象:
        # 内部循环体
        内部代码语句
        实战案例：打印同样的直角三角形
        用
        
for
        循环嵌套实现上述需求，代码更简洁：
        # 外部循环：控制行数（range(1,6) 生成 1~5 的序列，对应 5 行）
        for row in range(1, 6):
        # 内部循环：控制每行的 "*" 数量（每行的 "*" 数 = 当前行数）
        for col in range(row):
        print("*", end="")
        print()  # 换行
        运行结果（与 while 嵌套一致）：
        
*
**
***
****
*****
        3.3 ：循环控制语句（跳转语句）
        在实际开发中，我们可能需要提前退出循环、跳过某次循环，此时需要用到
        
break
        和
        
continue
        语句：
        语句
        功能
        break
        立即终止当前循环，跳出循环体
        continue
        跳过当前循环的剩余代码，直接进入下一次循环
        3.3.1 break 语句
        需求：遍历 1~10，遇到偶数时终止循环。
        for i in range(1, 11):
        if i % 2 == 0:
        break  # 遇到偶数（i=2）时终止循环
        print("当前数字：", i)
        运行结果：
        
当前数字： 1
        3.3.2 continue 跳过循环
        需求：遍历 1~10，只打印奇数（跳过偶数）。
        for i in range(1, 11):
        if i % 2 == 0:
        continue  # 遇到偶数时跳过当前循环，不执行后续打印
        print("当前奇数：", i)
        运行结果：
        
当前奇数： 1
当前奇数： 3
当前奇数： 5
当前奇数： 7
当前奇数： 9
        3.4：循环小结
        循环类型
        核心场景
        语法简洁度
        适用对象
        while
        条件驱动的循环（未知循环次数）
        中等
        任意条件表达式
        for
        遍历可迭代对象（已知循环次数）
        较高
        字符串、列表、range () 等
        循环嵌套
        复杂重复逻辑（如多维数据、图形）
        -
        上述两种循环的组合
        小建议：
        已知循环次数或需要遍历对象时，优先使用
        
for
        循环（代码更简洁、可读性更高）；
        未知循环次数（如等待用户输入）时，使用
        
while
        循环；
        循环嵌套的层数不宜过多（建议不超过 3 层），否则会降低代码可读性；
        避免无意识的无限循环，必要时用
        
break
        手动退出。