【Python基础】第3章：条件判断,运算与优先级,and和or

最新推荐文章于 2025-09-04 11:38:51 发布

原创最新推荐文章于 2025-09-04 11:38:51 发布 · 1.1k 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#python #网络 #开发语言

Python 专栏收录该内容

218 篇文章

订阅专栏

Python3.8

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

Python大礼包：《2025年最新Python全套学习资料包】免费领取

条件判断语句：if，elif，else

在Python中，条件判断使用if, elif（else if）, 和 else语句。

基本写法：

以if开头，使用‘判断条件’判断是否成立。如果成立，则执行if下面的代码块；如果不成立，则可以选择执行else下面的代码块。下面为基本结构示例：

基本结构：

if 判断条件:
执行体 # 如果判断条件为真，则执行此代码块
else:
执行体 # 如果判断条件为假，则执行此代码块（可选）

语法说明：

if是必需的，每个条件判断必须有一个if语句。

else是可选的，如果没有其他情况需要处理，可以省略else部分。

else子句在‘条件判断语句’中只能放在所有if和elif之后，不能插入中间。

示例：

a = 1
b = 2
if a > b:
print(a)
else:
print(b)
"""
解析：
我们可以先打印a > b是否为真（True）：print(a > b) ；输出为：False
所以判断条件为假，执行else下面的语句，打印b的值。
【上面的代码输出结果将为：2】
"""
print(a > b)

运行结果：

多重判断：

当存在多个‘判断条件’时，可以使用elif（else if）来处理更多的情况。

elif可以有多个，但每个elif都需要一个对应的判断条件。

基本结构：

if 判断条件1:
执行体1 # 如果判断条件1为真，则执行此代码块
elif 判断条件2:
执行体2 # 如果判断条件2为真，则执行此代码块
elif 判断条件3:
执行体3 # 如果判断条件3为真，则执行此代码块
...
else:
执行体n # 如果所有前面的条件都不满足，则执行此代码块（可选）

语法说明：

每个elif都需要一个对应的判断条件。

else部分也是可选的，如果没有其他情况需要处理，可以省略。

条件判断部分需要返回一个布尔值（True或False），可以是简单的比较操作符（如>, <, ==, !=等），也可以是复杂的逻辑表达式（如and, or等）。

示例：

# 示例1：基本if-else结构
a = 15
if a > 10:
print('a大于10')
else:
print('a小于或等于10')
# 示例2：多重条件判断（if-elif-else）
score = 85
if score >= 90:
print('优秀')
elif score >= 70:
print('良好')
elif score >= 60:
print('及格')
else:
print('不及格')

运行结果：

层层递进（多层嵌套）：

在实际应用中，可能不使用简单的单层结构，而是使用多层嵌套的形式。这种层层递进的结构可以帮助我们更细致地控制程序流程。

语法结构：

"""多层判断方式一："""
if 判断条件1:
执行体1
if 判断条件2：
执行体2
if 判断条件3：
执行体3
...更多的if...
else: # 可以按需省略
判断条件3不成立的执行体
else: # 可以按需省略
判断条件2不成立的执行体
else： # 可以按需省略
判断条件1不成立的执行体
"""多层判断方式二：这个写法相当于elif"""
if 判断条件1：
执行体1
else:
if 判断条件2：
执行体2
else:
...

示例一：多层判断方式一

a = 15
if a > 0:
print('你通过了第1关') # 第一层判断
if a > 5:
print('你通过了第2关') # 第二层判断
if a > 10:
print('你通过了第3关') # 第三层判断
else:
print('未通过第3关')
else:
print('未通过第2关')
else:
print('未通过第1关')

运行结果：

示例一：代码说明

首先检查a > 0，如果条件为真，则进入下一层判断。
在第一层判断的基础上，进一步检查a > 5，如果条件为真，则进入第三层判断。
在前两层判断的基础上，继续检查a > 10，如果条件为真，则输出相应的信息。
每一层的else部分是可选的，用于处理该层判断不成立的情况。

示例二：多层判断方式二（相当于elif）

score = 85
if score >= 90:
print('优秀')
else:
if score >= 70:
print('良好')
else:
if score >= 60:
print('及格')
else:
print('不及格')
"""这个示例，使用elif的写法在上面有，可以对比查看"""

运行结果：

示例二：代码说明

这种写法实际上是将多个if-else语句嵌套在一起，逻辑上等同于使用elif。
更简洁的方式是直接使用elif

缩进的重要性：

在Python中，代码块的定义依赖于缩进，不是像其它语言一样可以通过括号{}或其它符号定义。

由于Python依赖于缩进来解析代码，因此正确的缩进对于代码的正确执行起着重要的作用。

为什么重要？

代码块的定义：

用缩进定义代码块的范围，例如，在if语句中，缩进的代码行属于同一代码块。

语法错误：

错误缩进，会导致解释器抛出IndentationError的错误。

可读性：

适当的缩进可以提高代码的可读性，使得代码的结构更加清晰，便于理解和维护。

正确的缩进示例：

# 正确缩进示例
a = 5
if a > 0:
print('你通过了第1关') # 缩进4个空格或一个Tab
if a > 5:
print('你通过了第2关') # 再次缩进表示属于上一级if语句
if a > 10:
print('你通过了第3关') # 更深层次的缩进

运行结果：

错误的缩进示例

# 错误示例
a = 15
if a > 0:
print('你通过了第1关') # 这里缺少缩进，会报错

运行结果：

缩进规则：

缩进要一致，在整个代码文件中，应当保持一致的缩进方式，通常是4个空格（等于1个tab）作为标准缩进。（不要混用空格和tab，容易导致缩进不一致）
不要在行首使用空格，影响代码整洁和可读性。
每增加一层嵌套，缩进也应当增加。如示例所示：

"""标准的缩进"""
a = 9 # 顶格写
if a < 0: # 顶格写
print('哈哈哈哈') # 缩进：1个tab = 4个空格
else: # 与if平齐，同样顶格写
if a > 10: # 缩进：1个tab = 4个空格
print('a大于10') # 缩进：2个tab = 8个空格
else: # 缩进：1个tab = 4个空格
print('a大于等于0并且a小于等于10') # 缩进：2个tab = 8个空格
"""不标准的缩进：不报错，但是不标准-一旦代码多了，不整洁，不美观，可读性差。"""
a = 9
if a < 0:
print('哈哈哈哈') # 只有2个空格
else:
if a > 10:
print('a大于10') # 2个tab
else:
print('a大于等于0并且a小于等于10') # 5个空格

案例讲解：

闰年判断：

- 闰年标准：
  1. 四年一闰
  2. 百年不闰
  3. 四百年再闰

也就是两种情况下为闰年：

1. 可以被4整除，但不能被100整除的（例如：2004年）
2. 可以被400整除的年份（例如：2000年）

插入讲解两个算数运算符：//（整除取商），%（取余）

整除：将一个数值除以另一个数值，结果为整数，即除法的商，舍弃小数部分。

取余：求两个数值相除的余数。

# //：整除
a = 3 // 4
print(a)
# %：取余数
a = 3 % 4
print(a)

运行结果：

根据条件画个判断流程图：

根据流程，只使用if-else，判断是否闰年：

year = int(input("请输入一个年份: "))
if year % 4 == 0:
if year % 100 == 0:
if year % 400 == 0:
print("此年份是闰年")
else:
print(f"此年份不是闰年")
else:
print(f"此年份是闰年")
else:
print(f"此年份年不是闰年")

运行结果：

BMI计算：

计算公式：BMI = 体重(kg) / 身高(m)2

我们需要根据计算出来的BMI值，判断一个的体重状态。要求如下：

首先，我们需要用户输入身高（以cm为单位）、体重（以kg为单位）。由于计算上需要将身高按米（m）来计算，因此需要将身高从cm转换为m。也就是：

# 获取用户输入：w表示体重；h表示身高。
w = float(input("请输入你的体重（kg）: "))
h_cm = float(input("请输入你的身高（cm）: "))
# 将身高从厘米转换为米
h_m = h_cm / 100.0

这里简单说下“/”除法：符号“/”表示除法，不是整除也不是取余，取具体除完的值。

将一个数值除以另一个数值，结果为浮点数。

# /：除法
a = 3 / 4
print(a)

输出为：0.75

接下来，我们根据上述公式进行计算：

# 计算BMI:BMI = 体重(kg) / 身高(m)^2
bmi = w / (h_m ** 2)
单个/是除法。

最后，使用if，elif，else判断用户体重状态：

# 判断体重状态
if bmi < 18.5:
print("偏瘦")
elif 18.5 <= bmi < 25:
print("正常")
elif 25 <= bmi < 28:
print("超重")
elif 28 <= bmi < 32:
print("肥胖")
else:
print("非常肥胖")

代码结合后，运行结果将为：

逻辑运算符和运算符优先级

我们先总结一下基本算数运算符的使用方法。在理解运算优先级和逻辑运算符的使用。

算数运算符

就是加减乘除、幂运算...

常用的四则运算符号如下整理所示：

运算符	描述	示例
+	加法运算。	a = 1+1；print(a)。输出为2.
-	减法运算。	a = 1-1；print(a)。输出为0.
*	乘法运算。	a = 1*1；print(a)。输出为1.
/	除法运算。	a = 3/4；print(a)。输出为0.75.
//	整除取商。	a = 3//4；print(a)。输出为0.（就是取商）
%	取余（模运算）。	a = 3%4；print(a)。输出为3.（取余）

常用的四则运算示例：

加法运算符（+）：

将两个数值相加。

a = 3 + 5
print(a)

运行结果：

减法运算符（-）：

从一个数值中减去另一个数值。

a = 5 - 3
print(a)

乘法运算符（*）：

将两个数值相乘。

a = 5 * 3
print(a)

除法运算符（/）：

将一个数值除以另一个数值，结果为浮点数。

a = 5 / 2
print(a)

整除运算符（//）:

将一个数值除以另一个数值，结果为整数，即除法的商，舍弃小数部分。

a = 5 // 2
print(a)

取余运算符（%）:

求两个数值相除的余数。

a = 5 % 2
print(a)

高阶运算：

上面是简单的四则运算，除了基本的加减乘除外，还有取商(//)和取余(%)的运算。这里介绍一个函数，可以同时取商和余数。再另外介绍一下幂运算。

divmod()函数

函数语法：divmod(a, b)

a：被除数

b：除数

返回值：返回值的数据类型是一个元组（元组类型后面的课程会讲解，返回内容的格式如下）

(商, 余数)

使用示例：

# 5除以2
r = divmod(5, 2)
print(r)
# 输出为：(2, 1)
# 2是商；1是余数--可以和上面提到的//、%运算符对比。

运行结果将如图所示：

幂运算：**

用于求一个数值的另一个数值次幂。

示例：

# 求2的3次幂
a = 2 ** 3
# 求9的平方
b = 9 ** 2
print("2的3次幂为：", a, ",9的2次方为：", b)

运行结果：

幂运算：pow()函数

函数语法：pow(base, exp)

base: 底数，即幂运算中的基数。

exp: 指数，即幂运算中的幂次数。

返回值：

返回 base 的 exp 次幂的结果。

示例：

# 计算 2 的 3 次幂
r = pow(2, 3)
print(r)

运行结果：

运算符优先级

同小学数学中学过的那样，Python中也有优先级顺序。其中括号()是最高优先级。

下面是一个简化的运算符优先级表格，展示不同运算符的优先级顺序：

优先级	运算符
1	()用于分组，可以提高括号内表达式的优先级。
2	**幂运算
3	+ -正负号 +x 是正号，通常省略不写（如 +5 可以直接写成 5）。 -x 是负号，用来表示负数（如 -5）。
4	* / // %乘法、除法、整除、取余
5	+ - （加法和减法）

当然，还有很多其它的运算符，但我们没有必要记忆那么多，在实际编程中，使用括号 () 来来明确指定你想要提高的计算顺序是一个好习惯。

示例：()的运用

# 乘法和除法优先级高于加法和减法
print(1 + 2 * 3) # 输出 7
# 使用括号改变优先级
print((1 + 2) * 3) # 输出 9

运行结果：

示例：幂运算符优先级高于乘法

# 幂运算高于乘法
r = 4 * 3 ** 2
print(r) # 不会按顺序运算。输出: 36
r = 12 ** 2 # 【用这个和上面的结果比对】
print(r) # 输出：144

运行结果：

示例：正负号优先级

# 例如含负数的乘法，结果将为带-号的值：
r = 1 * 2 * -3
print(r)

运行结果：

逻辑运算符

与“and”、或“or”、非“not”

用于对一个或多个布尔值进行逻辑操作，并返回一个布尔结果。逻辑运算符在编程中非常常见，主要用于组合条件表达式，从而实现更复杂的逻辑判断。

以下为整理的逻辑运算符使用说明表格：

符号	描述	逻辑表达式
and	逻辑"与"	用法：and 运算符用于检查两个条件是否都为真。只有当两个条件都为真时，and 运算符的结果才为真。语法：条件1 and 条件2 返回值：当两个条件都为真，返回True；两个条件任意一个是假的，则返回False。
or	逻辑"或"	用法：or 运算符用于检查至少一个条件是否为真。如果至少有一个条件为真，or 运算符的结果就为真。语法：条件1 or 条件2 返回值：两个条件其中一个为真，返回True；两个条件都为假，则返回False。
not	逻辑"非"	用法：not 运算符用于反转条件的真值。如果条件为真，not 运算符的结果为假；如果条件为假，结果为真。语法：not 条件返回值：如果条件为真，则返回 False；如果条件为假，则返回 True。
逻辑运算符一般用来解决当有多个关系条件需要判断时使用，用来确定这些条件组合的方式，运算结果为布尔类型值。我们在第3节课的内容中可以知道，比较运算符的结果为True和False；通常我们将返回True的结果表示真，返回False的结果表示假。

and运算符使用示例：

# 两个条件都为真
r = (1 > 0) and (2 > 1)
# 分别打印(1 > 0)和(2 > 1)的比较结果。方便比对
print("(1 > 0)的比较结果：", (1 > 0)) # 输出：True
print("(2 > 1)的比较结果：", (2 > 1)) # 输出：True
# 打印使用了and运算符连接之后的r
print("使用and连接后的结果：", r) # 输出: True
# 至少一个条件为假
result = (1 > 0) and (2 < 1)
# 分别打印(1 > 0)和(2 < 1)的比较结果。方便比对
print("(1 > 0)的比较结果：", (1 > 0)) # 输出：True
print("(2 < 1)的比较结果：", (2 < 1)) # 输出：False
print("结果：", result) # 输出: False

运行结果如图所示：

or运算符使用示例：

# 至少一个条件为真
result = (1 > 0) or (2 < 1)
# 分别打印(1 > 0)和(2 < 1)的返回值。
print("(1 > 0)的比较结果：", (1 > 0)) # 输出：True
print("(2 < 1)的比较结果：", (2 < 1)) # 输出：False
print("使用or连接后的结果", result) # 输出: True
# 两个条件都为假
result = (1 < 0) or (2 < 1)
# 分别打印(1 < 0)和(2 < 1)的返回值。
print("(1 < 0)的比较结果：", (1 < 0)) # 输出：False
print("(2 < 1)的比较结果：", (2 < 1)) # 输出：False
print("结果", result) # 输出: False

运行结果如图所示：

not运算符示例：

'''当条件为真的时候，使用not'''
result = not (1 > 0)
# 打印(1 > 0)的比较结果。
print("(1 > 0)比较结果：", (1 > 0)) # 输出：True
print("条件是真值时的结果", result) # 输出: False
'''当条件为假的时候，使用not'''
result = not (1 < 0)
# 打印(1 < 0)的比较结果。
print("(1 < 0)比较结果：", (1 < 0)) # 输出：False
print("条件是假值时的结果", result) # 输出: True

运行结果：

注意-and/or的短路操作

短路操作就是，当使用and/or运算符时，(比如x and y)第一个表达式x返回为False，就不会计算第二个表达式y。

短路操作示例：

# and 运算符的短路操作
# 当第一个条件为 False 时，整个表达式的结果必定为 False，因此第二个条件不会被评估。
result = True and print("hello, python")
print("【and】非短路，上面两个条件都是真，所以输出：", result) # 输出 "hello, python"，result 为 None
result1 = False and print("hello, python")
print("【and】短路操作，因为第一个是假，第二个不会继续判断，输出：", result1) # 不会打印 "hello, python"，result1 为 False
# or 运算符的短路操作
# 当第一个条件为 True 时，整个表达式的结果必定为 True，因此第二个条件不会被评估。
result2 = False or print("hello, python")
print("【or】短路操作，第一个是假，程序会去找下一个值是不是真，输出：", result2) # 输出 "hello, python"，result2 为 None
result3 = True or print("hello, python")
print("【or】非短路，第一个是真，第二个也是真。输出：", result3) # 不会打印 "hello, python"，result3 为 True