Разбор реализации инкремента: два подхода на Python

В этой статье разберём два класса из статьи «Инкремент», которые по‑разному реализуют логику увеличения и уменьшения значений в Python. Оба примера активно используют магические методы, но решают задачу с разной философией: первый — как изменяемый счётчик, второй — как неизменяемый «умный» integer.

Что это за код?

Представлено два независимых решения:

• Inc — изменяемый объект‑счётчик с состоянием: хранит текущее и начальное значение, меняет своё внутреннее состояние при операциях.
• inc (наследуется от int) — неизменяемая обертка над целым числом: каждая операция возвращает новый объект, а не модифицирует существующий.

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

Исходный код

# Первый подход: изменяемый счётчик

class Inc():
    def __init__(self, value=0):
        self.initial = value
        self.value = value

    def __index__(self):
        return self.value

    def __pos__(self):
        self.value += 1
        return self.value

    def __neg__(self):
        self.value -= 1
        return self.value

    def __invert__(self):
        self.value = self.initial
        return self.value

# Второй подход: неизменяемая обертка поверх int

class inc(int):

    def __index__(self):
        return self

    def __pos__(self):
        return inc(self+1)

    def __neg__(self):
        return inc(self-1)

    def __add__(self, other):
        return inc(super().__add__(other))

    def __sub__(self, other):
        return inc(super().__sub__(other))

    def __mul__(self, other):
        return inc(super().__mul__(other))

    def __floordiv__(self, other):
        return inc(super().__floordiv__(other))

    def __mod__(self, other):
        return inc(super().__mod__(other))

    def __pow__(self, other):
        return inc(super().__pow__(other))

    def __iadd__(self, other):
        return inc(super().__iadd__(other))

    def __isub__(self, other):
        return inc(super().__isub__(other))

    def __imul__(self, other):
        return inc(super().__imul__(other))

    def __ifloordiv__(self, other):
        return inc(super().__ifloordiv__(other))

    def __imod__(self, other):
        return inc(super().__imod__(other))

    def __ipow__(self, other):
        return inc(super().__ipow__(other))

Зачем это нужно?

Такие реализации полезны, когда нужно:

• Инкапсулировать логику инкремента/декремента и сделать её частью объекта, а не разбросать по коду.
• Переопределить поведение унарных операторов (+x, -x) под свои нужды.
• Сбросить значение к исходному через понятный оператор (~x в случае Inc).
• Создать тип с кастомной арифметикой, который прозрачно ведёт себя как число в некоторых контекстах (например, в индексации или при передаче в функции, ожидающие целые).

Практические кейсы: - счётчики событий с возможностью сброса; - игровые очки/уровни с контролируемым изменением; - прототипы DSL (предметно‑ориентированных языков) на Python; - эксперименты с перегрузкой операторов для обучения.

Такие классы можно использовать в скриптах для нумерации шагов, генерации ID или подсчёта токенов в тестовых данных.

Как использовать этот код?

Вариант 1: изменяемый счётчик (Inc)

c = Inc(5)
print(+c)      # 6  (вызовет __pos__, изменит внутреннее состояние)
print(+c)      # 7
print(-c)      # 6  (декремент)
print(~c)      # 5  (сброс к initial)

Особенности: - состояние хранится внутри объекта; - унарные + и - меняют значение; - ~ сбрасывает к начальному.

Вариант 2: неизменяемая обёртка (inc)

x = inc(10)
y = +x         # inc(11) — новый объект
z = -x         # inc(9)
w = x + 5      # inc(15)
v = x * 2      # inc(20)

print(x)       # 10 (не изменился)
print(y)       # 11

Особенности: - каждая операция возвращает новый экземпляр inc; - исходный объект остаётся неизменным; - поддерживается большинство арифметических операций.

Интеграция в другие скрипты

Оба класса можно использовать там, где ожидается целое число:

counter = Inc(0)
for i in range(5):
    +counter           # инкремент
    print(counter.value)

x = inc(3)
index = +x             # можно использовать как индекс
lst = [10, 20, 30, 40]
print(lst[index])      # работает, т.к. __index__ реализован

Разбор ключевых моментов

Класс Inc

• __init__: сохраняет начальное и текущее значение.
• __index__: позволяет использовать объект в качестве индекса (lst[obj]).
• __pos__ / __neg__: реализуют инкремент и декремент, изменяя внутреннее состояние.
• __invert__: оператор ~ используется как «сброс к начальному значению» — это нестандартное, но допустимое применение.

Класс inc

• Наследуется от int, поэтому ведёт себя как целое число.
• Все арифметические методы возвращают новый экземпляр inc, сохраняя неизменяемость.
• Переопределены как обычные (__add__, __sub__), так и «in‑place» операции (__iadd__ и т.п.), хотя для неизменяемого типа они всё равно создают новый объект.
• __index__ позволяет использовать экземпляры в индексации.

Важные нюансы и возможные проблемы

Возможные улучшения

• Добавить __repr__ и __str__ для понятного вывода в логах и отладке.
• Реализовать сравнение (__eq__, __lt__ и др.) для полноценной работы как с числами.
• Добавить валидацию и обработку ошибок (например, при выходе за границы диапазона).
• Для Inc добавить методы reset(), increment(), decrement() с понятными именами вместо перегрузки операторов.