干货分享，感谢您的阅读！备注：本博客将自己初步学习Python的总结进行分享，希望大家通过本博客可以在短时间内快速掌握Python的基本程序编码能力，如有错误请留言指正，谢谢！（持续更新）
一、快速了解 Python 和 环境准备
（一）Python 快速介绍
Python 是一种 简洁、强大、易读 的编程语言，广泛应用于 Web 开发、数据分析、人工智能、自动化运维 等领域。它由 Guido van Rossum 在 1991 年设计，因其清晰的语法和强大的生态系统，迅速成为全球最受欢迎的编程语言之一。
在 2017 年底，Stack Overflow 发布的数据显示，Python 已经超越 JavaScript 成为了该平台上提问流量最多的编程语言。
（二）Jupyter Notebook：从梦想到行业标配
Jupyter Notebook 的诞生源于创始人 Fernando Pérez一个大胆的想法：打造一个能整合 Julia（Ju）、Python（Py）和 R（ter） 这三种科学计算语言的通用计算平台。但目前Jupyter 早已超越最初的设想，成为一个支持几乎所有编程语言的多功能计算环境。
从 2017 年起，北美顶尖高校纷纷全面拥抱 Jupyter Notebook：
学术界：斯坦福的 CS231N《计算机视觉与神经网络》 课程2017 年便完全迁移到 Jupyter Notebook、UC Berkeley 的 《数据科学基础》 课程也在同年改用 Jupyter 作为唯一的作业平台。
工业界： Facebook尽管大型后端开发仍依赖传统 IDE，但几乎所有 内部分析、机器学习训练和数据探索 都基于 Jupyter Notebook 运行。同时 Google 的 AI Research 部门 Google Brain，也是清一色地全部使用 Jupyter Notebook（改进定制版，叫 Google Colab）。
（三）Mac 上安装 Python 和 Jupyter Notebook 的步骤
| 步骤 | 命令 | 说明 |
|---|---|---|
| 1. 安装 Homebrew | /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" |
Mac 的包管理工具（如果未安装） |
| 2. 安装 Python 3 | brew install python |
安装最新的 Python 3 |
| 3. 验证 Python 版本 | python3 --version |
确保安装成功，显示 Python 3.x.x |
| 4. 安装 Jupyter Notebook | pip3 install jupyter |
通过 pip3 安装 Jupyter |
| 5. 检查 Jupyter 是否可用 | jupyter --version |
确保 Jupyter 已正确安装 |
| 6. 启动 Jupyter Notebook | jupyter notebook |
打开 Jupyter Notebook，浏览器自动打开 |
这样，我们就可以在 Mac 上使用 Jupyter Notebook 进行 Python 开发了！
备注：
如果你不习惯也可以直接idea，毕竟这么多年习惯了java开发，我就是两个都安装了，无所谓！
如果不想安装也可以在线使用：Jupyter 官方在线工具
二、Python 基础：变量、数据类型与输入输出
Python 以其 简洁、易读 的语法受到欢迎，而理解变量、数据类型和输入输出是学习 Python 的第一步。这部分内容构成了 Python 编程的基石。这部分代码我写的时候都是直接在idea中，网络版本有时很慢。Jupyter 官方在线工具
（一）变量：数据的存储与引用
变量（Variable）是用于存储数据的容器，在 Python 中变量不需声明类型，直接赋值即可创建。
1. 变量的定义与赋值
x = 10 # 整数变量
name = "Alice" # 字符串变量
pi = 3.14159 # 浮点数变量
is_python_fun = True # 布尔变量Python 是动态类型语言，变量的类型是根据赋值内容自动推导的。
2. 变量命名规则
变量名必须 以字母或下划线（_）开头，不能以数字开头。
变量名只能包含 字母、数字和下划线，不能包含空格或特殊符号。
变量名区分大小写（
age和Age是不同的变量）。推荐使用 小写字母+下划线（
snake_case）风格，如user_name，符合 Python 代码规范（PEP 8）。
示例：正确与错误的变量命名
valid_name = "OK" # 正确
_valid_123 = 42 # 正确
2nd_value = "wrong" # ❌ 错误：不能以数字开头
user-name = "error" # ❌ 错误：不能包含 `-`
（二）数据类型（Data Types）
Python 具有丰富的数据类型，主要包括：
| 数据类型 | 示例 | 说明 |
|---|---|---|
| 整数（int） | x = 42 |
存储整数，如 10, -5, 1000 |
| 浮点数（float） | pi = 3.14 |
存储小数，如 3.1415, -0.5 |
| 字符串（str） | name = "Alice" |
存储文本，如 "hello" |
| 布尔值（bool） | is_valid = True |
只有 True 或 False |
| 列表（list） | nums = [1, 2, 3] |
有序可变的集合 |
| 元组（tuple） | colors = ('red', 'blue') |
有序不可变的集合 |
| 字典（dict） | person = {"name": "Alice", "age": 25} |
键值对存储 |
| 集合（set） | unique_nums = {1, 2, 3} |
无序不重复元素集合 |
Python 提供 type() 函数来查看变量的数据类型：
x = 42
print(type(x)) # 输出：<class 'int'>
Python 允许不同类型之间的转换：
age = "25"
age = int(age) # 将字符串转换为整数
pi = 3.14
pi_str = str(pi) # 将浮点数转换为字符串
（三）输入与输出（Input & Output）
1. 标准输入（input）
input() 用于从用户获取输入，所有输入默认是 字符串类型：
name = input("请输入你的名字: ")
print("你好,", name)
如果需要数值类型，需要进行 类型转换：
age = int(input("请输入你的年龄: ")) # 输入默认是字符串，需要转换成整数
print("你明年就", age + 1, "岁了！")
基本验证：
2. 标准输出（print）
print() 用于向控制台输出内容：
name = "Alice"
age = 25
print("姓名:", name, "年龄:", age) # 多个参数用逗号分隔
格式化输出（推荐使用 f-string，Python 3.6+ 支持）：
print(f"姓名: {name}, 年龄: {age}") # 推荐的写法✅ 小练习题
尝试自己编写代码练习以下问题：（后面我单独出一篇博客将答案附上）
定义一个变量
temperature，存储36.6，并使用print()输出"体温: 36.6 摄氏度"。编写一个程序，提示用户输入姓名和年龄，并打印
"你好，XX！你今年 YY 岁"（其中XX和YY由用户输入）。
Python 的变量、数据类型和输入输出构成了编程的基础，熟练掌握这些概念后，就可以进行更复杂的逻辑编写了！
三、控制流：让代码具备决策能力
在编程中，控制流 决定了代码的执行顺序，使程序能够做出决策（条件判断），或重复执行任务（循环）。通过 布尔值、逻辑运算、if 语句、for 和 while 循环，我们可以让 Python 代码变得更加智能和高效。这部分我会总结下这些关键概念，其是构建更具逻辑性程序的基础。
（一）布尔值与逻辑判断
在 Python 中，布尔值（Boolean） 是控制程序逻辑的基础。它用于 条件判断、循环控制和逻辑运算，让代码具备决策能力。
1. 布尔值（Boolean）
布尔值只有两个取值：
True # 代表 "真"
False # 代表 "假"
布尔值本质上是整数的特殊形式，其中：
True == 1 # 结果为 True
False == 0 # 结果为 True
布尔值的基本使用
is_python_fun = True
is_raining = False
print(is_python_fun) # 输出：True
print(type(is_python_fun)) # 输出：<class 'bool'>
2. 比较运算符（Comparison Operators）
比较运算符用于比较两个值，返回 True 或 False。
| 运算符 | 含义 | 示例 | 结果 |
|---|---|---|---|
== |
等于 | 5 == 5 |
True |
!= |
不等于 | 5 != 3 |
True |
> |
大于 | 10 > 3 |
True |
< |
小于 | 2 < 8 |
True |
>= |
大于等于 | 5 >= 5 |
True |
<= |
小于等于 | 3 <= 2 |
False |
代码示例
a = 10
b = 5
print(a > b) # True
print(a == b) # False
print(a != b) # True
3. 布尔运算符（Boolean Operators）
Python 提供了 and、or 和 not 三种逻辑运算符，用于组合多个布尔表达式。
| 运算符 | 含义 | 示例 | 结果 |
|---|---|---|---|
and |
逻辑与（都为 True 时才为 True） |
True and False |
False |
or |
逻辑或（只要一个为 True 就是 True） |
True or False |
True |
not |
逻辑非（取反） | not True |
False |
3.1 and 逻辑与
x = 5
y = 10
print(x > 0 and y > 5) # True，因为两个条件都成立
print(x > 0 and y < 5) # False，因第二个条件不成立
3.2 or 逻辑或
x = 5
y = 10
print(x > 0 or y < 5) # True，只要有一个条件为 True 即可
print(x < 0 or y < 5) # False，两个条件都为 False
3.3 not 逻辑非
is_python_fun = True
print(not is_python_fun) # False，因为取反了
4. 混合布尔运算（优先级）
运算符的 优先级 从高到低依次为：not（最高）、and、or（最低）
print(True or False and False)
# 等价于 True or (False and False) → True or False → True
print(not True or False)
# 等价于 (not True) or False → False or False → False
5. 布尔值与其他数据类型的转换
在 Python 中，所有数据类型 都可以转换为布尔值：
以下情况视为
False：0（整数 0）0.0（浮点数 0）""（空字符串）[]（空列表）{}（空字典）None（特殊值，表示“空”）
其他情况均为
True。
5.1 使用 bool() 进行类型转换
print(bool(0)) # False
print(bool("")) # False
print(bool([])) # False
print(bool(42)) # True
print(bool("hello")) # True
5.2 在 if 语句中使用
name = "Alice"
if name: # 相当于 if bool(name) == True
print("名字有效")
else:
print("名字为空")
输出：
名字有效✅ 小练习题
练习 1：布尔运算
判断以下表达式的结果：
True and False or Truenot (False or True)(10 > 5) and (3 != 3)
练习 2：用户输入比较
让用户输入两个数字，比较它们的大小，并输出 "第一个数字更大" 或 "第二个数字更大"。
# 提示：使用 input() 和 if 语句布尔值和逻辑判断是 条件判断和循环 的基础，熟练掌握它们后，代码将更加智能化！ 🚀
（二）🌟 条件判断（if 语句）
在编程中，我们经常需要根据不同条件来执行不同的代码。这就要用到 条件判断语句（if statement）。Python 中使用 if、elif 和 else 关键字来实现条件分支。
1. 基本 if 语句
语法结构：
if 条件:
语句块
✅ 当“条件”为 True 时，语句块才会被执行。
示例：
age = 20
if age >= 18:
print("你已经成年了")
输出：
你已经成年了2. if-else 结构（两分支选择）
用于处理“要么这样，要么那样”的情况。
语法结构：
if 条件:
语句块1
else:
语句块2
示例：
temperature = 15
if temperature > 20:
print("北京天气今天很暖和")
else:
print("北京天气今天有点冷")
输出：
北京天气今天有点冷3. if-elif-else 结构（多分支选择）
用于处理多个条件判断的情况（相当于“多项选择”）。
语法结构：
if 条件1:
语句块1
elif 条件2:
语句块2
elif 条件3:
语句块3
else:
默认语句块
示例：
score = 85
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 60:
print("及格")
else:
print("不及格")
输出：
良好💡
elif是 "else if" 的缩写。Python 中没有switch语句，if-elif-else是推荐的替代方案。
4. 嵌套 if 语句
嵌套 指的是在一个 if 块内部再写 if 判断。可以用来表示更复杂的逻辑结构。
示例：
age = 25
is_student = True
if age < 30:
if is_student:
print("你是年轻的学生")
else:
print("你是年轻的上班族")
输出：
你是年轻的学生⚠️ 注意缩进层级，Python 是靠缩进来识别代码块的！
5. 条件表达式（三元运算符）
Python 支持一种简洁的写法：在一行中完成 if-else 判断。
语法：
变量 = 值1 if 条件 else 值2
示例：
age = 16
status = "成年" if age >= 18 else "未成年"
print(status)
输出：
未成年适合用于 根据条件选择一个值赋给变量 的情况。
✅ 小练习题
练习 1：分数等级判断器
让用户输入一个 0～100 的整数，判断其属于哪个等级：
90 以上：优秀
80～89：良好
70～79：中等
60～69：及格
低于 60：不及格
其他情况提示“输入有误”
练习 2：三角形合法性判断
输入三条边的长度，判断是否能组成一个三角形（任意两边之和大于第三边），并进一步判断：
是等边三角形
是等腰三角形
是普通三角形
否则输出“不合法的三角形”
练习 3：模拟 ATM 登录与权限检查（嵌套）
假设用户名为
admin，密码为8888，登录成功后再检查是否为管理员（管理员输入"yes"才能继续操作）。
练习 4：三元运算小测试
输入一个数字，输出
"正数"、"负数"或"零"，用三元运算符 实现。
🧠 小结
| 类型 | 场景示例 |
|---|---|
if |
只有一个条件 |
if-else |
两种可能，二选一 |
if-elif-else |
多种情况，依次判断 |
嵌套 if |
条件套条件，多层判断 |
| 三元表达式 | 简洁地赋值，适合一行判断 |
（三）循环（Loops）
在编程中，我们常常需要重复执行某些操作，比如遍历列表、处理每一行数据、执行某个动作直到满足条件等等。Python 提供了两种主要的循环结构：while 循环和 for 循环，配合控制语句（如 break、continue）可以构建出丰富的循环逻辑。
1. while 循环（基于条件重复执行）
✅ 基本语法
while 条件表达式:
循环体
每次循环前都会检查“条件表达式”的值；
条件为
True→ 执行循环体；条件为
False→ 结束循环。
🧪 示例：打印 1 到 5 的数字
i = 1
while i <= 5:
print(i)
i += 1
🔁 break 语句（提前终止循环）
break 用于立即跳出整个循环结构，不管循环条件是否还为 True。
i = 1
while True:
print(i)
if i == 3:
break
i += 1
输出：1, 2, 3，然后退出循环
🔁 continue 语句（跳过当前迭代）
continue 用于跳过本次循环中剩下的语句，直接进入下一次判断。
i = 0
while i < 5:
i += 1
if i == 3:
continue
print(i)
输出：1, 2, 4, 5（跳过了 3）
2. for 循环（用于遍历序列）
✅ 基本语法
for 变量 in 可迭代对象:
循环体
可迭代对象包括：字符串、列表、字典、集合、元组等。
🔁 遍历字符串
for ch in "hello":
print(ch)
🔁 遍历列表
fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
print(fruit)
🔁 遍历字典
info = {"name": "Tom", "age": 20}
for key in info:
print(key, "=>", info[key])
或使用 .items() 遍历键值对：
for key, value in info.items():
print(f"{key}: {value}")
🔁 遍历集合
s = {"apple", "banana", "cherry"}
for item in s:
print(item)
🔁 range() 函数与数值循环
for i in range(1, 6):
print(i)
range(n)：0 到 n-1range(start, end)：start 到 end-1range(start, end, step)：按步长生成
🔁 enumerate() 结合索引遍历
想同时获取元素和下标时使用 enumerate()：
colors = ['red', 'green', 'blue']
for index, color in enumerate(colors):
print(f"{index}: {color}")
3. 循环控制语句
✅ break：提前终止整个循环
通常与 if 配合使用，用于在满足某个条件时立即退出循环。
for i in range(1, 10):
if i == 5:
break
print(i)
✅ continue：跳过当前迭代
用于跳过某些不符合条件的值。
for i in range(1, 6):
if i % 2 == 0:
continue
print(i) # 输出 1 3 5（跳过偶数）
✅ else 语句在循环中的作用
else 可以与 for 或 while 循环一起使用：
当循环没有被
break中断时，else中的语句会执行。for i in range(1, 5): if i == 10: break else: print("未被 break，循环正常结束")这在处理搜索类问题时特别有用：
nums = [1, 3, 5, 7] target = 4 for num in nums: if num == target: print("找到目标") break else: print("未找到目标")
✅ 小结
| 循环类型 | 用途 | 特点 |
|---|---|---|
while |
条件控制循环 | 不确定次数时使用 |
for |
遍历序列 | 更简洁，适合固定结构 |
break |
跳出循环 | 终止整个循环体 |
continue |
跳过本次迭代 | 继续下一轮 |
else |
循环结构补充 | 仅在循环未被 break时执行 |
✅ 小练习题
🧪 练习题 1：打印 1~100 中所有能被 7 整除的数
🧪 练习题 2：使用 while 计算从 1 累加到 n 的和（n 由用户输入）
🧪 练习题 3：找出列表中第一个大于 50 的元素，并输出其值和索引
🧪 练习题 4：输出 1~30 中除了能被 3 整除的数（使用 continue）
🧪 练习题 5：统计一段字符串中元音字母的个数（不区分大小写）
🧪 练习题 6：使用 for 和 else 实现一个猜数字小游戏
四、🧩 函数与相关基础知识：让代码会“思考”的魔法工具
在编程的世界里，函数就像是程序的“积木”：它们能把一段可复用的操作封装起来，想用就调用，修改也方便，堪称优雅代码的起点。
无论是打印一行文字，计算一个数列的和，还是训练一个 AI 模型，本质上你做的都是“定义功能 + 调用功能” —— 这正是函数的使命。
（一）函数基础
1. 什么是函数？为什么要使用函数？
在编程中，函数是一个非常重要的概念，它可以被理解为“功能块”，用来封装一段代码，供其他地方调用。通过函数，开发者可以：
提高代码复用性：避免重复写相同的代码，简化开发和维护。
增强可读性：将复杂的任务拆解成小的、独立的单元，便于理解。
分隔逻辑：函数让代码的逻辑结构更加清晰和模块化，有助于团队协作开发。
例如，我们可以定义一个函数来计算两个数字的和，而不需要每次都重复写加法的操作。只要定义一次，后续就可以随时调用。
2. 使用 def 定义函数
在 Python 中，函数是通过 def 关键字来定义的。它的基本语法如下：
def function_name(parameters):
# 函数体
return result
def是 Python 中定义函数的关键字function_name是你给函数命名的名称，符合命名规则parameters是函数的输入（可以没有）return是返回结果的关键字（如果不返回任何值，则默认为None）
示例：一个简单的加法函数
def add(a, b):
return a + b
# 调用函数
result = add(3, 5)
print(result) # 输出: 8
这里我们定义了一个 add 函数，输入参数是 a 和 b，它们会被加在一起并返回结果。
3. 函数的调用和执行流程
定义函数后，调用函数就能执行该函数的代码。Python 会根据函数调用的顺序进入函数体，并执行其中的代码。
当函数被调用时，程序会暂停当前位置，跳转到函数体执行代码，直到遇到
return语句（或者函数执行完毕）才返回。如果没有
return语句，则返回None。
示例：简单的函数调用与返回值
def greet(name):
return f"Hello, {name}!"
message = greet("Alice")
print(message) # 输出: Hello, Alice!
这里的 greet 函数通过 return 语句返回了一个字符串，调用时传入了参数 "Alice"，最终返回 "Hello, Alice!"。
4. print() 与 return 的区别与使用场景
在 Python 中，print() 和 return 都用于输出数据，但它们有显著的不同：
print()用于将信息输出到控制台，主要用于调试、输出中间结果或与用户交互。return用于函数的输出，它将值返回给调用者，可以被其他代码再次使用。
示例：print() 和 return 对比
# 使用 print()
def greet_print(name):
print(f"Hello, {name}!")
greet_print("Alice") # 输出: Hello, Alice!
# 使用 return
def greet_return(name):
return f"Hello, {name}!"
message = greet_return("Alice")
print(message) # 输出: Hello, Alice!
greet_print使用print()输出值，但无法把它传递给其他部分的代码。greet_return使用return返回结果，这个返回值可以在代码的其他地方使用或存储。
小结一下吧
函数是代码复用、模块化的核心工具。
使用
def定义函数，return返回值。print()用于输出调试信息，return用于返回计算结果。
（二）函数参数
函数参数是函数接收外部输入的方式。理解和掌握函数参数的使用，不仅能帮助你编写更灵活的代码，还能让你的程序更具扩展性和可维护性。
1. 位置参数
位置参数是最常见的函数参数类型，它是指参数传递时位置的顺序决定了每个参数的含义。
例如，在函数定义时，参数 a 和 b 的位置决定了它们的意义。当调用函数时，传递的参数值会根据位置匹配到相应的参数。
示例：位置参数
def add(a, b):
return a + b
result = add(3, 5) # 位置参数：3 被赋值给 a，5 被赋值给 b
print(result) # 输出: 8
这里的 add 函数有两个位置参数：a 和 b。我们调用 add(3, 5) 时，3 会赋值给 a，5 会赋值给 b，最终返回它们的和。
2. 关键字参数
关键字参数允许你在调用函数时显式地指定每个参数的名称。这样可以不关心参数的顺序，只需要知道参数名。
示例：关键字参数
def greet(name, age):
return f"Hello, {name}! You are {age} years old."
message = greet(age=25, name="Alice") # 参数顺序不重要
print(message) # 输出: Hello, Alice! You are 25 years old.
在调用 greet 函数时，age 和 name 的顺序不再重要，关键字参数通过指定 age=25 和 name="Alice" 来传递值。
3. 默认参数
默认参数是指在定义函数时，为某些参数提供默认值。如果调用时没有提供这些参数的值，Python 会使用默认值。
示例：默认参数
def greet(name, age=18): # age 有默认值
return f"Hello, {name}! You are {age} years old."
message1 = greet("Alice") # 调用时没有提供 age，使用默认值
message2 = greet("Bob", 30) # 调用时提供了 age，覆盖默认值
print(message1) # 输出: Hello, Alice! You are 18 years old.
print(message2) # 输出: Hello, Bob! You are 30 years old.
在 greet 函数中，age 有默认值 18。如果调用时没有传入 age，就会使用默认值；如果传入了 age，则会覆盖默认值。
4. 可变参数：*args 与 **kwargs
有时候我们不知道函数需要接收多少个参数，这时可以使用 可变参数。
*args用于接收位置参数，它将接收多余的位置参数并将其打包成一个元组。**kwargs用于接收关键字参数，它将接收多余的关键字参数并将其打包成一个字典。
示例：*args 和 **kwargs
def example(*args, **kwargs):
print("args:", args)
print("kwargs:", kwargs)
# 调用函数时传入不同数量的参数
example(1, 2, 3, name="Alice", age=25)
# 输出:
# args: (1, 2, 3)
# kwargs: {'name': 'Alice', 'age': 25}
*args将所有位置参数（1,2,3）打包成一个元组(1, 2, 3)。**kwargs将所有关键字参数（name="Alice",age=25）打包成一个字典{'name': 'Alice', 'age': 25}。
5. 参数顺序规范
当一个函数同时使用位置参数、默认参数和可变参数时，有一定的顺序规范，必须遵循以下顺序：
位置参数
默认参数
*args**kwargs
示例：参数顺序
def function(a, b=2, *args, c, **kwargs):
print(a, b, args, c, kwargs)
# 调用时，按照顺序传递参数
function(1, c=3, d=4, e=5)
# 输出: 1 2 () 3 {'d': 4, 'e': 5}
a是位置参数，必须最先提供。b是默认参数，如果不提供则使用默认值。*args用于接收多余的所有位置参数。c是一个关键字参数，调用时必须显式指定。**kwargs用于接收多余的所有关键字参数。
小结一下吧
位置参数：根据参数顺序传递值。
关键字参数：显式指定参数名和值。
默认参数：函数定义时为参数提供默认值。
可变参数：
*args用于接收多位置参数，**kwargs用于接收多关键字参数。参数顺序：位置参数 > 默认参数 >
*args>**kwargs。
（三）函数返回值
在 Python 中，函数不仅可以执行某些操作，还可以将结果“返回”给调用者。这就是 返回值（Return Value） 的概念。
通过 return 语句，函数可以把处理的结果交给外部使用。如果函数没有 return，那它默认返回的是 None。
1. 使用 return 返回结果
基本语法：
def function_name(...):
...
return result
示例：
def square(x):
return x * x
result = square(5)
print(result) # 输出: 25
函数 square 返回的是 x 的平方，调用后我们可以拿到这个结果并继续使用。
2. 返回多个值（元组）
Python 支持从一个函数中返回多个值，这些值实际上被打包成一个元组返回。
示例：
def get_name_and_age():
name = "Alice"
age = 30
return name, age
n, a = get_name_and_age()
print(n) # Alice
print(a) # 30
多值返回的本质是：
return name, age等价于return (name, age)，然后通过拆包语法接收。
3. 函数无返回值时的表现
如果函数中没有 return 语句，或者只是 return 而没有值，那默认返回的是 None。
示例：
def say_hello():
print("Hello!")
result = say_hello()
print(result) # 输出: None
这个函数 say_hello() 虽然做了事情（打印），但没有 return，因此返回值是 None。
4. 提前终止函数执行
return 不仅能返回值，还能用来提前终止函数的执行。
示例：
def divide(a, b):
if b == 0:
return "除数不能为 0"
return a / b
print(divide(10, 0)) # 输出: 除数不能为 0
print(divide(10, 2)) # 输出: 5.0
当 b 是 0 时，函数遇到第一个 return 后立即终止执行，不会继续往下运行。
5. 将返回值作为表达式使用
函数返回值可以被用在其他表达式或函数中，像这样：
def add(a, b):
return a + b
print(add(2, 3) * 10) # 输出: 50
add(2, 3) 会返回 5，然后再与 10 相乘。
小结一下吧
| 内容 | 示例 | 返回值说明 |
|---|---|---|
| 返回单个值 | return x |
返回一个对象 |
| 返回多个值 | return x, y |
返回一个元组 |
| 无 return 或 return None | return / 无 return |
返回 None |
| 提前结束函数 | if ...: return ... |
直接退出函数 |
| 返回值可以参与表达式 | add(1, 2) * 3 |
函数结果用于计算 |
五、📚 字符串操作模块
在 Python 中，字符串（str）是最常用、最重要的数据类型之一。无论你是在处理用户输入、读取文件、构建网页内容、分析文本数据，几乎都绕不开对字符串的处理。
现在我们总结掌握 Python 字符串的各种操作方法，从最基本的创建与访问，到复杂的格式化与正则匹配，覆盖日常开发中 90% 的高频场景。我们需要学会如何清洗、切割、替换、判断和重组字符串，并为后续的数据处理与文本分析打下坚实基础。
（一）📘 字符串基础
在 Python 中，字符串（str）是用来表示文本的数据类型。本部分介绍字符串的创建方式、基本特性、访问技巧以及常见的基本操作。
1. 字符串的定义与创建
字符串可以用 单引号 '、双引号 " 或 三引号 ''' / """ 括起来。
# 单引号
s1 = 'hello'
# 双引号
s2 = "world"
# 三引号（支持多行）
s3 = '''This is
a multi-line
string.'''
✔️ Python 中单引号和双引号作用相同，主要用于避免转义冲突。
2. 字符串是不可变对象
字符串是 不可变的（immutable）：创建后无法修改，只能重新赋值。
s = "hello"
# s[0] = 'H' # ❌ 错误！字符串不能直接修改
s = "Hello" # ✅ 只能重新赋值
3. 字符串的索引与切片
字符串可以看作字符的序列，可以通过索引或切片访问其部分内容。
s = "Python"
# 索引（从 0 开始）
print(s[0]) # P
print(s[-1]) # n（最后一个字符）
# 切片 [start:end:step]
print(s[0:2]) # Py（不包括 end）
print(s[::2]) # Pto（每隔1个）
print(s[::-1]) # nohytP（反转字符串）
✅ 切片非常强大，是字符串处理中不可或缺的工具。
4. 字符串的连接与重复
# 拼接字符串
a = "Hello"
b = "World"
c = a + " " + b
print(c) # Hello World
# 重复字符串
print("ha" * 3) # hahaha
5. 字符串的成员运算
s = "python"
print("p" in s) # True
print("z" not in s) # True
6. 字符串与类型转换
num = 123
text = str(num) # 数字转字符串
print("数字是：" + text)
# 也可以使用 f-string（推荐）
print(f"数字是：{num}")
🧠 小结
| 操作类型 | 常用方法 / 语法 |
|---|---|
| 创建字符串 | 'abc', "abc", '''abc''' |
| 索引 | s[0], s[-1] |
| 切片 | s[1:4], s[::-1] |
| 拼接与重复 | +, * |
| 判断是否存在 | in, not in |
| 类型转换 | str(x), f"{x}" |
（二）📘 字符串常见操作方法
Python 的字符串类型（str）内建了大量实用的方法，帮助我们完成查找、替换、对齐、大小写转换、格式化等各类文本处理任务。本节将系统讲解所有主流、实用的方法，并配合用例说明。
1. 大小写转换
| 方法 | 作用 |
|---|---|
.lower() |
转为小写 |
.upper() |
转为大写 |
.capitalize() |
首字母大写，其余小写 |
.title() |
每个单词首字母大写 |
.swapcase() |
大小写互换 |
s = "hello World"
print(s.lower()) # hello world
print(s.upper()) # HELLO WORLD
print(s.capitalize()) # Hello world
print(s.title()) # Hello World
print(s.swapcase()) # HELLO wORLD
2. 查找与判断
| 方法 | 功能 |
|---|---|
.find(sub) |
找到子串首次出现的位置（找不到返回 -1） |
.rfind(sub) |
从右侧开始查找 |
.index(sub) |
与 find 类似，但找不到抛出异常 |
.startswith(prefix) |
是否以某前缀开头 |
.endswith(suffix) |
是否以某后缀结尾 |
.in |
判断子串是否存在 |
s = "hello python"
print(s.find("py")) # 6
print(s.startswith("he")) # True
print(s.endswith("on")) # True
print("py" in s) # True
3. 删除空白符与字符清洗
| 方法 | 功能 |
|---|---|
.strip() |
删除两端空白符 |
.lstrip() |
删除左侧空白符 |
.rstrip() |
删除右侧空白符 |
.replace(old, new) |
替换子串 |
s = " hello world "
print(s.strip()) # "hello world"
s2 = "python,java,c"
print(s2.replace(",", " | ")) # python | java | c
4. 字符串对齐与填充
| 方法 | 说明 |
|---|---|
.center(width, char) |
居中填充 |
.ljust(width, char) |
左对齐填充 |
.rjust(width, char) |
右对齐填充 |
.zfill(width) |
用 0 填充左侧数字部分 |
print("hi".center(10, "-")) # ---hi-----
print("hi".ljust(10, ".")) # hi........
print("hi".rjust(10, "*")) # ********hi
print("42".zfill(5)) # 00042
5. 拆分与连接
| 方法 | 功能 |
|---|---|
.split(sep) |
拆分为列表 |
.rsplit(sep) |
从右拆分 |
.splitlines() |
拆分多行字符串 |
'sep'.join(list) |
用分隔符连接列表为字符串 |
s = "apple,banana,grape"
print(s.split(",")) # ['apple', 'banana', 'grape']
lines = "line1\nline2\nline3"
print(lines.splitlines()) # ['line1', 'line2', 'line3']
words = ['one', 'two', 'three']
print("-".join(words)) # one-two-three
6. 内容判断类方法（返回布尔值）
| 方法 | 判断类型 |
|---|---|
.isalpha() |
是否全字母 |
.isdigit() |
是否全数字 |
.isalnum() |
是否全是字母或数字 |
.isspace() |
是否全是空白符 |
.isupper() |
是否全为大写 |
.islower() |
是否全为小写 |
.istitle() |
是否符合标题规范（首字母大写） |
print("abc".isalpha()) # True
print("123".isdigit()) # True
print("abc123".isalnum()) # True
print(" ".isspace()) # True
7. 高级字符串格式化（f-string）
name = "Alice"
age = 30
# 推荐方式：f-string（Python 3.6+）
print(f"{name} is {age} years old.") # Alice is 30 years old
# 老式：format()
print("{} is {} years old.".format(name, age))
# 占位对齐控制
print(f"|{name:^10}|{age:>3}|") # 居中+右对齐
8. 转义字符与原始字符串
| 字符 | 含义 |
|---|---|
\n |
换行 |
\t |
制表符 |
\\ |
反斜杠 |
r"" |
原始字符串，不转义 |
print("hello\nworld") # 换行
print(r"c:\new\folder") # c:\new\folder
9. 其他实用技巧
长字符串拼接：
s = ( "This is a very long string " "split across multiple lines " "but still valid." )字符串比较支持
<,>,==等字典序对比：print("apple" < "banana") # True
🧠 小结：常用字符串方法分类对照表
| 类型 | 常用方法 |
|---|---|
| 查找判断 | find(), startswith(), in |
| 修改清洗 | strip(), replace() |
| 大小写处理 | lower(), capitalize() |
| 对齐填充 | center(), zfill() |
| 格式化 | f"", format() |
| 判断内容 | isdigit(), isalpha() |
| 分割拼接 | split(), join() |
| 其他 | len(), 转义、比较等 |
（三）📘 字符串切片与索引
1. 字符串索引（正向索引 / 负向索引）
Python 字符串是序列类型，每个字符都有对应的索引位置。我们可以通过索引访问字符串中的单个字符。
📍 正向索引（从 0 开始）
s = "python"
print(s[0]) # p
print(s[1]) # y
print(s[5]) # n
| 字符 | p | y | t | h | o | n |
|---|---|---|---|---|---|---|
| 索引 | 0 | 1 | 2 | 3 | 4 | 5 |
📍 负向索引（从 -1 开始，表示从右往左）
s = "python"
print(s[-1]) # n
print(s[-2]) # o
print(s[-6]) # p
| 字符 | p | y | t | h | o | n |
|---|---|---|---|---|---|---|
| 索引 | -6 | -5 | -4 | -3 | -2 | -1 |
🧠 注意：
超出索引范围（如
s[10]）会抛出IndexError。字符串是 不可变对象，不能通过索引修改某个字符。
2. 字符串切片（[start:stop:step]）
切片（slice）是从字符串中提取子串的一种方式，语法格式为：
s[start : stop : step]
start：起始索引（包含）stop：终止索引（不包含）step：步长（默认为 1）
🎯 基础切片
s = "Hello, Python!"
print(s[0:5]) # Hello
print(s[7:13]) # Python
print(s[:5]) # Hello（从头开始）
print(s[7:]) # Python!（直到结尾）
🎯 使用负数索引切片
s = "abcdefg"
print(s[-4:-1]) # def
print(s[-7:-4]) # abc
🎯 添加步长（step）
s = "0123456789"
print(s[::2]) # 02468（每两个字符取一个）
print(s[1::3]) # 147（从索引 1 开始，每隔 3 个取）
🎯 反向切片（步长为负数）
s = "abcdef"
print(s[::-1]) # fedcba（字符串反转）
print(s[-1:-7:-1]) # fedcba（等同上行）
🧠 切片边界记忆口诀
包头不包尾：起始位置包含，结束位置不包含。
步长方向一致：正数步长从左到右，负数步长从右到左。
索引可以为负：负索引从末尾向前数。
3. 字符串的遍历
遍历字符串可以逐个访问其字符，常用于统计、查找、生成新字符串等任务。
🎯 基础遍历
s = "hello"
for c in s:
print(c)
输出：
h
e
l
l
o
🎯 带索引遍历（推荐：使用 enumerate）
s = "hello"
for index, char in enumerate(s):
print(f"{index} -> {char}")
输出：
0 -> h
1 -> e
2 -> l
3 -> l
4 -> o
🔎 经典应用场景小结
| 场景 | 示例 |
|---|---|
| 提取子串 | s[3:7] |
| 字符串反转 | s[::-1] |
| 判断回文 | s == s[::-1] |
| 截取前缀/后缀 | s[:3] 或 s[-3:] |
| 每隔一个字符取 | s[::2] |
（四）📘 字符串格式化
Python 提供了三种主要的字符串格式化方式：
%占位符格式化（经典写法）str.format()方法格式化（兼容写法）f-string 格式化（推荐方式，Python 3.6+）
1.% 占位符格式化（C 风格）
这是最早期的格式化方式，语法类似于 C 语言：
name = "Alice"
age = 25
print("My name is %s and I am %d years old." % (name, age))
| 占位符 | 含义 |
|---|---|
%s |
字符串 |
%d |
整数 |
%f |
浮点数（默认小数点后 6 位） |
%.2f |
浮点数保留 2 位小数 |
🧠 缺点：可读性差、容易出错，不推荐用于新代码。
2.str.format() 方法格式化
引入于 Python 2.7 / 3.0，支持位置参数、关键字参数，更灵活：
name = "Alice"
age = 25
print("My name is {} and I am {} years old.".format(name, age))
🎯 支持 位置参数 / 关键字参数
print("Hello, {0}. You are {1}.".format("Bob", 30))
print("Hello, {name}. You are {age}.".format(name="Bob", age=30))
🎯 支持格式控制
pi = 3.1415926
print("Pi is {:.2f}".format(pi)) # Pi is 3.14
🧠 缺点：写法较冗长，推荐 f-string 替代。
3.f-string 格式化（Python 3.6+，推荐✅）
最现代、最简洁的格式化方式，代码更清晰，推荐作为首选写法。
name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")
🎯 支持表达式
a = 5
b = 3
print(f"{a} + {b} = {a + b}")
🎯 支持格式化控制
pi = 3.1415926
print(f"Pi rounded to 2 digits: {pi:.2f}")
🎯 与函数、数据结构结合
user = {"name": "Bob", "score": 88}
print(f"{user['name']} scored {user['score']}")
🧪 三种方式对比
| 特性 | % 格式化 |
str.format() |
f-string |
|---|---|---|---|
| 可读性 | ❌ | ✅ | ✅✅✅ |
| 功能强大 | 一般 | ✅✅ | ✅✅✅ |
| 写法简洁 | 一般 | ❌ | ✅✅✅ |
| 推荐程度 | ❌ 不推荐 | ✅ 过渡用法 | ✅✅✅ 首选 |
📝 小结一下吧
新代码推荐 f-string，语法简洁、表达能力强。
str.format()适用于兼容旧版本 Python。%占位符方式适合了解，不建议用于正式项目中。
🎯 想练点格式化相关的习题？还是我们继续进入 第 5 节 字符串常用方法详解？