🤔 Что такое декораторы?

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

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

🤔 Что такое Наблюдатель (Observer)?

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

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

🟠Разделение обязанностей:
Позволяет отделить объект, который изменяет свое состояние, от объектов, которые реагируют на эти изменения.
🟠Поддержка реактивного программирования:
Обеспечивает автоматическое уведомление и обновление зависимых объектов при изменении состояния наблюдаемого объекта.
🟠Гибкость и расширяемость:
Легко добавлять или удалять наблюдателей без изменения кода наблюдаемого объекта.
Пример реализации

from abc import ABC, abstractmethod

class Observer(ABC):
    @abstractmethod
    def update(self, message: str):
        pass

class ConcreteObserver(Observer):
    def __init__(self, name: str):
        self._name = name
    
    def update(self, message: str):
        print(f"{self._name} received message: {message}")

class Subject:
    def __init__(self):
        self._observers = []
    
    def add_observer(self, observer: Observer):
        self._observers.append(observer)
    
    def remove_observer(self, observer: Observer):
        self._observers.remove(observer)
    
    def notify_observers(self, message: str):
        for observer in self._observers:
            observer.update(message)

# Клиентский код для использования паттерна Наблюдатель
def main():
    subject = Subject()
    
    observer1 = ConcreteObserver("Observer 1")
    observer2 = ConcreteObserver("Observer 2")
    
    subject.add_observer(observer1)
    subject.add_observer(observer2)
    
    subject.notify_observers("Event 1")  # Observer 1 received message: Event 1
                                        # Observer 2 received message: Event 1
    
    subject.remove_observer(observer1)
    
    subject.notify_observers("Event 2")  # Observer 2 received message: Event 2

if __name__ == "__main__":
    main()

1⃣`Observer`:
Объявляет метод update, который должны реализовать все конкретные наблюдатели.
2⃣`ConcreteObserver`:
Реализует интерфейс Observer и определяет, как наблюдатель должен реагировать на обновления.
3⃣`Subject`:
Содержит список наблюдателей и методы для добавления, удаления и уведомления наблюдателей.
4⃣`notify_observers`:
Вызывается при изменении состояния субъекта и уведомляет всех зарегистрированных наблюдателей.

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

🤔 Что такое генератор?

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

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

🤔 Что такое паттерн Состояние (State)?

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

🚩Зачем нужен

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

from abc import ABC, abstractmethod

# Интерфейс состояния
class State(ABC):
    @abstractmethod
    def insert_coin(self):
        pass
    
    @abstractmethod
    def eject_coin(self):
        pass
    
    @abstractmethod
    def dispense(self):
        pass

# Конкретные состояния
class NoCoinState(State):
    def __init__(self, machine):
        self.machine = machine

    def insert_coin(self):
        print("Coin inserted.")
        self.machine.set_state(self.machine.has_coin_state)
    
    def eject_coin(self):
        print("No coin to eject.")
    
    def dispense(self):
        print("Insert coin first.")

class HasCoinState(State):
    def __init__(self, machine):
        self.machine = machine
    
    def insert_coin(self):
        print("Coin already inserted.")
    
    def eject_coin(self):
        print("Coin ejected.")
        self.machine.set_state(self.machine.no_coin_state)
    
    def dispense(self):
        print("Dispensing product.")
        self.machine.set_state(self.machine.no_coin_state)

# Контекст
class VendingMachine:
    def __init__(self):
        self.no_coin_state = NoCoinState(self)
        self.has_coin_state = HasCoinState(self)
        self.state = self.no_coin_state
    
    def set_state(self, state: State):
        self.state = state
    
    def insert_coin(self):
        self.state.insert_coin()
    
    def eject_coin(self):
        self.state.eject_coin()
    
    def dispense(self):
        self.state.dispense()

# Клиентский код
def main():
    machine = VendingMachine()
    
    machine.insert_coin()  # Coin inserted.
    machine.dispense()     # Dispensing product.
    machine.eject_coin()   # No coin to eject.
    
    machine.insert_coin()  # Coin inserted.
    machine.eject_coin()   # Coin ejected.
    machine.dispense()     # Insert coin first.

if __name__ == "__main__":
    main()

🚩Как это работает

🟠Интерфейс `State`
Определяет методы, которые должны реализовать все конкретные состояния.
🟠Конкретные состояния (`NoCoinState`, `HasCoinState`)
Реализуют интерфейс State и определяют поведение для каждого состояния.
🟠Класс `VendingMachine`
Содержит ссылки на все возможные состояния и метод для изменения текущего состояния. Делегирует вызовы методов текущему состоянию.
🟠Методы `insert_coin`, `eject_coin`, `dispense`
Вызываются клиентом и делегируются текущему состоянию.

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

🤔 Чем init() отличается от new()?

Метод `__init__()` отвечает за инициализацию объекта после его создания и не создает сам объект, а лишь настраивает его начальные параметры. Метод `__new__()` отвечает за создание нового экземпляра класса и вызывается перед `__init__()`. `__new__()` используется, когда требуется контролировать процесс создания объектов, например, при наследовании или работе с неизменяемыми типами. В большинстве случаев программисту достаточно использовать только `__init__()`.

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

🤔 Что такое RPC?

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

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

🟠Простота использования
Позволяет разработчикам вызывать удаленные процедуры так, как будто они находятся на локальной машине, что упрощает программирование распределенных систем.
🟠Абстракция сетевого взаимодействия
Скрывает сложность сетевого взаимодействия, позволяя сосредоточиться на логике приложения.
🟠Интероперабельность
Обеспечивает взаимодействие между приложениями, работающими на разных платформах и написанных на разных языках программирования.

🚩Как работает

1⃣Клиент
Инициирует вызов удаленной процедуры, отправляя запрос на сервер.
2⃣Сервер
Принимает запрос, выполняет запрашиваемую процедуру и возвращает результат клиенту.

Сервер

from xmlrpc.server import SimpleXMLRPCServer

def add(x, y):
    return x + y

def main():
    server = SimpleXMLRPCServer(("localhost", 8000))
    print("Listening on port 8000...")
    server.register_function(add, "add")
    server.serve_forever()

if __name__ == "__main__":
    main()

3⃣Stub (заглушки)
Клиентские и серверные заглушки генерируются для сериализации и десериализации данных, что позволяет передавать данные по сети.

Клиент

import xmlrpc.client

def main():
    with xmlrpc.client.ServerProxy("http://localhost:8000/") as proxy:
        result = proxy.add(5, 3)
        print(f"5 + 3 = {result}")

if __name__ == "__main__":
    main()

🚩Как это работает

1⃣Сервер
Создает XML-RPC сервер и регистрирует функцию add, которая принимает два числа и возвращает их сумму. Сервер ожидает запросы на порту 8000.
2⃣Клиент
Подключается к серверу через ServerProxy и вызывает удаленную функцию add с аргументами 5 и 3. Результат вызова выводится на экран.

🚩Плюсы

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

🚩Минусы

➖Зависимость от сети
Работа системы зависит от сетевого соединения, что может приводить к задержкам и ошибкам.
➖Сложность отладки
Ошибки и проблемы могут быть сложными для диагностики из-за распределенной природы системы.
➖Безопасность
Необходимо обеспечить безопасность данных, передаваемых по сети, особенно при использовании в открытых сетях.

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

🤔 Что такое итератор?

Итератор в Python — это объект, который поддерживает метод `__iter__()` и `__next__()` для последовательного перебора элементов коллекции. Итераторы используются для работы с циклами и обеспечивают ленивую генерацию данных, не загружая их все сразу в память. Каждый вызов метода `next()` возвращает следующий элемент, а при отсутствии элементов вызывается исключение `StopIteration`. Итераторы полезны для работы с большими данными и потоками данных.

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

🤔 Что такое lru cache?

Это механизм кэширования, который использует стратегию "наименее недавно использованный" для управления хранимыми данными. LRU-кэш хранит фиксированное количество наиболее часто используемых элементов, удаляя наименее недавно использованные элементы, когда необходимо освободить место для новых.

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

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

Python предоставляет удобную реализацию LRU-кэша через декоратор lru_cache в модуле functools. Этот декоратор можно использовать для кэширования результатов вызова функции.

from functools import lru_cache

@lru_cache(maxsize=4)
def expensive_computation(n):
    print(f"Computing {n}...")
    return n * n

def main():
    print(expensive_computation(1))  # Computing 1... -> 1
    print(expensive_computation(2))  # Computing 2... -> 4
    print(expensive_computation(3))  # Computing 3... -> 9
    print(expensive_computation(4))  # Computing 4... -> 16

    print(expensive_computation(1))  # Cached -> 1
    print(expensive_computation(2))  # Cached -> 4

    print(expensive_computation(5))  # Computing 5... -> 25 (1 removed from cache)
    print(expensive_computation(3))  # Cached -> 9

    print(expensive_computation(1))  # Computing 1... -> 1 (2 removed from cache)

if __name__ == "__main__":
    main()

1⃣Декоратор `@lru_cache`
Декорирует функцию expensive_computation, добавляя механизм кэширования.

2⃣Аргумент `maxsize`
Определяет максимальный размер кэша. В данном примере, кэш может хранить до 4 элементов.

3⃣Кэширование и замена
При вызове функции сначала проверяется, есть ли результат в кэше. Если есть, возвращается кэшированный результат. Если нет, функция вычисляет результат, и он сохраняется в кэш. Когда кэш переполняется, наименее недавно использованный элемент удаляется.

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

🤔 Какие знаешь принципы ООП?

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

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

🤔 Что такое шаблонный метод (Template method)?

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

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

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

🚩Пример использования

Пример реализации паттерна Шаблонный метод для процесса приготовления кофе и чая. Общие шаги включают кипячение воды, заваривание напитка и добавление добавок, но конкретные шаги зависят от типа напитка.

from abc import ABC, abstractmethod

class CaffeineBeverage(ABC):
    def prepare_recipe(self):
        self.boil_water()
        self.brew()
        self.pour_in_cup()
        self.add_condiments()
    
    def boil_water(self):
        print("Boiling water")
    
    def pour_in_cup(self):
        print("Pouring into cup")
    
    @abstractmethod
    def brew(self):
        pass
    
    @abstractmethod
    def add_condiments(self):
        pass

class Tea(CaffeineBeverage):
    def brew(self):
        print("Steeping the tea")
    
    def add_condiments(self):
        print("Adding lemon")

class Coffee(CaffeineBeverage):
    def brew(self):
        print("Dripping coffee through filter")
    
    def add_condiments(self):
        print("Adding sugar and milk")

# Клиентский код для использования паттерна Шаблонный метод
def main():
    tea = Tea()
    coffee = Coffee()

    print("Making tea:")
    tea.prepare_recipe()

    print("\nMaking coffee:")
    coffee.prepare_recipe()

if __name__ == "__main__":
    main()

🚩Как это работает

1⃣Абстрактный класс `CaffeineBeverage`
Определяет шаблонный метод prepare_recipe, который описывает последовательность шагов алгоритма.
2⃣Методы `boil_water` и `pour_in_cup`
Реализованы в абстрактном классе, так как они одинаковы для всех напитков.
3⃣Абстрактные методы `brew` и `add_condiments`
Объявлены в абстрактном классе и должны быть реализованы в подклассах.
4⃣Подклассы `Tea` и `Coffee`
Реализуют методы brew и add_condiments, определяя конкретные шаги для приготовления чая и кофе.

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

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

Индексы в 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)   

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