🤔 Что такое @staticmethod?

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

🚩Зачем нужен

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

🚩Как использовать

Для создания статического метода, нужно использовать декоратор @staticmethod перед определением метода. В отличие от обычных методов класса, статический метод не принимает параметр self.

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b
    
    @staticmethod
    def multiply(a, b):
        return a * b

# Вызов статических методов
print(MathUtils.add(5, 3))  # Вывод: 8
print(MathUtils.multiply(5, 3))  # Вывод: 15

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

class Validator:
    @staticmethod
    def is_valid_email(email):
        return "@" in email and "." in email

# Вызов статического метода
print(Validator.is_valid_email("test@example.com"))  # Вывод: True
print(Validator.is_valid_email("invalid-email"))  # Вывод: False

🚩Сравнение с другими методами

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

Пример для сравнения:

class Example:
    def instance_method(self):
        print("This is an instance method")
    
    @classmethod
    def class_method(cls):
        print("This is a class method")
    
    @staticmethod
    def static_method():
        print("This is a static method")

# Создание экземпляра класса
obj = Example()

# Вызов методов
obj.instance_method()  # Вывод: This is an instance method
Example.class_method()  # Вывод: This is a class method
Example.static_method()  # Вывод: This is a static method

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

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

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

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

🤔 Что такое @dataclass?

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

🚩Зачем нужен

🟠Упрощение кода
Автоматически генерирует методы, сокращая шаблонный код.
🟠Читабельность
Делает код более чистым и легким для понимания.
🟠Удобство
Обеспечивает удобные и мощные возможности для работы с данными.

🚩Как использовать

Нужно импортировать его из модуля dataclasses и применить к классу. Внутри класса достаточно определить только поля данных.

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

# Примеры использования
person1 = Person(name="Alice", age=30)
person2 = Person(name="Bob", age=25)

print(person1)  # Вывод: Person(name='Alice', age=30)
print(person2)  # Вывод: Person(name='Bob', age=25)
print(person1 == person2)  # Вывод: False

🚩Автоматически генерируемые методы

🟠`__init__`
Инициализирует объект с заданными значениями атрибутов.
🟠`__repr__`
Возвращает строковое представление объекта, удобное для отладки.
🟠`__eq__`
Сравнивает объекты на равенство по их атрибутам.
🟠`__lt__`, `__le__`, `__gt__`, `__ge__`
Могут быть сгенерированы для сравнения объектов (если указано).

🚩Настройка поведения

Вы можете настроить поведение @dataclass с помощью параметров, таких как order, frozen, и других.

🟠`order=True`
Генерирует методы для сравнения объектов.
🟠`frozen=True`
Делает экземпляры неизменяемыми (immutable).

Пример

from dataclasses import dataclass

@dataclass(order=True, frozen=True)
class Person:
    name: str
    age: int

person1 = Person(name="Alice", age=30)
person2 = Person(name="Bob", age=25)

print(person1 > person2)  # Вывод: True (поскольку 'Alice' > 'Bob' по алфавиту, если имена равны, сравниваются возраста)
# person1.age = 31  # Ошибка: FrozenInstanceError (поскольку класс заморожен)

🚩Поля данных и их настройки

Вы можете использовать функцию field() для настройки отдельных полей, например, для указания значений по умолчанию или исключения полей из методов __repr__, __eq__, и других.

from dataclasses import dataclass, field

@dataclass
class Person:
    name: str
    age: int = 0
    address: str = field(default="Unknown", repr=False)

person = Person(name="Alice")
print(person)  # Вывод: Person(name='Alice', age=0)

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

🤔 Расскажи о сложностях с которыми столкнулась во время обучения?

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

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

🤔 Чем отличается атрибут класса от атрибута объекта?

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

🚩Атрибуты класса

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

class MyClass:
    class_attribute = 42  # Атрибут класса

# Доступ к атрибуту класса
print(MyClass.class_attribute)  # Вывод: 42

# Создание экземпляров
obj1 = MyClass()
obj2 = MyClass()

# Доступ к атрибуту класса через экземпляры
print(obj1.class_attribute)  # Вывод: 42
print(obj2.class_attribute)  # Вывод: 42

# Изменение атрибута класса
MyClass.class_attribute = 100
print(obj1.class_attribute)  # Вывод: 100
print(obj2.class_attribute)  # Вывод: 100

🚩Атрибуты объекта (экземпляра)

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

class MyClass:
    def __init__(self, value):
        self.instance_attribute = value  # Атрибут объекта

# Создание экземпляров
obj1 = MyClass(10)
obj2 = MyClass(20)

# Доступ к атрибутам объекта
print(obj1.instance_attribute)  # Вывод: 10
print(obj2.instance_attribute)  # Вывод: 20

# Изменение атрибутов объекта
obj1.instance_attribute = 15
print(obj1.instance_attribute)  # Вывод: 15
print(obj2.instance_attribute)  # Вывод: 20

🚩Ключевые различия

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

🟠Инициализация и использование
Атрибуты класса инициализируются при определении класса и общие для всех экземпляров. Атрибуты объекта инициализируются в методе __init__ и уникальны для каждого экземпляра.

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

🚩Пример различий

class MyClass:
    class_attribute = 'class value'

    def __init__(self, value):
        self.instance_attribute = value

# Создание экземпляров
obj1 = MyClass('instance value 1')
obj2 = MyClass('instance value 2')

# Доступ к атрибутам класса и объекта
print(MyClass.class_attribute)      # Вывод: class value
print(obj1.class_attribute)         # Вывод: class value
print(obj2.class_attribute)         # Вывод: class value

print(obj1.instance_attribute)      # Вывод: instance value 1
print(obj2.instance_attribute)      # Вывод: instance value 2

# Изменение атрибута класса через класс
MyClass.class_attribute = 'new class value'
print(obj1.class_attribute)         # Вывод: new class value
print(obj2.class_attribute)         # Вывод: new class value

# Изменение атрибута объекта
obj1.instance_attribute = 'new instance value 1'
print(obj1.instance_attribute)      # Вывод: new instance value 1
print(obj2.instance_attribute)      # Вывод: instance value 2

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

🤔 Какие основные HTTP методы знаешь?

Основные методы: GET для получения данных, POST для отправки данных, PUT для обновления или создания ресурса, DELETE для удаления. Также используются PATCH для частичного обновления, HEAD для получения заголовков и OPTIONS для определения доступных методов.

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

🤔 Геттеры и сеттеры, property атрибуты?

Используются для контроля доступа к атрибутам класса. Они позволяют вам добавлять логику при получении (геттер) и изменении (сеттер) значений атрибутов. В Python эти методы можно реализовать с помощью функции property, которая упрощает создание геттеров и сеттеров, делая код более читабельным и идиоматичным.

🚩Геттеры и сеттеры

Геттер — это метод, который возвращает значение атрибута, а сеттер — метод, который устанавливает значение атрибута.
Пример без использования property

class MyClass:
    def __init__(self, value):
        self._value = value  # Приватный атрибут

    def get_value(self):
        return self._value

    def set_value(self, value):
        if value >= 0:
            self._value = value
        else:
            raise ValueError("Value must be non-negative")

# Примеры использования
obj = MyClass(10)
print(obj.get_value())  # Вывод: 10

obj.set_value(20)
print(obj.get_value())  # Вывод: 20

try:
    obj.set_value(-10)  # Пример вызова исключения
except ValueError as e:
    print(e)  # Вывод: Value must be non-negative

🚩`property` атрибуты

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

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

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        if value >= 0:
            self._value = value
        else:
            raise ValueError("Value must be non-negative")

# Примеры использования
obj = MyClass(10)
print(obj.value)  # Вывод: 10 (используется геттер)

obj.value = 20
print(obj.value)  # Вывод: 20 (используется сеттер)

try:
    obj.value = -10  # Пример вызова исключения через сеттер
except ValueError as e:
    print(e)  # Вывод: Value must be non-negative

🚩Плюсы

➕Инкапсуляция
Позволяет скрыть реализацию и управлять доступом к данным через методы, что делает код более безопасным и гибким.
➕Читабельность
Код выглядит как работа с обычными атрибутами, а не методами, что упрощает его понимание.
➕Контроль
Легко добавить валидацию или логику при установке или получении значений.

🚩Полный пример с геттером, сеттером и делетером

Также можно использовать декоратор @property для создания делетера (удаления атрибута).

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

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        if value >= 0:
            self._value = value
        else:
            raise ValueError("Value must be non-negative")

    @value.deleter
    def value(self):
        del self._value

# Примеры использования
obj = MyClass(10)
print(obj.value)  # Вывод: 10

obj.value = 20
print(obj.value)  # Вывод: 20

del obj.value
try:
    print(obj.value)  # Ошибка, так как атрибут удален
except AttributeError as e:
    print(e)  # Вывод: 'MyClass' object has no attribute '_value'

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

🤔 Что знаешь про ORM?

ORM (Object-Relational Mapping) — это технология, которая позволяет работать с реляционными базами данных через объектно-ориентированные модели. Она автоматически преобразует объекты в SQL-запросы и обратно, упрощая работу с данными. Популярные ORM включают Hibernate, SQLAlchemy и Django ORM.

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

🤔 Как еще мы можем гарантировать закрытие файла, если не через with?

Использование оператора with является рекомендованным способом гарантированного закрытия файла, так как он автоматически управляет открытием и закрытием ресурса. Однако, если по какой-то причине вы не можете использовать with, можно гарантировать закрытие файла другими способами, такими как использование явного вызова метода close() в блоке finally.

🟠С использованием `try-finally`
Открытие и закрытие файла с использованием блока try-finally гарантирует, что файл будет закрыт, даже если в блоке try произойдет исключение. В этом примере файл открывается в блоке try, и его содержимое читается. Независимо от того, происходит ли исключение в блоке try или нет, блок finally будет выполнен, и файл будет закрыт.

file = None
try:
    file = open('example.txt', 'r')
    content = file.read()
    print(content)
finally:
    if file:
        file.close()

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

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    
    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            self.file.close()

# Примеры использования
file_manager = FileManager('example.txt', 'r')
try:
    file = file_manager.__enter__()
    content = file.read()
    print(content)
finally:
    file_manager.__exit__(None, None, None)

🟠С использованием декоратора
Еще один способ — использование декоратора для автоматического управления открытием и закрытием файла.

from functools import wraps

def open_file(filename, mode):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            file = open(filename, mode)
            try:
                result = func(file, *args, **kwargs)
            finally:
                file.close()
            return result
        return wrapper
    return decorator

@open_file('example.txt', 'r')
def read_file(f):
    return f.read()

# Примеры использования
print(read_file())

🟠С использованием менеджера контекста из `contextlib`
Модуль contextlib предоставляет полезные утилиты для создания контекстных менеджеров. Одной из таких утилит является contextlib.contextmanager, которая позволяет создавать контекстные менеджеры с помощью генераторов.

from contextlib import contextmanager

@contextmanager
def open_file(filename, mode):
    file = open(filename, mode)
    try:
        yield file
    finally:
        file.close()

# Примеры использования
file_manager = open_file('example.txt', 'r')
file = file_manager.__enter__()
try:
    content = file.read()
    print(content)
finally:
    file_manager.__exit__(None, None, None)

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

🤔 Что знаешь про singleton?

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

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

🤔 Что такое monkey patch?

Monkey patching (буквально "заплатка обезьяны") в программировании — это техника, позволяющая динамически изменять или расширять код во время выполнения программы. В Python это означает изменение или дополнение методов, атрибутов или классов в модуле или библиотеке, даже если у вас нет прямого доступа к исходному коду.

🚩Зачем нужен monkey patching

🟠Исправление ошибок
Быстрое исправление ошибок в сторонних библиотеках без необходимости изменения их исходного кода.
🟠Добавление функциональности
Расширение возможностей сторонних библиотек.
🟠Изменение поведения
Замена существующих функций или методов на свои собственные для изменения поведения программы.

🚩Пример monkey patching

import time

# Оригинальная функция
def original_sleep(seconds):
    time.sleep(seconds)
    print(f"Slept for {seconds} seconds")

# Monkey patching функции sleep
def patched_sleep(seconds):
    print(f"Patched! Should have slept for {seconds} seconds")

# Применение monkey patching
time.sleep = patched_sleep

# Примеры использования
time.sleep(3)  # Вывод: Patched! Should have slept for 3 seconds

🚩Недостатки

➖Неявные изменения
Изменения могут быть неочевидны другим разработчикам, что может привести к путанице и затруднениям в отладке.
➖Совместимость
Monkey patching может вызвать проблемы совместимости при обновлении библиотек или модулей.
➖Непредсказуемость
Изменения в поведении программы могут быть трудно предсказуемыми и отлаживаемыми.

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

🤔 Для чего нужен сериализатор?

Сериализатор преобразует данные из одного формата в другой, например, из объектов в JSON или обратно. Он используется для передачи данных между системами, а также для хранения или передачи структурированных данных. В веб-разработке сериализаторы часто применяются для работы с API.

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

🤔 Что такое pytest?

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

🚩Зачем нужен

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

🚩Как используется

🟠Написание тестов
Тесты пишутся в виде функций, начинающихся с test_.
🟠Запуск тестов
Тесты выполняются с помощью команды pytest в командной строке.
🟠Ассерты
Используются стандартные утверждения (assert) для проверки условий.

🚩Основные возможности

🟠Автоматическое обнаружение тестов
pytest автоматически находит тестовые функции, классы и файлы.
🟠Фикстуры: Позволяют определять подготовительный и завершающий код для тестов.
🟠Параметризация
Позволяет запускать один и тот же тест с различными входными данными.
🟠Плагины
Расширяют функциональность фреймворка, например, для генерации отчетов, интеграции с CI/CD системами.

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

# test_sample.py
def test_addition():
    assert 1 + 1 == 2

def test_subtraction():
    assert 2 - 1 == 1

Запуск тестов:

pytest

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

import pytest

@pytest.fixture
def sample_data():
    return {"key1": "value1", "key2": "value2"}

def test_sample_data(sample_data):
    assert sample_data["key1"] == "value1"

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

import pytest

@pytest.mark.parametrize("a, b, result", [
    (1, 2, 3),
    (2, 3, 5),
    (3, 5, 8)
])
def test_addition(a, b, result):
    assert a + b == result

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

🤔 Зачем нужен метод super в классе?

Метод super позволяет вызывать методы родительского класса в контексте текущего класса. Это удобно при переопределении методов для сохранения их базового поведения. Также super используется для инициализации атрибутов родительского класса.

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

🤔 Что такое mock?

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

🚩Зачем нужен

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

🚩Основные возможности

🟠Создание mock-объектов
Могут заменять любые объекты в коде.
🟠Настройка поведения
Указание, какие значения должны возвращать mock-объекты.
🟠Отслеживание вызовов
Возможность проверять, как и сколько раз были вызваны методы mock-объекта.
🟠Контекстные менеджеры и декораторы
Упрощают замену объектов в тестах на mock.

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

Предположим, у нас есть функция, которая обращается к внешнему API:

import requests

def get_user_data(user_id):
    response = requests.get(f"https://api.example.com/users/{user_id}")
    return response.json()

Чтобы протестировать эту функцию без реальных запросов, можно использовать mock:

from unittest.mock import patch

@patch('requests.get')
def test_get_user_data(mock_get):
    mock_get.return_value.json.return_value = {"id": 1, "name": "John Doe"}
    
    result = get_user_data(1)
    
    assert result == {"id": 1, "name": "John Doe"}
    mock_get.assert_called_once_with("https://api.example.com/users/1")

🚩Основные методы и атрибуты

🟠return_value
Устанавливает возвращаемое значение метода.
🟠side_effect
Устанавливает последовательность возвращаемых значений или исключений.
🟠assert_called_with()
Проверяет, что метод был вызван с определенными аргументами.
🟠assert_called_once_with()
Проверяет, что метод был вызван ровно один раз с определенными аргументами.

🚩Пример с контекстным менеджером

import requests
from unittest.mock import patch

def get_status_code(url):
    response = requests.get(url)
    return response.status_code

def test_get_status_code():
    with patch('requests.get') as mock_get:
        mock_get.return_value.status_code = 200
        
        assert get_status_code("https://example.com") == 200
        mock_get.assert_called_once_with("https://example.com")

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

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

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

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

🤔 Какие бывают виды тестов?

Существует несколько видов тестов, каждый из которых имеет свою цель и особенности.

🚩Виды

🟠Юнит-тесты (Unit Tests)
Проверка работы отдельных модулей или функций в изоляции от других частей системы.
Ориентированы на минимальные части кода (функции, методы, классы).
Высокая скорость выполнения.
Простота написания и отладки.
Обычно пишутся разработчиками.

def add(a, b):
    return a + b

def test_add():
    assert add(1, 2) == 3

🟠Интеграционные тесты (Integration Tests)
Проверка взаимодействия между различными модулями или компонентами системы.
Тестируют комбинации модулей и их взаимодействие.
Более сложные и медленные по сравнению с юнит-тестами.
Могут выявить проблемы в интерфейсах между модулями.

def fetch_data_from_api():
    response = requests.get('https://api.example.com/data')
    return response.json()

def test_fetch_data_from_api():
    data = fetch_data_from_api()
    assert 'key' in data

🟠Системные тесты (System Tests)
Проверка всей системы целиком на соответствие требованиям.
Тестируют систему в рабочей среде.
Включают проверку всех функциональных и нефункциональных требований.
Могут включать пользовательские сценарии.
Тестирование веб-приложения на основе реальных пользовательских сценариев, включая проверку интерфейса, баз данных и API.

🟠Приемочные тесты (Acceptance Tests)
Проверка соответствия системы требованиям и ожиданиям заказчика или конечного пользователя.
Часто выполняются вместе с заказчиком или пользователем.
Фокусируются на бизнес-требованиях и пользовательских сценариях.
Успешное прохождение приемочных тестов является критерием готовности системы к выпуску.
Тестирование нового функционала с участием конечных пользователей для проверки его удобства и соответствия их ожиданиям.

🟠Регрессионные тесты (Regression Tests)
Убедиться, что изменения в коде не вызвали новых ошибок в уже работающем функционале.
Выполняются после внесения изменений в код.
Обычно автоматизируются и включают повторное выполнение всех или части существующих тестов.
Повторное выполнение всех юнит-тестов и интеграционных тестов после рефакторинга кода.

🟠Нефункциональные тесты (Non-functional Tests)
Проверка нефункциональных аспектов системы, таких как производительность, безопасность, удобство использования и др.

🚩Основные виды:

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

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

🤔 Как работает middleware?

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

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

🤔 Пирамида тестирования?

Это концепция, предложенная Майком Коэном (Mike Cohn), которая описывает оптимальное соотношение разных видов тестов для обеспечения качественного программного обеспечения. Пирамида тестирования визуально представлена в виде треугольника, где каждый уровень соответствует определённому виду тестов, а ширина уровня отражает рекомендуемое количество тестов этого вида.

🚩Уровни пирамиды тестирования

🟠Юнит-тесты (Unit Tests)
Расположение: Основание пирамиды.
Цель: Тестирование отдельных функций или методов в изоляции.
Количество: Наибольшее количество тестов.
Особенности: Высокая скорость выполнения, низкая стоимость написания и поддержки.

def add(a, b):
return a + b

def test_add():
assert add(1, 2) == 3

🟠Интеграционные тесты (Integration Tests)
Расположение: Средний уровень пирамиды.
Цель: Тестирование взаимодействия между различными модулями или компонентами.
Количество: Меньше, чем юнит-тестов, но больше, чем системных тестов.
Особенности: Проверка интерфейсов и взаимодействия между модулями, более сложные и медленные, чем юнит-тесты.

def fetch_data_from_api():
response = requests.get('https://api.example.com/data')
return response.json()

def test_fetch_data_from_api():
data = fetch_data_from_api()
assert 'key' in data

🟠Системные тесты (System Tests)
Расположение: Вершина пирамиды.
Цель: Тестирование всей системы целиком на соответствие требованиям.
Количество: Наименьшее количество тестов.
Особенности: Включают тестирование пользовательских сценариев, проверку функциональных и нефункциональных требований, самые сложные и медленные.

🚩Зачем нужна

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

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

🤔 Чем отличаются декораторы classmethod и staticmethod?

classmethod делает метод привязанным к классу, а не к экземпляру, и первым аргументом передаёт сам класс (cls). staticmethod не привязан ни к классу, ни к экземпляру, и ведёт себя как обычная функция внутри класса. Оба декоратора используются для разделения логики методов в зависимости от их назначения.

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

🤔 Что делать, если тестируемая функция использует удалённое подключение к внешним сервисам, которое иногда выдает ошибку таймаута, 404 и им подобные?

Такие ситуации можно обработать и протестировать несколькими способами. Один из наиболее распространенных подходов — использование mock-объектов для имитации поведения внешних сервисов. Это позволяет изолировать тестируемую функцию и контролировать ее взаимодействие с внешними сервисами.

🚩Шаги для решения проблемы

1⃣Использование библиотеки `unittest.mock` для создания mock-объектов
С помощью библиотеки unittest.mock можно подменить вызовы к внешним сервисам и задать их поведение, включая ошибки и исключения.

2⃣Обработка исключений в тестируемой функции
В тестируемой функции следует предусмотреть обработку возможных ошибок, таких как таймауты и HTTP-статусы (например, 404), чтобы она корректно реагировала на эти ситуации.

Предположим, у нас есть функция, которая запрашивает данные с удаленного сервиса

import requests

def fetch_data_from_api(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.Timeout:
        return {"error": "Timeout"}
    except requests.exceptions.HTTPError as http_err:
        return {"error": f"HTTP error: {http_err.response.status_code}"}
    except requests.exceptions.RequestException as err:
        return {"error": f"Request error: {err}"}

🚩Тестирование с использованием `unittest.mock`

Установка поведения для mock-объекта
Создадим тесты, которые подменяют вызов requests.get и задают различные сценарии ошибок.

from unittest.mock import patch
import requests
import pytest

def test_fetch_data_timeout():
    with patch('requests.get') as mock_get:
        mock_get.side_effect = requests.exceptions.Timeout
        result = fetch_data_from_api("https://example.com/data")
        assert result == {"error": "Timeout"}

def test_fetch_data_404():
    with patch('requests.get') as mock_get:
        mock_response = mock_get.return_value
        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(response=mock_response)
        mock_response.status_code = 404
        result = fetch_data_from_api("https://example.com/data")
        assert result == {"error": "HTTP error: 404"}

def test_fetch_data_request_exception():
    with patch('requests.get') as mock_get:
        mock_get.side_effect = requests.exceptions.RequestException("Connection error")
        result = fetch_data_from_api("https://example.com/data")
        assert result == {"error": "Request error: Connection error"}

1⃣Тест на таймаут
Используем mock_get.side_effect = requests.exceptions.Timeout для имитации ошибки таймаута. Проверяем, что функция возвращает ожидаемое значение при таймауте.

2⃣Тест на HTTP ошибку 404
Устанавливаем mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(response=mock_response) для имитации HTTP ошибки. Устанавливаем код статуса mock_response.status_code = 404. Проверяем, что функция возвращает ожидаемое значение при HTTP ошибке 404.

3⃣Тест на общую ошибку запроса
Используем mock_get.side_effect = requests.exceptions.RequestException("Connection error") для имитации общей ошибки запроса. Проверяем, что функция возвращает ожидаемое значение при общей ошибке запроса.

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