判断语句

布尔对象

布尔(英文叫 bool )对象是只有两种取值的对象: TrueFalse

对应 , 或者说

很多事情的回答 只有正反两种答案: 是 或者 否

比如: 今天是星期天吗?

要么 是 ,要么 否。

Python中的布尔对象 对应 只有两种取值。

其中 True 对应 是, False 对应 否。



布尔表达式

产生布尔值的表达式,就是 布尔表达式

通常有如下几种


是否相等

是否相等的表达式 像这样

1 == 1

== 连接两个比较对象。

如果 两个比较对象相等,解释器运算结果为 True

如果不相等,解释器运算结果为 False


请运行Python解释器命令行,输入如下语句

1 == 1

返回值为 True

1 == 2

返回值为 False

1 == '1'

返回值为 False。想一想,为什么?

'1' == '1'

返回值为 True

是否不相等

!= 连接两个比较对象。

如果两个比较对象不相等,解释器运算结果为 True

如果相等,解释器运算结果为 False


请运行Python解释器命令行,输入如下语句

1 != 1

返回值为 False

1 != 2

返回值为 True

1 != '1'

返回值为 True

'1' != '1'

返回值为 False

是否大于

> 连接两个比较对象。

如果前面的对象大于后面的对象,解释器运算结果为 True

否则,运算结果为 False


请运行Python解释器命令行,输入如下语句

1 > 1

返回值为 False

1 > 0

返回值为 True

1 > 2 

返回值为 False

是否大于等于

>= 连接两个比较对象。

如果前面的对象大于或者等于后面的对象,解释器运算结果为 True

否则,运算结果为 False


请运行Python解释器命令行,输入如下语句

1 >= 1

返回值为 True

1 >= 0

返回值为 True

1 >= 2 

返回值为 False

是否小于

< 连接两个比较对象。

如果前面的对象小于后面的对象,解释器运算结果为 True

否则,运算结果为 False


请运行Python解释器命令行,输入如下语句

1 < 1

返回值为 False

1 < 0

返回值为 False

1 < 2 

返回值为 True

是否小于等于

<= 连接两个比较对象。

如果前面的对象小于或者等于后面的对象,解释器运算结果为 True

否则,运算结果为 False


请运行Python解释器命令行,输入如下语句

1 <= 1

返回值为 True

1 <= 0

返回值为 False

1 <= 2 

返回值为 True

条件组合

有的时候,条件表达式 还会 组合起来 成为一个更大的表达式

条件表达式 主要有3 种组合关系

且 的 条件组合

这种组合关系是用 and 关键字 连接的,如下

表达式1  and  表达式2

这种组合,只有表达式1 和 表达式2 都成立 (也就是计算结果都为True),最终的结果才成立(为True)

任何一个表达式为 False ,结果都是False

你可以打开Python解释器,依次输入如下的语句,看看结果是什么

True   and  True    # 结果为 True
True   and  False   # 结果为 False
False  and  True    # 结果为 False
False  and  False   # 结果为 False

num1 = 5
str1 = 'ok'
num1 > 4  and  str1 == 'ok'   # 结果为 True
num1 > 4  and  str1 == 'bad'  # 结果为 False
num1 > 6  and  str1 == 'ok'   # 结果为 False
num1 > 6  and  str1 == 'bad'  # 结果为 False

num1 > 4  and  str1 == 'ok' and  num1 > 5 # 结果为 False

或 的 条件组合

这种组合关系是用 or 关键字 连接的,如下

表达式1  or  表达式2

这种组合,只要表达式1 和 表达式2 任何一个成立 (也就是任何一个计算结果为True),最终的结果才成立(为True)

如果两个表达式计算结果都为 False ,结果才是False

你可以打开Python解释器,依次输入如下的语句,看看结果是什么

True   or  True    # 结果为 True
True   or  False   # 结果为 True
False  or  True    # 结果为 True
False  or  False   # 结果为 False

num1 = 5
str1 = 'ok'
num1 > 4  or  str1 == 'ok'   # 结果为 True
num1 > 4  or  str1 == 'bad'  # 结果为 True
num1 > 6  or  str1 == 'ok'   # 结果为 True
num1 > 6  or  str1 == 'bad'  # 结果为 False

num1 > 6  or  str1 == 'ok' or  num1 != 5  # 结果为 True
num1 > 6  or  str1 == 'sk' or  num1 != 5  # 结果为 False


如果 and 和 or 一起使用, 注意 是先计算 and 部分, 其结果 再和 or 一起计算

比如:

这个表达式

6 > 5  or  'sk' == 'sk' and  4 == 5

就要先计算

'sk' == 'sk' and  4 == 5

结果是 False

然后这个False 再和前面的计算,就是

6 > 5  or  False

所以最后的结果是True


如果我们就是想要: 先计算前面的or 部分, 然后再和 后面 and 一起计算呢?

那么就可以使用括号,想这样

(6 > 5  or  'sk' == 'sk') and  4 == 5

就要先计算

(6 > 5  or  'sk' == 'sk') 

结果是 True

然后这个结果 True 再和前面的计算,就是

True and  4 == 5

所以最后的结果是False

可以看出, 不用的优先级会导致不同的结果



not 的 合条件组

这种组合其实就是把后面的布尔表达式的结果反过来

这种组合关系是用 not 关键字 的,如下

not 表达式1

not 加在条件表达式1的前面,会反转其结果。

表达式1 计算结果为True, 最终的结果为 False

表达式1 计算结果为False,最终的结果为 True

你可以打开Python解释器,依次输入如下的语句,看看结果是什么

not  True    # 结果为 False
not  False   # 结果为 True


num1 = 5
str1 = 'ok'
not num1 > 4      # 结果为 False
not str1 == 'sk'  # 结果为 True


如果 and 和 or 一起使用, 注意 是先计算 not , 再计算 and 部分, 最后再计算 or

这样的表达式

not 4 > 6  or  'sk' == 'ok' and  4 > 3

先计算 not 4 > 6 得到 True

再计算 'sk' == 'ok' and 4 > 3 得到 False

将上面的结果 用 or 连接 ,就是 True or False ,所以最后结果是 True

如果大家想了解完整的Python运算符的优先级,可以点击这里,参考官网操作符优先级表



判断语句

上面的这些布尔表达式都表示了一个结果, True 还是 False。

那么这些表达式有什么用呢?

主要是用在判断语句中。

判断语句是根据 某个条件 决定是否要执行一些代码。

如果这个条件 对应的表达式结果 为True ,就表示条件成立,就去执行,否则就不执行。

判断语句是用 if ... elif ... else ... 关键字引导的

我们看一个例子。



我们假设 某个国家的 出租车 计费 有如下规则。

里程 收费
<= 3公里 20 元/每公里
>3公里 15 元/每公里

我们要写一个函数,计算费用,可以这样写

def charge(miles):
    if miles <=3:
        print('20 元/每公里')
        return miles*20
    else:
        print('15 元/每公里')
        return miles*15

if 后面的 miles <=3 就是一个布尔表达式,如果其计算结果是 True,就执行紧接着下面缩进的代码。

这里就是:

print('20 元/每公里')
return miles*20

如果 if 后面的表达式结果为False 就不会执行它


如果有 else 部分, 表示当前面if 后面的 表达式结果是False ,就去执行 else 下面缩进的代码。

这里就是:

print('15 元/每公里')
return miles*15

如果 if 后面的表达式结果为True, 就不会执行它。

可以这样分别调用该函数,看看什么结果

charge(3)  # 执行 if 下面缩进的代码

charge(5)  # 执行 else 下面缩进的代码



如果有更多的判断逻辑,就需要使用 elif

比如,计费规则更多一些

里程 收费
<= 3公里 20 元/每公里
>3公里 且 <= 5公里 15 元/每公里
>5公里 且 <= 8公里 12 元/每公里
>8公里 10 元/每公里

就可以这样写

def charge(miles):
    if miles <=3:
        print('20 元/每公里')
        return miles*20
    elif miles <=5:   # 当不满足 miles <=3 的时候
        print('15 元/每公里')
        return miles*15
    elif miles <=8:   # 当不满足  miles <=3 也不满足miles <=5  的时候
        print('12 元/每公里')
        return miles*12
    else: # 当不满足 miles <=3 也不满足 miles <=5 也不满足 miles <=8 的时候
        print('10 元/每公里')
        return miles*10

解释器执行上面的条件语句的时候,是顺序进行判断的,

当第1个条件 miles <=3 成立的话,就执行对应下面的缩进代码,

        print('20 元/每公里')
        return miles*20

如果不成立,继续看后面的 elif 的条件 miles <=3 。 如果成立,就执行对应下面的缩进代码

        print('15 元/每公里')
        return miles*15

如果不成立,继续看后面的 elif 的条件 miles <=8 。 如果成立,就执行对应下面的缩进代码

        print('12 元/每公里')
        return miles*12

如果不成立,就执行最后的else 对应下面的缩进代码,

        print('10 元/每公里')
        return miles*10



注意 elif 和else 的区别是 :

elif 后面会有一个 条件表达式, 而 else 没有


当然 if 和 elif 后面 的条件表达式可以是一个复合表达式,比如

计费规则 和乘车时间 也有关系

里程 时间 收费
<= 3公里 <= 1小时 20 元/每公里
>3公里 <= 1小时 15 元/每公里
def charge(miles, duration):
    if miles <= 3 and duration <= 1:
        print('20 元/每公里')
        return miles*20
    elif miles > 3 and duration <= 1 :
        print('15 元/每公里')
        return miles*15



条件判断嵌套

有的时候,代码再条件判断中还需要有条件判断

比如,如果上面的计费规则更多一些

里程 时间 收费
<= 3公里 <= 1小时 20 元/每公里
  > 1小时 22 元/每公里
>3公里 <= 1小时 15 元/每公里
  > 1小时 18 元/每公里

就可以像下面这样,在条件判断后面缩进的代码里面继续使用条件判断

def charge(miles, duration):
    if miles <= 3 
        if  duration <= 1:
            print('20 元/每公里')
            return miles*20
        else:
            print('22 元/每公里')
            return miles*22
    elif miles > 3 :
        if  duration <= 1:
            print('15 元/每公里')
            return miles*15
        else:
            print('18 元/每公里')
            return miles*18

要注意的是 里面的条件判断 成立后的代码还要 再次缩进




课后练习

去做练习

上一页 下一页