Понимание работы логических операций 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.
Логическое ИЛИ (||)
Логический оператор ИЛИ ( || ) (дизъюнкция) для набора операндов истинен будет true только в случае, если один или несколько его операндов имеют значение true .
Обычно используется с булевыми (логическими) значениями. Тогда возвращается булевое значение. Однако фактически оператор || возвращает значение одного из операндов, поэтому если этот оператор используется с небулевыми значениями, он вернет небулевое значение.
Интерактивный пример
Синтаксис
|| expr2;
Описание
Если expr1 может быть преобразовано в true , то вернётся expr1 ; в противном случае возвращается expr2 .
Если значение может быть преобразовано в true , то оно рассматривается как истиноподобное (truthy). Если же значение может быть преобразовано в false , то оно называется ложноподобным (falsy).
Примеры выражений, которые могут быть преобразованы в false :
- null ;
- NaN ;
- 0 ;
- пустая строка ( «» , » , « );
- undefined .
Несмотря на то, что оператор || может использоваться с операндами без логических значений, это всё равно булевый оператор, поскольку его возвращаемое значение всегда можно преобразовать в булевый примитив. Чтобы явно преобразовать возвращаемое значение этого оператора (или вообще любое выражение) в соответствующее значение булевого типа, используйте двойной оператор НЕ или конструктор Boolean (en-US).
Сокращённое вычисление
Оператор логического ИЛИ вычисляется слева направо, делая возможным сокращённое вычисление выражения, согласно следующему правилу:
(истинноподобное выражение) || следующее выражение — вычисление останавливается на истинноподобном выражении;
Сокращенное вычисление хорошо тем, что следующее выражение не будет вычислено, т.е. всё, связанное с ним, будет проигнорировано (например, если следующее выражение представляет собой вызов функции, то он никогда не произойдёт). Всё потому, что значение оператора известно уже после вычисления первого операнда. Посмотрите на пример:
function A() console.log("вызвана функция A"); return false; > function B() console.log("вызвана функция B"); return true; > console.log(B() || A()); // В результате вызова функции B, в консоли будет выведено "вызвана функция B", // а далее в консоли появится false (это результат оператора)
Приоритет операторов
Следующие выражения могут показаться эквивалентными, но это не так, потому что оператор && выполняется до оператора || (см. приоритет операторов).
true || (false && false); // вернёт true, поскольку сначала вычисляется && (true || false) && false; // вернёт false, поскольку у группировки выше приоритет
Примеры
Использование оператора ИЛИ
В следующем коде показаны примеры использования оператора || (логическое ИЛИ).
= true || true; // t || t вернёт true o2 = false || true; // f || t вернёт true o3 = true || false; // t || f вернёт true o4 = false || 3 == 4; // f || f вернёт false o5 = "Cat" || "Dog"; // t || t вернёт "Cat" o6 = false || "Cat"; // f || t вернёт "Cat" o7 = "Cat" || false; // t || f вернёт "Cat" o8 = "" || false; // f || f вернёт false o9 = false || ""; // f || f вернёт "" o10 = false || varObject; // f || object вернёт varObject
Примечание: Если вы используете этот оператор, чтобы задать значение по умолчанию для некоторой переменной, имейте в виду, что любое ложноподобное будет проигнорировано. Если вам нужно исключить только null или undefined , попробуйте воспользоваться оператором нулевого слияния.
Правила конвертации для булевых значений
Конвертация И в ИЛИ
Следующая операция с булевыми значениями:
Для чего могут использоваться операторы и или
В языке Python операторы and и or, как вы и ожидали, выполняют булевы операции, но они не возвращают булевы значения: результатом всегда является значение одного из операндов.
Пример 2.16. Оператор and
>>> 'a' and 'b' 'b' >>> '' and 'b' '' >>> 'a' and 'b' and 'c' 'c'
| При использовании оператора and, значения вычисляются в булевом контексте слева напрво. Значения 0, '', [], (), <> и None являются ложью, все остальное является истиной [3] . Если у and оба операнда являются истиной, результатом будет последнее значение. В данном случае вычисляется выражение 'a', которое является истиной, затем 'b', которое также является истиной, и возвращается 'b'. | |
| Если какой-либо из операндов является ложью, результатом будет первое такое значение. В данном случает '' — первое значение, являющееся ложью. | |
| Все значения являются истиной, так что в результате мы получаем последнее — 'c'. |
Пример 2.17. Оператор or
>>> 'a' or 'b' 'a' >>> '' or 'b' 'b' >>> '' or [] or <> <> >>> def sidefx(): . print "in sidefx()" . return 1 >>> 'a' or sidefx() 'a'
| Как и для and опреранды or вычисляются в булевском контексте слева направо. Если операнд является истиной, or немедленно возвращает результат. В данном случае 'a' — первое истинное значение. | |
| or вычисляет выражение '', которое является ложью, затем 'b', которое является истиной, и возвращает 'b'. | |
| Если все значения являются ложью, or возвращает последнее. or вычисляет '' (ложь), [] (ложь), затем <> (ложь) и возвращает <>. | |
| Обратите внимание, что or вычисляет операнды до тех пор, пока не найдет истинное значение, остальное игнорируется. Это имеет значение, когда вычисление операнда дает сторонние эффекты. В данном случае функция sidefx не вызывается, так как для получения результата выражения с опереатором or достаточно того, что первый операнд, 'a', является истиной. |
Если вы используете C, то, наверное, знакомы с выражением bool ? a : b, которое дает a, если bool является истиной, b, если bool ложно. Благодаря особенностям работы операторов and и or в Python, вы можете достигнуть анологичного эффекта.
Пример 2.18. Прием с and-or
>>> a = "first" >>> b = "second" >>> 1 and a or b 'first' >>> 0 and a or b 'second'
| Синтаксис bool ? a : b в языке Python выглядит похоже. Все выражение вычисляется слева направо, так что оператор and применяется первым. 1 and 'first' дает 'first', затем 'first' or 'second' дает 'first'. | |
| 0 and 'first' дает 0, тогда 0 or 'second' дает 'second'. |
Однако, так как такое выражение выполняет обычные логические операции, а не является специальной конструкцией языка, существует очень важная разница между приемом с and-or в языке Python и конструкцией bool ? a : b в C. Если значение a является ложью, это прием не будет работать так как вы могли ожидать. (Вы можете сказать, что обожгись на этом? Более одного раза?)
Пример 2.19. Когда прием с and-or не работает
>>> a = "" >>> b = "second" >>> 1 and a or b 'second'
| Так как a — пустая строка, которую Python считает ложью в булевом контексте, 1 and '' дает '', а '' or 'second' дает 'second'. Ой! Это не то, что мы хотели получить. |
| Прием с and-or, bool and a or b, не будет работать так же, как конструкция bool ? a : b в C, если a является ложью. | |
Для безопасного использования приема с and-or необходимо сделать так, чтобы a всегда было истинным. Один из самых распространенных способо это сделать — заменить a на [a] и b на [b], тогда первый элемент получаемого списка будет либо a, либо b.
Пример 2.20. Безопасное использование приема с and-or
>>> a = "" >>> b = "second" >>> (1 and [a] or [b])[0] ''
| Так как выражение [a] является непустым списком, оно никогда не будет ложно. Даже если a равно 0, '' или другому значению, являющемуся ложью, список [a] всегда будет являться истиной, потому что содержит один элемент. |
Кажется, этот прием не стоит того, чтобы его использовать. В конце концов вы всегда можете воспользоваться интсрукцией if. Тогда зачем вся эта суета? Конечно, в большинстве случаев выбирая между двумя константами вы можете использовать простой синтаксис и не беспокоиться, потому что значение a всегда будет истинным. И даже если придется использовать более сложный синтакс, на это могут найтись весские причины: в некоторых случаях в языке Python использование инструкции if не допускается, например в lambda-функциях.
- В Python Cookbook обсуждаются альтернативы приему с and-or.
[3] Ну, почти все. По умолчанию экземпляры классов являются истиной, но вы можете определить специальные методы в классе, чтобы его экземпляры могли быть ложью. Вы узнаете все о классах и специальных методах в главе 3.
Copyright © 2000, 2001, 2002 Марк Пилгрим
Copyright © 2001, 2002 Перевод, Денис Откидач
Операторы Python
В этом руководстве речь пойдет об операторах языка программирования Python. Вы узнаете об арифметических, логических и битовых операторах, а также операторах сравнения, присваивания, принадлежности, тождественности и их синтаксисе. Все это будет проиллюстрировано примерами.
Оператор в Python — это символ, который выполняет операцию над одним или несколькими операндами.
Операндом выступает переменная или значение, над которыми проводится операция.
Введение в операторы Python
Операторы Python бывают 7 типов:
- Арифметические операторы
- Операторы сравнения
- Операторы присваивания
- Логические операторы
- Операторы принадлежности
- Операторы тождественности
- Битовые операторы
Арифметические операторы Python
Этот тип включает операторы для проведения базовых арифметических операций.
Сложение (+)
Складывает значение по обе стороны оператора.
Пример:
Вычитание (-)
Вычитает значение правой стороны из значения в левой.
Пример:
Умножение (*)
Перемножает значения с обеих сторон оператора.
Пример:
Деление (/)
Делит значение левой стороны на значение правой. Тип данных результата деления — число с плавающей точкой.
Пример:
Возведение в степень (**)
Возводит первое число в степень второго.
Пример:
Деление без остатка (//)
Выполняет деление и возвращает целочисленное значение частного, убирая цифры после десятичной точки.
Пример:
Деление по модулю (остаток от деления) (%)
Выполняет деление и возвращает значение остатка.
Пример:
>>> 10.5%3 Операторы сравнения
Операторы сравнения в Python проводят сравнение операндов. Они сообщают, является ли один из них больше второго, меньше, равным или и то и то.
Меньше (<)
Этот оператор проверяет, является ли значение слева меньше, чем правое.
Пример:
False Больше (>)
Проверяет, является ли значение слева больше правого.
Пример:
True Меньше или равно (<=)
Проверяет, является ли левая часть меньше или равной правой.
Пример:
True Больше или равно (>=)
Проверяет, является ли левая часть больше или равной правой.
Пример:
True Равно (==)
Этот оператор проверяет, равно ли значение слева правому. 1 равна булевому True , а 2 (двойка) — нет. 0 равен False .
Пример:
True >>> 1==True True >>> 7==True False >>> 0==False True >>> 0.5==True False Не равно (!=)
Проверяет, не равно ли значение слева правому. Оператор <> выполняет ту же задачу, но его убрали в Python 3.
Когда условие выполнено, возвращается True . В противном случае — False . Это возвращаемое значение можно использовать в последующих инструкциях и выражениях.
Пример:
False >>> 1==True # Это вызывает SyntaxError Операторы присваивания
Оператор присваивания присваивает значение переменной. Он может манипулировать значением до присваивания. Есть 8 операторов присваивания: 1 простой и 7 с использованием арифметических операторов.
Присваивание (=)
Присваивает значение справа левой части. Стоит обратить внимание, что == используется для сравнения, а = — для присваивания.
Пример:
>>> a = 7 >>> print(a) Сложение и присваивание (+=)
Суммирует значение обеих сторон и присваивает его выражению слева. a += 10 — это то же самое, что и a = a + 10 .
То же касается и все остальных операторов присваивания.
Пример:
>>> a += 2 >>> print(a) Вычитание и присваивание (-=)
Вычитает значение справа из левого и присваивает его выражению слева.
Пример:
>>> a -= 2 >>> print(a) Деление и присваивание (/=)
Делит значение слева на правое. Затем присваивает его выражению слева.
Пример:
>>> a /= 7 >>> print(a) Умножение и присваивание (*=)
Перемножает значения обеих сторон. Затем присваивает правое левому.
Пример:
>>> a *= 8 >>> print(a) Деление по модулю и присваивание (%=)
Выполняет деление по модулю для обеих частей. Результат присваивает левой части.
Пример:
>>> a %= 3 >>> print(a) Возведение в степень и присваивание (**=)
Выполняет возведение левой части в степень значения правой части. Затем присваивает значение левой части.
Пример:
>>> a **= 5 >>> print(a) Деление с остатком и присваивание (//=)
Выполняет деление с остатком и присваивает результат левой части.
Пример:
>>> a //= 3 >>> print(a) Это один из важных операторов Python
Логические операторы Python
Это союзы, которые позволяют объединять по несколько условий. В Python есть всего три оператора: and (и), or (или) и not (не).
И (and)
Если условия с двух сторон оператора and истинны, тогда все выражение целиком считается истинным.
Пример:
>>> a = 7 > 7 and 2 > -1 >>> print(a) False Или (or)
Выражение ложно, если оба операнда с двух сторон ложные. Если хотя бы одно из них истинное, то и все выражение истинно.
Пример:
>>> a = 7 > 7 or 2 > -1 >>> print(a) True Не (not)
Этот оператор инвертирует булевые значения выражения. True превращается в False и наоборот. В примере внизу булево значение 0 — False . Поэтому оно превращается в True .
Пример:
>>> a = not(0) >>> print(a) True Операторы принадлежности
Эти операторы проверяют, является ли значение частью последовательности. Последовательность может быть списком, строкой или кортежем. Есть всего два таких оператора: in и not in .
В (in)
Проверяет, является ли значение членом последовательности. В этом примере видно, что строки fox нет в списке питомцев. Но cat — есть, поэтому она возвращает True . Также строка me является подстрокой disappointment . Поэтому она вернет True .
Пример:
>>> pets=['dog','cat', 'ferret'] >>> 'fox' in pets False >>> 'cat' in pets True >>> 'me' in 'disappointment' True Нет в (not in)
Этот оператор проверяет, НЕ является ли значение членом последовательности.
Пример:
>>> 'pot' not in 'disappointment' True Операторы тождественности
Эти операторы проверяют, являются ли операнды одинаковыми (занимают ли они одну и ту же позицию в памяти).
Это (is)
Если операнды тождественны, то вернется True . В противном случае — False . Здесь 2 не является 20 , поэтому вернется False . Но ‘2’ — это то же самое, что и «2» . Разные кавычки не меняют сами объекты, поэтому вернется True .
Пример:
>>> 2 is 20 False >>> '2' is "2" True Это не (is not)
2 — это число, а ‘2’ — строка. Поэтому вернется True .
Пример:
>>> 2 is not '2' True Битовые операторы Python
Эти операторы работают над операндами бит за битом.
Бинарное И (&)
Проводит побитовую операцию and над двумя значением. Здесь бинарная 2 — это 10 , а 3 — 11 . Результатом побитового and является 10 — бинарная 2 . Побитовое and над 011 (3) и 100 (4) выдает результат 000 (0).
Пример:
Бинарное ИЛИ (|)
Проводит побитовую операцию or на двух значениях. Здесь or для 10 (2) и 11 (3) возвращает 11 (3).
Пример:
Бинарное ИЛИ НЕТ (^)
Проводит побитовую операцию xor (исключающее или) на двух значениях. Здесь результатом ИЛИ НЕ для 10 (2) и 11 (3) будет 01 (1).
Пример:
Инвертирующий оператор (~)
Он возвращает инвертированные двоичные числа. Другими словами, переворачивает биты. Битовая 2 — это 00000010 . Ее инвертированная версия — 11111101 . Это бинарная -3 . Поэтому результат -3 . Похожим образом ~1 равняется -2 .
Пример:
Еще раз, инвертированная -3 — это 2 .
Бинарный сдвиг влево (<<)
Он сдвигает значение левого операнда на позицию, которая указана справа. Так, бинарная 2 — это 10 . 2 Пример:
Бинарный сдвиг вправо (>>)
Сдвигает значение левого оператора на позицию, указанную справа. Так, бинарная 3 — это 11 . 3 >> 2 сдвинет значение на два положение вправо. Результат — 00 , то есть 0 . 3 >> 1 сдвинет на одну позицию вправо, а результатом будет 01 — бинарная 1 .
Пример:
>>> 3>>2 >>> 3>>1 Выводы
В этом уроке были рассмотрены все 7 типов операторов Python. Для каждого был предложен пример в IDE. Для понимания особенностей работы операторов нужно продолжать с ними работать, использовать в условных конструкциях и объединять.