在 Python 中使用“and”布尔运算符

目录

Python中有三个布尔运算符或逻辑运算符：and，or，和not。在决定程序将遵循的执行路径之前，您可以使用它们来检查是否满足某些条件。在本教程中，您将了解and运算符以及如何在代码中使用它。

在本教程中，您将学习如何：

• 理解Python操作符背后的逻辑and
• 构建和理解使用运算符的布尔和非布尔表达式and
• and在布尔上下文中使用运算符来决定程序的操作过程
• and在非布尔上下文中使用运算符使您的代码更简洁

您还将编写一些实际示例，这些示例将帮助您了解如何使用and运算符以Pythonic 的方式处理不同的问题。即使您没有使用 的所有功能and，了解它们也能让您编写更好、更准确的代码。

在 Python 中使用布尔逻辑

早在 1854 年，George Boole 就撰写了The Laws of Thought，其中包含所谓的布尔代数。该代数依赖于两个值：true和false。它还定义了一组布尔操作的，也被称为逻辑运算，由通用运算符表示AND，OR，和NOT。

这些布尔值和运算符在编程中非常有用。例如，您可以使用运算符构造任意复杂的布尔表达式，并确定它们的结果真值是真还是假。您可以使用布尔表达式的真值来决定程序的动作过程。

在 Python 中，Boolean 类型 bool是 的子类，int可以采用值Trueor False：

>>> issubclass(bool, int)
True
>>> help(bool)
Help on class bool in module builtins:

class bool(int)
    ...

>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>

>>> isinstance(True, int)
True
>>> isinstance(False, int)
True

>>> int(True)
1
>>> int(False)
0

正如您在这段代码中看到的那样，Python 实现bool为int具有两个可能值的子类，True以及False。这些值是Python中的内置常量。他们在内部为整数来实现的数字与值1的True和0为False。请注意，True和 都False必须大写。

除了bool类型之外，Python 还提供了三个布尔运算符或逻辑运算符，允许您将布尔表达式和对象组合成更复杂的表达式。这些运算符如下：

使用这些运算符，您可以连接多个布尔表达式和对象来构建您自己的表达式。与其他语言不同，Python 使用英文单词来表示布尔运算符。这些词是语言的关键字，因此您不能将它们用作标识符。

在本教程中，您将了解 Python 的and运算符。该运算符实现逻辑AND运算。您将了解它的工作原理以及如何在布尔或非布尔上下文中使用它。

Pythonand运算符入门

Python 的and运算符接受两个操作数，它们可以是布尔表达式、对象或组合。使用这些操作数，and运算符可以构建更复杂的表达式。and表达式中的操作数通常称为条件。如果两个条件都为真，则and表达式返回真结果。否则，它返回一个错误的结果：

>>> True and True
True

>>> False and False
False

>>> True and False
False

>>> False and True
False

这些示例表明，and表达式仅True在表达式中的两个操作数都为真时才返回。由于and运算符需要两个操作数来构建表达式，因此它是一个二元运算符。

上面的快速示例显示了所谓的and运算符真值表：

此表总结了布尔表达式（如 ）的结果真值operand1 and operand2。表达式的结果取决于其操作数的真值。如果两者都是真的，那就是真的。否则就是假的。这是and操作符背后的一般逻辑。但是，此运算符可以做的比 Python 中的多。

在以下部分中，您将学习如何使用and不同类型的操作数来构建您自己的表达式。

>>> 5 == 3 + 2
True
>>> 5 > 3
True
>>> 5 < 3
False
>>> 5 != 3
True

>>> [5, 3] == [5, 3]
True

>>> "hi" == "hello"
False

>>> 5 > 3 and 5 == 3 + 2
True

>>> 5 < 3 and 5 == 5
False

>>> 5 == 5 and 5 != 5
False

>>> 5 < 3 and 5 != 5
False

expression1 and expression2

>>> 5 > 3 and 5 == 3 + 2 and 5 != 3
True

>>> 5 < 3 and 5 == 3 and 5 != 3
False

短路评估

Python 的逻辑运算符，例如andand or，使用称为短路求值或惰性求值的东西。换句话说，Python仅在需要时评估右侧的操作数。

为了确定and表达式的最终结果，Python 从评估左操作数开始。如果为假，则整个表达式为假。在这种情况下，无需计算右侧的操作数。Python 已经知道最终结果。

左操作数为假会自动使整个表达式为假。评估剩余的操作数会浪费 CPU 时间。Python 通过短路评估来防止这种情况。

相反，and运算符仅在第一个操作数为真时才对右侧的操作数求值。在这种情况下，最终结果取决于右操作数的真值。如果为真，则整个表达式为真。否则，表达式为假。

要演示短路功能，请查看以下示例：

>>> def true_func():
...     print("Running true_func()")
...     return True
...

>>> def false_func():
...     print("Running false_func()")
...     return False
...

>>> true_func() and false_func()  # Case 1
Running true_func()
Running false_func()
False

>>> false_func() and true_func()  # Case 2
Running false_func()
False

>>> false_func() and false_func()  # Case 3
Running false_func()
False

>>> true_func() and true_func()  # Case 4
Running true_func()
Running true_func()
True

下面是这段代码的工作原理：

• 情况 1：Python 求值true_func()，返回True. 为了确定最终结果，Python 计算false_func()并获取False. 您可以通过查看两个函数的输出来确认这一点。
• 情况 2：Python 求值false_func()，返回False。Python 已经知道最终结果是False，所以它不会评估true_func()。
• 案例 3：Python 运行false_func()并得到False结果。它不需要第二次评估重复函数。
• 案例 4：Python 求值true_func()并得到True结果。然后它再次评估该函数。由于两个操作数都计算为True，因此最终结果为True。

Python 从左到右处理布尔表达式。当它不再需要评估任何进一步的操作数或子表达式来确定最终结果时，它就会停止。总结这个概念，您应该记住，如果and表达式中的左操作数为假，则不会计算右操作数。

短路评估会对代码的性能产生重大影响。要利用这一点，请在构建and表达式时考虑以下提示：

• 将耗时的表达式放在and关键字的右侧。这样，如果短路规则生效，代价高的表达式就不会运行。
• 将更可能为假的表达式放在and关键字的左侧。这样，Python 更有可能仅通过评估左操作数来确定整个表达式是否为假。

有时您可能希望避免在特定布尔表达式中进行惰性求值。您可以通过使用按位运算符( &, |, ~) 来实现。这些运算符也适用于布尔表达式，但它们会急切地评估操作数：

>>> def true_func():
...     print("Running true_func()")
...     return True
...

>>> def false_func():
...     print("Running false_func()")
...     return False
...

>>> # Use logical and
>>> false_func() and true_func()
Running false_func()
False

>>> # Use bitwise and
>>> false_func() & true_func()
Running false_func()
Running true_func()
False

在第一个表达式中，and运算符按预期工作延迟。它计算第一个函数，由于结果为假，它不计算第二个函数。然而，在第二个表达式中，&即使第一个函数返回，按位 AND 运算符 ( ) 也会急切地调用这两个函数False。请注意，在这两种情况下，最终结果都是False。

尽管此技巧有效，但通常不鼓励使用。您应该使用按位运算符来操作位，使用布尔运算符来处理布尔值和表达式。要更深入地了解按位运算符，请查看Python 中的按位运算符。

and对通用对象使用 Python 的运算符

您可以使用and运算符将两个 Python 对象组合到一个表达式中。在这种情况下，Python 在内部使用bool()来确定操作数的真值。因此，您将获得特定对象而不是布尔值。你只得到True或者False如果给定的操作数显式计算结果为True或False：

>>> 2 and 3
3

>>> 5 and 0.0
0.0

>>> [] and 3
[]

>>> 0 and {}
0

>>> False and ""
False

在这些示例中，and如果计算结果为，则表达式返回左侧的操作数False。否则，它返回右边的操作数。为了产生这些结果，and运算符使用 Python 的内部规则来确定对象的真值。Python 文档说明了这些规则，如下所示：

默认情况下，一个对象被认为是真，除非它的类定义了一个__bool__()返回False的__len__()方法或一个返回零的方法，当与对象一起调用时。以下是大多数被认为是 false 的内置对象：

• 常量定义为 false:None和False.
• 任何数字类型的零：0, 0.0, 0j, Decimal(0),Fraction(0, 1)
• 空序列和集合：'', (), [], {}, set(),range(0)

（来源）

考虑到这些规则，再次查看上面的代码。在第一个示例中，整数2为真（非零），因此and返回正确的操作数3。在第二个示例中，5为真，因此and即使计算结果为 ，也会返回正确的操作数False。

下一个示例使用空列表 ( []) 作为左操作数。由于空列表的计算结果为 false，因此该and表达式返回空列表。获得True或的唯一情况False是在表达式中显式使用布尔对象。

以下是and当您将运算符与常见 Python 对象而不是布尔表达式一起使用时，您可以如何总结该运算符的行为。请注意，Python 使用每个对象的真值来确定最终结果：

通常，如果and表达式中的操作数是对象而不是布尔表达式，则运算符会在其计算结果为 时返回左侧的对象False。否则，它会返回右侧的对象，即使它的计算结果为False。

混合布尔表达式和对象

您还可以在and表达式中组合布尔表达式和常见的 Python 对象。在这种情况下，如果and表达式为假，则表达式仍返回左操作数，否则返回右操作数。返回值可以是True、False或常规对象，具体取决于表达式的哪一部分提供该结果：

>>> 2 < 4 and 2
2
>>> 2 and 2 < 4
True

>>> 2 < 4 and []
[]
>>> [] and 2 < 4
[]

>>> 5 > 10 and {}
False
>>> {} and 5 > 10
{}

>>> 5 > 10 and 4
False
>>> 4 and 5 > 10
False

这些示例使用布尔表达式和常见对象的组合。在每对示例中，您会看到可以获取非布尔对象或布尔值，True或False. 结果将取决于表达式的哪一部分提供了最终结果。

下表总结了and组合布尔表达式和常见 Python 对象时运算符的行为：

为了找出返回的内容，Python 计算左侧的布尔表达式以获取其布尔值（True或False）。然后 Python 使用其内部规则来确定右侧对象的真值。

作为测试您理解的练习，您可以尝试通过将第三列中的操作数的顺序交换为 来重写此表object and expression。尝试预测每行将返回什么。

组合 Python 逻辑运算符

正如您在本教程前面看到的，Python 提供了两个额外的逻辑运算符：or运算符和not运算符。您可以将它们与and运算符一起使用来创建更复杂的复合表达式。如果要使用多个逻辑运算符做出准确清晰的表达式，则需要考虑每个运算符的优先级。换句话说，您需要考虑 Python 执行它们的顺序。

与其他运算符相比，Python 的逻辑运算符的优先级较低。但是，有时使用一对括号 ( ()) 来确保一致且可读的结果是有益的：

>>> 5 or 2 and 2 > 1
5

>>> (5 or 3) and 2 > 1
True

这些示例将or运算符和and运算符组合在一个复合表达式中。就像and运算符一样，运算or符使用短路评估。and然而，与 不同的是，or一旦找到真正的操作数，运算符就会停止。您可以在第一个示例中看到这一点。由于5为真，or子表达式立即返回5而不计算表达式的其余部分。

相比之下，如果将or子表达式括在一对括号中，则它可以作为单个真操作数工作，并且2 > 1也会被评估。最终结果是True。

要点是，如果您在单个表达式中使用多个逻辑运算符，那么您应该考虑使用括号来明确您的意图。这个技巧还将帮助您获得正确的逻辑结果。

and在布尔上下文中使用 Python 的运算符

像所有 Python 的布尔运算符一样，and运算符在布尔上下文中特别有用。您可以在布尔上下文中找到布尔运算符的大多数实际用例。

两个主要结构在 Python 中定义了布尔上下文：

1. if语句让您执行条件执行并根据某些初始条件的结果采取不同的行动方案。
2. while循环允许您执行条件迭代并在给定条件为真时运行重复性任务。

这两个结构是您所谓的控制流语句的一部分。它们帮助您决定程序的执行路径。

您可以使用 Python 的and运算符在if语句和while循环中构造复合布尔表达式。

if 声明

布尔表达式通常被称为条件，因为它们通常意味着需要满足给定的要求。它们在条件语句的上下文中非常有用。在 Python 中，这种类型的语句以if关键字开头并以条件结尾。条件语句还可以包含elifandelse子句。

Python 条件语句遵循英语语法中的条件逻辑。如果条件为真，则if执行代码块。否则，执行跳转到不同的代码块：

>>> a = -8

>>> if a < 0:
...     print("a is negative")
... elif a > 0:
...     print("a is positive")
... else:
...     print("a is equal to 0")
...
a is negative

由于a持有负数，条件a < 0为真。该if代码块中运行，而你得到的消息a is negative 印在屏幕上。a但是，如果将 的值更改为正数，则elif块会运行并且 Python 会打印a is positive. 最后，如果您设置a为零，则else代码块将执行。继续玩，a看看会发生什么！

现在假设您要确保在运行某段代码之前满足两个条件——这意味着它们都为真。要尝试此操作，假设您需要获取运行脚本的用户的年龄，处理该信息，并向用户显示他们当前的生命阶段。

启动您最喜欢的代码编辑器或 IDE并创建以下脚本：

# age.py

age = int(input("Enter your age: "))

if age >= 0 and age <= 9:
    print("You are a child!")
elif age > 9 and age <= 18:
    print("You are an adolescent!")
elif age > 18 and age <= 65:
    print("You are an adult!")
elif age > 65:
    print("Golden ages!")

在这里，您使用用户的年龄input()，然后使用将其转换为整数int()。该if子句检查是否age大于或等于0。在同一个子句中，它检查是否age小于或等于9。为此，您需要构建一个and复合布尔表达式。

这三个elif子句检查其他时间间隔以确定与用户年龄相关的生命阶段。

如果您从命令行运行此脚本，则会得到如下内容：

$ python age.py
Enter your age: 25
You are an adult!

根据您在命令行中输入的年龄，脚本会采取一种或另一种行动。在此特定示例中，您提供 25 岁的年龄，并将消息You are an adult!打印到您的屏幕上。

while 循环

的while环是可使用的第二构建and表达式来控制程序的执行流程。通过and在while语句头中使用运算符，您可以测试多个条件并在满足所有条件时重复循环的代码块。

假设您正在为制造商设计控制系统的原型。该系统有一个关键机制，应在 500 psi 或更低的压力下工作。如果压力超过 500 psi 而保持在 700 psi 以下，则系统必须运行一系列给定的标准安全操作。对于大于 700 psi 的压力，系统必须运行一套全新的安全措施。

要解决此问题，您可以使用while带有and表达式的循环。这是一个模拟可能解决方案的脚本：

 1# pressure.py
 2
 3from time import sleep
 4from random import randint
 5
 6def control_pressure():
 7    pressure = measure_pressure()
 8    while True:
 9        if pressure <= 500:
10            break
11
12        while pressure > 500 and pressure <= 700:
13            run_standard_safeties()
14            pressure = measure_pressure()
15
16        while pressure > 700:
17            run_critical_safeties()
18            pressure = measure_pressure()
19
20    print("Wow! The system is safe...")
21
22def measure_pressure():
23    pressure = randint(490, 800)
24    print(f"psi={pressure}", end="; ")
25    return pressure
26
27def run_standard_safeties():
28    print("Running standard safeties...")
29    sleep(0.2)
30
31def run_critical_safeties():
32    print("Running critical safeties...")
33    sleep(0.7)
34
35if __name__ == "__main__":
36    control_pressure()

在 中control_pressure()，您while在第 8 行创建一个无限循环。如果系统稳定且压力低于 500 psi，则条件语句跳出循环，程序结束。

在第 12 行，第一个嵌套while循环运行标准安全操作，而系统压力保持在 500 psi 和 700 psi 之间。在每次迭代中，循环都会获得一个新的压力测量值，以便在下一次迭代中再次测试条件。如果压力超过 700 psi，则第 16 行上的第二个回路将运行关键安全操作。

def control_pressure():
    while True:
        pressure = measure_pressure()
        if pressure > 700:
            run_critical_safeties()
        elif 500 < pressure <= 700:
            run_standard_safeties()
        elif pressure <= 500:
            break
    print("Wow! The system is safe...")

要运行此脚本，请打开命令行并输入以下命令：

$ python pressure.py
psi=756; Running critical safeties...
psi=574; Running standard safeties...
psi=723; Running critical safeties...
psi=552; Running standard safeties...
psi=500; Wow! The system is safe...

屏幕上的输出应该与此示例输出略有不同，但您仍然可以了解应用程序的工作原理。

and在非布尔上下文中使用 Python 的运算符

这个事实and可以返回对象除了刚才True和False是一个有趣的功能。例如，此功能允许您使用and运算符进行条件执行。假设您需要更新一个flag变量，如果给定列表中的第一项等于某个预期值。对于这种情况，您可以使用条件语句：

>>> a_list = ["expected value", "other value"]
>>> flag = False

>>> if len(a_list) > 0 and a_list[0] == "expected value":
...     flag = True
...

>>> flag
True

在这里，条件检查列表是否至少有一项。如果是，则检查列表中的第一项是否等于"expected value"字符串。如果两项检查都通过，flag则更改为True。您可以利用and运算符来简化此代码：

>>> a_list = ["expected value", "other value"]
>>> flag = False

>>> flag = len(a_list) > 0 and a_list[0] == "expected value"

>>> flag
True

在此示例中，突出显示的行完成了所有工作。它检查两个条件并一次性完成相应的分配。此表达式and从if您在前一个示例中使用的语句中取出运算符，这意味着您不再在布尔上下文中工作。

上面示例中的代码比您之前看到的等效条件语句更简洁，但可读性较差。要正确理解此表达式，您需要了解and运算符内部的工作方式。

将 Python 的and运算符付诸实践

到目前为止，您已经学习了如何使用 Python 的and运算符来创建复合布尔表达式和非布尔表达式。您还学习了如何在if语句和while循环等布尔上下文中使用此逻辑运算符。

在本节中，您将构建一些实际示例，以帮助您决定何时使用and运算符。通过这些示例，您将学习如何利用and编写更好、更多 Pythonic 的代码。

>>> number = 7

>>> if number > 0:
...     if number < 10:
...         # Do some calculation with number...
...         print("Calculation done!")
...
Calculation done!

>>> number = 7

>>> if number > 0 and number < 10:
...     # Do some calculation with number...
...     print("Calculation done!")
...
Calculation done!

>>> x = 5
>>> x >= 0 and x <= 10
True

>>> x = 20
>>> x >= 0 and x <= 10
False

>>> def is_between(number, start=0, end=10):
...     return number >= start and number <= end
...

>>> is_between(5)
True
>>> is_between(20)
False

>>> is_between(20, 10, 40)
True

>>> for number in range(-100, 100):
...     included = number < 0 and number > 10
...     print(f"Is {number} included?", included)
...
Is -100 included? False
Is -99 included? False

...

Is 0 included? False
Is 1 included? False

...

Is 98 included? False
Is 99 included? False

>>> x = 5
>>> 0 < x < 10
True

>>> x = 20
>>> 0 < x < 10
False

>>> x = 5
>>> y = 15

>>> 0 < x < 10 < y < 20

>>> # Equivalent and expression
>>> 0 < x and x < 10 and 10 < y and y < 20
True

>>> x = 10
>>> y = 10
>>> z = 10

>>> x == y == z
True

>>> # Equivalent and expression
>>> x == y and y == z
True

有条件地链接函数调用

如果您曾经在Unix 系统上使用过Bash，那么您可能知道这种构造。这是一种方便的技术，允许您在链中运行多个命令。当且仅当前一个命令成功时，每个命令才会运行：command1 && command2

$ cd /not_a_dir && echo "Success"
bash: cd: /not_a_dir: No such file or directory

$ cd /home && echo "Success"
Success

这些示例使用 Bash 的短路 AND 运算符 ( &&) 使echo命令的执行依赖于命令的成功cd。

由于 Pythonand也实现了惰性求值的思想，您可以用它来模拟这个 Bash 技巧。例如，您可以在单个and表达式中链接一系列函数调用，如下所示：

func1() and func2() and func3() ... and funcN()

在这种情况下，Python 调用func1(). 如果函数的返回值计算为真值，则 Python 调用func2()，依此类推。如果其中一个函数返回 false 值，则 Python 将不会调用其余函数。

下面是一个使用一些pathlib函数来操作文本文件的示例：

>>> from pathlib import Path
>>> file = Path("hello.txt")
>>> file.touch()

>>> # Use a regular if statement
>>> if file.exists():
...     file.write_text("Hello!")
...     file.read_text()
...
6
'Hello!'

>>> # Use an and expression
>>> file.exists() and file.write_text("Hello!") and file.read_text()
'Hello!'

好的！在一行代码中，您无需if语句即可有条件地运行三个函数。在这个特定示例中，唯一可见的区别是.write_text()返回它写入文件的字节数。交互式 shell 会自动将该值显示在屏幕上。请记住，当您将代码作为脚本运行时，这种差异是不可见的。

结论

Python 的and运算符允许您构建复合布尔表达式，您可以使用这些表达式来决定程序的操作过程。您可以使用and运算符解决布尔或非布尔上下文中的多个问题。了解如何and正确使用运算符可以帮助您编写更多Pythonic代码。

在本教程中，您学习了如何：

• 使用 Python 的and运算符
• 使用 Python 的运算符构建布尔和非布尔表达式and
• 决定行动方针使用你的程序的and操作在布尔上下文
• and在非布尔上下文中使用运算符使您的代码更简洁

通过本教程中的实际示例可以帮助您大致了解如何使用and运算符在 Python 代码中做出决策。