Python операции сравнения. Операторы и выражения на языке Python
Оператор | Описание | Примеры |
---|---|---|
+ | Сложение - Суммирует значения слева и справа от оператора |
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 | Логические операторы |
О ператоры являются конструкциями, которые могут манипулировать значением операндов. Рассмотрим выражение 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
Логические операторы |
- Перевод
В этой части статьи рассматриваются уловки для выбора одного из двух значений на основе логического условия, передача и получение произвольного числа аргументов функций, а также распространенный источник ошибок - тот факт, что дефолтные значения аргументов функции вычисляются только один раз.
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)".
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.
Недавно я купил книгу И.В. Петрова «Программируемые контроллеры в автоматических системах». Так как вроде и пишу много в , но всё равно не чувствую себя профи:
Я как-то был на грани того, чтобы сдаться и бросить свой проект. Раньше я искал мотивацию, чтобы заниматься чем-нибудь. Я искал смысл во всех действиях, думал, а какой в конечном счёте мне даст результат? И опять искал мотивацию...
К чему это я, сейчас опять я тупо клацаю по клавиатуре и смотрю в монитор. И я снова написал статью, пишу эти строчки, иногда не зная, почему и зачем, к чему меня приведёт это в конце концов?
Да, у меня появляются трудности, да, у меня много чего не получается. Но нужно бороться с этим.
Знаете, от того чем ты занимаешься, нужно получать кайф, живём всё равно один раз.
Ещё раз о мотивации, посмотрите, что говорит Джордж Карлин по этому поводу, сорри за ненормативную лексику.
С уважением, Гридин Семён
Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 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.