📌 Как в классах хранятся атрибуты и методы?

💬 Спрашивают в 3% собеседований

В Python классы и их экземпляры хранят атрибуты и методы в определённых структурах данных. Понимание этих структур помогает лучше понять, как работают классы и объекты, а также как Python реализует инкапсуляцию и наследование.

🤔 Хранение атрибутов в экземплярах класса

Экземпляры классов хранят свои атрибуты в специальном словаре __dict__. Этот словарь содержит пары ключ-значение, где ключ — это имя атрибута, а значение — его значение.

➕ Пример:

class MyClass:
    def __init__(self, value):
        self.value = value

obj = MyClass(42)
print(obj.__dict__)  # Вывод: {'value': 42}

🤔 Хранение атрибутов и методов в классах

Классы в Python также используют словарь __dict__, чтобы хранить свои атрибуты и методы. Этот словарь доступен через атрибут __dict__ класса и содержит все атрибуты и методы класса.

➕ Пример:

class MyClass:
    class_attribute = "Классовый атрибут"

    def __init__(self, value):
        self.value = value

    def method(self):
        return "Метод экземпляра"

print(MyClass.__dict__)
# Выводит словарь, содержащий class_attribute, __init__, method и другие служебные атрибуты

🤔 Атрибуты и методы наследуются

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

➕ Пример наследования:

class Parent:
    def method(self):
        return "Метод родителя"

class Child(Parent):
    pass

child = Child()
print(child.method())  # Вывод: "Метод родителя"

🤔 Порядок поиска атрибутов и методов: MRO

Порядок разрешения методов (MRO) определяет, в каком порядке Python ищет атрибуты и методы. MRO можно получить с помощью метода mro() или атрибута __mro__.

➕ Пример получения MRO:

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

print(D.mro())
# Вывод: [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

🤔 Специальные атрибуты класса

➕ `__dict__`: Содержит атрибуты и методы класса или экземпляра.
➕ `__mro__`: Кортеж, показывающий порядок разрешения методов.
➕ `__bases__`: Кортеж базовых классов, от которых наследуется класс.

➕ Пример специальных атрибутов:

class Parent:
    pass

class Child(Parent):
    pass

print(Child.__bases__)  # Вывод: (<class '__main__.Parent'>,)
print(Child.__mro__)    # Вывод: (<class '__main__.Child'>, <class '__main__.Parent'>, <class 'object'>)

🤔 Подводя итог

Атрибуты и методы экземпляров класса хранятся в словаре __dict__ экземпляра, а атрибуты и методы самого класса — в словаре __dict__ класса. Наследование и порядок разрешения методов (MRO) определяют, как Python ищет атрибуты и методы в иерархии классов.

🤔Кратко:

Атрибуты экземпляров хранятся в __dict__ объекта, а атрибуты и методы класса — в __dict__ класса. Порядок разрешения методов (MRO) определяет, как Python ищет атрибуты и методы.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Чем отличается класс от объекта класса?

💬 Спрашивают в 3% собеседований

🤔 Отличие класса от объекта класса

🤔 Класс

Класс — это шаблон или чертеж для создания объектов. Он определяет набор свойств и методов, которые будут у объектов этого класса. Класс описывает, что должно быть у объектов, но сам по себе не является конкретным экземпляром.

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        return f"{self.name} barks"

В этом примере Dog — это класс, который определяет, что у каждой собаки будет имя и метод bark().

🤔 Объект класса

Объект класса — это конкретный экземпляр класса, созданный на основе его шаблона. Он имеет реальные данные и может выполнять методы, определенные в классе.

my_dog = Dog("Rex")
print(my_dog.bark())  # Выведет: Rex barks

my_dog — это объект класса Dog. Он имеет конкретное имя "Rex" и может выполнять метод bark().

🤔 Основные отличия:

1️⃣ Определение vs. Реализация:
- Класс: Определяет свойства и поведение (методы).
- Объект: Реализует эти свойства и методы с конкретными данными.

2️⃣ Создание:
- Класс: Создается один раз и служит шаблоном.
- Объект: Можно создать множество объектов на основе одного класса.

3️⃣ Статические vs. Динамические:
- Класс: Статичен, определяет общую структуру.
- Объект: Динамичен, хранит конкретное состояние.

🤔 Пример для понимания:

class Car: def __init__(s, m, y): s.m, s.y = m, y
def drive(s): return f"The {s.m} from {s.y} is driving"
c1, c2 = Car("Toyota", 2020), Car("Honda", 2019)
print(c1.drive())  # The Toyota from 2020 is driving
print(c2.drive())  # The Honda from 2019 is driving

- Car — это класс.
- car1 и car2 — это объекты класса Car, каждый из которых имеет свои данные (модель и год выпуска).

🤔 Краткое объяснение

Класс — это шаблон для создания объектов, определяющий свойства и методы. Объект — это конкретный экземпляр класса с реальными данными и функциональностью.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

🤔 Что такое MRO ?

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

Ставь 👍 если знал ответ и 🔥 если нет

📌 Что такое абстракция?

💬 Спрашивают в 3% собеседований

Абстракция — это один из ключевых принципов объектно-ориентированного программирования (ООП), который позволяет упростить сложные системы, скрывая детали их реализации и предоставляя только необходимую функциональность. В Python абстракция достигается через использование классов и интерфейсов, что позволяет разработчикам создавать более понятные и управляемые структуры кода.

🤔 Принцип абстракции

Абстракция позволяет сосредоточиться на том, что делает объект, а не на том, как он это делает. Это достигается путем:

1️⃣ Скрытия внутренней реализации: Пользователи объектов видят только методы и свойства, которые предоставляются классом, но не детали их реализации.
2️⃣Предоставления простого интерфейса: Классы могут предоставлять четко определенные методы, которые обеспечивают взаимодействие с объектами.

🤔 Абстрактные классы и методы в Python

В Python абстракция часто реализуется с использованием абстрактных классов и методов. Абстрактные классы определяются с помощью модуля abc (Abstract Base Classes), а абстрактные методы обозначаются декоратором @abstractmethod.

➕ Пример абстрактного класса

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

    @abstractmethod
    def move(self):
        pass

🤔 Реализация абстрактного класса

Абстрактный класс Animal определяет два абстрактных метода: make_sound и move. Эти методы не имеют реализации и должны быть реализованы в подклассах. Попробуем создать подклассы:

class Dog(Animal):
    def make_sound(self):
        return "Bark"

    def move(self):
        return "Run"

class Cat(Animal):
    def make_sound(self):
        return "Meow"

    def move(self):
        return "Jump"

Теперь мы можем создать объекты классов Dog и Cat и использовать их методы, не задумываясь о деталях реализации.

dog = Dog()
print(dog.make_sound())  # Вывод: "Bark"
print(dog.move())        # Вывод: "Run"

cat = Cat()
print(cat.make_sound())  # Вывод: "Meow"
print(cat.move())        # Вывод: "Jump"

🤔 Преимущества абстракции

1️⃣ Упрощение сложных систем: Абстракция помогает разбивать сложные системы на более управляемые части.
2️⃣ Повышение читабельности и поддерживаемости кода: Код становится более понятным, так как скрываются ненужные детали реализации.
3️⃣ Снижение зависимости кода: Изменения в реализации не влияют на пользователей класса, что позволяет более гибко изменять и расширять функциональность.

🤔 Подводя итог

Абстракция в ООП позволяет скрывать детали реализации и предоставлять простой интерфейс для взаимодействия с объектами. В Python абстракция достигается через абстрактные классы и методы, которые определяются с использованием модуля abc и декоратора @abstractmethod.

🤔Кратко:

Абстракция скрывает детали реализации и предоставляет простой интерфейс для использования объектов. В Python это реализуется с помощью абстрактных классов и методов.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Какие типы полиморфизма есть в python?

💬 Спрашивают в 3% собеседований

В Python существуют два основных типа полиморфизма: перегрузка методов и наследование и переопределение методов. Давайте рассмотрим каждый из них подробнее.

1️⃣ Перегрузка методов
Перегрузка методов подразумевает использование одного и того же метода с различными типами данных. Однако в Python это реализуется несколько иначе, чем в статически типизированных языках, таких как C++ или Java. В Python отсутствует явная поддержка перегрузки методов. Вместо этого мы можем использовать стандартные функции с переменным числом аргументов.

Пример:

class Math:
    def add(self, a, b, c=0):
        return a + b + c

math = Math()
print(math.add(2, 3))  # 5
print(math.add(2, 3, 4))  # 9

В этом примере метод add может принимать два или три аргумента, что является примером неявной перегрузки.

2️⃣ Наследование и переопределение методов
Наследование и переопределение методов – это более распространенный и важный аспект полиморфизма в Python. Это когда методы в дочернем классе переопределяют поведение методов в базовом классе.

Пример:

class Animal:
    def sound(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def sound(self):
        return "Woof"

class Cat(Animal):
    def sound(self):
        return "Meow"

def make_sound(animal):
    print(animal.sound())

dog = Dog()
cat = Cat()

make_sound(dog)  # Woof
make_sound(cat)  # Meow

В этом примере класс Dog и класс Cat переопределяют метод sound базового класса Animal. Функция make_sound вызывает метод sound независимо от конкретного типа объекта.

🤔 Краткий итог:
1️⃣ Перегрузка методов позволяет использовать методы с различным числом аргументов.
2️⃣ Наследование и переопределение методов позволяет дочерним классам реализовывать или изменять поведение методов базового класса.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Как создать итератор из коллекции?

💬 Спрашивают в 3% собеседований

В Python можно создать итератор из коллекции, используя встроенную функцию iter(). Итераторы – это объекты, которые реализуют метод __iter__() и метод __next__(). Давайте рассмотрим, как это работает на примере.

🤔 Пример создания итератора

Рассмотрим список, который является одной из стандартных коллекций в Python:

my_list = [1, 2, 3, 4, 5]

Чтобы создать итератор из этого списка, используем функцию iter():

my_iterator = iter(my_list)

Теперь my_iterator – это итератор, который можно использовать для поочередного доступа к элементам списка.

🤔 Использование итератора

Мы можем использовать функцию next() для получения следующего элемента итератора:

print(next(my_iterator))  # Выводит: 1
print(next(my_iterator))  # Выводит: 2
print(next(my_iterator))  # Выводит: 3

Когда элементы коллекции заканчиваются, next() вызовет исключение StopIteration.

🤔 Итераторы и циклы

Обычно итераторы используются в сочетании с циклами for, что упрощает работу с ними:

for item in my_iterator:
    print(item)

Если попытаться использовать итератор повторно после его исчерпания, он больше не будет выдавать элементы:

my_iterator = iter(my_list)
for item in my_iterator:
    print(item)

# Повторное использование того же итератора:
for item in my_iterator:
    print(item)  # Ничего не выведет, так как итератор уже исчерпан

🤔 Создание собственного итератора

Можно создать собственный итератор, определив класс с методами __iter__() и __next__().

Пример:

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

my_iterable = MyIterator([10, 20, 30])
for item in my_iterable:
    print(item)

В этом примере мы создали собственный итератор, который перебирает элементы списка [10, 20, 30].

🤔 Краткий итог:
1️⃣ Итератор можно создать из коллекции с помощью функции iter().
2️⃣ Итераторы используют методы __iter__() и __next__() для поочередного доступа к элементам.
3️⃣ Итераторы обычно применяются в циклах for для удобства перебора элементов коллекции.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Как создать класс, который поддерживает протокол итератора?

💬 Спрашивают в 3% собеседований

Для того чтобы создать класс, который поддерживает протокол итератора в Python, нужно определить два метода: __iter__() и __next__(). Давайте рассмотрим пошагово, как это сделать.

1️⃣ Определение класса

Начнем с создания класса, который будет содержать коллекцию данных. В данном примере это будет список.

class MyIterable:
    def __init__(self, data):
        self.data = data
        self.index = 0

2️⃣: Метод `__iter__()`

Метод __iter__() должен возвращать сам итератор. В данном случае наш класс сам будет являться итератором, поэтому метод __iter__() будет возвращать self.

class MyIterable:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

3️⃣ Метод `__next__()`

Метод __next__() должен возвращать следующий элемент последовательности. Если элементы закончились, метод должен вызывать исключение StopIteration.

class MyIterable:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

🤔 Полный пример

class MyIterable:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

# Создаем объект нашего класса
my_iterable = MyIterable([10, 20, 30, 40, 50])

# Используем его в цикле for
for item in my_iterable:
    print(item)

🤔 Объяснение

1️⃣Инициализация (`__init__`): Мы создаем объект класса и передаем ему список данных. self.data хранит данные, а self.index отслеживает текущую позицию в последовательности.
2️⃣ Итерация (`__iter__`): Метод __iter__() возвращает сам объект, так как наш класс будет сам итератором.
3️⃣ Следующий элемент (`__next__`): Метод __next__() возвращает следующий элемент в последовательности и увеличивает индекс. Если элементов больше нет, вызывается исключение StopIteration.

🤔 Краткий итог:
1️⃣Определите методы __iter__() и __next__() в вашем классе.
2️⃣ __iter__() должен возвращать объект итератора (обычно self).
3️⃣ __next__() должен возвращать следующий элемент или вызывать StopIteration, если элементов больше нет.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Для чего нужны static method?

💬 Спрашивают в 3% собеседований

Статические методы (static methods) в Python используются для создания методов, которые связаны с классом, но не требуют доступа к экземпляру этого класса или к самим данным класса. Это методы, которые выполняют функции, связанные с классом, но не изменяют и не используют состояние экземпляра (атрибуты объекта) или состояние самого класса (атрибуты класса). Они могут быть вызваны на уровне класса, а не на уровне экземпляра класса.

🤔 Как создать статический метод

Для создания статического метода в Python используется декоратор @staticmethod. Давайте рассмотрим пример:

class MyClass:
    @staticmethod
    def static_method(arg1, arg2):
        return arg1 + arg2

🤔 Пример использования статического метода

Вы можете вызывать статический метод как через сам класс, так и через его экземпляр:

result = MyClass.static_method(5, 10)
print(result)  # Вывод: 15

my_instance = MyClass()
result = my_instance.static_method(3, 7)
print(result)  # Вывод: 10

🤔 Зачем нужны статические методы

1️⃣ Логическая группировка: Статические методы позволяют логически группировать функции, которые связаны с классом, но не зависят от состояния конкретного экземпляра. Это помогает организовать код и делает его более читабельным.

2️⃣ Удобство вызова: Иногда полезно вызывать метод, не создавая экземпляр класса. Например, если метод выполняет какую-то утилитарную функцию или обрабатывает данные, не связанные с объектом.

3️⃣ Избежание изменений состояния: Поскольку статические методы не могут изменять состояние экземпляра или класса, их использование может способствовать созданию безопасного и предсказуемого кода.

🤔 Сравнение с методами класса и экземпляра

➕ Методы экземпляра: Методы экземпляра (instance methods) принимают первым аргументом self, что позволяет им изменять состояние конкретного экземпляра класса.

  class MyClass:
      def instance_method(self, value):
          self.value = value
  

➕ Методы класса: Методы класса (class methods) принимают первым аргументом cls, что позволяет им изменять состояние самого класса.

  class MyClass:
      class_variable = 0

      @classmethod
      def class_method(cls, value):
          cls.class_variable = value
  

➕ Статические методы: Статические методы не принимают self или cls в качестве первого аргумента и не могут изменять состояние экземпляра или класса.

  class MyClass:
      @staticmethod
      def static_method(arg1, arg2):
          return arg1 + arg2
  

🤔 Краткий итог:
1️⃣Статические методы используются для функций, которые не зависят от состояния экземпляра или класса.
2️⃣ Они создаются с помощью декоратора @staticmethod.
3️⃣ Такие методы удобны для логической группировки и вызова функций без создания экземпляра класса.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Для чего нужны class method?

💬 Спрашивают в 3% собеседований
Методы класса (class methods) в Python используются для методов, которые работают с самим классом, а не с его экземплярами. Они позволяют изменять состояние класса или выполнять операции, которые относятся ко всему классу в целом, а не к отдельным его экземплярам.

🤔 Как создать метод класса

Для создания метода класса в Python используется декоратор @classmethod. Такие методы принимают первым аргументом не self (как в методах экземпляра), а cls, что указывает на сам класс.

Пример:

class MyClass:
    class_variable = 0

    @classmethod
    def class_method(cls, value):
        cls.class_variable = value

🤔 Пример использования метода класса

Метод класса можно вызывать как на уровне класса, так и через экземпляры класса:

# Вызов метода класса через сам класс
MyClass.class_method(10)
print(MyClass.class_variable)  # Вывод: 10

# Вызов метода класса через экземпляр класса
instance = MyClass()
instance.class_method(20)
print(MyClass.class_variable)  # Вывод: 20

🤔 Зачем нужны методы класса

1️⃣ Работа с атрибутами класса: Методы класса позволяют изменять атрибуты класса, а не отдельного экземпляра. Это полезно, когда нужно поддерживать общее состояние для всех экземпляров класса.

2️⃣ Фабричные методы: Методы класса часто используются для создания экземпляров класса с определенными параметрами или для реализации альтернативных конструкторов.

3️⃣ Логическая группировка: Они позволяют логически группировать функции, связанные с классом, делая код более организованным и понятным.

🤔 Пример фабричного метода

Фабричный метод — это метод класса, который возвращает новый экземпляр класса. Рассмотрим пример, где метод класса используется для создания объекта с предустановленными значениями.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_birth_year(cls, name, birth_year):
        age = 2024 - birth_year
        return cls(name, age)

# Создание экземпляра через основной конструктор
person1 = Person("Alice", 30)
print(person1.name, person1.age)  # Вывод: Alice 30

# Создание экземпляра через фабричный метод
person2 = Person.from_birth_year("Bob", 1990)
print(person2.name, person2.age)  # Вывод: Bob 34

🤔 Сравнение с методами экземпляра и статическими методами

➕ Методы экземпляра: Методы, которые работают с конкретным экземпляром класса и могут изменять его состояние (принимают self).

  class MyClass:
      def instance_method(self, value):
          self.value = value
  

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

  class MyClass:
      @staticmethod
      def static_method(arg1, arg2):
          return arg1 + arg2
  

➕ Методы класса: Методы, которые работают с самим классом и могут изменять его состояние (используют декоратор @classmethod).

  class MyClass:
      class_variable = 0

      @classmethod
      def class_method(cls, value):
          cls.class_variable = value
  

🤔 Краткий итог:
1️⃣ Методы класса используются для работы с атрибутами и состоянием самого класса.
2️⃣ Они создаются с помощью декоратора @classmethod и принимают cls в качестве первого аргумента.
3️⃣ Часто применяются для реализации фабричных методов и логической группировки функций, связанных с классом.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

🤔 Чем обычный метод отличается от class method?

Обычные методы и методы класса в Python различаются в основном тем, к чему они привязаны и как используются. Давайте рассмотрим их отличия более подробно.

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

Привязка к экземпляру:
🟠Обычные методы работают с конкретными экземплярами класса.
🟠Они принимают первым аргументом self, который указывает на текущий экземпляр класса.

Использование атрибутов: Могут изменять состояние экземпляра, то есть работать с его атрибутами.

Определение:

   class MyClass:
       def instance_method(self, value):
           self.value = value

Вызов:

   instance = MyClass()
   instance.instance_method(10)

Пример:

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(f"{self.name} говорит: Гав-гав!")

dog = Dog("Бобик")
dog.bark()  # Вывод: Бобик говорит: Гав-гав!

🚩Методы класса (Class Methods)

Привязка к классу:
🟠Методы класса работают с самим классом и его атрибутами.
🟠Они принимают первым аргументом cls, который указывает на сам класс.

Использование атрибутов: Могут изменять состояние класса, то есть работать с атрибутами класса.

Определение:

   class MyClass:
       class_variable = 0

       @classmethod
       def class_method(cls, value):
           cls.class_variable = value

Вызов: Могут вызываться как через сам класс, так и через его экземпляры.

   MyClass.class_method(10)
   instance = MyClass()
   instance.class_method(20)
   

Пример:

class Dog:
    total_dogs = 0

    def __init__(self, name):
        self.name = name
        Dog.total_dogs += 1

    @classmethod
    def get_total_dogs(cls):
        return cls.total_dogs

dog1 = Dog("Бобик")
dog2 = Dog("Шарик")
print(Dog.get_total_dogs())  # Вывод: 2

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое dependency injection?

Внедрение зависимостей (Dependency Injection, DI) — это дизайн-паттерн, используемый в объектно-ориентированном программировании для управления зависимостями между объектами. Внедрение зависимостей позволяет сделать код более гибким, тестируемым и поддерживаемым, отделяя создание объектов от их использования.

🚩Основные концепции

🟠Зависимости: Это объекты, от которых зависит класс. Например, если класс Car использует объект Engine, то Engine является зависимостью для Car.
🟠Внедрение: Процесс передачи зависимостей классу. Вместо того чтобы создавать зависимости внутри класса, они передаются извне.

🚩Преимущества внедрения зависимостей

🟠Снижение связности: Классы меньше зависят друг от друга, что упрощает их замену или модификацию.
🟠Упрощение тестирования: Легче подменять реальные зависимости на моки или стабы для написания тестов.
🟠Улучшение читаемости и поддержки кода: Код становится более модульным и легче поддерживается.

🚩Типы внедрения зависимостей

🟠Внедрение через конструктор: Зависимости передаются через параметры конструктора.
🟠Внедрение через методы (или сеттеры): Зависимости передаются через специальные методы.
🟠Внедрение через свойства: Зависимости назначаются через свойства объекта.

Рассмотрим пример, где класс Car зависит от класса Engine.

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self, engine):
        self.engine = engine

    def start(self):
        self.engine.start()
        print("Car started")

# Создание объекта Engine
engine = Engine()

# Внедрение зависимости Engine в объект Car через конструктор
car = Car(engine)
car.start()

Внедрения через методы (сеттеры)

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self.engine = None

    def set_engine(self, engine):
        self.engine = engine

    def start(self):
        if self.engine is not None:
            self.engine.start()
            print("Car started")
        else:
            print("No engine to start")

# Создание объекта Engine
engine = Engine()

# Создание объекта Car
car = Car()

# Внедрение зависимости Engine в объект Car через метод
car.set_engine(engine)
car.start()

Внедрения через свойства

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self._engine = None

    @property
    def engine(self):
        return self._engine

    @engine.setter
    def engine(self, engine):
        self._engine = engine

    def start(self):
        if self._engine is not None:
            self._engine.start()
            print("Car started")
        else:
            print("No engine to start")

# Создание объекта Engine
engine = Engine()

# Создание объекта Car
car = Car()

# Внедрение зависимости Engine в объект Car через свойство
car.engine = engine
car.start()

Ставь 👍 и забирай 📚 Базу знаний