花开陌上

判断语句

判断语句是程序的三大语句结构之一。

它的作用是根据判断的条件是否成立（真或假），来决定后续代码执行顺序。

单选选择的判断-if判断

yourAge =  20
myAge = 18

if yourAge > myAge:    
    print("你的年龄比我大")

代码的作用
这段代码将两个人的年龄进行判断，并且输出了结论。
第1行和第2行代码，将年龄分别赋值给两个变量。
第4行代码将两个变量进行判断。
第5行代码，输出"你的年龄比我大"。

if
使用 if (中文翻译为如果)，表明我们要在这里进行语句判断。

判断条件
if 后的判断条件通常是一个布尔表达式。
即该表达式有两种结果：True 或 False。
本例中，yourAge > myAge 的运算结果为 True。

冒号
判断语句的固定格式，用来表示这行判断条件的结束。

四个空格
用四个空格标记当 if 判断条件为True（真）时，需要执行的语句。
在这里，先记住这个格式，稍后会讲解这里空四格的原因。

执行部分
if 判断条件为True（真）时，程序就会执行if 判断内的代码。
在这里我们使用 print() 语句输出"你的年龄比我大"。

执行顺序
if 判断的执行顺序，梳理成流程图后，再来整理一下运行流程。
第一种情况，程序运行到 if 判断时，如果条件为真，则进入执行部分；完成后，程序接着运行 if 判断下面的代码。

第二种情况，程序运行到 if 判断时，如果条件为假，程序就直接跳开 if 判断的执行部分，运行后面的代码。

代码小结
通过以下格式在代码中使用 if 判断语句

关键字

关键字是程序语言中有特殊意义的单词，它们都不能被用来作为变量名，函数名，类名等。

此外，由于变量名区分大小写，所以 if 不能作为变量名，但 IF 、If、iF可以。

缩进

Python 中不同层级的代码之间强制要求缩进，并且相同层级的代码要求缩进的空格数量一致。

在这里第 1 到 3 行代码属于同一层级，第 4 和第 5 行代码属于同一层级。

在Python中，缩进的数量不做强制的要求，可以 1 个空格，可以 2 个空格
建议每个缩进用 4 个空格，这是一种比较美观易读的代码风格。

代码块

同一层级的代码集合叫做代码块，代码块中的代码会按由上至下的顺序执行。
在 Python 中，通过缩进来划分代码块。
if 判断后面跟随条件，如果条件成立，程序执行归属于 if 判断的一个代码块。
这时候就需要使用缩进组织代码块，区分代码的层级。

在连续的多个 if 判断中，每一个 if 判断内都有一个代码块。
只有当 if 条件成立时，程序才会执行这个 if 判断里面的代码块。
如果条件不成立，程序就会跳开这个 if 判断，继续运行接下来的代码。

多个if判断
例如：Tony的年龄是12岁，Kevin的年龄是11岁。判断谁的年龄更大，然后输出他的名字。

我们需要考虑两种情况：

1. 如果 Tony 比 Kevin 大，输出 Tony 的名字；
2. 如果 Tony 比 Kevin 小，输出 Kevin 的名字。

在这里，连续使用两个 if 判断就可以得到结果，编写出来的代码如图所示。

有了判断语句，我们就可以打破代码的默认执行顺序了（按由上至下的顺序执行）。
如图，两段代码里都有一行代码是不会执行的。
判断语句“里面”的代码块只有当判断布尔表达式为真的时候才会执行。

if 判断时，最容易出现以下两种 bug：

1. 缩进问题
   同一代码块缩进需要保持一致，建议每个缩进用 4 个空格。

   

2. 语法错误
   if 判断中，布尔表达式后面的冒号常常被遗漏，这是判断语句的固定格式。

   

学习了 if 判断，如果布尔表达式成立，就执行后面的代码块。
假设，if 判断后面的布尔表达式不成立，我们想要执行另外的代码块，这该怎么办呢？

在图例中，我们使用了两个 if，来保证对比情况都会有对应的输出。
为了更便捷地写出代码，我们可以使用 if-else 来优化这段程序。

if 后面的语句是当判断条件成立时，需要执行的操作。
else 后面的语句是判断条件不成立时，执行的操作。

双选选择的判断-if-else

yourScore = 80
myScore = 90

if yourScore > myScore:
    print("你的得分比我高")
else:
    print("你的得分不比我高")

代码的作用
本例中比较了变量 yourScore 和变量 myScore。
如果 yourScore 大于 myScore，就输出"你的得分比我高"。
第7行代码进行 else 判断，否则就输出"你的得分不比我高"。

if 判断
if 后面的布尔表达式，在这里不成立。
if 里面的代码块，也就是第5行代码，不会被执行。

else
一个关键字 else，如果之前的 if 判断条件不成立，就执行 else 的代码块。

冒号
在 else 之后使用冒号，表示后续缩进的代码块在判断条件不成立的时候会被执行。

缩进
缩进生成 else 内的代码块，这里我们还是空四格。

执行顺序
把 if-else 语句的执行顺序，梳理成流程图后，再来整理一下程序运行流程。

第一种情况，程序运行到 if 判断时，如果条件为真，执行 if 的代码块。
完成后，运行 if-else 后面的代码。

第二种情况，程序运行到 if 判断时，如果条件为假，程序就直接跳开 if 判断的执行部分，运行 else 的代码块。
完成后，运行 if-else 后面的代码。

代码小结
使用if-else的格式

if-else 语句有两个特性。
第一，else 需与 if 搭配使用，它无法独立出现。
必须先有 if，然后才能使用 else，否则程序就会报错。

第二，if 与 else 成互斥关系。
互斥关系也就是说，程序不会既执行 if 内的代码块，又执行 else 内的代码块。
else 是把 if 判断条件无法囊括的情况全部揽到了自己这里。

学习了两种判断语句 if 和 if-else。

if 语句属于单向判断。
只要条件成立，就会运行 if 内的代码块；条件不成立，程序就会跳开 if 判断。

if-else语句属于双向判断。
如果 if 的条件不成立，就执行 else 内的代码块。
if 和 else 是两个互斥关系，程序只会执行其中的一个。

当我们在同时使用 if 和 if-else 语句时，要注意 if 和 else 的关系。
例如，图例中的代码，包含了 2 个 if 判断和 1 个 if-else语句，这三个判断互不影响。
在这里，else 是与第 3 个 if 搭配成 if-else 语句，与前两个 if 无关

在判断语句中，除了使用布尔表达式可以作为条件，还有其他的数据类型也可以作为判断条件。
图中代码能够正常运行是因为 myAge 被赋值了一个整型 20，所以它被判定为 True，于是程序继续执行了下一步代码。

在这里，变量myAge就是“非零非空”数据

“非零”这个概念比较好理解，数字 0 被判断为False，其他数字（包含正数和负数）都被判断为True。
“非空”是什么意思呢？要理解“非空”先要理解“空值”这个概念。

空值

空值，又叫 NULL 值，在 Python 中写作 None。None 是关键字。
它代表这个数值不是整型，不是字符串，不是浮点型，表示没有值。
注意，它和 0 不一样，因为 0 的值是 0，而空值的值是None。

了解了“空值”后，“非空”就更好理解了。
当一个变量里有值，并且这个值不是空值，我们就说这个变量非空。
非空值可以是整型、字符串、浮点型和布尔数。

非值

当一个变量里有值，并且这个值不是空值（None），我们就说这个变量“非空”。
同时我们也把所有不是空值的值称为“非空值”。

布尔表达式和非零非空数据，都可以作为判断语句的条件。
在判断语句中，对非零值判断为真；对数字0的判断为假；对 None 的判断为假。

接触 if-else 判断时，最容易出现以下两种 bug：

1. 语法错误
   else 后面的冒号常常被遗漏，这是if-else的固定格式，有冒号程序才知道下面是 else 的代码块。

2. 缩进问题
   if 和 else 为互斥关系，else 的代码块需要通过缩进形成。为了保持风格统一，每个缩进用 4 个空格。

   

复杂的多项选择 - elif

但是生活中，N 选一的情况更为多见。
在Python中，也可以通过添加更多的选择，实现从“二选一”到“多选一”的进阶

如图所示，为了实现完整的判断，我们使用了三个 if，来保证所有的得分对比情况（大于、等于、小于）都会有对应的输出。

但是对于这种3个或以上的条件，无法使用一个if-else 结构来优化代码。
这时可以使用Python判断语句中的第三个关键字 elif（else if的缩写）。

if 后的语句是当 if 判断条件成立时，执行的操作。
elif 后的语句是当 if 判断不成立时，再判断一次，如果成立，执行的操作。
else 后的语句是当以上所有判断条件都不成立时，执行的操作。

elif

day = 3

if day == 1:
    print("元气满满地工作")
elif (day >= 2) and (day <= 5):
    print("继续搬砖吧")
else: 
    print("世界这么大，出去走走吧")

代码的作用
本例第3、4行代码判断了如果变量 day 等于1，就输出"元气满满地工作"。
第5、6行代码判断了如果变量 day 大于等于2并且小于等于5，就输出"继续搬砖吧"。
第7、8行代码判断了如果之前的条件都不满足，就输出"世界这么大，出去走走吧"。

if 判断
if 后面的布尔表达式，在这里不成立。
if 里面的代码块，也就是第4行代码，不会被执行。

elif
一个关键字，是 else 和 if 的缩写。
如果之前的 if 判断条件不成立，就再做一次新的判断，执行 elif 后面的代码。

布尔表达式
两次比较运算，如果变量 day 大于等于2，如果变量 day 小于等于5。
本例中结果都为 True 。

一次逻辑运算 and（“与”运算）。
本例中参与运算的分别是 True 和 True ，运算结果为 True 。

括号，用来框定代码运算的顺序，表明先进行比较运算，再进行逻辑“与”运算。

冒号
就像 if 和 else 一样，elif 语句的最后也需要一个冒号。
在 elif 之后使用冒号，表示后续缩进的代码块在判断条件成立的时候会被执行。

缩进
缩进生成 elif 内的代码块，这里还是空四格。

else
一个关键字 else，如果前面的 if 和 elif 的判断条件都不成立，就执行 else 后面缩进的代码块。

执行顺序
把 if-elif-else 判断的执行顺序，梳理成流程图后，再来整理一下程序运行流程。

第一种情况，程序运行到 if 判断时，如果条件为真，执行 if 的代码块。
完成后，运行 if-elif-else 后面的代码。

第二种情况，程序运行到 if 判断时，如果条件为假，程序就直接跳开 if 判断的执行部分，再次运行到 elif 的判断，如果条件为真，执行 elif 的代码块。
完成后，运行 if-elif-else 后面的代码。

第三种情况，程序运行到 elif 判断时，如果条件为假，程序就直接跳开 elif 判断的执行部分，运行 else 的代码块。
完成后，运行 if-elif-else 后面的代码。

代码小结
通过 elif 进行条件判断时，我们可以使用这样的格式

if-elif-else 语句有3个特性。

1. 如果不满足 if 的条件，就判断是否满足 elif 的条件，满足就执行 elif 内的代码块，不满足就执行 else 内的代码块。

2. elif 需与 if 搭配使用，它无法独立出现。必须先有 if ，然后才能使用 elif ，否则程序就会报错。

   

3. if 、elif 与 else 成互斥关系。
   互斥关系指的是，程序不会同时执行 if 内、 elif 内和 else 内的代码块，只会执行其中一个。
   else 是把 if 和 elif 判断条件无法囊括的情况全部划分到自己这里。

   

现在，已经学习了三种判断语句：
if 、if-else 和 if-elif-else 。

通过 if 、else 、elif 的搭配使用，我们可以覆盖条件判断中的所有情况，让程序按照我们预定的逻辑来执行很多自动化的工作。

if 语句属于单向判断。
只要条件成立，就会运行 if 内的代码块；条件不成立，程序就会跳开 if 判断。

if-else 语句属于双向判断。
如果 if 的条件不成立，就执行 else 内的代码块。
if 和 else 是两个互斥关系，程序只会执行其中的一个。

if-elif-else 语句属于多向判断（3个或以上的条件）。
如果 if 的条件不成立，就执行 elif 再判断一次，如果 elif 的条件也不成立，就执行 else 内的代码块。
if 、elif 、 else 是互斥关系，程序只会执行其中的一个。
并且，当判断的条件超过3个时，中间的多个条件都可以使用 elif ，无论中间有多少个 elif ，它和其他 if 、elif 都是互斥关系。

嵌套语句

嵌套语句在很多地方都有应用，这里主要了解 if 的嵌套。

if 嵌套：
在基础条件满足的情况下，再在基础条件里面增加额外的判断条件，即条件里套条件。

if嵌套

time = 13
num = 2

if (time >= 9) and (time <= 23):
    print("在打折时间内")

    if num >= 2:
        print("全场八折")

代码的作用
本例第1、2行代码分别将时间13和数量2赋值给了变量 time 和 num 。
第4、5行代码判断了如果变量 time 大于等于9并且小于等于23，就输出"在打折时间内"。
第7、8行代码在变量 time 大于等于9并且小于等于23成立的条件下，判断了如果变量 num 大于等于2，就输出"全场八折"。

外层条件
第一层判断条件 if 。
首先判断了如果变量 time 大于等于9并且小于等于23，就输出"在打折时间内"。

内层条件
第二层判断条件 if 。
在第一层判断变量 time 大于等于9并且小于等于23成立的条件下，判断了如果变量 num 大于等于2，就输出"全场八折"。

缩进四格
Python是以缩进的空格数来区分代码块的。
如果外层条件和内层条件的代码块都采用同样的缩进，Python 就没办法区分内外层条件是如何嵌套的。
在这里，外层条件 if 语句内的代码块缩进四个空格。

缩进八格
在将内层条件 if 语句写进外层条件的执行分支时，内层条件 if语句内的代码块要在原有缩进的基础上，再增加相应的缩进。
在这里，内层条件 if 语句内的代码块在外层条件内的代码块缩进的基础上再加四个空格，也就是八个空格。

注意⚠️ ：缩进在Python语法规则中扮演重要的角色

执行顺序
把 if 嵌套的执行顺序，梳理成流程图后，再来整理一下程序运行流程。
如图所示，嵌套的原则是先确定外层条件再确定内层条件，只有当外层条件成立时，才有可能进入到内层条件当中继续执行。

需要注意的是，在相互嵌套时，一定要严格遵守不同级别代码块的缩进规范。
每嵌套一层都需要在原有缩进的基础上，再增加相应的缩进。

代码小结
当要使用 if 嵌套时，就可以用这样的格式

不仅是 if 嵌套 ，在Python中，if 、if-else 和 if -elif-else 之间也可以相互嵌套。
嵌套原则与 if 嵌套类似。

如图所示，这是一段能实现分组和判断成绩的代码。
1个外层条件 if-else 语句判断变量 gender 的值，确定男女分组，2个内层条件 if-else 语句判断变量 score 的值，确定成绩情况。

值得注意的是，虽然使用嵌套可以大大提高代码的逻辑性和层次感。
但是，任何东西都不能过度使用。
一般来说，超过3层以上的嵌套会使代码变得难以阅读，不符合Python简洁表达的理念。