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

😮 Добавлена новая база слитых курсов на 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, если элементов больше нет. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

📌 Как создать итератор из коллекции? 💬 Спрашивают в 3% собеседований В Python можно создать итератор из коллекции, используя встроенную функцию iter(). Итераторы – это объекты, которые реализуют метод __iter__() и метод __next__(). Давайте рассмотрим, как это работает на примере. 🤔 Пример создания итератора Рассмотрим список, который является одной из стандартных коллекций в Python:

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

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

my_iterator = iter(my_list)

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

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

Когда элементы коллекции заканчиваются, next() вызовет исключение StopIteration. 🤔 Итераторы и циклы Обычно итераторы используются в сочетании с циклами for, что упрощает работу с ними:

for item in my_iterator:
    print(item)

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

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

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

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

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

    def __iter__(self):
        return self

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

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

В этом примере мы создали собственный итератор, который перебирает элементы списка [10, 20, 30]. 🤔 Краткий итог: 1️⃣ Итератор можно создать из коллекции с помощью функции iter(). 2️⃣ Итераторы используют методы __iter__() и __next__() для поочередного доступа к элементам. 3️⃣ Итераторы обычно применяются в циклах for для удобства перебора элементов коллекции. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

📌 Какие типы полиморфизма есть в python? 💬 Спрашивают в 3% собеседований В Python существуют два основных типа полиморфизма: перегрузка методов и наследование и переопределение методов. Давайте рассмотрим каждый из них подробнее. 1️⃣ Перегрузка методов Перегрузка методов подразумевает использование одного и того же метода с различными типами данных. Однако в Python это реализуется несколько иначе, чем в статически типизированных языках, таких как C++ или Java. В Python отсутствует явная поддержка перегрузки методов. Вместо этого мы можем использовать стандартные функции с переменным числом аргументов. Пример:

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

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

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

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

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

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

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

dog = Dog()
cat = Cat()

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

В этом примере класс Dog и класс Cat переопределяют метод sound базового класса Animal. Функция make_sound вызывает метод sound независимо от конкретного типа объекта. 🤔 Краткий итог: 1️⃣ Перегрузка методов позволяет использовать методы с различным числом аргументов. 2️⃣ Наследование и переопределение методов позволяет дочерним классам реализовывать или изменять поведение методов базового класса. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

📌 Что такое абстракция? 💬 Спрашивают в 3% собеседований Абстракция — это один из ключевых принципов объектно-ориентированного программирования (ООП), который позволяет упростить сложные системы, скрывая детали их реализации и предоставляя только необходимую функциональность. В Python абстракция достигается через использование классов и интерфейсов, что позволяет разработчикам создавать более понятные и управляемые структуры кода. 🤔 Принцип абстракции Абстракция позволяет сосредоточиться на том, что делает объект, а не на том, как он это делает. Это достигается путем: 1️⃣ Скрытия внутренней реализации: Пользователи объектов видят только методы и свойства, которые предоставляются классом, но не детали их реализации. 2️⃣Предоставления простого интерфейса: Классы могут предоставлять четко определенные методы, которые обеспечивают взаимодействие с объектами. 🤔 Абстрактные классы и методы в Python В Python абстракция часто реализуется с использованием абстрактных классов и методов. Абстрактные классы определяются с помощью модуля abc (Abstract Base Classes), а абстрактные методы обозначаются декоратором @abstractmethod. ➕ Пример абстрактного класса

from abc import ABC, abstractmethod

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

    @abstractmethod
    def move(self):
        pass

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

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

    def move(self):
        return "Run"

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

    def move(self):
        return "Jump"

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

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

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

🤔 Преимущества абстракции 1️⃣ Упрощение сложных систем: Абстракция помогает разбивать сложные системы на более управляемые части. 2️⃣ Повышение читабельности и поддерживаемости кода: Код становится более понятным, так как скрываются ненужные детали реализации. 3️⃣ Снижение зависимости кода: Изменения в реализации не влияют на пользователей класса, что позволяет более гибко изменять и расширять функциональность. 🤔 Подводя итог Абстракция в ООП позволяет скрывать детали реализации и предоставлять простой интерфейс для взаимодействия с объектами. В Python абстракция достигается через абстрактные классы и методы, которые определяются с использованием модуля abc и декоратора @abstractmethod. 🤔Кратко: Абстракция скрывает детали реализации и предоставляет простой интерфейс для использования объектов. В Python это реализуется с помощью абстрактных классов и методов. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

Ментор поможет сэкономить время и быстрее зайти в IT https://easyoffer.ru/mentor