Какие бывают виды методов класса?

Виды методов класса в Python

В Python существует несколько типов методов класса, которые различаются по способу работы с данными класса и экземпляра:

1. Обычные методы (Instance Methods)

Это самые часто используемые методы. Они работают с данными конкретного экземпляра класса и всегда получают self как первый аргумент.

class User:
    def __init__(self, name: str, email: str):
        self.name = name
        self.email = email
    
    # Обычный метод (instance method)
    def get_full_info(self) -> str:
        return f"{self.name} ({self.email})"
    
    def update_email(self, new_email: str) -> None:
        self.email = new_email

# Использование
user = User("John", "john@example.com")
print(user.get_full_info())  # John (john@example.com)
user.update_email("john.new@example.com")
print(user.get_full_info())  # John (john.new@example.com)

Характеристики:

• Первый параметр всегда self
• Может менять состояние экземпляра
• Имеет доступ к другим методам и свойствам через self

2. Методы класса (@classmethod)

Методы класса работают с данными класса (не экземпляра). Первый параметр — cls (сама класс).

class User:
    total_users = 0  # Данные класса
    
    def __init__(self, name: str):
        self.name = name
        User.total_users += 1
    
    # Метод класса (@classmethod)
    @classmethod
    def get_total_users(cls) -> int:
        return cls.total_users
    
    @classmethod
    def from_string(cls, user_string: str):
        """Factory method — создаёт объект из строки"""
        name = user_string.split(",")[0]
        return cls(name)

# Использование
user1 = User("Alice")
user2 = User("Bob")
print(User.get_total_users())  # 2

# Factory pattern
user3 = User.from_string("Charlie,30")
print(user3.name)  # Charlie

Характеристики:

• Первый параметр cls (класс)
• Может работать с данными класса (class variables)
• Можно вызвать на самом классе, не создавая экземпляр
• Часто используются для factory methods и альтернативных конструкторов

3. Статические методы (@staticmethod)

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

class MathHelper:
    
    # Статический метод (@staticmethod)
    @staticmethod
    def add(a: int, b: int) -> int:
        return a + b
    
    @staticmethod
    def is_even(number: int) -> bool:
        return number % 2 == 0

# Использование
print(MathHelper.add(5, 3))  # 8
print(MathHelper.is_even(4))  # True

# Можно вызвать и на экземпляре
helper = MathHelper()
print(helper.add(10, 20))  # 30

Характеристики:

• Нет self или cls
• Это обычные функции, находящиеся внутри класса
• Не могут модифицировать состояние экземпляра или класса
• Удобны для группировки функций по логическим блокам

4. Свойства (@property)

Свойства позволяют использовать методы как атрибуты. Это паттерн для getter/setter.

class Person:
    def __init__(self, first_name: str, last_name: str):
        self._first_name = first_name
        self._last_name = last_name
    
    # Property для чтения (getter)
    @property
    def full_name(self) -> str:
        return f"{self._first_name} {self._last_name}"
    
    # Property для записи (setter)
    @full_name.setter
    def full_name(self, name: str) -> None:
        parts = name.split()
        self._first_name = parts[0]
        self._last_name = parts[1] if len(parts) > 1 else ""
    
    # Property для удаления (deleter)
    @full_name.deleter
    def full_name(self) -> None:
        self._first_name = ""
        self._last_name = ""

# Использование
person = Person("John", "Doe")
print(person.full_name)  # John Doe

person.full_name = "Jane Smith"
print(person.full_name)  # Jane Smith

del person.full_name
print(person._first_name, person._last_name)  # (пусто)

Характеристики:

• Используются как атрибуты, но выполняют код методов
• Имеют getter, setter и deleter
• Удобны для валидации и вычисляемых свойств

5. Магические методы (Magic/Dunder methods)

Это методы, которые вызываются автоматически при определённых операциях (двойное подчёркивание __).

class Vector:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y
    
    # __str__: строковое представление
    def __str__(self) -> str:
        return f"Vector({self.x}, {self.y})"
    
    # __repr__: представление для разработчика
    def __repr__(self) -> str:
        return f"Vector(x={self.x}, y={self.y})"
    
    # __add__: оператор +
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    # __sub__: оператор -
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    
    # __len__: функция len()
    def __len__(self) -> float:
        return (self.x ** 2 + self.y ** 2) ** 0.5
    
    # __eq__: оператор ==
    def __eq__(self, other) -> bool:
        return self.x == other.x and self.y == other.y
    
    # __hash__: для использования в sets и как ключи dict
    def __hash__(self) -> int:
        return hash((self.x, self.y))

# Использование
v1 = Vector(1, 2)
v2 = Vector(3, 4)

print(str(v1))  # Vector(1, 2)
print(repr(v1))  # Vector(x=1, y=2)
print(v1 + v2)  # Vector(4, 6)
print(len(v1))  # 2.236... (длина вектора)
print(v1 == v2)  # False

Популярные магические методы:

• __init__: конструктор
• __str__: строка для пользователя
• __repr__: для разработчика
• __add__, __sub__, __mul__: арифметические операции
• __eq__, __lt__, __gt__: сравнение
• __len__, __getitem__: работа с последовательностями
• __call__: делает объект вызываемым

6. Приватные методы (_prefix и __prefix)

class BankAccount:
    def __init__(self, balance: float):
        self.balance = balance
    
    # Приватный метод (convention): одно подчёркивание
    def _calculate_interest(self) -> float:
        return self.balance * 0.05
    
    # Очень приватный метод: двойное подчёркивание (name mangling)
    def __validate_balance(self) -> bool:
        return self.balance >= 0
    
    def withdraw(self, amount: float):
        if not self.__validate_balance():
            raise ValueError("Invalid balance")
        
        if self.balance >= amount:
            self.balance -= amount
        else:
            raise ValueError("Insufficient funds")

# Использование
account = BankAccount(1000)
account.withdraw(100)  # OK
# account.__validate_balance()  # AttributeError: нельзя вызвать

# Name mangling преобразует __method в _ClassName__method
print(account._BankAccount__validate_balance())  # Работает, но не рекомендуется

Характеристики:

• _method: приватный по соглашению (convention)
• __method: очень приватный (name mangling: преобразуется в _ClassName__method)

7. Сравнительная таблица

Рекомендации по использованию

1. Instance methods: 90% методов класса
2. Classmethods: factory patterns, альтернативные конструкторы
3. Staticmethods: утилиты, которые логически принадлежат классу
4. Properties: getter/setter вместо методов для более читаемого кода
5. Magic methods: для интеграции с встроенными Python функциями
6. Private methods: для скрытия деталей реализации