Какой логической операции нет в языке python
Перейти к содержимому

Какой логической операции нет в языке python

  • автор:

Условный оператор

Все ранее рассматриваемые программы имели линейную структуру: все инструкции выполнялись последовательно одна за одной, каждая записанная инструкция обязательно выполняется.

Допустим мы хотим по данному числу x определить его абсолютную величину (модуль). Программа должна напечатать значение переменной x, если x>0 или же величину -x в противном случае. Линейная структура программы нарушается: в зависимости от справедливости условия x>0 должна быть выведена одна или другая величина. Соответствующий фрагмент программы на Питоне имеет вид:

x = int(input())
if x > 0:
print(x)
else:
print(-x)

В этой программе используется условная инструкция if (если). После слова if указывается проверяемое условие (x > 0), завершающееся двоеточием. После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно, в нашем примере это вывод на экран величины x. Затем идет слово else (иначе), также завершающееся двоеточием, и блок инструкций, который будет выполнен, если проверяемое условие неверно, в данном случае будет выведено значение -x.

Итак, условная инструкция в Питоне имеет следующий синтаксис:

if Условие: 
Блок инструкций 1
else:
Блок инструкций 2

Блок инструкций 1 будет выполнен, если Условие истинно. Если Условие ложно, будет выполнен Блок инструкций 2.

В условной инструкции может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением. Например, если дано число x и мы хотим заменить его на абсолютную величину x, то это можно сделать следующим образом:

if x < 0:
x = -x
print(x)

В этом примере переменной x будет присвоено значение -x, но только в том случае, когда x

Для выделения блока инструкций, относящихся к инструкции if или else в языке Питон используются отступы. Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела и не рекомедуется использовать в качестве отступа символ табуляции.

Это одно из существенных отличий синтаксиса Питона от синтаксиса большинства языков, в которых блоки выделяются специальными словами, например, нц. кц в Кумире, begin. end в Паскале или фигурными скобками в Си.

Понимание работы логических операций 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 . Как всегда, скобки могут быть использованы для выражения желаемого приоритета в операциях.

Логические операции, упорядоченные по приоритету выполнения:

  1. not x — если x ложно, то возвращается True , иначе False .
  2. x and y — если x ложно, то возвращается x , иначе у .
  3. 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 :

  1. Оператор and вычисляет значения в булевом контексте слева направо. Значения 0 , » , [] , () , <> и None являются ложью, все остальное является истиной. Если у and оба операнда являются истиной, результатом будет последнее значение.
  2. Если какой-либо из операндов является ложью, результатом будет первое такое значение. В данном случает это » — пустая строка, первое значение которое является ложью.
  3. Все значения являются истиной, так что в результате мы получаем последнее 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 :

  1. Оператор or вычисляет значения в булевом контексте слева направо. Если операнд является истиной, or немедленно возвращает результат. В данном случае a , первое истинное значение.
  2. or вычисляет выражение » , которое является ложью, затем b, которое является истиной, и возвращает его значение.
  3. Если все значения являются ложью, or возвращает последнее.
  4. Обратите внимание, что 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. 

Какой логической операции нет в языке python

Ряд операций представляют условные выражения. Все эти операции принимают два операнда и возвращают логическое значение, которое в Python представляет тип bool . Существует только два логических значения — True (выражение истинно) и False (выражение ложно).

Операции сравнения

Простейшие условные выражения представляют операции сравнения, которые сравнивают два значения. Python поддерживает следующие операции сравнения:

  • == Возвращает True, если оба операнда равны. Иначе возвращает False.
  • != Возвращает True, если оба операнда НЕ равны. Иначе возвращает False.
  • > (больше чем) Возвращает True, если первый операнд больше второго.
  • < (меньше чем) Возвращает True, если первый операнд меньше второго.
  • >= (больше или равно) Возвращает True, если первый операнд больше или равен второму.

Примеры операций сравнения:

a = 5 b = 6 result = 5 == 6 # сохраняем результат операции в переменную print(result) # False - 5 не равно 6 print(a != b) # True print(a > b) # False - 5 меньше 6 print(a < b) # True bool1 = True bool2 = False print(bool1 == bool2) # False - bool1 не равно bool2

Операции сравнения могут сравнивать различные объекты - строки, числа, логические значения, однако оба операнда операции должны представлять один и тот же тип.

Логические операции

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

    Оператор and (логическое умножение) применяется к двум операндам:

x and y

Сначала оператор and оценивает выражение x, и если оно равно False, то возвращается его значение. Если оно равно True, то оценивается второй операнд - y и возвращается значение y.

age = 22 weight = 58 result = age > 21 and weight == 58 print(result) # True

В данном случае оператор and сравнивает результаты двух выражений: age > 21 weight == 58 . И если оба этих выражений возвращают True, то оператор and также возвращает True (формально возвращается значение последнего операнда). Но операндами оператора and необязательно выступают значения True и False. Это могут быть любые значения. Например:

result = 4 and "w" print(result) # w, так как 4 равно True, поэтому возвращается значение последнего операнда result = 0 and "w" print(result) # 0, так как 0 эквивалентно False
x or y

Сначала оператор or оценивает выражение x, и если оно равно True, то возвращается его значение. Если оно равно False, то оценивается второй операнд - y и возвращается значение y. Например

age = 22 isMarried = False result = age > 21 or isMarried print(result) # True, так как выражение age > 21 равно True

И также оператор or может применяться к любым значениям. Например:

result = 4 or "w" print(result) # 4, так как 4 эквивалентно True, поэтому возвращается значение первого операнда result = 0 or "w" print(result) # w, так как 0 эквивалентно False, поэтому возвращается значение последнего операнда
age = 22 isMarried = False print(not age > 21) # False print(not isMarried) # True print(not 4) # False print(not 0) # True

Оператор in

Оператор in возвращает True если в некотором наборе значений есть определенное значение. Он имеет следующую форму:

значение in набор_значений

Например, строка представляет набор символов. И с помощью оператора in мы можем проверить, есть ли в ней какая-нибудь подстрока:

message = "hello world!" hello = "hello" print(hello in message) # True - подстрока hello есть в строке "hello world!" gold = "gold" print(gold in message) # False - подстроки "gold" нет в строке "hello world!"

Если нам надо наоборот проверить, нет ли в наборе значений какого-либо значения, то мы може использовать модификацию оператора - not in . Она возвращает True , если в наборе значений НЕТ определенного значения:

message = "hello world!" hello = "hello" print(hello not in message) # False gold = "gold" print(gold not in message) # True

Python: Логические операторы

Мы уже умеем писать функции, которые проверяют одиночные условия. А в этом уроке научимся строить составные условия.

Предположим, что сайт при регистрации требует, чтобы пароль был длиннее восьми символов и содержал хотя бы одну заглавную букву. Попробуем написать два отдельных логических выражения и соединим их специальным оператором «И»:

Пароль длиннее 8 символов И пароль содержит хотя бы одну заглавную букву

Вот функция, которая принимает пароль и говорит, соответствует ли он условиям ( True ) или не соответствует ( False ):

def has_capital_letter(string): # Проверяет наличие хотя бы одной заглавной буквы в строке def is_correct_password(password): length = len(password) return length > 8 and has_capital_letter(password) print(is_correct_password('Qwerty')) # => False print(is_correct_password('Qwerty1234')) # => True print(is_correct_password('qwerty1234')) # => False 

and — означает «И». В математической логике это называют конъюнкцией. Все выражение считается истинным, если истинен каждый операнд — каждое из составных выражений. Иными словами, and означает «и то, и другое». Приоритет этого оператора ниже, чем приоритет операторов сравнения. Поэтому выражение has_capital_letter(password) and length > 8 тоже правильно отрабатывает без скобок.

Кроме and часто используется оператор or — «ИЛИ» (дизъюнкция). Он означает «или то, или другое, или оба». Выражение a or b считается истинным, если хотя бы один из операндов или одновременно все — истинные. В другом случае выражение ложное.

Операторы можно комбинировать в любом количестве и любой последовательности. Если в коде одновременно встречаются and и or , то приоритет задают скобками. Ниже пример расширенной функции, которая определяет корректность пароля:

def has_capital_letter(string): # Проверяет наличие хотя бы одной заглавной буквы в строке def has_special_chars(string): # Проверяет содержание специальных символов в строке def is_strong_password(password): length = len(password) # Скобки задают приоритет. Понятно, что к чему относится. return (length > 8 and has_capital_letter(password)) and has_special_chars(password) 

Теперь представим, что мы хотим купить квартиру, которая удовлетворяет таким условиям: площадь от 100 квадратных метров и больше на любой улице ИЛИ площадь от 80 квадратных метров и больше, но на центральной улице Main Street .

Напишем функцию, которая проверит квартиру. Она принимает два аргумента: площадь — число и название улицы — строку:

def is_good_apartment(area, street): return area >= 100 or (area >= 80 and street == 'Main Street') print(is_good_apartment(91, 'Queens Street')) # => False print(is_good_apartment(78, 'Queens Street')) # => False print(is_good_apartment(70, 'Main Street')) # => False print(is_good_apartment(120, 'Queens Street')) # => True print(is_good_apartment(120, 'Main Street')) # => True print(is_good_apartment(80, 'Main Street')) # => True 

Область математики, в которой изучаются логические операторы, называется булевой алгеброй. Ниже увидите таблицы истинности — по ним можно определить, каким будет результат, если применить оператора:

И and
A B A and B
True True True
True False False
False True False
False False False
ИЛИ or
A B A or B
True True True
True False True
False True True
False False False

Задание

Реализуйте функцию is_leap_year() , которая принимает год в форме числа и определяет является ли он високосным или нет. Год будет високосным, если он кратен (то есть делится без остатка) 400 или он одновременно кратен 4 и не кратен 100. Как видите, в определении уже заложена вся необходимая логика, осталось только переложить её на код:

is_leap_year(2018) # false is_leap_year(2017) # false is_leap_year(2016) # true 

Кратность можно проверять так:

# % - возвращает остаток от деления левого операнда на правый # Проверяем что number кратен 10 number % 10 == 0 # Проверяем что number не кратен 10 number % 10 != 0 

Упражнение не проходит проверку — что делать? ��

Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:

  • Обязательно приложите вывод тестов, без него практически невозможно понять что не так, даже если вы покажете свой код. Программисты плохо исполняют код в голове, но по полученной ошибке почти всегда понятно, куда смотреть.

В моей среде код работает, а здесь нет ��

Тесты устроены таким образом, что они проверяют решение разными способами и на разных данных. Часто решение работает с одними входными данными, но не работает с другими. Чтобы разобраться с этим моментом, изучите вкладку «Тесты» и внимательно посмотрите на вывод ошибок, в котором есть подсказки.

Мой код отличается от решения учителя ��

Это нормально ��, в программировании одну задачу можно выполнить множеством способов. Если ваш код прошел проверку, то он соответствует условиям задачи.

В редких случаях бывает, что решение подогнано под тесты, но это видно сразу.

Прочитал урок — ничего не понятно ��

Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в «Обсуждениях». Идеально, если вы сформулируете непонятные моменты в виде вопросов. Обычно нам нужно несколько дней для внесения правок.

Кстати, вы тоже можете участвовать в улучшении курсов: внизу есть ссылка на исходный код уроков, который можно править прямо из браузера.

Полезное

  • Булева алгебра
  • Логическое «И»
  • Логическое «ИЛИ»

Определения

  • Логические операторы — операторы «И» ( and ), ИЛИ ( or ), позволяющие создавать составные логические условия.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *