Операторы Python и их приоритет выполнения. Операторы и выражения на языке Python

Operator	Описание	Примеры
	Логический оператор "И". Условие будет истинным если оба операнда истина.	True and True равно True. True and False равно False. False and True равно False. False and False равно False.
	Логический оператор "ИЛИ". Если хотя бы один из операндов истинный, то и все выражение будет истинным.	True or True равно True. True or False равно True. False or True равно True. False or False равно False.
	Логический оператор "НЕ". Изменяет логическое значение операнда на противоположное.	not True равно False. not False равно True.

Python. Операторы ветвления. Условный оператор. Оператор множественного выбора. Структуры организации циклов.

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

Оператора ветвления if....else

Условный оператор реализует выполнение определённых команд при условии, что некоторое логическое выражение (условие) принимает значение «истина» true. В большинстве языков программирования условный оператор начинается с ключевого слова if

Оператор множественного выбора

Инструкция множественного выбора позволяет выполнять различные части программы в зависимости от того, какое значение будет иметь некоторая целочисленная переменной elif

Циклы while и for

Инструкция while, обеспечивает способ организации универсальных циклов;

Инструкция for, предназначена для обхода элементов в последовательностях и выполнения

блока программного кода для каждого из них.

14. Python. Кортежи, словари, списки. Срезы

Кортеж, по сути - неизменяемый список.

Зачем нужны кортежи, если есть списки?

Защита от дурака. То есть кортеж защищен от изменений, как намеренных (что плохо), так и случайных (что хорошо).

Ну и создать кортеж из итерируемого объекта можно с помощью все той же пресловутой функции tuple()

>>> a = tuple("hello, world!")

("h", "e", "l", "l", "o", ",", " ", "w", "o", "r", "l", "d", "!")

Словари в Python - неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами.

Методы словарей

dict.clear () - очищает словарь.

dict.copy () - возвращает копию словаря.

classmethod dict.fromkeys (seq[, value]) - создает словарь с ключами из seq и значением value (по умолчанию None).

dict.get (key[, default]) - возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None).

dict.items () - возвращает пары (ключ, значение).

dict.keys () - возвращает ключи в словаре.

dict.pop (key[, default]) - удаляет ключ и возвращает значение. Если ключа нет, возвращает default (по умолчанию бросает исключение).

dict.popitem () - удаляет и возвращает пару (ключ, значение). Если словарь пуст, бросает исключение KeyError. Помните, что словари неупорядочены.

dict.setdefault (key[, default]) - возвращает значение ключа, но если его нет, не бросает исключение, а создает ключ с значением default (по умолчанию None).

dict.update () - обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).

dict.values () - возвращает значения в словаре.

Что такое списки?

Списки в Python - упорядоченные изменяемые коллекции объектов произвольных типов (почти как массив, но типы могут отличаться).

Чтобы использовать списки, их нужно создать. Создать список можно несколькими способами. Например, можно обработать любой итерируемый объект (например, строку) встроенной функцией list:.

Таблица "методы списков"

Метод Что делает

list.append(x) Добавляет элемент в конец списка

list.extend(L) Расширяет список list, добавляя в конец все элементы списка L

list.insert(i, x) Вставляет на i-ый элемент значение x

list.remove(x) Удаляет первый элемент в списке, имеющий значение x

list.pop([i]) Удаляет i-ый элемент и возвращает его. Если индекс не указан, удаляется последний элемент

list.index(x, ]) Возвращает положение первого элемента от start до end со значением x

list.count(x) Возвращает количество элементов со значением x

list.sort() Сортирует список на основе функции

list.reverse() Разворачивает список

list.copy() Поверхностная копия списка (новое в python 3.3)

list.clear() Очищает список (новое в python 3.3)

Срезы

В Python, кроме индексов, существуют ещё и срезы.

item - берёт срез от номера START, до STOP (не включая его), с шагом STEP. По умолчанию START = 0, STOP = длине объекта, STEP = 1. Соответственно, какие-нибудь (а возможно, и все) параметры могут быть опущены.

>>> a =

Также все эти параметры могут быть и отрицательными:

>>> a =

>>> a[::-1]

>>> a[-2::-1]

>>> a

В последнем примере получился пустой список, так как START < STOP, а STEP отрицательный. То же самое произойдёт, если диапазон значений окажется за пределами объекта:

>>> a =

>>> a

Также с помощью срезов можно не только извлекать элементы, но и добавлять и удалять элементы (разумеется, только для изменяемых последовательностей).

>>> a =

>>> a =

Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 3 и 5 больше 7, вы согласитесь, скажете: «Да, это правда». Если же кто-то будет утверждать, что сумма трех и пяти меньше семи, то вы расцените такое утверждение как ложное.

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

Например, выражение 4 > 5 является логическим, так как его результатом является либо правда, либо ложь. Выражение 4 + 5 не является логическим, так как результатом его выполнения является число.

На позапрошлом уроке мы познакомились с тремя типами данных – целыми и вещественными числами, а также строками. Сегодня введем четвертый – логический тип данных (тип bool). Его также называют булевым. У этого типа всего два возможных значения: True (правда) и False (ложь).

>>> a = True >>> type (a) >>> b = False >>> type (b)

Здесь переменной a было присвоено значение True, после чего с помощью встроенной в Python функции type() проверен ее тип. Интерпретатор сообщил, что это переменная класса bool. Понятия "класс" и "тип данных" в данном случае одно и то же. Переменная b также связана с булевым значением.

В программировании False обычно приравнивают к нулю, а True – к единице. Чтобы в этом убедиться, можно преобразовать булево значение к целочисленному типу:

>>> int (True ) 1 >>> int (False ) 0

Возможно и обратное. Можно преобразовать какое-либо значение к булевому типу:

>>> bool (3.4 ) True >>> bool (-150 ) True >>> bool (0 ) False >>> bool (" " ) True >>> bool ("" ) False

И здесь работает правило: всё, что не 0 и не пустота, является правдой.

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

Говоря на естественном языке (например, русском) мы обозначаем сравнения словами "равно", "больше", "меньше". В языках программирования используются специальные знаки, подобные тем, которые используются в математике: > (больше), < (меньше), >= (больше или равно), <= (меньше или равно), == (равно), != (не равно).

Не путайте операцию присваивания значения переменной, обозначаемую в языке Python одиночным знаком "равно", и операцию сравнения (два знака "равно"). Присваивание и сравнение – разные операции.

>>> a = 10 >>> b = 5 >>> a + b > 14 True >>> a < 14 - b False >>> a <= b + 5 True >>> a != b True >>> a == b False >>> c = a == b >>> a, b, c (10, 5, False)

В данном примере выражение c = a == b состоит из двух подвыражений. Сначала происходит сравнение (==) переменных a и b . После этого результат логической операции присваивается переменной c. Выражение a, b, c просто выводит значения переменных на экран.

Сложные логические выражения

Логические выражения типа kByte >= 1023 являются простыми, так как в них выполняется только одна логическая операция. Однако, на практике нередко возникает необходимость в более сложных выражениях. Может понадобиться получить ответа "Да" или "Нет" в зависимости от результата выполнения двух простых выражений. Например, "на улице идет снег или дождь", "переменная news больше 12 и меньше 20".

В таких случаях используются специальные операторы, объединяющие два и более простых логических выражения. Широко используются два оператора – так называемые логические И (and ) и ИЛИ (or ).

and , необходимо, чтобы результаты обоих простых выражений, которые связывает данный оператор, были истинными. Если хотя бы в одном случае результатом будет False, то и все сложное выражение будет ложным.

Чтобы получить True при использовании оператора or , необходимо, чтобы результат хотя бы одного простого выражения, входящего в состав сложного, был истинным. В случае оператора or сложное выражение становится ложным лишь тогда, когда ложны оба составляющие его простые выражения.

Допустим, переменной x было присвоено значение 8 (x = 8), переменной y присвоили 13 (y = 13). Логическое выражение y < 15 and x > 8 будет выполняться следующим образом. Сначала выполнится выражение y < 15 . Его результатом будет True. Затем выполнится выражение x > 8 . Его результатом будет False. Далее выражение сведется к True and False , что вернет False.

>>> x = 8 >>> y = 13 >>> y < 15 and x > 8 False

Если бы мы записали выражение так: x > 8 and y < 15 , то оно также вернуло бы False. Однако сравнение y < 15 не выполнялось бы интерпретатором, так как его незачем выполнять. Ведь первое простое логическое выражение (x > 8) уже вернуло ложь, которая, в случае оператора and, превращает все выражение в ложь.

В случае с оператором or второе простое выражение проверяется, если первое вернуло ложь, и не проверяется, если уже первое вернуло истину. Так как для истинности всего выражения достаточно единственного True, неважно по какую сторону от or оно стоит.

>>> y < 15 or x > 8 True

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

• Перевод

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

4. Выбор значений

4.1. Правильный путь

Начиная с версии 2.5, Python поддерживает синтаксис «value_if_true if test else value_if_false». Таким образом, вы можете выбрать одно из двух значений, не прибегая к странному синтаксису и подробным пояснениям:
test = True # test = False result = "Test is True" if test else "Test is False" # result = "Test is True"
Увы, это всё еще немного некрасиво. Вы также можете использовать несколько таких конструкций в одной строке:
test1 = False test2 = True result = "Test1 is True" if test1 else "Test1 is False, test2 is True" if test2 else "Test1 and Test2 are both False"
Сначала выполняется первый if/else, а если test1 = false, выполняется второй if/else. Вы можете делать и более сложные вещи, особенно если воспользуетесь скобками.

Этот способ весьма новый, и я испытываю к нему смешанные чувства. Это правильная, понятная конструкция, она мне нравится… но она всё еще уродлива, особенно при использовании нескольких вложенных конструкций. Конечно, синтаксис всех уловок для выбора значений некрасив. У меня слабость к описанному ниже способу с and/or, сейчас я нахожу его интуитивным, сейчас я понимаю, как он работает. К тому же он ничуть не менее эффективен, чем «правильный» способ.

Хотя инлайновый if/else - новый, более правильный способ, вам всё же стоит ознакомиться со следующими пунктами. Даже если вы планируете использовать Python 2.5, вы встретите эти способы в старом коде. Разумеется, если вам нужна обратная совместимость, будет действительно лучше просмотреть их.

4.2. Уловка and/or

«and» и «or» в Python - сложные создания. Применение and к нескольким выражениям не просто возвращает True или False. Оно возвращает первое false-выражение, либо последнее из выражений, если все они true. Результат ожидаем: если все выражения верны, возвращается последнее, являющееся true; если одно из них false, оно и возвращается и преобразуется к False при проверке логического значения.

Аналогично, операция or возвращает первое true-значение, либо последнее, если ни одно из них не true.

Это вам не поможет, если вы просто проверяете логическое значение выражения. Но можно использовать and и or в других целях. Мой любимый способ - выбор значения в стиле, аналогичном тернарному оператору языка C «test? value_if_true: value_if_false»:
test = True # test = False result = test and "Test is True" or "Test is False" # теперь result = "Test is True"
Как это работает? Если test=true, оператор and пропускает его и возвращает второе (последнее) из данных ему значений: "Test is True" or "Test is False" . Далее, or вернет первое true выражение, т. е. "Test is True".

Если test=false, and вернет test, останется test or "Test is False" . Т. к. test=false, or его пропустит и вернет второе выражение, "Test is False".

Внимание, будьте осторожны со средним значением («if_true»). Если оно окажется false, выражение с or будет всегда пропускать его и возвращать последнее значение («if_false»), независимо от значения test.

После использования этого метода правильный способ (п. 4.1) кажется мне менее интуитивным. Если вам не нужна обратная совместимость, попробуйте оба способа и посмотрите, какой вам больше нравится. Если не можете определиться, используйте правильный.

Конечно, если вам нужна совместимость с предыдущими версиями Python, «правильный» способ не будет работать. В этом случае and/or - лучший выбор в большинстве ситуаций.

4.3. True/False в качестве индексов

Другой способ выбора из двух значений - использование True и False как индексов списка с учетом того факта, что False == 0 и True == 1:
test = True # test = False result = ["Test is False","Test is True"] # теперь result = "Test is True"
Этот способ более честный, и value_if_true не обязано быть true. Однако у него есть существенный недостаток: оба элемента списка вычисляются перед проверкой. Для строк и других простых элементов это не проблема. Но если каждый из них требует больших вычислений или операций ввода-вывода, вычисление обоих выражений недопустимо. Поэтому я предпочитаю обычную конструкцию или and/or.

Также заметьте, что этот способ работает только тогда, когда вы уверены, что test - булево значение, а не какой-то объект. Иначе придется писать bool(test) вместо test, чтобы он работал правильно.

5. Функции

5.1. Значения по умолчанию для аргументов вычисляются только один раз

Начнем этот раздел с предупреждения. Эта проблема много раз смущала многих программистов, включая меня, даже после того, как я разобрался в проблеме. Легко ошибиться, используя значения по умолчанию:
def function(item, stuff = ): stuff.append(item) print stuff function(1) # выводит "" function(2) # выводит "" !!!
Значения по умолчанию для аргументов вычисляются только один раз, в момент определения функции. Python просто присваивает это значение нужной переменной при каждом вызове функции. При этом он не проверяет, изменилось ли это значение. Поэтому, если вы изменили его, изменение будет в силе при следующих вызовах функции. В предыдущем примере, когда мы добавили значение к списку stuff, мы изменили его значение по умолчанию навсегда. Когда мы вызываем функцию снова, ожидая дефолтное значение, мы получаем измененное.

Решение проблемы: не используйте изменяемые объекты в качестве значений по умолчанию. Вы можете оставить всё как есть, если не изменяете их, но это плохая идея. Вот как следовало написать предыдущий пример:
def function(item, stuff = None): if stuff is None: stuff = stuff.append(item) print stuff function(1) # выводит "" function(2) # выводит "", как и ожидалось
None неизменяем (в любом случае, мы не пытаемся его изменить), так что мы обезопасили себя от внезапного изменения дефолтного значения.

С другой стороны, умный программист, возможно, превратит это в уловку для использования статических переменных, как в языке C.

5.1.1. Заставляем дефолтные значения вычисляться каждый раз

Если вы не хотите вносить в код функции лишний беспорядок, можно заставить интерпретатор заново вычислять значения аргументов перед каждым вызовом. Следующий декоратор делает это:
from copy import deepcopy def resetDefaults(f): defaults = f.func_defaults def resetter(*args, **kwds): f.func_defaults = deepcopy(defaults) return f(*args, **kwds) resetter.__name__ = f.__name__ return resetter
Просто примените этот декоратор к функции, чтобы получить ожидаемые результаты:
@resetDefaults # так мы применяем декоратор def function(item, stuff = ): stuff.append(item) print stuff function(1) # выводит "" function(2) # выводит "", как и ожидалось

5.2. Переменное число аргументов

Python позволяет использовать произвольное число аргументов в функциях. Сначала определяются обязательные аргументы (если они есть), затем нужно указать переменную со звездочкой. Python присвоит ей значение списка остальных (не именованных) аргументов:
def do_something(a, b, c, *args): print a, b, c, args do_something(1,2,3,4,5,6,7,8,9) # выводит "1, 2, 3, (4, 5, 6, 7, 8, 9)"
Зачем это нужно? Например, функция должна принимать несколько элементов и делать с ними одно и то же (например, складывать). Можно заставить пользователя передавать функции список: sum_all(). А можно позволить передавать произвольное число аргументов, тогда получится более чистый код: sum_all(1,2,3).

Функция также может иметь переменное число именованных аргументов. После определения всех остальных аргументов укажите переменную с "**" в начале. Python присвоит этой переменной словарь полученных именованных аргументов, кроме обязательных:
def do_something_else(a, b, c, *args, **kwargs): print a, b, c, args, kwargs do_something_else(1,2,3,4,5,6,7,8,9, timeout=1.5) # выводит "1, 2, 3, (4, 5, 6, 7, 8, 9), {"timeout": 1.5}"
Зачем так делать? Я считаю, самая распространенная причина - функция является оберткой другой функции (или функций), и неиспользуемые именованные аргументы могут быть переданы другой функции (см. п. 5.3).

5.2.1. Уточнение

Использование именованных аргументов и произвольного числа обычных аргументов после них, по-видимому, невозможно, потому что именованные аргументы должны быть определены до "*"-параметра. Например, представим функцию:
def do_something(a, b, c, actually_print = True, *args): if actually_print: print a, b, c, args
У нас проблема: не получится передать actually_print как именованный аргумент, если при этом нужно передать несколько неименованных. Оба следующих варианта вызовут ошибку:
do_something(1, 2, 3, 4, 5, actually_print = True) # actually_print сначала приравнивается к 4 (понятно, почему?), а затем # переопределяется, вызывая TypeError ("got multiple values for keyword argument") do_something(1, 2, 3, actually_print = True, 4, 5, 6) # Именованные аргументы не могут предшествовать обычным. Происходит SyntaxError. Единственный способ задать actually_print в этой ситуации - передать его как обычный аргумент: do_something(1, 2, 3, True, 4, 5, 6) # результат: "1, 2, 3, (4, 5, 6)"
Единственный способ задать actually_print в этой ситуации - передать его как обычный аргумент:
do_something(1, 2, 3, True, 4, 5, 6) # результат: "1, 2, 3, (4, 5, 6)"

5.3. Передача списка или словаря в качестве нескольких аргументов

Поскольку можно получить переданные аргументы в виде списка или словаря, нет ничего удивительного в том, что передавать аргументы функции тоже можно из списка или словаря. Синтаксис совершенно такой же, как в предыдущем пункте, нужно поставить перед списком звездочку:
args = pow(*args) # возвращает pow(5,2), т. е. 25
А для словаря (что используется чаще) нужно поставить две звездочки:
def do_something(actually_do_something=True, print_a_bunch_of_numbers=False): if actually_do_something: print "Something has been done" # if print_a_bunch_of_numbers: print range(10) kwargs = {"actually_do_something": True, "print_a_bunch_of_numbers": True} do_something(**kwargs) # печатает "Something has been done", затем ""
Историческая справка: в Python до версии 2.3 для этих целей использовалась встроенная функция apply (function, arg_list, keyword_arg_dict)".

У каждой операции есть свои операторы. В унарных и бинарных операциях применяются базовые операторы (сложение, вычитание, отрицание, унарный плюс, унарный минус, присваивание). Тернарный имеет три аргумента: условие if, выражение, если условие == true, и выражение, если условие == false.

Понять, что такое оператор, поможет следующий пример.

A = b + c

К переменной b прибавляется c, результат присваивается переменной a. Весь пример в целом a = b + c - это выражение. Переменные, которые в нем фигурируют, - это операнды. Производимая операция - сложение, а используемый для этого оператор - “+”.

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

Пайтон предоставляет огромное количество библиотек для решения вычислительных задач. Большой набор методов ставит Python на один уровень с Matlab и Octave. Арифметические операции применяются относительно к целым числам типа int, вещественным типа float, комплексным complex.

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

Все возможные арифметические операции приведены в таблице.

Добавление одного числа к другому выполняет оператор additional. Вычитание осуществляется с помощью subtraction. Умножение одного числа на другое происходит с multiplication. Возведение в степень осуществляется с помощью exponenta. Для деления используется division.

Оператор modulus (%) возвращает остаток от деления левого операнда на правый. Если переменная a = 10, переменная b = 20, то b%a == 0. Что такое оператор деления с остатком, легко понять на следующем примере. Если 9/2 == 4.5, то 9//2 возвращает результат, равный 4. Деление с floor division (//) возвращает целое число от операции деления левого операнда на правый.

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

Наряду с целыми и вещественными числами в Python существуют комплексные числа. Они состоят из действительной и мнимой части. Записываются в виде c = a+bj, где а - действительная часть,

C.real() #a

b - мнимая.

C.imag() #b

Арифметические операции c комплексными числами имеют те же свойства, что и с вещественными. Использование complex numbers можно представить на плоскости с прямоугольной системой координат. Точка a пересечения оси X и оси Y соответствует комплексному числу x + yi. Таким образом, на оси X располагаются вещественные числа, а на вертикальной оси Y - мнимые.

Сравнение

Операторы в Python используется для сравнения переменных. Кроме стандартных, известных из математических задач, существует проверка по значению и по типу, а также проверка неравенства.

Операции сравнения осуществляются в виде a x b, где x - это оператор сравнения.

В программировании оператор “=” работает не так, как в математике. Соответствие значений каждого аргумента определяется оператором “==”, но “=” только присваивает значение. С помощью!= проверяется неравенство переменных. Этот оператор можно заменить как “<>”, что не является стандартным оператором в других языках, как Си, Джава или Джаваскрипт.

Присваивание

Операторы Python присваивают значение переменной.

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

Алгоритм работы:

• вычисление левостороннего значения;
• вычисление правостороннего значения;
• присвоение одного значения другому - при конфликте типов должно быть осуществлено их приведение;
• возврат результата операции - true или false.

И математической операции работают по такому принципу:

a x b, где x - это оператор, означает что a = a x b. Таким образом, a += b говорит о том, что значение переменной a прибавляется к значению переменной b, а их результат присваивается переменной a. То же самое происходит с другими примерами. Например, a **= b расшифровывается как a = a ** b, то есть a возводится в степень b, результат в итоге присваивается a.

Условия

Проверка условий выполняется с помощью тернарного оператора Python.

Он состоит из двух или трех частей:

• if - проверяемое выражение;
• elif - необязательная инструкция (аналогичная if else или elseif);
• else - основная инструкция.

a = int(input()) if X: A = Y else: A = Z

Выражение можно задать в одной строке.

A = Y if X else Z

Части else и elseif можно отбрасывать, выражение выглядит так:

If 1: print("hello 1")

В Пайтоне существуют операторы break и continue. Break прерывает выполнение кода на всех уровнях. Continue прекращает текущую итерацию, продолжает выполнение со следующей точки.

Побитовые

Такие операторы Python интерпретируют операнды как последовательность нулей и единиц.

Они используют числа в двоичном представлении, возвращают результат в виде 32-битного числа.

a = 0 #a = 1 #a = 2 #a = 3 #a = 255 #

Отрицательное число в двоичном формате получается методом замены бита на противоположное и прибавления 1.

314 #-314 #+ 1 =

Отличие a >> b от a >>> b в том, что при сдвиге и отбрасывании правых значений слева добавляются копии первых битов.

9 #9 >> 2 #-9 #-9 >> 2 #

Но при a >>> b левые значение будут заполнены нулями.

9 #-9 >>> 2 #

Логические

Всего существует три логических оператора.

• and - возвращает true, если a == b == x;
• or - возвращает true есть a == x или b == x;
• not - возвращает false, если a == b == x.

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

Оператор принадлежности проверяет, является ли переменная частью некоторой последовательности.

• a in b возвращает true, если находит переменную a в последовательности b;
• a not in b возвращает true, если не находит переменную а в последовательности b.

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

• a is b возвращает true, если переменные справа и слева указывают на один объект;
• a is not b возвращает true, если переменные не указывают на один объект.

Приоритеты

В списке приведены операторы и выражения, отсортированные по приоритету выполнения от меньшего к большему.

Операторы в Python и их приоритет выполнения:

• Лямбда выражения.
• Python.
• Булевое ИЛИ.
• Булевое И.
• Булевое НЕ.
• Операторы тождественности, принадлежности, операторы присваивания.
• Битовый ИЛИ.
• Битовый НЕ.
• Битовый И.
• Битовый оператор сдвига битов.
• Сложение и вычитание.
• Умножение и деление, включая операцию получения остатка деления и целого числа.
• Битовое НЕ.
• Возведение в степень.
• Обращение к элементу массива по индексу, слайсинг, обращение к объекту класса, вызов функции с аргументами.

Первый пункт в списке - лямбда-выражение. Lambda expression используется для создания анонимных функций. Лямбда ведет себя как обычная функция, и объявляется в виде

Def (arguments): return expression

После лямбда-выражения следуют операции, выполняемые тернарным оператором Python.

В конце списка располагаются методы манипуляции массивом и функциями. Обращение к элементу массива по индексу выглядит так:

В рассматриваемом случае а - это массив, i - это индекс элемента.

Слайсинг означает передачу полной копии массива или выборочную последовательность из членов списка. Диапазон желаемых значения указывается в . В качестве аргументов x представляется начало отсчета, y - конец, а z - шаг прохождения по элементам массива при каждой итерации. X по умолчанию обозначает начало списка, y - конец, z равняется единице. Если указать z как отрицательное число, значения списка передаются в обратном порядке с конца к началу.

Оператор	Описание	Примеры
+	Сложение - Суммирует значения слева и справа от оператора	15 + 5 в результате будет 20 20 + -3 в результате будет 17 13.4 + 7 в результате будет 20.4
-	Вычитание - Вычитает правый операнд из левого	15 - 5 в результате будет 10 20 - -3 в результате будет 23 13.4 - 7 в результате будет 6.4
*	Умножение - Перемножает операнды	5 * 5 в результате будет 25 7 * 3.2 в результате будет 22.4 -3 * 12 в результате будет -36
/	Деление - Делит левый операнд на правый	15 / 5 в результате будет 3 5 / 2 в результате будет 2 (В Python 2.x версии при делении двух целых чисел результат будет целое число) 5.0 / 2 в результате будет 2.5 (Чтобы получить "правильный" результат хотя бы один операнд должен быть float)
%	Деление по модулю - Делит левый операнд на правый и возвращает остаток.	6 % 2 в результате будет 0 7 % 2 в результате будет 1 13.2 % 5 в результате 3.2
**	Возведение в степень - возводит левый операнд в степень правого	5 ** 2 в результате будет 25 2 ** 3 в результате будет 8 -3 ** 2 в результате будет -9
//	Целочисленное деление - Деление в котором возвращается только целая часть результата. Часть после запятой отбрасывается.	12 // 5 в результате будет 2 4 // 3 в результате будет 1 25 // 6 в результате будет 4

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

Оператор	Описание	Примеры
==	Проверяет равны ли оба операнда. Если да, то условие становится истинным.	5 == 5 в результате будет True True == False в результате будет False "hello" == "hello" в результате будет True
!=		12 != 5 в результате будет True False != False в результате будет False "hi" != "Hi" в результате будет True
<>	Проверяет равны ли оба операнда. Если нет, то условие становится истинным.	12 <> 5 в результате будет True. Похоже на оператор!=
>	Проверяет больше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным.	5 > 2 в результате будет True. True > False в результате будет True. "A" > "B" в результате будет False.
<	Проверяет меньше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным.	3 < 5 в результате будет True. True < False в результате будет False. "A" < "B" в результате будет True.
>=	Проверяет больше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным.	1 >= 1 в результате будет True. 23 >= 3.2 в результате будет True. "C" >= "D" в результате будет False.
<=	Проверяет меньше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным.	4 <= 5 в результате будет True. 0 <= 0.0 в результате будет True. -0.001 <= -36 в результате будет False.

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

Оператор	Описание	Примеры
=	Присваивает значение правого операнда левому.	c = 23 присвоит переменной с значение 23
+=	Прибавит значение правого операнда к левому и присвоит эту сумму левому операнду.	с = 5 а = 2 с += а равносильно: с = с + а. с будет равно 7
-=	Отнимает значение правого операнда от левого и присваивает результат левому операнду.	с = 5 а = 2 с -= а равносильно: с = с - а. с будет равно 3
*=	Умножает правый операнд с левым и присваивает результат левому операнду.	с = 5 а = 2 с *= а равносильно: с = с * а. c будет равно 10
/=	Делит левый операнд на правый и присваивает результат левому операнду.	с = 10 а = 2 с /= а равносильно: с = с / а. c будет равно 5
%=	Делит по модулю операнды и присваивает результат левому.	с = 5 а = 2 с %= а равносильно: с = с % а. c будет равно 1
**=	Возводит в левый операнд в степень правого и присваивает результат левому операнду.	с = 3 а = 2 с **= а равносильно: с = с ** а. c будет равно 9
//=	Производит целочисленное деление левого операнда на правый и присваивает результат левому операнду.	с = 11 а = 2 с //= а равносильно: с = с // а. c будет равно 5

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

Побитовые операторы предназначены для работы с данными в битовом (двоичном) формате. Предположим, что у нас есть два числа a = 60; и b = 13. В двоичном формате они будут иметь следующий вид:

Оператор	Описание	Примеры
&	Бинарный "И" оператор, копирует бит в результат только если бит присутствует в обоих операндах.	(a & b) даст нам 12, которое в двоичном формате выглядит так 0000 1100
|	Бинарный "ИЛИ" оператор копирует бит, если тот присутствует в хотя бы в одном операнде.	(a | b) даст нам 61, в двоичном формате 0011 1101
^	Бинарный "Исключительное ИЛИ" оператор копирует бит только если бит присутствует в одном из операндов, но не в обоих сразу.	(a ^ b) даст нам 49, в двоичном формате 0011 0001
~	Бинарный комплиментарный оператор. Является унарным (то есть ему нужен только один операнд) меняет биты на обратные, там где была единица становиться ноль и наоборот.	(~a) даст в результате -61, в двоичном формате выглядит 1100 0011.
<<	Побитовый сдвиг влево. Значение левого операнда "сдвигается" влево на количество бит указанных в правом операнде.	a << 2 в результате даст 240, в двоичном формате 1111 0000
>>	Побитовый сдвиг вправо. Значение левого операнда "сдвигается" вправо на количество бит указанных в правом операнде.	a >> 2 даст 15, в двоичном формате 0000 1111

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

Оператор	Описание	Примеры
and	Логический оператор "И". Условие будет истинным если оба операнда истина.	True and True равно True. True and False равно False. False and True равно False. False and False равно False.
or	Логический оператор "ИЛИ". Если хотя бы один из операндов истинный, то и все выражение будет истинным.	True or True равно True. True or False равно True. False or True равно True. False or False равно False.
not	Логический оператор "НЕ". Изменяет логическое значение операнда на противоположное.	not True равно False. not False равно True.

Операторы членства в Python:

В добавок к перечисленным операторам, в Python присутствуют, так называмые, операторы членства, предназначенные для проверки на наличие элемента в составных типах данных, таких, как строки, списки, кортежи или словари :

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

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

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

В следующей таблице описан приоритет выполнения операторов в Python от наивысшего (выполняется в первую очередь) до наинизшего.

Оператор	Описание
**	Возведение в степень
~ + -	Комплиментарный оператор
* / % //	Умножение, деление, деление по модулю, целочисленное деление.
+ -	Сложение и вычитание.
>> <<	Побитовый сдвиг вправо и побитовый сдвиг влево.
&	Бинарный "И".
^ |	Бинарный "Исключительное ИЛИ" и бинарный "ИЛИ"
<= < > >=	Операторы сравнения
<> == !=	Операторы равенства
= %= /= //= -= += *= **=	Операторы присваивания
is is not	Тождественные операторы
in not in	Операторы членства
not or and	Логические операторы