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

目录

Python 的not运算符允许您反转布尔表达式和对象的真值。您可以在布尔上下文中使用此运算符，例如if语句和while循环。它也适用于非布尔上下文，允许您反转变量的真值。

not有效地使用运算符将帮助您编写准确的负布尔表达式来控制程序中的执行流程。

在本教程中，您将学习：

• Python 的not运算符如何工作
• 如何not在布尔和非布尔上下文中使用运算符
• 如何使用operator.not_()函数进行逻辑否定
• 如何以及何时避免代码中不必要的负面逻辑

您还将编写一些实际示例，使您能够更好地理解not运算符的一些主要用例及其使用的最佳实践。要从本教程中获得最大收益，您应该具备一些有关布尔逻辑、条件语句和while循环的先前知识。

在 Python 中使用布尔逻辑

George Boole将现在称为Boolean algebra 的东西放在一起，它依赖于true和false值。它还定义了一组布尔运算：AND，OR，和NOT。这些布尔值和运算符对编程很有帮助，因为它们可以帮助您决定程序中的操作过程。

在Python中，布尔型，bool是的子类int：

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

class bool(int)
    bool(x) -> bool
    ...

这种类型有两个可能的值，True和False，它们是Python中的内置常量，必须大写。在内部，Python 将它们实现为整数：

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

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

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

Python 在内部实现其布尔值1forTrue和0for False。继续并True + True在交互式shell 中执行以查看会发生什么。

Python 提供了三个布尔或逻辑运算符：

使用这些运算符，您可以通过将布尔表达式相互连接、对象相互连接、甚至布尔表达式与对象连接来构建表达式。Python 使用英文单词作为布尔运算符。这些词是语言的关键字，因此您不能将它们用作标识符而不会导致语法错误。

在本教程中，您将了解 Python 的not运算符，它实现逻辑NOT运算或否定。

Pythonnot运算符入门

该not操作是布尔或逻辑运算，实现在Python否定。它是一元的，这意味着它只需要一个操作数。操作数可以是布尔表达式或任何 Python对象。即使是用户定义的对象也能工作。的任务not是反转其操作数的真值。

如果您应用not到计算结果为 的操作数True，那么您将得到False结果。如果你申请not一个假操作数，那么你会得到True：

>>> not True
False

>>> not False
True

该not运营商否定其操作数的真值。一个真正的操作数返回False。返回一个假操作数True。这两个语句发现了什么是俗称的真值表的not：

使用not，您可以否定任何布尔表达式或对象的真值。此功能在以下几种情况下值得使用：

• 在语句和循环的上下文中检查未满足的条件ifwhile
• 反转对象或表达式的真值
• 检查一个值是否不在给定的容器中
• 检查对象的身份

在本教程中，您将找到涵盖所有这些用例的示例。首先，您将首先了解not运算符如何处理布尔表达式以及常见的 Python 对象。

布尔表达式总是返回一个布尔值。在 Python 中，这种表达式返回Trueor False。假设您要检查给定的数字变量是否大于另一个：

>>> x = 2
>>> y = 5

>>> x > y
False

>>> not x > y
True

表达式x > y总是返回False，所以你可以说它是一个布尔表达式。如果你放在not这个表达式之前，那么你会得到相反的结果，True。

>>> not True == False
True

>>> False == not True
File "<stdin>", line 1
    False == not True
             ^
SyntaxError: invalid syntax

>>> False == (not True)
True

您还可以使用not常见的 Python 对象，例如numbers、strings、lists、 tuples、dictionaries、set、用户定义的对象等：

>>> # Use "not" with numeric values
>>> not 0
True
>>> not 42
False
>>> not 0.0
True
>>> not 42.0
False
>>> not complex(0, 0)
True
>>> not complex(42, 1)
False

>>> # Use "not" with strings
>>> not ""
True
>>> not "Hello"
False

>>> # Use "not" with other data types
>>> not []
True
>>> not [1, 2, 3]
False
>>> not {}
True
>>> not {"one": 1, "two": 2}
False

在每个示例中，not否定其操作数的真值。为了确定给定对象是真还是假，Python 使用bool()，它返回True或False取决于手头对象的真值。

这个内置函数在内部使用以下规则来计算其输入的真值：

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

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

（来源）

一旦not知道其操作数的真值，它就会返回相反的布尔值。如果对象的计算结果为True，则not返回False。否则，它返回True。

>>> 0 and 42
0
>>> True and False
False
>>> True and 42 > 27
True

>>> 0 or 42
42
>>> True or False
True
>>> False or 42 < 27
False

>>> not 0
True
>>> not 42
False
>>> not True
False

现在您已经了解了notPython 的工作原理，您可以深入研究这个逻辑运算符的更具体的用例。在下一节中，您将学习not在布尔上下文中使用。

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

与其他两个逻辑运算符一样，not运算符在布尔上下文中特别有用。在 Python 中，您有两个定义布尔上下文的语句：

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

这两个结构是您所谓的控制流语句的一部分。它们帮助您决定程序的执行路径。对于not运算符，您可以使用它来选择在不满足给定条件时要采取的操作。

if not condition:
    # Do something...

>>> import math

>>> def is_prime(n):
...     if n <= 1:
...         return False
...     for i in range(2, int(math.sqrt(n)) + 1):
...         if n % i == 0:
...             return False
...     return True
...

>>> # Work with prime numbers only
>>> number = 3
>>> if is_prime(number):
...     print(f"{number} is prime")
...
3 is prime

>>> # Work with composite numbers only
>>> number = 8
>>> if not is_prime(number):
...     print(f"{number} is composite")
...
8 is composite

>>> x = 30

>>> # Use the "and" operator
>>> if x >= 20 and x < 40:
...     print(f"{x} is inside")
...
30 is inside

>>> # Chain comparison operators
>>> if 20 <= x < 40:
...     print(f"{x} is inside")
...
30 is inside

>>> x = 50

>>> if x < 20 or x >= 40:
...     print(f"{x} is outside")
...
50 is outside

>>> x = 50

>>> # Reuse the chained logic
>>> if not (20 <= x < 40):
...     print(f"{x} is outside")
50 is outside

 1# guess.py
 2
 3from random import randint
 4
 5secret = randint(1, 10)
 6
 7print("Welcome!")
 8
 9name = ""
10while not name:
11    name = input("Enter your name: ").strip()

>>> toggle = False

>>> for _ in range(4):
...     print(f"toggle is {toggle}")
...     if toggle:
...         # Do something...
...         toggle = False
...     else:
...         # Do something else...
...         toggle = True
...
toggle is False
toggle is True
toggle is False
toggle is True

>>> toggle = False

>>> for _ in range(4):
...     print(f"toggle is {toggle}")
...     if toggle:
...         pass  # Do something...
...     else:
...         pass  # Do something else...
...     toggle = not toggle
...
toggle is False
toggle is True
toggle is False
toggle is True

>>> from operator import not_

>>> # Use not_() with numeric values
>>> not_(0)
True
>>> not_(42)
False
>>> not_(0.0)
True
>>> not_(42.0)
False
>>> not_(complex(0, 0))
True
>>> not_(complex(42, 1))
False

>>> # Use not_() with strings
>>> not_("")
True
>>> not_("Hello")
False

>>> # Use not_() with other data types
>>> not_([])
True
>>> not_([1, 2, 3])
False
>>> not_({})
True
>>> not_({"one": 1, "two": 2})
False

>>> from operator import and_, or_

>>> and_(False, False)
False
>>> and_(False, True)
False
>>> and_(True, False)
False
>>> and_(True, True)
True

>>> or_(False, False)
False
>>> or_(False, True)
True
>>> or_(True, False)
True
>>> or_(True, True)
True

>>> from operator import not_

>>> employees = ["John", "", "", "Jane", "Bob", "", "Linda", ""]

>>> sorted(employees, key=not_)
['John', 'Jane', 'Bob', 'Linda', '', '', '', '']

使用 Python 的not运算符：最佳实践

当您使用not操作符时，您应该考虑遵循一些最佳实践，这些实践可以使您的代码更具可读性、干净和 Pythonic。在本节中，您将了解与not在成员资格和身份测试的上下文中使用运算符相关的一些最佳实践。

您还将了解否定逻辑如何影响代码的可读性。最后，您将了解一些可以帮助您避免不必要的否定逻辑的便捷技术，这是编程最佳实践。

>>> numbers = [1, 2, 3, 4]

>>> 3 in numbers
True

>>> 5 in numbers
False

>>> # Bad practice
>>> not "c" in ["a", "b", "c"]
False

>>> # Best practice
>>> "c" not in ["a", "b", "c"]
False

>>> x = 30

>>> # Between 20 and 40
>>> x in range(20, 41)
True

>>> # Outside 20 and 40
>>> x not in range(20, 41)
False

>>> obj = None
>>> obj is None
True

>>> obj = None

>>> # Bad practice
>>> not obj is None
False

>>> # Best practice
>>> obj is not None
False

避免不必要的否定逻辑

该not运算符使您能够反转给定条件或对象的含义或逻辑。在编程中，这种特征被称为负逻辑或否定。

正确使用否定逻辑可能会很棘手，因为这种逻辑很难思考和理解，更不用说难以解释了。一般来说，负逻辑比正逻辑意味着更高的认知负荷。所以，只要有可能，你应该使用积极的公式。

下面是一个custom_abs()使用负条件返回输入数字的绝对值的函数示例：

>>> def custom_abs(number):
...     if not number < 0:
...         return number
...     return -number
...

>>> custom_abs(42)
42

>>> custom_abs(-42)
42

该函数将一个数字作为参数并返回其绝对值。您可以通过使用正逻辑以最小的更改获得相同的结果：

>>> def custom_abs(number):
...     if number < 0:
...         return -number
...     return number
...

>>> custom_abs(42)
42

>>> custom_abs(-42)
42

就是这样！您custom_abs()现在使用正逻辑。它更简单易懂。为了获得此结果，您删除not并移动了负号 ( -) 以number在其低于 时修改输入0。

您可以找到许多类似的示例，其中更改比较运算符可以删除不必要的否定逻辑。假设您要检查变量x是否不等于给定值。您可以使用两种不同的方法：

>>> x = 27

>>> # Use negative logic
>>> if not x == 42:
...     print("not 42")
...
not 42

>>> # Use positive logic
>>> if x != 42:
...     print("not 42")
...
not 42

在此示例中，您not通过将比较运算符从等于 ( ==) 更改为不同 ( !=)来删除运算符。在许多情况下，您可以通过使用适当的关系或相等运算符以不同方式表达条件来避免否定逻辑。

但是，有时否定逻辑可以节省您的时间并使您的代码更加简洁。假设您需要一个条件语句来初始化文件系统中不存在的给定文件。在这种情况下，您可以使用not检查文件是否不存在：

from pathlib import Path

file = Path("/some/path/config.ini")

if not file.exists():
    # Initialize the file here...

该not运营商允许你反转调用的结果.exists()上file。如果.exists()返回False，则需要初始化文件。但是，如果条件为假，则if代码块不会运行。这就是为什么您需要not运算符来反转.exists().

现在想一想如何将这个否定条件变成肯定条件。到目前为止，如果文件存在，您没有任何操作可以执行，因此您可以考虑使用pass语句和附加else子句来处理文件初始化：

if file.exists():
    pass # YAGNI
else:
    # Initialize the file here...

尽管此代码有效，但它违反了“您不需要它”（YAGNI）原则。这是消除负面逻辑的特别坚定的尝试。

这个例子背后的想法是表明有时使用否定逻辑是正确的方法。因此，您应该考虑您的具体问题并选择合适的解决方案。一个好的经验法则是尽可能避免否定逻辑，而不是不惜一切代价避免它。

最后，你应该特别注意避免双重否定。假设您有一个名为的常量NON_NUMERIC，其中包含 Python 无法转换为数字的字符，例如字母和标点符号。从语义上讲，这个常量本身就意味着否定。

现在假设您需要检查给定字符是否为数值。既然你已经有了NON_NUMERIC，你可以考虑使用not来检查条件：

if char not in NON_NUMERIC:
    number = float(char)
    # Do further computations...

这段代码看起来很奇怪，在您作为程序员的职业生涯中，您可能永远不会做这样的事情。然而，做一些类似的事情有时很诱人，比如上面的例子。

此示例使用双重否定。它依赖于NON_NUMERIC，也依赖于not，这使得它难以消化和理解。如果你遇到过这样的一段代码，那么花点时间尝试积极地编写它，或者至少尝试删除一层否定。

结论

Pythonnot是一个逻辑运算符，用于反转布尔表达式和对象的真值。当您需要检查条件语句和while循环中未满足的条件时，它很方便。

您可以使用not运算符来帮助您决定程序中的操作过程。您还可以使用它来反转代码中布尔变量的值。

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

• 使用 Python 的not运算符
• not在布尔和非布尔上下文中使用运算符
• 用于operator.not_()以函数式执行逻辑否定
• 尽可能避免代码中不必要的负面逻辑

为此，您编写了一些实际示例来帮助您理解not运算符的一些主要用例，因此您现在可以更好地准备在自己的代码中使用它。