【Python-Day 6】从零精通 Python 运算符（上）：算术、赋值与比较运算全解析

最新推荐文章于 2025-05-01 23:36:42 发布

吴师兄大模型

最新推荐文章于 2025-05-01 23:36:42 发布

阅读量1.1k

点赞数 26

分类专栏： Python从入门到精通：全栈开发者必修课文章标签： python 开发语言运算符人工智能 ai pytorch 深度学习

本文链接：https://blog.csdn.net/Kiradzy/article/details/147567806

版权

Python从入门到精通：全栈开发者必修课专栏收录该内容

46 篇文章

订阅专栏

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
 02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
 03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
 04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
 05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘

PyTorch系列文章目录

机器学习系列文章目录

Python系列文章目录

01-【Python-Day 1】告别编程恐惧：轻松掌握 Python 安装与第一个程序的 6 个步骤
 02-【Python-Day 2】掌握Python基石：变量、内存、标识符及int/float/bool数据类型
 03-【Python-Day 3】玩转文本：字符串(String)基础操作详解 (上)
04-【Python-Day 4】玩转文本：Python 字符串常用方法深度解析 (下篇)
05-【Python-Day 5】Python 格式化输出实战：%、format()、f-string 对比与最佳实践
06- 【Python-Day 6】从零精通 Python 运算符（上）：算术、赋值与比较运算全解析

前言

大家好！欢迎来到 Python 学习之旅的第六天。在前几天的学习中，我们已经掌握了 Python 的基本环境搭建、变量、基本数据类型以及强大的字符串操作。今天，我们将深入探讨编程中最基本也是最核心的操作——运算。计算机程序的本质就是处理数据，而运算符正是执行这些处理操作的“工具”。它们就像我们数学中的加减乘除，是构建复杂逻辑和算法的基石。

本篇文章是 Python 运算符系列的（上）篇，我们将重点聚焦于三类最常用、最基础的运算符：算术运算符、赋值运算符和比较运算符。理解它们的工作原理和使用方法，对于后续学习条件判断、循环控制等至关重要。让我们一起揭开 Python 运算的神秘面纱吧！

一、算术运算符：执行数学计算

1.1 什么是算术运算符？

算术运算符（Arithmetic Operators）是我们最熟悉的运算符，它们用于执行基本的数学运算，如加、减、乘、除等。在 Python 中，这些运算符可以作用于数字类型（整数 int、浮点数 float），并返回运算结果。

想象一下，你要计算购物总价、平均分、或者游戏中角色的剩余血量，这些都离不开算术运算符。

1.2 常用算术运算符详解

Python 提供了丰富的算术运算符来满足不同的计算需求。下面我们逐一介绍：

1.2.1 加法 (`+`)

用于将两个数值相加。

# 示例：加法运算
num1 = 10
num2 = 5.5
result = num1 + num2

print(f"{num1} + {num2} = {result}")  # 输出：10 + 5.5 = 15.5
print(f"结果类型: {type(result)}")    # 输出：结果类型: <class 'float'>

注意：如果参与运算的数中包含浮点数，结果通常也是浮点数。

1.2.2 减法 (`-`)

用于计算两个数值的差。

# 示例：减法运算
a = 100
b = 30
difference = a - b

print(f"{a} - {b} = {difference}") # 输出：100 - 30 = 70
print(f"结果类型: {type(difference)}") # 输出：结果类型: <class 'int'>

1.2.3 乘法 (`*`)

用于计算两个数值的乘积。

# 示例：乘法运算
price = 19.9
quantity = 3
total_cost = price * quantity

print(f"单价 {price} 元，数量 {quantity} 个，总价：{total_cost}") # 输出：单价 19.9 元，数量 3 个，总价：59.7
print(f"结果类型: {type(total_cost)}") # 输出：结果类型: <class 'float'>

补充: * 运算符还可以用于字符串和列表的重复，我们在之前的字符串章节已经见过。

1.2.4 除法 (`/`)

用于计算两个数值相除的结果。特别注意：在 Python 3 中，/ 运算符总是返回一个浮点数结果，即使两个数可以整除。

# 示例：除法运算
dividend = 10
divisor = 3
quotient_float = dividend / divisor

dividend2 = 10
divisor2 = 2
quotient_float2 = dividend2 / divisor2

print(f"{dividend} / {divisor} = {quotient_float}")     # 输出：10 / 3 = 3.3333333333333335
print(f"结果类型: {type(quotient_float)}")   # 输出：结果类型: <class 'float'>

print(f"{dividend2} / {divisor2} = {quotient_float2}")  # 输出：10 / 2 = 5.0
print(f"结果类型: {type(quotient_float2)}") # 输出：结果类型: <class 'float'>

常见问题：

除以零：尝试用任何数字除以 0 会导致 ZeroDivisionError 错误。在实际编程中需要避免这种情况，例如通过条件判断检查除数是否为零。
```
denominator = 0
if denominator != 0:
    result = 10 / denominator
else:
    print("错误：除数不能为零！")
```

1.2.5 取模 / 求余 (`%`)

用于计算两个数相除后的余数。

# 示例：取模运算
total_items = 17
items_per_box = 5
remainder = total_items % items_per_box

print(f"{total_items} 个物品，每盒装 {items_per_box} 个，剩余：{remainder} 个") # 输出：17 个物品，每盒装 5 个，剩余：2 个

# 判断奇偶数
num = 8
if num % 2 == 0:
    print(f"{num} 是偶数") # 输出：8 是偶数
else:
    print(f"{num} 是奇数")

应用场景：判断奇偶性、周期性操作（如每隔 N 个元素处理一次）、获取数字的最后几位等。

1.2.6 幂运算 / 指数 (`**`)

用于计算一个数的幂次方。x ** y 表示计算 x 的 y 次方 ( $x^y$ )。

# 示例：幂运算
base = 2
exponent = 10
power_result = base ** exponent

print(f"{base} 的 {exponent} 次方是：{power_result}") # 输出：2 的 10 次方是：1024

# 计算平方根 (0.5 次方)
num = 9
sqrt_result = num ** 0.5
print(f"{num} 的平方根是：{sqrt_result}") # 输出：9 的平方根是：3.0

1.2.7 整除 / 向下取整 (`//`)

用于计算两个数相除后的整数部分，并向下取整（取小于或等于结果的最大整数）。

# 示例：整除运算
dividend = 17
divisor = 5
integer_quotient = dividend // divisor

dividend2 = -17
divisor2 = 5
integer_quotient2 = dividend2 // divisor2

print(f"{dividend} // {divisor} = {integer_quotient}")   # 输出：17 // 5 = 3
print(f"结果类型: {type(integer_quotient)}") # 输出：结果类型: <class 'int'>

print(f"{dividend2} // {divisor2} = {integer_quotient2}") # 输出：-17 // 5 = -4 (注意是向下取整)

# 对比普通除法
print(f"{dividend} / {divisor} = {dividend / divisor}")   # 输出：17 / 5 = 3.4
print(f"{dividend2} / {divisor2} = {dividend2 / divisor2}") # 输出：-17 / 5 = -3.4

对比 / 与 //:

/：总是返回浮点数结果，精确表示除法。
//：返回整除后的整数部分，并且是向下取整。

应用场景：当你只需要知道一个数能被另一个数整除多少次，而不需要小数部分时，例如计算需要多少个完整的箱子来装物品。

1.3 运算符优先级初探

和小学数学一样，Python 中的运算符也有优先级。例如，乘法和除法的优先级高于加法和减法。

result = 2 + 3 * 4  # 先计算 3 * 4 = 12，再计算 2 + 12 = 14
print(f"2 + 3 * 4 = {result}") # 输出：14

result_with_parentheses = (2 + 3) * 4 # 使用括号改变优先级，先算 2 + 3 = 5，再算 5 * 4 = 20
print(f"(2 + 3) * 4 = {result_with_parentheses}") # 输出：20

我们将在下一篇文章（运算符下篇）中详细讨论所有运算符的优先级规则。目前只需了解，可以使用圆括号 () 来明确指定运算顺序。

1.4 实践场景

财务计算：计算利息、税费、总成本、利润率等。
数据分析：计算平均值、标准差、数据归一化等。
游戏开发：计算得分、伤害值、物体移动距离、碰撞检测等。
工程计算：物理公式计算、单位换算等。

二、赋值运算符：给变量赋予新值

2.1 什么是赋值运算符？

赋值运算符（Assignment Operators）用于将运算符右侧的值（或表达式的结果）赋给左侧的变量。最基本、最核心的赋值运算符就是等号 =。

# 示例：基本赋值
name = "Alice"      # 将字符串 "Alice" 赋给变量 name
age = 30          # 将整数 30 赋给变量 age
pi_approx = 3.14  # 将浮点数 3.14 赋给变量 pi_approx
is_student = False # 将布尔值 False 赋给变量 is_student

2.2 基本赋值 (`=`)

这是最常用的赋值方式，直接将右边的值存入左边的变量所指向的内存空间。

2.3 复合赋值运算符

除了基本的 =，Python 还提供了一系列复合赋值运算符（Compound Assignment Operators），它们将算术运算和赋值操作合并为一个步骤，使代码更简洁。

其通用形式是 变量运算= 表达式，等价于 变量 = 变量运算表达式。

2.3.1 常见的复合赋值运算符

运算符	等价于	描述
`+=`	`x = x + y`	加法赋值
`-=`	`x = x - y`	减法赋值
`*=`	`x = x * y`	乘法赋值
`/=`	`x = x / y`	除法赋值
`%=`	`x = x % y`	取模赋值
`**=`	`x = x ** y`	幂赋值
`//=`	`x = x // y`	整除赋值

2.3.2 示例与优势

# 示例：复合赋值运算符
count = 5
print(f"初始 count: {count}")

# count = count + 2 的简写
count += 2
print(f"执行 count += 2 后: {count}") # 输出：7

score = 100
print(f"初始 score: {score}")

# score = score - 10 的简写
score -= 10
print(f"执行 score -= 10 后: {score}") # 输出：90

price = 5
print(f"初始 price: {price}")

# price = price * 1.2 的简写 (涨价20%)
price *= 1.2
print(f"执行 price *= 1.2 后: {price}") # 输出：6.0

items = 25
print(f"初始 items: {items}")

# items = items // 10 的简写 (计算有多少个完整的十)
items //= 10
print(f"执行 items //= 10 后: {items}") # 输出：2

优势：

简洁性：代码更短，更易读。
效率：在某些情况下（尤其对于可变对象的操作），可能比分开写运算和赋值稍微高效一点（变量名只需查找一次）。

2.4 链式赋值与解包赋值 (简单了解)

Python 还支持一些更高级的赋值方式：

链式赋值：可以将同一个值赋给多个变量。

x = y = z = 100
print(x, y, z) # 输出：100 100 100

解包赋值：可以将一个序列（如元组或列表）中的元素同时赋给多个变量（后续讲列表和元组时会详细介绍）。

point = (10, 20)
x_coord, y_coord = point # 将元组 point 中的元素分别赋给 x_coord 和 y_coord
print(f"X: {x_coord}, Y: {y_coord}") # 输出：X: 10, Y: 20

三、比较运算符：判断值之间的关系

3.1 什么是比较运算符？

比较运算符（Comparison Operators），也称为关系运算符（Relational Operators），用于比较两个值之间的关系，例如判断它们是否相等、哪个更大等。

3.2 核心特性：返回布尔值

比较运算符最关键的特点是，它们的运算结果永远是一个布尔值（True 或 False）。这个特性使得比较运算符成为构建条件判断（if 语句）和循环控制（while 循环）的基础。

3.3 常用比较运算符详解

运算符	描述	示例 (`a=5`, `b=10`)	结果
`==`	等于：检查两边的值是否相等	`a == b`	`False`
`!=`	不等于：检查两边的值是否不等	`a != b`	`True`
`>`	大于：检查左边的值是否大于右边的值	`a > b`	`False`
`<`	小于：检查左边的值是否小于右边的值	`a < b`	`True`
`>=`	大于等于：检查左边的值是否大于或等于右边的值	`a >= 5`	`True`
`<=`	小于等于：检查左边的值是否小于或等于右边的值	`b <= 10`	`True`

3.3.1 等于 (`==`)

检查两个操作数的值是否相等。

# 示例：等于运算
x = 10
y = 10.0
z = "10"

print(f"{x} == {y}: {x == y}")   # 输出：10 == 10.0: True (数值上相等)
print(f"{x} == {z}: {x == z}")   # 输出：10 == "10": False (类型不同，值也不同)

常见陷阱：

混淆 = 和 ==: 一个常见的初学者错误是将赋值运算符 = 当作比较运算符 == 使用。= 用于赋值，== 用于比较。在需要判断相等性的地方（如 if 语句）误用 = 会导致语法错误或逻辑错误。
```
# 错误示例 (通常会导致 SyntaxError 或意想不到的行为)
# if x = 5:
#    print("x is 5")

# 正确示例
if x == 5:
    print("x is 5")
```

3.3.2 不等于 (`!=`)

检查两个操作数的值是否不相等。

# 示例：不等于运算
score1 = 90
score2 = 85

print(f"{score1} != {score2}: {score1 != score2}") # 输出：90 != 85: True

name1 = "Bob"
name2 = "Bob"
print(f"'{name1}' != '{name2}': {name1 != name2}") # 输出：'Bob' != 'Bob': False

3.3.3 大于 (`>`)

检查左操作数的值是否严格大于右操作数。

# 示例：大于运算
age = 20
required_age = 18

print(f"年龄 {age} > 要求年龄 {required_age}: {age > required_age}") # 输出：年龄 20 > 要求年龄 18: True

3.3.4 小于 (`<`)

检查左操作数的值是否严格小于右操作数。

# 示例：小于运算
temperature = -5
freezing_point = 0

print(f"温度 {temperature} < 冰点 {freezing_point}: {temperature < freezing_point}") # 输出：温度 -5 < 冰点 0: True

3.3.5 大于等于 (`>=`)

检查左操作数的值是否大于或等于右操作数。

# 示例：大于等于运算
player_level = 10
unlock_level = 10

print(f"玩家等级 {player_level} >= 解锁等级 {unlock_level}: {player_level >= unlock_level}") # 输出：玩家等级 10 >= 解锁等级 10: True

3.3.6 小于等于 (`<=`)

检查左操作数的值是否小于或等于右操作数。

# 示例：小于等于运算
discount_threshold = 100
purchase_amount = 99.5

print(f"购买金额 {purchase_amount} <= 优惠门槛 {discount_threshold}: {purchase_amount <= discount_threshold}") # 输出：购买金额 99.5 <= 优惠门槛 100: True

3.4 不同类型间的比较

数字类型：整数和浮点数可以直接比较大小。

字符串：字符串比较是按照字典序（lexicographical order）进行的，逐个比较字符的 Unicode 编码值。

print(f"'apple' < 'banana': {'apple' < 'banana'}") # 输出：'apple' < 'banana': True
print(f"'Apple' < 'apple': {'Apple' < 'apple'}")   # 输出：'Apple' < 'apple': True (大写字母编码值小于小写字母)
print(f"'10' > '5': {'10' > '5'}")             # 输出：'10' > '5': False (字符串比较，'1' < '5')

不同类型：在 Python 3 中，大多数不同类型之间（如数字和字符串）直接进行 >、<、>=、<= 比较会引发 TypeError。== 和 != 比较不同类型通常直接返回 False 和 True。

3.5 实践场景

条件判断：在 if, elif, else 语句中根据比较结果执行不同的代码块。

score = 75
if score >= 60:
    print("及格")
else:
    print("不及格")

循环控制：在 while 循环中决定循环是否继续。

attempts = 0
max_attempts = 3
while attempts < max_attempts:
    print(f"尝试次数: {attempts + 1}")
    # 做一些尝试...
    attempts += 1

数据筛选：从列表中筛选出满足特定条件的元素。
输入验证：检查用户输入的值是否在有效范围内。

四、总结

今天我们系统学习了 Python 中最基础的三类运算符，它们是进行计算和判断的基础：

算术运算符：
- 用于执行基本的数学计算 (+, -, *, /, %, **, //)。
- / 执行浮点除法，// 执行整除（向下取整）。
- % 用于获取余数，在判断奇偶、周期性问题中常用。
- 注意除以零错误 (ZeroDivisionError) 和运算符优先级（可用括号控制）。
赋值运算符：
- = 是最基本的赋值方式，用于给变量存值。
- 复合赋值运算符 (+=, -= 等) 提供了“运算+赋值”的简洁写法。
比较运算符：
- 用于比较两个值的大小或相等性 (==, !=, >, <, >=, <=)。
- 核心特性：结果永远是布尔值 True 或 False。
- 是 if 语句和 while 循环进行决策的关键。
- 注意：区分赋值 = 和比较 ==。

掌握这些运算符是编写任何有意义的 Python 程序的前提。在下一篇文章【Python-Day 7】中，我们将继续探索 Python 运算符的世界，学习逻辑运算符 (and, or, not)、成员运算符 (in, not in)、身份运算符 (is, is not) 以及完整的运算符优先级规则。敬请期待！