Б ольшинство строк программного кода представляют собой выражения. Например: 1 + 2 — это выражение. Выражение состоит из 2 частей:
Операторы сравнения
Для проверки истинности данного условия, используется логический тип. Когда мы выполним данное выражение, в результате нам вернется True (истина) или False (ложь).
В данном примере мы используем один из операторов сравнения — «==» (равно). Всего в Python таких операторов 6:
Логические операторы
Арифметические операторы
Арифметические операторы в Python производят арифметические операции над числами (сложение, вычитание, деление и т.д.);
Операторы присваивания
Операторы присваивания в Python работаю вполне очевидно — значение находящееся справа присваивается переменной, находящейся слева. Существует несколько разновидностей операторов присваивания:
Python поддерживает не только обычное присваивание правого операнда левому, но и множественное присваивание.
С помощью такого присваивания можно поменять значения переменных между собой:
>>> a = 1 >>> b = 2 >>> a, b = b, a >>> print(a, b) 2 1
Также с помощью множественного присваивания можно «распаковывать» строки (str), списки (list), кортежи (tuple) и словари (dict).
Распаковка особенно удобна, когда функция возвращает несколько значений в виде кортежа (tuple):
>>> def test_page(): return 404, «Not found» >>> code, message = test_page() >>> print(code, message) 404 Not found
Главное условие распаковки – количество элементов должно совпадать
Если необходимо распаковать лишь несколько элементов, воспользуйтесь переменной со знаком » * «:
>>> text = «deactivate» >>> first, second, *other_letters = text >>> print(first, second, other_letters) d e [‘a’, ‘c’, ‘t’, ‘i’, ‘v’, ‘a’, ‘t’, ‘e’]
Побитовые операторы
Операторы членства
В Python существует всего 2 оператора принадлежности — in и not in и предназначены они для проверки наличия элемента в строке (str), списке (list), словаре (dict) или кортеже (tuple).
Операторы тождественности
Данные операторы сравнивают размещение двух объектов в памяти.
Приоритет операторов
Таблица приоритетов операторов в Python показана ниже.
Элементы отсортированы по убыванию, с высокого приоритета к более низкому. В комбинациях с несколькими операторами, оператор с большим приоритетом выполняется первым.
Хотя операторы отношения (сравнения) могут использоваться для проверки того, является ли конкретное условие истинным или ложным, они могут проверять только одно условие за раз. Но часто нам нужно знать, выполняются ли одновременно несколько условий. Например, чтобы проверить, выиграли ли мы в лотерею, мы должны сравнить, все ли выбранные нами числа совпадают с выигрышными числами. В лотерее с 6 числами это будет включать 6 сравнений, и все они должны быть верными. В других случаях нам нужно знать, выполняется ли какое-либо из нескольких условий. Например, мы можем решить пропустить работу сегодня, если мы заболели, или если мы слишком устали, или если мы выиграли в лотерею в нашем предыдущем примере. Это потребует проверки того, верно ли какое-либо из трех сравнений.
Возможность тестирования несколько условий нам дают логические операторы.
В C++ есть 3 логических оператора:
Логическое НЕ (NOT)
Вы уже сталкивались с унарным оператором логического НЕ в уроке «4.9 – Логические (булевы) значения». Мы можем резюмировать эффекты логического НЕ следующим образом:
Логическое НЕ часто используется в условных выражениях:
Следует остерегаться того, что логическое НЕ имеет очень высокий уровень приоритета. Начинающие программисты часто делают следующую ошибку:
Эта программа напечатает:
Правильный способ написать приведенный выше фрагмент:
Лучшая практика
Если логическое НЕ предназначено для работы с результатом других операторов, другие операторы и их операнды должны быть заключены в круглые скобки.
Логическое ИЛИ (OR)
Логическое ИЛИ (оператор || )
Левый операнд
Правый операнд
Результат
false
false
false
false
true
true
true
false
true
true
true
true
Например, рассмотрим следующую программу:
Вы можете связать вместе множество операторов логического ИЛИ:
Начинающие программисты иногда путают оператор логическое ИЛИ ( || ) с оператором побитовое ИЛИ ( | ) (который будет рассмотрен позже). Несмотря на то, что у них обоих в названии есть «ИЛИ», они выполняют разные функции. Их смешивание, вероятно, приведет к неверным результатам.
Логическое И (AND)
Логическое И (оператор && )
Левый операнд
Правый операнд
Результат
false
false
false
false
true
false
true
false
false
true
true
true
Как и в случае с логическим ИЛИ, вы можете связать вместе множество операторов логическое И:
Вычисление по короткой схеме
Вычисление по короткой схеме дает еще одну возможность показать, почему операторы, вызывающие побочные эффекты, не должны использоваться в составных выражениях. Рассмотрим следующий фрагмент:
Если x не равно 1, всё условие должно быть ложным, поэтому ++y никогда не вычисляется! Таким образом, y будет инкрементироваться только в том случае, если x равен 1, что, вероятно, не совсем то, что задумывал программист!
Предупреждение
Вычисление по короткой схеме может привести к тому, что логическое ИЛИ и логическое И не будут вычислять один операнд. Избегайте использования выражений с побочными эффектами в выражениях с этими операторами.
Как и в случае с логическим и побитовым ИЛИ, начинающие программисты иногда путают оператор логическое И ( && ) с оператором побитовое И ( & ).
Смешивание И и ИЛИ
Смешивания операторов логическое И и логическое ИЛИ в одном выражении часто невозможно избежать, но это область, полная потенциальных опасностей.
Многие программисты предполагают, что логическое И и логическое ИЛИ имеют одинаковый приоритет (или забывают, что это не так), точно так же, как сложение/вычитание и умножение/деление. Однако логическое И имеет более высокий приоритет, чем логическое ИЛИ, поэтому операторы логическое И будут вычисляться перед операторами логическое ИЛИ (если они не заключены в скобки).
Лучшая практика
При смешивании логического И и логического ИЛИ в одном выражении явно заключите каждую операцию в скобки, чтобы убедиться, что они вычисляются так, как вы хотите.
Закон де Моргана
Закон де Моргана говорит нам, как логическое НЕ должно распределяться в этих случаях:
Другими словами, когда вы распределяете логическое НЕ, вам также необходимо преобразовать логическое И в логическое ИЛИ, и наоборот!
Иногда это может быть полезно при попытке упростить чтение сложных выражений.
Где логический оператор исключающее ИЛИ (XOR)?
Логический оператор исключающее ИЛИ (XOR) – это логический оператор, представленный на некоторых языках, который используется для проверки истинности нечетного числа условий.
Логическое исключающее ИЛИ
Левый операнд
Правый операнд
Результат
false
false
false
false
true
true
true
false
true
true
true
false
Это выражение можно расширить до нескольких операндов следующим образом:
Обратите внимание, что приведенные выше шаблоны логического исключающего ИЛИ работают только в том случае, если операнды являются логического типа (не целочисленными значениями). Если вам нужна форма логического исключающего ИЛИ, которая работает с не-логическими операндами, вы можете использовать static_cast для преобразования их в bool :
Небольшой тест
Вопрос 1
Вычислите следующие выражения.
Примечание: в ответах мы «объясняем нашу работу», показывая вам шаги, предпринятые для получения окончательного ответа. Шаги разделены символом →. Выражения, которые были проигнорированы из-за правила вычисления по короткой схеме, помещены в квадратные скобки. Например,
Операторы * и ** в Питоне. Что это и как использовать
Операторы (operators) * и ** встречаются в питоне очень часто. Иногда они немного непонятны и новичкам, и опытным ребятам, переходящим на питон с ряда других языков программирования (в которых операторы могут использоваться немного иначе). Статья известного питон-коуча Трея Ханнера (Trey Hunner), который помогает девелоперам расширять свои знания. Дата написания статьи: 10.11.2018.
Функционал операторов * и ** развивается уже много лет. Я хочу рассмотреть все способы их использования по состоянию на текущий момент. Буду указывать, что конкретно работает только в современных версиях питона. Поэтому, если вы изучали операторы * и ** еще во времена питона 2 (Python 2), советую хотя бы проглядеть данную статью, потому что в питоне 3 (Python 3) этим операторам добавили много новых возможностей.
Если вы начали изучать питон недавно и еще не освоили аргументы ключевых слов (keyword arguments; также известные как именованные аргументы, named arguments), предлагаю сперва прочитать мою статью про аргументы ключевых слов в питоне.
Что мы обсуждать не будем
В данной статье, говоря про операторы * и **, я имею в виду операторы-префиксы (prefix operators), а не инфиксы (infix). То есть, функции умножения и возведения в степень не входят в тему статьи.
Тогда про что же мы говорим
Мы говорим про операторы-префиксы * и **, которые используются перед переменной (variable). Например:
В данном коде можно увидеть два способа использования оператора *. Оператор ** отсутствует.
В сферу применения рассматриваемых операторов входит: 1. Операторы * и **: передача аргументов в функцию. 2. Операторы * и **: захват аргументов, переданных в функцию. 3. Оператор *: принятие аргументов, содержащих только ключевые слова. 4. Оператор *: захват элементов во время распаковки кортежа (tuple). 5. Оператор *: распаковка итерируемых объектов в списке или кортеже. 6. Оператор **: + распаковка словарей в других словарях.
Даже если вам кажется, что вы освоили все эти способы, позволяющие использовать операторы * и **, рекомендую посмотреть на все нижеприведенные блоки кода, чтобы убедиться, что они все вам знакомы. Последние несколько лет разработчики ядра питона продолжают добавлять этим операторам новые возможности, поэтому какие-то из новых применений можно проглядеть.
Операторы * и ** при распаковке во время вызова функции
При вызове функции оператор * можно задействовать для распаковки итерируемого объекта в аргументах, введенных для вызова:
В строке print(*fruits) производится вызов всех элементов списка fruits в функции print. Они становятся отдельными аргументами. При этом нам даже не надо знать, сколько всего аргументов окажется в списке.
В данном примере оператор * – не просто синтактический выверт (syntactic sugar). Без * отправить все элементы конкретного итерируемого объекта в качестве отдельных аргументов было бы невозможно (это не касается списков с сфиксированной длиной).
В данном случае мы принимаем список со списками в качестве элементов и возвращаем «преобразованный» список со списками:
Функционал оператора ** примерно такой же, просто он применяется к аргументам ключевых слов. Он позволяет нам взять словарь, содержащий пары из ключей и значений, и распаковать его в аргументы ключевых слов при вызове функции.
Скажу из своего опыта. Оператор ** не часто используется для распаковки аргументов ключевых слов при вызове функции. Чаще всего я вижу такие примеры при работе с наследованием: вызовы super() часто включают в себя оба оператора.
Операторы * и ** можно использовать неоднократно при вызове функции. Данная возможность появилась в питоне 3.5. Иногда это может оказаться очень уместным:
Неоднократное использование ** выглядит примерно так же:
Однако не нужно терять бдительности при неоднократном использовании операторов * и **. Неоднократное указание одного и того же аргумента ключевых слов не допускается в функциях питона. Поэтому, если использовать ** для словарей, то ключи должны быть уникальными. В противном случае возникнет исключение.
Операторы * и ** при упаковке аргументов, переданных функции
При определении тела функции можно использовать оператор *, чтобы захватывать неограниченное количество позиционных аргументов, переданных этой функции. Они оформляются в кортеж.
Данная функция принимает любое количество аргументов.
Функции питона print и zip принимают любое количество позиционных аргументов. Такое использование оператора * при упаковке аргументов позволяет нам создавать свои функции, которые (аналогично print и zip) принимают любое количество аргументов.
Кроме того, для оператора ** в данном вопросе предусмотрена еще одна возможность: его можно использовать при определении тела функции, позволяющей захватить в словарь любые аргументы ключевых слов, переданные этой функции:
В данном месте ** захватывает в словарь аргументы ключевых слов, которые мы передаем данной функции. Впоследствии аргументы атрибутов (attributes) данной функции смогут на него ссылаться.
Позиционные аргументы, содержащие аргументы только из ключевых слов
питон 3 ввел специальный синтаксис для передачи аргументов, содержащих только ключевые слова, в функцию. Они представляют собой такие аргументы функции, которые можно определить только с помощью синтаксиса для ключевых слов. Это означает, что их нельзя определить позиционно.
Чтобы принимать аргументы, содержащие только ключевые слова, мы можем поместить именованные аргументы после оператора * при определении тела функции:
Данную функцию можно использовать так:
Аргументы dictionary и default поставлены после *keys. То есть, их можно только в качестве аргументов ключевых слов. Если мы попытаемся определить их позиционно, то увидим ошибку:
Данное поведение внедрено в питон с помощью предложения PEP 3102.
Аргументы, содержащие только ключевые слова и не содержащие позиционные аргументы
Аргументы, содержащие только ключевые слова, – неплохое средство. Но что если вы хотите требовать ввода аргументов, содержащих только ключевые слова, не захватывая неограниченное количество позиционных аргументов?
питон позволяет сделать это с помощью немного странного синтаксиса, когда оператор * как бы сам по себе:
Данная функция принимает аргумент, содержащий итерируемый объект (iterable). Его можно определить позиционно (то есть, первым) или с помощью названия и аргумента fillvalue, который входит в число аргументов, допускающих только ключевые слова. Это означает, что мы можем вызвать функцию with_previous вот так:
Данная функция принимает два аргумента. Один из них, fillvalue, обязательно определяется как аргумент, содержащий ключевое слово.
Обычно я использую аргументы, допускающие только ключевые слова, при захвате неопределенного количества позиционных аргументов. Но иногда я использую данную возможность оператора *, чтобы форсировать исключительно позиционное определение аргумента.
На самом деле, данный подход используется встроенной функцией питона sorted. Если посмотреть справку для sorted, можно увидеть следующее:
Пример использования оператора * как самого по себе прямо в документации по аргументам функции sorted.
Операторы * и ** при распаковке кортежа
Дополнительно к вышенаписанному, в питоне 3 добавлен новый способ применения *, который некоторым образом связан с вышеописанными возможностями этого оператора при определении тела функции и при вызове функции.
Оператор * теперь можно использовать при распаковке кортежа:
Если вы задаете себе вопрос: как же мне использовать это в своем коде, посмотрите примеры в моей статье про распаковку кортежей в питоне. В этой статье я показал, каким образом такое использование оператора * может, в некоторых случаях, стать альтернативой для срезания последовательностей (sequence slicing).
Обычно во время своих лекций об операторе * я говорю, что можно использовать только одно выражение с ним в отдельном вызове многократного присвоения (multiple assignment). Технически это некорректно, потому что можно его использовать два раза при вложенной распаковке (nested unpacking). Данный вопрос я рассмотрел подробно в статье про распаковку кортежей.
Правда, я никогда не встречал хорошего примера такого использования. Не думаю, что стал бы его рекомендовать, даже если бы удалось найти. Он выглядит немного непонятно.
Данная возможность добавлена в питон на основе предложения PEP 3132. Следует отметить, что оно не относится к очень длинным.
Операторы * и ** в литерале списка
В питоне 3.5 добавлено очень много возможностей, связанных с оператором *, на основе предложения PEP 448. Одной из самых заметных новых возможностей стало использование * для вывода итерируемого объекта в новый список.
Допустим, у вас есть функция, которая принимает любые последовательности и возвращает список, содержащий каскад из последовательности и ее реверсивного варианта:
Данная функция должна пару раз провести конвертацию в список, чтобы объединить списки и вернуть результат. Начиная с питона 3.5, мы можем, вместо вышеприведенного примера, написать следующее:
В данном коде больше нет нескольких ненужных вызовов списков. Поэтому он стал эффективнее и лучше читается.
Данная функция возвращает новый список, в котором первый элемент переданного списка (или другой последовательности) перенесен в конец нового списка.
Это очень удачная возможность, позволяющая с помощью оператора * объединять итерируемые объекты различных типов. Оператор * работает с любыми итерируемыми объектами, а оператор + работает только с определенными последовательностями, при чем все из объединяемых должны быть одного типа.
Отмечу, что данная возможность не ограничивается только созданием списков. Мы можем выводить итерируемые объекты в новые кортежи или множества (set):
Обратите внимание, что последняя строка принимает список и генератор (generator), а потом выводит их в новое множество. Перед появлением этой возможности для оператора * было непросто сделать это в одну строку кода. Разумеется, способ сделать это существовал, но его было непросто вспомнить или обнаружить:
Оператор ** в литерале словаря
Помимо вышеприведенного на основе предложения PEP 448 в функционал ** добавлен вывод пар ключ/значение (key/value) из словаря в новый словарь:
Про это я написал еще одну статью. Сейчас ее можно найти под новым названием про идиоматический способ сливать словари в питоне. Данную возможность можно использовать не только для сливания двух словарей. Например, можно скопировать словарь, параллельно добавляя в него новые значения:
Еще можно скопировать или слить словари, переписывая определенные значения:
Операторы * и ** обладают немалыми возможностями в питоне
В питоне операторы * и ** – не просто синтактический выверт. Некоторые из их возможностей реализуются и другими средствами, но доступные альтернативы обычно более громоздкие и потребляют больше ресурсов. Кроме того, некоторые элементы в функционале этих операторов попросту не доступны без их использования. Например, без помощи * невозможно передать в функцию неопределенное количество позиционных аргументов.
Прочитав обо всех возможностях * и **, вы, возможно, удивитесь названиям, под которыми используются эти странные операторы. К сожалению, для них нет лаконичных названий. Я слышал, как * называли оператором для упаковки и распаковки. Еще слышал, как его называли «splat» (это из мира Руби) и просто звездой.
Чаще всего я называю их звездой (star) и двойной звездой (double star) (или звездой-звездой (star star)). В данном случае разделения с их функциями как инфиксов не проводится (речь идет про операции умножения и возведения в степень). Но обычно из контекста очевидно, о чем идет речь, про префиксы или инфиксы.
Если вы не понимаете операторы * и ** или боитесь не запомнить все их возможности, не нужно беспокоиться. Способов использования много, и запоминать каждую конкретную возможность для каждого из них не так важно. Лучше будет осознать, в каких случаях к ним можно обратиться. Предлагать использовать данную статью как чек-лист или создать свой чек-лист, который поможет вам использовать операторы * и ** в питоне.
Операторы – это столпы программы, на которых построена логика на конкретном языке программирования. Python предоставляет множество операторов, которые описаны ниже.
Что такое операторы в Python?
Оператор в Python – это символ, который отвечает за конкретную операцию между двумя операндами.
Арифметические операторы
Рассмотрим следующую таблицу для подробного объяснения арифметических операторов.
Оператор
Описание
+(Сложение)
Он используется для добавления двух операндов. Например, если a = 20, b = 10 => a + b = 30
-(Вычитание)
Он используется для вычитания второго операнда из первого операнда. Если первый операнд меньше второго, значение будет отрицательным. Например, если a = 20, b = 10 => a – b = 10
/(деление)
Он возвращает частное после деления первого операнда на второй операнд. Например, если a = 20, b = 10 => a / b = 2,0
*(Умножение)
Он используется для умножения одного операнда на другой. Например, если a = 20, b = 10 => a * b = 200
%(Остаток от деления)
Он возвращает напоминание после деления первого операнда на второй операнд. Например, если a = 20, b = 10 => a% b = 0
**(возведение в степень)
Это экспоненциальный оператор, представленный при вычислении степени первого операнда для второго операнда.
//(целочисленное деление)
Он дает минимальное значение частного, полученного при делении двух операндов.
Оператор сравнения
Операторы сравнения используются для сравнения значений двух операндов и соответственно возвращают логическое значение true или false. Операторы сравнения описаны в следующей таблице.
Оператор
Описание
==
Если значения двух операндов равны, то условие становится истинным.
!=
Если значения двух операндов не равны, условие становится истинным.
=
Если первый операнд больше или равен второму операнду, то условие становится истинным.
>
Если первый операнд больше второго операнда, то условие становится истинным.
> (сдвиг вправо)
Левый операнд перемещается вправо на количество битов, присутствующих в правом операнде.
Операторы присваивания
Операторы присваивания используются для присвоения значения правого выражения левому операнду. Операторы присваивания описаны в следующей таблице.
Оператор
Описание
=
Присваивает значение правого выражения левому операнду.
+=
Увеличивает значение левого операнда на значение правого операнда и присваивает измененное значение обратно левому операнду. Например, если a = 10, b = 20 => a+ = b будет равно a = a+ b и, следовательно, a = 30.
-=
Уменьшает значение левого операнда на значение правого операнда и присваивает измененное значение обратно левому операнду. Например, если a = 20, b = 10 => a- = b будет равно a = a – b и, следовательно, a = 10.
*=
Умножает значение левого операнда на значение правого операнда и присваивает измененное значение обратно левому операнду. Например, если a = 10, b = 20 => a* = b будет равно a = a* b и, следовательно, a = 200.
%=
Делит значение левого операнда на значение правого операнда и присваивает напоминание обратно левому операнду. Например, если a = 20, b = 10 => a % = b будет равно a = a % b и, следовательно, a = 0.
**=
a**=b будет равно a=a**b, например, если a = 4, b =2, a**=b присвоит a 4**2 = 16.
//=
A//=b будет равно a = a// b, например, если a = 4, b = 3, a//=b присвоит 4//3 = 1 a.
Операторы членства
Операторы членства Python используются для проверки принадлежности значения внутри структуры данных Python. Если значение присутствует в структуре данных, то результирующее значение истинно, в противном случае возвращается ложь.
Оператор
Описание
in
Он считается истинным, если первый операнд находится во втором операнде(списке, кортеже или словаре).
not in
Он считается истинным, если первый операнд не найден во втором операнде(списке, кортеже или словаре).
Логический
Логические операторы используются в основном при вычислении выражения для принятия решения. Python поддерживает следующие логические операторы.
Оператор
Описание
and
Если оба выражения истинны, то условие будет истинным. Если a и b являются двумя выражениями, a → true, b → true => a и b → true.
or
Если одно из выражений истинно, то условие будет истинным. Если a и b являются двумя выражениями, a → true, b → false => a или b → true.
not
Если выражение a истинно, то не (a) будет ложным и наоборот.
Операторы идентификации
Операторы идентичности используются, чтобы решить, является ли элемент определенным классом или типом.
Оператор
Описание
is
Он считается истинным, если ссылка, присутствующая с обеих сторон, указывает на один и тот же объект.
is not
Он оценивается как истина, если ссылка, присутствующая с обеих сторон, не указывает на один и тот же объект.
Приоритет оператора
Приоритет операторов важен, поскольку он позволяет нам узнать, какой оператор должен быть оценен первым. Таблица приоритета операторов в Python приведена ниже.