Python基本运算符
🐹今日诗词:相恨不如潮有信，相思始觉海非深🐹
⛳️点赞 ☀️收藏⭐️关注💬卑微小博主🙏
⛳️点赞 ☀️收藏⭐️关注💬卑微小博主🙏
目录
🧮 Python中的算术运算符
1. 基本算术运算符
2. 整数除法vs浮点数除法（你提到不太清楚的部分）
2.1 浮点除法 /
2.2 整数除法 //
3. 幂运算 **
4. 取余运算 %
5. 复合赋值运算符
6. 运算符优先级
7. 数值类型和运算结果
实践检验
🔍 Python中的关系运算符
1. 基本关系运算符
2. 比较不同数据类型的值
2.1 数值比较
2.2 字符串比较
2.3 不同类型的比较
2.4 None的比较
3. 链式比较
4. 身份运算符 is 和 is not
5. 成员运算符 in 和 not in
实践检验
🎯 Python关系运算符
📚 一、基础概念
📊 Python关系运算符一览表
🎯 特殊比较运算符
1️⃣ 大于运算符 (>)
2️⃣ 小于运算符 (<)
3️⃣ 大于等于运算符 (>=)
4️⃣ 小于等于运算符 (<=)
5️⃣ 等于运算符 (==)
6️⃣ 不等于运算符 (!=)
💡 进阶技巧
1. 链式比较（Python独家！）
2. 比较运算符的优先级
3. 自定义对象的比较
🎯Python逻辑运算符
📊 Python逻辑运算符总览
1️⃣ and 运算符（逻辑与）
基本概念
🎯 and的"短路"特性
2️⃣ or 运算符（逻辑或）
基本概念
🎯 or的"短路"特性
3️⃣ not 运算符（逻辑非）
基本概念
🎨 组合使用逻辑运算符
优先级规则
💡 Python中的"真值"和"假值"
什么算False？
什么算True？
📝 小测验时间！
🎯 赋值运算符
1. 基础赋值运算符 =
2. 复合赋值运算符（简写形式）
3. Python特色赋值技巧
4. 海象运算符 := (Python 3.8+)
⚠️ 注意事项
1. 赋值 vs 相等判断
2. 可变对象的陷阱
3. 赋值运算符不能用于字面量
💡 记忆技巧
🎪 快速练习
美图分享
🧮 Python中的算术运算符
1. 基本算术运算符
让我们来完整地介绍它们：
| 运算符 | 名称 | 示例 | 结果 |
|
| 加法 |
|
|
|
| 减法 |
|
|
|
| 乘法 |
|
|
|
| 除法 |
|
|
|
| 取余(模) |
|
|
|
| 整除(地板除) |
|
|
|
| 幂运算 |
|
|
2. 整数除法vs浮点数除法（你提到不太清楚的部分）
在Python中，除法运算有两种形式：
2.1 浮点除法 /
使用单斜杠 / 进行的除法运算总是返回一个浮点数，即使两个操作数都是整数且能整除：
print(10 / 5) # 输出: 2.0 (注意是浮点数)
print(5 / 2) # 输出: 2.52.2 整数除法 //
使用双斜杠 // 进行的除法运算会执行"地板除"，即向下取整，返回商的整数部分：
print(10 // 5) # 输出: 2
print(5 // 2) # 输出: 2
print(5 // 3) # 输出: 1
print(-5 // 3) # 输出: -2 (注意负数的向下取整)当操作数中有浮点数时，整数除法的结果也会是浮点数，但仍然执行向下取整：
print(5.0 // 2) # 输出: 2.0
print(5 // 2.0) # 输出: 2.03. 幂运算 **
正如你所理解的，幂运算符 ** 用于计算一个数的多少次方：
print(2 ** 3) # 输出: 8 (2的3次方)
print(5 ** 2) # 输出: 25 (5的平方)
print(10 ** 0) # 输出: 1 (任何数的0次方都是1)
print(4 ** 0.5) # 输出: 2.0 (4的平方根)4. 取余运算 %
取余运算符返回除法运算后的余数：
print(10 % 3) # 输出: 1 (10除以3余1)
print(20 % 7) # 输出: 6 (20除以7余6)
print(15 % 5) # 输出: 0 (15能被5整除，余数为0)取余的一个常见应用是判断一个数是否能被另一个数整除：
if number % 2 == 0:print("这是一个偶数")
else:print("这是一个奇数")5. 复合赋值运算符
Python还提供了复合赋值运算符，将算术运算和赋值合并在一起：
x = 10
x += 5 # 等同于 x = x + 5，结果: x = 15
x -= 3 # 等同于 x = x - 3，结果: x = 12
x *= 2 # 等同于 x = x * 2，结果: x = 24
x /= 6 # 等同于 x = x / 6，结果: x = 4.0
x //= 2 # 等同于 x = x // 2，结果: x = 2.0
x %= 1 # 等同于 x = x % 1，结果: x = 0.0
x **= 3 # 等同于 x = x ** 3，结果: x = 0.06. 运算符优先级
Python中的运算符有不同的优先级，影响表达式的计算顺序：
1. ** (最高优先级)
2. *, /, //, %
3. +, - (最低优先级)
如果不确定或想要改变计算顺序，可以使用括号：
print(2 + 3 * 4) # 输出: 14 (先计算 3 * 4 = 12，再 2 + 12 = 14)
print((2 + 3) * 4) # 输出: 20 (先计算 2 + 3 = 5，再 5 * 4 = 20)7. 数值类型和运算结果
不同类型的数值进行运算时，Python会按照以下规则决定结果类型：
- 如果任一操作数是复数，结果是复数
- 否则，如果任一操作数是浮点数，结果是浮点数
- 否则，结果是整数
print(5 + 3) # 输出: 8 (整数)
print(5 + 3.0) # 输出: 8.0 (浮点数)
print(5 / 3) # 输出: 1.6666666666666667 (浮点数，即使操作数都是整数)实践检验
让我们来做个小练习，确保你理解了这些内容：
- 计算 17 除以 5 的商和余数。
- 计算 2 的 10 次方。
- 如果 x = 10，使用复合赋值运算符将 x 的值增加 5，然后乘以 2，最后除以 3 并取整。
请尝试回答这些问题，我们一起来巩固所学知识！🚀
🔍 Python中的关系运算符
1. 基本关系运算符
Python中的关系运算符用于比较两个值，结果总是返回布尔值（True或False）：
| 运算符 | 描述 | 示例 | 结果 |
|
| 等于 |
|
|
|
| 不等于 |
|
|
|
| 大于 |
|
|
|
| 小于 |
|
|
|
| 大于或等于 |
|
|
|
| 小于或等于 |
|
|
需要注意的是，=是赋值运算符，而==是相等比较运算符，这是初学者容易混淆的地方。
x = 5 # 赋值运算，将5赋值给变量x
x == 5 # 比较运算，检查x是否等于5，返回True2. 比较不同数据类型的值
2.1 数值比较
不同数值类型（整数、浮点数、复数）之间可以直接比较：
print(5 == 5.0) # True - 整数和浮点数可以相等
print(10 > 9.9) # True
print(3 < 3.1) # True2.2 字符串比较
字符串按照字典顺序（lexicographically）比较，也就是按照Unicode编码的顺序：
print("apple" < "banana") # True - 'a'在'b'之前
print("apple" < "Apple") # False - 大写字母在小写字母之前
print("123" < "45") # True - '1'在'4'之前2.3 不同类型的比较
在Python 3中，不同类型的对象通常不能直接比较（除了数值类型）：
# 在Python 3中这些会引发TypeError
print(5 < "5") # TypeError: '<' not supported between instances of 'int' and 'str'
print(True > "False") # TypeError: '>' not supported between instances of 'bool' and 'str'但是，==和!=可以比较任何类型的对象：
print(5 == "5") # False - 不同类型的对象不相等
print(True != "True") # True - 不同类型的对象不相等2.4 None的比较
None只等于None，不等于任何其他值：
print(None == None) # True
print(None == 0) # False
print(None == "") # False
print(None == False) # False3. 链式比较
Python支持链式比较，这是一个非常方便的特性：
x = 5
print(1 < x < 10) # True - 等同于 1 < x and x < 10
print(10 > x >= 5) # True - 等同于 10 > x and x >= 5
print(1 <= x <= 5 <= 10) # True - 多重比较这使得代码更加简洁易读，特别是在检查一个值是否在某个范围内时。
4. 身份运算符 is 和 is not
虽然不是严格意义上的关系运算符，但is和is not用于比较对象的身份（是否是同一个对象）：
a = [1, 2, 3]
b = [1, 2, 3]
c = aprint(a == b) # True - 内容相同
print(a is b) # False - 不是同一个对象
print(a is c) # True - 是同一个对象is比较的是对象的身份（内存地址），而==比较的是对象的值。
对于小的整数和短字符串，Python可能会重用对象（这是一种优化），所以is的结果可能会让人困惑：
x = 5
y = 5
print(x is y) # 通常是True，但这取决于Python的实现a = "hello"
b = "hello"
print(a is b) # 通常是True，但这取决于Python的实现因此，最好只在比较对象与None时使用is：
x = None
if x is None:print("x是None")5. 成员运算符 in 和 not in
成员运算符用于检查一个值是否存在于序列中（如字符串、列表、元组、集合、字典）：
fruits = ["apple", "banana", "cherry"]
print("apple" in fruits) # True
print("orange" in fruits) # False
print("orange" not in fruits) # Truemessage = "Hello, World!"
print("Hello" in message) # True
print("hello" in message) # False - 大小写敏感person = {"name": "Alice", "age": 30}
print("name" in person) # True - 检查键
print("Alice" in person) # False - 不检查值实践检验
让我们来做个小练习，确保你理解了这些内容：
1. 如何检查一个数字是否在1到100之间（包括1和100）？
2. 如何检查一个字符串是否不包含空格？
3. 如何判断一个变量既不是None也不是空字符串？
请尝试回答这些问题，我们一起来巩固所学知识！🚀
🎯 Python关系运算符
📚 一、基础概念
关系运算符（也叫比较运算符）是用来比较两个值之间关系的运算符，返回结果永远是布尔值（True或False）。
# 关系运算符的本质
result = 5 > 3 # result的值是True，类型是bool
print(type(result)) # <class 'bool'>📊 Python关系运算符一览表
| 运算符 | 名称 | 示例 | 结果 | 说明 |
| > | 大于 |
| True | 左边大于右边返回True |
| < | 小于 |
| True | 左边小于右边返回True |
| >= | 大于等于 |
| True | 左边大于或等于右边返回True |
| <= | 小于等于 |
| True | 左边小于或等于右边返回True |
| == | 等于 |
| True | 两边值相等返回True |
| != | 不等于 |
| True | 两边值不相等返回True |
🎯 特殊比较运算符
| 运算符 | 名称 | 示例 | 结果 | 说明 |
| is | 身份运算符 |
| - | 判断是否为同一对象（同一内存地址） |
| is not | 身份运算符 |
| - | 判断是否不是同一对象 |
| in | 成员运算符 |
| True | 判断元素是否在序列中 |
| not in | 成员运算符 |
| True | 判断元素是否不在序列中 |
1️⃣ 大于运算符 (>)
# 基本用法
print(10 > 5) # True - 数字比较
print(3.14 > 3) # True - 整数和浮点数可以比较
print('b' > 'a') # True - 字符串按字典序比较# 特殊情况
print(-5 > -10) # True - 负数比较：-5比-10大
print(True > False) # True - 布尔值比较：True(1) > False(0)# 实际应用
temperature = 38
if temperature > 37:print("发烧了！😷 该吃药了！")2️⃣ 小于运算符 (<)
# 基本用法
print(3 < 5) # True
print('apple' < 'banana') # True - 按字母顺序# 列表比较
print([1, 2] < [1, 3]) # True - 逐元素比较
print([1] < [1, 0]) # False - 第一个元素相等，看第二个# 实际应用
age = 16
if age < 18:print("未成年人，不能进入网吧！🚫")3️⃣ 大于等于运算符 (>=)
# 基本用法
print(5 >= 5) # True - 等于也满足条件
print(6 >= 5) # True - 大于也满足条件
print(4 >= 5) # False# 边界检查
score = 60
if score >= 60:print("恭喜及格！✅")# 链式比较（Python特色！）
if 0 <= score <= 100:print("分数有效！")4️⃣ 小于等于运算符 (<=)
# 基本用法
print(5 <= 5) # True
print(3 <= 5) # True
print(6 <= 5) # False# 范围判断
height = 180
if 170 <= height <= 185:print("身高适中！👍")# 字符串比较
if 'a' <= 'z':print("确实在字母表范围内！")5️⃣ 等于运算符 (==)
# 基本用法
print(5 == 5) # True
print(5 == 5.0) # True - 值相等即可，类型可以不同# ⚠️ 注意：赋值用=，比较用==
x = 5 # 赋值
if x == 5: # 比较print("x的值是5")# 容器比较
print([1, 2] == [1, 2]) # True - 内容相同
print({'a': 1} == {'a': 1}) # True - 字典内容相同# 浮点数陷阱！😱
print(0.1 + 0.2 == 0.3) # False！精度问题
# 解决方案：
import math
print(math.isclose(0.1 + 0.2, 0.3)) # True6️⃣ 不等于运算符 (!=)
# 基本用法
print(5 != 3) # True
print(5 != 5) # False# 类型检查
user_input = "123"
if user_input != "":print("用户输入了内容！")# 循环控制
password = ""
while password != "correct":password = input("请输入密码：")
print("密码正确！")💡 进阶技巧
1. 链式比较（Python独家！）
# 优雅的范围判断
age = 25
if 18 <= age <= 60:print("工作年龄！💼")# 等价于：
if age >= 18 and age <= 60:print("工作年龄！")# 多重链式
x, y, z = 1, 2, 3
print(x < y < z) # True
print(x < y > 0) # True - 相当于 x < y and y > 02. 比较运算符的优先级
# 比较运算符优先级低于算术运算符
print(5 + 3 > 7) # True - 先算5+3=8，再比较8>7# 但高于逻辑运算符
print(5 > 3 and 2 < 4) # True - 先比较，后逻辑运算# 使用括号让代码更清晰
print((5 + 3) > 7) # 推荐写法！3. 自定义对象的比较
class Student:def __init__(self, name, score):self.name = nameself.score = score# 定义等于比较def __eq__(self, other):return self.score == other.score# 定义小于比较def __lt__(self, other):return self.score < other.score# 使用
tom = Student("Tom", 85)
jerry = Student("Jerry", 90)
print(tom < jerry) # True - 比较分数
print(tom == jerry) # False怎么样？这次是不是清晰多了？😊 现在来几个小练习检验一下：
- True or False？
-
'10' > '2'的结果是？[1, 2, 3] == [1, 2, 3]的结果是？None is None的结果是？
- 写出表达式： 判断变量
x是否为0到100之间的偶数 - debug时间： 下面代码有什么问题？
if score = 100:print("满分！")- 实战应用： 写一个函数，判断用户输入的密码是否符合要求（长度8-16位）
来吧！让我看看你掌握得怎么样了！🚀
逻辑运算符可是编程中的"逻辑大师"！🧙♂️ 它们就像是程序中的"如果...并且...或者..."这样的连接词，让我们能够组合多个条件！
🎯Python逻辑运算符
📊 Python逻辑运算符总览
| 运算符 | 名称 | 示例 | 说明 | 类比 |
| and | 逻辑与 |
| 两个都为True才返回True | 且、并且、同时 |
| or | 逻辑或 |
| 至少一个为True就返回True | 或者、要么 |
| not | 逻辑非 |
| 取反，True变False，False变True | 不是、否定 |
1️⃣ and 运算符（逻辑与）
基本概念
# and：两个条件都满足才为True
print(True and True) # True - 两个都是True
print(True and False) # False - 有一个False
print(False and True) # False - 有一个False
print(False and False) # False - 两个都是False# 记忆口诀：and很严格，必须全对才给过！😤🎯 and的"短路"特性
# and有个聪明的特性：如果第一个条件是False，就不会检查第二个条件了！
def check_first():print("检查第一个条件")return Falsedef check_second():print("检查第二个条件")return True# 看看会输出什么？
result = check_first() and check_second()
# 只输出：检查第一个条件
# 因为第一个是False，and直接返回False，不检查第二个！2️⃣ or 运算符（逻辑或）
基本概念
# or：至少有一个为True就返回True
print(True or True) # True
print(True or False) # True - 有一个True就够了
print(False or True) # True - 有一个True就够了
print(False or False) # False - 两个都False才False# 记忆口诀：or很宽容，有个对的就给过！😊🎯 or的"短路"特性
# or也有短路特性：如果第一个条件是True，就不检查第二个了！
def check_easy():print("检查简单条件")return Truedef check_complex():print("检查复杂条件（很耗时）")return True# 把简单的条件放前面，可以提高效率！
result = check_easy() or check_complex()
# 只输出：检查简单条件3️⃣ not 运算符（逻辑非）
基本概念
# not：取反操作
print(not True) # False
print(not False) # True# not可以让逻辑更自然
is_student = True
if not is_student:print("需要购买全价票")
else:print("享受学生优惠！")🎨 组合使用逻辑运算符
优先级规则
# 优先级：not > and > or
# 但是！建议用括号让逻辑更清晰！# 不好的写法（容易混淆）：
if age >= 18 and is_student or is_teacher:print("可以进入")# 好的写法（清晰明了）：
if (age >= 18 and is_student) or is_teacher:print("可以进入")# 或者：
if age >= 18 and (is_student or is_teacher):print("可以进入")💡 Python中的"真值"和"假值"
什么算False？
# 以下值在布尔上下文中都是False：
print(bool(False)) # False
print(bool(0)) # False - 数字0
print(bool(0.0)) # False - 浮点数0.0
print(bool("")) # False - 空字符串
print(bool([])) # False - 空列表
print(bool(())) # False - 空元组
print(bool({})) # False - 空字典
print(bool(None)) # False - None# 记忆技巧：空的、零的、None都是False！什么算True？
# 除了上面的False值，其他都是True！
print(bool(True)) # True
print(bool(1)) # True
print(bool(-1)) # True - 非零数字都是True
print(bool("hello")) # True - 非空字符串
print(bool([1, 2])) # True - 非空列表
print(bool(" ")) # True - 注意！空格字符串是True！📝 小测验时间！
- 判断输出：
print(True and False or True) # 结果是？
print(not False and True) # 结果是？
print(False or not False) # 结果是？- 写出条件： 判断一个数是否在10-20之间（包含），但不能是15
- 改进代码： 下面的代码有什么问题？如何改进？
if score >= 90 and score <= 100:grade = "A"
if score >= 80 and score < 90:grade = "B"
if score >= 70 and score < 80:grade = "C"- 实战应用： 写一个函数，判断今天是否适合出门：
-
- 不下雨 且 (温度在15-28度之间 或 是周末)
- 或者 有重要约会
🎯 赋值运算符
1. 基础赋值运算符 =
# 简单赋值
x = 10
name = "Python"2. 复合赋值运算符（简写形式）
| 运算符 | 名称 | 例子 | 等价于 | 描述 |
|
| 赋值 |
|
| 把右操作数的值赋给左操作数。 |
|
| 加法赋值 |
|
| 把右操作数的值加到左操作数上，再赋给左操作数。 |
|
| 减法赋值 |
|
| 从左操作数中减去右操作数的值，再赋给左操作数。 |
|
| 乘法赋值 |
|
| 左操作数乘以右操作数的值，再赋给左操作数。 |
|
| 除法赋值 |
|
| 左操作数除以右操作数的值，再赋给左操作数。 |
|
| 取模赋值 |
|
| 左操作数对右操作数取模，再赋给左操作数。 |
|
| 整除赋值 |
|
| 左操作数对右操作数整除，再赋给左操作数。 |
|
| 幂赋值 |
|
| 左操作数的右操作数次方，再赋给左操作数。 |
3. Python特色赋值技巧
# 多重赋值
a = b = c = 0 # 三个变量都赋值为0# 多变量赋值（解包赋值）
x, y = 10, 20
name, age = "小明", 18# 交换变量（Python独特写法）
a, b = b, a # 不需要临时变量# 序列解包
first, *rest = [1, 2, 3, 4] # first=1, rest=[2,3,4]
*head, last = [1, 2, 3, 4] # head=[1,2,3], last=44. 海象运算符 := (Python 3.8+)
# 在表达式中赋值
if (n := len(data)) > 10:print(f"数据太长：{n}个元素")# while循环中使用
while (line := input()) != "quit":print(f"你输入了：{line}")⚠️ 注意事项
1. 赋值 vs 相等判断
x = 5 # 赋值（一个等号）
x == 5 # 判断相等（两个等号）2. 可变对象的陷阱
# ❌ 列表的链式赋值会指向同一对象
list1 = list2 = []
list1.append(1)
print(list2) # [1] 也被修改了！# ✅ 正确做法
list1 = []
list2 = []3. 赋值运算符不能用于字面量
# ❌ 错误
5 += 3
"hello" += "world"# ✅ 正确
x = 5
x += 3
message = "hello"
message += "world"💡 记忆技巧
- 复合赋值 = 运算 + 赋值
-
x += 1读作 "x 加等于 1"- 先做运算，再赋值回去
- 解包赋值看逗号
-
- 左右两边逗号数量要匹配
*号可以收集多余的值
- 海象运算符像表情
-
:=横着看像海象- 用于"边赋值边使用"
🎪 快速练习
# 1. 预测结果
x = 10
x += 5
x *= 2
x //= 3
print(x) # 结果是？# 2. 解包赋值
data = [1, 2, 3, 4, 5]
a, b, *c = data
# a=? b=? c=?# 3. 修复代码
score = 85
# 如何用一行代码实现：如果score>=60，grade="及格"，否则grade="不及格"美图分享
✨🎆谢谢你的阅读和耐心！祝愿你在编程的道路上取得更多的成功与喜悦！"🎆✨🎄
⭐️点赞收藏加关注，学习知识不迷路⭐️
🎉✔️💪🎉✔️💪🎉✔️💪🎉✔️💪🎉
👍😏⛳️点赞☀️收藏⭐️关注😏👍
👍😏⛳️点赞☀️收藏⭐️关注😏👍
👍😏⛳️点赞☀️收藏⭐️关注😏👍
🙆♂️🙆♂️🙆♂️🙆♂️🙆♂️🙆♂️🙆♂️🙆♂️🙆♂️🙆♂️🙆♂️🙆♂️🙆♂️