Одностраничные приложения с Vue.js и Flask: RESTful API с Flask

RESTful API с Flask Добро пожаловать в четвертый пост об использовании Vue.js и Flask для полнофункциональной веб-разработки. В центре внимания этого поста будет создание серверного REST API с использованием веб-фреймворка Flask на основе Python. Код этого сообщения находится в репозитории моей учетной записи GitHub [https://github.com/amcquistan/flask-vuejs-survey/tree/FourthPost] в ветке FourthPost. Содержание серии 1. Поиск и знакомство с VueJS [/ single-page-apps-with-vue-js-and-flask-setting-up-vue-js /] 2. Навигация

RESTful API с Flask

Добро пожаловать в четвертый пост об использовании Vue.js и Flask для полнофункциональной веб-разработки. В центре внимания этого поста будет создание серверного REST API с использованием веб-фреймворка Flask на основе Python.

Код этого сообщения находится в репозитории моей учетной записи GitHub в ветке FourthPost.

Содержание серии

  1. Seup и знакомство с VueJS
  2. Навигация по Vue Router
  3. Управление состоянием с Vuex
  4. RESTful API с Flask (вы здесь)
  5. Интеграция AJAX с REST API
  6. JWT аутентификация
  7. Развертывание на виртуальном частном сервере

Краткое объяснение Flask

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

Сборка файлов бэкэнд-проекта

Я начинаю с каталога / backend с создания виртуальной среды Python3 и установки Flask и нескольких других необходимых библиотек.

 $ python -m venv venv 
 $ source venv/bin/activate 
 (venv) $ pip install Flask Flask-SQLAlchemy Flask-Migrate Flask-Script requests

Одна вещь, которая делает Flask (и по большей части всю экосистему Python) такой замечательной, - это большое количество хорошо спроектированных пакетов, доступных в PyPI . Ниже приводится краткое объяснение установленных мною библиотек и их предполагаемого использования.

  • Flask: веб-микро-фреймворк
  • Flask-SQLAlchemy: ORM на основе SQLAlchemy с добавленным к нему удивительным соусом для Flask.
  • Flask-Migrate: библиотека миграции базы данных
  • Flask-Script: чрезвычайно полезный пакет для взаимодействия с приложением Flask из командной строки.
  • запросы: удобный пакет для выполнения сетевых запросов, который я буду использовать для тестирования REST API

В каталоге / backend я создаю несколько новых файлов с именами manage.py и appserver.py. Кроме того, я создам новый каталог внутри / backend, который станет моим приложением Flask "Surveyapi". В каталоге Surveyapi я создаю файлы __init__.py, models.py, application.py и api.py. Это приводит к тому, что структура каталогов начинается с / backend, например (без каталога venv).

 ├── manage.py 
 ├── appserver.py 
 └── surveyapi 
 ├── __init__.py 
 ├── api.py 
 ├── application.py 
 ├── config.py 
 └── models.py

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

  • manage.py: доступ к экземпляру приложения Flask для различных команд Flask-Script
  • appserver.py: сценарий запуска для запуска приложения Surveyapi
  • Surveyapi /: внутреннее приложение Flask
  • __init__.py: превращает каталог Surveyapi в действительный пакет Python.
  • api.py: для определения конечных точек маршрута REST API, способных принимать и создавать запросы и ответы JSON.
  • application.py: для создания экземпляра приложения Flask
  • config.py: содержит параметры конфигурации для приложения Flask.
  • models.py: для определения классов, которые будут служить объектами данных для приложения опроса, таких как Survey, Question и Choice.

Создание фабрики приложений

Я начну кодирование приложения Surveyapi с определения некоторых настроек внутри config.py следующим образом:

 """ 
 config.py 
 - settings for the flask application object 
 """ 
 
 class BaseConfig(object): 
 DEBUG = True 
 SQLALCHEMY_DATABASE_URI = 'sqlite:///survey.db' 
 SQLALCHEMY_TRACK_MODIFICATIONS = False 
 # used for encryption and session management 
 SECRET_KEY = 'mysecretkey'

Этот класс конфигурации определяет URI соединения базы данных приложения SQLALCHEMY_DATABASE_URI с однофайловой базой данных SQLite с именем survey.db. Он также предоставляет SECRET_KEY который используется для шифрования.

Внутри application.py я создам так называемую фабричную функцию приложения, которая делает именно то, что звучит: она создает экземпляр приложения Flask. Помимо создания экземпляра Flask, он также является источником BaseConfig и регистрирует схему маршрутов API, которую я создам дальше.

 """ 
 application.py 
 - creates a Flask app instance and registers the database object 
 """ 
 
 from flask import Flask 
 
 def create_app(app_name='SURVEY_API'): 
 app = Flask(app_name) 
 app.config.from_object('surveyapi.config.BaseConfig') 
 from surveyapi.api import api 
 app.register_blueprint(api, url_prefix="/api") 
 return app

Blueprint API

Затем я перейду к модулю api.py, где я могу определить объект Blueprint api содержащий маршруты RESTful. Для простоты я начну с определения простой функции просмотра, называемой say_hello() связанной с конечной точкой /api/hello/<string:name>/ . <string:name> представляет собой динамическую строковую переменную, которая передается в функцию просмотра say_hello(name) в качестве параметра функции, который я использую в возвращаемом ответном сообщении JSON.

 """ 
 api.py 
 - provides the API endpoints for consuming and producing 
 REST requests and responses 
 """ 
 
 from flask import Blueprint, jsonify, request 
 
 api = Blueprint('api', __name__) 
 
 @api.route('/hello/<string:name>/') 
 def say_hello(name): 
 response = { 'msg': "Hello {}".format(name) } 
 return jsonify(response)

Точка входа на сервер разработки и проверка установки

Чтобы проверить это, мне нужно добавить пару строк кода в appserver.py, чтобы создать экземпляр приложения. Это позволяет мне запустить сервер разработки Flask, вызвав метод run() в экземпляре app

 """ 
 appserver.py 
 - creates an application instance and runs the dev server 
 """ 
 
 if __name__ == '__main__': 
 from surveyapi.application import create_app 
 app = create_app() 
 app.run()

Для запуска сервера разработки Flask все, что мне нужно сделать, это запустить интерпретатор Python и передать ему сценарий appserver.py, как показано ниже.

 (venv) $ python appserver.py 
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit) 
 * Restarting with stat 
 * Debugger is active! 
 * Debugger PIN: 676-284-544

Теперь, чтобы протестировать новую конечную точку, в новом терминале с активированной виртуальной средой я запущу интерпретатор Python и сделаю запрос GET на http://localhost:5000/api/hello/adam/ с помощью пакета requests

 (venv) $ python 
 >>> import requests 
 >>> response = requests.get('http://localhost:5000/api/hello/adam/') 
 >>> print(response.json()) 
 {'msg': 'Hello adam'}

Определение уровня данных

Теперь, когда я убедился, что у меня есть работающее приложение Flask, я могу сосредоточиться на создании уровня данных с помощью ORM Flask-SQLAlchemy. Реализация уровня данных потребует написания некоторых классов данных внутри models.py, например:

  • Опрос: это объект верхнего уровня, который будет содержать один или несколько вопросов вместе с их вариантами ответов.
  • Вопрос: объекты, которые принадлежат объекту опроса и содержат варианты выбора
  • Выбор: объекты, которые принадлежат вопросу и представляют варианты ответа на вопрос опроса.

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

 """ 
 models.py 
 - Data classes for the surveyapi application 
 """ 
 
 from datetime import datetime 
 from flask_sqlalchemy import SQLAlchemy 
 
 db = SQLAlchemy() 
 
 class Survey(db.Model): 
 __tablename__ = 'surveys' 
 
 id = db.Column(db.Integer, primary_key=True) 
 name = db.Column(db.Text) 
 created_at = db.Column(db.DateTime, default=datetime.utcnow) 
 questions = db.relationship('Question', backref="survey", lazy=False) 
 
 def to_dict(self): 
 return dict(id=self.id, 
 name=self.name, 
 created_at=self.created_at.strftime('%Y-%m-%d %H:%M:%S'), 
 questions=[question.to_dict() for question in self.questions]) 
 
 class Question(db.Model): 
 __tablename__ = 'questions' 
 
 id = db.Column(db.Integer, primary_key=True) 
 text = db.Column(db.String(500), nullable=False) 
 created_at = db.Column(db.DateTime, default=datetime.utcnow) 
 survey_id = db.Column(db.Integer, db.ForeignKey('surveys.id')) 
 choices = db.relationship('Choice', backref='question', lazy=False) 
 
 def to_dict(self): 
 return dict(id=self.id, 
 text=self.text, 
 created_at=self.created_at.strftime('%Y-%m-%d %H:%M:%S'), 
 survey_id=self.survey_id, 
 choices=[choice.to_dict() for choice in self.choices]) 
 
 class Choice(db.Model): 
 __tablename__ = 'choices' 
 
 id = db.Column(db.Integer, primary_key=True) 
 text = db.Column(db.String(100), nullable=False) 
 selected = db.Column(db.Integer, default=0) 
 created_at = db.Column(db.DateTime, default=datetime.utcnow) 
 question_id = db.Column(db.Integer, db.ForeignKey('questions.id')) 
 
 def to_dict(self): 
 return dict(id=self.id, 
 text=self.text, 
 created_at=self.created_at.strftime('%Y-%m-%d %H:%M:%S'), 
 question_id=self.question_id)

Как упоминалось ранее, я использую расширение SQLAlchemy для Flask, называемое Flask-SQLAlchemy, для работы ORM для этого приложения. Мне нравится Flask-SQLAlchemy, потому что он имеет довольно Pythonic API и предоставляет разумные значения по умолчанию для определения классов данных и работы с ними.

Каждый класс наследуется от Model который предоставляет интуитивно понятные и читаемые служебные методы для взаимодействия с данными, хранящимися в базе данных. Более того, каждый класс состоит из серии полей класса, которые транслируются в поля таблицы базы данных, как указано в Column SQLAlchemy и связанном типе (например, Integer , String , DateTime , Text , ...).

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

Далее в списке необходимо зарегистрировать объект SQLAlchemy, db , с объектом приложения Flask в application.py.

 """ 
 application.py 
 - creates a Flask app instance and registers the database object 
 """ 
 
 from flask import Flask 
 
 def create_app(app_name='SURVEY_API'): 
 app = Flask(app_name) 
 app.config.from_object('surveyapi.config.BaseConfig') 
 
 from surveyapi.api import api 
 app.register_blueprint(api, url_prefix="/api") 
 
 from surveyapi.models import db 
 db.init_app(app) 
 
 return app

Последнее, что я хотел бы сделать, это объединить пакеты расширений Flask-Script и Flask-Migrate внутри модуля manage.py, чтобы обеспечить миграцию. Этот удобный модуль manage.py объединит классы данных, которые я только что определил, и свяжет их с контекстом приложения вместе с механизмами Flask-Migrate и Flask-Script.

 """ 
 manage.py 
 - provides a command line utility for interacting with the 
 application to perform interactive debugging and setup 
 """ 
 
 from flask_script import Manager 
 from flask_migrate import Migrate, MigrateCommand 
 
 from surveyapi.application import create_app 
 from surveyapi.models import db, Survey, Question, Choice 
 
 app = create_app() 
 
 migrate = Migrate(app, db) 
 manager = Manager(app) 
 
 # provide a migration utility command 
 manager.add_command('db', MigrateCommand) 
 
 # enable python shell with application context 
 @manager.shell 
 def shell_ctx(): 
 return dict(app=app, 
 db=db, 
 Survey=Survey, 
 Question=Question, 
 Choice=Choice) 
 
 if __name__ == '__main__': 
 manager.run()

В этом фрагменте кода выше я выполняю две задачи. Во-первых, я создаю экземпляр объекта приложения Flask, чтобы он предоставлял контекст для экземпляров Migrate(app, db) и Manage(app) . Затем я добавляю команду к manager которая позволяет мне создавать и запускать миграции из командной строки следующим образом:

 (venv) $ python manage.py db init
  • Инициализируйте каталог миграции рядом с приложением Surveyapi и файлом базы данных Survey.db.
1

<!-- -->

 (venv) $ python manage.py db migrate
  • Создайте исходный файл миграции, чтобы преобразовать классы из models.py в SQL, который будет генерировать соответствующие таблицы.
1

<!-- -->

 (venv) $ python manage.py db upgrade
  • Запустите миграцию, чтобы обновить базу данных с помощью таблиц, описанных на предыдущем шаге.

Последнее, что я делаю в модуле manage.py, - это создание другой настраиваемой команды, использующей @manager.shell для украшения функции shell_ctx() которая возвращает ключевые слова сопоставления dict для app и db вместе с Survey , Question и, Choice классов данных.

Теперь я воспользуюсь полезностью этой служебной команды оболочки, чтобы продемонстрировать, как работать с ORM Flask-SQLAlchemy в созданном ею интерпретаторе python.

 (venv) $ python manage.py shell 
 (venv) Adams-MacBook-Pro:backend adammcquistan$ python manage.py shell 
 >>> survey = Survey(name='Dogs') 
 >>> question = Question(text='What is your favorite dog?') 
 >>> question.choices = [Choice(text='Beagle'), Choice(text='Rottweiler'), Choice(text='Labrador')] 
 >>> question2 = Question(text='What is your second favorite dog?') 
 >>> question2.choices = [Choice(text='Beagle'), Choice(text='Rottweiler'), Choice(text='Labrador')] 
 >>> survey.questions = [question, question2] 
 >>> db.session.add(survey) 
 >>> db.session.commit() 
 >>> surveys = Survey.query.all() 
 >>> for s in surveys: 
 ... print('Survey(id={}, name={})'.format(s.id, s.name)) 
 ... for q in s.questions: 
 ... print(' Question(id={}, text={})'.format(q.id, q.text)) 
 ... for c in q.choices: 
 ... print(' Choice(id={}, text={})'.format(c.id, c.text)) 
 ... 
 Survey(id=1, name=Dogs) 
 Question(id=1, text=What is your favorite dog?) 
 Choice(id=1, text=Beagle) 
 Choice(id=3, text=Labrador) 
 Choice(id=2, text=Rottweiler) 
 Question(id=2, text=What is your second favorite dog?) 
 Choice(id=4, text=Beagle) 
 Choice(id=6, text=Labrador) 
 Choice(id=5, text=Rottweiler)

Красиво, правда?

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

Завершение RESTful API

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

  • Получите все опросы вместе с их вопросами и вариантами ответов
  • Получите один опрос вместе с его вопросами и вариантами ответов
  • Создайте новый опрос с указанными в нем вопросами и вариантами ответов.
  • Обновить варианты ответов в опросе после того, как опрос был проведен

Для начала я пойду вперед и импортировать все классы данных вместе с SQLAlchemy db , например , так у меня есть доступ к ним. Вверху api.py я добавляю следующий импорт:

 """ 
 api.py 
 - provides the API endpoints for consuming and producing 
 REST requests and responses 
 """ 
 
 from flask import Blueprint, jsonify, request 
 from .models import db, Survey, Question, Choice

Что касается фактических конечных точек ресурсов, я начну с написания кода для получения всех ресурсов опроса. Внутри api.py мне нужно заменить конечную точку /hello/<string:name>/ на функцию просмотра /surveys/ конечной точки и surveys()

 @api.route('/surveys/') 
 def surveys(): 
 surveys = Survey.query.all() 
 return jsonify({ 'surveys': [s.to_dict() for s in surveys] })

Если сервер разработки все еще работает, то, как только я сохраню файлы проекта, сервер должен автоматически перезагрузиться, обновив все изменения. Если нет, то запуск (venv) $ python appserver.py запустит сервер. Теперь в другом терминале с активированной виртуальной средой я могу использовать requests для тестирования этой новой конечной точки. Однако я хотел бы поделиться советом по отображению ответов JSON в более удобочитаемом виде с помощью другого замечательного пакета Python под названием pprint.

 (venv) $ pip install pprint 
 (venv) $ python 
 >>> import pprint, requests 
 >>> pp == pprint.PrettyPrinter() 
 >>> resp = requests.get('http://localhost:5000/api/surveys/') 
 >>> pp.pprint(resp.json()) 
 {'surveys': [{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 1, 
 'name': 'Dogs', 
 'questions': [{ 
 'choices': [{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 1, 
 'question_id': 1, 
 'text': 'Beagle' 
 },{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 3, 
 'question_id': 1, 
 'text': 'Labrador' 
 },{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 2, 
 'question_id': 1, 
 'text': 'Rottweiler'}], 
 'created_at': '2018-03-06 03:52:44', 
 'id': 1, 
 'survey_id': 1, 
 'text': 'What is your favorite dog?' 
 },{ 
 'choices': [{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 4, 
 'question_id': 2, 
 'text': 'Beagle' 
 },{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 6, 
 'question_id': 2, 
 'text': 'Labrador' 
 },{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 5, 
 'question_id': 2, 
 'text': 'Rottweiler'}], 
 'created_at': '2018-03-06 03:52:44', 
 'id': 2, 
 'survey_id': 1, 
 'text': 'What is your second favorite dog?'}]} 
 ]}

Далее я буду реализовывать функциональность для получения одного опроса по его id с конечной точкой URL /surveys/id/ и просмотра функции survey(id) . Сразу после surveys() я помещаю следующий код:

 @api.route('/surveys/<int:id>/') 
 def survey(id): 
 survey = Survey.query.get(id) 
 return jsonify({ 'survey': survey.to_dict() })

Я снова сохраню файлы и протестирую новую конечную точку API, чтобы убедиться, что она выдает правильный ответ.

 >>> resp = requests.get('http://localhost:5000/api/surveys/1/') 
 >>> pp.pprint(resp.json()) 
 {'survey': { 
 'created_at': '2018-03-06 03:52:44', 
 'id': 1, 
 'name': 'Dogs', 
 'questions': [{ 
 'choices': [{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 1, 
 'question_id': 1, 
 'text': 'Beagle' 
 },{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 3, 
 'question_id': 1, 
 'text': 'Labrador' 
 },{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 2, 
 'question_id': 1, 
 'text': 'Rottweiler'}], 
 'created_at': '2018-03-06 03:52:44', 
 'id': 1, 
 'survey_id': 1, 
 'text': 'What is your favorite dog?' 
 },{ 
 'choices': [{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 4, 
 'question_id': 2, 
 'text': 'Beagle' 
 },{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 6, 
 'question_id': 2, 
 'text': 'Labrador' 
 },{ 
 'created_at': '2018-03-06 03:52:44', 
 'id': 5, 
 'question_id': 2, 
 'text': 'Rottweiler'}], 
 'created_at': '2018-03-06 03:52:44', 
 'id': 2, 
 'survey_id': 1, 
 'text': 'What is your second favorite dog?'}]} 
 }

До сих пор я использовал только метод маршрута HTTP GET по умолчанию, подходящий для извлечения данных из RESTful API. Однако для последних двух функций мне нужно будет использовать методы HTTP POST и PUT для конечных точек /api/surveys/ и /api/surveys/id/ соответственно. Я буду использовать метод HTTP POST для создания новых опросов и метод HTTP PUT для обновления существующего опроса новым набором выбранных вариантов ответа.

Для /api/surveys/ route мне нужно будет добавить параметр метода в объявление маршрута, чтобы указать, что он принимает как GET, так и POST методы, methods=('GET','POST') . Кроме того, я изменю тело surveys() чтобы различать тип метода и добавить возможность сохранять новый опрос в базе данных.

 @api.route('/surveys/', methods=('GET', 'POST')) 
 def fetch_surveys(): 
 if request.method == 'GET': 
 surveys = Survey.query.all() 
 return jsonify({ 'surveys': [s.to_dict() for s in surveys] }) 
 elif request.method == 'POST': 
 data = request.get_json() 
 survey = Survey(name=data['name']) 
 questions = [] 
 for q in data['questions']: 
 question = Question(text=q['text']) 
 question.choices = [Choice(text=c['text']) 
 for c in q['choices']] 
 questions.append(question) 
 survey.questions = questions 
 db.session.add(survey) 
 db.session.commit() 
 return jsonify(survey.to_dict()), 201

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

 >>> import json 
 >>> survey = { 
 ... 'name': 'Cars', 
 ... 'questions': [{ 
 ... 'text': 'What is your favorite car?', 
 ... 'choices': [ 
 ... { 'text': 'Corvette' }, 
 ... { 'text': 'Mustang' }, 
 ... { 'text': 'Camaro' }] 
 ... }, { 
 ... 'text': 'What is your second favorite car?', 
 ... 'choices': [ 
 ... { 'text': 'Corvette' }, 
 ... { 'text': 'Mustang' }, 
 ... { 'text': 'Camaro' }] 
 ... }] 
 ... } 
 >>> headers = {'Content-type': 'application/json'} 
 >>> resp = requests.post('http://localhost:5000/api/surveys/', headers=headers, data=json.dumps(survey)) 
 >>> resp.status_code 
 201

Последняя часть, которую нужно реализовать, - это возможность обновить существующий опрос, добавив в него новые варианты ответов на опрос. Опять же, мне нужно будет добавить методы GET и PUT в определение /api/surveys/id/ маршрута, methods=('GET', 'PUT') . Затем я обновляю survey(id) чтобы обновить варианты связанных вопросов опроса, указанные как выбранные в теле JSON запроса PUT.

 @api.route('/surveys/<int:id>/', methods=('GET', 'PUT')) 
 def survey(id): 
 if request.method == 'GET': 
 survey = Survey.query.get(id) 
 return jsonify({ 'survey': survey.to_dict() }) 
 elif request.method == 'PUT': 
 data = request.get_json() 
 for q in data['questions']: 
 choice = Choice.query.get(q['choice']) 
 choice.selected = choice.selected + 1 
 db.session.commit() 
 survey = Survey.query.get(data['id']) 
 return jsonify(survey.to_dict()), 201

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

 >>> survey_choices = { 
 ... 'id': 1, 
 ... 'name': 'Dogs', 
 ... 'questions': [ 
 ... { 'id': 1, 'choice': 1 }, 
 ... { 'id': 2, 'choice': 5 }] 
 ... } 
 >>> headers = {'Content-type': 'application/json'} 
 >>> resp = requests.put('http://localhost:5000/api/surveys/1/', data=json.dumps(survey_choices), headers=headers) 
 >>> resp.status_code() 
 201

Ресурсы

Хотите узнать больше о Python и создании серверных API? Попробуйте пройти курс, например REST API с Flask и Python,{.udemy-link} чтобы глубже погрузиться в внутреннюю веб-разработку с помощью Python.

Заключение

В этой статье я рассказал, как реализовать простой, довольно простой, RESTful API с использованием Flask в соответствии со следующей таблицей:

Маршрут Методика Функциональность

/ API / обзоры / ПОЛУЧАТЬ Получить все опросы / API / обзоры / ПОЧТА Создать новый опрос / API / обзоры / идентификатор / ПОЛУЧАТЬ Получить опрос по идентификатору / API / обзоры / идентификатор / СТАВИТЬ Обновление выбранных вариантов опроса

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

Как всегда, спасибо за чтение и не стесняйтесь комментировать или критиковать ниже.

comments powered by Disqus

Содержание