运算符是参与运算的符号。例如,+ 可以做加法,== 可以比较两个值是否相等,and 可以组合两个条件。
+
==
and
1price = 30 2quantity = 2 3 4total = price * quantity 5print(total)
这里的 * 是运算符,price 和 quantity 是操作数。Python 先根据运算符的规则计算右侧表达式,再把结果赋给 total。
*
price
quantity
total
运算符不只用于数字。字符串、列表、字典等对象也可以参与某些运算,但具体结果取决于对象支持的操作。
算术运算符用于做数学计算:
7 + 2
9
-
7 - 2
5
7 * 2
14
/
7 / 2
3.5
//
7 // 2
3
%
7 % 2
1
**
7 ** 2
49
01left = 7 02right = 2 03 04print(left + right) # 9 05print(left - right) # 5 06print(left * right) # 14 07print(left / right) # 3.5 08print(left // right) # 3 09print(left % right) # 1 10print(left ** right) # 49
/ 的结果总是普通除法结果,通常是 float。// 表示向下取整的整除,不是简单地把小数部分截掉,负数参与运算时尤其要注意:
float
1print(7 // 2) # 3 2print(-7 // 2) # -4,结果向负无穷取整 3print(-7 % 2) # 1
% 经常用于判断奇偶、循环取值和按固定数量分组:
1number = 18 2 3if number % 2 == 0: 4 print("这是偶数") 5else: 6 print("这是奇数")
字符串也可以使用 + 拼接,使用 * 重复:
1title = "Python" + " 运算符" 2line = "-" * 20 3 4 5print(title) # Python 运算符 6print(line) # --------------------
但不同类型不能随意相加。数字和字符串拼接时,要使用 str() 或 f-string:
str()
1age = 18 2 3print("年龄:" + str(age)) 4print(f"年龄:{age}") 5# print("年龄:" + age) # TypeError
比较运算符用于判断两个值的关系。本篇使用内置数据类型进行比较,结果是布尔值 True 或 False:
True
False
age == 18
!=
age != 18
>
score > 60
<
score < 60
>=
score >= 60
<=
score <= 60
1score = 82 2 3print(score >= 60) # True 4print(score == 100) # False 5print(score != 0) # True
== 是比较运算,判断两边的值是否相等;= 是赋值运算,把右边的结果绑定给左边的变量:
=
1age = 18 2is_adult = age >= 18 3 4print(is_adult) # True
Python 不会像某些语言那样,把字符串 "18" 自动转换成数字 18 再比较。比较不同类型的值时,应该先判断它们是否真的具有可比较的含义:
"18"
18
1print(1 == 1.0) # True,整数和浮点数按数值比较 2print(1 == True) # True,bool 是 int 的特殊子类 3print(1 == "1") # False,不会把字符串自动转换成整数 4 5# print(1 < "2") # TypeError:数字和字符串不能直接比较大小
这里的 1 == 1.0 可以直接得到 True,是因为 Python 对兼容的数字类型使用数值语义进行比较;这不代表变量本身被永久转换成了另一种类型。True 和 False 也属于布尔类型,只是它们在 Python 的类型体系中分别对应数值 1 和 0,因此不建议把布尔值和数字混在业务条件中比较。
1 == 1.0
0
如果数据来自表单、命令行或 HTTP 请求,它通常先以字符串出现,需要显式转换后再比较:
1age_text = "18" 2age = int(age_text) 3 4if age >= 18: 5 print("已成年")
显式转换能让代码清楚表达意图,也能让无效输入在转换时及时暴露,而不是依赖不明显的类型规则。
字符串可以按字典顺序比较,列表也可以从前往后比较元素,但这类比较必须符合业务含义,不要只因为语法能够运行就认为结果一定符合需求:
1print("apple" < "banana") # True 2print([1, 2] == [1, 2]) # True
逻辑运算符用于组合多个条件:
or
not
1age = 20 2has_ticket = True 3 4can_enter = age >= 18 and has_ticket 5needs_help = not has_ticket 6 7print(can_enter) # True 8print(needs_help) # False
and 和 or 不一定返回 True 或 False。它们会短路求值,并返回参与判断的某个操作数:
1name = "" 2display_name = name or "匿名用户" 3 4print(display_name) # 匿名用户
这段代码中,name 是空字符串,在真值判断中为假,因此 or 返回右边的 "匿名用户"。
name
"匿名用户"
and 适合表达“前一个条件成立后,才继续检查后一个条件”:
1user = None 2 3if user is not None and user.get("name"): 4 print(user["name"])
当 user is not None 为假时,Python 不会继续执行 user.get("name"),因此不会因为对 None 调用方法而报错。
user is not None
user.get("name")
None
条件过多时,建议拆成多个有意义的变量,不要把一整段业务逻辑压缩成一行:
1is_adult = age >= 18 2has_valid_ticket = has_ticket 3 4if is_adult and has_valid_ticket: 5 print("允许进入")
最基本的赋值运算符是 =。它不是数学里的“相等”,而是把右边表达式的结果绑定给左边的变量。
Python 还提供了复合赋值运算符,把计算和重新赋值合在一起:
+=
value = value + 1
value += 1
-=
value = value - 1
value -= 1
*=
value = value * 2
value *= 2
/=
value = value / 2
value /= 2
//=
value = value // 2
value //= 2
%=
value = value % 2
value %= 2
**=
value = value ** 2
value **= 2
1count = 1 2 3count += 2 4print(count) # 3 5 6count *= 4 7print(count) # 12
表中的展开写法适合帮助理解这些数字运算,复合赋值与普通赋值并不在所有对象上完全等价。对列表使用 += 会原地追加元素,共享这个列表的其他变量也能看到变化;使用 topics = topics + other 则创建结果列表并重新赋值,原列表的别名不会跟着改变:
topics = topics + other
1topics = ["变量"] 2topics += ["运算符"] 3 4print(topics) # ['变量', '运算符']
Python 还支持链式赋值,例如 first = second = 1;也支持下面的解包赋值:
first = second = 1
1first, second = 1, 2 2first, second = second, first 3 4print(first) # 2 5print(second) # 1
成员运算符判断一个值是否包含在字符串、列表、元组、集合或字典中:
in
not in
1topics = ["变量", "运算符", "JSON"] 2 3print("运算符" in topics) # True 4print("模块" not in topics) # True 5print("Python" in "Python 3.12") # True
对字典使用 in 时,检查的是键,不是值:
1profile = { 2 "name": "小微", 3 "age": 18, 4} 5 6print("name" in profile) # True 7print("小微" in profile) # False
如果需要检查字典的值,可以使用 profile.values();如果需要同时检查键和值,可以使用 profile.items():
profile.values()
profile.items()
1profile = {"name": "小微", "age": 18} 2 3print("小微" in profile.values()) 4print(("name", "小微") in profile.items())
身份运算符是 is 和 is not,用于判断两个名字是否指向同一个对象:
is
is not
1first = ["Python"] 2second = ["Python"] 3third = first 4 5print(first == second) # True,内容相等 6print(first is second) # False,不是同一个对象 7print(first is third) # True,是同一个对象
普通数据比较值时使用 ==,不要用 is 代替。is 最常见、最明确的场景是判断 None:
1result = None 2 3if result is None: 4 print("没有查询结果")
位运算符直接操作整数的二进制位。业务代码中不一定天天用到,但在权限标记、底层协议和性能敏感的场景中很有用:
&
5 & 3
|
5 | 3
^
5 ^ 3
~
~5
<<
5 << 1
>>
5 >> 1
1read = 1 # 001 2write = 2 # 010 3permission = read | write 4 5print(permission) # 3,011 6print(permission & read) # 1,拥有读取权限
初学阶段只需要知道位运算处理的是整数的二进制表示。遇到权限标记这类场景时,再结合具体业务学习每一位代表什么。
由于日常开发中,位运算符的使用场景较少,所以这里不展开介绍
同一个表达式里出现多个运算符时,Python 会按照优先级决定计算顺序。常见的顺序可以先记住下面这几层:
()
+x
-x
1result = 2 + 3 * 4 2with_parentheses = (2 + 3) * 4 3 4print(result) # 14 5print(with_parentheses) # 20
不要依赖自己记住所有优先级。只要表达式稍微复杂,就主动使用括号:
1is_available = (stock > 0) and (is_enabled or is_admin)
括号不仅能改变计算顺序,也能把作者的意图直接写出来,减少读者和自己之后理解代码的成本。
在线案例会对同一组操作数进行算术和比较运算,并展示短路、成员判断、身份判断和列表复合赋值的结果。实验只执行本篇的 Python 代码,不需要外部服务。
main.py 提供接口,把请求数据交给主题文件。完整入口代码如下:
main.py
01from fastapi import FastAPI, Query 02 03from operators import build_operator_report 04 05app = FastAPI() 06 07@app.get("/operators") 08async def operators( 09 left: int = Query(default=7, ge=-100, le=100), 10 right: int = Query(default=2, ge=-6, le=6), 11 name: str = Query(default="", max_length=40), 12) -> dict[str, object]: 13 report = build_operator_report(left, right, name) 14 print(f"操作数:{left}、{right};显示名字:{report['logic']['display_name']}") 15 print(f"原地 += 之后,别名看到:{report['assignment']['in_place']['alias']}") 16 print(f"重新赋值之后,别名看到:{report['assignment']['rebind']['alias']}") 17 return report 18
实验保存在 operators.py 中。这里展示的代码与在线工作区的原始文件直接共用同一份来源:
operators.py
01def build_operator_report(left: int, right: int, name: str) -> dict[str, object]: 02 try: 03 division = {"true": left / right, "floor": left // right, "remainder": left % right} 04 except ZeroDivisionError as error: 05 division = {"error": type(error).__name__} 06 try: 07 power = left ** right 08 except ZeroDivisionError as error: 09 power = type(error).__name__ 10 11 in_place = ["变量"] 12 in_place_alias = in_place 13 in_place += ["运算符"] 14 15 rebound = ["变量"] 16 rebound_alias = rebound 17 rebound = rebound + ["运算符"] 18 19 first = ["Python"] 20 second = ["Python"] 21 third = first 22 topics = ["变量", "运算符", "JSON"] 23 user = None 24 read = 1 25 write = 2 26 permission = read | write 27 28 return { 29 "arithmetic": { 30 "sum": left + right, 31 "difference": left - right, 32 "product": left * right, 33 "division": division, 34 "power": power, 35 }, 36 "negative_division": {"floor": -7 // 2, "remainder": -7 % 2}, 37 "comparison": {"equal": left == right, "greater": left > right, "number_and_text": 1 == "1"}, 38 "logic": {"display_name": name or "匿名用户", "safe_access": bool(user is not None and user.get("name"))}, 39 "assignment": { 40 "in_place": {"result": in_place, "alias": in_place_alias, "same_object": in_place is in_place_alias}, 41 "rebind": {"result": rebound, "alias": rebound_alias, "same_object": rebound is rebound_alias}, 42 }, 43 "membership": {"contains_operator": "运算符" in topics, "missing_module": "模块" not in topics}, 44 "identity": {"equal_values": first == second, "separate_objects": first is second, "shared_object": first is third}, 45 "bits": {"permission": permission, "has_read": bool(permission & read)}, 46 "precedence": {"normal": 2 + 3 * 4, "parentheses": (2 + 3) * 4}, 47 } 48
打开在线案例,运行后发送默认 GET /operators?left=7&right=2。响应里会包含:
GET /operators?left=7&right=2
01{ 02 "arithmetic": { 03 "sum": 9, 04 "difference": 5, 05 "product": 14, 06 "division": {"true": 3.5, "floor": 3, "remainder": 1}, 07 "power": 49 08 }, 09 "negative_division": {"floor": -4, "remainder": 1}, 10 "precedence": {"normal": 14, "parentheses": 20} 11}
同时查看 assignment:in_place.alias 会看到 ["变量", "运算符"],same_object 是 true;rebind.alias 仍然只有 ["变量"],same_object 是 false。这说明列表上的 += 和 list = list + other 对别名有不同影响。响应中展示的是 Python 对象比较的结果,JSON 本身不会保存别名关系。
assignment
in_place.alias
["变量", "运算符"]
same_object
true
rebind.alias
["变量"]
false
list = list + other
把请求地址改为 /operators?left=-7&right=2&name=小微,可以同时观察负数整除和 or 返回的名字。name 为空时返回 "匿名用户",非空时返回原名字。
/operators?left=-7&right=2&name=小微
把 right 改为 0,arithmetic.division 会返回 {"error": "ZeroDivisionError"}。这个错误已经捕获,其他运算结果仍然可以查看;left=0&right=-1 的乘方错误也会被捕获。案例限制了整数范围和指数大小,超出范围时返回 HTTP 422,避免无意间计算极大的整数。日志会打印两个操作数和两组列表的别名内容。
right
arithmetic.division
{"error": "ZeroDivisionError"}
left=0&right=-1
下载并解压项目,在项目目录执行:
1uv run fastapi dev main.py
然后访问 http://127.0.0.1:8000/operators?left=7&right=2,或在 http://127.0.0.1:8000/docs 中修改参数。
http://127.0.0.1:8000/operators?left=7&right=2
http://127.0.0.1:8000/docs
浏览器使用当前 Pyodide 的 Python 环境,本机使用 .python-version 指定的版本。在线模式无需启动本机端口,也不需要模型密钥。本篇的文件草稿、日志、Git 配置和 PI Agent 对话独立保存,依赖下载缓存可与同站其他文章共享。
.python-version
此段落已有评论,按 Enter 查看评论及回复列表。
连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。
1. 运算符是什么
运算符是参与运算的符号。例如,
+可以做加法,==可以比较两个值是否相等,and可以组合两个条件。这里的
*是运算符,price和quantity是操作数。Python 先根据运算符的规则计算右侧表达式,再把结果赋给total。运算符不只用于数字。字符串、列表、字典等对象也可以参与某些运算,但具体结果取决于对象支持的操作。
2. 算术运算符
算术运算符用于做数学计算:
+7 + 29-7 - 25*7 * 214/7 / 23.5//7 // 23%7 % 21**7 ** 249/的结果总是普通除法结果,通常是float。//表示向下取整的整除,不是简单地把小数部分截掉,负数参与运算时尤其要注意:%经常用于判断奇偶、循环取值和按固定数量分组:字符串也可以使用
+拼接,使用*重复:但不同类型不能随意相加。数字和字符串拼接时,要使用
str()或 f-string:3. 比较运算符
比较运算符用于判断两个值的关系。本篇使用内置数据类型进行比较,结果是布尔值
True或False:==age == 18!=age != 18>score > 60<score < 60>=score >= 60<=score <= 60==是比较运算,判断两边的值是否相等;=是赋值运算,把右边的结果绑定给左边的变量:Python 不会像某些语言那样,把字符串
"18"自动转换成数字18再比较。比较不同类型的值时,应该先判断它们是否真的具有可比较的含义:这里的
1 == 1.0可以直接得到True,是因为 Python 对兼容的数字类型使用数值语义进行比较;这不代表变量本身被永久转换成了另一种类型。True和False也属于布尔类型,只是它们在 Python 的类型体系中分别对应数值1和0,因此不建议把布尔值和数字混在业务条件中比较。如果数据来自表单、命令行或 HTTP 请求,它通常先以字符串出现,需要显式转换后再比较:
显式转换能让代码清楚表达意图,也能让无效输入在转换时及时暴露,而不是依赖不明显的类型规则。
字符串可以按字典顺序比较,列表也可以从前往后比较元素,但这类比较必须符合业务含义,不要只因为语法能够运行就认为结果一定符合需求:
4. 逻辑运算符
逻辑运算符用于组合多个条件:
andornotand和or不一定返回True或False。它们会短路求值,并返回参与判断的某个操作数:这段代码中,
name是空字符串,在真值判断中为假,因此or返回右边的"匿名用户"。and适合表达“前一个条件成立后,才继续检查后一个条件”:当
user is not None为假时,Python 不会继续执行user.get("name"),因此不会因为对None调用方法而报错。条件过多时,建议拆成多个有意义的变量,不要把一整段业务逻辑压缩成一行:
5. 赋值运算符
最基本的赋值运算符是
=。它不是数学里的“相等”,而是把右边表达式的结果绑定给左边的变量。Python 还提供了复合赋值运算符,把计算和重新赋值合在一起:
+=value = value + 1value += 1-=value = value - 1value -= 1*=value = value * 2value *= 2/=value = value / 2value /= 2//=value = value // 2value //= 2%=value = value % 2value %= 2**=value = value ** 2value **= 2表中的展开写法适合帮助理解这些数字运算,复合赋值与普通赋值并不在所有对象上完全等价。对列表使用
+=会原地追加元素,共享这个列表的其他变量也能看到变化;使用topics = topics + other则创建结果列表并重新赋值,原列表的别名不会跟着改变:Python 还支持链式赋值,例如
first = second = 1;也支持下面的解包赋值:6. 成员运算符
成员运算符判断一个值是否包含在字符串、列表、元组、集合或字典中:
innot in对字典使用
in时,检查的是键,不是值:如果需要检查字典的值,可以使用
profile.values();如果需要同时检查键和值,可以使用profile.items():7. 身份运算符
身份运算符是
is和is not,用于判断两个名字是否指向同一个对象:普通数据比较值时使用
==,不要用is代替。is最常见、最明确的场景是判断None:8. 位运算符
位运算符直接操作整数的二进制位。业务代码中不一定天天用到,但在权限标记、底层协议和性能敏感的场景中很有用:
&5 & 3|5 | 3^5 ^ 3~~5<<5 << 1>>5 >> 1初学阶段只需要知道位运算处理的是整数的二进制表示。遇到权限标记这类场景时,再结合具体业务学习每一位代表什么。
由于日常开发中,位运算符的使用场景较少,所以这里不展开介绍
9. 运算符优先级
同一个表达式里出现多个运算符时,Python 会按照优先级决定计算顺序。常见的顺序可以先记住下面这几层:
();**;+x、-x;*、/、//、%;+、-;==、>、in、is;not;and;or。不要依赖自己记住所有优先级。只要表达式稍微复杂,就主动使用括号:
括号不仅能改变计算顺序,也能把作者的意图直接写出来,减少读者和自己之后理解代码的成本。
10. 在线实验
在线案例会对同一组操作数进行算术和比较运算,并展示短路、成员判断、身份判断和列表复合赋值的结果。实验只执行本篇的 Python 代码,不需要外部服务。
main.py提供接口,把请求数据交给主题文件。完整入口代码如下:实验保存在
operators.py中。这里展示的代码与在线工作区的原始文件直接共用同一份来源:10.1 运行并观察
打开在线案例,运行后发送默认
GET /operators?left=7&right=2。响应里会包含:同时查看
assignment:in_place.alias会看到["变量", "运算符"],same_object是true;rebind.alias仍然只有["变量"],same_object是false。这说明列表上的+=和list = list + other对别名有不同影响。响应中展示的是 Python 对象比较的结果,JSON 本身不会保存别名关系。把请求地址改为
/operators?left=-7&right=2&name=小微,可以同时观察负数整除和or返回的名字。name为空时返回"匿名用户",非空时返回原名字。把
right改为0,arithmetic.division会返回{"error": "ZeroDivisionError"}。这个错误已经捕获,其他运算结果仍然可以查看;left=0&right=-1的乘方错误也会被捕获。案例限制了整数范围和指数大小,超出范围时返回 HTTP 422,避免无意间计算极大的整数。日志会打印两个操作数和两组列表的别名内容。10.2 本机运行
下载并解压项目,在项目目录执行:
然后访问
http://127.0.0.1:8000/operators?left=7&right=2,或在http://127.0.0.1:8000/docs中修改参数。浏览器使用当前 Pyodide 的 Python 环境,本机使用
.python-version指定的版本。在线模式无需启动本机端口,也不需要模型密钥。本篇的文件草稿、日志、Git 配置和 PI Agent 对话独立保存,依赖下载缓存可与同站其他文章共享。