Что делает в python

Операторы Python: краткий справочник

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

Список операторов Python

Операторы Python можно разделить на несколько категорий:

• Операторы присваивания
• Арифметические операторы
• Логические операторы
• Операторы сравнения
• Битовые операторы

Остановимся подробнее на каждом типе.

Операторы присваивания Python

Операторы присваивания включают базовый символ присваивания – символ “равно” (=).

Однако, чтобы упростить код и уменьшить избыточность, Python также поддерживает арифметические операторы присваивания.

К ним относится оператор +=, который присваивает сумму двух операндов левому операнду, оператор //=, который присваивает результат деления, и другие.

Вот список всех арифметических операторов присваивания в Python.

Оператор	Описание
+=	a+=b равносильно a=a+b (оператор складывает значения двух операндов и присваивает его левому операнду)
*=	a*=b равносильно a=a*b
/=	a/=b равносильно a=a/b
%=	a%=b равносильно a=a%b
**=	a**=b равносильно a=a**b (возведение в степень)
//=	a//=b равносильно a=a//b

Как использовать операторы присваивания

# take two variable, assign values with assignment operators a=3 b=4 print("a: "+str(a)) print("b: "+str(b)) # it is equivalent to a=a+b a+=b print("a: "+str(a)) print("b: "+str(b)) # it is equivalent to a=a*b a*=b print("a: "+str(a)) print("b: "+str(b)) # it is equivalent to a=a/b a/=b print("a: "+str(a)) print("b: "+str(b)) # it is equivalent to a=a%b a%=b print("a: "+str(a)) print("b: "+str(b)) # it is equivalent to a=a**b ( exponent operator) a**=b print("a: "+str(a)) print("b: "+str(b)) # it is equivalent to a=a//b ( floor division) a//=b print("a: "+str(a)) print("b: "+str(b))

Арифметические операторы Python

Оператор	Описание	Пример
+	Складывает два числа	sum = a + b
–	Вычитает одно число из другого	difference = a – b
*	используется для умножения двух чисел. Если вы попробуете умножить строку и целое число, эта операция повторит данную строку указанное количество раз.	mul = a*b>>> “Hi”*5
‘HiHiHiHiHi’
/	используется для деления двух чисел	div = b/a
%	Модуль, остаток от деления	mod = a%b
**	Возведение в степень

#create two variables a=100 b=200 # addition (+) operator print(a+b) # subtraction (-) operator print(a-b) # multiplication (*) operator print(a*b) # division (/) operator print(b/a) # modulus (%) operator print(a%b) # prints the remainder of a/b # exponent (**) operator print(a**b) #prints a^b

Операторы сравнения Python

оператор	описание	Пример
==	Возвращает значение True, если два операнда равны, в противном случае выдает False.	flag = a == b
!=	возвращает True, если два операнда не равны, в противном случае выдает False.	flag = a != b
>	Возвращает значение True, если левый операнд больше, чем правый, в противном случае выдает False.	flag = a > b
	Возвращает значение True, если левый операнд меньше, чем правый, в противном случае выдает False.	flag = a < b
>=	Возвращает значение True, если левый операнд больше или равен правому, в противном случае выдает False.	flag = a > b
	Возвращает значение True, если левый операнд меньше или равен правому, в противном случае выдает False.	flag = a < b

# create two variables a=100 b=200 # (==) operator, checks if two operands are equal or not print(a==b) # (!=) operator, checks if two operands are not equal print(a!=b) # (>) operator, checks left operand is greater than right operand or not print(a>b) # () operator, checks left operand is less than right operand or not print(a #(>=) operator, checks left operand is greater than or equal to right operand or not print(a>=b) # ( <=) operator, checks left operand is less than or equal to right operand or notprint(a<=b)

Битовые операторы Python

Оператор	Описание	Пример
&	Битовый оператор И (AND)	x = 10 & 7 = 2
Binary OR Operator
^	Битовое исключающее ИЛИ (XOR)	x = 10 ^ 7 = 13
~	Битовый оператор НЕТ	x = ~10 = -11
	Битовый оператор сдвига влево	x = 10
>>	Битовый оператор сдвига вправо	x = 10>>1 = 5

#create two variables a=10 # binary 1010 b=7 # binary 0111 # Binary AND (&) operator, done binary AND operation print(a&b) # Binary OR (|) operator, done binary OR operation print(a|b) # Binary XOR (^) operator, done binary XOR operation print(a^b) # Binary ONEs Compliment (~) operator, done binary One's Compliment operation print(~a) # Binary Left Shift () operator, done binary Left Shift operation print(a <<1)# Binary Right Shift (>>) operator, done binary Right Shift operation print(a>>1)

Логические операторы Python

Оператор	Описание	Пример
and	Логический оператор И (AND)	flag = exp1 and exp2
or	Логический оператор ИЛИ (OR)	flag = exp1 or exp2
not	Логический оператор НЕ (NOT)	flag = not(True) = False

#take user input as int a=int(input()) # logical AND operation if a%4==0 and a%3==0: print("divided by both 4 and 3") # logical OR operation if a%4==0 or a%3==0: print("either divided by 4 or 3") # logical NOT operation if not(a%4==0 or a%3==0): print("neither divided by 4 nor 3")

Приоритет операторов Python

Некоторые операторы Python имеют более высокий приоритет, чем другие . Особенно важно это понимать, если вы работаете с выражениями, которые содержат несколько операторов. Например, рассмотрим следующее выражение:

Как думаете, в какой последовательности будут выполнены эти операции? Мы можем сложить 2 и 3, а затем умножить результат на 4. Также мы можем сначала умножить 3 и 4, а затем добавить к ним 2. Как видите, разная последовательность выполнения операций дает нам разный результат – это показывает, что приоритет операторов важен.

Ниже вы найдете список операторов с указанием уровня приоритета в порядке убывания (то есть чем ниже оператор в списке, тем ниже его приоритет).

1. Скобки: ()
2. Возведение в степень: **
3. Битовый оператор НЕТ , унарный плюс и минус: ~, +, –
4. Умножение, деление, модуль: *, /, %
5. Сложение и вычитание: +, –
6. Правый и левый сдвиг: >>,
7. Битовый оператор И: &
8. Битовые OR и XOR: |, ^
9. Операторы сравнения: ==, !=, >, =,
10. Оператор присваивания: =

№8 Операторы в Python / Уроки по Python для начинающих

Операторами пользуются для выполнения операций с переменными и значениями.
Python делит операторы на следующие группы:

• Арифметические операторы
• Операторы присваивания
• Операторы сравнения
• Логические операторы
• Операторы тождественности
• Операторы принадлежности
• Побитовые операторы

Арифметические операторы в Python

Арифметические операторы используются с числовыми значениями для выполнения общих математических операций:

Оператор	Значение	Пример
+	добавление	4 + 5
—	вычитание	8 — 3
*	умножение	5 * 5
/	деление	4 / 2
%	остаток от деления	7 % 2
**	возведение в степень	2 ** 3
//	целочисленное деление	15 // 4

Операторы присваивания в Python

Операторы присваивания используются для присваивания значений переменным:

Оператор	Пример	Так же как
=	x = 5	x = 5
+=	x += 3	x = x + 3
-=	x -= 3	x = x — 3
*=	x *= 3	x = x * 3
/=	x /= 3	x = x / 3
%=	x %= 3	x = x % 3
//=	x //= 3	x = x // 3
**=	x **= 3	x = x ** 3
&=	x &= 3	x = x & 3
|=	x |= 3	x = x | 3
^=	x ^= 3	x = x ^ 3
>>=	x >>= 3	x = x >> 3
	x	x = x

Операторы сравнения в Python

Операторы сравнения используются для сравнения двух значений:

Оператор	Значение	Пример
==	равно	x == y
!=	не равно	x != y
>	больше чем	x > y
	меньше чем	x < y
>=	больше чем или равно	x >= y
	меньше чем или равно	x

Логические операторы в Python

Логические операторы используются для объединения условных операторов:

Оператор	Значение	Пример
and	Возвращает значение True если оба утверждения верны	x < 5 and x < 10
or	Возвращает True если одно из утверждений верно	x < 5 or x < 4
not	Меняет результат, возвращает False если результат True	not(x < 5 and x < 10)

Операторы тождественности в Python

Операторы тождественности используются для сравнения объектов. Являются ли они одним и тем же объектом с одинаковым местоположением в памяти:

Оператор	Значение	Пример
is	Возвращает true если переменные являются одним объектом	x is y
is not	Возвращает true если переменные разные	x is not y

Операторы принадлежности в Python

Операторы принадлежности используются для проверки того, представлена ​​ли последовательность в объекте:

Оператор	Значение	Пример
in	Возвращает True если последовательность присутствует в объекте	x in y
not in	Возвращает True если последовательность не присутствует в объекте	x not in y

Побитовые операторы в Python

Побитовые операторы используются для работы в битовом (двоичном) формате:

Оператор	Название	Значение
&	И	Устанавливает каждый бит в 1, если оба бита 1
|	Или	Устанавливает каждый бит в 1 если один из двух битов 1
^	только или	Устанавливает каждый бит в 1 если только один из битов 1
~	Не	Переставляет все биты
	Сдвиг влево	Сдвигает влево на количество бит указанных справа
>>	Сдвиг вправо	Сдвигает вправо на количество бит указанных справа

• ТЕГИ
• Уроки Python для начинающих

Операторы * и ** в Питоне. Что это и как использовать

Операторы (operators) * и ** встречаются в питоне очень часто. Иногда они немного непонятны и новичкам, и опытным ребятам, переходящим на питон с ряда других языков программирования (в которых операторы могут использоваться немного иначе). Статья известного питон-коуча Трея Ханнера (Trey Hunner), который помогает девелоперам расширять свои знания. Дата написания статьи: 10.11.2018.

Функционал операторов * и ** развивается уже много лет. Я хочу рассмотреть все способы их использования по состоянию на текущий момент. Буду указывать, что конкретно работает только в современных версиях питона. Поэтому, если вы изучали операторы * и ** еще во времена питона 2 (Python 2), советую хотя бы проглядеть данную статью, потому что в питоне 3 (Python 3) этим операторам добавили много новых возможностей.

Если вы начали изучать питон недавно и еще не освоили аргументы ключевых слов (keyword arguments; также известные как именованные аргументы, named arguments), предлагаю сперва прочитать мою статью про аргументы ключевых слов в питоне.

Что мы обсуждать не будем

В данной статье, говоря про операторы * и **, я имею в виду операторы-префиксы (prefix operators), а не инфиксы (infix). То есть, функции умножения и возведения в степень не входят в тему статьи.

Тогда про что же мы говорим

Мы говорим про операторы-префиксы * и **, которые используются перед переменной (variable). Например:

>>> numbers = [2, 1, 3, 4, 7]
>>> more_numbers = [*numbers, 11, 18]
>>> print(*more_numbers, sep=’, ‘)
2, 1, 3, 4, 7, 11, 18

В данном коде можно увидеть два способа использования оператора *. Оператор ** отсутствует.

В сферу применения рассматриваемых операторов входит:
1. Операторы * и **: передача аргументов в функцию.
2. Операторы * и **: захват аргументов, переданных в функцию.
3. Оператор *: принятие аргументов, содержащих только ключевые слова.
4. Оператор *: захват элементов во время распаковки кортежа (tuple).
5. Оператор *: распаковка итерируемых объектов в списке или кортеже.
6. Оператор **: + распаковка словарей в других словарях.

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

Операторы * и ** при распаковке во время вызова функции

При вызове функции оператор * можно задействовать для распаковки итерируемого объекта в аргументах, введенных для вызова:

>>> fruits = [‘lemon’, ‘pear’, ‘watermelon’, ‘tomato’]
>>> print(fruits[0], fruits[1], fruits[2], fruits[3])
lemon pear watermelon tomato
>>> print(*fruits)
lemon pear watermelon tomato

В строке print(*fruits) производится вызов всех элементов списка fruits в функции print. Они становятся отдельными аргументами. При этом нам даже не надо знать, сколько всего аргументов окажется в списке.

В данном примере оператор * – не просто синтактический выверт (syntactic sugar). Без * отправить все элементы конкретного итерируемого объекта в качестве отдельных аргументов было бы невозможно (это не касается списков с сфиксированной длиной).

Еще один пример:

def transpose_list(list_of_lists):
return [
list(row)
for row in zip(*list_of_lists)
]

В данном случае мы принимаем список со списками в качестве элементов и возвращаем «преобразованный» список со списками:

>>> transpose_list([[1, 4, 7], [2, 5, 8], [3, 6, 9]])
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Функционал оператора ** примерно такой же, просто он применяется к аргументам ключевых слов. Он позволяет нам взять словарь, содержащий пары из ключей и значений, и распаковать его в аргументы ключевых слов при вызове функции.

>>> date_info = <'year': "2020", 'month': "01", 'day': "01">
>>> filename = «—.txt».format(**date_info)
>>> filename
‘2020-01-01.txt’

Скажу из своего опыта. Оператор ** не часто используется для распаковки аргументов ключевых слов при вызове функции. Чаще всего я вижу такие примеры при работе с наследованием: вызовы super() часто включают в себя оба оператора.

Операторы * и ** можно использовать неоднократно при вызове функции. Данная возможность появилась в питоне 3.5. Иногда это может оказаться очень уместным:

>>> fruits = [‘lemon’, ‘pear’, ‘watermelon’, ‘tomato’]
>>> numbers = [2, 1, 3, 4, 7]
>>> print(*numbers, *fruits)
2 1 3 4 7 lemon pear watermelon tomato

Неоднократное использование ** выглядит примерно так же:

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

Операторы * и ** при упаковке аргументов, переданных функции

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

from random import randint
def roll(*dice):
return sum(randint(1, die) for die in dice)

Данная функция принимает любое количество аргументов.

>>> roll(20)
18
>>> roll(6, 6)
9
>>> roll(6, 6, 6)
8

Функции питона print и zip принимают любое количество позиционных аргументов. Такое использование оператора * при упаковке аргументов позволяет нам создавать свои функции, которые (аналогично print и zip) принимают любое количество аргументов.

Кроме того, для оператора ** в данном вопросе предусмотрена еще одна возможность: его можно использовать при определении тела функции, позволяющей захватить в словарь любые аргументы ключевых слов, переданные этой функции:

def tag(tag_name, **attributes):
attribute_list = [
f’=»»‘
for name, value in attributes.items()
]
return f» >»

В данном месте ** захватывает в словарь аргументы ключевых слов, которые мы передаем данной функции. Впоследствии аргументы атрибутов (attributes) данной функции смогут на него ссылаться.

>>> tag(‘a’, href=»http://treyhunner.com»)
>>> tag(‘img’, height=20, width=40, src=»https://kirill-sklyarenko.ru/face.jpg»)

Позиционные аргументы, содержащие аргументы только из ключевых слов

питон 3 ввел специальный синтаксис для передачи аргументов, содержащих только ключевые слова, в функцию. Они представляют собой такие аргументы функции, которые можно определить только с помощью синтаксиса для ключевых слов. Это означает, что их нельзя определить позиционно.

Чтобы принимать аргументы, содержащие только ключевые слова, мы можем поместить именованные аргументы после оператора * при определении тела функции:

def get_multiple(*keys, dictionary, default=None):
return [
dictionary.get(key, default)
for key in keys
]

Данную функцию можно использовать так:

Аргументы dictionary и default поставлены после *keys. То есть, их можно только в качестве аргументов ключевых слов. Если мы попытаемся определить их позиционно, то увидим ошибку:

>>> fruits = <'lemon': 'yellow', 'orange': 'orange', 'tomato': 'red'>
>>> get_multiple(‘lemon’, ‘tomato’, ‘squash’, fruits, ‘unknown’)
Traceback (most recent call last):
+ File «», line 1, in
TypeError: get_multiple() missing 1 required keyword-only argument: ‘dictionary’

Данное поведение внедрено в питон с помощью предложения PEP 3102.

Аргументы, содержащие только ключевые слова и не содержащие позиционные аргументы

Аргументы, содержащие только ключевые слова, – неплохое средство. Но что если вы хотите требовать ввода аргументов, содержащих только ключевые слова, не захватывая неограниченное количество позиционных аргументов?

питон позволяет сделать это с помощью немного странного синтаксиса, когда оператор * как бы сам по себе:

def with_previous(iterable, *, fillvalue=None):
«»»Yield each iterable item along with the item before it.»»»
previous = fillvalue
for item in iterable:
yield previous, item
previous = item

Данная функция принимает аргумент, содержащий итерируемый объект (iterable). Его можно определить позиционно (то есть, первым) или с помощью названия и аргумента fillvalue, который входит в число аргументов, допускающих только ключевые слова. Это означает, что мы можем вызвать функцию with_previous вот так:

>>> list(with_previous([2, 1, 3], fillvalue=0))
[(0, 2), (2, 1), (1, 3)]

>>> list(with_previous([2, 1, 3], 0))
Traceback (most recent call last):
File «», line 1, in
TypeError: with_previous() takes 1 positional argument but 2 were given

Данная функция принимает два аргумента. Один из них, fillvalue, обязательно определяется как аргумент, содержащий ключевое слово.

Обычно я использую аргументы, допускающие только ключевые слова, при захвате неопределенного количества позиционных аргументов. Но иногда я использую данную возможность оператора *, чтобы форсировать исключительно позиционное определение аргумента.

На самом деле, данный подход используется встроенной функцией питона sorted. Если посмотреть справку для sorted, можно увидеть следующее:

>>> help(sorted)
Help on built-in function sorted in module builtins:
sorted(iterable, /, *, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.
A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order.

Пример использования оператора * как самого по себе прямо в документации по аргументам функции sorted.

Операторы * и ** при распаковке кортежа

Дополнительно к вышенаписанному, в питоне 3 добавлен новый способ применения *, который некоторым образом связан с вышеописанными возможностями этого оператора при определении тела функции и при вызове функции.

Оператор * теперь можно использовать при распаковке кортежа:

>>> fruits = [‘lemon’, ‘pear’, ‘watermelon’, ‘tomato’]
>>> first, second, *remaining = fruits
>>> remaining
[‘watermelon’, ‘tomato’]
>>> first, *remaining = fruits
>>> remaining
[‘pear’, ‘watermelon’, ‘tomato’]
>>> first, *middle, last = fruits
>>> middle
[‘pear’, ‘watermelon’]

Если вы задаете себе вопрос: как же мне использовать это в своем коде, посмотрите примеры в моей статье про распаковку кортежей в питоне. В этой статье я показал, каким образом такое использование оператора * может, в некоторых случаях, стать альтернативой для срезания последовательностей (sequence slicing).

Обычно во время своих лекций об операторе * я говорю, что можно использовать только одно выражение с ним в отдельном вызове многократного присвоения (multiple assignment). Технически это некорректно, потому что можно его использовать два раза при вложенной распаковке (nested unpacking). Данный вопрос я рассмотрел подробно в статье про распаковку кортежей.

>>> fruits = [‘lemon’, ‘pear’, ‘watermelon’, ‘tomato’]
>>> ((first_letter, *remaining), *other_fruits) = fruits
>>> remaining
[‘e’, ‘m’, ‘o’, ‘n’]
>>> other_fruits
[‘pear’, ‘watermelon’, ‘tomato’]

Правда, я никогда не встречал хорошего примера такого использования. Не думаю, что стал бы его рекомендовать, даже если бы удалось найти. Он выглядит немного непонятно.

Данная возможность добавлена в питон на основе предложения PEP 3132. Следует отметить, что оно не относится к очень длинным.

Операторы * и ** в литерале списка

В питоне 3.5 добавлено очень много возможностей, связанных с оператором *, на основе предложения PEP 448. Одной из самых заметных новых возможностей стало использование * для вывода итерируемого объекта в новый список.

Допустим, у вас есть функция, которая принимает любые последовательности и возвращает список, содержащий каскад из последовательности и ее реверсивного варианта:

def palindromify(sequence):
return list(sequence) + list(reversed(sequence))

Данная функция должна пару раз провести конвертацию в список, чтобы объединить списки и вернуть результат. Начиная с питона 3.5, мы можем, вместо вышеприведенного примера, написать следующее:

def palindromify(sequence):
return [*sequence, *reversed(sequence)]

В данном коде больше нет нескольких ненужных вызовов списков. Поэтому он стал эффективнее и лучше читается.

def rotate_first_item(sequence):
return [*sequence[1:], sequence[0]]

Данная функция возвращает новый список, в котором первый элемент переданного списка (или другой последовательности) перенесен в конец нового списка.

Это очень удачная возможность, позволяющая с помощью оператора * объединять итерируемые объекты различных типов. Оператор * работает с любыми итерируемыми объектами, а оператор + работает только с определенными последовательностями, при чем все из объединяемых должны быть одного типа.

Отмечу, что данная возможность не ограничивается только созданием списков. Мы можем выводить итерируемые объекты в новые кортежи или множества (set):

Обратите внимание, что последняя строка принимает список и генератор (generator), а потом выводит их в новое множество. Перед появлением этой возможности для оператора * было непросто сделать это в одну строку кода. Разумеется, способ сделать это существовал, но его было непросто вспомнить или обнаружить:

>>> set().union(fruits, uppercase_fruits)

Оператор ** в литерале словаря

Помимо вышеприведенного на основе предложения PEP 448 в функционал ** добавлен вывод пар ключ/значение (key/value) из словаря в новый словарь:

>>> date_info =
>>> track_info =
>>> all_info = <**date_info, **track_info>
>>> all_info

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

>>> date_info =
>>> event_info = <**date_info, 'group': "Python Meetup">
>>> event_info

Еще можно скопировать или слить словари, переписывая определенные значения:

>>> event_info =
>>> new_info = <**event_info, 'day': "14">
>>> new_info

Операторы * и ** обладают немалыми возможностями в питоне

В питоне операторы * и ** – не просто синтактический выверт. Некоторые из их возможностей реализуются и другими средствами, но доступные альтернативы обычно более громоздкие и потребляют больше ресурсов. Кроме того, некоторые элементы в функционале этих операторов попросту не доступны без их использования. Например, без помощи * невозможно передать в функцию неопределенное количество позиционных аргументов.

Прочитав обо всех возможностях * и **, вы, возможно, удивитесь названиям, под которыми используются эти странные операторы. К сожалению, для них нет лаконичных названий. Я слышал, как * называли оператором для упаковки и распаковки. Еще слышал, как его называли «splat» (это из мира Руби) и просто звездой.

Чаще всего я называю их звездой (star) и двойной звездой (double star) (или звездой-звездой (star star)). В данном случае разделения с их функциями как инфиксов не проводится (речь идет про операции умножения и возведения в степень). Но обычно из контекста очевидно, о чем идет речь, про префиксы или инфиксы.

Если вы не понимаете операторы * и ** или боитесь не запомнить все их возможности, не нужно беспокоиться. Способов использования много, и запоминать каждую конкретную возможность для каждого из них не так важно. Лучше будет осознать, в каких случаях к ним можно обратиться. Предлагать использовать данную статью как чек-лист или создать свой чек-лист, который поможет вам использовать операторы * и ** в питоне.

• перевод с английского
• python
• операторы

Операторы и выражения¶

Большинство предложений (логических строк) в программах содержат выражения. Простой пример выражения: 2 + 3 . Выражение можно разделить на операторы и операнды.

Операторы – это некий функционал, производящий какие-либо действия, который может быть представлен в виде символов, как например + , или специальных зарезервированных слов. Операторы могут производить некоторые действия над данными, и эти данные называются операндами. В нашем случае 2 и 3 – это операнды.

Операторы¶

Кратко рассмотрим операторы и их применение:

Обратите внимание, вычислить значения выражений, данных в примерах, можно также используя интерпретатор интерактивно. Например, для проверки выражения 2 + 3 воспользуйтесь интерактивной командной строкой интерпретатора Python:

>>> 2 + 3 5 >>> 3 * 5 15 

Операторы и их применение

Можно составлять произвольные цепочки сравнений: 3 < 5 < 7 даёт True .

Краткая запись мат. операций и присваивания¶

Зачастую результат проведения некой математической операции необходимо присвоить переменной, над которой эта операция производилась. Для этого существуют краткие формы записи выражений:

Вы можете записать:

a = 2; a = a * 3 

a = 2; a *= 3 

Обратите внимание, что выражения вида “ переменная = переменная операция выражение ” принимает вид “ переменная операция = выражение ”.

Порядок вычисления¶

Если имеется выражение вида 2 + 3 * 4 , что производится раньше: сложение или умножение? Школьный курс математики говорит нам, что умножение должно производиться в первую очередь. Это означает, что оператор умножения имеет более высокий приоритет, чем оператор сложения.

Следующая таблица показывает приоритет операторов в Python, начиная с самого низкого (самое слабое связывание) и до самого высокого (самое сильное связывание). Это означает, что в любом выражении Python сперва вычисляет операторы и выражения, расположенные внизу таблицы, а затем операторы выше по таблице.

Эта таблица взята из Справочника по языку Python (англ.) и приводится здесь для полноты описания. На практике лучше использовать скобки для группировки операторов и операндов, чтобы в явном виде указать порядок вычисления выражений. Заодно это облегчит чтение программы. Более подробно см. в разделе Изменение порядка вычисления ниже.

Приоритет операторов

Оператор	Описание
lambda	лямбда-выражение
or	Логическое “ИЛИ”
and	Логическое “И”
not x	Логическое “НЕ”
in , not in	Проверка принадлежности
is , is not	Проверка тождественности
< , , >= , != , ==	Сравнения
|	Побитовое “ИЛИ”
^	Побитовое “ИСКЛЮЧИТЕЛЬНО ИЛИ”
&	Побитовое “И”
>	Сдвиги
+ , —	Сложение и вычитание
* , / , // , %	Умножение, деление, целочисленное деление и остаток от деления
+x , -x	Положительное, отрицательное
~x	Побитовое НЕ
**	Возведение в степень
x.attribute	Ссылка на атрибут
x[индекс]	Обращение по индексу
x[индекс1:индекс2]	Вырезка
f(аргументы . )	Вызов функции
(выражения, . )	Связка или кортеж [2]
[выражения, . ]	Список
	Словарь

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

В этой таблице операторы с равным приоритетом расположены в одной строке. Например, + и — имеют равный приоритет.

Изменение порядка вычисления¶

Для облегчения чтения выражений можно использовать скобки. Например, 2 + (3 * 4) определённо легче понять, чем 2 + 3 * 4 , которое требует знания приоритета операторов. Как и всё остальное, скобки нужно использовать разумно (не перестарайтесь) и избегать излишних, как в (2 + (3 * 4)) .

Есть ещё одно преимущество в использовании скобок – они дают возможность изменить порядок вычисления выражений. Например, если сложение необходимо произвести прежде умножения, можно записать нечто вроде (2 + 3) * 4 .

Ассоциативность¶

Операторы обычно обрабатываются слева направо. Это означает, что операторы с равным приоритетом будут обработаны по порядку от левого до правого. Например, 2 + 3 + 4 обрабатывается как (2 + 3) + 4 .

Выражения¶

Пример (сохраните как expression.py ):

length = 5 breadth = 2 area = length * breadth print('Площадь равна', area) print('Периметр равен', 2 * (length + breadth)) 

Вывод:

$ python expression.py Площадь равна 10 Периметр равен 14

Как это работает:

Длина и ширина прямоугольника хранятся в переменных length и breadth соответственно. Мы используем их для вычисления периметра и площади прямоугольника при помощи выражений. Результат выражения length * breadth сохраняется в переменной area , после чего выводится на экран функцией print . Во втором случае мы напрямую подставляем значение выражения 2 * (length + breadth) в функцию print .

Также обратите внимание, как Python “красиво печатает” результат. Несмотря на то, что мы не указали пробела между ‘Площадь равна’ и переменной area , Python подставляет его за нас, чтобы получить красивый и понятный вывод. Программа же остаётся при этом легкочитаемой (поскольку нам не нужно заботиться о пробелах между строками, которые мы выводим). Это пример того, как Python облегчает жизнь программисту.

Резюме¶

Мы увидели, как пользоваться операторами, операндами и выражениями. Это основные строительные блоки любой программы. Далее мы увидим, как это применить на практике.

Примечания¶

[1]	“True” — англ. “Верно (Правда)”; “False” — англ. “Ошибочно (Ложь)”. (прим. перев.)

[2]	“tuple” — англ. “кортеж” (прим. перев.)