Приведи пример класса в Python

# Примеры классов в Python

Базовый пример: простой класс User

class User:
    """Простой класс для представления пользователя"""
    
    def __init__(self, name, email, age):
        """Конструктор — вызывается при создании объекта"""
        self.name = name      # Атрибут экземпляра
        self.email = email
        self.age = age
    
    def greet(self):
        """Метод экземпляра"""
        return f"Привет, я {self.name}!"
    
    def birthday(self):
        """Увеличиваем возраст"""
        self.age += 1
        return f"{self.name} теперь {self.age} лет"

# Использование класса
user = User("Alice", "alice@example.com", 30)
print(user.greet())      # Привет, я Alice!
print(user.birthday())   # Alice теперь 31 лет
print(user.age)          # 31

Практический пример: класс для банковского счёта

class BankAccount:
    """Класс для управления банковским счётом"""
    
    def __init__(self, account_number, owner, balance=0):
        self.account_number = account_number
        self.owner = owner
        self._balance = balance  # _ означает "приватный"
        self.transaction_history = []
    
    def deposit(self, amount):
        """Пополнить счёт"""
        if amount <= 0:
            raise ValueError("Сумма должна быть положительной")
        
        self._balance += amount
        self.transaction_history.append({
            'type': 'deposit',
            'amount': amount,
            'balance': self._balance
        })
        return f"Пополнено на {amount}. Остаток: {self._balance}"
    
    def withdraw(self, amount):
        """Снять деньги"""
        if amount <= 0:
            raise ValueError("Сумма должна быть положительной")
        
        if amount > self._balance:
            raise ValueError("Недостаточно средств")
        
        self._balance -= amount
        self.transaction_history.append({
            'type': 'withdraw',
            'amount': amount,
            'balance': self._balance
        })
        return f"Снято {amount}. Остаток: {self._balance}"
    
    def get_balance(self):
        """Получить текущий баланс"""
        return self._balance
    
    def get_history(self):
        """Получить историю операций"""
        return self.transaction_history
    
    def __str__(self):
        """Представление объекта как строки"""
        return f"BankAccount({self.account_number}, {self.owner}, {self._balance})"

# Использование
account = BankAccount("123456", "Alice", 1000)
print(account.deposit(500))          # Пополнено на 500. Остаток: 1500
print(account.withdraw(300))         # Снято 300. Остаток: 1200
print(account)                       # BankAccount(123456, Alice, 1200)
print(account.get_balance())         # 1200

Класс с методами класса и статическими методами

class MathUtils:
    """Утилиты для математических операций"""
    
    PI = 3.14159  # Атрибут класса (общий для всех экземпляров)
    
    @staticmethod
    def add(a, b):
        """Статический метод — не требует self"""
        return a + b
    
    @staticmethod
    def multiply(a, b):
        return a * b
    
    @classmethod
    def from_string(cls, operation_string):
        """Метод класса — получает cls вместо self"""
        # Может использоваться как альтернативный конструктор
        a, b = map(float, operation_string.split(','))
        return cls(a, b)
    
    @classmethod
    def get_pi(cls):
        """Получить значение PI"""
        return cls.PI
    
    def __init__(self, a, b):
        self.a = a
        self.b = b
    
    def calculate_area_circle(self):
        """Вычислить площадь круга радиусом self.a"""
        return self.PI * self.a ** 2

# Использование
print(MathUtils.add(5, 3))           # 8 (статический метод)
print(MathUtils.get_pi())            # 3.14159 (метод класса)

math = MathUtils(5, 10)
print(math.calculate_area_circle())  # 78.53975 (метод экземпляра)

Наследование: класс автомобиля

class Vehicle:
    """Базовый класс для транспортных средств"""
    
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
        self.is_running = False
    
    def start(self):
        self.is_running = True
        return f"{self.brand} {self.model} заведена"
    
    def stop(self):
        self.is_running = False
        return f"{self.brand} {self.model} остановлена"

class Car(Vehicle):
    """Класс автомобиля, наследует Vehicle"""
    
    def __init__(self, brand, model, num_doors):
        super().__init__(brand, model)  # Вызываем конструктор родителя
        self.num_doors = num_doors
    
    def open_trunk(self):
        return f"Открыто багажное отделение {self.brand}"

class Motorcycle(Vehicle):
    """Класс мотоцикла"""
    
    def __init__(self, brand, model, has_sidecar):
        super().__init__(brand, model)
        self.has_sidecar = has_sidecar
    
    def wheelie(self):
        if self.is_running:
            return f"Мотоцикл {self.brand} делает стойку на переднее колесо!"
        return "Сначала заведите мотоцикл"

# Использование
car = Car("Toyota", "Camry", 4)
print(car.start())                   # Toyota Camry заведена
print(car.open_trunk())              # Открыто багажное отделение Toyota

moto = Motorcycle("Harley-Davidson", "Sportster", False)
print(moto.start())                  # Harley-Davidson Sportster заведена
print(moto.wheelie())                # Мотоцикл Harley-Davidson делает стойку...

Класс с properties (свойства)

class Temperature:
    """Класс для конвертации температур"""
    
    def __init__(self, celsius):
        self._celsius = celsius  # Приватный атрибут
    
    @property
    def celsius(self):
        """Getter для Celsius"""
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        """Setter для Celsius"""
        if value < -273.15:
            raise ValueError("Температура ниже абсолютного нуля")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        """Автоматический расчёт Fahrenheit"""
        return self._celsius * 9/5 + 32
    
    @fahrenheit.setter
    def fahrenheit(self, value):
        """Установка через Fahrenheit"""
        self._celsius = (value - 32) * 5/9
    
    @property
    def kelvin(self):
        """Автоматический расчёт Kelvin"""
        return self._celsius + 273.15

# Использование
temp = Temperature(25)
print(temp.celsius)      # 25
print(temp.fahrenheit)   # 77.0
print(temp.kelvin)       # 298.15

temp.fahrenheit = 86     # Устанавливаем через Fahrenheit
print(temp.celsius)      # 30.0 (автоматически пересчитано)

Класс с магическими методами (dunder methods)

class Vector:
    """Класс для представления 2D вектора"""
    
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        """Красивое представление для пользователя"""
        return f"Vector({self.x}, {self.y})"
    
    def __repr__(self):
        """Представление для разработчика (для отладки)"""
        return f"Vector(x={self.x}, y={self.y})"
    
    def __add__(self, other):
        """Сложение векторов: v1 + v2"""
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        """Вычитание векторов: v1 - v2"""
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):
        """Умножение на скаляр: v * 2"""
        return Vector(self.x * scalar, self.y * scalar)
    
    def __eq__(self, other):
        """Сравнение: v1 == v2"""
        return self.x == other.x and self.y == other.y
    
    def __len__(self):
        """Длина вектора: len(v)"""
        return (self.x ** 2 + self.y ** 2) ** 0.5
    
    def __getitem__(self, index):
        """Индексирование: v[0] → x, v[1] → y"""
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            raise IndexError("Vector index must be 0 or 1")

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

print(v1)                # Vector(3, 4)
print(v1 + v2)          # Vector(4, 6)
print(v1 - v2)          # Vector(2, 2)
print(v1 * 2)           # Vector(6, 8)
print(v1 == Vector(3, 4))  # True
print(len(v1))           # 5.0 (длина вектора)
print(v1[0], v1[1])     # 3 4

Класс с инкапсуляцией (приватные атрибуты)

class SecurePassword:
    """Класс для безопасного хранения пароля"""
    
    def __init__(self, password):
        self.__password = password  # __ делает атрибут приватным
        self.__attempts = 0
        self.__max_attempts = 3
    
    def verify(self, input_password):
        """Проверить пароль"""
        if self.__attempts >= self.__max_attempts:
            raise PermissionError("Слишком много неудачных попыток")
        
        if input_password == self.__password:
            self.__attempts = 0  # Сбрасываем счётчик при правильном пароле
            return True
        else:
            self.__attempts += 1
            raise ValueError(f"Неверный пароль. Осталось {self.__max_attempts - self.__attempts} попыток")
    
    def change_password(self, old_password, new_password):
        """Изменить пароль"""
        if old_password != self.__password:
            raise ValueError("Старый пароль неверен")
        
        self.__password = new_password
        return "Пароль успешно изменён"
    
    # Имя-манглинг: __password становится _SecurePassword__password
    # Это не реальная защита, но предотвращает случайный доступ

# Использование
password = SecurePassword("secret123")
print(password.verify("secret123"))  # True
print(password.change_password("secret123", "newpass123"))  # Пароль успешно изменён

Класс с контекстным менеджером (with statement)

class FileManager:
    """Класс для безопасной работы с файлами"""
    
    def __init__(self, filename, mode='r'):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        """Вызывается при входе в блок with"""
        self.file = open(self.filename, self.mode)
        print(f"Файл {self.filename} открыт")
        return self.file
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """Вызывается при выходе из блока with"""
        if self.file:
            self.file.close()
            print(f"Файл {self.filename} закрыт")
        
        # Если произошло исключение, можно обработать его
        if exc_type is not None:
            print(f"Ошибка: {exc_val}")
            return False  # Пробросить исключение дальше

# Использование
with FileManager('test.txt', 'w') as f:
    f.write("Привет, мир!")  # Файл автоматически закроется после блока
# Файл test.txt открыт
# Файл test.txt закрыт

Класс с итератором

class CountUp:
    """Класс, который считает от 1 до n"""
    
    def __init__(self, max):
        self.max = max
        self.current = 0
    
    def __iter__(self):
        """Вернуть сам объект как итератор"""
        return self
    
    def __next__(self):
        """Вернуть следующее значение"""
        self.current += 1
        if self.current > self.max:
            raise StopIteration  # Остановить итерацию
        return self.current

# Использование
for number in CountUp(5):
    print(number)  # 1, 2, 3, 4, 5

Заключение

Класс в Python — это шаблон для создания объектов, который может содержать:

• Атрибуты (переменные)
• Методы (функции)
• Свойства (properties с getter/setter)
• Магические методы (операторы и поведение)
• Наследование (расширение функциональности)
• Инкапсуляцию (скрытие деталей)

Классы — это основа объектно-ориентированного программирования в Python и позволяют писать структурированный, переиспользуемый и maintainable код.