Оператор – языковая конструкция, которая выполняет определенное действие над переданным значением (например, умножение). Набор операторов, доступных в Python, изначальное определен разработчиками, расширить его нет возможности (не стоит путать с набором поддерживаемых функций).
Математические операторы
Используются для различных операций над числами:
+ (сложение)
>>> 13 + 33 # Целые числа 46 >>> 17.4 + 4.2 # Вещественные числа 21.6 >>> 12 + 11.4 # Целые и вещественные числа 23.4
— (вычитание).
>>> 20 - 6 # Целые числа 14 >>> 14.4 - 3.2 # Вещественные числа 11.2 >>> 14 - 2.2 # Целые и вещественные числа 11.8
* (умножение)
>>> 12 * 4 # Целые числа 48 >>> 11.4 * 3.1 # Вещественные числа 35.34 >>> 10 * 4.2 # Целые и вещественные числа 42.0
/ (деление). В качестве результата всегда выступает вещественное число, даже если осуществляется деление простых чисел нацело.
>>> 20 / 5 # Деление целых чисел без остатка 4.0 >>> 10 / 3 # Деление целых чисел с остатком 3.3333333333333335 >>> 20.0 / 4.0 # Деление вещественных чисел 5.0 >>> 10.0 / 3.0 # Деление вещественных чисел 3.3333333333333335 >>> 30 / 6.0 # Деление целого числа на вещественное 5.0 >>> 60.0 / 6 # Деление вещественного числа на целое 10.0
% (остаток от деления).
>>> 40 % 8 # Деление целых чисел без остатка 0 >>> 20 % 7 # Деление целых чисел с остатком 6 >>> 70.0 % 7.0 # Операция над вещественными числами 0.0 >>> 30.0 % 4.0 # Операция над вещественными числами 2.0 >>> 20 % 4.0 # Операция над целыми и вещественными числами 0.0 >>> 40 % 9.0 # Операция над целыми и вещественными числами 4.0 >>> 80.0 % 8 # Операция над целыми и вещественными числами 0.0 >>> 15.0 % 4 # Операция над целыми и вещественными числами 3.0
// (деление с округлением вниз). Полученный остаток всегда отбрасывается.
>>> 15 // 3 # Деление целых чисел без остатка 5 >>> 20 // 7 # Деление целых чисел с остатком 2 >>> 60.0 // 6.0 # Деление вещественных чисел 10.0 >>> 10.0 // 4.0 # Деление вещественных чисел 2.0 >>> 10 // 2.0 # Деление целого числа на вещественное 5.0 >>> 10 // 4.0 # Деление целого числа на вещественное 2.0 >>> 20.0 // 4 # Деление вещественного числа на целое 5.0 >>> 10.0 // 7 # Деление вещественного числа на целое 1.0
** (возведение в степень). Первым операндом указывается основание, вторым – показатель степени.
>>> 5 ** 3, 5.0 ** 3 (125, 125.0)
Унарный минус (-). Производится изменение знака числа на противоположный.
>>> -11, -11.0, -(-11), -(-11.0) (-11, -11.0, 11, 11.0)
Унарный плюс (+). С числом никаких действий не производится.
>>> +12, +12.0) (12, 12.0)
Приведенные примеры показывают, что при проведении математических операций с числами разных типов результат получает самый сложный тип. Самый простой тип – целые числа, далее идут вещественные и комплексные числа.
При работе с вещественными числами стоит учитывать некоторые особенности реализации точности вычислений. Нередко полученный результат отличается от ожидаемого:
>>> 0.3 - 0.1 - 0.1 - 0.1 -2.7755575615628914e-17
Очевидно, что в данном примере программа в качестве ответа должна была вывести 0. Если при расчетах важна высокая точность, необходимо использовать возможности модуля decimal.
>>> from decimal import Decimal
>>> Decimal("0.3") - Decimal("0.1") - Decimal("0.1") - Decimal("0.1")
Decimal('0.0')
Двоичные операторы
В данную категорию относят операторы, которые позволяют манипулировать отдельными битами.
& — двоичное И
>>> k = 101 # 01100101 >>> m = 77 # 01001101 >>> x = k & m # 01000101
~ — двоичная инверсия. В каждом бите значение меняется на противоположное.
>>> x = 101 # 01100101 >>> x = ~x # 10011010
| — двоичное или
>>> k = 101 # 01100101 >>> m = 77 # 01001101 >>> z = x | y # 01101101
^ — двоичное исключающее ИЛИ
>>> x = 119 # 01110111 >>> y = 245 # 11110101 >>> z = x ^ y # 10000010
<< – сдвиг влево двоичного представления числа. Первым операндом указывается число, вторым – количество разрядов. Разряды справа при этом заполняются нулями.
>>> x = 119 # 01110111 >>> y = x << 1 # 11101110 >>> z = y << 1 # 11011100 >>> k = z << 2 # 01110000
>> – сдвиг вправо. Двоичное представление числа сдвигается вправо. Если число отрицательное, то разряды слева заполняются единицами, если положительное – то нулями.
>>> x = 119 # 01110111 >>> y = x >> 1 # 00111011 >>> z = y >> 1 # 00011101 >>> k = z >> 2 # 00000111 >>> x = -127 # 10000001 >>> y = x >> 1 # 11000000 >>> z = y >> 2 # 11110000
Операторы для работы с последовательностями
Различные операции с последовательностями выполняются при помощи следующих операций:
+ – конкатенация (соединение).
>>> print("Текст1" + "Текст2") # Конкатенация строк
Текст1Текст2
>>> [1, 3, 5] + [7, 9, 11] # Списки
[1, 3, 5, 7, 9, 11]
>>> (1, 4, 5) + (8, 10, 12) # Кортежи
(1, 4, 5, 8, 10, 12)
* — повторение. Последовательность, указанная в первом операнде повторяется, количество повторов указывается во втором операнде.
>>> "f" * 10 # Строки 'ffffffffff' >>> [1, 3] * 4 # Списки [1, 3, 1, 3, 1, 3, 1, 3] >>> (1, 4) * 2 # Кортежи (1, 4, 1, 4)
in – проверка на вхождение. В первом операнде указывается символ (набор символов), во втором – последовательность для проверки. При обнаружении совпадения возвращается True, иначе – False.
>>> "Текст" in "Текст для поиска" # Строки
True
>>> "Набор" in "Строка для поиска" # Строки
False
>>> 5 in [1, 4, 6], 2 in [1, 2, 3] # Списки
(False, True)
>>> 5 in (1, 4, 7), 2 in (1, 2, 8) # Кортежи
(False, True)
not in – проверка на отсутствие вхождений. Аналогично предыдущему оператору, но True возвращается, если указанный набор не входит в указанную последовательность.
>>> "код" not in "Пример кода на Python" # Строки False >>> "код" not in "Анализируемый текст" # Строки True >>> 3 not in [1, 3, 6], 5 not in [1, 7, 44] # Списки (False, True) >>> 2 not in (1, 2, 3), 6 not in (1, 2, 3) # Кортежи (False, True)
Операторы присваивания
Данные операторы позволяют сохранить в переменной новое значение.
= — простое присваивание.
>>> k = 7
>>> k
7
+= присваивание со сложением. Значение исходной переменной увеличивается на значение, указанное во втором операнде.
>>> x = 6; x += 11 # Эквивалентно x = x + 11
>>> x
17
Если применить данный оператор к последовательности, будет произведена конкатенация.
>>> k = "Python"; s += " 3.11"
>>> print(k)
Python 3.11
-= присваивание с вычитанием. Инициируется уменьшение переменной на указанное значение.
>>> x = 15; x -= 8 # Эквивалентно x = x - 8
>>> x
7
*= — присваивание с умножением. Исходное значение переменной умножается на значение второго операнда.
>>> k = 12; k *= 4 # Эквивалентно k = k * 4
>>> k
48
Если данную операцию применить к последовательности, будет произведено повторение.
>>> k = "#"; s *= 5 >>> k '#####'
/= — присваивание с делением. Значение в переменной делится на указанную величину.
>>> m = 10; m /= 3 # Эквивалентно m = m / 3 >>> m 3.3333333333333335 >>> m = 10.0; m /= 3.0 # Эквивалентно y = y / 3.0 >>> m 3.3333333333333335
//= присваивание с делением (округление в меньшую сторону). Переменная делится на значение второго операнда, полученный результат округляется вниз.
>>> g = 10; g //= 3 # Эквивалентно g = g // 3
>>> g
3
>>> g = 10.0; g //= 3.0 # Эквивалентно g = g // 3.0
>>> g
3.0
%= — присваивание по модулю. Исходное значение делится по модулю на указанное значение.
>>> x = 10; x %= 2 # Эквивалентно x = x % 2
>>> x
0
>>> t = 10; t %= 3 # Эквивалентно t = t % 3
>>> t
1
**= — присваивание с возведением в степень. Второй операнд указывает на значение степени.
>>> y = 11; y **= 2 # Эквивалентно y = y ** 2
>>> y
121
:= — присваивание в рамках сложного выражения (доступно, начиная с версии 3.8).
Пустой оператор
В Python также предусмотрен пустой оператор pass, который не совершает никаких действий.
Обычно пустой оператора используют, чтобы временно определить новую функцию или пустой класс. Можно сразу определить структуру программы, чтобы далее перейти к реализации.
def empty_function(): pass . . . class empty_class: pass
Приоритет операторов
В процессе работы с кодом важно учитывать приоритет операторов – очередность, с которой они будут выполняться. К примеру, оператор вычитания имеет более низкий приоритет, чем оператор умножения.
В качестве примера можно рассмотреть следующее выражение.
d = 6 + 10 * 4 / 2
Вычисления будут идти по следующей схеме:
1. Число 10 умножается на 4, поскольку оператор сложения имеет более низкий приоритет.
2. Полученный результат будет разделен на 2. Операторы умножения и деления имеют одинаковый приоритет, поэтому выполняются слева направо.
3. К новому результату будет прибавлено число 5.
4. Итоговое значение присваивается переменной, оператор присваивания имеет самый низкий приоритет.
Если необходимо изменить порядок обработки, можно использовать в нужных местах скобки, например, чтобы повысить приоритет сложения.
x = (6 + 10) * 4 / 2
Все основные операторы в порядке снижения приоритета:
1. +x, -x, ~x, **, унарный плюс, унарный минус, двоичная инверсия, степень. При использовании унарных операторов слева от возведения в степень, то унарные оператор имеет меньший приоритет, если справа – то больший. Пример:
-10 ** -2 эквивалентно выражению -(10 ** (-2))
2. /, //, *, % — деление, деление с округлением вниз, умножение, остаток от деления.
3. -,+ вычитание и сложение.
4. >>, << двоичные сдвиги.
5. & — двоичное И.
6. ^ — двоичное исключающее ИЛИ.
7. | — двоичное ИЛИ
8. =, -=, +=,*=, /=, //=, **=, %= — операторы присваивания.