当前位置：首页 > news >正文

【云运维】Python基础（一）

news 2025/11/10 8:39:50

Python基础（一）

第1章：Python介绍

Python 是一门诞生于 1991 年的高级编程语言，由荷兰程序员吉多・范罗苏姆设计，其核心设计理念是 “简洁、可读性强、通用性高”。

从特性来看，Python 采用清晰的语法结构，摒弃了多余的符号冗余（如强制分号、大括号），以缩进规范代码逻辑，让代码更接近自然语言，降低了学习和阅读门槛，即便非专业开发者也能快速上手。同时，它拥有庞大而活跃的生态系统，内置丰富的标准库，且第三方库覆盖各行各业 —— 从数据分析（Pandas、NumPy）、人工智能（TensorFlow、PyTorch）、Web 开发（Django、Flask），到自动化运维、爬虫开发、科学计算、教育科研等领域，均有成熟的工具支持，实现了 “一门语言，多场景适配”。

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

第2章：Python基础

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

与其他语言不同，Python 的代码格式是语法的一部分，格式不规范会直接导致程序报错。

2.1.1 注释：代码的 “说明书”

注释用于解释代码功能，不参与程序执行，分为单行注释和多行注释。

1）单行注释

以 # 开头，可单独占一行或跟在代码后
规范要求：# 后加空格；与代码共行时，代码和注释间至少留 2 个空格

# 单行注释：打印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() 函数查看类型。

在这里插入图片描述

类型分类	具体类型	说明	示例
数字类型	整型（int）	整数（正负均可）	`0`、`101`、`-239`
	浮点型（float）	小数或科学计数法	`3.1415`、`4.2E-10`
	复数类型（complex）	实部 + 虚部（j 表示虚数单位）	`3.12+1.23j`、`-1.23-93j`
	布尔类型（bool）	仅 `True`（真）/`False`（假），是 int 子类	`True`、`False`
组合类型	字符串（str）	有序字符集合，单 / 双 / 三引号包裹	`'Python123'`、`"abc&%"`、`'''hello'''`
	列表（list）	有序、任意数据类型，长度不固定,`[]` 包裹	`[1, 2, 'hello']`
	元组（tuple）	有序，任意数据类型，长度不固定，只能看不能改，数据高安全场景，`()` 包裹	`(1, 2, 'hello')`
	集合（set）	无序（因为无下标），去重(如果有多份相同的数据会被视为一份数据输出)->（元素必须唯一），`{}` 包裹	`{'apple', 'orange', 1}`
	字典（dict）	无序键值对集合，`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)，适合频繁做成员检查的场景。
# 存储无序唯一元素：当不需要关注元素的顺序，只需要确保唯一性时，集合是比列表更合适的选择。
# 集合的元素必须是不可变类型（如整数、03字符串、元组等），且自身是可变的（可添加、删除元素）。如果需要不可变的集合，可以使用 frozenset。

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

1）输入：input() 函数

功能：接收用户键盘输入，返回 字符串类型（即使输入数字）
语法：input([prompt])（prompt 是输入提示信息，可选）
示例：

number = input("请输入数字：")
print(type(number))  # 无论输入什么，返回都是 str 类型

运行结果：

请输入数字：10
<class 'str'>

2）输出：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 提供了 4 种核心数字类型，分别适用于不同的数值场景，支持进制转换、类型转换等灵活操作。

2.4.1 整型（int）：整数的表示与进制转换

定义：用于表示整数，支持 4 种进制表示：
- 二进制：以 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 等价于 0
布尔值判断规则：以下情况会被判定为 False，其余为 True：
- None、False
- 任何数字类型的 0（0、0.0、0j）
- 任何空序列（''、()、[]）
- 空字典（{}）
示例代码：

print(bool(0))    # False
print(bool(''))   # False
print(bool(1))    # True
print(bool([1,2]))# True

2.4.5 数字类型转换：强制类型转换函数

Python 提供 3 个核心转换函数，支持数字类型间的灵活转换：

函数	功能	示例	结果
`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 中的运算核心

运算符是用于实现数据运算的特殊符号，根据功能可分为 7 大类，支持单目 / 双目运算，遵循明确的优先级规则。

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`

混合运算类型转换规则：
1. 整型与浮点型混合运算时：整型 → 浮点型（如 10 / 2.0 = 5.0）
2. 其他类型与复数混合运算时：其他类型 → 复数（如 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`	`0`
`*=`	`num = num * x`	`num *= 3`	`3`
`/=`	`num = num / x`	`num /= 2`	`0.5`
`//=`	`num = num // x`	`num //= 2`	`0`
`%=`	`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=2，b=3）	结果
`<<`	操作数按位左移	`a << b`	16
`>>`	操作数按位右移	`a >> b`	0
`&`	左操作数与右操作数执行按位与运算	`a & b`	2
`	`	左操作数与右操作数执行按位或运算	`a
`^`	左操作数与右操作数执行按位异或运算	`a ^ b`	1
`~`	操作数按位取反	`~a`	-3

关键说明：
- 左移 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 条件表达式:代码块  # 条件为 True 时执行（注意缩进，通常4个空格）

执行逻辑

若 条件表达式 的布尔值为 True（条件成立），执行缩进的代码块；
若为 False（条件不成立），跳过代码块，继续执行后续代码。

实战案例：成绩合格判断

某中学英语模拟考，60 分及以上为 “合格”，判断小明（88 分）的成绩结果：

score = 88
if score >= 60:print("小明的成绩评估：合格")

运行结果:

小明的成绩评估：合格

3.1.2 双分支：if-else 语句

语法格式

if 条件表达式:代码块1  # 条件成立时执行
else:代码块2  # 条件不成立时执行

执行逻辑

二选一执行：条件成立→代码块 1，否则→代码块 2，覆盖所有可能性。

实战案例：成绩及格 / 不及格判断

修改成绩，对比两次执行结果：

# 案例1：成绩88分
score = 88
if score >= 60:print("考试及格")
else:print("考试不及格")
# 运行结果：考试及格# 案例2：成绩50分
score = 50
if score >= 60:print("考试及格")
else:print("考试不及格")
# 运行结果：考试不及格

3.1.3 多分支：if-elif-else 语句

语法格式

if 条件1:代码块1  # 条件1成立执行
elif 条件2:代码块2  # 条件1不成立、条件2成立执行
elif 条件3:代码块3  # 前两个条件都不成立、条件3成立执行
...
else:代码块n  # 所有条件都不成立时执行（可选）

执行逻辑

按顺序判断条件，只要有一个条件成立，执行对应代码块后直接退出整个结构；
所有条件都不成立时，执行 else 代码块（else 可省略，此时无匹配时不执行任何操作）。

实战案例：成绩等级评定

按分数划分等级：≥85→优秀，75-84→良好，60-74→合格，<60→不合格：

score = 84
if score >= 85:print("优秀")
elif 75 <= score < 85:print("良好")
elif 60 <= score < 75:print("合格")
else:print("不合格")

运行结果:

良好

3.1.4 嵌套分支：if 嵌套

语法格式

if 外层条件:外层代码块  # 外层条件成立时执行if 内层条件:内层代码块  # 外层条件成立 + 内层条件成立时执行else:内层else代码块  # 外层成立、内层不成立时执行
else:外层else代码块  # 外层条件不成立时执行

执行逻辑

先判断外层条件，只有外层条件成立，才会进一步判断内层条件；
内层条件可嵌套多层（建议不超过 3 层，避免代码可读性变差）。

生活场景类比

高铁进站：先检票（外层条件）→ 检票通过后，再安检（内层条件）→ 安检通过才能进站。

实战案例1：计算当月天数

根据年份和月份，计算当月天数：

大月（1、3、5、7、8、10、12）：31 天
小月（4、6、9、11）：30 天
2 月：闰年 29 天，平年 28 天（闰年判断：能被 400 整除，或能被 4 整除但不能被 100 整除）

year = 2024
month = 2if month in [1, 3, 5, 7, 8, 10, 12]:print(f"{year}年{month}月有31天")
elif month in [4, 6, 9, 11]:print(f"{year}年{month}月有30天")
elif month == 2:# 内层条件：判断是否为闰年if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):print(f"{year}年{month}月有29天")else:print(f"{year}年{month}月有28天")
else:print("输入的月份无效（需为1-12）")

运行结果:

2024年2月有29天

实战案例2：带输入校验的成绩评定

实际开发中，需处理用户输入错误（如输入非数字、分数超出 0-100 范围），结合 isdigit() 函数（判断字符串是否为纯数字）实现输入校验：

需求：

输入成绩，判断等级（优秀 / 良好 /中等 / 合格 / 不合格）；
若输入非数字或分数超出 0-100，提示 “输入有误” 并重新输入。

代码实现:

# 根据成绩判断优良中差，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() 是 Python 内置函数，用于生成一个整数序列（可迭代对象），常与 for 循环搭配实现「固定次数的循环」。

range () 函数的三种用法

用法	说明	示例	生成的序列
range(n)	生成 0 ~ n-1 的整数序列	range(5)	0, 1, 2, 3, 4
range(start, end)	生成 start ~ end-1 的整数序列	range(2, 6)	2, 3, 4, 5
range(start, end, step)	生成 start ~ end-1 的序列，步长为 step	range(1, 10, 2)	1, 3, 5, 7, 9

示例：循环 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 = 1while col <= row:print("*", end="")  # end="" 表示不换行，默认 end="\n"（换行）col += 1print()  # 每行结束后换行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 () 等
循环嵌套	复杂重复逻辑（如多维数据、图形）	-	上述两种循环的组合