Python通关秘籍之基础教程(一）
引言
在编程的世界里，Python就像一位温和而强大的导师，它以简洁优雅的语法和强大的功能吸引着无数初学者和专业人士。无论你是想开发网站、分析数据、构建人工智能，还是仅仅想学习编程思维，Python都是你的理想选择。
Python的魅力在于它的易读性和广泛的应用场景。它的代码就像英语句子一样自然，即使是完全没有编程经验的人也能快速上手。同时，Python拥有庞大的生态系统，从Web开发（Django、Flask）到数据分析（Pandas、NumPy），再到人工智能（TensorFlow、PyTorch），几乎无所不能。
本教程将带你从零开始，逐步掌握Python的基础知识。我们将像搭积木一样，一块一块地构建你的编程技能，确保你不仅“会写代码”，更能“理解代码背后的逻辑”。
一、Python环境搭建
在开始编程之前，我们需要准备好“工具箱”。就像画家需要画笔和画布，程序员也需要一个合适的开发环境。
1.1 安装Python
首先，访问Python官网下载最新版本的Python。安装时记得勾选“Add Python to PATH”选项，这样你就可以在命令行直接运行Python了。 不知道怎么安装的请参考教程：window11环境下Python安装详细介绍。
1.2 选择开发工具
Python代码可以写在任何文本编辑器中，但专业的开发工具能大幅提升效率。推荐以下选择：
-
初学者友好：IDLE（Python自带）、Thonny
-
功能全面：VS Code（轻量级）、PyCharm（专业级）
-
在线环境：Replit（无需安装，直接浏览器编写）
小贴士：VS Code安装后，记得添加Python扩展（搜索“Python”并安装），它会提供代码补全、错误检查等功能。如需要相关开发工具安装教程，请在评论区留言，我会根据需要留言情况发布相关教程。
二、Python语法基础
2.1 第一个Python程序：Hello,Word!
每个程序员的第一课都是打印“Hello, World！”。在Python中，这只需要一行代码：
print("Hello, World!")
运行方式：
- 在命令行输入
python进入交互模式，直接输入代码并按回车。 - 或将代码保存为
.py文件（如hello.py），然后用python hello.py运行。
2.2 语法规则
想象你正在建造一座代码城堡，Python 的语法格式就是你搭建城堡的规则和蓝图。
2.2.1 语法格式
-
缩进：缩进在 Python 里就像是城堡里不同楼层的划分线。在其他一些编程语言中，用大括号来圈定代码块，就像用围栏圈出一块地。但 Python 别具一格，它使用缩进来告诉程序哪些代码属于同一个 “代码块家族”。
if 5 > 3: print("5 确实比 3 大呢！") x = 10 print(f"我在满足条件的代码块里，定义了 x 为 {x}") print("我不在那个条件代码块里啦")在这里，
print("5 确实比 3 大呢！")、x = 10和print(f"我在满足条件的代码块里，定义了 x 为 {x}")这几行代码因为缩进，就像是住在同一楼层的居民，它们都属于if条件满足时要执行的代码块。一旦缩进结束，print("我不在那个条件代码块里啦")就像是住在另一楼层，不属于这个if代码块。通常大家约定俗成用 4 个空格作为一个缩进层级，这就好比每个楼层的高度都有统一标准，这样城堡才会整齐美观，别人来看你的代码城堡也能一目了然。
-
换行
-
单行语句：Python 里的语句就像是我们平常说的句子，大多数情况下，一个完整的想法（语句）独占一行。比如你说 “我要定义一个数字变量”，在代码里就是
num = 5，这就是一个简单的单行语句，它完整地表达了定义变量num并赋值为5的意思。 -
多行语句：但有时候，一个句子太长了，一口气说不完怎么办呢？这时候就可以用反斜杠
\来 “喘口气”，把句子拆分成多行。就像这样：long_string = "这是一个超级超级长的字符串哦， \ 我们可以用反斜杠巧妙地把它分成多行来写， \ 这样看起来就不会那么拥挤啦，代码也更清晰。"还有一种情况，当你在使用圆括号
()、方括号[]或花括号{}时，就好像给这个句子加上了一个 “特殊容器”，在这个容器里面，句子跨多行写就不需要反斜杠了。比如：my_list = [ 1, 2, 3, 4, 5 ]这里面的数字就像一群小伙伴，在
[]这个 “容器” 里可以开心地各占一行，程序也能明白它们是一个整体。
-
-
注释
代码不仅是给计算机看的（因为代码本身已能被计算机执行），更是给未来的自己、团队成员或其他开发者看的。代码中的注释就像是“使用说明书”，能帮助你或其他开发者快速理解代码，从而提升代码的可读性、可维护性和可协作性。
-
单行注释：单行注释就像是你贴在代码墙上的一张小纸条，用来给路过的人（包括以后的自己）解释某一行代码在做什么。在 Python 里，用
#来表示单行注释。比如说：# 下面这行代码计算两个数的和 sum_result = 3 + 5 -
多行注释：如果你要对一大段代码或者一个函数、类进行详细解释，单行注释就不够用了，这时候就轮到多行注释出场。它就像一张大大的海报，可以写好多好多内容。在 Python 里，可以用三个单引号
'''或者三个双引号"""来包裹注释内容。例如：''' 这是一个多行注释示例哦。 这里可以详细描述函数的功能， 比如它接受哪些参数，返回什么结果， 以及函数实现的大致思路等等。 ''' def my_function(): pass这样，对于复杂的代码部分，通过多行注释就能解释得清清楚楚。
-
-
冒号
冒号在 Python 里就像是城堡里不同房间的入口标识。当你使用
if、for、while、def、class这些关键字的时候，就好像你在说 “这里要进入一个新的代码房间啦”，然后紧跟一个冒号，告诉程序 “下面缩进的代码就是这个房间里的内容”。比如：if condition: # if 代码房间的内容 pass for item in iterable: # for 代码房间的内容 pass def my_function(): # 函数代码房间的内容 pass class MyClass: # 类代码房间的内容 pass
2.2.2 命名规则
-
标识符命名：
-
组成字符：标识符（变量名、函数名、类名、模块名、包名）可以由字母（包括大写和小写）、数字和下划线
_组成。例如，my_variable、MyClass、_private_variable都是合法的标识符。 -
开头字符：不能以数字开头。例如，
123variable是不合法的，而variable123是合法的。 -
长度限制：理论上没有长度限制，但为了代码的可读性，应尽量保持名称简洁明了。
-
大小写敏感：Python 对标识符的大小写是敏感的，
my_variable和My_Variable是两个不同的标识符。
-
-
变量命名
- 蛇形命名法（snake_case）：这是 Python 中变量命名最常用的风格。多个单词之间用下划线连接，全部小写。例如：
user_name、total_amount。 - 驼峰命名法：虽然在 Python 中不常用，但也可接受。分为小驼峰命名法（
lowerCamelCase），第一个单词首字母小写，后面单词首字母大写，如myVariable；大驼峰命名法（UpperCamelCase），每个单词首字母都大写，常用于类名，如MyClass。 - 避免使用保留字：不能使用 Python 的保留字作为变量名，如
if、for、while、def等。这些保留字在 Python 中有特定的语法含义。
- 蛇形命名法（snake_case）：这是 Python 中变量命名最常用的风格。多个单词之间用下划线连接，全部小写。例如：
-
函数命名
- 命名风格：通常使用蛇形命名法，以动词开头描述函数的功能。例如：
calculate_sum、print_message。 - 体现功能：函数名应清晰地表达函数的作用，让阅读代码的人能快速了解函数的功能。
- 命名风格：通常使用蛇形命名法，以动词开头描述函数的功能。例如：
-
类命名
- 命名风格：使用大驼峰命名法，每个单词的首字母大写，类名通常为名词。例如：
UserInfo、DatabaseManager。 - 反映本质：类名应准确反映类所代表的事物或概念的本质，有助于理解代码的结构和功能。
- 命名风格：使用大驼峰命名法，每个单词的首字母大写，类名通常为名词。例如：
-
模块命名
- 命名风格：使用蛇形命名法，全部小写，尽量简短且能体现模块的功能。例如：
math_operations.py、file_utils.py。 - 避免冲突：模块名应避免与 Python 标准库中的模块名冲突，以免在导入模块时出现问题。
- 命名风格：使用蛇形命名法，全部小写，尽量简短且能体现模块的功能。例如：
-
包命名
- 命名风格：同样使用蛇形命名法，全部小写，通常为一个简短的描述性名称。例如：
my_package、data_processing。 - 层次结构清晰：包名应能反映其在项目中的层次结构和功能，便于组织和管理项目代码。
- 命名风格：同样使用蛇形命名法，全部小写，通常为一个简短的描述性名称。例如：
2.2.3 Python中的保留字
在Python中，保留字（Reserved Words，又称关键字） 是语言预定义的、具有特殊语法含义的词汇，用于实现核心逻辑（如条件判断、循环、函数定义等）。它们不能作为变量名、函数名或其他标识符使用，否则会引发语法错误。
Python的保留字数量随版本迭代略有调整（如Python 3.10+新增了match、case等）。在这里先作为了解，后续会有实际应用讲解。以下是Python 3.11中全部35个保留字，按功能分类说明：
-
基础逻辑控制
用于构建程序的基础逻辑结构：
-
True:布尔类型的“真”值（逻辑肯定）。 -
False：布尔类型的“假”值（逻辑否定）。 -
None：表示“空值”或“不存在的对象”（NoneType类型的唯一实例）。 -
and：逻辑与（用于布尔运算或条件组合）。 -
or：逻辑或（用于布尔运算或条件组合）。 -
not：逻辑非（用于布尔取反）。 -
in：成员运算符用于判断一个值是否在序列（如列表、字符串、元组等）中。 -
is：身份运算符用于比较两个对象的内存地址，判断它们是否为同一个对象。 -
if：条件判断（引导if-elif-else分支）。 -
elif：if的分支延续（简写为else if）。 -
else：if或elif的默认分支；循环正常结束（未被break中断）时执行（较少使用）。 -
pass：空操作占位符（用于语法完整性，无实际执行）。
-
-
循环迭代
用于控制循环执行或遍历可迭代对象：
for：遍历可迭代对象（如列表、字符串）。while：基于条件的循环（当条件为真时持续执行）。break：终止当前循环（跳出整个循环体）。continue：跳过当前迭代（继续下一次循环）。
-
函数与类定义
用于定义函数、类或其他可调用对象：
def：定义函数（如def func(): ...）。class：定义类（如class MyClass: ...）。return：从函数中返回值（结束函数执行）。lambda：创建匿名函数（单行表达式）。yield：定义生成器函数（返回可迭代对象，支持惰性计算）。
-
作用域与变量
用于控制变量的作用域（可见范围）：
global：声明变量为全局作用域（在函数内修改全局变量时使用）。nonlocal：声明变量为外层函数作用域（在嵌套函数内修改外层变量时使用）。
-
模块与导入
用于导入外部模块或管理命名空间：
import：导入模块（如import math）。from：从模块中导入特定对象（如from os import path）。as：为导入的对象起别名（简化名称或避免冲突）。
-
异常处理
用于捕获和处理运行时错误：
try：包裹可能引发异常的代码块。except：捕获特定类型的异常（如except ValueError:）。finally：无论是否发生异常都会执行的代码块（常用于资源释放）。raise：主动抛出异常（强制触发错误）。
-
上下文管理
用于管理资源（如文件、网络连接）的获取与释放：
with：通过上下文管理器自动处理资源（无需手动关闭）。
-
其他特殊用途
async：定义异步函数（协程）。await：在异步函数中等待另一个协程完成。match：模式匹配（Python 3.10+，类似switch-case）。case：配合match定义具体匹配模式（Python 3.10+）。
Python提供了keyword模块，可用于动态查看当前版本的保留字列表：
import keyword
print(keyword.kwlist)
# 输出所有保留字（Python 3.11示例）
# ['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']
print(keyword.iskeyword("if")) # 检查是否为保留字（输出True）
print(keyword.iskeyword("hello")) # 输出False
2.3 变量与数据类型
变量和数据类型是基础且核心的概念。就像搭建积木城堡，变量是放置积木的位置，数据类型则决定了积木的形状和用途。
2.3.1 变量
变量是一个用于存储数据的命名容器，就好比一个贴着标签的盒子，你可以把各种东西（数据）放进这个盒子里，之后通过标签（变量名）来找到并使用这些东西。
在 Python 中，不需要提前声明变量的类型，直接给变量赋值就可以创建变量。例如：
# 创建一个名为 num 的变量，并赋值为 10
num = 10
# 创建一个名为 name 的变量，并赋值为 'Alice'
name = 'Alice'
变量的命名规则请返回查看2.2.2 命名规则——变量命名。
2.3.2 数据类型
Python 中有多种数据类型，每种数据类型都有其独特的特点和用途。这里先对Python的各种数据类型进行简单了解，后续会逐一对其进行详细的操作讲解。
1. 数字类型
-
整数（
int）：代表整数，没有小数部分，可以是正数、负数或零。例如：# 定义整数变量 age = 25 count = -10 zero = 0 -
浮点数（
float）：表示带有小数部分的数字。例如：# 定义浮点数变量 pi = 3.14159 price = 9.99有些浮点数在计算机内部表示时可能会有微小的精度误差，这是由于计算机使用二进制表示小数的特性导致的。例如：
print(0.1 + 0.2) # 输出结果可能接近 0.3，但不完全等于 0.3，而是 0.30000000000000004具体解释请看文章：Python中关于浮点数运算的不确定尾数的解释。
-
复数（
complex）：用于表示复数，由实数部分和虚数部分组成，形式为a + bj，其中a是实数部分，b是虚数部分。例如：# 定义复数变量 z = 3 + 4j
2. 字符串类型
字符串是由字符组成的序列，可以用单引号 '、双引号 " 或三引号 ''' 或 """ 来表示。例如：
# 用单引号定义字符串
single_quote_str = 'Hello, World!'
# 用双引号定义字符串
double_quote_str = "Python is great"
# 用三引号定义多行字符串
multi_line_str = '''This is a
multi - line string.'''
字符串支持多种操作，如索引、切片、拼接等，这将在后续内容中详细讲解。
3. 布尔类型（bool）
在 Python 中，布尔类型（Boolean） 是一种表示逻辑值的数据类型，仅包含两个可能的取值：
-
True（真）：表示“成立”或“存在”。 -
False（假）：表示“不成立”或“不存在”。# 定义一个变量值为True is_true = True # 定义一个变量值为False is_false = False
这两个值是 Python 的关键字（首字母必须大写），直接用于逻辑判断。
4. 列表（List）
列表是一种有序的可变序列，用方括号 [] 表示，可以包含不同类型的数据。例如：
# 定义一个列表
my_list = [10, 'apple', 3.14, True]
列表支持索引、切片、添加、删除、修改等操作，这将在后续内容中详细讲解。
5. 元组（Tuple）
元组是一种有序的不可变序列，用圆括号 () 表示。一旦创建，元组的元素不能被修改。例如：
# 定义一个元组
my_tuple = (10, 'apple', 3.14)
6. 字典（Dictionary）
字典是一种无序的键值对集合，用花括号 {} 表示。每个键（key）必须是唯一的，且不可变（如字符串、数字、元组等），值（value）可以是任意类型。例如：
# 定义一个字典
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
通过键来访问对应的值，也可以添加、修改和删除键值对，这将在后续内容中详细讲解。
7. 集合（Set）
集合是一个无序的、不包含重复元素的可变数据类型，用花括号 {} 或 set() 函数创建。例如：
# 用花括号创建集合
my_set = {1, 2, 3, 3}
# 集合会自动去除重复元素，实际为 {1, 2, 3}
# 用 set() 函数创建集合
another_set = set([1, 2, 2, 3])
# 同样为 {1, 2, 3}
集合支持交集、并集、差集等数学集合运算，这将在后续内容中详细讲解。
2.4 运算符：让数字和逻辑动起来
2.4.1 算术运算符
算术运算符用于执行基本的数学运算。
-
加法（
+）：将两个数值相加。num1 = 5 num2 = 3 result = num1 + num2 # 将 num1 和 num2 相加，结果为 8 print(result) -
减法（
-）：从第一个数中减去第二个数。num1 = 5 num2 = 3 result = num1 - num2 # 用 num1 减去 num2，结果为 2 print(result) -
乘法（
*）：将两个数相乘。num1 = 5 num2 = 3 result = num1 * num2 # num1 乘以 num2，结果为 15 print(result) -
除法（
/）：用第一个数除以第二个数，结果为浮点数。num1 = 5 num2 = 3 result = num1 / num2 # 5 除以 3，结果为 1.6666666666666667 print(result) -
整除（
//）：执行除法运算并返回商的整数部分。num1 = 5 num2 = 3 result = num1 // num2 # 5 除以 3 的商的整数部分，结果为 1 print(result) -
取模（
%）：返回除法运算的余数。num1 = 5 num2 = 3 result = num1 % num2 # 5 除以 3 的余数，结果为 2 print(result) -
幂运算（
**）：将第一个数作为底数，第二个数作为指数进行幂运算。num1 = 5 num2 = 3 result = num1 ** num2 # 5 的 3 次方，结果为 125 print(result)
2.4.2 比较运算符
比较运算符用于比较两个值，并返回布尔值（True 或 False），判断条件是否成立。
-
等于（
==）：判断两个值是否相等。num1 = 5 num2 = 5 is_equal = num1 == num2 # 判断 num1 和 num2 是否相等，结果为 True print(is_equal) -
不等于（
!=）：判断两个值是否不相等。num1 = 5 num2 = 3 is_not_equal = num1 != num2 # 判断 num1 和 num2 是否不相等，结果为 True print(is_not_equal) -
大于（
>）：判断第一个值是否大于第二个值。num1 = 5 num2 = 3 is_greater = num1 > num2 # 判断 num1 是否大于 num2，结果为 True print(is_greater) -
小于（
<）：判断第一个值是否小于第二个值。num1 = 5 num2 = 3 is_less = num1 < num2 # 判断 num1 是否小于 num2，结果为 False print(is_less) -
大于等于（
>=）：判断第一个值是否大于或等于第二个值。num1 = 5 num2 = 5 is_greater_or_equal = num1 >= num2 # 判断 num1 是否大于或等于 num2，结果为 True print(is_greater_or_equal) -
小于等于（
<=）：判断第一个值是否小于或等于第二个值。num1 = 5 num2 = 5 is_less_or_equal = num1 <= num2 # 判断 num1 是否小于或等于 num2，结果为 True print(is_less_or_equal)
2.4.3 逻辑运算符
逻辑运算符用于组合多个条件判断，返回布尔值。
-
与（
and）：只有当两边的条件都为True时，结果才为True。condition1 = 5 > 3 condition2 = 2 < 4 result = condition1 and condition2 # 两个条件都为 True，结果为 True print(result) -
或（
or）：只要两边的条件有一个为True，结果就为True。condition1 = 5 > 3 condition2 = 2 > 4 result = condition1 or condition2 # condition1 为 True，结果为 True print(result) -
非（
not）：对条件进行取反操作，将True变为False，False变为True。condition = 5 > 3 result = not condition # condition 为 True，取反后结果为 False print(result)
2.4.4 赋值运算符
赋值运算符用于给变量赋值，除了基本的 = 之外，还有一些复合赋值运算符。
-
简单赋值（
=）：将右边的值赋给左边的变量。num = 5 # 将 5 赋给变量 num print(num) -
加法赋值（
+=）：先将变量与右边的值相加，再将结果赋给该变量。num = 5 num += 3 # 相当于 num = num + 3，num 变为 8 print(num) -
减法赋值（
-=）：先将变量减去右边的值，再将结果赋给该变量。num = 5 num -= 3 # 相当于 num = num - 3，num 变为 2 print(num) -
乘法赋值（
\*=）：先将变量与右边的值相乘，再将结果赋给该变量。num = 5 num *= 3 # 相当于 num = num * 3，num 变为 15 print(num) -
除法赋值（
/=）：先将变量除以右边的值，再将结果赋给该变量，结果为浮点数。num = 5 num /= 3 # 相当于 num = num / 3，num 变为 1.6666666666666667 print(num) -
整除赋值（
//=）：先将变量整除右边的值，再将结果赋给该变量。num = 5 num //= 3 # 相当于 num = num // 3，num 变为 1 print(num) -
取模赋值（
%=）：先将变量对右边的值取模，再将结果赋给该变量。num = 5 num %= 3 # 相当于 num = num % 3，num 变为 2 print(num) -
幂赋值（
\**=）：先将变量进行幂运算（以自身为底数，右边的值为指数），再将结果赋给该变量。num = 5 num **= 3 # 相当于 num = num ** 3，num 变为 125 print(num)
2.4.5 位运算符
位运算符用于对二进制数进行操作。在计算机中，数据以二进制形式存储，位运算符直接对这些二进制位进行操作。
-
按位与（
&）：对两个数的二进制表示的每一位进行与操作，只有当对应位都为1时，结果位才为1。num1 = 5 # 二进制为 0b101 num2 = 3 # 二进制为 0b011 result = num1 & num2 # 按位与结果为 0b001，即 1 print(result) -
按位或（
|）：对两个数的二进制表示的每一位进行或操作，只要对应位有一个为1，结果位就为1。num1 = 5 # 二进制为 0b101 num2 = 3 # 二进制为 0b011 result = num1 | num2 # 按位或结果为 0b111，即 7 print(result) -
按位异或（
^）：对两个数的二进制表示的每一位进行异或操作，当对应位不同时，结果位为1。num1 = 5 # 二进制为 0b101 num2 = 3 # 二进制为 0b011 result = num1 ^ num2 # 按位异或结果为 0b110，即 6 print(result) -
按位取反（
~）：对一个数的二进制表示的每一位进行取反操作，0变1，1变0。注意，Python 中整数的按位取反结果与数学上的补码表示有关。num = 5 # 二进制为 0b101 result = ~num # 按位取反结果为 -6 print(result) -
左移（
<<）：将一个数的二进制表示向左移动指定的位数，右边补0。左移相当于乘以2的移动位数次方。num = 5 # 二进制为 0b101 result = num << 2 # 左移 2 位，结果为 0b10100，即 20 print(result) -
右移（
>>）：将一个数的二进制表示向右移动指定的位数，左边补符号位（正数补0，负数补1）。右移相当于整除2的移动位数次方。num = 5 # 二进制为 0b101 result = num >> 2 # 右移 2 位，结果为 0b001，即 1 print(result)
2.4.6 成员运算符
成员运算符用于判断一个值是否在序列（如列表、字符串、元组等）中。
-
in：如果值在序列中，返回True，否则返回False。my_list = [1, 2, 3, 4, 5] is_in_list = 3 in my_list # 判断 3 是否在 my_list 中，结果为 True print(is_in_list) my_string = "Hello, World!" is_in_string = 'o' in my_string # 判断 'o' 是否在 my_string 中，结果为 True print(is_in_string) -
not in：如果值不在序列中，返回True，否则返回False。my_list = [1, 2, 3, 4, 5] is_not_in_list = 6 not in my_list # 判断 6 是否不在 my_list 中，结果为 True print(is_not_in_list) my_string = "Hello, World!" is_not_in_string = 'z' not in my_string # 判断 'z' 是否不在 my_string 中，结果为 True print(is_not_in_string)
2.4.7 身份运算符
身份运算符用于比较两个对象的内存地址，判断它们是否为同一个对象。
-
is：如果两个对象的内存地址相同，返回True,否则返回False。num1 = 5 num2 = 5 is_same = num1 is num2 # 判断 num1 和 num2 是否为同一个对象，结果为 True print(is_same) list1 = [1, 2, 3] list2 = [1, 2, 3] is_same_list = list1 is list2 # 判断 list1 和 list2 是否为同一个对象，结果为 False print(is_same_list) -
is not：如果两个对象的内存地址不同，返回True，否则返回False。num1 = 5 num2 = 10 is_not_same = num1 is not num2 # 判断 num1 和 num2 是否不是同一个对象，结果为 True print(is_not_same)
2.5 流程控制：引导程序走向的 “交通指挥家”
在 Python 编程中，流程控制就像是交通指挥家，决定着程序代码的执行顺序和路径。通过流程控制语句，我们可以让程序根据不同的条件做出不同的决策，或者重复执行某些代码块。Python 主要有三种流程控制结构：顺序结构、选择结构和循环结构。
2.5.1 顺序结构
顺序结构是程序中最基本的执行结构，代码按照从上到下的顺序依次执行，就像我们平时阅读文章一样，逐行阅读和执行。
# 定义变量 a 并赋值为 5
a = 5
# 定义变量 b 并赋值为 3
b = 3
# 计算 a 和 b 的和并赋值给 result
result = a + b
# 打印结果
print(result)
在这个例子中，先执行 a = 5，再执行 b = 3，接着执行 result = a + b，最后执行 print(result)，这就是典型的顺序结构。
2.5.1 选择结构
选择结构根据条件的判断结果来决定执行哪部分代码，就像我们在生活中遇到岔路口时，根据不同的情况选择不同的道路。
-
if语句if语句用于判断一个条件是否成立，如果成立则执行相应的代码块。age = 18 # 判断 age 是否大于等于 18 if age >= 18: print("你已经成年，可以投票啦！")在这个例子中，首先定义了变量
age并赋值为18，然后if语句判断age >= 18这个条件是否为True，如果为True，就执行缩进的代码块print("你已经成年，可以投票啦！")。 -
if - else语句if - else语句用于在条件成立和不成立时分别执行不同的代码块，即有两个分支。age = 15 # 判断 age 是否大于等于 18 if age >= 18: print("你已经成年，可以投票啦！") else: print("你还未成年，不能投票哦。")这里同样先定义
age为15，if语句判断age >= 18为False，所以不执行if代码块，而是执行else后面缩进的代码块print("你还未成年，不能投票哦。")。 -
if - elif - else语句当有多个条件需要依次判断时，可以使用
if - elif - else语句，它提供了多个分支选择。score = 85 # 判断 score 是否大于等于 90 if score >= 90: print("成绩优秀！") # 判断 score 是否大于等于 80 且小于 90 elif score >= 80: print("成绩良好！") # 判断 score 是否大于等于 60 且小于 80 elif score >= 60: print("成绩及格。") else: print("成绩不及格，需要努力哦。")此例中，先定义
score为85，if语句判断score >= 90为False，接着判断elif score >= 80为True，所以执行print("成绩良好！")，后面的elif和else代码块不再执行。 -
嵌套
if语句在一个
if或else代码块中还可以再嵌套if语句，实现更复杂的条件判断。age = 20 is_student = True # 判断 age 是否大于等于 18 if age >= 18: # 如果 age 大于等于 18，再判断是否是学生 if is_student: print("你是成年学生，可以享受学生优惠。") else: print("你已成年，但不是学生。") else: print("你未成年。")这里先判断
age >= 18，为True时进入第一个if代码块，然后在这个代码块中又判断is_student，根据其结果执行不同的代码。
2.5.2 循环结构
循环结构允许我们重复执行一段代码，直到满足特定条件为止，就像你绕着操场跑步，跑几圈后才停止。
-
for循环-
for循环通常用于遍历可迭代对象（如列表、元组、字符串等）。fruits = ['apple', 'banana', 'cherry'] # 遍历 fruits 列表 for fruit in fruits: print(fruit)在这个例子中，
fruits是一个列表，for循环依次从列表中取出每个元素并赋值给fruit，然后执行缩进的代码块print(fruit)，所以会依次打印出列表中的每个水果名称。 -
for循环还可以结合range()函数使用，range()函数用于生成一个整数序列。# 生成从 0 到 4 的整数序列（不包括 5） for i in range(5): print(i)
-
-
while循环while循环会在条件为True时不断重复执行代码块，直到条件变为False。count = 0 # 当 count 小于 5 时，执行循环体 while count < 5: print(count) count = count + 1在这个例子中，首先定义
count为0，while语句判断count < 5为True，就执行缩进的代码块，先打印count的值，然后将count加1。每次循环结束后都会重新判断count < 5，直到count变为5，条件为False时，循环结束。 -
嵌套循环
-
for循环的嵌套-
遍历二维列表
matrix = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] # 外层循环遍历二维列表的每一个子列表 for row in matrix: # 内层循环遍历每个子列表中的元素 for num in row: print(num, end=' ') print()在这个例子中，
matrix是一个二维列表，它包含三个子列表。外层for循环每次取出一个子列表并赋值给row，内层for循环则遍历row中的每个元素并打印出来。end=' '确保每个元素打印后以空格分隔，而外层循环每次结束时的print()则起到换行的作用，这样就能按矩阵的形式打印出所有元素。 -
打印乘法表
# 外层循环控制行数 for i in range(1, 10): # 内层循环控制列数 for j in range(1, i + 1): product = i * j print(f"{i}×{j}={product}\t", end='') print()这里外层
for循环从1到9迭代，代表乘法表的行数。对于每一行i，内层for循环从1到i迭代，代表该行的列数。每次计算i和j的乘积并格式化输出，\t用于在输出中添加制表符，使输出更加整齐。
-
-
while循环的嵌套打印直角三角形
# 定义行数 rows = 5 # 外层 while 循环控制行数 i = 1 while i <= rows: # 内层 while 循环控制每行的星号数量 j = 1 while j <= i: print('*', end=' ') j = j + 1 print() # 换行，用于开始新的一行 i = i + 1在这个例子中：
- 外层
while循环通过变量i来控制行数，从1到5。 - 对于每一行
i，内层while循环通过变量j来控制该行打印的星号数量，j从1到i。所以随着行数的增加，每行打印的星号数量也逐渐增加，形成一个直角三角形。
- 外层
-
for和while混合嵌套寻找两个列表中的公共元素
list1 = [10, 20, 30, 40] list2 = [30, 40, 50, 60] found_common = False # for 循环遍历 list1 for num1 in list1: # while 循环遍历 list2 j = 0 while j < len(list2): if num1 == list2[j]: print(f"找到公共元素: {num1}") found_common = True break j = j + 1 if found_common: break在这个示例中：
- 外层使用
for循环遍历list1中的每个元素num1。 - 对于
list1中的每一个元素，内层使用while循环遍历list2。 - 如果在
list2中找到与num1相同的元素，就打印出这个公共元素，并设置found_common为True，然后使用break语句跳出内层while循环。接着通过外层的条件判断，再次使用break跳出外层for循环，因为已经找到至少一个公共元素，无需继续查找。如果没有找到公共元素，while循环会完整遍历list2。
- 外层使用
-
-
循环控制语句
-
break语句：用于立即终止循环，跳出循环体。for i in range(10): # 当 i 等于 5 时，终止循环 if i == 5: break print(i)这里
for循环遍历range(10)，当i等于5时，执行break语句，循环立即结束，所以只会打印出0到4。 -
continue语句：用于跳过当前循环的剩余部分，直接进入下一次循环。for i in range(10): # 当 i 是偶数时，跳过本次循环的剩余部分 if i % 2 == 0: continue print(i)此例中，
for循环遍历range(10)，当i是偶数（i % 2 == 0）时，执行continue语句，跳过print(i)，直接进入下一次循环，所以只会打印出1, 3, 5, 7, 9。 -
else子句（在循环中）：在for或while循环正常结束（没有通过break终止）时，会执行else子句中的代码。for i in range(5): print(i) else: print("循环正常结束。")这里
for循环正常遍历完range(5)，没有遇到break，所以循环结束后会执行else子句中的print("循环正常结束。")。
-
三、函数
在 Python 中，函数就像是一个个智能小助手，它们能帮你完成各种特定的任务。你可以把一些经常使用的代码片段封装到函数里，需要的时候调用它，就像叫小助手来帮忙做事一样，这样不仅能减少重复代码，还能让你的程序结构更清晰。
3.1 函数的定义与调用
3.1.1 函数的定义
使用 def 关键字来定义函数，后面跟着函数名和一对圆括号，括号里可以放参数（也可以不放），最后以冒号结尾。函数体是缩进的代码块，包含了函数要执行的具体操作。
# 定义一个简单的函数，函数名为 greet，没有参数
def greet():
print("Hello, World!")
3.1.2 函数的调用
定义好函数后，就可以通过函数名加上括号来调用它，这样函数里的代码就会被执行。
# 定义一个简单的函数，函数名为 greet，没有参数
def greet():
print("Hello, World!")
# 调用 greet 函数
greet()
在这个例子中，greet 函数被定义后，通过 greet() 调用，屏幕上就会输出 Hello, World!。如果函数没有被调用，则函数不会被执行。
3.2 函数的参数
3.2.1 位置参数
位置参数是最常见的参数类型，调用函数时传递的参数按照定义函数时参数的顺序依次匹配。
# 定义一个函数，接受两个位置参数 name 和 age
def introduce(name, age):
print(f"我叫 {name}，今年 {age} 岁。")
# 调用 introduce 函数，传递两个参数
introduce("Alice", 25)
这里 introduce 函数定义了两个位置参数 name 和 age，调用时按照顺序传递了 "Alice" 和 25，函数就会按照参数顺序使用它们，输出 我叫 Alice，今年 25 岁。。
3.2.2 默认参数
默认参数在定义函数时就给参数指定了一个默认值。调用函数时，如果没有传递该参数的值，就会使用默认值。
# 定义一个函数，接受一个位置参数 name，以及一个默认参数 country，默认值为 "China"
def greet_user(name, country="China"):
print(f"你好，{name}！你来自 {country}。")
# 调用 greet_user 函数，只传递 name 参数
greet_user("Bob")
# 调用 greet_user 函数，传递 name 和 country 参数
greet_user("Charlie", "USA")
在这个例子中，greet_user 函数的 country 参数有默认值 "China"。当只传递 name 参数调用函数时，country 就会使用默认值；当传递了 country 参数时，就会使用传递的值。
3.2.3 可变参数（*args）
可变参数允许函数接受任意数量的位置参数。在函数定义中，使用 *args 来表示可变参数（args 只是一个习惯用法，可以使用其他合法的变量名），它会把所有传递进来的位置参数收集到一个元组中。
# 定义一个函数，接受可变参数 *args
def sum_numbers(*args):
total = 0
for num in args:
total += num
return total
# 调用 sum_numbers 函数，传递不同数量的参数
result1 = sum_numbers(1, 2, 3)
result2 = sum_numbers(10, 20, 30, 40)
print(result1)
print(result2)
这里 sum_numbers 函数可以接受任意数量的数字参数，并将它们相加返回。*args 把传递的参数收集成元组，通过 for 循环遍历元组进行求和。
3.2.4 关键字参数（**kwargs）
关键字参数允许函数接受任意数量的关键字参数（键值对形式）。在函数定义中，使用 **kwargs 来表示关键字参数（同样，kwargs 只是习惯用法），它会把所有传递进来的关键字参数收集到一个字典中。
# 定义一个函数，接受关键字参数 **kwargs
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
# 调用 print_info 函数，传递不同的关键字参数
print_info(name="David", age=30, city="New York")
在这个例子中，print_info 函数接受任意数量的关键字参数，并将它们以 键: 值 的形式打印出来。**kwargs 把传递的关键字参数收集成字典，通过 for 循环遍历字典进行输出。
3.3 函数的返回值
函数可以通过 return 语句返回一个值，这个值可以是任何数据类型。一旦执行到 return 语句，函数就会停止执行，并将返回值传递给调用它的地方。
# 定义一个函数，接受两个参数 a 和 b，返回它们的和
def add(a, b):
return a + b
# 调用 add 函数，并将返回值赋给 result 变量
result = add(3, 5)
print(result)
在这个例子中，add 函数计算两个数的和并返回，调用函数时将返回值赋给 result 变量，然后打印出来。
3.4 函数的文档注释
函数文档注释（Docstring）是对函数功能、参数、返回值等信息的描述，它是提高代码可读性和可维护性的重要工具。通常在函数定义的第一行，使用三引号（''' 或 """）括起来。
def multiply(a, b):
"""
这个函数用于计算两个数的乘积。
参数:
a -- 第一个数字
b -- 第二个数字
返回值:
两个数字的乘积
"""
return a * b
你可以通过 函数名.__doc__ 来查看函数的文档注释。
print(multiply.__doc__)
3.5 函数的嵌套定义与作用域
3.5.1 函数的嵌套定义
在一个函数内部还可以定义另一个函数，内部函数只能在外部函数内部被调用。
def outer_function():
print("这是外部函数。")
def inner_function():
print("这是内部函数。")
inner_function()
outer_function()
在这个例子中，inner_function 定义在 outer_function 内部，outer_function 调用了 inner_function。
3.5.2 作用域
作用域是指变量在程序中可被访问的范围。Python 中有全局作用域和局部作用域。
-
全局变量：在函数外部定义的变量，在整个程序中都可以访问（除非在函数内部重新定义同名变量）。
-
局部变量：在函数内部定义的变量，只能在函数内部访问。
# 全局变量 global_variable = 10 def test_function(): # 局部变量 local_variable = 20 print(f"局部变量: {local_variable}") print(f"全局变量: {global_variable}") test_function() # 这里无法访问 local_variable，会报错 # print(local_variable)在这个例子中，
global_variable是全局变量，在函数内部可以访问；local_variable是局部变量，只能在test_function内部访问。
3.6 匿名函数
在 Python 中，除了常规使用 def 关键字定义的函数外，还有一种特殊的函数，被称为匿名函数。匿名函数没有显式的函数名，它以一种简洁的方式定义小型函数，就像一个小巧灵活的 “代码小精灵”，在需要简单函数的场景中发挥着独特的作用。
3.6.1 匿名函数的定义
匿名函数使用 lambda 关键字来定义，其基本语法如下：
lambda 参数列表: 表达式
lambda 关键字后面跟着参数列表（可以有多个参数，用逗号分隔，也可以没有参数），然后是一个冒号，冒号后面是一个表达式。这个表达式的计算结果就是匿名函数的返回值。
例如，定义一个简单的匿名函数来计算两个数的和：
add = lambda a, b: a + b
这里我们将匿名函数赋值给变量 add，就可以像调用普通函数一样调用它：
add = lambda a, b: a + b
result = add(3, 5)
print(result)
3.6.2 匿名函数的应用场景
匿名函数不需要像普通函数那样使用 def 关键字、函数名以及完整的代码块结构，一行代码就能定义一个函数，适用于简单的函数逻辑。通常在只需要使用一次函数的场景中使用，不需要专门为其定义一个完整的函数，从而减少代码量。
-
作为函数参数
许多 Python 内置函数或第三方库函数允许传入一个函数作为参数，这时匿名函数就非常有用。例如，
sorted()函数可以对列表进行排序，通过传入匿名函数可以自定义排序规则。假设有一个包含字典的列表，每个字典表示一个人，包含
name和age两个键，现在要根据age对列表进行排序：people = [ {'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 20}, {'name': 'Charlie', 'age': 30} ] sorted_people = sorted(people, key=lambda person: person['age']) print(sorted_people)在这个例子中，
sorted()函数的key参数接受一个函数，我们使用匿名函数lambda person: person['age']来指定按照age字段进行排序。 -
结合
map()函数map()函数接受一个函数和一个可迭代对象作为参数，将函数应用到可迭代对象的每个元素上，并返回一个新的可迭代对象。结合匿名函数可以方便地对列表中的每个元素进行特定操作。例如，将列表中的每个数字平方：
numbers = [1, 2, 3, 4, 5] squared_numbers = list(map(lambda x: x ** 2, numbers)) print(squared_numbers)这里使用匿名函数
lambda x: x ** 2作为map()函数的第一个参数，对numbers列表中的每个元素进行平方操作，map()函数返回一个迭代器，通过list()函数将其转换为列表。 -
结合
filter()函数filter()函数用于过滤可迭代对象中的元素，它接受一个函数和一个可迭代对象作为参数，返回一个新的可迭代对象，其中只包含使函数返回True的元素。结合匿名函数可以轻松实现数据过滤。例如，从列表中过滤出所有偶数：
numbers = [1, 2, 3, 4, 5] even_numbers = list(filter(lambda x: x % 2 == 0, numbers)) print(even_numbers)这里匿名函数
lambda x: x % 2 == 0作为filter()函数的第一个参数，用于判断每个元素是否为偶数，filter()函数返回符合条件的元素组成的迭代器，再通过list()函数转换为列表。
学习秘籍
1️⃣ 多写代码少死记（动手比看书重要！）
2️⃣ 善用print()调试（观察程序每一步）
3️⃣ 错误是朋友（读懂报错信息你就赢了50%）