Операции в Python: Полное руководство

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

Что такое операторы и операнды?

Оператор — это символ или ключевое слово, которое выполняет определенное действие над одним или несколькими значениями (операндами). Например, в выражении a + b знак + — это оператор сложения, а a и b — операнды.

Операторы в Python делятся на несколько категорий:

1. Арифметические

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

3. Логические

4. Побитовые

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

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

7. Операторы идентичности

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

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

Важные особенности:

• Деление / всегда возвращает число с плавающей точкой (float), даже если результат целочисленный: span style="background-color:#dddddd">4 / 2 даст span style="background-color:#dddddd">2.0 .

• Целочисленное деление // возвращает результат, округленный вниз до ближайшего целого числа: span style="background-color:#dddddd">7 // 2 даст span style="background-color:#dddddd">3, а span style="background-color:#dddddd">-7 // 2 даст span style="background-color:#dddddd">-4 .

• Остаток от деления span style="background-color:#dddddd">% часто используется для проверки четности числа (span style="background-color:#dddddd">n % 2 == 0) или для работы с циклическими структурами.

• Возведение в степень span style="background-color:#dddddd">** поддерживает работу с отрицательными степенями: span style="background-color:#dddddd">4 ** 0.5 даст span style="background-color:#dddddd">2.0 (квадратный корень).

Примеры использования:

# Базовые арифметические операции 
a, b = 15, 4 
print(a + b) # 19 
print(a - b) # 11 
print(a * b) # 60 
print(a / b) # 3.75 
print(a // b) # 3 
print(a % b) # 3 
print(a ** b) # 50625 

# Проверка числа на четность 
number = 17 
if number % 2 == 0: 
    print(f"{number} - четное") 
else: 
    print(f"{number} - нечетное") # 17 - нечетное

Операторы сравнения (реляционные)

Операторы сравнения используются для сравнения двух значений и всегда возвращают булево значение (True или False)

Важно: Операторы сравнения можно объединять в цепочки. Выражение a < b < c эквивалентно (a < b) and (b < c) и работает очень эффективно.

x, y, z = 5, 10, 7
print(x < y < z)    # 5 < 10 < 7 -> False
print(x < y > z)    # 5 < 10 > 7 -> True

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

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

Особенности работы:

• and возвращает первый "ложный" операнд или последний "истинный", если все операнды истинны.

• or возвращает первый "истинный" операнд или последний "ложный", если все операнды ложны.

• В Python следующие значения считаются "ложными" (False): False, None, 0, 0.0, "" (пустая строка), [] (пустой список), {} (пустой словарь), () (пустой кортеж), set() (пустое множество)

# Примеры с логическими операторами
age = 25
has_license = True

if age >= 18 and has_license:
    print("Можно водить машину")

# Логические операторы с числами
print(0 and 10)   # 0 (первый ложный)
print(5 and 10)   # 10 (последний истинный)
print(5 or 10)    # 5 (первый истинный)
print(0 or 10)    # 10 (последний ложный, но все ложны)

# Условное присваивание с or
name = input("Введите имя: ") or "Гость"
print(f"Привет, {name}")  # Если ввод пуст, name будет "Гость"

Побитовые операторы

Побитовые операторы работают с числами на уровне их двоичного представления:

# Примеры побитовых операций

a, b = 5, 3  # 5 = 0101, 3 = 0011

print(a & b)   # 1 (0001)
print(a | b)   # 7 (0111)
print(a ^ b)   # 6 (0110)
print(~a)      # -6 (инверсия всех битов)
print(a << 1)  # 10 (умножение на 2)
print(a >> 1)  # 2 (деление на 2, целочисленное)

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

Операторы присваивания используются для присвоения значений переменным.

x = 10
x += 5    # x = 15
x *= 2    # x = 30
x //= 4   # x = 7
print(x)  # 7

Операторы принадлежности: in и not in

Операторы in и not in используются для проверки наличия элемента в коллекции (списке, кортеже, строке, множестве, словаре и т.д.)

Важные особенности:

• Для словарей in проверяет наличие ключа, а не значения .

• Оператор in для строк проверяет вхождение подстроки.

• Для объектов range проверка выполняется очень эффективно (за O(1))

# Списки и кортежи
fruits = ['яблоко', 'банан', 'апельсин']
print('банан' in fruits)      # True
print('груша' not in fruits)  # True

# Строки
text = "Hello, World!"
print("World" in text)        # True
print("Python" in text)       # False

# Словари (проверка ключей)
user = {'name': 'Иван', 'age': 30}
print('name' in user)         # True
print('Иван' in user)         # False (проверяются ключи!)

# Range
print(50 in range(0, 100))    # True (очень быстро!)

Операторы идентичности: is и is not

Это, пожалуй, один из самых важных и часто вызывающих вопросы разделов. Операторы is и is not сравнивают идентичность объектов, а не их значения.

Чем отличается == от is?

Это ключевое различие, которое нужно понимать каждому Python-разработчику:

• == (оператор равенства) — сравнивает значения объектов. Выражение a == b проверяет, эквивалентны ли данные в переменных a и b. Для пользовательских классов поведение == можно переопределить с помощью метода __eq__().

• is (оператор идентичности) — сравнивает идентификаторы объектов, то есть проверяет, указывают ли переменные на один и тот же объект в памяти. Это эквивалентно сравнению id(a) == id(b).

# Пример 1: Разные объекты с одинаковыми значениями
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)   # True  (значения одинаковы)
print(a is b)   # False (это разные объекты в памяти)

# Пример 2: Один и тот же объект
c = a
print(a is c)   # True  (ссылаются на один объект)

# Пример 3: Проверка на None (рекомендуемый способ)
x = None
print(x is None)     # True
print(x == None)     # True, но так делать не рекомендуется

# Пример 4: Строки могут вести себя неожиданно из-за интернирования
s1 = "hello"
s2 = "hello"
print(s1 is s2)      # Может быть True из-за оптимизации, но полагаться на это нельзя!

Практические рекомендации:

• Используйте is для сравнения с None, True, False (это синглтоны).

• Используйте == для сравнения значений чисел, строк, списков и других коллекций.

• Используйте is когда вам действительно нужно проверить, что две переменные ссылаются на один объект.

Оператор := (моржовый оператор / walrus operator)

Оператор := был представлен в Python 3.8 и получил название "walrus operator" (моржовый оператор) за сходство с моржом — глазами и клыками . Его официальное название — оператор присваивания в выражении (assignment expression). Он позволяет присвоить значение переменной прямо внутри другого выражения, например, в условии if или цикле while.

# Без оператора := (традиционный подход)
data = input("Введите данные: ")
while len(data) > 0:
    print(f"Вы ввели: {data}")
    data = input("Введите данные: ")

# С оператором := (более компактно)
while (data := input("Введите данные: ")) != "":
    print(f"Вы ввели: {data}")

Ключевые особенности:

• Позволяет избежать повторного вычисления выражений.

• Повышает читаемость кода, когда нужно и присвоить, и проверить значение.

• Имеет низкий приоритет, поэтому в сложных выражениях рекомендуется использовать скобки

Другие примеры использования:

# В списковых включениях (list comprehensions)
numbers = [1, 5, 8, 12, 15, 3]
# Вычисляем квадрат и фильтруем те, что больше 10
squared = [n_sq for n in numbers if (n_sq := n ** 2) > 10]
print(squared)  # [25, 64, 144, 225]

# Проверка и обработка данных из файла
with open('data.txt', 'r') as file:
    while (line := file.readline().strip()):
        print(f"Обработка: {line}")

# Условное выполнение с сохранением результата
if (result := some_expensive_calculation()) > 100:
    print(f"Результат превысил 100: {result}")

Когда НЕ стоит использовать:

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

# Плохой пример - трудно читать
values = [5, 15, 25, 35, 45]
if (above := (v := values[0]) > 10) and (incremented := (new := v + 10) > 20):
    print(new)  # Не делайте так!

Тернарный условный оператор

Тернарный оператор позволяет записать условное выражение в одну строку.
Его синтаксис: значение_если_истина if условие else значение_если_ложь.

age = 18
status = "Совершеннолетний" if age >= 18 else "Несовершеннолетний"
print(status)  # "Совершеннолетний"

# Вложенный тернарный оператор
score = 85
grade = "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "D"
print(grade)  # "B"

Приоритет операторов

В Python, как и в математике, у операторов есть приоритет. Операторы с более высоким приоритетом выполняются раньше. Ниже приведена таблица приоритетов от высшего к низшему:

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

Сводная таблица всех операторов Python

Заключение

Python предлагает богатый набор операторов, которые делают код выразительным и лаконичным. Понимание различий между == и is, правильное использование оператора := и знание приоритетов помогут вам писать более качественный и эффективный код.

Освоение операторов — это фундамент, на котором строится все дальнейшее изучение языка. Практикуйтесь, экспериментируйте с разными типами данных, и вскоре использование этих операторов станет для вас естественным.