Как написать фреймворк на python

Как написать свой python веб-фреймворк

Каждый из нас хотя бы раз в жизни мечтал сделать что-то «как это, но лучше» . Сегодня мы частично поддадимся этому желанию и, закрыв глаза на стоящую за ним глупость, рассмотрим с чего начать создание своего web-фреймвока на python .

Несмотря на то, что тема кажется очень сложной, в основе её лежат настолько простые вещи, что справится с этой задачей даже школьник . Помимо очевидно необходимого (хотя бы примерно) понимания протокола HTTP , нам нужно понять как вообще какие-то там байты доходят до питона.

Здесь на сцену выходят такие понятия как WSGI и ASGI , которые являются стандартом взаимодействия между веб-сервером и python-приложением. Причем с точки зрения реализации ASGI — лишь следующий шаг в развитии протокола, поддерживающий асинхронность. Что на практике чаще всего сводится к поддержке вебсокетов и увеличению в разы количества обрабатываемых запросов в секунду за счёт использования времени простоя при IO операциях, но сейчас не об этом.

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

def wsgi_app(environ, start_response):  . 

Далее, всё что от нас требуется — вызвать обработчик start_response передав код ответа и заголовки, а после вернуть итератор с телом ответа. Можно использовать yield , чтобы превратить функцию в генератор, а можно просто использовать return iter(. ) — тут уже ваша реализация.

Более интересным и живым является, конечно же, ASGI. На нём мы и остановимся, чтобы рассмотреть немного подробнее, т.к. писать в 2022 году фреймворк под WSGI как минимум глупо.

async def app(scope, receive, send):  await send(. )

Отличия небольшие, но какие! Во-первых, наша функция стала async , что уже позволяет нам использовать разного рода преимущества асинхронного программирования и увеличить производительность. Во-вторых, мы получили немного иные параметры: scope , который содержит информацию о запросе (тип, метод, путь, заголовки и т.д.) и две корутины receive и send (они же асинхронные функции, которые мы должны подвергнуть жесточайшему await ‘у) для получения и отправки данных.

Теперь, зная теорию, мы вполне можем написать своё первое ASGI приложение, которое будет отвечать на HTTP запросы, возвращая простой текст «It’s alive!» в ответ:

async def app(scope, receive, send):  assert scope['type'] == 'http'  await send(  'type': 'http.response.start',  'status': 200,  'headers': [  [b'content-type', b'text/plain'],  ],  >)  await send(  'type': 'http.response.body',  'body': b'It\'s alive!',  >)

Ну и запустим какой-нибудь ASGI сервер (например, uvicorn ), который будет принимать запросы и выполнять наш код:

uvicorn main:app

Переходим в браузер, вводим адрес из лога uvicorn, смотрим — оно живое!

Вы и не заметили, но к данному абзацу у нас есть всё необходимое , чтобы начать имплементацию своего собственного фреймворка , ведь тот же FastAPI , который я так люблю упоминать, работает точно так же ! Роутинг, промежуточные слои, сессии и прочее — всё это условности и расширения функций, которые реализуют сами фреймворки поверх стандартов WSGI и ASGI.

Есть небольшая уловка, которая избавляет разработчиков FastAPI от работы с «низкоуровневым» ASGI кодом. Уловка эта называется starlette и является по сути обёрткой над ASGI, которая делает всю грязную работу, но это мы рассмотрим (если рассмотрим) как-нибудь в другой раз.

• Uptime
• Twitter
• GitHub

Как в Python создать свой ПО фреймворк? [закрыт]

Закрыт. На этот вопрос невозможно дать объективный ответ. Ответы на него в данный момент не принимаются.

Хотите улучшить этот вопрос? Переформулируйте вопрос так, чтобы на него можно было дать ответ, основанный на фактах и цитатах.

Закрыт 3 года назад .

хочу в основном ради обучения, ну и не только, попробовать написать свой ПО фреймворк на Python. Но вот сколько гуглю только нашел информацию по ВЕБ-фреймворкам, но никак не по ПО. Подскажите способы. Буду очень благодарен

Отслеживать
27.2k 2 2 золотых знака 45 45 серебряных знаков 76 76 бронзовых знаков
задан 29 сен 2020 в 16:05
228 4 4 серебряных знака 11 11 бронзовых знаков

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

29 сен 2020 в 16:07
на питоне будет не эффективно и медленно, пишите на си или асм.
29 сен 2020 в 17:17
@Интик Нормально будет, не надо тут вашего asm.
30 сен 2020 в 8:50
@Victor VosMottor по фреймворк работающий с 1 ядром это не нормально
30 сен 2020 в 10:08

Я думаю что если уметь оптимизировать, + учесть скорость многих пк, то не будет медленно, а си, ну как бы нет, есть С++, который гораздо круче, но я его не знаю, и учить врятли буду, Python, C#, и для веба

30 сен 2020 в 13:28

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Сперва необходимо понять что такое фреймворк. Потому что иногда фреймворки путают с библиотеками. Библиотека это некоторый набор готовых решений для конкретных задач. Например библиотека для работы с растровым изображением. Она потому и библиотека — потому что помогает в работе с растровым изображением (вот какой каламбур). Есть узкоспециализированная задача — есть набор функций (библиотека) для ее решения.

В свою очередь фреймворк помогает с архитектурными задачами — задачами проектирования. Можно 1000 раз использовать разные библиотечные функции, заменять их, переписывать, менять библиотеки. Но что то фундаментальное — архитектура приложения, пишется один раз и поддерживается на всем протяжении жизни приложения. Фреймворк в первую очередь предоставляет каркас — каркас на который надевают все остальное. Вокруг каркаса и организовывается код. Фреймворк позволяет обобщить решение задач, возлагая на конечного пользователя писать более предметно ориентированный код.

Написать свой личный фреймворк это достаточно трудоемкая задача. Написать библиотеку проще. В качестве своего домашнего фреймворка, можно попробовать сделать фреймворк для написания парсеров. Множество людей пишут так или иначе парсеры. Может быть тут можно что то сделать?!

Фреймворки Python

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

Python — один из самых популярных и универсальных языков программирования в мире. Он прост в изучении, мощный в своих возможностях и подходит для разработки различных типов приложений: от веб-сайтов до игр, от анализа данных до машинного обучения.

Что такое фреймворк

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

Зачем использовать фреймворки Python

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

В этой статье мы будем говорить о фреймворках для веб-разработки на Python.

Веб-разработка — это процесс создания веб-сайтов или веб-приложений, которые работают в интернете или локальной сети. Веб-разработка состоит из двух частей: фронтенд (то, что видит пользователь) и бэкенд (то, что происходит на сервере). Для создания веб-приложений нужно знать несколько языков программирования, например, таких как HTML, CSS, JavaScript для фронтенда и PHP, Ruby, Python для бэкенда.

Фреймворки Python имеет ряд преимуществ для веб-разработчиков, так как они:

• Ускоряют процесс разработки: предоставляют готовые решения для часто встречающихся задач, таких как аутентификация, маршрутизация, работа с базами данных, кэширование.
• Обеспечивают безопасность приложений: защищают от распространенных угроз и атак, таких как SQL-инъекции, XSS, CSRF.
• Повышают производительность и стабильность приложений: оптимизируют код, управляют памятью и ресурсами, поддерживают масштабируемость и нагрузку.
• Упрощают интеграцию с различными технологиями и сервисами: такими как API, машинное обучение, облачные платформы.
• Имеют большое и активное сообщество разработчиков: которые поддерживают и обновляют фреймворки, а также предоставляют документацию, учебные материалы и помощь при возникновении проблем.
• Помогают избежать написания повторяющегося кода: встроенные функции и инструменты позволяют разработчикам использовать готовые модули и библиотеки — это сокращает время и усилия, затрачиваемые на написание однотипного кода, и повышает производительность разработчика.
• Определяют архитектуру и логику приложения: определяют архитектурные принципы и паттерны, такие как MVC (Model-View-Controller), MVVM (Model-View-ViewModel), которые помогают разработчикам разделить код на логические компоненты и упрощают поддержку и масштабирование приложения.
• Определяют взаимодействие с другими системами: предоставляют интеграцию с другими системами и сервисами через встроенные API и расширяемость.

Основные типы фреймворков Python

Фреймворки Python для веб-разработки можно разделить на три типа: Full Stack фреймворки, микрофреймворки и асинхронные фреймворки.

Full Stack фреймворки

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

Назначение: подходят для создания сложных и масштабируемых приложений с большим функционалом.

Примеры Full Stack фреймворков: Django, Pyramid, Web2py.

Микрофреймворки

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

Назначение: подходят для создания простых и легковесных приложений или прототипов.

Примеры микрофреймворков: Flask, Bottle, Tornado.

Асинхронные фреймворки

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

Асинхронное программирование — это вид параллельного программирования, в котором какая-либо единица работы может выполняться отдельно от основного потока выполнения приложения. Когда основной поток сталкивается с операцией, которая требует ожидания (например, запрос к базе данных или к внешнему сервису), он не блокируется, а переключается на другую задачу, пока не получит результат. Таким образом повышается эффективность и отзывчивость приложений, особенно при работе с большим количеством одновременных запросов.

Назначение: подходят для создания высокопроизводительных и масштабируемых приложений, которые могут обрабатывать большое количество одновременных соединений.

Примеры асинхронных фреймворков: FastAPI, Twisted, Kivy.

Если вы хотите глубже изучить пайтон фремворки, читайте нашу статью ТОП-12 популярных Python фреймворков.

Софья Пирогова

автор статей / копирайтер

Вам может также понравиться.

Для чего и кому нужны Big Data

7 нояб. 2023 г.

Big Data: основные понятия

31 окт. 2023 г.

Создание своего веб-фреймворка на Python — Часть 1

22 апреля 2019 г. Archy Просмотров: 23010 RSS 5
Веб-программирование » Python для начинающих » Общие вопросы

“Не нужно изобретать велосипед” — одна из тех мантр, которую нам повторяют время от времени. Но что, если мы хотим узнать больше о велосипеде? Что, если я хочу научиться делать велосипеды? Я думаю в таком случае, заново изобрести велосипед — отличный способ обучения. Поэтому, в этом руководстве мы напишем собственный веб-фреймворк, чтобы увидеть, как работает магия Flask, Django, и других фреймворков.

В этом руководстве мы построим наиболее важные части фреймворка. В конце у нас появятся обработчики запросов (к примеру, Django views), и маршрутизации: простая (как /books/ ) и параметризованная (как /greet/ ). Если интересно, в разделе комментариев вы можете рассказать о других функциях, которые на ваш взгляд, стоит реализовать в нашем фреймворке.

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

Gunicorn это WSGI HTTP сервер, так что для него нужна особенная точка входа в наше приложение.

Ознакомились с WSGI? Отлично! Давайте продолжим.

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

VPS для практики

Если вы начинающий программист, то рано или поздно вам придется познакомиться с Linux и запуском своего приложения сразу на рабочий VPS для клиента или для собственного проекта. Мы рекомендуем VPS от Fornex, т.к. данный хостинг отлично подходит для тех кто хочет быстро получить рабочий и надежный VPS.

Какой VPS выбрать?

Это самый сложный вопрос который может появится у новичка над которым вываливают весь спектр услуг.

Первым делом нужно завести аккаунт на Fornex.com

На данном этапе нашего проекта подойдет и обычный VPS.

Выбираем SSD CLOUD 1GB и операционную систему Debian 9. Всегда нужно выбирать последнюю самую новую версию. Это избавит вас от проблем со старыми библиотеками.

Подключение по SSH

После заказа нашего VPS, мы получим данные от сервера. Нам понадобиться логин и пароль от SSH. Для того чтобы войти по SSH мы воспользуемся Putty (для Windows) либо в обычный терминал на Linux пишем:

ssh root@IP-нашего-VPS

$ apt update $ apt upgrade

$ apt install python3

Для корректной работы, нужно установить необходимые библиотеки:

$ apt install python3-setuptools python3-dev python3-venv $ apt install libtiff5-dev libjpeg8-dev zlib1g-dev $ apt install libfreetype6-dev liblcms2-dev libwebp-dev tcl8.6-dev tk8.6-dev python-tk

Ниже мы будем использовать менеджер пакетов pip, устанавливаем его:

$ apt install python3-pip

Создание веб-фреймворка

Придумайте название вашего фреймворка и создайте одноименную папку. Свой я назвал bumbo :

cd /home mkdir bumbo

Переходим к этой папке, создаем виртуальное окружение и активируем её:

cd bumbo python3.6 -m venv venv source venv/bin/activate

Теперь мы создаем файл под названием app.py , где будет находиться наша точка входа для gunicorn:

touch app.py

Внутри нашего файла app.py мы впишем простую функцию, чтобы узнать, будет ли она работать с gunicorn :

# app.py def app(environ, start_response): response_body = b"Hello, World!" status = "200 OK" start_response(status, headers=[]) return iter([response_body])

Как говорилось ранее, вызываемый точкой входа объект получает два параметра. Один из них — environ , где вся информация о запросах хранится в качестве метода request, url, параметров запроса, и тому подобное. Второй параметр — start_response , который высылает предполагаемый ответ. Теперь, попробуем запустить этот код с gunicorn . Для этого нам нужно его установить и запустить следующим образом:

pip install gunicorn gunicorn app:app

Первая app — это файл, который мы создали, вторая — это название функции, которую мы только что написали. Если все прошло удачно, вы увидите выдачу наподобие следующей:

[2019-03-20 17:58:56 +0500] [30962] [INFO] Starting gunicorn 19.9.0 [2019-03-20 17:58:56 +0500] [30962] [INFO] Listening at: http://127.0.0.1:8000 (30962) [2019-03-20 17:58:56 +0500] [30962] [INFO] Using worker: sync [2019-03-20 17:58:56 +0500] [30966] [INFO] Booting worker with pid: 30966

Если вы видите такую выдачу, откройте свой браузер и перейдите на http://localhost:8000 . Вы должны увидеть нашего старого доброго друга, сообщение Hello, World! Далее мы будем работать исходя из этого.

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

Создадим файл api.py :

touch api.py

Внутри этого файла создадим следующий класс API . Вкратце объясню, что он делает.

# api.py class API: def __call__(self, environ, start_response): response_body = b"Hello, World!" status = "200 OK" start_response(status, headers=[]) return iter([response_body])

Теперь, удалите все внутри app.py и впишите следующее:

# app.py from api import API app = API()

Перезапустите gunicorn и проверьте результат в браузере. Он должен быть таким же, как и раньше, так как мы просто конвертировали нашу функцию под названием арр в класс под названием API и переопределили его метод __call__ , который вызывается при вызове экземпляров этого класса:

app = API() app() # здесь вызывается __call__

Теперь, когда мы создали наш класс, я хочу сделать код более элегантным, так как наши байты ( b»Hello World» ) и start_response могут запутать нас.

К счастью, есть замечательный пакет под названием WebOb, который предоставляет объекты для HTTP запросов и ответов, заворачивая среду запросов WSGI и статус, заголовки и тело ответов. Используя данный пакет, мы можем передать environ и start_response классам, которые предоставляются этим пакетом, без необходимости разбираться с этим самостоятельно.

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

Здесь мы приступим к рефакторингу данного кода. Для начала, установим WebOb:

pip install webob

Импортируйте классы Request и Response в начало файла api.py:

# api.py from webob import Request, Response . 

Теперь мы можем использовать их внутри метода __call__ :

# api.py from webob import Request, Response class API: def __call__(self, environ, start_response): request = Request(environ) response = Response() response.text = "Hello, World!" return response(environ, start_response)

Выглядит намного лучше! Перезапустите gunicorn и увидите тот же результат, что и раньше. Лучшая часть в том, что мне не нужно объяснять, что здесь происходит! Всё говорит само за себя. Мы создаем запрос, и возвращаем этот ответ.

Отлично! Хочу обратить внимание на то, что request здесь еще не используется, так как мы ничего для этого не сделали. Итак, давайте используем эту возможность и также используем объект request. Кстати, давайте проведем рефакторинг создания ответа, превратив его в собственный метод. Почем так лучше? Мы узнаем позже:

# api.py from webob import Request, Response class API: def __call__(self, environ, start_response): request = Request(environ) response = self.handle_request(request) return response(environ, start_response) def handle_request(self, request): user_agent = request.environ.get("HTTP_USER_AGENT", "No User Agent Found") response = Response() response.text = f"Здравствуй, мой друг с браузером: " return response

Перезапустите gunicorn и увидите новое сообщение в браузере, а мы будем двигаться дальше.

С этого момента, все запросы обработаны общим путем. Вне зависимости от того, какой запрос мы получили, мы просто возвращаем один и тот же ответ, который создан в методе handle_request. В конечном счете, нам нужно быть динамичными. Таким образом, нам нужно обработать запрос от /home/ , иначе чем обработка запроса из /about/ .

Для этого, создадим два метода внутри app.py . Они будут обрабатывать эти два запроса:

# app.py from api.py import API app = API() def home(request, response): response.text = "Привет! Это ГЛАВНАЯ страница" def about(request, response): response.text = "Привет! Это страница О НАС!"

Теперь нам нужно как-то связать эти два метода с упомянутыми ранее путями: /home/ и /about/ . Мне нравится как Flask справляется с данной задачей и я решил вдохновиться от него:

# app.py from api.py import API app = API() @app.route("/home") def home(request, response): response.text = "Привет! Это ГЛАВНАЯ страница" @app.route("/about") def about(request, response): response.text = "Привет! Это страница О НАС!"

Что скажете? Выглядит неплохо. Давайте это реализуем.

Как вы видите, метод route является декоратором, принимает путь и оборачивает методы. Это будет несложно реализовать:

# api.py class API: def __init__(self): self.routes = <> def route(self, path): def wrapper(handler): self.routes[path] = handler return handler return wrapper . 

Что было сделано? В методе __init__ мы просто определили словарь под названием self.routes, в котором мы будем хранить пути в качестве ключей, а обработчики — в качестве значений. Это может выглядеть следующим образом:

print(self.routes) < "/home": , "/about": >

В методе route, мы возьмем путь в качестве аргумента и в методе wrapper просто внесем этот путь в словарь self.routes в качестве ключа, а обработчик — в качестве значения.

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

# api.py from webob import Request, Response class API: . def handle_request(self, request): response = Response() for path, handler in self.routes.items(): if path == request.path: handler(request, response) return response . 

Не так уж и сложно, не так ли? Мы просто провели итерацию над self.routes, сравнили пути с путем запроса, и при совпадении, вызвали обработчик, связанный с этим путем.

Перезапустите gunicorn и проверьте эти пути в браузере. Сначала, перейдите по http://localhost:8000/home/ , и затем по http://localhost:8000/about/ . Вы должны увидеть соответствующие сообщения. Удобно, не так ли?

Следующим нашим действием будет найти ответ на вопрос “Что случится, если путь не будет найден?”. Давайте создадим метод, который возвращает простой HTTP ответ “не найдено” со статусом кода 404:

# api.py from webob import Request, Response class API: . def default_response(self, response): response.status_code = 404 response.text = "Not found." . 

Теперь, используем это в нашем методе handle_request :

# api.py from webob import Request, Response class API: . def handle_request(self, request): response = Response() for path, handler in self.routes.items(): if path == request.path: handler(request, response) return response self.default_response(response) return response . 

Перезапустите gunicorn и попробуйте посетить несуществующие пути. Вы должны увидеть страницу “Not found”. Теперь, выполним рефакторинг таким образом, чтобы найти обработчик для его собственного метода ради читаемости:

# api.py from webob import Request, Response class API: . def find_handler(self, request_path): for path, handler in self.routes.items(): if path == request_path: return handler . 

Как и в предыдущем случае, он просто итерирует над self.route , сравнивает пути с путем запроса и возвращает обработчик, если пути совпадают. Он возвращает None, если обработчик не был найден. Теперь, мы можем использовать его в нашем методе handle_request:

# api.py from webob import Request, Response class API: . def handle_request(self, request): response = Response() handler = self.find_handler(request_path=request.path) if handler is not None: handler(request, response) else: self.default_response(response) return response . 

На мой взгляд, все выглядит намного лучше и понятнее. Перезапустите gunicorn, чтобы убедиться в там, что все работает так же, как и раньше.

Теперь у нас есть пути и обработчики. Это замечательно, но наши пути достаточно простые. Они не поддерживают сложные параметры ключевых слов в пути URL. Что если нам нужен путь наподобие @app.route(«/hello/») и иметь возможность использовать значение person_name внутри наших обработчиков, вот так:

def say_hello(request, response, person_name): resp.text = f"Hello, "

Для этого, если кто-то перейдет по /hello/Matthew/ , нам нужно иметь возможность сопоставить этот путь с зарегистрированным /hello// и найти надлежащий обработчик. К счастью, есть готовый пакет под названием parse который делает именно то, что нам нужно. Давайте установим его:

pip install parse

>>> from parse import parse >>> result = parse("Hello, ", "Hello, Matthew") >>> print(result.named)

Как вы видите, он проанализировал строку Hello, Matthew и определил, что Matthew соответствует предоставленному .

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

# api.py from webob import Request, Response from parse import parse class API: . def find_handler(self, request_path): for path, handler in self.routes.items(): parse_result = parse(path, request_path) if parse_result is not None: return handler, parse_result.named return None, None . 

Мы все еще итерируем над self.routes, и теперь вместо сравнения пути с путем запроса, мы попытаемся проанализировать его, и если будет результат, мы вернем обработчик и параметры ключевых слов как словарь. Теперь, мы можем использовать наш handle_request для отсылки этих параметров в обработчик вот так:

# api.py from webob import Request, Response from parse import parse class API: . def handle_request(self, request): response = Response() handler, kwargs = self.find_handler(request_path=request.path) if handler is not None: handler(request, response, **kwargs) else: self.default_response(response) return response . 

Единственное, что здесь меняется — это то, что мы получаем обработчик и аргументы ключевых слов kwargs от self.find_handler, и передаем kwargs обработчику вот так: **kwargs.

Давайте напишем обработчик с таким типом пути и испробуем его:

# app.py . @app.route("/hello/") def greeting(request, response, name): resp.text = f"Hello, " . 

Перезапустите gunicorn и перейдите по http://localhost:8000/hello/Matthew/ . Вы увидите замечательное сообщение Hello, Matthew . Шикарно, да? Добавьте немного своих подобных обработчиков.

Вы также можете указать тип заданных параметров. Например, вы можете выполнить @app.route(«/tell/») , чтобы получить age вашего параметра внутри обработчика в виде цифры.

Вывод

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

Еще записи по теме

• Python — основные концепции
• Joxi — как делать скриншоты?
• Разработка приложений под Windows 8
• Работаем с Яндекс.Метрикой на Python
• Чтение изображения из SQLite
• Игровой автомат Voodoo — на сайте Вулкан 24 казино играйте в самые щедрые слоты
• Легкий python веб-фреймворк – Bottle