在 Python 中使用“and”布尔运算符（在线翻译器）

目录

在 Python 中使用布尔逻辑

Python 和运算符入门

在布尔表达式中使用 Python 和运算符

短路评估

对通用对象使用 Python 和运算符

混合布尔表达式和对象

组合 Python 逻辑运算符

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

if 语句

while 循环

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

将 Python 和 Operator 付诸行动

扁平化嵌套 if 语句

检查数值范围

有条件地链接函数调用

结论

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) >>> type(False) >>> 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不同类型的操作数来构建您自己的表达式。

and在布尔表达式中使用 Python 的运算符

您通常会使用逻辑运算符来构建复合布尔表达式，它们是产生布尔值的变量和值的组合。换句话说，布尔表达式返回Trueor False。

比较和相等测试是此类表达式的常见示例：

>>>

>>> 5 == 3 + 2 True >>> 5 > 3 True >>> 5 < 3 False >>> 5 != 3 True >>> [5, 3] == [5, 3] True >>> "hi" == "hello" False

所有这些表达式都返回Trueor False，这意味着它们是布尔表达式。您可以使用and关键字将它们组合起来，以创建一次测试两个或多个子表达式的复合表达式：

>>>

>>> 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

在这里，当您组合两个True表达式时，您会得到True结果。任何其他组合返回False。从这些示例中，您可以得出结论，使用and运算符创建复合布尔表达式的语法如下：

expression1 and expression2

如果子表达式expression1和expression2计算结果都为True，则复合表达式为True。如果至少一个子表达式的计算False结果为 ，则结果为False。

and构建复合表达式时可以使用的运算符数量没有限制。这意味着您可以使用多个and运算符在单个表达式中组合两个以上的子表达式：

>>>

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

同样，如果所有子表达式的计算结果都为True，那么您将得到True。否则，您将获得False. 特别是当表达式变长时，您应该记住 Python 从左到右依次计算表达式。

短路评估

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是在表达式中显式使用布尔对象。

注意：如果您需要获取True或False来自and涉及公共对象而不是布尔表达式的表达式，则可以使用bool(). 此内置函数显式返回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 中定义了布尔上下文：

if语句让您执行条件执行并根据某些初始条件的结果采取不同的行动方案。

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 行上的第二个回路将运行关键安全操作。

注意：上例中的实现control_pressure()旨在展示and操作符如何在while循环上下文中工作。

但是，这不是您可以编写的最有效的实现。您可以重构control_pressure()以使用单个循环而不使用and：

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...")

在这个替代实现中and，您使用链式表达式而不是 using ，500 < pressure <= 700它的作用相同，pressure > 500 and pressure <= 700但更干净，更 Pythonic。另一个优点是您measure_pressure()只调用一次，这最终会更有效率。

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

$ 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 的代码。

扁平化嵌套if语句

Python之禅的一项原则指出“扁平优于嵌套”。例如，虽然具有两级嵌套if语句的代码是正常的并且完全没问题，但是当您有两级以上的嵌套时，您的代码确实开始看起来混乱和复杂。

假设您需要测试给定的数字是否为正数。然后，一旦您确认它是正数，您就需要检查该数字是否低于给定的正值。如果是，您可以使用手头的数字进行特定计算：

>>>

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

凉爽的！这两个嵌套if语句解决了您的问题。您首先检查数字是否为正，然后检查它是否小于10。在这个小例子中，print()对你的特定计算的调用是一个占位符，只有当两个条件都为真时才会运行。

即使代码有效，通过删除嵌套的if. 你怎么能这样做？好吧，您可以使用and运算符将两个条件组合在一个复合条件中：

>>>

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

像and运算符这样的逻辑运算符通常提供一种通过删除嵌套条件语句来改进代码的有效方法。尽可能利用它们。

在此特定示例中，您and将创建一个复合表达式，用于检查数字是否在给定的范围或区间内。Python 通过链接表达式提供了一种更好的方法来执行此检查。例如，您可以将上面的条件写为0 < number < 10。这是下一节的主题。

检查数值范围

仔细查看下一节中的示例，您可以得出结论，Python 的and运算符是检查特定数值是否在给定区间或范围内的便捷工具。例如，以下表达式检查数字x是否在0和之间10，包括两个：

>>>

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

在第一个表达式中，and运算符首先检查是否x大于或等于0。由于条件为真，and运算符检查是否x小于或等于10。最终结果为真，因为第二个条件也为真。这意味着该数字在所需的间隔内。

在第二个示例中，第一个条件为真，但第二个条件为假。一般结果为假，这意味着该数字不在目标区间内。

您可以将此逻辑包含在一个函数中并使其可重用：

>>>

>>> 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

在此示例中，is_between()将number作为参数。它还需要start和end，它定义了目标间隔。请注意，这些参数具有默认参数值，这意味着它们是可选参数。

您的is_between()函数返回计算and表达式的结果，该表达式检查是否number在start和之间end，包括两者。

注意：无意中编写and总是返回的表达式False是一个常见的错误。假设你要编写一个表达式之间排除值0，并10从给定的计算。

为了达到这个结果，你从两个布尔表达式开始：

number < 0

number > 10

以这两个表达式为起点，您可以考虑使用and将它们组合成一个复合表达式。但是，没有任何数字同时小于0和大于10，因此您最终会遇到始终为假的情况：

>>>

>>> 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

在这种情况下，and处理手头问题的逻辑运算符是错误的。您应该改用or运算符。来试试看吧！

尽管使用and运算符可以让您优雅地检查一个数字是否在给定的间隔内，但还有一种更 Pythonic 的技术可以解决同样的问题。在数学中，你可以写 0 < x < 10 来表示 x 在 0 到 10 之间。

在大多数编程语言中，这个表达式没有意义。然而，在 Python 中，这个表达式就像一个魅力：

>>>

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

在不同的编程语言中，这个表达式会以求值开始0 < x，这是真的。下一步是将真正的布尔值与 进行比较10，这没有多大意义，因此表达式失败。在 Python 中，发生了一些不同的事情。

Python 在内部将这种类型的表达式重写为等效的and表达式，例如x > 0 and x < 10. 然后执行实际评估。这就是为什么您在上面的示例中得到正确结果的原因。

就像您可以使用多个and运算符链接多个子表达式一样，您也可以在不显式使用任何and运算符的情况下链接它们：

>>>

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

您还可以使用此 Python 技巧来检查多个值是否相等：

>>>

>>> 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 代码中做出决策。

Python 面向对象编程

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。