Быстрый старт

Желаете начать работу? Эта страница предоставляет хорошее введение в Flask. Сначала выполните Установка, чтобы настроить проект и установить Flask.

Минимальное приложение

Минимальное приложение Flask выглядит примерно так:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello_world():
    return "<p>Hello, World!</p>"

Что делает этот код?

1. Сначала мы импортировали класс Flask. Экземпляр этого класса будет нашим WSGI-приложением.
2. Затем мы создаём экземпляр этого класса. Первым аргументом является имя модуля или пакета приложения. __name__ — удобное сокращение для большинства случаев. Это необходимо, чтобы Flask знал, где искать ресурсы, такие как шаблоны и статические файлы.
3. Затем мы используем декоратор route(), чтобы указать Flask, какой URL должен вызывать нашу функцию.
4. Функция возвращает сообщение, которое мы хотим отобразить в браузере пользователя. По умолчанию тип контента — HTML, поэтому HTML в строке будет рендериться браузером.

Сохраните его как hello.py или что-то подобное. Убедитесь, что ваше приложение не называется flask.py, так как это вызовет конфликт с самим Flask.

Чтобы запустить приложение, используйте команду flask или python -m flask. Прежде чем вы сможете это сделать, вам необходимо указать вашему терминалу приложение для работы, экспортировав переменную окружения FLASK_APP.

$ export FLASK_APP=hello
$ flask run
 * Running on http://127.0.0.1:5000/

> set FLASK_APP=hello
> flask run
 * Running on http://127.0.0.1:5000/

> $env:FLASK_APP = "hello"
> flask run
 * Running on http://127.0.0.1:5000/

Это запускает очень простой встроенный сервер, который достаточно хорош для тестирования, но, вероятно, не для использования в продакшене. Дополнительные варианты развертывания см. в Варианты развертывания.

Теперь перейдите по адресу http://127.0.0.1:5000/, и вы должны увидеть приветствие «hello world».

$ flask run --host=0.0.0.0

Что делать, если сервер не запускается

В случае, если команда python -m flask завершается ошибкой или flask не существует, есть несколько причин. Прежде всего, необходимо просмотреть сообщение об ошибке.

Старая версия Flask

В версиях Flask, более ранних чем 0.11, существовали другие способы запуска приложения. Короче говоря, команды flask и python -m flask отсутствовали. В этом случае у вас есть два варианта: либо обновить до более новых версий Flask, либо ознакомиться с Сервер разработки, чтобы узнать альтернативный метод запуска сервера.

Неверное имя импорта

Переменная среды FLASK_APP содержит имя модуля для импорта в команде flask run. В случае неверного именования модуля при запуске возникнет ошибка импорта (или если отладка включена при переходе к приложению). Она сообщит вам, что пытался импортировать и почему это не удалось.

Наиболее распространённой причиной является опечатка или то, что вы не создали объект app.

Режим отладки

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

Чтобы включить все функции разработки, установите переменную среды FLASK_ENV в значение development перед вызовом flask run.

$ export FLASK_ENV=development
$ flask run

> set FLASK_ENV=development
> flask run

> $env:FLASK_ENV = "development"
> flask run

См. также:

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

Экранирование HTML

При возвращении HTML (тип ответа по умолчанию в Flask) все предоставляемые пользователем значения, рендерящиеся в выводе, должны быть экранированы, чтобы защитить от атак с внедрением кода. Шаблоны HTML, рендерящиеся с Jinja, представленные позже, сделают это автоматически.

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

from markupsafe import escape

@app.route("/<name>")
def hello(name):
    return f"Hello, {escape(name)}!"

Если пользователь смог отправить имя <script>alert("bad")</script>, экранирование приводит к отображению его как текста, а не к выполнению сценария в браузере пользователя.

<name> в маршруте захватывает значение из URL и передаёт его в функцию представления. Правила переменных объяснены ниже.

Маршрутизация

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

Используйте декоратор route(), чтобы связать функцию с URL-адресом.

@app.route('/')
def index():
    return 'Index Page'

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

Вы можете сделать больше! Вы можете сделать части URL динамичными и прикрепить несколько правил к функции.

Правила переменных

Вы можете добавить переменные части в URL, указав их <variable_name>. Затем ваша функция получает <variable_name> в качестве ключевого аргумента. Необязательно, вы можете использовать преобразователь для указания типа аргумента, например <converter:variable_name>.

from markupsafe import escape

@app.route('/user/<username>')
def show_user_profile(username):
    # show the user profile for that user
    return f'User {username}'

@app.route('/post/<int:post_id>')
def show_post(post_id):
    # show the post with the given id, the id is an integer
    return f'Post {post_id}'

@app.route('/path/<path:subpath>')
def show_subpath(subpath):
    # show the subpath after /path/
    return f'Subpath {subpath}'

Типы преобразователей:

Уникальные URL-адреса / Поведение перенаправления

Следующие два правила отличаются использованием конечной косой черты.

@app.route('/projects/')
def projects():
    return 'The project page'

@app.route('/about')
def about():
    return 'The about page'

Канонический URL-адрес для точки входа projects имеет конечную косую черту. Он похож на папку в файловой системе. Если вы обращаетесь к URL-адресу без конечной косой черты (/projects), Flask перенаправляет вас на канонический URL-адрес с конечной косой чертой (/projects/).

Канонический URL-адрес для точки входа about не имеет конечной косой черты. Он похож на путь к файлу. Обращение к URL-адресу с конечной косой чертой (/about/ ) приводит к ошибке 404 «Не найдено». Это помогает поддерживать уникальность URL-адресов для этих ресурсов, что помогает поисковым системам избежать индексирования одной и той же страницы дважды.

Строка URL

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

Почему вы хотели бы строить URL-адреса с помощью функции обратного преобразования URL url_for(), а не жёстко кодировать их в своих шаблонах?

1. Обратное преобразование часто более описательно, чем жёсткая кодировка URL-адресов.
2. Вы можете изменить все URL-адреса сразу, вместо того, чтобы помнить о необходимости ручного изменения жёстко закодированных URL-адресов.
3. Создание URL-адресов обрабатывает экранирование специальных символов прозрачно.
4. Сгенерированные пути всегда абсолютные, избегая неожиданного поведения относительных путей в браузерах.
5. Если ваше приложение размещено вне корневого URL-адреса, например, в /myapplication вместо /, url_for() должным образом обрабатывает это за вас.

Например, здесь мы используем метод test_request_context() для проверки url_for(). test_request_context() сообщает Flask о том, что он должен вести себя так, как будто обрабатывает запрос, даже когда мы используем оболочку Python. См. Локальные переменные контекста.

from flask import url_for

@app.route('/')
def index():
    return 'index'

@app.route('/login')
def login():
    return 'login'

@app.route('/user/<username>')
def profile(username):
    return f'{username}\'s profile'

with app.test_request_context():
    print(url_for('index'))
    print(url_for('login'))
    print(url_for('login', next='/'))
    print(url_for('profile', username='John Doe'))

/
/login
/login?next=/
/user/John%20Doe

Методы HTTP

Веб-приложения используют различные методы HTTP при обращении к URL-адресам. Вам следует ознакомиться с методами HTTP при работе с Flask. По умолчанию маршрут отвечает только на запросы GET. Вы можете использовать аргумент methods декоратора route() для обработки различных методов HTTP.

from flask import request

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        return do_the_login()
    else:
        return show_the_login_form()

Если GET присутствует, Flask автоматически добавляет поддержку метода HEAD и обрабатывает запросы HEAD в соответствии со спецификацией HTTP RFC RFC. Аналогично, OPTIONS автоматически реализуется для вас.

Статические файлы

Динамические веб-приложения также нуждаются в статических файлах. Обычно оттуда берутся файлы CSS и JavaScript. В идеале ваш веб-сервер настроен на их обслуживание, но во время разработки Flask может это сделать тоже. Просто создайте папку с именем static в вашем пакете или рядом с вашим модулем, и она будет доступна по адресу /static в приложении.

Для генерации URL-адресов статических файлов используйте специальное имя конечной точки 'static':

url_for('static', filename='style.css')

Файл должен храниться в файловой системе как static/style.css.

Вывод шаблонов

Генерация HTML изнутри Python не является приятной задачей и довольно сложной, поскольку вам нужно самостоятельно выполнять экранирование HTML, чтобы обеспечить безопасность приложения. По этой причине Flask автоматически настраивает движок шаблонов Jinja2 для вас.

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

from flask import render_template

@app.route('/hello/')
@app.route('/hello/<name>')
def hello(name=None):
    return render_template('hello.html', name=name)

Flask будет искать шаблоны в папке templates. Поэтому, если ваше приложение является модулем, эта папка находится рядом с этим модулем, если это пакет, она находится внутри пакета:

Случай 1: модуль:

/application.py
/templates
    /hello.html

Случай 2: пакет:

/application
    /__init__.py
    /templates
        /hello.html

Для шаблонов можно использовать весь потенциал шаблонов Jinja2. Подробнее ознакомьтесь с официальной документацией по шаблонам Jinja2 Template Documentation.

Вот пример шаблона:

<!doctype html>
<title>Hello from Flask</title>
{% if name %}
  <h1>Hello {{ name }}!</h1>
{% else %}
  <h1>Hello, World!</h1>
{% endif %}

Внутри шаблонов вы также можете получить доступ к объектам request, session и g 1, а также к функции get_flashed_messages().

Шаблоны особенно полезны при использовании наследования. Если вы хотите узнать, как это работает, см. Наследование шаблонов. В основном наследование шаблонов позволяет сохранять определенные элементы на каждой странице (например, заголовок, навигацию и подвал).

Автоматическое экранирование включено, поэтому если name содержит HTML, он будет автоматически экранирован. Если вы можете доверять переменной и знаете, что она будет безопасным HTML (например, потому что она пришла из модуля, который преобразует разметку wiki в HTML), вы можете отметить её как безопасную, используя класс Markup или фильтр |safe в шаблоне. Подробнее ознакомьтесь с документацией Jinja 2.

Вот основное представление о том, как работает класс Markup:

>>> from markupsafe import Markup
>>> Markup('<strong>Hello %s!</strong>') % '<blink>hacker</blink>'
Markup('<strong>Hello &lt;blink&gt;hacker&lt;/blink&gt;!</strong>')
>>> Markup.escape('<blink>hacker</blink>')
Markup('&lt;blink&gt;hacker&lt;/blink&gt;')
>>> Markup('<em>Marked up</em> &raquo; HTML').striptags()
'Marked up \xbb HTML'

1

Не уверены, что такое объект g? Это то, в чем вы можете хранить информацию для своих нужд. См. документацию по flask.g и Использование SQLite 3 с Flask.

Доступ к данным запроса

Для веб-приложений важно реагировать на данные, отправляемые клиентом на сервер. В Flask эта информация предоставляется глобальным объектом request. Если у вас есть некоторый опыт работы с Python, вы можете задаться вопросом, как этот объект может быть глобальным, и как Flask всё ещё остается потокобезопасным. Ответ – локальные переменные контекста:

Локальные переменные контекста

Некоторые объекты в Flask являются глобальными объектами, но не в обычном смысле. На самом деле эти объекты являются прокси-серверами для объектов, локальных для определенного контекста. Довольно многословно. Но это на самом деле довольно легко понять.

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

Что это значит для вас? В основном вы можете полностью игнорировать этот факт, если вы не занимаетесь чем-то вроде тестирования юнит-тестами. Вы заметите, что код, зависящий от объекта запроса, внезапно начнет давать сбой, потому что объекта запроса нет. Решение заключается в создании вашего собственного объекта запроса и привязке его к контексту. Самое простое решение для тестирования – использовать менеджер контекста test_request_context(). В сочетании с инструкцией with он привяжет тестовый запрос, чтобы вы могли с ним взаимодействовать. Вот пример:

from flask import request

with app.test_request_context('/hello', method='POST'):
    # now you can do something with the request until the
    # end of the with block, such as basic assertions:
    assert request.path == '/hello'
    assert request.method == 'POST'

Другая возможность – передать всю среду WSGI методу request_context():

with app.request_context(environ):
    assert request.method == 'POST'

Объект запроса

Объект запроса документирован в разделе API и мы не будем подробно рассматривать его здесь (см. Request). Вот краткий обзор некоторых наиболее распространённых операций. Сначала вам нужно импортировать его из модуля flask:

from flask import request

Текущий метод запроса доступен с помощью атрибута method. Для доступа к данным формы (данные, передаваемые в запросе POST или PUT) вы можете использовать атрибут form. Вот полный пример использования двух упомянутых выше атрибутов:

@app.route('/login', methods=['POST', 'GET'])
def login():
    error = None
    if request.method == 'POST':
        if valid_login(request.form['username'],
                       request.form['password']):
            return log_the_user_in(request.form['username'])
        else:
            error = 'Invalid username/password'
    # the code below is executed if the request method
    # was GET or the credentials were invalid
    return render_template('login.html', error=error)

Что произойдёт, если ключа не существует в атрибуте form? В этом случае возникает специальная ошибка KeyError. Вы можете перехватить её как стандартную ошибку KeyError, но если вы этого не сделаете, будет показана страница ошибки HTTP 400 Bad Request. Поэтому во многих ситуациях вам не придётся с этим бороться.

Для доступа к параметрам, переданным в URL (?key=value), можно использовать атрибут args:

searchword = request.args.get('key', '')

Рекомендуется получать параметры URL с помощью get или перехватывая исключение KeyError, так как пользователи могут изменять URL, и в этом случае выводить страницу с ошибкой 400 (Bad Request) не является удобным для пользователя.

Полный список методов и атрибутов объекта запроса можно найти в документации Request.

Загрузка файлов

Вы можете легко обрабатывать загруженные файлы с помощью Flask. Просто не забудьте установить атрибут enctype="multipart/form-data" в вашей HTML-форме, иначе браузер вообще не будет передавать ваши файлы.

Загруженные файлы хранятся в памяти или в временном месте на файловой системе. Вы можете получить доступ к этим файлам, посмотрев на атрибут files объекта запроса. Каждый загруженный файл хранится в этом словаре. Он ведет себя как стандартный объект Python file, но также имеет метод save(), который позволяет сохранить файл на файловой системе сервера. Вот простой пример, демонстрирующий, как это работает:

from flask import request

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
    if request.method == 'POST':
        f = request.files['the_file']
        f.save('/var/www/uploads/uploaded_file.txt')
    ...

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

from werkzeug.utils import secure_filename

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
    if request.method == 'POST':
        file = request.files['the_file']
        file.save(f"/var/www/uploads/{secure_filename(f.filename)}")
    ...

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

Куки

Для доступа к кукам можно использовать атрибут cookies. Для установки кук можно использовать метод set_cookie объектов ответа. Атрибут cookies объектов запроса представляет собой словарь со всеми куками, переданными клиентом. Если вы хотите использовать сессии, не используйте куки напрямую, а вместо этого используйте сессии Flask, которые добавляют дополнительную безопасность для кук.

Чтение кук:

from flask import request

@app.route('/')
def index():
    username = request.cookies.get('username')
    # use cookies.get(key) instead of cookies[key] to not get a
    # KeyError if the cookie is missing.

Хранение кук:

from flask import make_response

@app.route('/')
def index():
    resp = make_response(render_template(...))
    resp.set_cookie('username', 'the username')
    return resp

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

Иногда вам может потребоваться установить куки в момент, когда объект ответа еще не существует. Это возможно, используя шаблон Отложенные обратные вызовы запроса.

Также см. Об ответах.

Перенаправления и ошибки

Для перенаправления пользователя на другой конечный пункт используйте функцию redirect(); для преждевременного прерывания запроса с кодом ошибки используйте функцию abort():

from flask import abort, redirect, url_for

@app.route('/')
def index():
    return redirect(url_for('login'))

@app.route('/login')
def login():
    abort(401)
    this_is_never_executed()

Это довольно бесполезный пример, потому что пользователь будет перенаправлен с главной страницы на страницу, к которой у него нет доступа (401 означает отказ в доступе), но он показывает, как это работает.

По умолчанию для каждого кода ошибки отображается черно-белая страница ошибки. Если вы хотите настроить страницу ошибки, вы можете использовать декоратор errorhandler():

from flask import render_template

@app.errorhandler(404)
def page_not_found(error):
    return render_template('page_not_found.html'), 404

Обратите внимание на 404 после вызова render_template(). Это сообщает Flask, что код состояния этой страницы должен быть 404, что означает «не найдено». По умолчанию предполагается 200, что означает: все прошло хорошо.

Дополнительные сведения см. в разделе Обработка ошибок приложения.

Об ответах

Возвращаемое значение функции представления автоматически преобразуется в объект ответа. Если возвращаемое значение — строка, оно преобразуется в объект ответа со строкой в качестве тела ответа, кодом состояния 200 OK и MIME-типом text/html. Если возвращаемое значение — словарь, вызывается jsonify(), чтобы сгенерировать ответ. Логика, которую применяет Flask для преобразования возвращаемых значений в объекты ответа, следующая:

1. Если возвращается объект ответа соответствующего типа, он возвращается из представления напрямую.
2. Если это строка, создается объект ответа с этими данными и параметрами по умолчанию.
3. Если это словарь, объект ответа создается с помощью jsonify.
4. Если возвращается кортеж, элементы кортежа могут предоставить дополнительную информацию. Такие кортежи должны иметь вид (response, status), (response, headers), или (response, status, headers). Значение status переопределит код состояния, а headers может быть списком или словарем дополнительных значений заголовков.
5. Если ничего из этого не работает, Flask предположит, что возвращаемое значение — это допустимое приложение WSGI, и преобразует его в объект ответа.

Если вы хотите получить объект результата ответа внутри представления, вы можете использовать функцию make_response().

Представьте, что у вас есть представление такого вида:

from flask import render_template

@app.errorhandler(404)
def not_found(error):
    return render_template('error.html'), 404

Вам просто нужно обернуть выражение возврата функцией make_response() и получить объект ответа для его изменения, а затем вернуть его:

from flask import make_response

@app.errorhandler(404)
def not_found(error):
    resp = make_response(render_template('error.html'), 404)
    resp.headers['X-Something'] = 'A value'
    return resp

API с JSON

Распространённый формат ответа при написании API — JSON. Начать работу с таким API с Flask легко. Если вы вернёте dict из представления, он будет преобразован в ответ JSON.

@app.route("/me")
def me_api():
    user = get_current_user()
    return {
        "username": user.username,
        "theme": user.theme,
        "image": url_for("user_image", filename=user.image),
    }

В зависимости от дизайна API, вам может потребоваться создавать ответы JSON для типов, отличных от dict. В этом случае используйте функцию jsonify(), которая будет сериализовать любой поддерживаемый тип данных JSON. Или изучите расширения сообщества Flask, которые поддерживают более сложные приложения.

from flask import jsonify

@app.route("/users")
def users_api():
    users = get_all_users()
    return jsonify([user.to_json() for user in users])

Сессии

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

Для использования сессий необходимо установить секретный ключ. Вот как работают сессии:

from flask import session

# Set the secret key to some random bytes. Keep this really secret!
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'

@app.route('/')
def index():
    if 'username' in session:
        return f'Logged in as {session["username"]}'
    return 'You are not logged in'

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        session['username'] = request.form['username']
        return redirect(url_for('index'))
    return '''
        <form method="post">
            <p><input type=text name=username>
            <p><input type=submit value=Login>
        </form>
    '''

@app.route('/logout')
def logout():
    # remove the username from the session if it's there
    session.pop('username', None)
    return redirect(url_for('index'))

$ python -c 'import os; print(os.urandom(16))'
b'_5#y2L"F4Q8z\n\xec]/'

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

Помимо стандартных сессий на стороне клиента, если вы хотите обрабатывать сессии на стороне сервера, существуют несколько расширений Flask, которые это поддерживают.

Отображение сообщений

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

Для отображения сообщения используйте метод flash(), для получения сообщений используйте get_flashed_messages(), который также доступен в шаблонах. Полный пример см. в разделе Всплывающие сообщения.

Ведение журнала

Иногда вы можете столкнуться с ситуацией, когда данные должны быть корректными, но на самом деле не являются таковыми. Например, у вас может быть код на стороне клиента, который отправляет HTTP-запрос на сервер, но он очевидно некорректен. Это может быть вызвано вмешательством пользователя в данные или сбоем в коде клиента. В большинстве случаев в такой ситуации можно ответить 400 Bad Request, но иногда этого недостаточно, и код должен продолжать работать.

Возможно, вы всё ещё хотите записывать, что-то подозрительное произошло. Именно здесь логгеры пригодятся. Начиная с Flask 0.3, для вас уже настроен логгер.

Вот несколько примеров вызовов логгирования:

app.logger.debug('A value for debugging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('An error occurred')

Прикреплённый logger является стандартным логгером Logger, поэтому обратитесь к официальной документации logging для получения дополнительной информации.

См. Обработка ошибок приложения.

Подключение WSGI-средств разработки

Чтобы добавить WSGI-средство разработки в ваше приложение Flask, оберните атрибут приложения wsgi_app. Например, чтобы применить средство разработки Werkzeug's ProxyFix для работы за Nginx:

from werkzeug.middleware.proxy_fix import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)

Обертывание app.wsgi_app вместо app означает, что app всё ещё указывает на ваше приложение Flask, а не на средство разработки, поэтому вы можете продолжить использование и настройку app напрямую.

Использование расширений Flask

Расширения — это пакеты, которые помогают вам выполнять общие задачи. Например, Flask-SQLAlchemy предоставляет поддержку SQLAlchemy, что упрощает и облегчает её использование с Flask.

Для получения дополнительной информации об расширениях Flask, см. Расширения.

Развёртывание на веб-сервере

Готовы развернуть ваше новое приложение Flask? См. Варианты развёртывания.