Python | Вопросы собесов

Бесплатные уроки по IT-профессиям. Учитесь на практике! Узнайте, с чего начать свой путь в IT или дизайне и как выбрать профессию по душе. Получите билет! Получить предложение #реклама 16+ free.skillfactory.ru О рекламодателе

🤔 Что такое Фабричный метод (Factory method)? Это порождающий паттерн проектирования, который определяет интерфейс для создания объекта, но позволяет подклассам изменять тип создаваемого объекта. Это позволяет классу делегировать создание объектов подклассам, таким образом убирая жесткую привязку к конкретным классам и делая систему более гибкой и расширяемой. 🚩Основные концепции 🟠Продукт (Product): Определяет интерфейс для объектов, которые будут создаваться. 🟠Конкретный продукт (Concrete Product): Реализует интерфейс продукта. 🟠Создатель (Creator): Определяет фабричный метод, который возвращает объект продукта. Может содержать реализацию метода по умолчанию, возвращающую какой-то стандартный продукт. 🟠Конкретный создатель (Concrete Creator): Переопределяет фабричный метод для создания конкретного продукта. 🚩Использования фабричного метода Определение интерфейса продукта

from abc import ABC, abstractmethod

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

Создание конкретных продуктов

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

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

Определение создателя

class AnimalFactory(ABC):
    @abstractmethod
    def create_animal(self) -> Animal:
        pass

    def some_operation(self) -> str:
        animal = self.create_animal()
        return f"The animal says: {animal.speak()}"

Создание конкретных создателей

class DogFactory(AnimalFactory):
    def create_animal(self) -> Animal:
        return Dog()

class CatFactory(AnimalFactory):
    def create_animal(self) -> Animal:
        return Cat()

Использование фабричного метода

def client_code(factory: AnimalFactory):
    print(factory.some_operation())

dog_factory = DogFactory()
cat_factory = CatFactory()

print("Client: Testing client code with DogFactory:")
client_code(dog_factory)  # Вывод: The animal says: Woof!

print("\nClient: Testing client code with CatFactory:")
client_code(cat_factory)  # Вывод: The animal says: Meow!

🚩Плюсы ➕Изоляция конкретных классов: Клиентский код работает с интерфейсами или абстрактными классами, а не с конкретными реализациями. ➕Упрощение добавления новых продуктов: Легко добавлять новые виды продуктов, создавая новые конкретные создатели. ➕Гибкость и расширяемость: Позволяет изменять способ создания объектов без изменения клиентского кода. 🚩Минусы ➖Усложнение кода: Может потребоваться создание большого количества классов для каждого конкретного продукта и его создателя. ➖Дополнительные абстракции: Для каждого типа продукта требуется создание интерфейсов или абстрактных классов. Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое Построитель (Builder)? Паттерн "Строитель" — это порождающий паттерн проектирования, который позволяет создавать сложные объекты пошагово и отделяет процесс конструирования объекта от его представления, что дает возможность использовать один и тот же процесс для создания различных представлений. 🚩Основные концепции 🟠 Строитель (Builder): Интерфейс или абстрактный класс, определяющий шаги для построения объекта. 🟠Конкретные строители (Concrete Builders): Реализуют интерфейс строителя, создавая конкретные части продукта. 🟠Продукт (Product): Сложный объект, который строится. 🟠Директор (Director): Опциональный класс, который контролирует процесс построения, используя строителя. 🚩Рассмотрим пример использования паттерна "Строитель" для создания объектов типа House. 🟠Создание продукта

class House:
    def __init__(self):
        self.walls = None
        self.roof = None
        self.windows = None

    def __str__(self):
        return f"House with {self.walls} walls, {self.roof} roof, and {self.windows} windows."

🟠Определение интерфейса строителя

from abc import ABC, abstractmethod

class HouseBuilder(ABC):
    @abstractmethod
    def build_walls(self):
        pass

    @abstractmethod
    def build_roof(self):
        pass

    @abstractmethod
    def build_windows(self):
        pass

    @abstractmethod
    def get_house(self):
        pass

🟠Создание конкретных строителей

class ConcreteHouseBuilder(HouseBuilder):
    def __init__(self):
        self.house = House()

    def build_walls(self):
        self.house.walls = "brick"
        return self

    def build_roof(self):
        self.house.roof = "tile"
        return self

    def build_windows(self):
        self.house.windows = "double-glazed"
        return self

    def get_house(self):
        return self.house

🟠Создание директора (опционально)

class Director:
    def __init__(self, builder):
        self.builder = builder

    def construct_house(self):
        self.builder.build_walls().build_roof().build_windows()
        return self.builder.get_house()

🟠Использование паттерна "Строитель"

# Использование без директора
builder = ConcreteHouseBuilder()
house = builder.build_walls().build_roof().build_windows().get_house()
print(house)  # House with brick walls, tile roof, and double-glazed windows.

# Использование с директором
director = Director(builder)
house = director.construct_house()
print(house)  # House with brick walls, tile roof, and double-glazed windows.

🚩Преимущества паттерна "Строитель" 🟠 Упрощение создания сложных объектов: Позволяет создавать сложные объекты пошагово. 🟠Отделение процесса конструирования от представления: Разделяет логику создания объекта и его состав. 🟠 Гибкость: Один и тот же процесс построения можно использовать для создания различных представлений объекта. 🚩Недостатки паттерна "Строитель" 🟠Усложнение кода: Добавление дополнительных классов может усложнить структуру программы. 🟠Необходимость в дополнительных классах: Для каждого типа объекта требуется отдельный класс строителя. Ставь 👍 и забирай 📚 Базу знаний

Методичка: как сделать онлайн-встречи эффективнее Надоело ждать коллег, которые постоянно забывают о встречах, а отсутствие повестки и потерянные договоренности мешают нормально работать? Команда МТС Линк собрала на 37 страницах полезные материалы, чек-листы и кейсы, которые помогают компаниям проводить эффективные совещания в онлайне с помощью сервиса Встречи. Из методички узнаете: - Как создать постоянную ссылку и подключаться на встречи в 2 клика, - Как делать заметки и работать с файлами, не переживая за качество связи и безопасность данных. - Как облегчает жизнь ИИ, который расшифровывает созвоны в текст и автоматически отправляет расшифровку на почту. Еще в методичке описаны 7 способов оценки текущей эффективности ваших онлайн-встреч. Получить гайд можно бесплатно на сайте. Скачать #реклама mts-link.ru О рекламодателе

🤔 Что такое абстрактная фабрика? Абстрактная фабрика (Abstract Factory) — это порождающий паттерн проектирования, который предоставляет интерфейс для создания семейств взаимосвязанных или взаимозависимых объектов без указания их конкретных классов. Этот паттерн позволяет создавать комплекты объектов, которые должны работать вместе, обеспечивая при этом их взаимозаменяемость. 🚩Основные концепции 🟠Абстрактная фабрика (Abstract Factory): Интерфейс или базовый класс с методами для создания различных продуктов (объектов). 🟠Конкретные фабрики (Concrete Factories): Реализации абстрактной фабрики, создающие конкретные продукты. 🟠Абстрактные продукты (Abstract Products): Интерфейсы или базовые классы для продуктов, которые создаются фабриками. 🟠Конкретные продукты (Concrete Products): Реализации абстрактных продуктов. Создание абстрактных продуктов: Рассмотрим пример, в котором абстрактная фабрика создает различные виды кнопок и чекбоксов для двух разных операционных систем: Windows и MacOS.

from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def click(self):
        pass

class Checkbox(ABC):
    @abstractmethod
    def check(self):
        pass

Создание конкретных продуктов

class WindowsButton(Button):
    def click(self):
        print("Windows button clicked")

class MacOSButton(Button):
    def click(self):
        print("MacOS button clicked")

class WindowsCheckbox(Checkbox):
    def check(self):
        print("Windows checkbox checked")

class MacOSCheckbox(Checkbox):
    def check(self):
        print("MacOS checkbox checked")

Создание абстрактной фабрики

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass

    @abstractmethod
    def create_checkbox(self) -> Checkbox:
        pass

Создание конкретных фабрик

class WindowsFactory(GUIFactory):
    def create_button(self) -> Button:
        return WindowsButton()

    def create_checkbox(self) -> Checkbox:
        return WindowsCheckbox()

class MacOSFactory(GUIFactory):
    def create_button(self) -> Button:
        return MacOSButton()

    def create_checkbox(self) -> Checkbox:
        return MacOSCheckbox()

Использование абстрактной фабрики

def client_code(factory: GUIFactory):
    button = factory.create_button()
    checkbox = factory.create_checkbox()
    button.click()
    checkbox.check()

# Клиентский код может работать с любыми фабриками и продуктами
windows_factory = WindowsFactory()
macos_factory = MacOSFactory()

print("Client: Testing client code with Windows factory:")
client_code(windows_factory)

print("\nClient: Testing client code with MacOS factory:")
client_code(macos_factory)

🚩Преимущества абстрактной фабрики 🟠Изоляция конкретных классов: Клиентский код работает только с интерфейсами или абстрактными классами. 🟠Легкость замены семейств продуктов: Можно легко менять фабрики, чтобы использовать другие семейства продуктов. 🟠Согласованность продуктов: Абстрактная фабрика гарантирует, что продукты одного семейства будут совместимы между собой. 🚩Недостатки абстрактной фабрики 🟠Усложнение кода: Добавление новых классов и интерфейсов может усложнить структуру кода. 🟠Трудности расширения: При добавлении нового типа продукта может потребоваться изменение интерфейсов и всех конкретных фабрик. Ставь 👍 и забирай 📚 Базу знаний

Полезный гайд для HR в сфере IT! Корпоративное обучение и онбординг в IT-компании - не простая задача, ведь необходимо продумать множество деталей. В гайде для IT-компаний МТС Линк собрал лучшие практики, кейсы и рекомендации экспертов: - Как системно растить скиллы сотрудников и автоматизировать тренинги; - Как сделать обучение интерактивным с помощью онлайн-доски; - Как ускорить онбординг новых партнеров и увеличить перформанс. Получите гайд бесплатно на сайте. Скачать #реклама 16+ mts-link.ru О рекламодателе

🤔 Что такое порождающий паттерн? Порождающие паттерны (creational patterns) — это шаблоны проектирования в объектно-ориентированном программировании, которые предназначены для управления процессом создания объектов. 🚩Основные порождающие паттерны 🟠Одиночка (Singleton) 🟠Фабричный метод (Factory Method) 🟠Абстрактная фабрика (Abstract Factory) 🟠Строитель (Builder) 🟠Прототип (Prototype) Одиночка (Singleton): Паттерн Одиночка гарантирует, что у класса будет только один экземпляр, и предоставляет глобальную точку доступа к нему.

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # True

Фабричный метод (Factory Method): Фабричный метод определяет интерфейс для создания объекта, но позволяет подклассам изменять тип создаваемых объектов.

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

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

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

class AnimalFactory:
    @staticmethod
    def get_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            return None

dog = AnimalFactory.get_animal("dog")
cat = AnimalFactory.get_animal("cat")
print(dog.speak())  # Woof!
print(cat.speak())  # Meow!

Абстрактная фабрика (Abstract Factory): Абстрактная фабрика предоставляет интерфейс для создания семейств связанных или зависимых объектов без указания их конкретных классов.

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

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

class PetFactory:
    def create_dog(self):
        return Dog()

    def create_cat(self):
        return Cat()

factory = PetFactory()
dog = factory.create_dog()
cat = factory.create_cat()
print(dog.speak())  # Woof!
print(cat.speak())  # Meow!

Строитель (Builder): Паттерн Строитель используется для создания сложных объектов пошагово. Он позволяет создавать разные представления объекта, используя один и тот же код.

class House:
    def __init__(self):
        self.walls = None
        self.roof = None
        self.windows = None

    def __str__(self):
        return f"House with {self.walls} walls, {self.roof} roof, and {self.windows} windows."

class HouseBuilder:
    def __init__(self):
        self.house = House()

    def build_walls(self, walls):
        self.house.walls = walls
        return self

    def build_roof(self, roof):
        self.house.roof = roof
        return self

    def build_windows(self, windows):
        self.house.windows = windows
        return self

    def build(self):
        return self.house

builder = HouseBuilder()
house = builder.build_walls("brick").build_roof("tile").build_windows("double-glazed").build()
print(house)
# House with brick walls, tile roof, and double-glazed windows.

Прототип (Prototype): Паттерн Прототип создает новые объекты путем копирования существующих экземпляров (прототипов).

import copy

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

    def clone(self):
        return copy.deepcopy(self)

original = Prototype(10)
clone = original.clone()
print(original.value)  # 10
print(clone.value)     # 10
clone.value = 20
print(original.value)  # 10
print(clone.value)     # 20

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

До сих пор боишься вопроса про TCP/IP протоколы на собеседовании? 🖥 Network Admin — обучающий канал по сетевым технологиям. В канале ты найдешь множество полезной информации: ➖ Типы SSL - сертификатов ➖ Иерархия DNS ➖ Сетевая аналитика ➖ Процессы TCP сервера ➖ Маршрутизатор, Коммутатор, Хаб: В чем разница? ➖ Проверка уязвимости сервера Linux С Network Admin твои знания и навыки стремительно пойдут вверх Подписывайся - @networkadm

Помощь в трудоустройстве в IT-сфере! В России из-за дефицита айтишников запустили бесплатную программу по обучению IT-специалистов. Теперь любой желающий может попробовать себя в IT с полного нуля и начать обучение бесплатно! Узнайте про дальнейшее трудоустройство в ведущие IT-компании для восполнения кадрового дефицита. Для этого нужно: - Перейти по ссылке - Заполнить анкету и ответить на вопросы (занимает менее 3 минут) - На основании ваших ответов вы сразу узнаете, подходит ли вам сфера IT и сможете ли вы в ней работать Перейти на сайт #реклама 16+ urban-university.ru О рекламодателе

🤔 Что такое code cohesion & code coupling? Когезия (cohesion) и связность (coupling) — это два важных концепта в программировании, которые влияют на качество и структуру кода. 🚩Когезия (Cohesion) Когезия относится к степени, в которой элементы внутри модуля (например, класса или функции) связаны друг с другом и работают вместе для выполнения одной задачи. Высокая когезия означает, что элементы модуля сильно связаны и направлены на выполнение одной функции, что делает модуль более понятным и легким для сопровождения. Класс, выполняющий одну задачу:

class FileHandler:
    def read_file(self, filename):
        with open(filename, 'r') as file:
            return file.read()

    def write_file(self, filename, data):
        with open(filename, 'w') as file:
            file.write(data)

Функция, выполняющая одну конкретную задачу:

def calculate_sum(numbers):
    return sum(numbers)

Преимущества высокой когезии: 🟠Улучшенная читабельность и понятность кода. 🟠Легкость сопровождения и изменения. 🟠Повышенная вероятность повторного использования модулей. 🚩Связность (Coupling) Связность относится к степени зависимости одного модуля от другого. Высокая связность означает, что модули сильно зависят друг от друга, что делает систему более жесткой и сложной для сопровождения. Низкая связность, напротив, означает, что модули имеют минимальные зависимости друг от друга, что делает систему более гибкой и легко модифицируемой. Использование интерфейсов или абстракций:

class Database:
    def connect(self):
        pass

class MySQLDatabase(Database):
    def connect(self):
        print("Connecting to MySQL database")

class PostgreSQLDatabase(Database):
    def connect(self):
        print("Connecting to PostgreSQL database")

def initialize_db(db: Database):
    db.connect()

db = MySQLDatabase()
initialize_db(db)

Внедрение зависимостей:

class Service:
    def __init__(self, repository):
        self.repository = repository

    def perform_action(self):
        self.repository.save("Some data")

class Repository:
    def save(self, data):
        print(f"Saving {data}")

repository = Repository()
service = Service(repository)
service.perform_action()

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

😒 На одном Python уже давно не вывезешь, перспектива 2024 года - Информационная Безопасность Ловите два канала на тему ИБ и хакинга ZeroDay - Уроки по кибербезопасности и хакингу с нуля. Вирусы, взломы, OSINT, криптография и свежие новости Белый Хакер - программное обеспечение, утилиты, OSINT, инструменты, полезная литература и много другое. Совершенно новый формат непохожий на другие каналы.

Бесплатный мастер-класс по программированию приложений Онлайн-занятие для детей 12 -18 лет от Университета Иннополис. Всего за 1 час подросток самостоятельно создаст своё первое приложение и сможет в дальнейшем использовать полученные навыки для реализации собственных творческих идей. ⚡Мастер-класс ориентирован на всех желающих и для участия не требуется особых навыков, кроме базовых знаний компьютера и владения клавиатурой. Запишите подростка на мастер-класс, дайте старт полезному хобби, а возможно и будущей перспективной профессии. Зарегистрироваться #реклама 16+ progmatica.innopolis.university О рекламодателе

🤔 Что будет, если в родительских классах есть функции с одинаковым названием? Когда в Python используется наследование, и у родительских классов есть методы с одинаковым названием, происходит так называемое разрешение имен. Поведение зависит от способа вызова метода и от того, как определены классы. 🚩Множественное наследование и порядок разрешения методов (MRO) Если у вас есть множественное наследование, то порядок разрешения методов (MRO, Method Resolution Order) определяет, какой метод будет вызван. Python использует алгоритм C3-линеаризации для вычисления MRO.

class A:
    def say_hello(self):
        print("Hello from A")

class B:
    def say_hello(self):
        print("Hello from B")

class C(A, B):
    pass

c = C()
c.say_hello()

🚩Порядок разрешения методов (MRO) В примере выше класс C наследует от классов A и B. Метод say_hello есть в обоих родительских классах. Порядок разрешения методов в классе C будет таким: C -> A -> B. Чтобы увидеть MRO, можно использовать метод __mro__ или функцию mro():

print(C.__mro__)
# (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

print(C.mro())
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

Таким образом, при вызове c.say_hello() будет вызван метод say_hello класса A, так как он идет первым в MRO. 🚩Пример с переопределением метода в дочернем классе Если вы переопределите метод в дочернем классе, то будет вызван метод, определенный в самом дочернем классе:

class A:
    def say_hello(self):
        print("Hello from A")

class B:
    def say_hello(self):
        print("Hello from B")

class C(A, B):
    def say_hello(self):
        print("Hello from C")

c = C()
c.say_hello()
# Вывод: Hello from C

🚩Вызов методов родительских классов с использованием super() Иногда необходимо явно вызвать метод одного из родительских классов. Для этого используется функция super(), которая возвращает объект, через который можно вызывать методы родительского класса.

class A:
    def say_hello(self):
        print("Hello from A")

class B:
    def say_hello(self):
        print("Hello from B")

class C(A, B):
    def say_hello(self):
        super().say_hello()
        print("Hello from C")

c = C()
c.say_hello()
# Вывод:
# Hello from A
# Hello from C

🚩Вызов методов конкретных родительских классов Можно вызвать его напрямую через имя класса:

class A:
    def say_hello(self):
        print("Hello from A")

class B:
    def say_hello(self):
        print("Hello from B")

class C(A, B):
    def say_hello(self):
        A.say_hello(self)
        B.say_hello(self)
        print("Hello from C")

c = C()
c.say_hello()
# Вывод:
# Hello from A
# Hello from B
# Hello from C

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