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

Помощь в трудоустройстве в 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

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

😮 Добавлена новая база слитых курсов на 800ГБ: Python: https://t.me/+QPSH2IcGu4w5ODky Frontend и Web: https://t.me/+MiJVQSyUlDNjODky Программирование: https://t.me/+opj2LZT23ddiZDli Графика и дизайн: https://t.me/+vrZ8dhdUEXM3YmQy

ТОП-4 Курса по Программированию ⚡Tutortop — маркетплейс курсов №1 по количеству школ-партнеров, курсов и реальных отзывов студентов. ✅Хотите стать программистом, но не знаете с какого языка начать? Помогаем разобраться в самых популярных и востребованных языках программирования. Подарок в конце подборки! Выбрать #реклама 16+ tutortop.ru О рекламодателе

📌 Что такое dependency injection? 💬 Спрашивают в 3% собеседований Внедрение зависимостей (Dependency Injection, DI) — это дизайн-паттерн, используемый в объектно-ориентированном программировании для управления зависимостями между объектами. Внедрение зависимостей позволяет сделать код более гибким, тестируемым и поддерживаемым, отделяя создание объектов от их использования. 🤔 Основные концепции 1️⃣Зависимости: Это объекты, от которых зависит класс. Например, если класс Car использует объект Engine, то Engine является зависимостью для Car. 2️⃣Внедрение: Процесс передачи зависимостей классу. Вместо того чтобы создавать зависимости внутри класса, они передаются извне. 🤔 Преимущества внедрения зависимостей 1️⃣Снижение связности: Классы меньше зависят друг от друга, что упрощает их замену или модификацию. 2️⃣ Упрощение тестирования: Легче подменять реальные зависимости на моки или стабы для написания тестов. 3️⃣ Улучшение читаемости и поддержки кода: Код становится более модульным и легче поддерживается. 🤔 Типы внедрения зависимостей 1️⃣ Внедрение через конструктор: Зависимости передаются через параметры конструктора. 2️⃣ Внедрение через методы (или сеттеры): Зависимости передаются через специальные методы. 3️⃣ Внедрение через свойства: Зависимости назначаются через свойства объекта. 🤔 Пример внедрения через конструктор Рассмотрим пример, где класс 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()

🤔 Краткий итог: 1️⃣Внедрение зависимостей (DI) позволяет передавать зависимости извне, а не создавать их внутри класса. 2️⃣Это снижает связанность, улучшает тестируемость и упрощает поддержку кода. 3️⃣ Существует несколько способов внедрения зависимостей: через конструктор, методы и свойства. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

⚡ Когда говорят, что Python слишком простой язык, на сцену выходит канал Python Learning Здесь легко научиться: ▪️Превращать текст в голос ▪️Определять локацию по IP ▪️Писать телеграм-ботов ▪️Создавать 3D-игры Самый необычный канал про Python, подписывайся – @Python_per_month

📌 Чем обычный метод отличается от class method? 💬 Спрашивают в 3% собеседований Обычные методы и методы класса в Python различаются в основном тем, к чему они привязаны и как используются. Давайте рассмотрим их отличия более подробно. 🤔 Обычные методы (Instance Methods) 1️⃣ Привязка к экземпляру: ➕ Обычные методы работают с конкретными экземплярами класса. ➕ Они принимают первым аргументом self, который указывает на текущий экземпляр класса. 2️⃣ Использование атрибутов: ➕ Могут изменять состояние экземпляра, то есть работать с его атрибутами. 3️⃣ Определение:

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

4️⃣ Вызов: ➕ Вызываются через экземпляр класса.

   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) 1️⃣ Привязка к классу: ➕ Методы класса работают с самим классом и его атрибутами. ➕ Они принимают первым аргументом cls, который указывает на сам класс. 2️⃣ Использование атрибутов: ➕ Могут изменять состояние класса, то есть работать с атрибутами класса. 3️⃣ Определение:

   class MyClass:
       class_variable = 0

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

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

   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

🤔 Краткий итог: 1️⃣ Обычные методы: ➕ Работают с конкретными экземплярами класса. ➕ Принимают self как первый аргумент. ➕ Могут изменять состояние экземпляра. ➕ Вызываются через экземпляр класса. 2️⃣ Методы класса: ➕ Работают с самим классом. ➕ Принимают cls как первый аргумент. ➕ Могут изменять состояние класса. ➕ Могут вызываться как через класс, так и через экземпляры. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

📌 Для чего нужны 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️⃣ Часто применяются для реализации фабричных методов и логической группировки функций, связанных с классом. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

📌 Для чего нужны 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️⃣ Такие методы удобны для логической группировки и вызова функций без создания экземпляра класса. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

📌 Как создать класс, который поддерживает протокол итератора? 💬 Спрашивают в 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, если элементов больше нет. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых