Рубрики
Без рубрики

Мощное приложение To-Do Do Python Web Framework Flask Python менее чем за 30 минут

Если вы разрабатываете веб-приложение в Python, шансы вы используете каркас. Рамки «… … Tagged Python, обучение, программирование, учебник.

Если вы разрабатываете веб-приложение в Python, шансы вы используете каркас. А Рамки «Является ли библиотека кодовой кодовой информации, которая облегчает жизнью для создания надежных, масштабируемых и ремонторуемых веб-приложений», предоставляя многоразовый код или расширения для общих операций. Есть ряд рамки для Python, в том числе Колбу , Торнадо , Пирамида и Джанго Отказ Новые разработчики Python часто спрашивают: какие рамки я должен использовать?

  • Новые посетители сайта должны быть в состоянии зарегистрировать новые учетные записи.

  • Зарегистрированные пользователи могут войти в систему, выйти из системы, см. Информацию для своих профилей и редактировать их информацию.

  • Зарегистрированные пользователи могут создавать новые задания задач, увидеть их существующие задачи и редактировать существующие задачи.

Все это раунд к компактному набору конечных точек API, которые каждая бэкэнда должна реализовать, а также допустимые методы HTTP:

  • ПОЛУЧАТЬ/

  • Post/Счета

  • Post/учетные записи/логин

  • Получить/учетные записи/Выход

  • Получить, поставить, удалить/аккаунты/

  • Получить, сообщение/аккаунты//Задачи

  • Получить, поставить, удалить/учетные записи//Задачи/

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

Запуск и конфигурация колба

Как и большинство широко используемых библиотек Python, пакет колба устанавливается из Указатель пакета Python (PPI). Сначала создайте каталог для работы (что-то вроде Flake_Todo – это точное имя каталога), затем установите пакет Flask. Вы также захотите установить Flask-SQLalchemy, чтобы ваше приложение Flask имеет простой способ поговорить с базой данных SQL.

Мне нравится делать этот тип работы в виртуальной среде Python 3. Чтобы добраться туда, введите следующее в командной строке:

$ mkdir flask_todo

$ cd flask_todo

$ pipenv install --python 3.6

$ pipenv shell

(flask-someHash) $ pipenv install flask flask-sqlalchemy

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

Хороший способ перемещения – это повернуть кодовую базу в установочное распределение Python. В корне проекта создайте Setup.py и каталог, называемый ToDo для удержания исходного кода.

Setup.py должен выглядеть что-то подобное:

from setuptools import setup, find_packages

requires = [

    'flask',

    'flask-sqlalchemy',

    'psycopg2',

]

setup(

    name='flask_todo',

    version='0.0',

    description='A To-Do List built with Flask',

    author='',

    author_email='',

    keywords='web flask',

    packages=find_packages(),

    include_package_data=True,

    install_requires=requires

)

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

В каталоге TODO, содержащем исходный код, создайте файл app.py и пустой init .py файл. init .py Файл позволяет импортировать из TODO, как если бы это был установленный пакет. Файл app.py будет корнем приложения. Это то, куда уйдет вся благость приложения колбы, и вы создадите переменную среды, которая указывает на этот файл. Если вы используете Pipenv (например, я), вы можете найти вашу виртуальную среду с помощью Pipenv –venv и настроить эту переменную среды в сценарии активации окружающей среды.

# in your activate script, probably at the bottom (but anywhere will do)

export FLASK_APP=$VIRTUAL_ENV/../todo/app.py

export DEBUG='True'

Когда вы установили Flask, вы также установили сценарий командной строки Flask. Прогорание набора набора Flask пригласила пакет Flask Virtual Envirment для запуска HTTP-сервера с использованием объекта приложения в любом скрипте Clake_app Environment Revanable, чтобы. Назжек сценария также включает в себя переменную среды с именем отладки, которая будет использоваться немного позже.

Давайте поговорим об этом объекте приложения.

В ToDo/app.py вы создадите объект приложения, который является экземпляром объекта Flask. Это будет действовать как объект центрального конфигурации для всего приложения. Он используется для настройки кусочков приложения, необходимого для расширенной функциональности, например, подключение к базе данных и помощь в аутентификации.

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

from flask import Flask

app = Flask(__name__)

@app.route('/')

def hello_world():

    """Print 'Hello, world!' as the response body."""

    return 'Hello, world!'

Это самое простое полное приложение для колба. Приложение является экземпляром колбы, принимая в Имя файла сценария. Это позволяет Python знать, как импортировать из файлов относительно этого. App.reoute decorator украшает первый Вид функция; Он может указать один из маршрутов, используемых для доступа к приложению. (Мы посмотрим на это позже.)

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

В приведенном выше примере, когда приложение работает и доступ к http://domainname/ Пользователь получит «Привет, мир!» как ответ.

Если вы начинаете и имеете некоторые проблемы после этого учебника, вы можете проверить:

Python Flask для начинающих

Обучение программирование Python с нуля

Подключение базы данных в колбе

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

Колбу очень много «сделать сами сами» веб-каркас. Это означает, что нет встроенного взаимодействия базы данных, но пакет Flask-SQLAlchemy подключите базу данных SQL к приложению Flask. Пакет FLASK-SQLALCHEMEMEMENT требуется всего одна вещь для подключения к базе данных SQL: URL базы данных.

Обратите внимание, что широкий спектр систем управления базами данных SQL можно использовать с Flask-SQLAlchemy, до тех пор, пока СУБД имеет посредник, который следует за Стандарт DBAPI-2 Отказ В этом примере я буду использовать PostgreSQL (в основном потому, что я много использовал), поэтому посредник, чтобы поговорить с базой данных Postgres, является пакет PSYCOPG2. Убедитесь, что PSYCOPG2 установлен в вашей среде и включает его в список обязательных пакетов в Setup.py. Вам не нужно ничего делать с ним; Flask-Sqlalchemy узнает Postgres из URL базы данных.

Флэк нуждается в URL базы данных, чтобы быть частью своей центральной конфигурации через атрибут SQLALCHEMY_DATABASE_URI. Быстро и грязное решение – это жесткое управление URL базы данных в приложение.

# top of app.py

from flask import Flask

from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://localhost:5432/flask_todo'

db = SQLAlchemy(app)

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

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

В том же месте вы объявили FLASK_APP, объявляете Database_URL, указывая на местоположение вашей базы данных Postgres. Разработка имеет тенденцию работать на месте, поэтому просто укажите вашу локальную базу данных.

# also in your activate script

export DATABASE_URL='postgres://localhost:5432/flask_todo'

Теперь в App.py включите URL базы данных в вашей конфигурации приложения.

app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL', '')

db = SQLAlchemy(app)

И так же, как ваше приложение имеет соединение с базой данных!

Определение объектов в колбе

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

В разработке приложений «модель» относится к представлению данных некоторых действительных или концептуальных объектов. Например, если вы создаете заявку на автосалон, вы можете определить модель автомобиля, которая заключается в том, что инкапсулирует все атрибуты и поведение автомобиля.

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

Флэк-SQLALCHEMY PAKE PAPE PAKE SQLalchemy Чтобы настроить и сообщить структуру базы данных. Вы определите модель, которая будет жить в базе данных, наследующуюся из БД. Модель объекта и определить атрибуты этих моделей как БД. Инстанции колонны. Для каждого столбца вы должны указать тип данных, поэтому вы передадите этот тип данных в вызов DB. Столбец как первый аргумент.

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

  • Если: значение, которое является уникальным идентификатором для тяги из базы данных

  • Имя: имя или название задачи, которую пользователь увидит, когда задача перечислена

  • Заметка: любые дополнительные комментарии, которые человек может захотеть уйти с их задачей

  • Creation_date: дата и время Задача была создана

  • срок оплаты: Дата и время, когда задача должна быть завершена (если вообще)

  • Завершено: способ указать, есть ли или Не задача была завершена

Учитывая этот список атрибутов для объектов задач, объект задач приложения может быть определен так:

from .app import db

from datetime import datetime

class Task(db.Model):

    """Tasks for the To Do list."""

    id = db.Column(db.Integer, primary_key=True)

    name = db.Column(db.Unicode, nullable=False)

    note = db.Column(db.Unicode)

    creation_date = db.Column(db.DateTime, nullable=False)

    due_date = db.Column(db.DateTime)

    completed = db.Column(db.Boolean, default=False)

    def __init__(self, *args, **kwargs):

        """On construction, set date of creation."""

        super().__init__(*args, **kwargs)

        self.creation_date = datetime.now()

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

Модель отношения

В данном веб-приложении вы можете иметь возможность выражать отношения между объектами. В примере «Список TO-DO» пользователи владеют несколькими задачами, и каждая задача принадлежит только одному пользователю. Это пример отношения «многие до одной», также известных как внешние отношения ключей, где задачи – это «многие», и пользователь, владеющий этими задачами, является «один».

В колбе, отношения многих к одному могут быть указаны с использованием функции DB.Relationshiphip. Во-первых, постройте объект пользователя.

class User(db.Model):

    """The User object that owns tasks."""

    id = db.Column(db.Integer, primary_key=True)

    username = db.Column(db.Unicode, nullable=False)

    email = db.Column(db.Unicode, nullable=False)

    password = db.Column(db.Unicode, nullable=False)

    date_joined = db.Column(db.DateTime, nullable=False)

    token = db.Column(db.Unicode, nullable=False)

    def __init__(self, *args, **kwargs):

        """On construction, set date of creation."""

        super().__init__(*args, **kwargs)

        self.date_joined = datetime.now()

        self.token = secrets.token_urlsafe(64)

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

Теперь, когда пользовательская модель создана, вы можете настроить отношения иностранных ключей. Для установленных полей «Многие», «Многие» для пользователя, которым принадлежит эта задача, а также объект пользователя с этим идентификатором. Также убедитесь, что включите ключевое слово аргумент (Back_Populates), которые обновляют модель пользователя, когда задача получает пользователя в качестве владельца.

Для «One» установите поле для задач, которыми владеет конкретный пользователь. Подобно поддержанию двухсторонних отношений на объекте задачи, установите аргумент ключевых слов в поле «Отношения пользователя» для обновления задачи, когда она назначена пользователю.

# on the Task object

user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

user = db.relationship("user", back_populates="tasks")

# on the User object

tasks = db.relationship("Task", back_populates="user")

Инициализация базы данных

Теперь, когда устанавливаются модели и модели моделей, начните настройку вашей базы данных. Flask не приходит с собственной утилитой управления базой данных, поэтому вам придется писать собственные (в некоторой степени). Вам не нужно причудеть с этим; Вам просто нужно что-то, чтобы узнать, какие таблицы должны быть созданы, и какой-то код для их создания (или бросить их, если нужно возникнуть). Если вам нужно что-то более сложное, как обращение с обновлениями в таблицах баз данных (I.E., миграции базы данных), вы захотите посмотреть инструмент, похожий на Флэк-мигрировать или Флэк-алембический Отказ

Создайте сценарий, называемый INATINALIZEDB.PY рядом с Setup.py для управления базой данных. (Конечно, это не нужно назвать это, но почему бы не дать имена, которые подходят для функции файла?) В пределах инициализацииB.py импортируйте объект DB из App.py и используйте его для создания или падения таблиц. INATINALIZEDB.PY должен в конечном итоге выглядеть что-то подобное:

from todo.app import db

import os

if bool(os.environ.get('DEBUG', '')):

    db.drop_all()

db.create_all()

Если переменная среды отладки установлена, отбрасывает таблицы и восстановление. В противном случае просто создайте таблицы один раз, и вы хотите пойти.

Просмотров и URL Config

Последние биты, необходимые для подключения всего приложения, являются представлениями и маршрутами. В веб-разработке «View» (в концепции) является функциональностью, которая работает при определенной точке доступа («маршрут») в вашем приложении. Эти точки доступа отображаются как URL-адреса: пути к функциональности в приложении, которое возвращает некоторые данные или обрабатывают некоторые данные, которые были предоставлены. Представления будут логическими структурами, которые обрабатывают определенные HTTP-запросы от данного клиента и возвращают некоторые HTTP-ответ на этот клиент.

В колбе представления появляются как функции; Например, см. Вид Hello_World выше. Для простоты здесь снова:

@app.route('/')

def hello_world():

    """Print 'Hello, world!' as the response body."""

    return 'Hello, world!'

Когда маршрут http://domainname/ Доступ к работе, клиент получает ответ: «Привет, мир!»

С колкой функция помечена как представление, когда он украшен App.route. В свою очередь, app.route добавляет к центральной конфигурации приложения карты из указанного маршрута к функции, которая выполняется при доступе этого маршрута. Вы можете использовать это, чтобы начать построить остальную часть API.

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

from flask import jsonify

@app.route('/api/v1', methods=["GET"])

def info_view():

    """List of routes for this API."""

    output = {

        'info': 'GET /api/v1',

        'register': 'POST /api/v1/accounts',

        'single profile detail': 'GET /api/v1/accounts/',

        'edit profile': 'PUT /api/v1/accounts/',

        'delete profile': 'DELETE /api/v1/accounts/',

        'login': 'POST /api/v1/accounts/login',

        'logout': 'GET /api/v1/accounts/logout',

        "user's tasks": 'GET /api/v1/accounts//tasks',

        "create task": 'POST /api/v1/accounts//tasks',

        "task detail": 'GET /api/v1/accounts//tasks/',

        "task update": 'PUT /api/v1/accounts//tasks/',

        "delete task": 'DELETE /api/v1/accounts//tasks/'

    }

    return jsonify(output)

Так как вы хотите, чтобы ваш взгляд обрабатывал один специфический Тип HTTP-запроса, используйте app.route, чтобы добавить это ограничение. Аргумент ключевого слова методов примет список строк в качестве значения, причем каждая строка является типом возможного HTTP-метода. На практике вы можете использовать APP.ROUTE, чтобы ограничить один или несколько типов HTTP-запроса или принять любую, оставив аргумент ключевого слова методов в одиночку.

Все, что вы намереваетесь вернуться с вашей точки зрения Должен Быть строкой или объектом, которую колба превращается в строку при построении правильно отформатированного отклика HTTP. Исключения из этого правила, когда вы пытаетесь обрабатывать перенаправления и исключения, выбрасываемые вашим приложением. Что это значит для вас, разработчик, заключается в том, что вам нужно иметь возможность инкапсулировать любой ответ, который вы пытаетесь отправить обратно клиенту, в то, что можно интерпретировать как строку.

Хорошая структура, которая содержит сложность, но все еще может быть строгла это словарь Python. Следовательно, я рекомендую, когда вы хотите отправить некоторые данные клиенту, вы выбираете Dicton Python с любыми парами для ключевых пар, которые вам нужно передать информацию. Чтобы превратить этот словарь в должным образом отформатированный ответ JSON, заголовки и все, пропустите его как аргумент на функцию jsonify flock’s jsonify (из флэки импортируют jonsify).

Вышеуказанная функция представления требует того, что эффективно является листированием каждого маршрута, которую этот API намерен обрабатывать и отправлять его клиенту всякий раз, когда http://domainname/API/V1 Доступ к маршруту обращается. Обратите внимание, что, самостоятельно, колба поддерживает маршрутизацию до точно соответствующий URI, поэтому доступ к тому же маршруту с трейлинговым/создаст ошибку 404. Если вы хотели обрабатывать как с той же функцией зрения, вам понадобится декораторы стека, такие как:

@app.route('/api/v1', methods=["GET"])

@app.route('/api/v1/', methods=["GET"])

def info_view():

    # blah blah blah more code

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

Флэкские запросы и дБ

На его основе задание веб-фреймворк состоит в том, чтобы обрабатывать входящие HTTP-запросы и возвращать отклики HTTP. Ранее письменное представление на самом деле не имеет большого значения с HTTP-запросами, помимо доступов URI. Это не обрабатывает никаких данных. Давайте посмотрим на то, как Flach ведет себя, когда требуется обработка данных.

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

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

@app.route('/a/sample//route)

def some_view(variable):

    # some code blah blah blah

Чтобы обмениваться с базой данных в представлении, вы должны использовать объект DB, который был заполнен в верхней части сценария. Его атрибут сеанса – это ваше соединение с базой данных, когда вы хотите внести изменения. Если вы просто хотите запросить объекты, объекты, построенные из БД. Модель имеет свой собственный слой взаимодействия базы данных через атрибут запроса.

Наконец, любой ответ, который вы хотите, от представления, который более сложный, чем строка, должна быть построена сознательно. Ранее вы создали ответ, используя словарь «Jsonified», но были сделаны определенные допущения (например, код состояния, сообщение о состоянии, сообщение «ОК», «Content-Type из текста/простой»). Любой специальный соус, который вы хотите в вашем HTTP-ответе, должны быть добавлены сознательно.

Знание этих фактов о работе с просмотром флэкса позволяет создавать представление, задание которого состоит в том, чтобы создать новые объекты задач. Давайте посмотрим на код (ниже) и обратитесь к его детали.

from datetime import datetime

from flask import request, Response

from flask_sqlalchemy import SQLAlchemy

import json

from .models import Task, User

app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL', '')

db = SQLAlchemy(app)

INCOMING_DATE_FMT = '%d/%m/%Y %H:%M:%S'

@app.route('/api/v1/accounts//tasks', methods=['POST'])

def create_task(username):

    """Create a task for one user."""

    user = User.query.filter_by(username=username).first()

    if user:

        task = Task(

            name=request.form['name'],

            note=request.form['note'],

            creation_date=datetime.now(),

            due_date=datetime.strptime(due_date, INCOMING_DATE_FMT) if due_date else None,

            completed=bool(request.form['completed']),

            user_id=user.id,

        )

        db.session.add(task)

        db.session.commit()

        output = {'msg': 'posted'}

        response = Response(

            mimetype="application/json",

            response=json.dumps(output),

            status=201

        )

        return response

Давайте начнем с @ app.route decorator. Маршрут «/API/V1/учетные записи//Задачи», где находится переменная маршрута. Положите угловые кронштейны вокруг любой части маршрута, который вы хотите быть переменным, затем включите эту часть маршрута на следующей строке в списке параметров с тем же именем . Единственные параметры, которые должны находиться в списке параметров, должны быть переменными на вашем маршруте.

Далее наступает запрос:

user = User.query.filter_by(username=username).first()

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

task = Task(

    name=request.form['name'],

    note=request.form['note'],

    creation_date=datetime.now(),

    due_date=datetime.strptime(due_date, INCOMING_DATE_FMT) if due_date else None,

    completed=bool(request.form['completed']),

    user_id=user.id,

)

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

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

db.session.add(task)

db.session.commit()

Создание нового экземпляра задачи великолепна, но его конструкция не имеет присущей подключения к таблицам в базе данных. Чтобы вставить новую строку в соответствующую таблицу SQL, вы должны использовать сеанс, прикрепленный к объекту DB. DB.SOSSION.ADD (TACESS) этапы нового экземпляра задачи, который будет добавлен в таблицу, но еще не добавляет его. Пока это сделано только один раз здесь, вы можете добавить столько, сколько захотите, прежде чем совершать. Db.session.commit () принимает все устойчивые изменения или «комбинирует» и применяет их к соответствующим таблицам в базе данных.

output = {'msg': 'posted'}

response = Response(

    mimetype="application/json",

    response=json.dumps(output),

    status=201

)

Ответ представляет собой фактический экземпляр объекта ответа с его MIMETYPE, Body и статусом, установленным сознательно. Целью этого мнения является предупреждение пользователя, которое они создали что-то новое. Увидев, как этот взгляд должен быть частью Backend API, который отправляет и получает JSON, орган ответа должен быть JSON Serializable. Словарь с простым строковым сообщением должно быть достаточно. Убедитесь, что он готов к передаче, позвонив JSON.dumps в вашем словаре, что превратит ваш объект Python в действительный JSON. Это используется вместо Jsonify, так как jsonify конструирует фактический объект ответа, используя его вход в качестве тела ответа. Напротив, JSON.dumps просто принимает данный объект Python и преобразует его в действительный json строка, если это возможно.

По умолчанию код состояния любого ответа, отправленного с колбой, будет 200. Это будет работать для большинства обстоятельств, где вы не пытаетесь отправить обратно конкретное сообщение по перенаправлению или на уровне ошибок. Поскольку этот случай явно позволяет интерфейсу знать, когда был создан новый элемент, установите код состояния 201, который соответствует созданию новой вещи.

Вот и все! Это основной вид для создания нового объекта задач в колбе, учитывая текущую настройку приложения вашего списка TO-DO. Подобные взгляды могут быть построены для листинга, редактирования и удаления задач, но этот пример предлагает представление о том, как это можно сделать.

Источник: https://opensource.com/article/18/4/flask.

Подробнее Сообщения DEV:

  • Топ 10 ответов на вопросы интервью Sysadmin, которые могут спасти вашу жизнь

  • До скорости с JavaScript через 59 минут

  • Узнайте лучшие структуры данных и алгоритмы каждый студенческий компьютер должен знать

Оригинал: “https://dev.to/courseprobe/powerful-to-do-app-in-flask-python-web-framework-in-less-than-30-mins-2cm9”