Share This
Связаться со мной
Крути в низ
Categories
//Операторы в Python

Операторы в Python

11.01.2022Category : Python

В этой статье мы поговорим про различные операторы в Python. Мы на примерах разберем арифметические, битовые и логические операторы, а также операторы присваивания и сравнения. Кроме того, мы рассмотрим операторы принадлежности и идентичности, такие как is, is not и in, not in.

Арифметические операторы

Python реализует семь основных бинарных арифметических операторов, два из которых могут использоваться как унарные операторы. Они приведены в следующей таблице:

Оператор Название Описание
a + b Сложение Сумма a и b
a — b Вычитание Разность a и b
a * b Умножение Произведение a и b
a / b Деление Частное a и b
a // b Целочисленное деление Деление a на b без остатка (дробная часть отбрасывается)
a % b Взятие модуля Целый остаток от деления a на b
a ** b Возведение в степень a, возведенное в степень b
-a Отрицание Отрицательное значение a
+a Унарный плюс а без изменений (используется редко)

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

# сложение, вычитание, умножение (4 + 8) * (6.5 - 3) # 42.0

Целочисленное деление — это обычное деление, только с усечённой дробной частью:

# Деление print(11 / 2) # 5.5 # Целочисленное деление print(11 // 2) # 5

Оператор целочисленного деления был добавлен в Python 3. Если вы работаете в Python 2, вы должны знать, что стандартный оператор деления (/) действует как оператор целочисленного деления для целых чисел и как обычный оператор деления для чисел с плавающей запятой.

Наконец, упомянем ещё один арифметический оператор, который был добавлен в Python 3.5. Это оператор a @ b, предназначенный для указания матричного произведения a и b для использования в различных пакетах линейной алгебры.

operatory v python b13e04f - Операторы в Python

Марк Лутц «Изучаем Python»

Скачивайте книгу у нас в телеграм

Скачать ×

Битовые операторы

В дополнение к стандартным числовым операциям в Python есть операторы для выполнения побитовых логических операций над целыми числами. Они используются гораздо реже стандартных арифметических операций, но знать их полезно. Шесть побитовых операторов сведены в следующую таблицу:

Оператор Название Описание
a & b Логическое И Биты, определенные как в a, так и в b
a | b Логическое ИЛИ Биты, определенные в a или b или в обоих
a ^ b Исключающее ИЛИ Равен 1, если только a или только b равно 1
a << b Побитовый сдвиг влево Сдвинуть биты a влево на b единиц
a >> b Побитовый сдвиг вправо Сдвинуть биты a вправо на b единиц
~a Логическое НЕ Отрицание a

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

bin(10) # '0b1010'

Результат имеет префикс 0b, что указывает на двоичное представление. Остальные цифры означают, что число 10 выражается как сумма 1⋅23+0⋅22+1⋅21+0⋅20. Точно так же мы можем написать:

bin(4) # '0b100'

Теперь, используя логическое ИЛИ, мы можем найти число, которое объединяет биты 4 и 10:

4 | 10 # 14 bin(4 | 10) # '0b1110'

Эти побитовые операторы не так полезны, как стандартные арифметические операторы, но стоит увидеть их хотя бы раз, чтобы понять, какой класс операций они выполняют. В частности, у пользователей других языков иногда возникает соблазн использовать исключающее ИЛИ (т. е. a ^ b), на самом деле имея в виду возведение в степень (т. е. a ** b).

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

Мы видели, что переменным можно присваивать значение с помощью оператора =. Например, следующим образом:

a = 24 print(a) # 24

Мы можем использовать эти переменные в выражениях с любым из упомянутых ранее операторов. Например, чтобы добавить 2 к a, мы пишем:

a + 2 # 26

Мы можем захотеть обновить переменную a новым значением. В этом случае мы могли бы объединить сложение и присваивание и написать a = a + 2. Поскольку этот тип комбинированной операции и присваивания очень распространен, Python включает встроенные операторы обновления для всех арифметических операций:

a += 2  # эквивалентно a = a + 2 print(a) # 26

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

a += b    a -= b    a *= b    a /= b  a //= b    a %= b    a **= b    a &= b  a |= b    a ^= b    a <<= b    a >>= b

Каждый из этих операторов эквивалентен применению соответствующего оператора с последующим присваиванием. То есть для любого оператора ■ выражение a ■= b эквивалентно a = a ■ b с небольшой оговоркой.

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

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

Другой тип операций, который может быть очень полезным, — это сравнение различных переменных. Для этого в Python реализованы стандартные операторы сравнения, которые возвращают логические значения True или False. Операции сравнения представлены в следующей таблице:

Оператор Описание
a == b a равняется b
a < b a строго меньше чем b
a <= b a меньше либо равно b
a != b a не равняется b
a > b a строго больше чем b
a >= b a больше либо равно b

Эти операторы сравнения можно комбинировать с арифметическими и побитовыми операторами, чтобы осуществлять самые разнообразные операции над числами. Например, мы можем проверить, является ли число нечетным, проверив, что остаток от деления на 2 возвращает 1:

# 25 - нечетное число 25 % 2 == 1 # True # 66 - нечетное число 66 % 2 == 1 # False

Мы можем объединить несколько сравнений, чтобы проверить более сложные отношения:

# проверяем, находится ли a между 15 и 30 a = 25 15 < a < 30 # True

И, чтобы у вас немного закружилась голова, взгляните на это сравнение:

-1 == ~0 # True

Напомним, что ~ — это оператор инвертирования битов, и, очевидно, когда вы инвертируете все биты нуля, вы получите -1. Если вам интересно, почему это так, посмотрите схему кодирования целых чисел с дополнением до двух, которую Python использует для кодирования целых чисел со знаком, и подумайте, что происходит, когда вы начинаете переворачивать все биты целых чисел, закодированных таким образом.

От редакции Pythonist: об операторе != можно почитать в статье «Оператор неравенства != в Python».

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

При работе с логическими значениями Python предоставляет операторы для объединения значений с использованием стандартных понятий «и», «или» и «не». Эти операторы ожидаемо представлены словами and, or и not:

x = 4 (x < 6) and (x > 2) # True (x > 10) or (x % 2 == 0) # True not (x < 6) # False

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

# (x > 1) xor (x < 10) (x > 1) != (x < 10) # False

Иногда в языке возникает путаница: когда использовать логические операторы (and, or, not), а когда побитовые (&, |, ~). Ответ кроется в их названиях: логические операторы следует использовать, когда вы хотите вычислить логические значения (т.е. истинность или ложность) утверждений. Побитовые операции следует использовать, когда вы хотите работать с отдельными битами или компонентами рассматриваемых объектов.

Операторы принадлежности и идентичности

Помимо and, or и not, Python также имеет операторы для проверки принадлежности и идентичности. Они следующие:

Оператор Описание
a is b Возвращает True, если a и b — идентичные объекты
a is not b Возвращает True, если a и b — не идентичные объекты
a in b Возвращает True, если a содержится в b
a not in b Возвращает True, если a не содержится в b

Операторы is и is not проверяют идентичность объекта. Идентичность объекта отличается от равенства, как мы видим здесь:

a = [1, 2, 3] b = [1, 2, 3] a == b # True a is b # False a is not b # True

Как выглядят одинаковые объекты? Вот пример:

a = [1, 2, 3] b = a a is b # True

Разница между этими двумя случаями в том, что в первом a и b указывают на разные объекты, а во втором они указывают на один и тот же объект. Оператор is проверяет, указывают ли две переменные на один и тот же контейнер (объект), а не на то, что содержит контейнер.

Новички часто испытывают искушение использовать is, хотя на самом деле имеют в виду ==. Подробнее о разнице между == и is можно почитать в статье «Чем == отличается от is?«.

Операторы принадлежности проверяют принадлежность к составным объектам. Так, например, мы можем написать:

1 in [1, 2, 3] # True 2 not in [1, 2, 3] # False

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

Заключение

Итак, сегодня мы разобрали на примерах различные операторы в Python. Надеемся вам было полезно! Успехов в написании кода!

Перевод статьи «Basic Python Semantics: Operators».

  • 0 views
  • 0 Comment

Leave a Reply

Ваш адрес email не будет опубликован.

Этот сайт использует Akismet для борьбы со спамом. Узнайте, как обрабатываются ваши данные комментариев.

Свежие комментарии

    Рубрики

    About Author 01.

    blank
    Roman Spiridonov

    Моя специальность - Back-end Developer, Software Engineer Python. Мне 39 лет, я работаю в области информационных технологий более 5 лет. Опыт программирования на Python более 3 лет. На Django более 2 лет.

    Categories 05.

    © Speccy 2022 / All rights reserved

    Связаться со мной
    Close