🤔 Что такое индексы и как они работают?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое gPRC?

Это современный высокопроизводительный фреймворк для удаленных вызовов процедур (RPC), разработанный Google. Он использует HTTP/2 для транспортировки, Protocol Buffers (protobuf) для сериализации данных и предоставляет возможности, такие как аутентификация, балансировка нагрузки, двухсторонняя потоковая передача и многое другое.

🚩Зачем нужен?

🟠Высокая производительность
Использует HTTP/2, что обеспечивает низкую задержку и высокую пропускную способность.
🟠Многоязычная поддержка
Поддерживает множество языков программирования, включая C++, Java, Python, Go и многие другие.
🟠Простота использования
Обеспечивает простой способ определения сервисов с помощью Protocol Buffers.
🟠Двусторонняя потоковая передача
Поддерживает как однонаправленные, так и двусторонние потоки данных.
🟠Платформенная независимость
Обеспечивает взаимодействие между разными системами и языками программирования.

🚩Основные компоненты

🟠Сервисы
В gRPC услуги определяются с помощью файлов .proto (Protocol Buffers), где описываются методы и их параметры.
🟠Клиенты и серверы
gRPC автоматически генерирует код для клиентов и серверов на основе .proto файлов.
🟠Сериализация данных
Используются Protocol Buffers для сериализации и десериализации данных, что обеспечивает эффективную передачу по сети.

🚩Пример

1⃣Определение сервиса
Создайте файл service.proto для определения сервиса и его методов:

syntax = "proto3";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

2⃣Генерация кода
Сгенерируйте код клиента и сервера на языке Python:

python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. service.proto

3⃣Реализация сервера
Создайте сервер, используя сгенерированный код:

from concurrent import futures
import grpc
import service_pb2
import service_pb2_grpc

class Greeter(service_pb2_grpc.GreeterServicer):
    def SayHello(self, request, context):
        return service_pb2.HelloReply(message=f"Hello, {request.name}!")

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    service_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()

if __name__ == '__main__':
    serve()

4⃣Реализация клиента
Создайте клиент для вызова удаленного метода:

import grpc
import service_pb2
import service_pb2_grpc

def run():
    with grpc.insecure_channel('localhost:50051') as channel:
        stub = service_pb2_grpc.GreeterStub(channel)
        response = stub.SayHello(service_pb2.HelloRequest(name='World'))
    print("Greeter client received: " + response.message)

if __name__ == '__main__':
    run()

🚩Плюсы

➕Эффективность
Высокая производительность благодаря HTTP/2 и Protocol Buffers.
➕Многоязычность
Поддержка множества языков программирования.
➕Простота определения
Простое определение сервисов с помощью Protocol Buffers.
➕Расширенные возможности
Поддержка стриминга, аутентификации, балансировки нагрузки и других функций.
➕Платформенная независимость
Возможность взаимодействия между различными системами.

🚩Минусы

➖Крутая кривая обучения
Необходимость изучения Protocol Buffers и особенностей gRPC.
➖Ограниченная поддержка браузеров
gRPC не поддерживается напрямую в браузерах, хотя есть gRPC-Web для этих целей.
➖Сложности с отладкой
Отладка распределенных систем с использованием gRPC может быть сложной.

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

🤔 Что может быть ключем в словаре?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое проблема наследования?

Относится к ряду сложностей и недостатков, которые могут возникнуть при использовании наследования в объектно-ориентированном программировании. Хотя наследование является мощным механизмом для повторного использования кода и создания иерархий классов, оно также может привести к различным проблемам.

🚩Проблемы наследования

🟠Хрупкость базового класса
Изменения в базовом классе могут неожиданно повлиять на все производные классы. Это может вызвать ошибки, которые трудно отладить, особенно в больших системах.

🟠Повышенная связанность
Наследование создает тесную связанность между базовым и производными классами. Это затрудняет изменение одного класса без затрагивания других.

🟠Проблемы с повторным использованием
Иногда наследование используется для повторного использования кода, но это не всегда лучший подход. Наследование может привести к сложным иерархиям классов, которые трудно понять и сопровождать.

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

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

🟠Проблемы с множественным наследованием
В языках, поддерживающих множественное наследование (например, C++), это может привести к проблемам, таким как "ромбовидная" проблема, где один и тот же базовый класс наследуется более одного раза через разные пути в иерархии.

🚩Пример проблемы

Рассмотрим пример, где базовый класс изменяется, что приводит к неожиданным последствиям для производных классов. В этом примере изменение базового класса Animal может повлиять на работу производных классов Dog и Cat, особенно если они зависят от определенной реализации метода sound.

class Animal:
    def sound(self):
        return "Some sound"

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

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

# Изменение базового класса
class Animal:
    def sound(self):
        return "Default sound"

animals = [Dog(), Cat()]
for animal in animals:
    print(animal.sound())

🚩Альтернативы и решения

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

🟠Интерфейсы и абстрактные классы
Использование интерфейсов и абстрактных классов позволяет определить контракты для классов, не предоставляя реализации. Это помогает уменьшить связанность и улучшить гибкость.

🟠Шаблон проектирования "Стратегия"
Этот паттерн позволяет изменять алгоритмы поведения объекта во время выполнения, что может быть более гибким решением, чем наследование.

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

🤔 Что такое полиморфизм?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Когда нельзя линеаризовать?

🟠Асинхронное программирование
В асинхронном коде выполнение задач происходит не в линейном порядке, а в зависимости от готовности событий. Здесь линеаризация может привести к потере преимуществ асинхронности.

import asyncio

async def fetch_data():
await asyncio.sleep(1)
return "Data fetched"

async def main():
data = await fetch_data()
print(data)

asyncio.run(main())

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

def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)

🟠Обработка исключений
В некоторых случаях требуется обработка ошибок и исключений, что нарушает линейную структуру кода.

try:
result = 10 / 0
except ZeroDivisionError:
print("Деление на ноль!")

🟠Сложные циклы и условия
Когда код содержит сложные вложенные циклы и условия, его линейное представление становится громоздким и трудночитаемым.

for i in range(10):
for j in range(10):
if i == j:
print(f"{i} равно {j}")

🟠Паттерны проектирования
Некоторые паттерны проектирования, такие как фабричный метод или стратегия, предполагают использование классов и объектов, что не всегда удобно линеаризовать.

class Animal:
def speak(self):
pass

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

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

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

🟠Параллелизм
Параллельные вычисления, где задачи выполняются одновременно в разных потоках или процессах, не могут быть линеаризованы.

import threading

def print_numbers():
for i in range(5):
print(i)

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

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

🤔 Что такое лямбда-функции?

Лямбда-функции в Python — это анонимные функции, которые создаются с помощью ключевого слова `lambda`. Они могут принимать любое количество аргументов, но содержат только одно выражение, результат которого возвращается. Лямбда-функции часто используются для кратковременных операций, таких как сортировка или фильтрация данных. Это упрощённая версия функций, которая делает код более лаконичным.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 В чем основные принципы инкапсуляции?

🟠Скрытие данных
Инкапсуляция предполагает скрытие внутреннего состояния объекта от внешнего мира. Это достигается с помощью модификаторов доступа, таких как private, protected и public. В Python используются соглашения об именовании (например, одиночное подчеркивание _ для "protected" и двойное подчеркивание __ для "private") для индикации уровня доступа.

🟠Контроль доступа
Инкапсуляция позволяет контролировать доступ к данным и методам объекта. Это предотвращает некорректное использование или изменение состояния объекта, что может привести к ошибкам.

🟠Интерфейсы
Инкапсуляция способствует созданию четких интерфейсов для взаимодействия с объектами. Внешний код взаимодействует с объектом через его публичные методы, не зная о внутреннем устройстве.

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

В этом примере переменная __balance скрыта от внешнего доступа. Методы deposit, withdraw и get_balance обеспечивают контролируемый доступ к этой переменной, обеспечивая инкапсуляцию.

class BankAccount:
    def __init__(self, initial_balance):
        self.__balance = initial_balance  # Закрытая переменная

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
        else:
            raise ValueError("Amount must be positive")

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
        else:
            raise ValueError("Invalid withdrawal amount")

    def get_balance(self):
        return self.__balance

# Создание объекта и взаимодействие с ним
account = BankAccount(100)
account.deposit(50)
print(account.get_balance())  # 150
account.withdraw(30)
print(account.get_balance())  # 120

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

🤔 Что такое миксин?

Миксин — это класс, который предоставляет вспомогательные методы или свойства для использования в других классах через множественное наследование. Миксины не предназначены для самостоятельного использования, их задача — расширять функциональность других классов без изменения их основной логики. Миксины помогают избежать дублирования кода и улучшить модульность в программировании. Они широко применяются в фреймворках, таких как Django, для добавления общей логики в разные классы.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Для чего они нужны dunder методы?

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

🟠Инициализация объектов
Метод __init__ используется для инициализации новых объектов. Он позволяет задавать начальные значения атрибутов объекта.

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

person = Person("Alice", 30) 

🟠Представление объектов в виде строки
Метод __str__ определяет, как объект будет представлен в виде строки. Это удобно для пользовательского вывода.

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

    def __str__(self):
        return f"{self.name}, {self.age} years old"

person = Person("Alice", 30)
print(person)  # Alice, 30 years old   

🟠Перегрузка операторов
Dunder методы позволяют перегружать стандартные операторы. Например, __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(2, 3)
v2 = Vector(5, 7)
v3 = v1 + v2
print(v3)  # Vector(7, 10)   

🟠Доступ к элементам по индексу
Метод __getitem__ позволяет определить, как объект класса будет вести себя при доступе к его элементам по индексу.

class CustomList:
    def __init__(self, elements):
        self.elements = elements

    def __getitem__(self, index):
       return self.elements[index]

clist = CustomList([1, 2, 3, 4, 5])
print(clist[2])  # 3   

🟠Контекстные менеджеры
Метод __enter__ и __exit__ позволяют создавать объекты, которые могут использоваться в контекстах with.

class ManagedFile:
    def __init__(self, filename):
        self.filename = filename

    def __enter__(self):
        self.file = open(self.filename, 'r')
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()

with ManagedFile('example.txt') as f:
    content = f.read()
    print(content)   

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

🤔 Что такое MRO?

MRO (Method Resolution Order) — это порядок, в котором Python ищет методы в иерархии классов при множественном наследовании. MRO определяет последовательность классов, в которых Python будет искать атрибуты или методы, начиная с самого класса и двигаясь вверх по иерархии. Python использует алгоритм C3 Linearization для вычисления MRO. Порядок можно просмотреть с помощью метода `mro()` или функции `super()`.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Методы __len__ и __abs__?

Являются специальными методами, которые позволяют классам взаимодействовать с встроенными функциями len() и abs() соответственно. Эти методы помогают сделать пользовательские объекты более интуитивно понятными и удобными для использования.

🚩Метод __len__

Используется для определения длины объекта. Он должен возвращать количество элементов в объекте или какую-то другую числовую характеристику длины объекта. Например, для списков, кортежей и строк метод __len__ возвращает количество элементов или символов.

class MyCollection:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)

collection = MyCollection([1, 2, 3, 4, 5])
print(len(collection))  # Вывод: 5

🚩Метод __abs__

Метод __abs__ используется для определения абсолютного значения объекта. Он должен возвращать абсолютное значение объекта, как это делает встроенная функция abs() для чисел.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __abs__(self):
        return (self.x**2 + self.y**2) ** 0.5

vector = Vector(3, 4)
print(abs(vector))  # Вывод: 5.0

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

🤔 Для чего нужен PEP8?

PEP8 — это стиль кодирования, который описывает рекомендуемые стандарты для написания кода на Python. Его цель — сделать код более читаемым и согласованным между разными проектами и разработчиками. PEP8 охватывает различные аспекты, такие как отступы, именование переменных и функций, использование пробелов и длину строк. Соблюдение PEP8 улучшает качество кода и облегчает его поддержку и совместную работу над проектами.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое конструктор класса?

Это специальный метод, который вызывается автоматически при создании нового объекта класса. Этот метод называется __init__(). Он используется для инициализации объекта, то есть задания начальных значений атрибутов объекта.

🚩Создание класса с конструктором

Необходимо определить метод __init__() внутри класса.

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

    def display_info(self):
        print(f"Name: {self.name}, Age: {self.age}")

🚩Создание объекта класса

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

person1 = Person("Alice", 30)
person1.display_info()

🚩Пример с доп. методами

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

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

# Создание объекта
rect1 = Rectangle(10, 5)
print(f"Area: {rect1.area()}")           # Вывод: Area: 50
print(f"Perimeter: {rect1.perimeter()}") # Вывод: Perimeter: 30

Класс Rectangle имеет конструктор, который инициализирует атрибуты width и height. Методы area() и perimeter() вычисляют и возвращают площадь и периметр прямоугольника соответственно.

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

🤔 Что такое асинхронность?

Асинхронность в Python позволяет выполнять несколько операций одновременно, не блокируя выполнение программы. Асинхронные функции определяются с помощью ключевого слова `async`, и их выполнение управляется событиями, что делает возможным параллельное выполнение задач без использования потоков или процессов. Основные функции асинхронности включают `asyncio` и `await` для управления асинхронными операциями. Асинхронность особенно полезна для ввода-вывода и сетевых операций.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое рефлексия?

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

🚩Возможности

🟠Получение информации о типах данных и структурах
Определение типа объекта и его структуры во время выполнения.

🟠Динамическое создание и манипулирование объектами
Создание экземпляров классов и вызов их методов без явного указания имен классов и методов в коде.

🟠Инспекция и изменение атрибутов и методов
Доступ к атрибутам и методам объектов, их изменение и вызов.

🚩Примеры рефлексии в Python

1⃣Получение типа объекта и структуры

x = [1, 2, 3]

print(type(x))  # <class 'list'>
print(dir(x))   # Выводит все методы и атрибуты объекта списка

2⃣Проверка наличия и получение атрибутов и методов

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

    def my_method(self):
        return "Hello, world!"

obj = MyClass(10)

# Проверка наличия атрибута
print(hasattr(obj, 'value'))  # True

# Получение значения атрибута
print(getattr(obj, 'value'))  # 10

# Установка значения атрибута
setattr(obj, 'value', 20)
print(getattr(obj, 'value'))  # 20

# Проверка наличия метода
print(hasattr(obj, 'my_method'))  # True

# Вызов метода
method = getattr(obj, 'my_method')
print(method())  # Hello, world!

3⃣Динамическое создание объектов и вызов методов

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

    def my_method(self):
        return f"Value is {self.value}"

# Динамическое создание объекта
klass = globals()['MyClass']
obj = klass(42)

# Динамический вызов метода
method = getattr(obj, 'my_method')
print(method())  # Value is 42

4⃣Использование модуля inspect

import inspect

def my_function(param1, param2):
    pass

# Получение информации о параметрах функции
signature = inspect.signature(my_function)
for param in signature.parameters.values():
    print(param.name, param.default, param.annotation)

# Получение всех методов класса
class MyClass:
    def method(self):
        pass

methods = inspect.getmembers(MyClass, predicate=inspect.isfunction)
print(methods)  # [('method', <function MyClass.method at 0x...>)]

🚩Плюсы

➕Гибкость
Позволяет писать более общие и гибкие функции, которые могут работать с различными типами данных.
➕Отладка и тестирование
Облегчает отладку и тестирование кода, предоставляя средства для анализа объектов и их состояния.
➕Динамичность
Позволяет адаптировать поведение программы во время выполнения в зависимости от контекста и условий.

🚩Минусы

➖Сложность
Может сделать код более сложным для понимания и сопровождения.
➖Производительность
Рефлексия может повлиять на производительность, особенно при частом использовании в критически важных участках кода.
➖Безопасность
Использование рефлексии может открыть доступ к внутренним частям объектов, что может быть потенциально опасным при неправильном использовании.

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

🤔 Что такое ACID в SQL?

ACID — это набор свойств транзакций в базах данных, которые обеспечивают надёжность и целостность данных: атомарность, согласованность, изолированность и долговечность. Атомарность гарантирует, что все операции в транзакции выполняются как одно целое, согласованность поддерживает данные в согласованном состоянии, изолированность защищает от влияния других транзакций, а долговечность обеспечивает сохранение данных после завершения транзакции. Эти свойства помогают избежать ошибок и сбоев в обработке данных.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое деструктор класса?

Это специальный метод, который вызывается автоматически, когда объект класса уничтожается. В Python этот метод называется __del__(). Деструктор используется для выполнения операций очистки, таких как освобождение ресурсов или выполнение завершающих действий перед тем, как объект будет удален из памяти.

🚩Определение и использование деструктора

Определяется внутри класса с помощью метода __del__().

class FileManager:
    def __init__(self, filename):
        self.file = open(filename, 'w')
        print(f"Файл {filename} открыт для записи.")

    def write_data(self, data):
        self.file.write(data)

    def __del__(self):
        self.file.close()
        print("Файл закрыт.")

🟠Класс FileManager имеет конструктор __init__(), который открывает файл для записи.
🟠Метод write_data() записывает данные в файл.
🟠Деструктор __del__() закрывает файл, когда объект FileManager уничтожается.

🚩Создание и уничтожение объекта

Когда объект класса создается, вызывается конструктор. Когда объект больше не нужен, вызывается деструктор:

manager = FileManager('example.txt')
manager.write_data('Hello, world!')
# Когда объект manager больше не нужен, вызывается деструктор и файл закрывается

🚩Важные замечания

🟠Сборка мусора
Python использует механизм сборки мусора для автоматического управления памятью. Когда объект больше не используется (например, нет активных ссылок на него), сборщик мусора удаляет объект и вызывает его деструктор.

🟠Неопределенное время вызова
Точное время вызова деструктора зависит от работы сборщика мусора. Это означает, что нельзя гарантировать момент вызова деструктора. Поэтому для критических операций лучше использовать явное управление ресурсами, например, с помощью контекстных менеджеров (with).

🟠Контекстные менеджеры
Для явного управления ресурсами и их освобождения в предсказуемый момент лучше использовать контекстные менеджеры.

with open('example.txt', 'w') as file:
    file.write('Hello, world!')
# Файл автоматически закрывается после выхода из блока with   

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

🤔 В чем суть принципа REST?

REST (Representational State Transfer) — это архитектурный стиль для разработки веб-сервисов, который использует стандартные методы HTTP для взаимодействия между клиентом и сервером. В REST каждая операция выполняется с использованием определённого HTTP-метода: GET для получения данных, POST для создания, PUT для обновления и DELETE для удаления. RESTful API использует унифицированные ресурсы и URL для представления данных, а также статeless-коммуникацию между клиентом и сервером. Основной принцип REST — это простота и масштабируемость.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как создать абстрактный класс?

Используется модуль abc (Abstract Base Classes). Абстрактный класс не может быть инстанцирован и предназначен для создания шаблонов, которые должны быть реализованы в подклассах.

🚩Шаги

1⃣Импортирование модуля `abc`
Для использования абстрактных классов и методов нужно импортировать модуль abc.
2⃣Создание абстрактного класса
Абстрактный класс должен наследоваться от ABC (абстрактный базовый класс), который предоставляется модулем abc.
3⃣Определение абстрактных методов
Абстрактные методы обозначаются декоратором @abstractmethod. Эти методы должны быть реализованы в подклассах, иначе они тоже станут абстрактными.

from abc import ABC, abstractmethod

# Создание абстрактного класса
class Animal(ABC):

    @abstractmethod
    def make_sound(self):
        pass

    @abstractmethod
    def move(self):
        pass

# Попытка создания экземпляра абстрактного класса приведет к ошибке
# animal = Animal()  # TypeError: Can't instantiate abstract class Animal with abstract methods make_sound, move

# Создание подклассов, которые реализуют абстрактные методы
class Dog(Animal):
    def make_sound(self):
        return "Woof"

    def move(self):
        return "Runs"

class Bird(Animal):
    def make_sound(self):
        return "Tweet"

    def move(self):
        return "Flies"

# Теперь можно создать экземпляры подклассов
dog = Dog()
print(dog.make_sound())  # Woof
print(dog.move())        # Runs

bird = Bird()
print(bird.make_sound())  # Tweet
print(bird.move())        # Flies

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