Как определить метод класса и статический метод?

Метод класса (@classmethod) и статический метод (@staticmethod)

Методы класса и статические методы — это два способа определить методы, которые не требуют экземпляра класса. Они часто путаются, но имеют разные назначение и поведение.

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

Обычный метод получает экземпляр класса как первый аргумент (self):

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # Обычный метод
    def greet(self):
        return f"Hello, I'm {self.name}"

user = User("Alice", 30)
print(user.greet())  # Hello, I'm Alice

# Без экземпляра не работает
User.greet()  # TypeError: greet() missing 1 required positional argument: 'self'

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

Метод класса получает сам класс как первый аргумент (cls), а не экземпляр:

class User:
    count = 0  # Класс-переменная
    
    def __init__(self, name):
        self.name = name
        User.count += 1
    
    @classmethod
    def from_string(cls, user_string):
        """Альтернативный конструктор"""
        name, age = user_string.split(',')
        return cls(name)  # Использует cls вместо User
    
    @classmethod
    def get_user_count(cls):
        """Получить количество пользователей"""
        return cls.count

# Можно вызвать на классе
user1 = User.from_string("Alice,30")
user2 = User("Bob")

print(User.get_user_count())  # 2
print(user1.get_user_count())  # 2 (также работает на экземпляре)

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

• Получает cls (класс) вместо self (экземпляра)
• Может получать доступ и изменять переменные класса
• Может вызываться на классе и на экземпляре
• Часто используется для альтернативных конструкторов

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

Статический метод не получает ни self, ни cls. Это просто функция, которая живёт в namespace класса:

class MathHelper:
    @staticmethod
    def add(a, b):
        """Просто функция в пространстве имён класса"""
        return a + b
    
    @staticmethod
    def multiply(a, b):
        return a * b

# Можно вызвать на классе или экземпляре
print(MathHelper.add(2, 3))  # 5

helper = MathHelper()
print(helper.add(2, 3))  # 5

# Не зависит от класса или экземпляра

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

• Не получает self или cls
• Не может получать доступ к переменным класса или экземпляра
• Вызывается так же как обычная функция
• Используется как группировка функций по смыслу

4. Сравнение

class Database:
    instances = 0  # Класс-переменная
    
    def __init__(self):
        self.data = {}
        Database.instances += 1
    
    # Обычный метод
    def add(self, key, value):
        self.data[key] = value
    
    # Метод класса
    @classmethod
    def create_from_dict(cls, data_dict):
        """Создание экземпляра из словаря"""
        instance = cls()
        instance.data = data_dict.copy()
        return instance
    
    # Статический метод
    @staticmethod
    def validate_key(key):
        """Проверка ключа (не зависит от класса)"""
        return isinstance(key, str) and len(key) > 0

# Использование
db1 = Database()
db1.add("user_1", {"name": "Alice"})

db2 = Database.create_from_dict({"user_2": {"name": "Bob"}})

print(Database.validate_key("valid_key"))  # True
print(Database.validate_key(""))  # False

print(Database.instances)  # 2

5. Пример в Data Engineering

import pandas as pd
from datetime import datetime
import json

class DataProcessor:
    """Обработчик данных"""
    
    processed_count = 0
    
    def __init__(self, data_source):
        self.data_source = data_source
        self.data = None
    
    # Обычный метод
    def load_data(self):
        """Загружаем данные"""
        if self.data_source.endswith('.csv'):
            self.data = pd.read_csv(self.data_source)
        elif self.data_source.endswith('.json'):
            with open(self.data_source) as f:
                self.data = pd.DataFrame(json.load(f))
        DataProcessor.processed_count += 1
    
    # Метод класса для создания из нескольких источников
    @classmethod
    def merge_sources(cls, sources):
        """Загружаем и объединяем несколько источников"""
        processor = cls(sources[0])
        processor.load_data()
        
        for source in sources[1:]:
            temp = cls(source)
            temp.load_data()
            processor.data = pd.concat([processor.data, temp.data])
        
        return processor
    
    # Статический метод для валидации
    @staticmethod
    def validate_file_path(path):
        """Проверяем, что файл существует"""
        import os
        return os.path.exists(path)
    
    # Статический метод для трансформации
    @staticmethod
    def normalize_date(date_str):
        """Нормализуем формат даты"""
        return pd.to_datetime(date_str).strftime('%Y-%m-%d')
    
    # Метод класса для мониторинга
    @classmethod
    def get_stats(cls):
        """Получить статистику по обработке"""
        return {
            'processed_files': cls.processed_count,
            'timestamp': datetime.now().isoformat()
        }

# Использование

# Проверка файла (статический метод)
if DataProcessor.validate_file_path('data.csv'):
    
    # Загрузка одного файла
    processor = DataProcessor('data.csv')
    processor.load_data()
    
    # Трансформация данных
    processor.data['normalized_date'] = processor.data['date'].apply(
        DataProcessor.normalize_date
    )
    
    # Загрузка из нескольких источников (метод класса)
    multi_processor = DataProcessor.merge_sources([
        'data1.csv',
        'data2.csv',
        'data3.csv'
    ])
    
    # Мониторинг
    print(DataProcessor.get_stats())
    # {'processed_files': 4, 'timestamp': '2024-01-15T10:30:45'}

6. Когда использовать что

7. Наследование

class Animal:
    species_count = 0
    
    @classmethod
    def get_species_count(cls):
        return cls.species_count
    
    @staticmethod
    def get_sound():
        return "Some sound"

class Dog(Animal):
    species_count = 5
    
    @staticmethod
    def get_sound():
        return "Woof"

# @classmethod использует именно cls (Dog, не Animal)
print(Dog.get_species_count())  # 5
print(Animal.get_species_count())  # 0

# @staticmethod просто переопределяется
print(Dog.get_sound())  # Woof
print(Animal.get_sound())  # Some sound

Итоговый вывод

@classmethod — это для работы с классом в целом (альтернативные конструкторы, фабрики) @staticmethod — это для вспомогательных функций, логически связанных с классом, но не нуждающихся в доступе к данным