Python операторы сравнения. Операторы и выражения на языке Python
О ператоры являются конструкциями, которые могут манипулировать значением операндов. Рассмотрим выражение 4 + 5 = 9. Здесь, 4 и 5 называются операндами и + называется оператором.
Типы операторов
Язык Python поддерживает следующие типы операторов:
- Арифметические операторы
- Сравнение (реляционные) операторы
- Операторы присваивания
- Логические операторы
- Битовые операторы
- Членские операторы
- Операторы идентификации
Давайте рассмотрим все операторы один за другим.
Арифметические операторы в Python
а значение 10, а переменная б содержит значение 21, то:
оператор | Описание | пример |
---|---|---|
+ Сложение | Добавление значений по обе стороны от оператора. | а + b = 31 |
– Вычитание | Вычитание правого операнда из левого операнда. | а – b = -11 |
* Умножение | Умножение значения по обе стороны от оператора | a * b = 210 |
/ Деление | Делит левый операнд на правый операнд | б / а = 2,1 |
% Модуль | Делит левый операнд на правый операнд и возвращает остаток | б % а = 1 |
** Экспонента | Выполняет экспоненциальный расчет на операторах | а ** b = 10 в степени 20 |
// деление с округлением | Отдел пола – Разделение операндов, где результат является фактором, в котором цифра после десятичной запятой удаляется. Но если один из операндов отрицателен, то результат округляется, т.е. округляется от нуля (по отношению к отрицательной бесконечности): | 9 // 2 = 4 и 9,0 // 2,0 = 4,0, -11 // 3 = -4, -11,0 // 3 = -4,0 |
Операторы сравнения в Python
Операторы сравнения значений по обе стороны от них и решить, соотношение между ними. Их также называют реляционные операторы.
Предположим, переменная а содержит значение 10, а переменная б имеет значение 20, то:
оператор | Описание | пример |
---|---|---|
== | Если значения двух операндов равны, то условие становится истинным. | (а == б) не верно. |
!= | Если значения двух операндов не равны, то условие становится истинным. | (а! = б) истинно. |
> | Если значение левого операнда больше значения правого операнда, то условие становится истинным. | (а > б) не верно. |
< | Если значение левого операнда меньше значения правого операнда, то условие становится истинным. | (а < б) истинно. |
> = | Если значение левого операнда больше или равно значению правого операнда, то условие становится истинным. | (а >= б) не верно. |
<= | Если значение левого операнда меньше или равно значению правого операнда, то условие становится истинным. | (а <= б) истинно. |
Операторы присваивания в Python
Предположим, переменная содержит а значение 10, а переменная б имеет значение 20, то:
оператор | Описание | пример |
---|---|---|
= | Назначает значения с правой стороной операндов левой стороне операнда | с = а + b присваивает значение a + b в c |
+ = Добавить и | Добавляет правый операнд к левому операнду и присвоить результат левого операнда | с + = а эквивалентно c = c + a |
– = вычесть и | Вычитает правый операнд из левого операнда и присваивает результат левого операнда | с – = а эквивалентно c = c – a |
* = умножить и | Умножает правый операнд на левый операнд и присваивает результат левого операнда | с * = а эквивалентно c = c * a |
/ = разделить и | Делит левый операнд на правый операнд и присваивает результат левого операнда | с / = а эквивалентно c = c / ac /= a эквивалентно с = с / а |
% = Модуль и | Принимает модуль с помощью двух операндов и присваивает результат левого операнда | c% = а эквивалентно c = c % a |
** = Экспонент и | Выполняет вычисление экспоненту от операторов и присваивает значение левого операнда | с ** = а эквивалентно c = c ** a |
// = Floor Division | Выполняет деление операторов с округлением и присваивает значение левого операнда | с // = а эквивалентно c = c // a |
Битовые операторы в Python
Побитовые операторы работают над битами и выполняют операции бит за битом. Допустим, если а = 60; и б = 13; В настоящее время в двоичном формате они будут выглядить следующим образом:
—————–
а&б = 0000 1100
а|б = 0011 1101
а^б = 0011 0001
Встроенная функция bin() в Python может быть использована для получения двоичного представления целого числа.
Следующие Битовые операторы поддерживаются языком Python:
Оператор | Описание | Пример |
---|---|---|
& бинарный И | копии оператора бита, в результате, если они существует в обоих операндах | (а & б) (0000 означает 1100) |
| бинарный ИЛИ | копирует бит, если он существует в любом из операндов. | (а | б) = 61 (означает 0011 1101) |
^ бинарный Исключающий или | копирует бит, если он установлен в одном операнде, но не в обоих. | (а ^ б) = 49 (означает 0011 0001) |
~ Бинарным комплемент | Это унарное и имеет эффект бит «листать». | (~ а) = -61 (в форме означает двойной комплемент 1100 0011 из-за подписанного двоичного числа. |
<< Двоичный сдвиг влево | Значение левого операнда перемещается влево на число битов, заданное правым операндом. | а << = 240 (1111 означает 0000) |
>> Двоичный сдвиг вправо | Значение левого операнда перемещается вправо на число битов, заданное правым операндом. | а >> = 15 (0000 означает 1111) |
Логические операторы в Python
Следующие логические операторы поддерживаются языком Python. Предположим, переменная справедлива и переменная б имеет значение False, то:
Членские Операторы в Python
Статус операторов тестирования на членство в последовательности, такие как строки, списки или кортежи. Есть два членских операторов, как объяснено ниже:
Операторы идентификации в Python
Операторы идентификации сравнивают ячейки памяти двух объектов. Есть два оператора идентификации как объяснено ниже:
Операторы приоритетов в Python
В следующей таблице перечислены все операторы от наивысшего приоритета к самому низкому.
Порядковый номер | Оператор & Описание | |
---|---|---|
1 | **
Возведение в степень (повышение мощности) |
|
2 | ~ + –
Дополнение, унарный плюс и минус (имена методов для двух последних являются + @ и – @) |
|
3 | * / % //
Умножение, деление по модулю и остаток от деления |
|
4 | + –
Сложение и вычитание |
|
5 | >> <<
Правый и левый побитовый сдвиг |
|
6 | &
Побитовое «И» | |
7 | ^ |
Побитовое исключающее “ИЛИ и регулярное ИЛИ” |
|
8 | <= <>> =
операторы сравнения |
|
9 | <> ==! =
операторы равенства |
|
10 | = %= /= //= -= += *= **=
операторы присваивания |
|
11 | is not
операторы идентификации |
|
12 | in not in
операторы членства |
|
13 | not или and
Логические операторы |
Логический тип данных (или 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 баллов, первое условие будет ложно, потому программа выдаст.
Оператор | Описание | Примеры |
---|---|---|
+ | Сложение - Суммирует значения слева и справа от оператора |
15 + 5 в результате будет 20 |
- | Вычитание - Вычитает правый операнд из левого | 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 |
-= | Отнимает значение правого операнда от левого и присваивает результат левому операнду. |
с = 5 |
*= | Умножает правый операнд с левым и присваивает результат левому операнду. |
с = 5 |
/= | Делит левый операнд на правый и присваивает результат левому операнду. | с = 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. |
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 | Логические операторы |
Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 3 и 5 больше 7, вы согласитесь, скажете: «Да, это правда». Если же кто-то будет утверждать, что сумма трех и пяти меньше семи, то вы расцените такое утверждение как ложное.
Подобные фразы предполагают только два возможных ответа – либо "да", когда выражение оценивается как правда, истина, либо "нет", когда утверждение оценивается как ошибочное, ложное. В программировании и математике если результатом вычисления выражения может быть лишь истина или ложь, то такое выражение называется логическим .
Например, выражение 4 > 5 является логическим, так как его результатом является либо правда, либо ложь. Выражение 4 + 5 не является логическим, так как результатом его выполнения является число.
На позапрошлом уроке мы познакомились с тремя типами данных – целыми и вещественными числами, а также строками. Сегодня введем четвертый – логический тип данных (тип bool). Его также называют булевым. У этого типа всего два возможных значения: True (правда) и False (ложь).
>>>
a =
True
>>>
type
(a)
Здесь переменной 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.
26 10.2017
Для взаимодействия с определёнными числами или функциями требуются какие-то операции. Допустим, сложение, вычитание, умножение, деление. Например арифметический корень и возведение в степень. Операторы python имеют важное значение. Без них не было бы программы. И для того, чтобы перечислить все существующие операторы, выделен целый раздел.
Из этой статьи вы узнаете:
Всем привет, читатели, гости и друзья, с вами Гридин Семён. Недавно я проводил небольшой анонимный опрос среди своих подписчиков. В базе у меня подписалось 35 человек. Письма прочитали лишь половина, ответили на опрос всего три человека. Но знаете, для меня это очень большой результат. Приятно, когда всё-таки не стоишь на одном месте.
У меня на самом деле очень много идей и мыслей по развитию блога. Я уже давно запланировал открыть раздел по самоделкам на базе ПЛК, и Raspberry PI. Я хочу размещать на сайте не только свои проекты. Но также и проекты других авторов, определённо за денежное вознаграждение и прямую ссылку в соц. сетях.
Открою ещё вот такие разделы:
- Новости в области робототехники;
- Квадрокоптеры;
- Библиотеки;
- Механика роботов;
Конкурсы, конкурсы... Все любят призы, бонусы и подарки. Я тоже люблю, правда я пока не разу не участвовал нигде. Ещё не выпадал такой случай. Обязательно организую конкурсы.
С 1 пунктом всё никак не удаётся справиться. Написание качественных статей требует время. Пока не удаётся всё оптимизировать и укладываться вовремя.
Разносторонних тем по на самом деле много. Тема очень многогранная и обширная. Потихоньку будем охватывать. И разбирать практические примеры. Я в большей степени практик.
Знаете, очень приятно, что мой ресурс не бесполезен. Очень приятное ощущение от того, что ты принёс кому-то пользу. Это очень мотивирует работать над сайтом и двигаться дальше. Спасибо и вам друзья. Я стараюсь так, чтобы сайт был актуален на несколько лет вперёд.
Что такое оператор?
Под операторами понимаются какие-то особые отображения и действия с числами или ставящее в соответствие функции другую функцию. Говоря простым языком в выражении 4+5 =9. Цифры называются операндами, а «+» и «=» операторами. Ну вообщем как-то так.
В языке их несколько типов. Ну как и в другом любом языке.
- арифметические операторы (arithmetic operators);
- операторы сравнения (comparison или relational operators);
- операторы присваивания (assignment operators);
- логические операторы (logical operators);
- битовые операторы (bitwise operators);
- операторы принадлежности (membership operators);
- операторы тождественности (identity operators).
Арифметические операторы
Оператор | Описание | Примеры |
---|---|---|
+ | Сложение — Суммирует значения слева и справа от оператора | 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 |
Операторы сравнения
Оператор | Описание | Примеры |
---|---|---|
== | Проверяет равны ли оба операнда. Если да, то условие становится истинным. | 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. |
Операторы присваивания
Оператор | Описание | Примеры |
---|---|---|
= | Присваивает значение правого операнда левому. | 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 |
Побитовые операторы
Для тех кто не изучал курсы информатики. Представим что у нас есть два числа a=60 и b=13. В двоичной системе они будут выглядеть следующим образом a=0011 1100 и b=0000 1101.
Что можно делать с ними в итоге?
Оператор | Описание | Примеры |
---|---|---|
& | Бинарный «И» оператор, копирует бит в результат только если бит присутствует в обоих операндах. | (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 |
Логические операторы
Операторы членства
Эти операторы необходимы для проверки отдельных элементов в составных (строки, кортежи, списки и словари)
Операторы тождественности
Приоритет операторов
Оператор | Описание |
---|---|
** | Возведение в степень |
~ + — | Комплиментарный оператор |
* / % // | Умножение, деление, деление по модулю, целочисленное деление. |
+ — | Сложение и вычитание. |
>> << | Побитовый сдвиг вправо и побитовый сдвиг влево. |
& | Бинарный «И». |
^ | | Бинарный «Исключительное ИЛИ» и бинарный «ИЛИ» |
<= < > >= | Операторы сравнения |
<> == != | Операторы равенства |
= %= /= //= -= += *= **= | Операторы присваивания |
is is not | Тождественные операторы |
in not in | Операторы членства |
not or and | Логические операторы |
Вот такой вот небольшой списочек операторов. Пускай эта страница будет вам заметкой при программировании на языке Python.
Недавно я купил книгу И.В. Петрова «Программируемые контроллеры в автоматических системах». Так как вроде и пишу много в , но всё равно не чувствую себя профи:
Я как-то был на грани того, чтобы сдаться и бросить свой проект. Раньше я искал мотивацию, чтобы заниматься чем-нибудь. Я искал смысл во всех действиях, думал, а какой в конечном счёте мне даст результат? И опять искал мотивацию...
К чему это я, сейчас опять я тупо клацаю по клавиатуре и смотрю в монитор. И я снова написал статью, пишу эти строчки, иногда не зная, почему и зачем, к чему меня приведёт это в конце концов?
Да, у меня появляются трудности, да, у меня много чего не получается. Но нужно бороться с этим.
Знаете, от того чем ты занимаешься, нужно получать кайф, живём всё равно один раз.
Ещё раз о мотивации, посмотрите, что говорит Джордж Карлин по этому поводу, сорри за ненормативную лексику.
С уважением, Гридин Семён