Оператор – один из ключевых терминов языка Python. Они бывают разными: арифметическими, логическими и так далее. Они нужны для того, чтобы выполнять определенное действие с информацией, которая введена пользователем или возвращена другой функцией. Сегодня мы подробно рассмотрим, какие бывают операторы в языке Python и продемонстрируем примеры их использования.
Что такое оператор?
Под оператором в любом языке программирования подразумевают символ, который выполняет определенную операцию с частями информации – переменными или значениями. Такие данные называются операндами.
В Python есть 7 базовых типов операторов:
- Арифметические. Предназначены для выполнения стандартных операций типа сложения, вычитания, умножения или деления. Также есть ряд других арифметических операторов, которые будут рассмотрены далее.
- Операторы сравнения. Они берут операнд 1, операнд 2 (и так далее) и сравнивают их между собой. Например, этот оператор может сказать, является ли первая переменная больше второй, или же они равны и так далее.
- Операторы присваивания. Один из самых часто используемых типов операторов в Python. С его помощью осуществляется целый комплекс операций как самых простых (присваивание значения переменной), так и более сложных (возврат вывода функции в переменную).
- Логические операторы. С их помощью программист может соединить несколько условий, или сравнивать их между собой по логическому признаку.
- Операторы принадлежности. Выполняют простую проверку, относится ли конкретное значение определенному объекту (например, кортежу или списку).
- Операторы тождественности. С помощью этих операторов также выполняется сравнение операнд на предмет того, являются ли они одинаковыми. Но это немного отличается от операторов сравнения, поскольку проверка выполняется на предмет того, занимают ли они одно и то же место в памяти.
- Битовые. Эти операторы во многом работают так же, как другие, только выполняют операции по битам.
А теперь перейдем к рассмотрению каждого из этих типов операторов более подробно.
Арифметические операторы
Самые классические арифметические операторы – это сложение, вычитание, умножение и деление. Также рассмотрим ряд других, которые также выполняют арифметические действия.
Сложение. Соответствует математическому знаку +. Выполняет стандартную арифметическую операцию сложения. Синтаксис функции такой же, как и в математике: операнд 1 + операнд 2.
Например.
>>> 4+4
Вывод: 8.
Вычитание. Выполняет стандартную арифметическую операцию вычитания. Первый операнд – это первое число, а второй – это второе число соответственно. Сам оператор выглядит точно так же, как и математический знак минуса.
>>> 3-4
-1
Умножение. Умножает первое число на такое количество раз, которое указано во втором числе.
Также в качестве операнд, как и во всех остальных случаях, могут использоваться переменные. В этом случае осуществляется умножение переменной 1 на переменную 2.
>>> 5*5
25
Деление. Последовательность действий такая же самая, как и с умножением: сначала идет операнд 1, потом знак деления (/), а потом – операнд 2.
>>> 3/4
0.75
Возведение в степень. Берет число 1 и возводит в степень числа 2.
>>> 3**4
81
Деление без остатка. Все мы знаем, что после деления может оставаться остаток, если не получается разделить число на другое число непосредственно. С помощью этого оператора мы можем получить целое число, если разделить напрямую не получается. Например.
>>> 4//3
1
>>> 10//3
3
Деление по модулю. Выполняет похожую операцию на предыдущий пример, только возвращает как раз остаток. Этот оператор – знак процента, который находится между операндами. Например:
>>> 3%4
3
Операторы сравнения
С помощью операторов сравнения, как мы уже поняли, мы сравниваем между собой несколько операндов. Приведем операторы сравнения и примеры их использования.
Меньше. Соответствует математическому знаку «меньше». С его помощью программа сравнивает два значения. Если первое оказывается меньше второго, то выдает логическое значение True.
>>> 4<3
False
Больше. Этот оператор выполняет ту же самую операцию. Но возвращает значение True только в том случае, если первый операнд больше второго. То есть, противоположный предыдущему оператор.
>>> 4>3
True
Меньше или равно. Проверяет два условия:
- Левая часть меньше правой, или нет?
- Являются ли левая и правая части одинаковыми.
Если да, она возвращает True. То есть, должно соблюдаться или первое условие или второе.
>>> 7<=7
True
В этом примере мы видим, что число 7 равняется числу 7. Соответственно, программа выводит результат «истина». Ничего удивительного!
Больше или равно. Противоположный предыдущему оператор, возвращающий значение «истина» при соблюдении одного из этих условий:
- Два операнда являются одинаковыми.
- Первый операнд больше второго.
Синтаксис такой же самый, только вместо знака < используется знак >. Приведем пример для наглядности.
>>> 0>=0
True
Равно. В Python знак «равно» отличается от математического, поскольку последний выглядит так же, как оператор присваивания, о котором поговорим немного позже. В Python этот оператор выглядит, как два знака равно, которые идут друг за другом.
Проверка очевидна: этот оператор возвращает значение «истина» в случае, если оба операнда являются одинаковыми. При этом 1 и 0 могут выполнять роль логических операторов. То есть, их можно сравнивать между собой.
Давайте приведем несколько примеров, чтобы было более понятно, как этот оператор работает с различными операндами. Сначала пишется строка кода, а сразу вслед за ней – вывод.
>>> 3==3.0
True
>>> 1==True
True
>>> 7==True
False
>>> 0==False
True
>>> 0.5==True
False
Не равно. Этот арифметический символ также не выглядит, как зачеркнутый знак равно, как в математике. Этот оператор состоит из двух частей – восклицательного знака и математического знака «равно». То есть, он выглядит, как !=.
Полностью противоположный оператору «равно» символ. Если этот оператор обнаруживает, что операнды одинаковые, он возвращает значение «ложь», а не «истина», как в случае с оператором равенства.
>>> 1!=1.0
False
Раньше была еще одна версия этого оператора – <>. Но сейчас она не используется, поскольку была убрана в Python третьей версии.
Операторы присваивания
Теперь перейдем к рассмотрению операторов присваивания. Они предназначены для того, чтобы передавать переменной определенные значения как принадлежащие другим переменным, так и появившиеся вследствие их обработки. Операторы присваивания нужны еще и для того, чтобы назначать переменным объекты, с которыми можно дальше выполнять определенные действия.
Таким образом, спектр применений операторов этого типа довольно обширный.
Присваивание. Выглядит, как математический знак «равно». Это классический оператор, типичный пример применения которого – присваивание значения переменной. Давайте приведем такой пример.
>>> a = 7
>>> print(a)
7
Сложение и присваивание. Этот оператор не просто присваивает правую часть левой, но и увеличивает её на определённое значение.
Выглядит он, как знак плюса и равно вместе (+=).
Чтобы было более понятно, давайте рассмотрим этот код.
>>> a += 2
>>> print(a)
После выполнения соответствующих арифметических действий интерпретатор выдаст значение 9 при условии, что значение переменной a было 7.
То есть, этот оператор идентичен выражению a = a + 2.
Вычитание и присваивание. Противоположный предыдущему оператор. Если мы используем выражение a -= 2, это будет значить то же самое, что и выражение a = a – 2.
Деление и присваивание. Выполняет операцию деления между двумя операндами. После этого получившееся значение присваивается соответствующей переменной. Позволяет два действия: деление и присваивание запрограммировать всего одной строчкой кода. Можно также использовать переменные, объекты и другие значения, которые можно присвоить левой части, в правой.
Приведем пример.
>>> a /= 7
>>> print(a)
Умножение и присваивание. Выполняет аналогичную последовательность действий для двух операндов. Сначала выполняется арифметическая операция с двумя операндами, а потом получившееся значение присваивается левому. В данном случае такой арифметической операцией служит умножение.
>>> a *= 8
>>> print(a)
Деление по модулю и присваивание. Этот оператор выполняет сразу три действия:
- Делит первый операнд на второй.
- Определяет целое число.
- Присваивает это целое число той переменной, которая находится в правом операнде.
Синтаксис элементарный:
>>> a %= 3
>>> print(a)
Эта программа выполняет три описанных выше действия, после чего получившийся результат печатает в консоли или нижней строке онлайн-интерпретатора. Например, если переменная a = 10, то будет выведено число 3.
Возведение в степень и присваивание. Этот оператор выполняет два действия:
- Берет левый операнд и возводит его в степень, равная числу справа.
- Получившееся число сразу становится значением переменной слева.
Здесь, как и в других операторах, можно использовать переменные в качестве правого операнда. Например, если в левой части находится переменная с числом 4, а в правой – число 2, то на вывод будет отправлено число 16.
>>> a **= 2
>>> print(a)
16
Деление с остатком и присваивание. В принципе, вы уже поняли, как работает и записывается выражение с этим оператором. Он может получать остаток от деления первого числа на второе и возвращать его в ту переменную, которая стоит справа. Например, эта программа выводит остаток от деления на экран.
>>> a //= 3
>>> print(a)
Логические операторы
Логические операторы – одни из самых важных, поскольку позволяют управлять потоком выполнения программы. В Python предусмотрено три оператора этого типа – and, or, not. Их легко запомнить, потому что они идентичны аналогичным словам на английском языке. Соответственно, они обозначают «и», «или», «не» соответственно. Рассмотрим эти операторы подробнее.
И (and). Оператор, выполняющий следующий алгоритм:
- Сравнивает между собой два операнда.
- Если оба выражения являются истинными, возвращается значение True. Если же хотя бы одно из них ложное, то возвращается False.
Приведем пример использования выражения.
>>> a = 7 > 7 and 2 > -1
>>> print(a)
Аналогично примерам, приведенным выше, здесь программа печатает результат выполнения своих операций по предыдущей строчке. Поскольку после обработки обнаружится результат «Ложь», то консоль также выдаст значение False.
Или (or). В этом случае истиной будет считаться тот результат, когда хотя бы одно из условий в операндах является истинным. Если же оба из них ложные, то выдается значение False.
>>> a = 7 > 7 or 2 > -1
>>> print(a)
Не (not). Этот оператор осуществляет инверсию значений. То есть, если на входе находится «Истина», то на выходе будет «Ложь». И наоборот. Так, в примере, который будет чуточку ниже, цифра 0 используется в качестве аргумента функции not. Соответственно, в консоли было выведено обратное значение – True (Ведь 0 – это «ложь» в классификации этого языка).
>>> a = not(0)
>>> print(a)
True
Операторы принадлежности
С помощью этих операторов можно определить, входят ли значения в определенную последовательность. Она может быть любой – строкой, списком или кортежем. К этой категории относится всего два оператора – in и not in.
In. С английского переводится, как «В». Соответственно, с помощью этого оператора осуществляется проверка, является ли определенное значение частью последовательности списка, кортежа или строки.
Хотя принцип прост, покажем пример для наглядности.
>>> pets=[‘dog’,’cat’, ‘ferret’]
>>> ‘fox’ in pets
Попробуйте определить, какое значение будет возвращено в этой ситуации. Правильный ответ – «False». Почему? Да, fox – это действительно лиса, и она является животным. Но она не входит в список домашних питомцев, куда относятся только собаки, коты и хорьки. Поэтому возвращается значение «ложь».
Если же написать такую строку, то будет возвращено «истина».
>>> ‘cat’ in pets
Почему? Потому что кот есть в списке питомцев.
Теперь приведем пример проверки вхождения фразы в строку.
>>> ‘me’ in ‘disappointment’
Какой вывод будет у этой фразы? Правильно, «истина», потому что слог «me» в этом слове есть.
Not in. Этот оператор выполняет противоположное действие. Оно возвращает значение «истина» исключительно в случае, если не входит в состав последовательности та конструкция, которая находится в первом операнде.
Если бы мы в примерах выше использовали этот оператор, то были бы выданы такие результаты:
- Если бы мы проверяли вхождение лисы в перечень домашних питомцев, то было бы выдано значение True, потому что она не входит.
- Если бы мы проверяли вхождение кота в этот список, было бы возвращено значение false, поскольку он также не входит.
- Если бы мы проверяли факт вхождения слога «me» в слово «disappointment», то был бы выдан ответ false.
То есть, эти операторы работают полностью противоположным друг другу образом.
Операторы тождественности
Разберем более подробно операторы тождественности, поскольку они – наименее очевидны для новичка.
Это (is). Этот оператор проверяет тождественность. Если это так, то возвращается значение True. Если же нет, False. Давайте для демонстрации этого оператора приведем несколько примеров.
>>> 2 is 20
False
Здесь сравниваются числа 2 и 20. Они не являются одинаковыми, поэтому вернулось значение False.
>>> ‘2’ is «2»
True
А здесь сравниваются две двойки. При этом кавычки не учитываются, поскольку они не меняют объекты, это лишь системный символ, который позволяет людям и интерпретатору ориентироваться в коде. А поскольку кавычки этого не делают, то и возвращается значение True. Ведь они – идентичны.
Это не (is not). Как и любой обратный оператор, этот показывает полностью противоположное предыдущему значение.
Есть один нюанс. Оба оператора проверяют, являются ли объекты одинаковыми. То есть, если ввести первый операнд 1 и второй операнд ‘1’, то результат будет True в данном случае. Если говорить про предыдущую – False.
>>> 1 is not ‘1’
True
Почему так? Дело в том, что единица не тождественна ‘1’, поскольку эти значения представляют разные типы данных. В прошлом примере кавычки не учитывались, поскольку и в первом операнде, и во втором стоят кавычки. Здесь же мы видим, что первый операнд не имеет кавычки. И в этом случае они не будут считаться идентичными, даже если внешне выглядят одинаково.
Битовые операторы
На практике, используются довольно редко. Но применяются. И знать их тоже надо.
Для начала надо раскрыть, что такое побитовые операции в целом. Они выполняются над разрядами числа по специальным формулам, каждая из которых зависит от операторов.
Поэтому важно рассмотреть их более подробно.
Бинарное И (&). Полный аналог оператора and, только который работает с битами. Точно так же, как и любой другой битовый оператор, он выполняет операции с каждой парой битов по отдельности, осуществляя с ними действия в соответствии с этой таблицей.
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1
То есть, если первый бит в первой последовательности будет 0 и во второй последовательности битов первый бит будет 0, то после выполнения этой операции получится значение 0.
Точно так же и с каждым последующим битом. Предположим, у нас есть две последовательности:
00100101
00111010
После того, как каждая из этих последовательностей битов будет обработана оператором, получится следующая последовательность:
00100000
Естественно, передавать значения можно и в десятичной форме. В таком случае они будут преобразованы в двоичную и выполнены соответствующие вычисления. А потом они снова будут преобразованы в десятичную систему.
Например, если выполнить побитовое «И» с числами 2 и 3, то получится две последовательности битов в двоичной форме:
10
11
Если сопоставить с таблицей выше, то после побитового И будет выдан следующий результат:
10.
То есть, на вывод уйдет цифра 2, поскольку после выполнения операции побитового И 1 и 1 дали 1, а 0 и 1 дали 0. В результате, получилось значение 10, что соответствует 2.
По аналогичному принципу работают и другие бинарные операторы.
Бинарное ИЛИ (|). Соответствует побитовой операции or.
Общая таблица сопоставления битов с использованием этого оператора следующая.
0 | 0 = 0
0 | 1 = 1
1 | 0 = 1
1 | 1 = 1
То есть, если ввести такую строку кода, получится на выходе 3.
>>> 2|3
Почему? Потому что эти две десятичные цифры переводятся в следующие две последовательности.
10
11
1 на 1 дает 1, и 0 на 1 дает 1. Соответственно, получилось число 11 в двоичной форме, что соответствует 3 в десятичной. Поэтому такой вывод.
Бинарное ИЛИ НЕТ (^). С помощью этой функции выполняется исключающее между двумя операндами, переведенными в двоичную форму. Сопоставление осуществляется по таким правилам.
0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0
Таким образом, если выполнить соответствующую операцию с теми же самыми числами, то получится в результате 1. Ведь цифра 2 у нас 10, а 11 – это 3. Таким образом, если сопоставить разряды по правилам, получится в итоге 01.
>>> 2^3
10
11
––
01
Инвертирующий оператор. С его помощью пользователь может инвертировать 0 в 1 и наоборот.
Например, если применить его к 2, то получится в результате -3. Почему? Потому что в двоичном формате цифра 2 – это 00000010. Если же ее инвертировать, то получится 11111101, что соответствует двоичной -3. Таким образом, получится в итоге обычная 2.
Естественно, работает все и абсолютно наоборот. Ведь если 11111101 заменить на противоположные значения, то получится на выходе та же цифра 3.
Бинарный сдвиг влево и вправо. Осуществляет сдвиг левого оператора на ту позицию, которая есть справа. Например, если попробовать сдвинуть вправо бинарную 3 (то есть, 11) на два положения влево, то в результате получится число 00, поскольку единицы ушли за пределы разряда.
И такой принцип дальше. То есть, первый операнд – это то число, сдвиг которого надо осуществить. Второй же операнд – количество бит, на которое необходимо его выполнить.
Пример.
>>> 3>>2
>>> 3>>1
