Какие операторы используются в Python: руководство

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

• арифметические,
• сравнения,
• присваивания,
• тождественности,
• принадлежности,
• логические,
• побитовые.

В этой статье-справочнике подробно рассмотрим каждый из них и приведем примеры.

Арифметические

Для сложения, вычитания, умножения и деления используются, соответственно, +, -, * и /.

    

      

    
    >>> 24 + 28
52
>>> 24 - 28
-4
>>> 24 * 28
672
>>> 24 / 28
0.8571428571428571
  

Для возведения в степень — **.

    

      

    
    >>> 5 ** 2
25
>>> 5 ** 3
125
>>> 5 ** 4
625
  

Для целочисленного деления без остатка — //.

    

      

    
    >>> 61 // 12
5
>>> 52 // 22
2
>>> 75 // 3
25
>>> 77 // 3
25
  

% выдает остаток, то есть выполняет деление по модулю:

    

      

    
    >>> 62 % 6
2
>>> 65 % 9
2
>>> 48 % 5
3
>>> 48 % 12
0
  

Сравнения

Таких операторов выражения в Python шесть: >, <, >=, <=, ==, !=. Обратите внимание, что «равно» в Питоне при сравнении записывается так: ==, потому что один знак «равно» означает присвоение значения (об этом в следующей главе). Для выражения «не равно» используется сочетание символов !=. При сравнении значений интерпретатор языка будет выдавать ответы True и False в зависимости от того, являются ли выражения истинными или ложными. Примеры:

    

      

    
    >>> 26 > 58
False
>>> 26 < 58
True
>>> 26 >= 26
True
>>> 58 <= 57
False
>>> 50 == 50
True
>>> 50 != 50
False
>>> 50 != 51
True
  

Присваивания

Для присвоения значений переменным используется один знак «равно»:

    

      

    
    >>> b = 5
>>> variants = 20
  

Также предусмотрены удобные конструкции для совмещения всех арифметических действий с одновременным присваиванием полученного значения: +=, -=, *=, /=, //=, %=. Например:

    

      

    
    >>> cars = 5
>>> cars += 7
>>> cars
12
  

Мы задали переменную сars и присвоили ей значение 5, затем добавили еще 7 с одновременным присвоением нового значения. Конечно, можно вместо cars += 7 написать и так:

    

      

    
    >>> cars = cars + 7
>>> cars
12
  

Ошибки нет, но первый вариант более компактный. Посмотрим, как работают другие действия одновременно с присваиванием:

    

      

    
    >>> train = 11
>>> train -= 2
>>> train
9
>>> moto = 3
>>> moto *= 7
>>> moto
21
>>> plain = 8
>>> plain /= 4
>>> plain
2.0
  

Обратите внимание, что в последнем случае мы получили не целое значение, int, а с запятой, float.

Тождественности

Таких операторов в Python 2: is и is not. Как и в английском, первый означает (это) есть, а второй — это не. Ответами интерпретатора, как и в случае со сравнениями, будут True или False.

    

      

    
    >>> 55 is 55
True
>>> 55 is 56
False
>>> 55 is not 55
False
>>> 55 is not 56
True
>>> 55 is '55'
False
>>> '55' is "55"
True
  

Разбираемся, что произошло в последних двух операциях. В первом случае (55 is '55') сравнивалось целое число и строка, поэтому интерпретатор выдал False, а во втором ('55' is "55") оба операнда представляли собой строки, поэтому было выдано True. Заметьте, что Питону не важно, использует ли программа одинарные или двойные кавычки: оба варианта синтаксически допустимы, поэтому результат тождества оказался истинным.

Принадлежности

Этих операторов тоже только два: in и not in. Они проверяют, есть или нет определенное значение в какой-либо последовательности. Например:

    

      

    
    >>> wordlist = ('assistant', 'streetcar', 'fraudster', 'dancer', 'heat', 'blank', 'compass', 'commerce', 'judgment', 'approach')
>>> 'house' in wordlist
False
>>> 'assistant' in wordlist
True
>>> 'assistant' and 'streetcar' in wordlist
True
  

В последнем случае мы задействовали логический оператор (and), к рассмотрению которых и переходим.

Логические

В Питоне есть три логических оператора: and (и), or (или), а также not (не). and работает следующим образом: True возвращается только в том случае, если все операнды истинны. При этом обрабатываться может сколько угодно значений. Используем пример из главы выше:

    

      

    
    >>> wordlist = ('assistant', 'streetcar', 'fraudster', 'dancer', 'heat', 'blank', 'compass', 'commerce', 'judgment', 'approach')
>>> 'assistant' and 'streetcar' in wordlist
True
>>> 'fraudster' and 'dancer' and 'heat' and 'blank' in wordlist
True
>>> 'fraudster' and 'dancer' and 'heat' and 'blank' and 'house' in wordlist
False
  

Как видим, значения 'house' в строке не оказалось, поэтому интерпретатор выдал False. Те же операции можно производить и над целочисленными значениями:

    

      

    
    >>> numbers = 54 > 55 and 22 > 21
>>> print(numbers)
False
  

Всё верно, потому что одно из выражений ложно, а and требует, чтобы истинными были все условия.

or действует по-другому: выражение признается истинным в том случае, если истинно хотя бы одно из его значений. Поэтому, если в предыдущем примере мы заменим операторы and на or, то получим следующий результат:

    

      

    
    >>> numbers = 54 > 55 or 22 > 21
>>> print(numbers)
True
  

22 больше 21 и при этом для операции or не важно, что первое выражение ложно.

А вот как работает not:

    

      

    
    >>> first = True
>>> second = False
>>> print(not first)
False
>>> print(not second)
True
  

Из примера видно, что not переворачивает логические значения, меняя True на False и наоборот.

Побитовые

Побитовые (или битовые) операторы используются в Python для изменения объектов на уровне битов. Их всего пять (сдвиговые принадлежат к одному типу, поскольку различаются только направлением сдвига):

• & (AND)
• | (OR)
• ^ (XOR)
• ~ (NOT)
• << и >> (сдвиговые)

Битовые операторы основаны на принципах Булевой логики, поэтому действуют следующим образом:

& (AND) возвращает 1, если 1 есть в обоих операндах, в остальных случаях 0:

    

      

    
    >>> 1 & 1
1
>>> 1 & 0
0
>>> 0 & 1
0
>>> 0 & 0
0
  

| (OR) возвращает 1, если 1 есть в одном из операндов, иначе вернет 0:

    

      

    
    >>> 1 | 1
1
>>> 1 | 0
1
>>> 0 | 1
1
>>> 0 | 0
0
  

^ (XOR) возвращает 1, если операнды различаются, и 0, если они одинаковы:

    

      

    
    >>> 1 ^ 1
0
>>> 1 ^ 0
1
>>> 0 ^ 1
1
>>> 0 ^ 0
0
  

~ (NOT) переворачивает биты, преобразуя положительные значения в отрицательные со сдвигом на единицу следующим образом:

    

      

    
    >>> ~5
-6
>>> ~-5
4
>>> ~7
-8
>>> ~-7
6
>>> ~9
-10
>>> ~-9
8
  

<< и >> сдвигают биты на определенное количество, которое указывается справа:

    

      

    
    >>> 1 << 1
2
>>> 1 >> 1
0
  

Для понимания сдвигов давайте разложим значения на биты, добавив, где нужно, разряд для удобства:

    

      

    
    0 = 00
1 = 01
2 = 10
  

Поэтому, сдвигая в единице разряд влево, мы получаем 2, а если вправо, то 0. А если на два разряда?

    

      

    
    >>> 1 << 2
4
>>> 1 >> 2
0
  

    

      

    
    1 = 001
2 = 010
4 = 100
  

Сдвинув единицу на два разряда влево, мы получили 4, потому что 4 в битовом представлении будет 100. Сдвиг вправо на любое число разрядов всё равно дает нам ноль, так как бит «обнуляется» в любом случае.

Больше информации о битовых операторах можно найти в нашей статье о них. 

В завершение проясним один важный момент и разграничим похожие по способу действия языковые инструменты.

Чем отличаются операторы от функций 

Вы наверняка заметили, что в этот обзор не попала ни одна функция. Путаница в определении этих инструментов возникает из-за того, что и те, и другие производят похожие действия, то есть так или иначе преобразуют объекты. Однако функции более глобальны, то есть могут выполнять операции со строками и целыми блоками кода, а операторы — только с отдельными значениями и переменными. Поэтому функция может состоять в Python из блока операторов, а вот операторы из функций — никогда.