Операторы и выражения на языке Python. Логические операторы в Python

Логический тип данных (или Boolean) – это примитивный тип, который принимает одно из двух возможных значений: истину (True) или ложь (False). Этот тип используется во многих языках программирования для построения алгоритмов и управления поведением программ.

Примечание : Название этого типа данных (Boolean) всегда пишется с заглавной буквы, поскольку он назван в честь математика Джорджа Буля, который занимался исследованиями математической логики. Значения True и False тоже пишутся с большой буквы – в Python они являются специальными значениями.

Данное руководство ознакомит вас с основами булевой логики в Python: операторами сравнения, логическими операторами, таблицами истинности и т.п.

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

В программировании операторы сравнения используются при оценке и сравнении значений для последующего сведения их к одному логическому значению (True или False).

Операторы сравнения Python 3 представлены в этой таблице:

Оператор	Значение
==	Проверяет равенство между компонентами; условие истинно, если компоненты равны.
!=	Проверяет равенство между компонентами; условие истинно, если компоненты НЕ равны.
<	Оценивает значение левого компонента; условие истинно, если он меньше, чем правый.
>	Оценивает значение левого компонента; условие истинно, если он больше, чем правый.
<=	Оценивает значение левого компонента; условие истинно, если он меньше или равен правому компоненту.
>=	Оценивает значение левого компонента; условие истинно, если он больше или равен правому компоненту.

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

Теперь сравните значения переменных с помощью вышеперечисленных операторов.

x = 5
y = 8
print("x == y:", x == y)
print("x != y:", x != y)
print("x < y:", x < y)
print("x > y:", x > y)
print("x <= y:", x <= y)
print("x >= y:", x >= y)
x == y: False
x != y: True
x < y: True
x > y: False
x <= y: True
x >= y: False

Следуя математической логике, Python оценивает соотношения между значениями переменных так:

• 5 равно 8? Ложь
• 5 не равно 8? Истина
• 5 меньше 8? Истина
• 5 больше 8? Ложь
• 5 меньше или равно 8? Истина
• 5 больше или равно 8? Ложь

Также операторы сравнения можно применять к числам с плавающей точкой и строкам.

Примечание : Строки чувствительны к регистру; чтобы отключить такое поведение, нужно использовать специальный метод.

Попробуйте сравнить две строки:

Hello = "Hello"
hello = "hello"

Hello == hello: False

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

Hello = "Hello"
hello = "hello"
Hello_there = "Hello"
print("Hello == hello: ", Hello == hello)
print("Hello == Hello_there", Hello == Hello_there)
Hello == hello: False
Hello == Hello_there: True

Также для сравнения строк можно использовать операторы > и <. Python выполнит лексикографическое сравнение строк на основе значений символов ASCII.

Операторы сравнения можно применять к логическим значениям True и False:

t = True
f = False
print("t != f: ", t != f)
t != f: True

Обратите внимание на разницу между операторами = и ==.

x = y # Оператор присваивания. Устанавливает равенство между x и y (то есть присваивает x значение y).
x == y # Оператор сравнения. Проверяет равенство между x и y и оценивает выражение как истинное или ложное. Выражение истинно, если x и y равны.

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

Для сравнения значений используется три логических оператора, которые сводят результат к логическому значению True или False.

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

• сдал ли студент экзамен
• и зарегистрирован ли он.

Если оба значения истинны, студент будет переведён на следующий курс.

Другой пример: программа с логическими операторами может проверять активность пользователя в онлайн-магазине:

• использовал ли он кредит магазина
• или заказывал ли он товары в течение последних 6 месяцев.

Для примера попробуйте сравнить три выражения:

print((9 > 7) and (2 < 4)) # Оба выражения истинны (True)
print((8 == 8) or (6 != 6)) # Одно из выражений истинно (True)
print(not(3 <= 1)) # Выражение ложно (False)
True
True
True

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

Во втором случае истинно только значение 8 == 8. Поскольку хотя бы одно из предложенных условий истинно, оператор or возвращает True. Оператор and в таком случае выдал бы False.

В третьем случае выражение 3 <= 1 ложно. Оператор not изменяет полученное логическое значение на противоположное: not False = True.

Теперь попробуйте сравнить числа с плавающей точкой.

print((-0.2 > 1.4) and (0.8 < 3.1)) # Одно из выражений ложно (False)
print((7.5 == 8.9) or (9.2 != 9.2)) # Оба выражения ложны (False)
print(not(-5.7 <= 0.3)) # Выражение истинно (True)

• Поскольку в первом примере одно из выражений ложно, and вернёт False. Оператор and оценивает выражение как истинное только тогда, когда оба компонента истинны.
• Поскольку оба выражения ложны, оператор or выдаст False.
• Поскольку выражение истинно, оператор not вернёт False (not True = False).

Примечание : Если вы не понимаете, как это работает, вам помогут разобраться таблицы истинности. Эту тему мы рассмотрим далее в этом руководстве.

Логические операторы можно объединять в составные выражения:

not((-0.2 > 1.4) and ((0.8 < 3.1) or (0.1 == 0.1)))

Выражение (0.8 < 3.1) or (0.1 == 0.1) истинно, поскольку оба математических выражения, из которых оно состоит, истинны. Оператор or вернёт True.

Полученное значение True становится компонентом следующего выражения: (-0.2 > 1.4) and (True). Оператор and выдаст False, потому что выражение -0.2 > 1.4 ложно. (False) and (True) = False.

Таблицы истинности

Математическая логика – очень полезная в программировании область знаний. В данном руководстве мы ознакомимся с основными её аспектами.

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

Таблица истинности оператора ==

Таблица истинности оператора AND

Таблица истинности оператора OR

Таблица истинности оператора NOT

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

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

Для управления результатом и потоками данных программы можно использовать условные операторы (condition) с выражениями (clause).

Условные операторы оценивают значение как истинное или ложное.

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

Ниже приведён блок кода, который показывает, как объединить условные операторы для управления потоком программы Python.

if grade >= 65: # условие
print("Passing grade") # выражение
else:
print("Failing grade")

Эта программа оценивает результат каждого студента и определяет, сдал он экзамен или нет. К примеру, если студент набрал 83, первое условие будет иметь значение True, и программа выведет на экран строку:

Если же студент набрал 59 баллов, первое условие будет ложно, потому программа выдаст.

У каждой операции есть свои операторы. В унарных и бинарных операциях применяются базовые операторы (сложение, вычитание, отрицание, унарный плюс, унарный минус, присваивание). Тернарный имеет три аргумента: условие 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 как отрицательное число, значения списка передаются в обратном порядке с конца к началу.

Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 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.

Оператор	Описание	Примеры
+	Сложение - Суммирует значения слева и справа от оператора	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	Логические операторы

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 =