Оператор идентичности is в Python
Операторы is и not is проверяют идентичность объекта: x is y будет истинно тогда и только тогда, когда x и y являются одним и тем же объектом.
Выражение x is not y дает значение обратной истинности, т.е. возвращает True , если объекты НЕ идентичны.
Идентичность объекта определяется с помощью функции id() . Другими словами объекты идентичны, если они имеют одинаковый индификатор во время выполнения программы.
Поведение операторов is и is not не может быть настроено. Кроме того, они могут быть применены к любым двум объектам одновременно и никогда не вызывают исключения.
Примеры:
>>> x = 2 + 1 >>> 3 is x # True # смотрим индификаторы >>> id(x) 10914560 >>> id(3) 10914560 # пример со списками >>> x = [1, 2, 3, 4, 5, 6] >>> y = x >>> y is x # True >>> y = x.copy() >>> y is x # False >>> y is not x # True
Понимание работы логических операций and, or и not
Важно! Операторы and и or закорачивают вычисление своих операндов (т.е. используют замыкания): правый операнд вычисляется лишь в том случае, если его значение необходимо для получения истинного значения в операциях and или or . Другими словами, замыкания в логических операциях используются для запуска второй части или последующих частей логического выражения только в том случае, если это актуально!
- or — оценивает второй аргумент, только если первый равен False . Если какой либо операнд в цепочке or является истиной, немедленно возвращается результат — первое истинное значение.
- and — оценивает второй аргумент, только если первый равен True . Если в цепочке and все операнды являются истиной, результатом будет последнее значение. А если какой-либо из операндов является False , результатом будет первое ложное значение.
- not имеет более низкий приоритет, чем операторы сравнения, так not a == b интерпретируется как not (a == b) , а выражение a == not b вовсе является синтаксической ошибкой. Единственный логический оператор с одним аргументом. Он принимает один аргумент x и возвращает противоположный результат: False для истинного значения и True для ложного значения.
Операторы and и or не приводят свои результаты принудительно к значениям True или False , а возвращают один из своих операндов. Такой подход позволяет использовать эти операторы в более общих, а не только булевых операциях. Если другие операторы, прежде чем выполнить операцию, вычисляют все свои операнды, то в случае операторов and и or с их семантикой закорачивания необходимость вычисления правого операнда определяется результатом вычисления левого.
Из булевых операторов, not имеет самый высокий приоритет, а or самый низкий, так что A and not B or C эквивалентно (A and (not B)) or C . Как всегда, скобки могут быть использованы для выражения желаемого приоритета в операциях.
Логические операции, упорядоченные по приоритету выполнения:
- not x — если x ложно, то возвращается True , иначе False .
- x and y — если x ложно, то возвращается x , иначе у .
- x or y — если x ложно, то возвращается у , иначе x
Объяснение работы замыкания c оператором and :
a = 'a' b = 'b' c = 'c' >>> a and b # 'b' >>> '' and b # '' >>> a and b and c # 'c'
Пояснения к примеру выше с оператором and :
- Оператор and вычисляет значения в булевом контексте слева направо. Значения 0 , » , [] , () , <> и None являются ложью, все остальное является истиной. Если у and оба операнда являются истиной, результатом будет последнее значение.
- Если какой-либо из операндов является ложью, результатом будет первое такое значение. В данном случает это » — пустая строка, первое значение которое является ложью.
- Все значения являются истиной, так что в результате мы получаем последнее c .
Объяснение работы замыкания c оператором or :
a = 'a' b = 'b' >>> a or b # 'a' >>> '' or b # 'b' >>> '' or [] or <> # <> >>> def func(): . return 1 >>> a or func() # 'a'
Пояснения к примеру выше с оператором or :
- Оператор or вычисляет значения в булевом контексте слева направо. Если операнд является истиной, or немедленно возвращает результат. В данном случае a , первое истинное значение.
- or вычисляет выражение » , которое является ложью, затем b, которое является истиной, и возвращает его значение.
- Если все значения являются ложью, or возвращает последнее.
- Обратите внимание, что or вычисляет операнды до тех пор, пока не найдет истинное значение, остальное игнорируется. Это имеет значение, когда вычисление операнда дает сторонние эффекты. В данном случае функция func() не вызывается, так как для получения результата выражения с оператором or достаточно того, что первый операнд a является истиной.
Другие примеры с and и or :
>>> a = 'one' >>> b = 'two' >>> 1 and a or b # 'one' >>> 0 and a or b # 'two' >>> a = '' >>> b = 'two' # 'a' - пустая строка, которую Python считает ложью, # следовательно 1 and '' дает '', а '' or 'two' дает 'two'. >>> 1 and a or b # 'two'
Практическое использование замыканий and и or в кодовой базе.
Внимание! Замыкания в операциях and и or можно использовать с пользой в вычислениях для экономии ресурсов, сокращения времени выполнения и т.д., только будьте осторожны! Необходимо четко понимать как работают замыкания в операторах and и or .
- Экономия ресурсов и времени выполнения при помощи and ;
- Проверка предварительных условий перед выражением;
- Определение значения по умолчанию при помощи or ;
- Пример использования замыканий в функциях all() и any() .
Экономия ресурсов и времени выполнения при помощи and .
Рассмотрим реальный пример из модуля base64 стандартной библиотеки Python, который использует замыкание в оператора if . Исследуем функцию b64decode , которая берет строку (или объект, подобный байтам) и декодирует ее:
# взято из Lib/base64.py def b64decode(s, altchars=None, validate=False): """Decode the Base64 encoded bytes-like object or ASCII string s. [docstring cut for brevity] """ s = _bytes_from_decode_data(s) if altchars is not None: altchars = _bytes_from_decode_data(altchars) assert len(altchars) == 2, repr(altchars) s = s.translate(bytes.maketrans(altchars, b'+/')) # использование замыкания с оператором `and` if validate and not re.fullmatch(b'[A-Za-z0-9+/]*=', s): raise binascii.Error('Non-base64 digit found') return binascii.a2b_base64(s)
Смотрим на оператор if , который помечен комментарием. В условии сначала проверяется аргумент validate , а только потом результат работы функции re.fullmatch() . Аргумент validate сообщает функции, хочет ли пользователь вообще проверять строку, которую нужно декодировать. Обратите внимание, что если validate=False то сопоставление регулярного выражения не запускается (срабатывает замыкание). Если порядок операндов поменять, то результат остался такой же, но было бы потрачено гораздо больше времени.
Проверка предварительных условий перед выражением.
Другой типичный шаблон использования замыканий проявляется, когда перед определенной операцией, которая может вызвать исключение, нужно что-то проверить.
Допустим есть последовательность и нужно взять элемент по индексу, но последовательность может оказаться пустой или ее длина может быть меньше индекса. Например:
>>> lst = [0, 1, 2] >>> lst[3] # Traceback (most recent call last): # File "", line 1, in # IndexError: list index out of range
Используем проверку предварительных условий:
>>> lst = [0, 1, 2] >>> if lst and len(lst) >=3: . lst[3]
Здесь, в условии сначала проверяется что список НЕ пустой и только после этого вычисляется длинна этого списка. Если список пустой, то его длина проверяться не будет и условие if завершиться.
Еще один пример из модуля enum :
# взято из Lib/enum.py def _create_(cls, class_name, names, *, module=None, qualname=None, type=None, start=1): """ Convenience method to create a new Enum class. """ # [сокращено для краткости] # special processing needed for names? if isinstance(names, str): names = names.replace(',', ' ').split() # смотрим на следующие условие if isinstance(names, (tuple, list)) and names and isinstance(names[0], str): original_names, names = names, [] last_values = [] # [сокращено для краткости]
Более длинный оператор if содержит три выражения, разделенных операторами and , и первые два выражения нужны для того, чтобы убедиться, можно ли безопасно выполнить последнее.
- isinstance(names, (tuple, list)) — проверяет, является ли names кортежем или списком. Если не является то условие завершается.
- далее names проверяется пусто оно или нет. Если элементов нет то условие завершается.
- если names не пустой, то можно безопасно выполнить последнюю проверку, связанную с индексацией names[0] , а именно isinstance(names[0], str) .
Определение значения по умолчанию при помощи or .
Замыкание с помощью логического оператора or может использоваться для присвоения переменным значений по умолчанию. Вот пример:
# test.py greet = input("Ваше имя >> ") or "незнакомец" print(f"Привет, greet>!") # $python3 -i test.py # Ваше имя >> # Привет, незнакомец!
Если запустить этот пример и ничего не вводя нажать Enter, то получим вывод «Привет, незнакомец!». Что тут происходит? Если ничего не вводить и нажать Enter, то функция input() вернет пустую строку » , что является False . Следовательно, оператор or видит ложное значение слева и должен оценить правый операнд. Для определения окончательное значение выражения or оценивает правый операнд и если он True , то возвращает его значение.
Еще пример присвоения значение по умолчанию (используя or ) для изменяемого аргумента из стандартной библиотеки Python.
# взято из Lib/cgitb.py class Hook: """A hook to replace sys.excepthook that shows tracebacks in HTML.""" def __init__(self, display=1, logdir=None, context=5, file=None, format="html"): self.display = display # send tracebacks to browser if true self.logdir = logdir # log tracebacks to files if not None self.context = context # number of source code lines per frame self.file = file or sys.stdout # self.format = format
Этот код взят из модуля cgitb и определяет sys.stdout как значение по умолчанию для переменной self.file . Определение функции __init__ имеет file=None в качестве ключевого аргумента, так почему бы просто не написать file=sys.stdout ?
Проблема в том, что sys.stdout может быть изменяемым объектом, поэтому использование file=sys.stdout в качестве ключевого аргумента со значением по умолчанию не будет работать так, как ожидается. Это легче продемонстрировать со списком в качестве аргумента по умолчанию, хотя принцип тот же:
>>> def addend(val, l=[]): . l.append(val) . print(l) >>> addend(3, [1, 2]) # [1, 2, 3] >>> addend(5) # [5] >>> addend(5) # [5, 5] >>> addend(5) # [5, 5, 5]
Обратите внимание на три последовательных вызова addend(5) . Ожидается, что вызов addend(5) со значением по умолчанию l=[] будет вести себя одинаково, но т.к. список является изменяемым объектом, то вызовы добавляют значения val к значению по умолчанию [] , при этом список растет! Дополнительно смотрите материал «Список Python как аргумент по умолчанию».
Пример использования замыканий or и and в функциях all() и any() .
Если в выражении генератора использовать оператор моржа := , и принимать во внимание тот факт, что функции all() и any() также используют замыкания, то можно использовать следующую конструкцию для извлечения первого истинного элемента.
any(predicate(witness := item) for item in items)
Другими словами, если какой-либо элемент item удовлетворяет условию в функции predicate() , то переменная witness сохранит его значение!
Например, если последовательность содержит много целых чисел, как выяснить, есть ли там какие-либо нечетные числа, и как вывести первое из них?
items = [14, 16, 18, 20, 35, 41, 100] any_found = False for item in items: any_found = item % 2 if any_found: print(f"Найдено нечетное число item>.") break
Теперь все это сравним со следующим кодом:
>>> items = [14, 16, 18, 20, 35, 41, 100] >>> is_odd = lambda x: x % 2 >>> if any(is_odd(witness := item) for item in items): . print(f"Найдено нечетное число witness>.") # Найдено нечетное число 35.
Логические выражения и операторы
Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 3 и 5 больше 7, вы согласитесь, скажете: «Да, это правда». Если же кто-то будет утверждать, что сумма трех и пяти меньше семи, то вы расцените такое утверждение как ложное.
Подобные фразы предполагают только два возможных ответа – либо «да», когда выражение оценивается как правда/истина, либо «нет», когда утверждение оценивается как ошибочное/ложное. В программировании и математике если результатом вычисления выражения может быть лишь истина или ложь, то такое выражение называется логическим.
Например, выражение 4 > 5 является логическим, так как его результатом является либо правда, либо ложь. Выражение 4 + 5 не является логическим, так как результатом его выполнения является число.
На позапрошлом уроке мы познакомились с тремя типами данных – целыми и вещественными числами, а также строками. Сегодня введем четвертый – логический тип данных (тип bool ). Его также называют булевым. У этого типа всего два возможных значения: True (правда) и False (ложь).
>>> a = True >>> type(a) >>> b = False >>> type(b)
Здесь переменной a было присвоено значение True , после чего с помощью встроенной в Python функции type() проверен ее тип. Интерпретатор сообщил, что это переменная класса bool . Понятия «класс» и «тип данных» в данном случае одно и то же. Переменная b также связана с булевым значением.
В программировании False обычно приравнивают к нулю, а True – к единице. Чтобы в этом убедиться, можно преобразовать булево значение к целочисленному типу:
>>> int(True) 1 >>> int(False) 0
Возможно и обратное. Можно преобразовать какое-либо значение к булевому типу:
>>> bool(3.4) True >>> bool(-150) True >>> bool(0) False >>> bool(' ') True >>> bool('') False
И здесь работает правило: всё, что не 0 и не пустота, является правдой.
Логические операторы
Говоря на естественном языке (например, русском) мы обозначаем сравнения словами «равно», «больше», «меньше». В языках программирования используются специальные знаки, подобные тем, которые используются в математике: > (больше), < (меньше), >= (больше или равно),
Не путайте операцию присваивания значения переменной, обозначаемую в языке Python одиночным знаком «равно», и операцию сравнения (два знака «равно»). Присваивание и сравнение – разные операции.
>>> a = 10 >>> b = 5 >>> a + b > 14 True >>> a < 14 - b False >>> a >> a != b True >>> a == b False >>> c = a == b >>> a, b, c (10, 5, False)
В данном примере выражение c = a == b состоит из двух подвыражений. Сначала происходит сравнение ( == ) переменных a и b . После этого результат логической операции присваивается переменной c . Выражение a, b, c просто выводит значения переменных на экран.
Сложные логические выражения
Логические выражения типа kbyte >= 1023 являются простыми, так как в них выполняется только одна логическая операция. Однако, на практике нередко возникает необходимость в более сложных выражениях. Может понадобиться получить ответа «Да» или «Нет» в зависимости от результата выполнения двух простых выражений. Например, «на улице идет снег или дождь», «переменная news больше 12 и меньше 20».
В таких случаях используются специальные операторы, объединяющие два и более простых логических выражения. Широко используются два оператора – так называемые логические И (and) и ИЛИ (or).
Чтобы получить True при использовании оператора and , необходимо, чтобы результаты обоих простых выражений, которые связывает данный оператор, были истинными. Если хотя бы в одном случае результатом будет False , то и все сложное выражение будет ложным.
Чтобы получить True при использовании оператора or , необходимо, чтобы результат хотя бы одного простого выражения, входящего в состав сложного, был истинным. В случае оператора or сложное выражение становится ложным лишь тогда, когда ложны оба составляющие его простые выражения.
Допустим, переменной x было присвоено значение 8 ( x = 8 ), переменной y присвоили 13 ( y = 13 ). Логическое выражение y < 15 and x >8 будет выполняться следующим образом. Сначала выполнится выражение y < 15 . Его результатом будет True . Затем выполнится выражение x >8 . Его результатом будет False . Далее выражение сведется к True and False , что вернет False .
>>> x = 8 >>> y = 13 >>> y < 15 and x >8 False
В случае с оператором or второе простое выражение проверяется, если первое вернуло ложь, и не проверяется, если уже первое вернуло истину. Так как для истинности всего выражения достаточно единственного True , неважно по какую сторону от or оно стоит.
>>> y < 15 or x >8 True
В языке Python есть еще унарный логический оператор not , то есть отрицание. Он превращает правду в ложь, а ложь в правду. Унарный он потому, что применяется к одному выражению, стоящему после него, а не справа и слева от него как в случае бинарных and и or .
>>> not y < 15 False
>>> a = 5 >>> b = 0 >>> not a False >>> not b True
Число 5 трактуется как истина, отрицание истины дает ложь. Ноль приравнивается к False . Отрицание False дает True .
Практическая работа
- Присвойте двум переменным любые числовые значения.
- Используя переменные из п. 1, с помощью оператора and составьте два сложных логических выражения, одно из которых дает истину, другое – ложь.
- Аналогично выполните п. 2, но уже с оператором or .
- Попробуйте использовать в логических выражениях переменные строкового типа. Объясните результат.
- Напишите программу, которая запрашивала бы у пользователя два числа и выводила бы True или False в зависимости от того, больше первое число второго или нет.
Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
Глава 6.3 Булевы операторы and, or и not в Python 3
В строке 12 мы объявляем новую функцию chooseCave() . Она спрашивает игрока, в какую пещеру он хочет войти: 1 или 2 . И сохраняет ответ в переменной cave .
14. while cave != ‘1’ and cave != ‘2’:
Цикл в строке 14 помогает убедиться, что игрок ввел одно из двух предлагаемых чисел: 1 или 2. Если будет введено любое другое число (или даже текст) функция «выбросит это значение и снова попросит выбрать одно из двух предлагаемых чисел. Это называется проверкой ввода.
В строке 13 мы создаем новую переменную cave . В ней мы будем хранить ответ, который сделал игрок. Так как в момент объявления переменной никакого ответа не было, а использовать переменную без значения нельзя, мы присваиваем ей пустое значение. Теперь мы можем её использовать.
В строке 14 вы видите новое условие. Это новый оператор, который располагается между двумя условиями и называется and . Он называется булевым оператором.
Булевы операторы
Как мы уже знаем, булев тип данных имеет всего два значения: истина и ложь (True и False). Булев оператор оценивает переданные ему условия и вычисляет (в зависимости от истинности условий) одно из этих значений.
Отвлечемся от программирования и рассмотрим это на более доступном примере. Например, предложение: «У кошек есть усы и у собак есть хвост». С точки зрения программиста, это предложение содержит два условия. Первое: «У кошек есть усы», второе: «у собак есть хвост». Между этими условиями стоит булев оператор and ( и). Так как утверждение «у кошек есть усы» верно и утверждение что «у собак есть хвост» тоже верно, то и все предложение является истинным. Поэтому результатом вычисления оператора and будет истина (True ).
Однако, если мы изменим предложение следующим образом: «У кошек есть усы и у собак есть крылья», то булев результат этого выражения будет ложь ( False). Ведь, хотя у кошек и есть усы, крыльев у собак нет точно. В булевой логике утверждение может быть только истинным или только ложным. Условие and ( в предложении — и) означает, что выражение будет вычислено как True только в том случае, если оба условия будут верны.
Операторы and и or .
Оператор and , в Python 3, работает так же как мы рассмотрели в примере выше. Если оба условия — перед и после этого оператора — вычисляются как истина, то все выражение также будет являться истинным ( True). Однако, если одно, или оба условия будут вычислены как ложь, то, результатом работы оператора and также будет ложь ( False).
Чтобы было легче понять вышесказанное, попробуйте ввести в интерактивную оболочку несколько команд с этим оператором:
Рис. 6.3-1 Примеры использования булева оператора and в Python 3
Булев оператор or во многом похож на оператор and . Единственным различием является то что, если, хотя бы одно из условий будет вычислено как True (истина), то и все выражение будет считаться истинным. Оператор or может дать результат False (ложь) только в одном случае: оба утверждения, справа и слева от оператора, являются ложными. Для наглядности так же, как и в случае оператора and , введем в интерактивную оболочку несколько примеров:
Рис. 6.3-2 Пример работы оператора or в Python 3
Оператор not
Оператор not работает только с одним значением. Его суть заключается в логическом отрицании: если условие является истинным, то оператор not вычислит результат выражения как False ( ложь). И наоборот, ложное условие с оператором not даст результат True ( истина). Работу этого оператора также проверим в интерактивной оболочке:
Рис 6.3-3 Пример работы оператора not в Python 3
Таблицы истинности.
Если вы забыли, как работают булевы операторы, то можете пользоваться таблицами истинности. В каждой из них перечислены все возможные варианты условий конкретного оператора и результат вычисления этих условий:
Таблица истинности оператора and
True | False | False
False | False | False