【Python基础】（二）从 0 到 1 入门 Python 语法基础：从表达式到运算符的全面指南

前言

很多新手刚接触编程时，会被复杂的语法规则、晦涩的专业术语吓退，但 Python 完全不同 —— 它的语法贴近自然语言，代码可读性极强，就像在写伪代码一样。不过，“简单” 不代表 “不用学”，变量类型、运算符优先级、注释规范这些基础知识点，正是决定你能否写出高效、易维护代码的关键。 本文将基于 Python 核心语法体系，结合实战案例，从常量表达式到输入输出，从数据类型到运算符，全方位拆解 Python 基础语法。无论你是想入门编程，还是想巩固基础，这篇文章都能让你收获满满。话不多说，咱们直接开干！

一、Python 初体验：像用计算器一样写代码

刚接触 Python 时，我们可以把它当成一个高级计算器，先通过简单的算术运算感受编程的乐趣。这部分会带你认识表达式、常量和最基础的 print 函数。

1.1 表达式与常量：编程世界的 “算术题”

在 Python 中，像1 + 2 - 3、1 + 2 * 3这样的 “算术题” 被称为表达式，而1、2、3这种直接写出来的数值叫做字面值常量，+、-、*、/则是运算符（也叫操作符）。

表达式的计算结果叫做 “返回值”，我们可以用print函数将结果输出到控制台，就像按下计算器的 “等于” 键一样：

# 基本算术运算
print(1 + 2 - 3)    # 输出：0
print(1 + 2 * 3)    # 输出：7（先算乘除，后算加减，和数学规则一致）
print(1 + 2 / 3)    # 输出：1.6666666666666665
print((1 + 2) * 3)  # 输出：9（括号可以改变运算优先级）

这里有几个实用小细节，新手一定要注意：

• 运算符和数字之间可以没有空格，也可以有多个空格，但建议只留一个空格（代码更美观，可读性更强）；
• 熟悉 C/Java 的同学要注意：Python 中2 / 3的结果是小数（1.666...），而不是截断后的 0，更符合日常计算直觉；
• print是 Python 内置函数，作用是 “打印输出”，后续会详细介绍它的高级用法。

1.2 实战案例：计算四个分数的平均值

光说不练假把式，我们来做个简单实战：给定四个分数 67.5、89.0、12.9、32.2，计算它们的平均值。

根据平均值公式 “总和 ÷ 个数”，我们可以直接写表达式：

# 计算四个分数的平均值
print((67.5 + 89.0 + 12.9 + 32.2) / 4)

运行代码后，控制台会输出50.4，这就是四个数的平均值。是不是很简单？但如果我们要计算更复杂的指标（比如方差），只靠单次表达式就不够了 —— 这时候需要用到 “变量” 来保存中间结果。

二、变量：编程世界的 “储物盒”

想象一下，如果你在计算方差时，每次用到平均值都要重新写一遍(67.5 + 89.0 + 12.9 + 32.2) / 4，不仅麻烦，还容易出错。这时候，变量就像一个 “储物盒”，可以把计算结果存起来，后续直接调用即可。这是与计算器中的M键功能类似的。

2.1 变量是什么？

变量是一块用于存储数据的内存空间，就像宿舍楼上的房间 —— 每个房间都有编号（变量名），里面可以存放不同的数据（变量值）。我们可以通过变量名快速访问或修改里面的数据，而不用关心它在内存中的具体位置。

还是以计算方差为例，方差的计算步骤是：先求平均值→每个数减平均值的平方→求和→除以（个数 - 1）。用变量保存中间结果后，代码会清晰很多：

# 计算四个分数的方差
# 1. 计算平均值，用变量avg保存
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
# 2. 计算每个数与平均值差值的平方和，用变量total保存
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2
# 3. 计算方差，用变量result保存
result = total / 3
# 4. 输出结果
print(result)

运行代码后，会输出方差结果945.9566666666667。这里的avg、total、result都是变量，**是 Python 中的乘方运算符（**2就是求平方）。

2.2 变量的语法规则：命名不能 “随心所欲”

定义变量的语法非常简单：变量名 = 变量值，其中=是赋值运算符，表示把右侧的数据 “放进” 左侧的变量中。但变量名的命名有严格规则，分为 “硬性规则”（必须遵守）和 “软性规则”（建议遵守）。

硬性规则（违反会报错）

1. 变量名由数字、字母、下划线构成，不能包含其他特殊字符（比如!、@、#等）；
2. 数字不能开头（比如123num是非法的，num123是合法的）；
3. 变量名不能和 Python 的 “关键字” 重复（比如if、for、print这些有特殊功能的单词）；
4. 变量名大小写敏感（num和Num是两个不同的变量，比如num=10和Num=20互不影响）。

软性规则（提升代码质量）

1. 变量名要用有描述性的单词，让人一眼就知道变量的用途（比如用avg表示平均值，total表示总和，而不是用x、y、z）；
2. 多个单词构成的变量名，建议用 “驼峰命名法”（首个单词首字母小写，后续单词首字母大写），比如totalCount、personInfo；
3. 变量名尽量简洁，不要过长（比如用name表示姓名，而不是personFullName）。

反例：a=10、x2=30、my_name123=50（虽然合法，但可读性差）；

正例：age=18、studentScore=95、averageHeight=175.5（清晰易懂）。

2.3 变量的使用：读取与修改

变量的使用非常灵活，既可以读取它的值，也可以修改它的值，还能把一个变量的值赋给另一个变量。

读取变量值

# 定义变量
name = "张三"
age = 20
# 读取并输出变量值
print(name)  # 输出：张三
print(age)   # 输出：20

修改变量值

在 Python 中，修改变量不需要重新声明，直接用=赋值即可：

num = 10
print(num)  # 输出：10
# 修改变量值
num = 20
print(num)  # 输出：20

变量之间赋值

可以把一个变量的值 “复制” 给另一个变量：

a = 10
b = 20
# 把b的值赋给a
a = b
print(a)  # 输出：20
print(b)  # 输出：20（b的值不会变）

这里要注意：赋值是 “单向的”，a = b表示把b的值复制给a，而不是a和b相互绑定。后续修改a的值，不会影响b，反之亦然。

三、数据类型：给变量 “分类”，让操作更清晰

变量里能存的不只是数字，还能存文本、布尔值等不同类型的数据。Python 中的 “类型” 就像给变量贴标签，告诉我们这个变量能存什么数据，以及能对它做什么操作。

和 C++/Java 不同，Python 的变量不需要显式指定类型，而是在赋值时自动确定类型（比如a=10是整数类型，a="hello"是字符串类型）。我们可以用type()函数查看变量的类型。

3.1 常用数据类型详解

（1）整数（int）：没有大小限制的 “整数”

整数类型用于存储整数（正整数、负整数、0），比如10、-5、0。

a = 10
b = -20
c = 0
print(type(a))  # 输出：<class 'int'>
print(type(b))  # 输出：<class 'int'>

Python 的int类型有个强大的特点：表示范围无上限。只要内存足够，就能存储无限大的整数，比如：

# 超大整数运算
big_num = 123456789012345678901234567890
print(big_num * 2)  # 输出：246913578024691357802469135780

这和 C++/Java 不同，后者的整数类型有固定范围（比如 Java 的int最大是 2147483647），超过就会溢出。

（2）浮点数（float）：带小数点的 “小数”

浮点数用于存储小数（比如0.5、3.14），也可以用科学计数法表示（比如1.23e5表示 123000）。

a = 0.5
b = 3.14159
c = 1.23e5  # 等价于123000.0
print(type(a))  # 输出：<class 'float'>
print(c)        # 输出：123000.0

注意事项：

• Python 中没有double类型，float本质是双精度浮点数（和 C++/Java 的double一致），精度约为小数点后 15 位；
• 浮点数在计算机中存储不精确，后续会详细说明如何正确比较浮点数。

（3）字符串（str）：文本的 “载体”

字符串用于存储文本信息（比如姓名、地址、一句话），用单引号' '或双引号" "包裹即可。

a = 'hello'
b = "Python"
c = '我是程序员'
print(type(a))  # 输出：<class 'str'>
print(a + b)    # 输出：helloPython（字符串拼接）

字符串的常用操作：

1. 获取长度：用len()函数，返回字符串中字符的个数；

s = 'hello world'
print(len(s))  # 输出：11（空格也算一个字符）

2. 字符串拼接：用+运算符，只能拼接字符串和字符串（不能拼接字符串和数字）；

name = "张三"
age = 20
# 错误写法：print("姓名：" + name + "，年龄：" + age)（age是int类型，不能拼接）
# 正确写法：先把age转成字符串，或用f-string（后续会讲）
print("姓名：" + name + "，年龄：" + str(age))  # 输出：姓名：张三，年龄：20

3. 单引号和双引号等价：'hello'和"hello"完全一样，当字符串中包含引号时，可以交叉使用（比如He said "I love Python"）。

（4）布尔值（bool）：只有 “真” 和 “假”

布尔值是一种特殊类型，只有两个取值：True（真）和False（假），常用于逻辑判断（比如判断条件是否成立）。

a = True
b = False
print(type(a))  # 输出：<class 'bool'>
print(10 > 5)   # 输出：True（关系表达式的结果是布尔值）
print(10 == 5)  # 输出：False

布尔值的命名规则：True和False的首字母必须大写，不能写成true或false（会报错）。

3.2 为什么需要数据类型？

很多新手会疑惑：“为什么要分这么多类型？直接存数据不行吗？” 其实数据类型有两个核心作用：

1. 确定内存占用大小：不同类型的数据在内存中占用的空间不同。比如float类型占用 8 个字节（64 个二进制位），而int类型的占用空间会根据数值大小动态调整；
2. 规定可执行的操作：不同类型的变量支持的操作不同。比如int和float可以做+、-、*、/运算，而str类型只能做拼接（+）和求长度（len()）等操作。

简单说，数据类型就是给变量 “分类”，让计算机知道该如何处理这些数据 —— 就像苹果和香蕉都是水果，但苹果可以榨汁，香蕉可以做沙拉，分工不同，用法也不同。

3.3 Python 的动态类型特性

Python 的变量类型可以在程序运行过程中动态改变，这个特性叫做 “动态类型”，是 Python 的一大特色。

a = 10
print(type(a))  # 输出：<class 'int'>（初始是整数类型）
a = 'hello'
print(type(a))  # 输出：<class 'str'>（后来变成字符串类型）
a = True
print(type(a))  # 输出：<class 'bool'>（再变成布尔类型）

而 C++/Java 等语言是 “静态类型”，变量定义后类型就固定了（比如 Java 中int a=10，后续不能把a改成字符串）。

动态类型的优缺点：

• 优点：灵活，能减少代码量（比如一段代码可以支持多种类型）；
• 缺点：大型项目中容易出现类型错误，增加调试难度（比如不小心把整数类型改成了字符串，后续运算会报错）。

四、注释：给代码 “写说明”，让别人和自己都看懂

写代码就像写文章，光有内容不够，还需要 “注释” 来解释代码的用途、逻辑。注释是不会被 Python 执行的代码，只为了让开发者理解代码 —— 毕竟三个月后，你可能也不记得自己写的代码是干嘛的了。

4.1 为什么要写注释？

举个例子，下面两段代码，你觉得哪个更容易看懂？

无注释代码：

avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2
result = total / 3
print(result)

有注释代码：

# 计算四个分数（67.5, 89.0, 12.9, 32.2）的方差
# 方差公式：(每个数-平均值)²的和 ÷ (个数-1)
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4  # 步骤1：计算平均值
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg) ** 2  # 步骤2：计算平方和
result = total / 3  # 步骤3：计算方差
print(result)  # 步骤4：输出结果

显然，有注释的代码一目了然。记住：代码的第一目标是容易理解，第二目标才是执行正确。写注释不光是为了别人，更是为了未来的自己。

4.2 Python 注释的两种语法

Python 支持两种注释方式，分别适用于不同场景：

（1）单行注释：用#开头

#后面的内容都是注释，只作用于一行。可以单独占一行，也可以跟在代码后面：

# 这是单独一行的注释
num = 10  # 这是跟在代码后面的注释（说明变量的含义）
print(num)  # 输出变量num的值

（2）多行注释：用三引号包裹

用"""或'''包裹的内容是多行注释（也叫 “文档字符串”），可以跨越多行，常用于说明文件、函数或类的功能：

"""
这是多行注释（文档字符串）
作用：计算两个数的和并输出
参数：a - 第一个整数，b - 第二个整数
返回值：无
"""
a = 10
b = 20
print(a + b)

注意：三引号本质是字符串，如果没有赋值给变量，就会被当作注释；如果赋值给变量，就是一个字符串对象（但通常不用这种方式定义字符串）。

4.3 注释的规范：写注释也要 “讲规矩”

好的注释能提升代码质量，差的注释反而会误导别人。写注释要遵守以下规范：

1. 内容准确：注释必须和代码一致，代码修改后，注释也要及时更新（比如代码改成计算标准差，注释不能还写 “计算方差”）；
2. 篇幅合理：不要太精简（比如# 计算和可以，但# 求和也足够），也不要长篇大论（注释比代码还长就没必要了）；
3. 使用中文：国内开发场景中，建议用中文写注释（外企除外），避免英文注释表意不清；
4. 积极向上：注释中不要包含负能量、辱骂性语言（比如 “这破代码谁写的”“领导 SB”）。

反例：

# 计算x和y的和（但代码实际是计算乘积）
x = 5
y = 6
print(x * y)

正例：

# 计算x和y的乘积（用于后续计算面积）
x = 5  # 宽
y = 6  # 长
print(x * y)  # 输出面积：30

五、输入输出：程序与用户的 “对话”

程序不是孤立的，需要和用户交互 —— 用户向程序提供信息（输入），程序向用户展示结果（输出）。Python 中最基础的交互方式是通过控制台，用print()函数实现输出，用input()函数实现输入。

5.1 输出：用print()函数展示结果

print()是 Python 中最常用的输出函数，能输出字符串、变量、表达式结果等，还支持多种格式化方式。

（1）基本用法：输出单个内容

# 输出字符串
print("Hello, Python!")  # 输出：Hello, Python!
# 输出变量
name = "李四"
print(name)  # 输出：李四
# 输出表达式结果
print(10 + 20)  # 输出：30
print(3.14 * 2)  # 输出：6.28

（2）进阶用法：格式化输出（重点）

实际开发中，我们常需要混合输出字符串和变量（比如 “你的年龄是 20 岁”），这时候需要用到格式化输出。Python 中最简洁的方式是f-string（格式化字符串）。

f-string 的用法：在字符串前加f，用{}包裹变量或表达式：

name = "王五"
age = 25
height = 180.5
# 输出混合内容
print(f"姓名：{name}，年龄：{age}岁，身高：{height}cm")
# 输出：姓名：王五，年龄：25岁，身高：180.5cm
# 表达式也可以直接放在{}中
print(f"明年年龄：{age + 1}岁")  # 输出：明年年龄：26岁
print(f"身高的一半：{height / 2}cm")  # 输出：身高的一半：90.25cm

f-string 的优势：语法简洁、可读性强、运行效率高，是 Python3.6 及以上版本推荐的格式化方式。

除了 f-string，Python 还有%格式化、str.format()等方式，但 f-string 最直观，新手优先掌握这一种即可。

（3）其他用法：输出多个内容

print()函数可以同时输出多个内容，用逗号分隔，输出时会自动用空格连接：

a = 10
b = 20
print("a的值是", a, "b的值是", b)  # 输出：a的值是 10 b的值是 20

5.2 输入：用input()函数获取用户信息

input()函数用于从控制台获取用户输入，用户输入的内容会作为字符串返回（无论输入的是数字还是文本）。

（1）基本用法：获取输入并保存

# 获取用户输入，提示信息为“请输入你的姓名：”
name = input("请输入你的姓名：")
# 输出用户输入的内容
print(f"你好，{name}！")

运行代码后，控制台会显示 “请输入你的姓名：”，等待用户输入。用户输入后按回车，程序会继续执行，输出 “你好，XXX！”。

（2）关键注意：输入的是字符串类型

无论用户输入的是数字还是文本，input()的返回值都是字符串。如果需要进行算术运算，必须先把字符串转成对应的类型（int或float）。

反例（错误用法）：

# 想让用户输入两个整数，计算它们的和
a = input("请输入第一个整数：")
b = input("请输入第二个整数：")
print(f"它们的和是：{a + b}")

如果用户输入10和20，程序会输出1020，而不是30—— 因为a和b都是字符串，+是字符串拼接，不是算术加法。

正例（正确用法）：

# 先转成int类型，再计算
a = input("请输入第一个整数：")
b = input("请输入第二个整数：")
a = int(a)  # 把字符串转成整数
b = int(b)
print(f"它们的和是：{a + b}")  # 输出：30

如果用户输入的是小数，就用float()转成浮点数：

# 计算两个小数的和
x = float(input("请输入第一个小数："))
y = float(input("请输入第二个小数："))
print(f"它们的和是：{x + y}")

（3）实战案例：输入四个小数，计算平均值

结合输入输出和变量知识，我们做一个实战：让用户输入四个小数，程序计算并输出平均值。

# 输入四个小数
a = float(input("请输入第一个小数："))
b = float(input("请输入第二个小数："))
c = float(input("请输入第三个小数："))
d = float(input("请输入第四个小数："))
# 计算平均值
avg = (a + b + c + d) / 4
# 格式化输出（保留2位小数）
print(f"四个数的平均值是：{avg:.2f}")

运行示例：

请输入第一个小数：10.2
请输入第二个小数：20.3
请输入第三个小数：30.4
请输入第四个小数：40.5
四个数的平均值是：25.35

其中{avg:.2f}表示把avg格式化为保留 2 位小数的浮点数，让输出更整洁。

六、运算符：Python 的 “计算工具库”

运算符是用于执行运算的符号，Python 提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符、赋值运算符等。掌握运算符的用法和优先级，能让你写出更高效的代码。

6.1 算术运算符：做数学运算

算术运算符用于执行基本的数学运算，包括+（加）、-（减）、*（乘）、/（除）、%（取余）、**（乘方）、//（取整除法）。

关键注意点：

（1）除法不能除以 0：用0作为除数会抛出ZeroDivisionError异常（程序崩溃）；

print(10 / 0)  # 报错：ZeroDivisionError: division by zero

（2）取余运算的应用：取余常用于判断奇偶性（num % 2 == 0是偶数）、循环周期（比如每隔 n 次执行一次操作）；

# 判断奇偶性
num = 15
if num % 2 == 0:
    print("偶数")
else:
    print("奇数")  # 输出：奇数

（3）取整除法（//）：舍弃小数部分，向下取整（不是四舍五入）。比如7 // 2 = 3，-7 // 2 = -4（因为 - 4 比 - 3 小）；

（4）乘方运算支持小数次方：比如4 ** 0.5（4 的平方根）结果是2.0，8 ** (1/3)（8 的立方根）结果是2.0。

6.2 关系运算符：比较大小与相等

关系运算符用于比较两个值的关系，结果是布尔值（True或False）。包括<（小于）、<=（小于等于）、>（大于）、>=（大于等于）、==（等于）、!=（不等于）。

（1）基本用法：比较数字

a = 10
b = 20
print(a < b)   # 输出：True
print(a <= b)  # 输出：True
print(a > b)   # 输出：False
print(a == b)  # 输出：False（注意是==，不是=，=是赋值）
print(a != b)  # 输出：True

（2）扩展用法：比较字符串

关系运算符也能比较字符串，规则是 “字典序”（和英语词典的排序规则一致）：

• 先比较第一个字符的 ASCII 码值，谁小谁就 “小”；
• 第一个字符相同，再比较第二个，以此类推；
• 字符串长度不同但前缀相同，短的字符串更小（比如"apple" < "apples"）。

s1 = "hello"
s2 = "world"
s3 = "apple"
print(s1 < s2)  # 输出：True（'h'的ASCII码比'w'小）
print(s3 < s1)  # 输出：True（'a'的ASCII码比'h'小）
print("apple" == "apple")  # 输出：True（内容完全一致）

注意：Python 中直接用==比较字符串内容是否相等，这和 C/Java 不同（后者需要用strcmp函数）。

（3）避坑指南：浮点数不能用==比较

由于浮点数在计算机中存储不精确，直接用==比较两个浮点数是否相等，很可能得到错误结果：

print(0.1 + 0.2 == 0.3)  # 输出：False
print(0.1 + 0.2)         # 输出：0.30000000000000004（不是精确的0.3）

这不是 Python 的问题，而是 IEEE754 标准（浮点数存储标准）的固有缺陷。正确的比较方式是：判断两个浮点数的差值是否小于一个极小的误差范围（比如1e-6，即 0.000001）。

a = 0.1 + 0.2
b = 0.3
# 正确写法：差值的绝对值小于1e-6，就认为相等
if abs(a - b) < 1e-6:
    print("相等")  # 输出：相等
else:
    print("不相等")

6.3 逻辑运算符：组合条件判断

逻辑运算符用于组合多个条件，结果也是布尔值。包括and（并且）、or（或者）、not（非）。

（1）基本规则

• and：两侧条件都为True，结果才是True（一假则假）；
• or：两侧条件只要有一个为True，结果就是True（一真则真）；
• not：对条件取反（True变False，False变True）。

# and示例
age = 25
score = 85
print(age >= 18 and score >= 80)  # 输出：True（两个条件都满足）
print(age < 18 and score >= 80)   # 输出：False（第一个条件不满足）

# or示例
print(age >= 30 or score >= 80)   # 输出：True（第二个条件满足）
print(age < 18 or score < 60)     # 输出：False（两个条件都不满足）

# not示例
print(not age >= 30)  # 输出：True（age>=30是False，取反后是True）
print(not score < 60) # 输出：True（score<60是False，取反后是True）

（2）Python 特有：连续比较

Python 支持连续关系表达式，等价于用and连接，语法更简洁：

x = 10
# 等价于：x > 5 and x < 15
print(5 < x < 15)  # 输出：True
# 等价于：x >= 0 and x <= 20
print(0 <= x <= 20)  # 输出：True

这和大部分编程语言不同（比如 Java 中5 < x < 15会先计算5 < x得到True，再用True < 15，这是非法的）。

（3）短路求值：提高效率的小技巧

逻辑运算符存在 “短路求值” 特性，能避免不必要的计算，提高代码效率：

• and：如果左侧条件为False，右侧条件不再执行（因为整体结果已经是False）；
• or：如果左侧条件为True，右侧条件不再执行（因为整体结果已经是True）。

# and短路：左侧10>20是False，右侧10/0不会执行（不会报错）
print(10 > 20 and 10 / 0 == 1)  # 输出：False

# or短路：左侧10<20是True，右侧10/0不会执行（不会报错）
print(10 < 20 or 10 / 0 == 1)  # 输出：True

这个特性在实际开发中很有用，比如判断一个变量是否存在且满足某个条件时，可以避免空指针错误。

6.4 赋值运算符：简化赋值操作

赋值运算符用于给变量赋值，除了基本的=，还有复合赋值运算符（+=、-=、*=、/=、%=等）。

（1）基本赋值：=

a = 10  # 把10赋值给a
b = a   # 把a的值赋值给b

（2）链式赋值：同时给多个变量赋同一个值

x = y = z = 0  # x、y、z的值都是0
print(x, y, z)  # 输出：0 0 0

（3）多元赋值：同时给多个变量赋不同值

# 传统写法：需要临时变量
a = 10
b = 20
tmp = a
a = b
b = tmp

# 多元赋值写法：更简洁
a, b = 10, 20
a, b = b, a  # 交换a和b的值
print(a, b)  # 输出：20 10

多元赋值在交换变量、函数返回多个值时非常方便。

（4）复合赋值运算符：简化运算 + 赋值

复合赋值运算符是运算符 + =的组合，等价于变量 = 变量 运算符 数值。

注意：Python 中没有++（自增）和--（自减）运算符，如果需要自增 1，用a += 1即可（比++a更直观，避免了前置和后置的混淆）。

6.5 运算符优先级：谁先算，谁后算

当一个表达式中有多个运算符时，Python 会按照 “运算符优先级” 决定计算顺序（和数学中的 “先乘除后加减” 一致）。

优先级从高到低（常用）：

1. 括号（()）：优先级最高，先算括号里的；
2. 算术运算符：**（乘方）> *、/、%、// > +、-；
3. 关系运算符：<、<=、>、>=、==、!=；
4. 逻辑运算符：not > and > or；
5. 赋值运算符：=、+=、-=等（优先级最低，最后算）。

示例：

# 计算顺序：先算10*2=20，再算5+20=25，最后算25>20→True
print(5 + 10 * 2 > 20)  # 输出：True

# 计算顺序：先算a>5→True，再算b<10→False，最后算True and False→False
a = 10
b = 15
print(a > 5 and b < 10)  # 输出：False

如果不确定优先级，最简单的方法是加括号 —— 括号能改变优先级，让代码更清晰。

总结

Python学习没有什么捷径，如果在学习过程中遇到问题，不妨回头看看这篇文章，或者查阅 Python 官方文档。编程是一个循序渐进的过程，只要坚持练习，你一定能从新手成长为 Python 高手！