快速掌握Python编程基础

干货分享，感谢您的阅读！备注：本博客将自己初步学习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}") # 推荐的写法

✅ 小练习题

尝试自己编写代码练习以下问题：（后面我单独出一篇博客将答案附上）

1. 定义一个变量 temperature，存储 36.6，并使用 print() 输出 "体温: 36.6 摄氏度"。

2. 编写一个程序，提示用户输入姓名和年龄，并打印 "你好，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 = Falseprint(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 = 5print(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 → Trueprint(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) == Trueprint("名字有效")  
else:print("名字为空")

输出：

名字有效

✅ 小练习题

练习 1：布尔运算

判断以下表达式的结果：

• True and False or True

• not (False or True)

• (10 > 5) and (3 != 3)

练习 2：用户输入比较

让用户输入两个数字，比较它们的大小，并输出 "第一个数字更大" 或 "第二个数字更大"。

# 提示：使用 input() 和 if 语句

布尔值和逻辑判断是 条件判断和循环 的基础，熟练掌握它们后，代码将更加智能化！ 🚀

（二）🌟 条件判断（if 语句）

在编程中，我们经常需要根据不同条件来执行不同的代码。这就要用到 条件判断语句（if statement）。Python 中使用 if、elif 和 else 关键字来实现条件分支。

1. 基本 if 语句

语法结构：

if 条件:语句块

✅ 当“条件”为 True 时，语句块才会被执行。

示例：

age = 20if age >= 18:print("你已经成年了")

输出：

你已经成年了

2. if-else 结构（两分支选择）

用于处理“要么这样，要么那样”的情况。

语法结构：

if 条件:语句块1
else:语句块2

示例：

temperature = 15if temperature > 20:print("北京天气今天很暖和")
else:print("北京天气今天有点冷")

输出：

北京天气今天有点冷

3. if-elif-else 结构（多分支选择）

用于处理多个条件判断的情况（相当于“多项选择”）。

语法结构：

if 条件1:语句块1
elif 条件2:语句块2
elif 条件3:语句块3
else:默认语句块

示例：

score = 85if 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 = Trueif 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:breaki += 1

输出：1, 2, 3，然后退出循环

🔁 continue 语句（跳过当前迭代）

continue 用于跳过本次循环中剩下的语句，直接进入下一次判断。

i = 0
while i < 5:i += 1if i == 3:continueprint(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-1

• range(start, end)：start 到 end-1

• range(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:breakprint(i)

✅ continue：跳过当前迭代

用于跳过某些不符合条件的值。

for i in range(1, 6):if i % 2 == 0:continueprint(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 + bresult = 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 * xresult = square(5)
print(result)  # 输出: 25

函数 square 返回的是 x 的平方，调用后我们可以拿到这个结果并继续使用。

2. 返回多个值（元组）

Python 支持从一个函数中返回多个值，这些值实际上被打包成一个元组返回。

示例：

def get_name_and_age():name = "Alice"age = 30return name, agen, 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 / bprint(divide(10, 0))  # 输出: 除数不能为 0
print(divide(10, 2))  # 输出: 5.0

当 b 是 0 时，函数遇到第一个 return 后立即终止执行，不会继续往下运行。

5. 将返回值作为表达式使用

函数返回值可以被用在其他表达式或函数中，像这样：

def add(a, b):return a + bprint(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 节 字符串常用方法详解？