Python и парадигма ООП: от основ до продвинутых техник

Как сделать контролируемый доступ к атрибутам с помощью @property

В Python для управления чтением, записью и удалением атрибутов применяется декоратор @property. Это позволяет добавить логику без изменения интерфейса.

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32
    
    @fahrenheit.setter
    def fahrenheit(self, value):
        self._celsius = (value - 32) * 5/9

t = Temperature(0)
print(t.fahrenheit)  # 32.0
t.fahrenheit = 100
print(t._celsius)    # 37.777...

Python функциональный язык (python как функциональный язык)

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

Как организовать иерархию классов через наследование

Наследование позволяет создать дочерний класс на основе родительского, переопределяя или расширяя его функциональность.

class Animal:
    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return "Гав!"

class Cat(Animal):
    def speak(self):
        return "Мяу!"

animals = [Dog(), Cat()]
for a in animals:
    print(a.speak())

Гав!
Мяу!

Цель: повторное использование кода и полиморфизм. Используется при наличии отношения «является».

Как реализовать полиморфизм через магические методы

Магические методы (dunder methods) позволяют объектам вести себя как встроенные типы. Например, __str__, __repr__, __add__.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __str__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # Vector(4, 6)

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

Как защитить атрибуты от случайного изменения с помощью инкапсуляции

Python не имеет строгих модификаторов доступа, но с помощью двух подчёркиваний в начале имени (__name) включается механизм name mangling: имя преобразуется в _ClassName__name.

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance
    
    def get_balance(self):
        return self.__balance
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

acc = BankAccount(100)
# print(acc.__balance)  # AttributeError
print(acc.get_balance())  # 100
print(acc._BankAccount__balance)  # 100 (доступно, но не одобряется)

Цель: скрыть внутреннюю реализацию и предотвратить случайное повреждение данных. Используется для критичных атрибутов (баланс, пароль).

Как создать абстрактный базовый класс с обязательными методами

Модуль abc предоставляет ABC и @abstractmethod. Наследники обязаны реализовать абстрактные методы.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2

# s = Shape()  # TypeError: Can't instantiate abstract class
c = Circle(5)
print(c.area())  # 78.5

Цель: задать интерфейс и гарантировать, что наследники реализуют определённые методы. Используется в крупных фреймворках и библиотеках.

Как работать с множественным наследованием и разрешением конфликтов (MRO)

Python поддерживает множественное наследование. Порядок разрешения методов (MRO) определяется алгоритмом C3 линеаризации. Для просмотра MRO используется __mro__ или mro().

class A:
    def method(self):
        return "A"

class B(A):
    def method(self):
        return "B"

class C(A):
    def method(self):
        return "C"

class D(B, C):
    pass

d = D()
print(d.method())  # B (следует MRO)
print(D.__mro__)   # (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

Цель: комбинировать поведения нескольких классов. Используется, когда класс логически наследует свойства от нескольких предков (например, миксины).

Как использовать композицию вместо наследования для гибкого дизайна

Композиция - это включение одного объекта в другой через атрибуты. Это даёт большую гибкость, чем наследование.

class Engine:
    def start(self):
        return "Двигатель запущен"

class Car:
    def __init__(self):
        self.engine = Engine()
    
    def start(self):
        return self.engine.start()

car = Car()
print(car.start())

Цель: избежать жёсткой иерархии, легко заменять компоненты. Используется, когда объекты связаны отношением «имеет».

Как применять статические методы и методы класса

Статические методы (@staticmethod) не получают неявный первый аргумент. Методы класса (@classmethod) получают класс (cls) и могут вызываться как через класс, так и через экземпляр.

class MathOperations:
    @staticmethod
    def add(x, y):
        return x + y
    
    @classmethod
    def create_instance(cls, value):
        return cls(value)

print(MathOperations.add(3, 4))  # 7
obj = MathOperations.create_instance(10)
print(isinstance(obj, MathOperations))  # True

Цель: статические методы - для вспомогательных функций, методы класса - для альтернативных конструкторов. Используются, когда метод логически принадлежит классу, но не требует доступа к экземпляру.

Как создавать вызываемые объекты с помощью магического метода __call__

Метод __call__ позволяет экземпляру класса вести себя как функция.

class Multiplier:
    def __init__(self, factor):
        self.factor = factor
    
    def __call__(self, x):
        return x * self.factor

double = Multiplier(2)
print(double(5))  # 10

Цель: создание функциональных объектов с сохранением состояния. Используется в декораторах, замыканиях, генераторах.