Операторы и выражения на языке Python. Операторы в Python
26 10.2017
Для взаимодействия с определёнными числами или функциями требуются какие-то операции. Допустим, сложение, вычитание, умножение, деление. Например арифметический корень и возведение в степень. Операторы python имеют важное значение. Без них не было бы программы. И для того, чтобы перечислить все существующие операторы, выделен целый раздел.
Из этой статьи вы узнаете:
Всем привет, читатели, гости и друзья, с вами Гридин Семён. Недавно я проводил небольшой анонимный опрос среди своих подписчиков. В базе у меня подписалось 35 человек. Письма прочитали лишь половина, ответили на опрос всего три человека. Но знаете, для меня это очень большой результат. Приятно, когда всё-таки не стоишь на одном месте.
У меня на самом деле очень много идей и мыслей по развитию блога. Я уже давно запланировал открыть раздел по самоделкам на базе ПЛК, и Raspberry PI. Я хочу размещать на сайте не только свои проекты. Но также и проекты других авторов, определённо за денежное вознаграждение и прямую ссылку в соц. сетях.
Открою ещё вот такие разделы:
- Новости в области робототехники;
- Квадрокоптеры;
- Библиотеки;
- Механика роботов;
Конкурсы, конкурсы... Все любят призы, бонусы и подарки. Я тоже люблю, правда я пока не разу не участвовал нигде. Ещё не выпадал такой случай. Обязательно организую конкурсы.
С 1 пунктом всё никак не удаётся справиться. Написание качественных статей требует время. Пока не удаётся всё оптимизировать и укладываться вовремя.
Разносторонних тем по на самом деле много. Тема очень многогранная и обширная. Потихоньку будем охватывать. И разбирать практические примеры. Я в большей степени практик.
Знаете, очень приятно, что мой ресурс не бесполезен. Очень приятное ощущение от того, что ты принёс кому-то пользу. Это очень мотивирует работать над сайтом и двигаться дальше. Спасибо и вам друзья. Я стараюсь так, чтобы сайт был актуален на несколько лет вперёд.
Что такое оператор?
Под операторами понимаются какие-то особые отображения и действия с числами или ставящее в соответствие функции другую функцию. Говоря простым языком в выражении 4+5 =9. Цифры называются операндами, а «+» и «=» операторами. Ну вообщем как-то так.
В языке их несколько типов. Ну как и в другом любом языке.
- арифметические операторы (arithmetic operators);
- операторы сравнения (comparison или relational operators);
- операторы присваивания (assignment operators);
- логические операторы (logical operators);
- битовые операторы (bitwise operators);
- операторы принадлежности (membership operators);
- операторы тождественности (identity operators).
Арифметические операторы
Оператор | Описание | Примеры |
---|---|---|
+ | Сложение — Суммирует значения слева и справа от оператора | 15 + 5 в результате будет 20 20 + -3 в результате будет 17 13.4 + 7 в результате будет 20.4 |
— | Вычитание — Вычитает правый операнд из левого | 15 — 5 в результате будет 10 20 — -3 в результате будет 23 13.4 — 7 в результате будет 6.4 |
* | Умножение — Перемножает операнды | 5 * 5 в результате будет 25 7 * 3.2 в результате будет 22.4 — 3 * 12 в результате будет -36 |
/ | Деление — Делит левый операнд на правый | 15 / 5 в результате будет 3 5 / 2 в результате будет 2 (В Python 2.x версии при делении двух целых чисел результат будет целое число) 5.0 / 2 в результате будет 2.5 (Чтобы получить «правильный» результат хотя бы один операнд должен быть float) |
% | Деление по модулю — Делит левый операнд на правый и возвращает остаток. | 6 % 2 в результате будет 0 7 % 2 в результате будет 1 13.2 % 5 в результате 3.2 |
** | Возведение в степень — возводит левый операнд в степень правого | 5 ** 2 в результате будет 25 2 ** 3 в результате будет 8 — 3 ** 2 в результате будет -9 |
// | Целочисленное деление — Деление в котором возвращается только целая часть результата. Часть после запятой отбрасывается. | 12 // 5 в результате будет 2 4 // 3 в результате будет 1 25 // 6 в результате будет 4 |
Операторы сравнения
Оператор | Описание | Примеры |
---|---|---|
== | Проверяет равны ли оба операнда. Если да, то условие становится истинным. | 5 == 5 в результате будет True True == False в результате будет False «hello» == «hello» в результате будет True |
!= | 12 != 5 в результате будет True False != False в результате будет False «hi» != «Hi» в результате будет True |
|
<> | Проверяет равны ли оба операнда. Если нет, то условие становится истинным. | 12 <> 5 в результате будет True. Похоже на оператор!= |
> | Проверяет больше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 5 > 2 в результате будет True. True > False в результате будет True. «A» > «B» в результате будет False. |
< | Проверяет меньше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 3 < 5 в результате будет True. True < False в результате будет False. «A» < «B» в результате будет True. |
>= | Проверяет больше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 1 >= 1 в результате будет True. 23 >= 3.2 в результате будет True. «C» >= «D» в результате будет False. |
<= | Проверяет меньше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 4 <= 5 в результате будет True. 0 <= 0.0 в результате будет True. — 0.001 <= -36 в результате будет False. |
Операторы присваивания
Оператор | Описание | Примеры |
---|---|---|
= | Присваивает значение правого операнда левому. | c = 23 присвоит переменной с значение 23 |
+= | Прибавит значение правого операнда к левому и присвоит эту сумму левому операнду. | с = 5 а = 2 с += а равносильно: с = с + а. с будет равно 7 |
-= | Отнимает значение правого операнда от левого и присваивает результат левому операнду. | с = 5 а = 2 с -= а равносильно: с = с — а. с будет равно 3 |
*= | Умножает правый операнд с левым и присваивает результат левому операнду. | с = 5 а = 2 с *= а равносильно: с = с * а. c будет равно 10 |
/= | Делит левый операнд на правый и присваивает результат левому операнду. | с = 10 а = 2 с /= а равносильно: с = с / а. c будет равно 5 |
%= | Делит по модулю операнды и присваивает результат левому. | с = 5 а = 2 с %= а равносильно: с = с % а. c будет равно 1 |
**= | Возводит в левый операнд в степень правого и присваивает результат левому операнду. | с = 3 а = 2 с **= а равносильно: с = с ** а. c будет равно 9 |
//= | Производит целочисленное деление левого операнда на правый и присваивает результат левому операнду. | с = 11 а = 2 с //= а равносильно: с = с // а. c будет равно 5 |
Побитовые операторы
Для тех кто не изучал курсы информатики. Представим что у нас есть два числа a=60 и b=13. В двоичной системе они будут выглядеть следующим образом a=0011 1100 и b=0000 1101.
Что можно делать с ними в итоге?
Оператор | Описание | Примеры |
---|---|---|
& | Бинарный «И» оператор, копирует бит в результат только если бит присутствует в обоих операндах. | (a & b) даст нам 12, которое в двоичном формате выглядит так 0000 1100 |
| | Бинарный «ИЛИ» оператор копирует бит, если тот присутствует в хотя бы в одном операнде. | (a | b) даст нам 61, в двоичном формате 0011 1101 |
^ | Бинарный «Исключительное ИЛИ» оператор копирует бит только если бит присутствует в одном из операндов, но не в обоих сразу. | (a ^ b) даст нам 49, в двоичном формате 0011 0001 |
~ | Бинарный комплиментарный оператор. Является унарным (то есть ему нужен только один операнд) меняет биты на обратные, там где была единица становиться ноль и наоборот. | (~a) даст в результате -61, в двоичном формате выглядит 1100 0011. |
<< | Побитовый сдвиг влево. Значение левого операнда «сдвигается» влево на количество бит указанных в правом операнде. | a << 2 в результате даст 240, в двоичном формате 1111 0000 |
>> | Побитовый сдвиг вправо. Значение левого операнда «сдвигается» вправо на количество бит указанных в правом операнде. | a >> 2 даст 15, в двоичном формате 0000 1111 |
Логические операторы
Операторы членства
Эти операторы необходимы для проверки отдельных элементов в составных (строки, кортежи, списки и словари)
Операторы тождественности
Приоритет операторов
Оператор | Описание |
---|---|
** | Возведение в степень |
~ + — | Комплиментарный оператор |
* / % // | Умножение, деление, деление по модулю, целочисленное деление. |
+ — | Сложение и вычитание. |
>> << | Побитовый сдвиг вправо и побитовый сдвиг влево. |
& | Бинарный «И». |
^ | | Бинарный «Исключительное ИЛИ» и бинарный «ИЛИ» |
<= < > >= | Операторы сравнения |
<> == != | Операторы равенства |
= %= /= //= -= += *= **= | Операторы присваивания |
is is not | Тождественные операторы |
in not in | Операторы членства |
not or and | Логические операторы |
Вот такой вот небольшой списочек операторов. Пускай эта страница будет вам заметкой при программировании на языке Python.
Недавно я купил книгу И.В. Петрова «Программируемые контроллеры в автоматических системах». Так как вроде и пишу много в , но всё равно не чувствую себя профи:
Я как-то был на грани того, чтобы сдаться и бросить свой проект. Раньше я искал мотивацию, чтобы заниматься чем-нибудь. Я искал смысл во всех действиях, думал, а какой в конечном счёте мне даст результат? И опять искал мотивацию...
К чему это я, сейчас опять я тупо клацаю по клавиатуре и смотрю в монитор. И я снова написал статью, пишу эти строчки, иногда не зная, почему и зачем, к чему меня приведёт это в конце концов?
Да, у меня появляются трудности, да, у меня много чего не получается. Но нужно бороться с этим.
Знаете, от того чем ты занимаешься, нужно получать кайф, живём всё равно один раз.
Ещё раз о мотивации, посмотрите, что говорит Джордж Карлин по этому поводу, сорри за ненормативную лексику.
С уважением, Гридин Семён
Оператор | Описание | Примеры |
---|---|---|
+ | Сложение - Суммирует значения слева и справа от оператора |
15 + 5 в результате будет 20 |
- | Вычитание - Вычитает правый операнд из левого | 15 - 5 в результате будет 10 20 - -3 в результате будет 23 13.4 - 7 в результате будет 6.4 |
* | Умножение - Перемножает операнды | 5 * 5 в результате будет 25 7 * 3.2 в результате будет 22.4 -3 * 12 в результате будет -36 |
/ | Деление - Делит левый операнд на правый | 15 / 5 в результате будет 3 5 / 2 в результате будет 2 (В Python 2.x версии при делении двух целых чисел результат будет целое число) 5.0 / 2 в результате будет 2.5 (Чтобы получить "правильный" результат хотя бы один операнд должен быть float) |
% | Деление по модулю - Делит левый операнд на правый и возвращает остаток. | 6 % 2 в результате будет 0 7 % 2 в результате будет 1 13.2 % 5 в результате 3.2 |
** | Возведение в степень - возводит левый операнд в степень правого | 5 ** 2 в результате будет 25 2 ** 3 в результате будет 8 -3 ** 2 в результате будет -9 |
// | Целочисленное деление - Деление в котором возвращается только целая часть результата. Часть после запятой отбрасывается. | 12 // 5 в результате будет 2 4 // 3 в результате будет 1 25 // 6 в результате будет 4 |
Операторы сравнения в Python:
Оператор | Описание | Примеры |
---|---|---|
== | Проверяет равны ли оба операнда. Если да, то условие становится истинным. | 5 == 5 в результате будет True True == False в результате будет False "hello" == "hello" в результате будет True |
!= | 12 != 5 в результате будет True False != False в результате будет False "hi" != "Hi" в результате будет True |
|
<> | Проверяет равны ли оба операнда. Если нет, то условие становится истинным. |
12 <> 5 в результате будет True. Похоже на оператор!= |
> | Проверяет больше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 5 > 2 в результате будет True. True > False в результате будет True. "A" > "B" в результате будет False. |
< | Проверяет меньше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 3 < 5 в результате будет True. True < False в результате будет False. "A" < "B" в результате будет True. |
>= | Проверяет больше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 1 >= 1 в результате будет True. 23 >= 3.2 в результате будет True. "C" >= "D" в результате будет False. |
<= | Проверяет меньше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным. | 4 <= 5 в результате будет True. 0 <= 0.0 в результате будет True. -0.001 <= -36 в результате будет False. |
Операторы присваивания в Python:
Оператор | Описание | Примеры |
---|---|---|
= | Присваивает значение правого операнда левому. | c = 23 присвоит переменной с значение 23 |
+= | Прибавит значение правого операнда к левому и присвоит эту сумму левому операнду. |
с = 5 |
-= | Отнимает значение правого операнда от левого и присваивает результат левому операнду. |
с = 5 |
*= | Умножает правый операнд с левым и присваивает результат левому операнду. |
с = 5 |
/= | Делит левый операнд на правый и присваивает результат левому операнду. | с = 10 а = 2 с /= а равносильно: с = с / а. c будет равно 5 |
%= | Делит по модулю операнды и присваивает результат левому. | с = 5 а = 2 с %= а равносильно: с = с % а. c будет равно 1 |
**= | Возводит в левый операнд в степень правого и присваивает результат левому операнду. | с = 3 а = 2 с **= а равносильно: с = с ** а. c будет равно 9 |
//= | Производит целочисленное деление левого операнда на правый и присваивает результат левому операнду. | с = 11 а = 2 с //= а равносильно: с = с // а. c будет равно 5 |
Побитовые операторы в Python:
Побитовые операторы предназначены для работы с данными в битовом (двоичном) формате. Предположим, что у нас есть два числа a = 60; и b = 13. В двоичном формате они будут иметь следующий вид:
Оператор | Описание | Примеры |
---|---|---|
& | Бинарный "И" оператор, копирует бит в результат только если бит присутствует в обоих операндах. | (a & b) даст нам 12, которое в двоичном формате выглядит так 0000 1100 |
| | Бинарный "ИЛИ" оператор копирует бит, если тот присутствует в хотя бы в одном операнде. | (a | b) даст нам 61, в двоичном формате 0011 1101 |
^ | Бинарный "Исключительное ИЛИ" оператор копирует бит только если бит присутствует в одном из операндов, но не в обоих сразу. | (a ^ b) даст нам 49, в двоичном формате 0011 0001 |
~ | Бинарный комплиментарный оператор. Является унарным (то есть ему нужен только один операнд) меняет биты на обратные, там где была единица становиться ноль и наоборот. | (~a) даст в результате -61, в двоичном формате выглядит 1100 0011. |
<< | Побитовый сдвиг влево. Значение левого операнда "сдвигается" влево на количество бит указанных в правом операнде. | a << 2 в результате даст 240, в двоичном формате 1111 0000 |
>> | Побитовый сдвиг вправо. Значение левого операнда "сдвигается" вправо на количество бит указанных в правом операнде. | a >> 2 даст 15, в двоичном формате 0000 1111 |
Логические операторы в Python:
Оператор | Описание | Примеры |
---|---|---|
and | Логический оператор "И". Условие будет истинным если оба операнда истина. |
True and True равно True. |
or | Логический оператор "ИЛИ". Если хотя бы один из операндов истинный, то и все выражение будет истинным. | True or True равно True. True or False равно True. False or True равно True. False or False равно False. |
not | Логический оператор "НЕ". Изменяет логическое значение операнда на противоположное. | not True равно False. not False равно True. |
Операторы членства в Python:
В добавок к перечисленным операторам, в Python присутствуют, так называмые, операторы членства, предназначенные для проверки на наличие элемента в составных типах данных, таких, как строки, списки, кортежи или словари :
Операторы тождественности в Python:
Операторы тождественности сравнивают размещение двух объектов в памяти компьютера.
Приоритет операторов в Python
В следующей таблице описан приоритет выполнения операторов в Python от наивысшего (выполняется в первую очередь) до наинизшего.
Оператор | Описание |
---|---|
** | Возведение в степень |
~ + - | Комплиментарный оператор |
* / % // | Умножение, деление, деление по модулю, целочисленное деление. |
+ - | Сложение и вычитание. |
>> << | Побитовый сдвиг вправо и побитовый сдвиг влево. |
& | Бинарный "И". |
^ | | Бинарный "Исключительное ИЛИ" и бинарный "ИЛИ" |
<= < > >= | Операторы сравнения |
<> == != | Операторы равенства |
= %= /= //= -= += *= **= | Операторы присваивания |
is is not | Тождественные операторы |
in not in | Операторы членства |
not or and | Логические операторы |
Все ранее рассматриваемые программы имели линейную структуру: все инструкции выполнялись последовательно одна за одной, каждая записанная инструкция обязательно выполняется.
Допустим мы хотим по данному числу x определить его абсолютную величину (модуль). Программа должна напечатать значение переменной x, если x>0 или же величину -x в противном случае. Линейная структура программы нарушается: в зависимости от справедливости условия x>0 должна быть выведена одна или другая величина. Соответствующий фрагмент программы на Питоне имеет вид:
273 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 , то это можно сделать следующим образом:
273 x = int(input()) if x < 0: x = -x print(x)
В этом примере переменной x будет присвоено значение -x , но только в том случае, когда x<0 . А вот инструкция print(x) будет выполнена всегда, независимо от проверяемого условия.
Для выделения блока инструкций, относящихся к инструкции if или else в языке Питон используются отступы. Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела и не рекомедуется использовать в качестве отступа символ табуляции.
Это одно из существенных отличий синтаксиса Питона от синтаксиса большинства языков, в которых блоки выделяются специальными словами, например, нц... кц в Кумире, begin... end в Паскале или фигурными скобками в Си.
2. Вложенные условные инструкции
Внутри условных инструкций можно использовать любые инструкции языка Питон, в том числе и условную инструкцию. Получаем вложенное ветвление - после одной развилки в ходе исполнения программы появляется другая развилка. При этом вложенные блоки имеют больший размер отступа (например, 8 пробелов). Покажем это на примере программы, которая по данным ненулевым числам x и y определяет, в какой из четвертей координатной плоскости находится точка (x,y):
2 -3 x = int(input()) y = int(input()) if x > 0: if y > 0: # x > 0, y > 0 print("Первая четверть") else: # x > 0, y < 0 print("Четвертая четверть") else: if y > 0: # x < 0, y > 0 print("Вторая четверть") else: # x < 0, y < 0 print("Третья четверть")
В этом примере мы использовали комментарии - текст, который интерпретатор игнорирует. Комментариями в Питоне является символ # и весь текст после этого символа до конца строки.
3. Операторы сравнения
Как правило, в качестве проверяемого условия используется результат вычисления
одного из следующих операторов сравнения:
< Меньше — условие верно, если первый операнд меньше второго.
> Больше — условие верно, если первый операнд больше второго.
<= Меньше или равно.
>= Больше или равно.
== Равенство. Условие верно, если два операнда равны.
!= Неравенство. Условие верно, если два операнда неравны.
Например, условие (x * x < 1000) означает “значение x * x меньше 1000”, а условие (2 * x != y) означает “удвоенное значение переменной x не равно значению переменной y ”.
Операторы сравнения в Питоне можно объединять в цепочки (в отличии от большинства других языков программирования, где для этого нужно использовать логические связки), например, a == b == c или 1 <= x <= 10 .
4. Тип данных bool
Операторы сравнения возвращают значения специального логического типа bool . Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь). Если преобразовать логическое True к типу int , то получится 1, а преобразование False даст 0. При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .
4.1. Логические операторы
Иногда нужно проверить одновременно не одно, а несколько условий. Например, проверить, является ли данное число четным можно при помощи условия (n % 2 == 0) (остаток от деления n на 2 равен 0), а если необходимо проверить, что два данных целых числа n и m являются четными, необходимо проверить справедливость обоих условий: n % 2 == 0 и m % 2 == 0 , для чего их необходимо объединить при помощи оператора and (логическое И): n % 2 == 0 and m % 2 == 0 .
В Питоне существуют стандартные логические операторы: логическое И, логическое ИЛИ, логическое отрицание.
Логическое И является бинарным оператором (то есть оператором с двумя операндами: левым и правым) и имеет вид and . Оператор and возвращает True тогда и только тогда, когда оба его операнда имеют значение True .
Логическое ИЛИ является бинарным оператором и возвращает True тогда и только тогда, когда хотя бы один операнд равен True . Оператор “логическое ИЛИ” имеет вид or .
Логическое НЕ (отрицание) является унарным (то есть с одним операндом) оператором и имеет вид not , за которым следует единственный операнд. Логическое НЕ возвращает True , если операнд равен False и наоборот.
Пример. Проверим, что хотя бы одно из чисел a или b оканчивается на 0:
15 40 a = int(input()) b = int(input()) if a % 10 == 0 or b % 10 == 0: print("YES") else: print("NO")
Проверим, что число a — положительное, а b — неотрицательное:
If a > 0 and not (b < 0):
Или можно вместо not (b < 0) записать (b >= 0) .
5. Каскадные условные инструкции
Пример программы, определяющий четверть координатной плоскости, можно переписать используя “каскадную“ последовательность операцией if... elif... else:
5 7 x = int(input()) y = int(input()) if x > 0 and y > 0: print("Первая четверть") elif x > 0 and y < 0: print("Четвертая четверть") elif y > 0: print("Вторая четверть") else: print("Третья четверть")
В такой конструкции условия if , ..., elif проверяются по очереди, выполняется блок, соответствующий первому из истинных условий. Если все проверяемые условия ложны, то выполняется блок else , если он присутствует.
Логический тип данных (или Boolean) – это примитивный тип, который принимает одно из двух возможных значений: истину (True) или ложь (False). Этот тип используется во многих языках программирования для построения алгоритмов и управления поведением программ.
Примечание : Название этого типа данных (Boolean) всегда пишется с заглавной буквы, поскольку он назван в честь математика Джорджа Буля, который занимался исследованиями математической логики. Значения True и False тоже пишутся с большой буквы – в Python они являются специальными значениями.
Данное руководство ознакомит вас с основами булевой логики в Python: операторами сравнения, логическими операторами, таблицами истинности и т.п.
Операторы сравнения
В программировании операторы сравнения используются при оценке и сравнении значений для последующего сведения их к одному логическому значению (True или False).
Операторы сравнения Python 3 представлены в этой таблице:
Оператор | Значение |
== | Проверяет равенство между компонентами; условие истинно, если компоненты равны. |
!= | Проверяет равенство между компонентами; условие истинно, если компоненты НЕ равны. |
< | Оценивает значение левого компонента; условие истинно, если он меньше, чем правый. |
> | Оценивает значение левого компонента; условие истинно, если он больше, чем правый. |
<= | Оценивает значение левого компонента; условие истинно, если он меньше или равен правому компоненту. |
>= | Оценивает значение левого компонента; условие истинно, если он больше или равен правому компоненту. |
Попробуйте поработать с этими операторами, чтобы понять, как они действуют. Для начала создайте пару переменных:
Теперь сравните значения переменных с помощью вышеперечисленных операторов.
x = 5
y = 8
print("x == y:", x == y)
print("x != y:", x != y)
print("x < y:", x < y)
print("x > y:", x > y)
print("x <= y:", x <= y)
print("x >= y:", x >= y)
x == y: False
x != y: True
x < y: True
x > y: False
x <= y: True
x >= y: False
Следуя математической логике, Python оценивает соотношения между значениями переменных так:
- 5 равно 8? Ложь
- 5 не равно 8? Истина
- 5 меньше 8? Истина
- 5 больше 8? Ложь
- 5 меньше или равно 8? Истина
- 5 больше или равно 8? Ложь
Также операторы сравнения можно применять к числам с плавающей точкой и строкам.
Примечание : Строки чувствительны к регистру; чтобы отключить такое поведение, нужно использовать специальный метод.
Попробуйте сравнить две строки:
Hello = "Hello"
hello = "hello"
Hello == hello: False
Строки Hello и hello содержат одинаковый набор символов, однако они не равны, поскольку одна из них содержит символы верхнего регистра. Попробуйте добавить ещё одну переменную, которая также будет содержать символы верхнего регистра, а затем сравните их.
Hello = "Hello"
hello = "hello"
Hello_there = "Hello"
print("Hello == hello: ", Hello == hello)
print("Hello == Hello_there", Hello == Hello_there)
Hello == hello: False
Hello == Hello_there: True
Также для сравнения строк можно использовать операторы > и <. Python выполнит лексикографическое сравнение строк на основе значений символов ASCII.
Операторы сравнения можно применять к логическим значениям True и False:
t = True
f = False
print("t != f: ", t != f)
t != f: True
Обратите внимание на разницу между операторами = и ==.
x = y # Оператор присваивания. Устанавливает равенство между x и y (то есть присваивает x значение y).
x == y # Оператор сравнения. Проверяет равенство между x и y и оценивает выражение как истинное или ложное. Выражение истинно, если x и y равны.
Логические операторы
Для сравнения значений используется три логических оператора, которые сводят результат к логическому значению True или False.
Логические операторы обычно используются для оценки двух или больше выражений. Например, их можно использовать в программе, которая проверит:
- сдал ли студент экзамен
- и зарегистрирован ли он.
Если оба значения истинны, студент будет переведён на следующий курс.
Другой пример: программа с логическими операторами может проверять активность пользователя в онлайн-магазине:
- использовал ли он кредит магазина
- или заказывал ли он товары в течение последних 6 месяцев.
Для примера попробуйте сравнить три выражения:
print((9 > 7) and (2 < 4)) # Оба выражения истинны (True)
print((8 == 8) or (6 != 6)) # Одно из выражений истинно (True)
print(not(3 <= 1)) # Выражение ложно (False)
True
True
True
В первом случае оба выражения истинны, потому оператор and возвращает True.
Во втором случае истинно только значение 8 == 8. Поскольку хотя бы одно из предложенных условий истинно, оператор or возвращает True. Оператор and в таком случае выдал бы False.
В третьем случае выражение 3 <= 1 ложно. Оператор not изменяет полученное логическое значение на противоположное: not False = True.
Теперь попробуйте сравнить числа с плавающей точкой.
print((-0.2 > 1.4) and (0.8 < 3.1)) # Одно из выражений ложно (False)
print((7.5 == 8.9) or (9.2 != 9.2)) # Оба выражения ложны (False)
print(not(-5.7 <= 0.3)) # Выражение истинно (True)
- Поскольку в первом примере одно из выражений ложно, and вернёт False. Оператор and оценивает выражение как истинное только тогда, когда оба компонента истинны.
- Поскольку оба выражения ложны, оператор or выдаст False.
- Поскольку выражение истинно, оператор not вернёт False (not True = False).
Примечание : Если вы не понимаете, как это работает, вам помогут разобраться таблицы истинности. Эту тему мы рассмотрим далее в этом руководстве.
Логические операторы можно объединять в составные выражения:
not((-0.2 > 1.4) and ((0.8 < 3.1) or (0.1 == 0.1)))
Выражение (0.8 < 3.1) or (0.1 == 0.1) истинно, поскольку оба математических выражения, из которых оно состоит, истинны. Оператор or вернёт True.
Полученное значение True становится компонентом следующего выражения: (-0.2 > 1.4) and (True). Оператор and выдаст False, потому что выражение -0.2 > 1.4 ложно. (False) and (True) = False.
Таблицы истинности
Математическая логика – очень полезная в программировании область знаний. В данном руководстве мы ознакомимся с основными её аспектами.
Ниже представлены таблицы истинности для оператора сравнения == и всех логических операторов. Ими можно пользоваться при написании логических выражений. В таблицах перечислены общие случаи использования оператора, потому их рекомендуется выучить наизусть.
Таблица истинности оператора ==
Таблица истинности оператора AND
Таблица истинности оператора OR
Таблица истинности оператора NOT
Таблицы истинности – общие математические таблицы, которые используются в логике. Их полезно выучить наизусть, чтобы затем применять при построении алгоритмов и написании программ.
Использование логических операторов для управления потоком
Для управления результатом и потоками данных программы можно использовать условные операторы (condition) с выражениями (clause).
Условные операторы оценивают значение как истинное или ложное.
Выражение – это блок кода, который идёт после условного оператора и определяет результат программы.
Ниже приведён блок кода, который показывает, как объединить условные операторы для управления потоком программы Python.
if grade >= 65: # условие
print("Passing grade") # выражение
else:
print("Failing grade")
Эта программа оценивает результат каждого студента и определяет, сдал он экзамен или нет. К примеру, если студент набрал 83, первое условие будет иметь значение True, и программа выведет на экран строку:
Если же студент набрал 59 баллов, первое условие будет ложно, потому программа выдаст.
О ператоры являются конструкциями, которые могут манипулировать значением операндов. Рассмотрим выражение 4 + 5 = 9. Здесь, 4 и 5 называются операндами и + называется оператором.
Типы операторов
Язык Python поддерживает следующие типы операторов:
- Арифметические операторы
- Сравнение (реляционные) операторы
- Операторы присваивания
- Логические операторы
- Битовые операторы
- Членские операторы
- Операторы идентификации
Давайте рассмотрим все операторы один за другим.
Арифметические операторы в Python
а значение 10, а переменная б содержит значение 21, то:
оператор | Описание | пример |
---|---|---|
+ Сложение | Добавление значений по обе стороны от оператора. | а + b = 31 |
– Вычитание | Вычитание правого операнда из левого операнда. | а – b = -11 |
* Умножение | Умножение значения по обе стороны от оператора | a * b = 210 |
/ Деление | Делит левый операнд на правый операнд | б / а = 2,1 |
% Модуль | Делит левый операнд на правый операнд и возвращает остаток | б % а = 1 |
** Экспонента | Выполняет экспоненциальный расчет на операторах | а ** b = 10 в степени 20 |
// деление с округлением | Отдел пола – Разделение операндов, где результат является фактором, в котором цифра после десятичной запятой удаляется. Но если один из операндов отрицателен, то результат округляется, т.е. округляется от нуля (по отношению к отрицательной бесконечности): | 9 // 2 = 4 и 9,0 // 2,0 = 4,0, -11 // 3 = -4, -11,0 // 3 = -4,0 |
Операторы сравнения в Python
Операторы сравнения значений по обе стороны от них и решить, соотношение между ними. Их также называют реляционные операторы.
Предположим, переменная а содержит значение 10, а переменная б имеет значение 20, то:
оператор | Описание | пример |
---|---|---|
== | Если значения двух операндов равны, то условие становится истинным. | (а == б) не верно. |
!= | Если значения двух операндов не равны, то условие становится истинным. | (а! = б) истинно. |
> | Если значение левого операнда больше значения правого операнда, то условие становится истинным. | (а > б) не верно. |
< | Если значение левого операнда меньше значения правого операнда, то условие становится истинным. | (а < б) истинно. |
> = | Если значение левого операнда больше или равно значению правого операнда, то условие становится истинным. | (а >= б) не верно. |
<= | Если значение левого операнда меньше или равно значению правого операнда, то условие становится истинным. | (а <= б) истинно. |
Операторы присваивания в Python
Предположим, переменная содержит а значение 10, а переменная б имеет значение 20, то:
оператор | Описание | пример |
---|---|---|
= | Назначает значения с правой стороной операндов левой стороне операнда | с = а + b присваивает значение a + b в c |
+ = Добавить и | Добавляет правый операнд к левому операнду и присвоить результат левого операнда | с + = а эквивалентно c = c + a |
– = вычесть и | Вычитает правый операнд из левого операнда и присваивает результат левого операнда | с – = а эквивалентно c = c – a |
* = умножить и | Умножает правый операнд на левый операнд и присваивает результат левого операнда | с * = а эквивалентно c = c * a |
/ = разделить и | Делит левый операнд на правый операнд и присваивает результат левого операнда | с / = а эквивалентно c = c / ac /= a эквивалентно с = с / а |
% = Модуль и | Принимает модуль с помощью двух операндов и присваивает результат левого операнда | c% = а эквивалентно c = c % a |
** = Экспонент и | Выполняет вычисление экспоненту от операторов и присваивает значение левого операнда | с ** = а эквивалентно c = c ** a |
// = Floor Division | Выполняет деление операторов с округлением и присваивает значение левого операнда | с // = а эквивалентно c = c // a |
Битовые операторы в Python
Побитовые операторы работают над битами и выполняют операции бит за битом. Допустим, если а = 60; и б = 13; В настоящее время в двоичном формате они будут выглядить следующим образом:
—————–
а&б = 0000 1100
а|б = 0011 1101
а^б = 0011 0001
Встроенная функция bin() в Python может быть использована для получения двоичного представления целого числа.
Следующие Битовые операторы поддерживаются языком Python:
Оператор | Описание | Пример |
---|---|---|
& бинарный И | копии оператора бита, в результате, если они существует в обоих операндах | (а & б) (0000 означает 1100) |
| бинарный ИЛИ | копирует бит, если он существует в любом из операндов. | (а | б) = 61 (означает 0011 1101) |
^ бинарный Исключающий или | копирует бит, если он установлен в одном операнде, но не в обоих. | (а ^ б) = 49 (означает 0011 0001) |
~ Бинарным комплемент | Это унарное и имеет эффект бит «листать». | (~ а) = -61 (в форме означает двойной комплемент 1100 0011 из-за подписанного двоичного числа. |
<< Двоичный сдвиг влево | Значение левого операнда перемещается влево на число битов, заданное правым операндом. | а << = 240 (1111 означает 0000) |
>> Двоичный сдвиг вправо | Значение левого операнда перемещается вправо на число битов, заданное правым операндом. | а >> = 15 (0000 означает 1111) |
Логические операторы в Python
Следующие логические операторы поддерживаются языком Python. Предположим, переменная справедлива и переменная б имеет значение False, то:
Членские Операторы в Python
Статус операторов тестирования на членство в последовательности, такие как строки, списки или кортежи. Есть два членских операторов, как объяснено ниже:
Операторы идентификации в Python
Операторы идентификации сравнивают ячейки памяти двух объектов. Есть два оператора идентификации как объяснено ниже:
Операторы приоритетов в Python
В следующей таблице перечислены все операторы от наивысшего приоритета к самому низкому.
Порядковый номер | Оператор & Описание | |
---|---|---|
1 | **
Возведение в степень (повышение мощности) |
|
2 | ~ + –
Дополнение, унарный плюс и минус (имена методов для двух последних являются + @ и – @) |
|
3 | * / % //
Умножение, деление по модулю и остаток от деления |
|
4 | + –
Сложение и вычитание |
|
5 | >> <<
Правый и левый побитовый сдвиг |
|
6 | &
Побитовое «И» | |
7 | ^ |
Побитовое исключающее “ИЛИ и регулярное ИЛИ” |
|
8 | <= <>> =
операторы сравнения |
|
9 | <> ==! =
операторы равенства |
|
10 | = %= /= //= -= += *= **=
операторы присваивания |
|
11 | is not
операторы идентификации |
|
12 | in not in
операторы членства |
|
13 | not или and
Логические операторы |