🤔 Зачем нужен метод 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") для имитации общей ошибки запроса. Проверяем, что функция возвращает ожидаемое значение при общей ошибке запроса.

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

🤔 Что происходит в момент итерации по списку?

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

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

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

Можно использовать мокирование (mocking) зависимостей или стабирование (stubbing), чтобы заменить долгие операции на быстрые фиктивные реализации, которые будут возвращать заранее заданные значения. Также можно рассмотреть параллельное выполнение или кеширование результатов для ускорения тестов.

🚩Подходы к оптимизации тестов

🟠Кэширование результатов
Если функция выполняет одинаковые операции с одинаковыми входными данными, можно кэшировать результаты этих операций, чтобы не выполнять их повторно.
🟠Мокирование (mocking) повторяющихся операций
Используйте mock-объекты для замены дорогих операций фиктивными, которые возвращают заранее определенные результаты.
🟠Использование фикстур (fixtures)
Фикстуры позволяют подготовить данные или состояния один раз перед выполнением тестов и повторно использовать их в разных тестах.
🟠Параллельное выполнение тестов
Параллельное выполнение тестов может значительно сократить общее время тестирования. Допустим, у нас есть функция, которая выполняет дорогую операцию:

import time

def expensive_operation(data):
    time.sleep(5)  # Имитация долгой операции
    return sum(data)

def process_data(data):
    result = []
    for item in data:
        result.append(expensive_operation(item))
    return result

🚩Оптимизация с использованием

🟠Мокирования
Мы можем замокировать expensive_operation, чтобы она возвращала заранее определенные результаты без выполнения долгих операций.

from unittest.mock import patch

def test_process_data():
    data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    with patch('__main__.expensive_operation') as mock_expensive:
        mock_expensive.side_effect = [6, 15, 24]  # Заранее определенные результаты
        
        result = process_data(data)
        
        assert result == [6, 15, 24]
        assert mock_expensive.call_count == 3  # Проверка, что функция вызвана 3 раза

🟠Кэширования

Используем кэширование для хранения результатов дорогостоящих операций.

from functools import lru_cache

@lru_cache(maxsize=None)
def expensive_operation(data):
    time.sleep(5)  # Имитация долгой операции
    return sum(data)

def process_data(data):
    result = []
    for item in data:
        result.append(expensive_operation(tuple(item)))  # Преобразуем список в кортеж для кэширования
    return result

🚩Использование фикстур в pytest

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

import pytest

@pytest.fixture
def sample_data():
    return [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

def test_process_data(sample_data):
    with patch('__main__.expensive_operation') as mock_expensive:
        mock_expensive.side_effect = [6, 15, 24]  # Заранее определенные результаты
        
        result = process_data(sample_data)
        
        assert result == [6, 15, 24]

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

Запуск тестов параллельно
Используйте возможности параллельного выполнения тестов, например, с помощью pytest-xdist.

pytest -n 4  # Запуск тестов в 4 параллельных потоках

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

🤔 Как в функцию передаются аргументы, по ссылке или по значению?

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

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

🤔 Чем интеграционное тестирование отличается от функционального?

🚩Интеграционное тестирование

Проверка взаимодействия между различными модулями или компонентами системы.

🟠Фокус на взаимодействии
Проверяет, как отдельные части системы работают вместе.
🟠Обнаружение интерфейсных ошибок
Выявляет проблемы, которые могут возникнуть при передаче данных или управлении между модулями.
🟠Промежуточное тестирование
Проводится после юнит-тестов и перед системными тестами.
🟠Тестирование зависимостей
Включает взаимодействие с внешними сервисами, базами данных, файлами и другими модулями.
🟠Инструменты
Часто используются mock-объекты для замены реальных зависимостей.

def fetch_data_from_db():
    # Имитация запроса к базе данных
    return {"user": "John", "email": "john@example.com"}

def send_email(data):
    # Имитация отправки электронной почты
    print(f"Sending email to {data['email']}")

def process_user_data():
    data = fetch_data_from_db()
    send_email(data)

Интеграционный тест может выглядеть так

def test_process_user_data():
    data = fetch_data_from_db()
    assert data["email"] == "john@example.com"
    send_email(data)

🚩Функциональное тестирование

Проверка функциональности системы на соответствие требованиям.

🟠Фокус на функциональности
Проверяет, выполняет ли система свои функции в соответствии с заданными требованиями.
🟠Проверка конечного поведения
Тестирует систему с точки зрения конечного пользователя.
🟠Все уровни тестирования
Может включать юнит-тесты, интеграционные тесты, системные и приемочные тесты.
🟠Тестирование "черного ящика"
Не требует знания внутренней структуры или кода системы.
🟠Инструменты
Могут использоваться автоматизированные тестовые фреймворки, такие как Selenium для веб-приложений.

def register_user(username, password):
    # Имитация регистрации пользователя
    if username and password:
        return "Registration successful"
    else:
        return "Registration failed"

Функциональный тест может выглядеть так:

def test_register_user():
    assert register_user("testuser", "securepassword") == "Registration successful"
    assert register_user("", "securepassword") == "Registration failed"

🚩Ключевые отличия

🟠Цель
Интеграционное тестирование: Проверка взаимодействия между модулями.
Функциональное тестирование: Проверка функциональности системы на соответствие требованиям.
🟠Фокус
Интеграционное тестирование: Взаимодействие и интерфейсы между модулями.
Функциональное тестирование: Поведение системы с точки зрения пользователя.
🟠Уровень тестирования
Интеграционное тестирование: Промежуточный уровень между юнит-тестами и системными тестами.
Функциональное тестирование: Может охватывать все уровни, включая юнит-тесты, интеграционные, системные и приемочные тесты.
🟠Методология
Интеграционное тестирование: Тестирование "серого ящика" (частичное знание внутренней структуры).
Функциональное тестирование: Тестирование "черного ящика" (без знания внутренней структуры).

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

🤔 Кем себя видишь через два года при работе в фуллтайм?

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

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

🤔 Что происходит с запросом после того как мы обработали его во вьюхе?

🚩Этапы обработки запроса после вьюхи

1⃣Формирование ответа (Response) во вьюхе
Вьюха обрабатывает запрос (например, получение данных из базы данных, выполнение бизнес-логики). На основе обработки данных вьюха формирует объект ответа. В Django это может быть HttpResponse, JsonResponse и т.д. В Flask это может быть объект Response или просто строка, которая будет конвертирована в ответ.

from django.http import HttpResponse

def my_view(request):
   data = "Hello, World!"
   return HttpResponse(data)   

Пример в Flask

from flask import Flask, Response

app = Flask(__name__)

@app.route('/')
def my_view():
   return Response("Hello, World!")   

2⃣Обработка промежуточными слоями (Middleware)
После того как вьюха сформировала ответ, он проходит через цепочку промежуточных слоев (middleware). Middleware могут модифицировать объект ответа, добавлять заголовки, обрабатывать ошибки и т.д. Примеры обработки включают логирование, сжатие контента, обработку сессий и т.д.

class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        response['X-Custom-Header'] = 'My Custom Header'
        return response

3⃣Обработка сервером и отправка ответа
После прохождения всех промежуточных слоев ответ передается веб-серверу. Веб-сервер, такой как Nginx или Apache, отправляет сформированный ответ обратно клиенту (например, браузеру). Сервер обрабатывает низкоуровневые детали HTTP-протокола, такие как установка соединения, обработка заголовков и передача данных.

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

🤔 Что знаешь про два основных типа данных Python?

Основные типы данных Python — изменяемые (списки, множества, словари) и неизменяемые (строки, числа, кортежи). Изменяемые можно модифицировать после создания, тогда как неизменяемые остаются неизменными.

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

🤔 Каким образом проходит информация валидацию?

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

🟠Клиентская валидация (Client-side Validation)
До отправки данных на сервер. Используются HTML5 атрибуты и JavaScript. Снижение нагрузки на сервер, мгновенная обратная связь для пользователя. Не является надежной, так как пользователь может обойти ее.

<form>
    <input type="text" name="username" required minlength="3">
    <input type="email" name="email" required>
    <input type="submit">
</form>

Пример JavaScript валидации

document.querySelector('form').addEventListener('submit', function(event) {
    const username = document.querySelector('input[name="username"]').value;
    if (username.length < 3) {
        alert('Username must be at least 3 characters long.');
        event.preventDefault();
    }
});

🟠Серверная валидация (Server-side Validation)
После получения данных от клиента. Используются встроенные или сторонние библиотеки и фреймворки. Надежная защита, обязательна даже при наличии клиентской валидации. Добавляет нагрузку на сервер, может увеличить время отклика.

from django import forms

class UserForm(forms.Form):
    username = forms.CharField(min_length=3, max_length=100)
    email = forms.EmailField()

def my_view(request):
    if request.method == 'POST':
        form = UserForm(request.POST)
        if form.is_valid():
            # Обработка данных
            pass
        else:
            # Обработка ошибок
            pass
    else:
        form = UserForm()
    return render(request, 'my_template.html', {'form': form})

Пример в Flask

from flask import Flask, request, render_template_string
from wtforms import Form, StringField, validators

app = Flask(__name__)

class UserForm(Form):
    username = StringField('Username', [validators.Length(min=3, max=100)])
    email = StringField('Email', [validators.Email()])

@app.route('/', methods=['GET', 'POST'])
def my_view():
    form = UserForm(request.form)
    if request.method == 'POST' and form.validate():
        # Обработка данных
        pass
    return render_template_string('<form method="POST">{{ form.csrf_token }}{{ form.username }}{{ form.email }}<input type="submit"></form>', form=form)

🟠Валидация на уровне базы данных (Database Validation)
При сохранении данных в базу данных. Используются ограничения базы данных (constraints) и триггеры. Гарантия целостности данных на уровне хранения. Может вызвать ошибки, если данные уже были приняты сервером, но не прошли валидацию на уровне БД.

Пример ограничения в SQL

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(100) NOT NULL CHECK (LENGTH(username) >= 3),
    email VARCHAR(100) NOT NULL UNIQUE
);

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

🤔 Какие магические методы и для чего используются?

Магические методы (например, __init__, __str__, __len__, __add__) используются для определения поведения объектов в специфичных ситуациях, таких как инициализация, строковое представление, арифметические операции или работа с коллекциями.

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

🤔 Что такое WSGI?

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

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

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

🚩Основные компоненты

🟠WSGI-сервер
Программное обеспечение, которое принимает HTTP-запросы от клиента (например, браузера), преобразует их в формат, понятный приложению, и затем отправляет HTTP-ответы обратно клиенту. Примеры WSGI-серверов: Gunicorn, uWSGI.
🟠WSGI-приложение
Любое Python-приложение или фреймворк, которое реализует WSGI-интерфейс. Примеры фреймворков: Django, Flask.

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

WSGI определяет простой интерфейс, который веб-сервер использует для передачи запросов в приложение и получения ответов от него. Этот интерфейс основан на вызове функции или вызываемого объекта (callable), который принимает два аргумента: environ и start_response.

🟠`environ`
Словарь, содержащий все данные о запросе, такие как заголовки, параметры и другие метаданные.
🟠`start_response`
Функция, которую приложение вызывает для начала формирования ответа. Она принимает статус ответа и заголовки.

def application(environ, start_response):
    status = '200 OK'
    headers = [('Content-Type', 'text/plain')]
    start_response(status, headers)
    return [b"Hello, World!"]

# Запуск приложения с использованием встроенного WSGI-сервера wsgiref
if __name__ == "__main__":
    from wsgiref.simple_server import make_server
    server = make_server('localhost', 8051, application)
    print("Serving on http://localhost:8051...")
    server.serve_forever()

🚩Как использовать WSGI с фреймворками:

Современные Python веб-фреймворки, такие как Django и Flask, автоматически поддерживают WSGI. Это позволяет легко развертывать приложения, используя WSGI-серверы.

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello, World!"

if __name__ == "__main__":
    app.run()

Для развертывания этого приложения с использованием WSGI-сервера, например, Gunicorn, можно выполнить команду. Где myapp — это имя файла без расширения .py, а app — это объект приложения Flask.

gunicorn myapp:app

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

🤔 Что знаешь о сложности алгоритма?

Сложность алгоритма измеряется в терминах времени (time complexity) и памяти (space complexity), отражая, как ресурсы зависят от объёма входных данных. Часто используется нотация O-большое (например, O(n), O(log n)).

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

🤔 В чем отличие Django от микрофреймворков, например FastAPI?

Django и микрофреймворки, такие как FastAPI, предназначены для разработки веб-приложений на Python, но они имеют различия в подходе, функциональности и областях применения.

🚩Django

🟠Полный фреймворк (Full-Stack Framework)
Django предоставляет полный набор инструментов для разработки веб-приложений, включая ORM (Object-Relational Mapping), систему шаблонов, формы, аутентификацию, админ-панель и другие компоненты. Подходит для разработки сложных и крупных приложений, требующих множества встроенных функциональностей.

🟠Явные настройки и соглашения
Django следует принципу "The web framework for perfectionists with deadlines", предлагая стандартные способы решения большинства задач. Многое делается "из коробки", что снижает необходимость принимать решения по настройке и интеграции.

🟠Монолитная архитектура
Django создавался с идеей "все включено", что означает, что все основные компоненты встроены и работают вместе. Это упрощает создание приложений, но может быть избыточным для небольших или простых проектов.

🟠Удобство работы с базами данных
Django ORM позволяет удобно работать с различными базами данных, абстрагируясь от специфики SQL. Включает мощные средства для миграций баз данных.

from django.shortcuts import render
from django.http import HttpResponse

def hello_world(request):
    return HttpResponse("Hello, World!")

🚩FastAPI

🟠Микрофреймворк (Microframework)
FastAPI является легковесным фреймворком, предназначенным для создания высокопроизводительных веб-API. Включает минимальное количество компонентов, предоставляя только то, что необходимо для обработки запросов и ответов.

🟠Асинхронная поддержка и высокая производительность
FastAPI изначально поддерживает асинхронное программирование с помощью async и await, что позволяет создавать высокопроизводительные приложения. Построен на базе Starlette и Pydantic, что обеспечивает скорость работы и удобную валидацию данных.

🟠Минимальные зависимости
FastAPI следует принципу "минимальных зависимостей", позволяя разработчику добавлять только необходимые компоненты и библиотеки. Легко интегрируется с различными базами данных и другими инструментами по мере необходимости.

🟠Современные возможности типизации
FastAPI использует аннотации типов Python для автоматической генерации документации OpenAPI и валидации данных. Это упрощает разработку и тестирование API, делая код более читаемым и поддерживаемым.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def hello_world():
    return {"message": "Hello, World!"}

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

🟠Функциональность
Django: Предоставляет все необходимые инструменты для разработки полного веб-приложения, включая работу с базами данных, формами, аутентификацией и админ-панелью.
FastAPI: Фокусируется на создании быстрых и производительных веб-API, оставляя выбор других инструментов за разработчиком.

🟠Асинхронность
Django: Поддержка асинхронного программирования была добавлена в более поздних версиях, но изначально он был ориентирован на синхронное программирование.
FastAPI: Изначально построен с поддержкой асинхронного программирования, что позволяет создавать высокопроизводительные приложения.

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