Использование логического оператора "not" в Python

>>> 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 внутренне реализует свои логические значения как 1 для True и 0 для False. Продолжайте и запустите True + True в своей интерактивной  оболочке, чтобы посмотреть, что произойдет.
В Python предусмотрены три логических оператора:



Operator
Logical Operation




and
Conjunction


or
Disjunction


not
Negation



С помощью этих операторов вы можете создавать выражения, соединяя Логические выражения друг с другом, объекты друг с другом и даже логические выражения с объектами. Python использует английские слова для обозначения логических операторов. Эти слова являются ключевыми словами языка, поэтому вы не можете использовать их в качестве идентификаторов, не вызывая синтаксической ошибки.
В этом руководстве вы узнаете об операторе not в Python, который реализует логическую операцию NOT или отрицание .
Начало работы с оператором not в Python
Оператор not - это логический оператор, который реализует отрицание в Python. Это унарный, что означает, что он принимает только один операнд. Операндом может быть логическое выражение  или любой   объект Python . Работают   даже объекты, определенные пользователем. Задача not состоит в том, чтобы перевернуть  истинное значение своего операнда.
Если вы примените not к операнду, значение которого равно True, то в результате получите False. Если вы примените not к ложному операнду, то получите True:

>>> not True
False

>>> not False
True


Оператор not отрицает истинностное значение своего операнда. Операнд true возвращает False. Операнд false возвращает True. Эти два утверждения раскрывают то, что обычно известно как таблица истинности из not:



operand
not operand




True
False


False
True



С помощью not вы можете отменить значение истинности любого логического выражения или объекта. Эта функциональность оправдывает себя в нескольких ситуациях:

Проверка невыполненных условий в контексте if инструкций и while циклов
 Инвертирование истинного значения объекта или выражения
Проверка, не находится ли значение  в данном контейнере
Проверка идентичности объекта 

В этом руководстве вы найдете примеры, которые охватывают все эти варианты использования. Для начала вы узнаете, как оператор not работает с логическими выражениями, а также с обычными объектами Python.
Логическое выражение всегда возвращает логическое значение. В Python выражения такого типа возвращают True или False. Допустим, вы хотите проверить, является ли данная числовая переменная больше другой:

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

>>> x > y
False

>>> not x > y
True


Выражение x > y всегда возвращает False, так что вы можете сказать, что это логическое выражение. Если вы поставите not перед этим выражением, то получите обратный результат, True.
 Примечание: Python вычисляет операторы в строгом порядке, обычно известном как приоритет операторов.
Например, Python сначала вычисляет математические операторы и операторы сравнения. Затем он вычисляет логические операторы, включая not:

>>> not True == False
True

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

>>> False == (not True)
True


В первом примере Python вычисляет выражение True == False, а затем отрицает результат, вычисляя not.
Во втором примере Python сначала вычисляет оператор равенства (==) и выдает значение SyntaxError, потому что нет способа сравнить False и not. Вы можете заключить выражение not True в круглые скобки (()), чтобы устранить эту проблему. В этом кратком обновлении указано, что Python должен сначала вычислять заключенное в круглые скобки выражение.
Среди логических операторов not имеет более высокий приоритет, чем операторы and и or, которые имеют одинаковый приоритет.
Вы также можете использовать not с обычными объектами Python, такими как числа,  строки, списки, кортежи, словари,  наборы, определяемые пользователем объекты и т.д.:

>>> # 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__() метод, который возвращает ноль при вызове с объектом. Вот большинство встроенных объектов, которые считаются ложными:

константы, определенные как ложные: None и False.
ноль любого числового типа: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
пустые последовательности и коллекции: '', (), [], {}, set(), range(0)

( Источник)

Как только not узнает истинное значение своего операнда, он возвращает противоположное логическое значение. Если значение объекта равно True, то not возвращает False. В противном случае он возвращает True.
 Примечание:  Всегда возвращающий True или False является важным отличием not от двух других логических операторов, которые and оператор и оператор or.
Операторы and и or возвращают один из операндов в выражении, в то время как оператор not всегда возвращает логическое значение:

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


 Используя операторы and и or, вы получаете True или False обратно из выражения, когда одно из этих значений явно является результатом вычисления операндов. В противном случае вы получите один из операндов в выражении. С другой стороны, not ведет себя по-другому, возвращая True или False независимо от используемого операнда.
Чтобы вести себя подобно оператору and и оператору or, оператору not пришлось бы создавать и возвращать новые объекты, что часто неоднозначно и не всегда просто. Например, что, если бы выражение типа not "Hello" возвращало пустую строку ("")? Что бы вернуло выражение типа not ""? Вот почему оператор not всегда возвращает True или False.
Теперь, когда вы знаете, как not работает в Python, вы можете перейти к более конкретным вариантам использования этого логического оператора. В следующем разделе вы узнаете об использовании not в логических контекстах.
Использование оператора not в логических контекстах
Как и два других логических оператора, оператор not особенно полезен в логических контекстах. В Python есть два оператора, которые определяют логические контексты:

if инструкции позволяют выполнять условное выполнение и выполнять различные действия в зависимости от некоторых начальных условий.
while циклы позволяют выполнять условных итераций и запускать повторяющиеся задачи, пока выполняется заданное условие.

Эти две структуры являются частью того, что вы бы назвали операторами потока управления. Они помогают вам определить путь выполнения программы. В случае с оператором not вы можете использовать его для выбора действий, которые следует предпринять, если заданное условие не выполняется.
if Заявления
Вы можете использовать оператор not в операторе if, чтобы проверить, не выполнено ли заданное условие. Чтобы выполнить проверку оператора if, если что-то не произошло, вы можете поместить оператор not перед соответствующим условием. Поскольку оператор not возвращает отрицательный результат, то значение true становится False и наоборот.
Синтаксис оператора if с логическим оператором not таков:

if not condition:
    # Do something...


В этом примере condition может быть логическим выражением или любым другим объектом Python, который имеет смысл. Например, condition может быть переменной, содержащей строку, список, словарь, набор и даже определенный пользователем объект.
Если condition принимает значение false, то not возвращает True и выполняется блок кода if. Если значение condition равно true, то not возвращает False и блок кода if не выполняется.
Обычной ситуацией является использование предиката или логической функции в качестве condition. Допустим, вы хотите проверить, является ли данное число простым, прежде чем выполнять дальнейшую обработку. В этом случае вы можете написать функцию is_prime():

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


В этом примере is_prime() принимает целое число в качестве аргумента и возвращает True, если это простое число. В противном случае он возвращает False.
Вы также можете использовать эту функцию в отрицательном условном выражении, чтобы приблизиться к тем ситуациям, когда вы хотите работать только с составными числами:

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


Поскольку также возможно, что вам нужно работать только с составными числами, вы можете повторно использовать is_prime(), объединив его с оператором not, как вы это делали во втором примере.
Другой распространенной ситуацией в программировании является определение того, находится ли число внутри определенного числового интервала. Чтобы определить, находится ли число x в заданном интервале в Python, вы можете использовать оператор and или соответствующим образом связать операторы сравнения:

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


В первом примере вы используете оператор and для создания составного логического выражения, которое проверяет, находится ли x между 20 и 40. Во втором примере выполняется та же проверка, но с использованием связанных операторов, что является наилучшей практикой в Python.
 Примечание: В большинстве языков программирования выражение 20 <= x < 40 не имеет смысла. Оно должно начинаться с вычисления 20 <= x, что соответствует действительности. Следующим шагом было бы сравнить этот истинный результат с 40, что не имеет особого смысла, поэтому выражение завершается ошибкой. В Python происходит нечто иное.
Python внутренне переписывает выражение этого типа в эквивалентное and выражение, такое как x >= 20 and x < 40. Затем он выполняет фактическую оценку. Вот почему вы получаете правильный результат в приведенном выше примере.
Вы также можете столкнуться с необходимостью проверить, не находится ли число за пределами целевого интервала. Для этого вы можете использовать оператор or:

>>> x = 50

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


Это выражение or позволяет проверить, находится ли x за пределами интервала от 20 до 40. Однако, если у вас уже есть рабочее выражение, которое успешно проверяет, находится ли число в заданном интервале, вы можете повторно использовать это выражение для проверки противоположного условия:

>>> x = 50

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


В этом примере вы повторно используете выражение, которое вы изначально закодировали, чтобы определить, находится ли число внутри целевого интервала. Используя not перед выражением, вы проверяете, не находится ли x за пределами интервала от 20 до 40.
while Петли
Второй логический контекст, в котором вы можете использовать оператор not, находится в ваших циклах while. Эти циклы повторяются до тех пор, пока не будет выполнено заданное условие или пока вы не выйдете из цикла, используя break, using return или вызывая исключение. Использование not в цикле while позволяет выполнять итерацию, пока заданное условие не будет выполнено.
Допустим, вы хотите закодировать небольшую игру на Python, чтобы угадать случайное число от 1 до 10. В качестве первого шага вы решаете использовать input() для записи имени пользователя. Поскольку имя является обязательным условием для работы в остальной части игры, вам нужно убедиться, что вы его получили. Для этого вы можете использовать цикл while, который запрашивает имя пользователя до тех пор, пока пользователь не введет действительное имя.
Запустите свой  редактор кода или IDE и создайте новый guess.py файл для своей игры. Затем добавьте следующий код:

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


В guess.py сначала необходимо импортировать randint() из random. Эта функция позволяет генерировать случайные целые числа в заданном диапазоне. В данном случае вы генерируете числа от 1 до 10, включая оба. Затем вы печатаете приветственное сообщение для пользователя.
Цикл while в строке 10 повторяется до тех пор, пока пользователь не введет действительное имя. Если пользователь не указывает имя, просто нажимая Введите, то input() возвращает пустую строку (""), и цикл выполняется снова, потому что not "" возвращает True.
Теперь вы можете продолжить свою игру, написав код для обеспечения функции угадывания. Вы можете сделать это самостоятельно или развернуть поле ниже, чтобы ознакомиться с возможной реализацией.


Во второй части игры пользователь должен ввести число от 1 до 10 в качестве своего предположения. Игра должна сравнить введенное пользователем значение с текущим секретным номером и предпринять соответствующие действия. Вот возможная реализация:

while True:
    user_input = input("Guess a number between 1 and 10: ")
    if not user_input.isdigit():
        user_input = input("Please enter a valid number: ")
    guess = int(user_input)
    if guess == secret:
        print(f"Congrats {name}! You win!")
        break
    elif guess > secret:
        print("The secret number is lower than that...")
    else:
        print("The secret number is greater than that...")


Вы используете бесконечный цикл while, чтобы принимать вводимые пользователем данные до тех пор, пока он не угадает число secret. На каждой итерации вы проверяете, совпадают ли входные данные с secret, и предоставляете подсказки пользователю в соответствии с результатом. Продолжайте и попробуйте!
В качестве упражнения вы можете ограничить количество попыток, прежде чем пользователь проиграет игру. В данном случае хорошим вариантом могут быть три попытки.
Каким был ваш опыт работы с этой небольшой игрой? Чтобы узнать больше о программировании игр на Python, ознакомьтесь с PyGame: Руководство по программированию игр на Python.
Теперь, когда вы знаете, как использовать not в логических контекстах, пришло время узнать об использовании not в не логических контекстах. Это то, что вы будете делать в следующем разделе.
Использование оператора not в не логических контекстах
Поскольку оператор not также может принимать обычные объекты в качестве операнда, вы также можете использовать его в не логических контекстах. Другими словами, вы можете использовать его вне инструкции if или цикла while. Можно утверждать, что наиболее распространенным вариантом использования оператора not в не логическом контексте является инвертирование истинного значения данной переменной.
Предположим, вам нужно выполнить два разных действия в цикле поочередно. В этом случае вы можете использовать переменную flag для переключения действий на каждой итерации:

>>> 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, чтобы решить, какой курс действий предпринять. В конце каждого блока кода вы меняете значение toggle, чтобы можно было выполнить альтернативное действие на следующей итерации. Изменение значения toggle требует от вас повторного выполнения аналогичной логики дважды, что может привести к ошибкам.
Вы можете использовать оператор not, чтобы преодолеть этот недостаток и сделать ваш код более чистым и безопасным:

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


Теперь выделенная строка изменяет значение toggle между True и False с помощью оператора not. Этот код более чистый, менее повторяющийся и менее подверженный ошибкам, чем в примере, который вы написали ранее.
С использованием функционального оператора not
В отличие от оператора and и оператора or, оператор not имеет эквивалентную функциональную реализацию в модуле operator . Вызывается функция not_(). Она принимает объект в качестве аргумента и возвращает тот же результат, что и эквивалентное выражение not obj:

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


Чтобы использовать not_(), вам сначала нужно импортировать его из operator. Затем вы можете использовать функцию с любым объектом или выражением Python в качестве аргумента. Результат будет таким же, как при использовании эквивалентного выражения not.
 Примечание: В Python также есть функции and_() и or_(). Однако они отражают соответствующие им побитовые операторы, а не логические.
Функции and_() и or_() также работают с логическими аргументами:

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


В этих примерах вы используете and_() и or_() с True и False в качестве аргументов. Обратите внимание, что результат выполнения выражений соответствует таблице истинности операторов and и not соответственно.
Использование функции not_() вместо оператора not удобно при работе с функциями более высокого порядка, такими как map(), filter(), и тому подобное. Вот пример, в котором используется функция not_() вместе с sorted() для сортировки списка сотрудников путем размещения пустых имен сотрудников в конце списка:

>>> from operator import not_

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

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


В этом примере у вас есть начальный список с именем employees, который содержит несколько имен. Некоторые из этих имен являются пустыми строками. Вызов sorted() использует not_() в качестве функции key для создания нового списка, который сортирует сотрудников, перемещая пустые имена в конец списка.
Работа с оператором Python not: Лучшие практики
Когда вы работаете с оператором not, вам следует придерживаться нескольких рекомендаций, которые могут сделать ваш код более читабельным, чистым и основанным на Python. В этом разделе вы узнаете о некоторых рекомендациях, связанных с использованием оператора not в контексте членства и  идентификации тесты.
Вы также узнаете, как негативная логика может повлиять на читаемость вашего кода. Наконец, вы познакомитесь с некоторыми полезными приемами, которые помогут вам избежать ненужной негативной логики, что является передовой практикой программирования.
Проверка на членство
Тесты на принадлежность обычно полезны, когда вы определяете, существует ли определенный объект в данном типе данных контейнера, таком как список, кортеж, набор или словарь. Для выполнения такого рода тестов на Python вы можете использовать оператор in:

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

>>> 3 in numbers
True

>>> 5 in numbers
False


Оператор in возвращает True, если объект с левой стороны находится в контейнере с правой стороны выражения. В противном случае он возвращается False.
Иногда вам может понадобиться проверить, находится ли объект не  в данном контейнере. Как это можно сделать? Ответом на этот вопрос является оператор not.
В Python есть два разных синтаксиса для проверки того, находится ли объект не в данном контейнере. Сообщество Python считает первый синтаксис плохой практикой, поскольку его трудно читать. Второй синтаксис читается как обычный английский:

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

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


Первый пример работает. Однако из-за начального not читателю, читающему ваш код, сложно определить, работает ли оператор над "c" или над целым выражением, "c" in ["a", "b", "c"]. Эта деталь затрудняет чтение и понимание выражения.
Второй пример гораздо понятнее. В документации по Python синтаксис во втором примере называется оператором not in. Первый синтаксис может быть обычной практикой для людей, начинающих работать с Python.
Теперь пришло время вернуться к примерам, в которых вы проверяли, находится ли число внутри числового интервала или за его пределами. Если вы работаете только с целыми числами, то оператор not in предоставляет более удобный способ выполнения этой проверки:

>>> x = 30

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

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


В первом примере проверяется, находится ли x внутри диапазона от 20 до 40 или интервала. Обратите внимание, что вы используете 41 в качестве второго аргумента для range() включения 40 в проверку. 
 Примечание: Знаете ли вы, что тесты на членство с помощью range() очень эффективны? Узнайте больше в разделе Почему тесты членства в Python проходят так быстро для range()?.
Когда вы работаете с целыми числами, эта небольшая хитрость в отношении того, где именно вы используете оператор not, может существенно повлиять на читаемость кода.
Проверьте идентичность объектов
Еще одним распространенным требованием при написании кода на Python является проверка  идентификатора объекта. Вы можете определить идентификатор объекта, используя id(). Эта встроенная функция принимает объект в качестве аргумента и возвращает целое число, которое однозначно идентифицирует данный объект. Это число обозначает идентификатор объекта.
Практичным способом проверки подлинности является использование оператора is, который довольно полезен в некоторых условных операторах. Например, одним из наиболее распространенных вариантов использования оператора is является проверка того, является ли данный объект  None:

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


Оператор is возвращает True, если левый операнд имеет тот же идентификатор, что и правый. В противном случае он возвращает False.
В этом случае возникает вопрос: как проверить, не совпадают ли идентификаторы двух объектов? Опять же, вы можете использовать два разных синтаксиса:

>>> obj = None

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

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


В обоих примерах вы проверяете, имеет ли obj тот же идентификатор, что и объект None. Первый синтаксис несколько сложен для чтения и не является питоническим. Синтаксис is not намного более явный и понятный. В документации по Python этот синтаксис называется оператором is not и рекомендуется использовать его в качестве наилучшей практики.
Избегайте ненужной негативной логики
Оператор 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.
 Примечание: В Python предусмотрена встроенная функция с именем abs(), которая возвращает абсолютное значение числового параметра . Цель custom_abs() - облегчить изложение темы.
Вы можете найти много похожих примеров, в которых изменение оператора сравнения может устранить ненужную негативную логику. Допустим, вы хотите проверить, равна ли переменная 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().
 Примечание: В приведенном выше примере для обработки путей к файлам используется pathlib из стандартной библиотеки . Чтобы глубже погрузиться в эту классную библиотеку, ознакомьтесь с  Модулем pathlib для Python: Укрощение файловой системы.
Теперь подумайте, как превратить это отрицательное условие в положительное. До этого момента вам не нужно было выполнять никаких действий, если файл существует, поэтому вы можете подумать об использовании инструкции 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, что затрудняет усвоение и понимание. Если вы когда-нибудь доберетесь до такого фрагмента кода, как этот, найдите минутку, чтобы попробовать написать его позитивно или, по крайней мере, попытаться убрать один слой отрицания.
Заключение
 not в Python - это логический оператор, который инвертирует значение истинности логических выражений и объектов. Это удобно, когда вам нужно проверить наличие невыполненных условий в условных операторах и циклах while.
Вы можете использовать оператор not, который поможет вам определить последовательность действий в вашей программе. Вы также можете использовать его для инвертирования значений логических переменных в вашем коде.
 В этом руководстве вы узнали, как:

Работа с оператором Python not
Используйте оператор not в логических и не логических контекстах
Используйте operator.not_() для выполнения логического отрицания в функциональном стиле
Избегайте ненужной негативной логики в вашем коде, когда это возможно

С этой целью вы написали несколько практических примеров, которые помогли вам понять некоторые основные варианты использования оператора not, так что теперь вы лучше подготовлены к его использованию в своем собственном коде.
<статус завершения article-slug="python-не-оператор" class="btn-group mb-0" data-api-article-bookmark-url="/api/v1/articles/python-не-оператор/закладка/" data-api-article-завершение-статус-url="/api/v1/articles/python-not-operator/completion_status/">



<кнопка поделиться bluesky-text="Интересная статья на #Python от @realpython.com :" email-body="Ознакомьтесь с этой статьей о Python:%0A%0, в которой используется логический оператор "not" в Python"" email-subject="Статья о Python для вас" twitter-text="Интересная статья #Python статья от @realpython:" url="https://realpython.com/python-not-operator /" url-title='Использование логического оператора "not" в Python'>

 Смотрите сейчас, к этому уроку прилагается соответствующий видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание:  Используя оператор Python not

                







                 Back to Top