# Операторы и выражения
Кратко рассмотрим операторы и их применение:
Обратите внимание, вычислить значения выражений, данных в примерах, можно также используя интерпретатор интерактивно. Например, для проверки выражения `2 + 3` воспользуйтесь интерактивной командной строкой интерпретатора Python:
```python
>>> 2 + 3
5
>>> 3 * 5
15
```
**Операторы и их применение**
| Оператор | Название | Объяснение | Примеры |
| -------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `+` | Сложение | Суммирует два объекта | `3 + 5` даст `8`; `'a' + 'b'` даст `'ab'` |
| `-` | Вычитание | Даёт разность двух чисел; если первый операнд отсутствует, он считается равным нулю | `-5.2` даст отрицательное число, а `50 - 24` даст `26`. |
| `*` | Умножение | Даёт произведение двух чисел или возвращает строку, повторённую заданное число раз. | `2 * 3` даст `6`. `'la' * 3` даст `'lalala'`. |
| `**` | Возведение в степень | Возвращает число `х`, возведённое в степень `y` | `3 ** 4` даст `81` (т.е. `3 * 3 * 3 * 3`) |
| `/` | Деление | Возвращает частное от деления `x` на `y` | `4 / 3` даст `1.3333333333333333`. |
| `//` | Целочисленное деление | Возвращает неполное частное от деления | `4 // 3` даст `1`. `-4 // 3` даст `-2`. |
| `%` | Деление по модулю | Возвращает остаток от деления | `8 % 3` даст `2`. `-25.5 % 2.25` даст `1.5`. |
| `<<` | Сдвиг влево | Сдвигает биты числа влево на заданное количество позиций. (Любое число в памяти компьютера представлено в виде битов - или двоичных чисел, т.е. 0 и 1) | `2 << 2` даст `8`. В двоичном виде `2` представляет собой `10`. Сдвиг влево на 2 бита даёт `1000`, что в десятичном виде означает `8`. |
| `>>` | Сдвиг вправо | Сдвигает биты числа вправо на заданное число позиций. | `11 >> 1` даст `5`. В двоичном виде `11` представляется как `1011`, что будучи смещённым на 1 бит вправо, даёт `101`, а это, в свою очередь, не что иное как десятичное `5` |
| `&` | Побитовое И | Побитовая операция И над числами | `5 & 3` даёт `1`. |
| `\|` | Побитовое ИЛИ | Побитовая операция ИЛИ над числами | `5 \| 3` даёт `7` |
| `^` | Побитовое ИСКЛЮЧИТЕЛЬНО ИЛИ | Побитовая операция ИСКЛЮЧИТЕЛЬНО ИЛИ | `5 ^ 3` даёт `6` |
| `~` | Побитовое НЕ | Побитовая операция НЕ для числа `x` соответствует `-(x+1)` | `~5` даёт `-6`. |
| `<` | Меньше | Определяет, верно ли, что `x` меньше `y`. Все операторы сравнения возвращают `True` или `False`. Обратите внимание на заглавные буквы в этих словах. | 5 < 3 даст False,
а 3 < 5 даст True.
Можно составлять произвольные цепочки сравнений: 3 < 5 < 7 даёт True.
|
| `>` | Больше | Определяет, верно ли, что `x` больше `y` | `5 > 3` даёт `True`. Если оба операнда - числа, то перед сравнением они оба преобразуются к одинаковому типу. В противном случае всегда возвращается `False`. |
| `<=` | Меньше или равно | Определяет, верно ли, что `x` меньше или равно `y` | `x = 3; y = 6; x <= y` даёт `True`. |
| `>=` | Больше или равно | Определяет, верно ли, что `x` больше или равно `y` | `x = 4; y = 3; x >= 3` даёт `True`. |
| `==` | Равно | Проверяет, одинаковы ли объекты | `x = 2; y = 2; x == y` даёт `True`. `x = 'str'; y = 'stR'; x == y` даёт `False`. `x = 'str'; y = 'str'; x == y` даёт `True`. |
| `!=` | Не равно | Проверяет, верно ли, что объекты не равны | `x = 2; y = 3; x != y` даёт `True`. |
| `not` | Логическое НЕ | Если `x` равно `True`, оператор вернёт `False`. Если же `x` равно `False`, получим `True`. | `x = True; not x` даёт `False`. |
| `and` | Логическое И | `x and y` даёт `False`, если `x` равно `False` , в противном случае возвращает значение `y` | `x = False; y = True; x and y` возвращает `False`, поскольку x равно `False`. В этом случае Python не станет проверять значение `y`, так как уже знает, что левая часть выражения ‘and’ равняется `False`, что подразумевает, что и всё выражение в целом будет равно `False`, независимо от значений всех остальных операндов. Это называется укороченной оценкой булевых (логических) выражений. |
| `or` | Логическое ИЛИ | Если `x` равно `True`, в результате получим `True`, в противном случае получим значение `y` | `x = True; y = False; x or y` даёт `True`. Здесь также может производиться укороченная оценка выражений. |
#### Краткая запись мат. операций и присваивания
Зачастую результат проведения некой математической операции необходимо присвоить переменной, над которой эта операция производилась. Для этого существуют краткие формы записи выражений:
Вы можете записать:
```python
a = 2; a = a * 3
```
в виде:
```python
a = 2; a *= 3
```
Обратите внимание, что выражения вида “`переменная = переменная операция выражение`” принимает вид “`переменная операция = выражение`”.
### Порядок вычисления
Если имеется выражение вида `2 + 3 * 4`, что производится раньше: сложение или умножение? Школьный курс математики говорит нам, что умножение должно производиться в первую очередь. Это означает, что оператор умножения имеет более высокий приоритет, чем оператор сложения.
Следующая таблица показывает приоритет операторов в Python, начиная с самого низкого (самое слабое связывание) и до самого высокого (самое сильное связывание). Это означает, что в любом выражении Python сперва вычисляет операторы и выражения, расположенные внизу таблицы, а затем операторы выше по таблице.
Эта таблица взята из [Справочника по языку Python (англ.)](http://docs.python.org/py3k/reference/expressions.html#summary) и приводится здесь для полноты описания. На практике лучше использовать скобки для группировки операторов и операндов, чтобы в явном виде указать порядок вычисления выражений. Заодно это облегчит чтение программы.
**Приоритет операторов**
| Оператор | Описание |
| -------------------------------- | -------------------------------------------------------------- |
| `lambda` | лямбда-выражение |
| `or` | Логическое “ИЛИ” |
| `and` | Логическое “И” |
| `not x` | Логическое “НЕ” |
| `in`, `not in` | Проверка принадлежности |
| `is`, `is not` | Проверка тождественности |
| `<`, `<=`, `>`, `>=`, `!=`, `==` | Сравнения |
| `\|` | Побитовое “ИЛИ” |
| `^` | Побитовое “ИСКЛЮЧИТЕЛЬНО ИЛИ” |
| `&` | Побитовое “И” |
| `<<`, `>>` | Сдвиги |
| `+`, `-` | Сложение и вычитание |
| `*`, `/`, `//`, `%` | Умножение, деление, целочисленное деление и остаток от деления |
| `+x`, `-x` | Положительное, отрицательное |
| `~x` | Побитовое НЕ |
| `**` | Возведение в степень |
| `x.attribute` | Ссылка на атрибут |
| `x[индекс]` | Обращение по индексу |
| `x[индекс1:индекс2]` | Вырезка |
| `f(аргументы ...)` | Вызов функции |
| `(выражения, ...)` | Связка или кортеж |
| `[выражения, ...]` | Список |
| `{ключ:данные, ...}` | Словарь |
Операторы, о которых мы не упомянули, будут объяснены в дальнейших главах.
В этой таблице операторы с *равным приоритетом* расположены в одной строке. Например, `+` и `-` имеют равный приоритет.
### Изменение порядка вычисления
Для облегчения чтения выражений можно использовать скобки. Например, `2 + (3 * 4)` определённо легче понять, чем `2 + 3 * 4`, которое требует знания приоритета операторов. Как и всё остальное, скобки нужно использовать разумно (не перестарайтесь) и избегать излишних, как в `(2 + (3 * 4))`.
Есть ещё одно преимущество в использовании скобок – они дают возможность изменить порядок вычисления выражений. Например, если сложение необходимо произвести прежде умножения, можно записать нечто вроде `(2 + 3) * 4`.