Операторы Python и их приоритет выполнения. Интерактивный учебник языка Python
- Перевод
В этой части статьи рассматриваются уловки для выбора одного из двух значений на основе логического условия, передача и получение произвольного числа аргументов функций, а также распространенный источник ошибок - тот факт, что дефолтные значения аргументов функции вычисляются только один раз.
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.
Недавно я купил книгу И.В. Петрова «Программируемые контроллеры в автоматических системах». Так как вроде и пишу много в , но всё равно не чувствую себя профи:
Я как-то был на грани того, чтобы сдаться и бросить свой проект. Раньше я искал мотивацию, чтобы заниматься чем-нибудь. Я искал смысл во всех действиях, думал, а какой в конечном счёте мне даст результат? И опять искал мотивацию...
К чему это я, сейчас опять я тупо клацаю по клавиатуре и смотрю в монитор. И я снова написал статью, пишу эти строчки, иногда не зная, почему и зачем, к чему меня приведёт это в конце концов?
Да, у меня появляются трудности, да, у меня много чего не получается. Но нужно бороться с этим.
Знаете, от того чем ты занимаешься, нужно получать кайф, живём всё равно один раз.
Ещё раз о мотивации, посмотрите, что говорит Джордж Карлин по этому поводу, сорри за ненормативную лексику.
С уважением, Гридин Семён
Все ранее рассматриваемые программы имели линейную структуру: все инструкции выполнялись последовательно одна за одной, каждая записанная инструкция обязательно выполняется.
Допустим мы хотим по данному числу x определить его абсолютную величину (модуль). Программа должна напечатать значение переменной x, если x>0 или же величину -x в противном случае. Линейная структура программы нарушается: в зависимости от справедливости условия x>0 должна быть выведена одна или другая величина. Соответствующий фрагмент программы на Питоне имеет вид:
273 x = int(input()) if x > 0: print(x) else: print(-x)
В этой программе используется условная инструкция if (если). После слова if указывается проверяемое условие (x > 0) , завершающееся двоеточием. После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно, в нашем примере это вывод на экран величины x . Затем идет слово else (иначе), также завершающееся двоеточием, и блок инструкций, который будет выполнен, если проверяемое условие неверно, в данном случае будет выведено значение -x .
Итак, условная инструкция в Питоне имеет следующий синтаксис:
If Условие: Блок инструкций 1 else: Блок инструкций 2
Блок инструкций 1 будет выполнен, если Условие истинно. Если Условие ложно, будет выполнен Блок инструкций 2 .
В условной инструкции может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением. Например, если дано число x и мы хотим заменить его на абсолютную величину x , то это можно сделать следующим образом:
273 x = int(input()) if x < 0: x = -x print(x)
В этом примере переменной x будет присвоено значение -x , но только в том случае, когда x<0 . А вот инструкция print(x) будет выполнена всегда, независимо от проверяемого условия.
Для выделения блока инструкций, относящихся к инструкции if или else в языке Питон используются отступы. Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела и не рекомедуется использовать в качестве отступа символ табуляции.
Это одно из существенных отличий синтаксиса Питона от синтаксиса большинства языков, в которых блоки выделяются специальными словами, например, нц... кц в Кумире, begin... end в Паскале или фигурными скобками в Си.
2. Вложенные условные инструкции
Внутри условных инструкций можно использовать любые инструкции языка Питон, в том числе и условную инструкцию. Получаем вложенное ветвление - после одной развилки в ходе исполнения программы появляется другая развилка. При этом вложенные блоки имеют больший размер отступа (например, 8 пробелов). Покажем это на примере программы, которая по данным ненулевым числам x и y определяет, в какой из четвертей координатной плоскости находится точка (x,y):
2 -3 x = int(input()) y = int(input()) if x > 0: if y > 0: # x > 0, y > 0 print("Первая четверть") else: # x > 0, y < 0 print("Четвертая четверть") else: if y > 0: # x < 0, y > 0 print("Вторая четверть") else: # x < 0, y < 0 print("Третья четверть")
В этом примере мы использовали комментарии - текст, который интерпретатор игнорирует. Комментариями в Питоне является символ # и весь текст после этого символа до конца строки.
3. Операторы сравнения
Как правило, в качестве проверяемого условия используется результат вычисления
одного из следующих операторов сравнения:
< Меньше — условие верно, если первый операнд меньше второго.
> Больше — условие верно, если первый операнд больше второго.
<= Меньше или равно.
>= Больше или равно.
== Равенство. Условие верно, если два операнда равны.
!= Неравенство. Условие верно, если два операнда неравны.
Например, условие (x * x < 1000) означает “значение x * x меньше 1000”, а условие (2 * x != y) означает “удвоенное значение переменной x не равно значению переменной y ”.
Операторы сравнения в Питоне можно объединять в цепочки (в отличии от большинства других языков программирования, где для этого нужно использовать логические связки), например, a == b == c или 1 <= x <= 10 .
4. Тип данных bool
Операторы сравнения возвращают значения специального логического типа bool . Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь). Если преобразовать логическое True к типу int , то получится 1, а преобразование False даст 0. При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .
4.1. Логические операторы
Иногда нужно проверить одновременно не одно, а несколько условий. Например, проверить, является ли данное число четным можно при помощи условия (n % 2 == 0) (остаток от деления n на 2 равен 0), а если необходимо проверить, что два данных целых числа n и m являются четными, необходимо проверить справедливость обоих условий: n % 2 == 0 и m % 2 == 0 , для чего их необходимо объединить при помощи оператора and (логическое И): n % 2 == 0 and m % 2 == 0 .
В Питоне существуют стандартные логические операторы: логическое И, логическое ИЛИ, логическое отрицание.
Логическое И является бинарным оператором (то есть оператором с двумя операндами: левым и правым) и имеет вид and . Оператор and возвращает True тогда и только тогда, когда оба его операнда имеют значение True .
Логическое ИЛИ является бинарным оператором и возвращает True тогда и только тогда, когда хотя бы один операнд равен True . Оператор “логическое ИЛИ” имеет вид or .
Логическое НЕ (отрицание) является унарным (то есть с одним операндом) оператором и имеет вид not , за которым следует единственный операнд. Логическое НЕ возвращает True , если операнд равен False и наоборот.
Пример. Проверим, что хотя бы одно из чисел a или b оканчивается на 0:
15 40 a = int(input()) b = int(input()) if a % 10 == 0 or b % 10 == 0: print("YES") else: print("NO")
Проверим, что число a — положительное, а b — неотрицательное:
If a > 0 and not (b < 0):
Или можно вместо not (b < 0) записать (b >= 0) .
5. Каскадные условные инструкции
Пример программы, определяющий четверть координатной плоскости, можно переписать используя “каскадную“ последовательность операцией if... elif... else:
5 7 x = int(input()) y = int(input()) if x > 0 and y > 0: print("Первая четверть") elif x > 0 and y < 0: print("Четвертая четверть") elif y > 0: print("Вторая четверть") else: print("Третья четверть")
В такой конструкции условия if , ..., elif проверяются по очереди, выполняется блок, соответствующий первому из истинных условий. Если все проверяемые условия ложны, то выполняется блок else , если он присутствует.
О ператоры являются конструкциями, которые могут манипулировать значением операндов. Рассмотрим выражение 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
Логические операторы |