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

Вы хотите начать работу? Эта страница предоставляет хорошее введение в Flask. Предполагается, что у вас уже установлен Flask. Если нет, перейдите к разделу Установка.

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

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

from flask import Flask
app = Flask(__name__)

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

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

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

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

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

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

Если вы работаете в Windows, синтаксис переменной среды зависит от интерпретатора командной строки. В командной строке:

C:\path\to\app>set FLASK_APP=hello.py

А в PowerShell:

PS C:\path\to\app> $env:FLASK_APP = "hello.py"

В качестве альтернативы вы можете использовать python -m flask:

$ export FLASK_APP=hello.py
$ python -m 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 удобен для запуска локального сервера разработки, но вам придется перезапускать его вручную после каждого изменения в вашем коде. Это не очень удобно, и Flask может сделать лучше. Если вы включите поддержку отладки, сервер будет перезагружаться при изменениях кода, а также предоставит вам полезный отладчик, если что-то пойдет не так.

Чтобы включить все функции разработки (включая режим отладки), вы можете экспортировать переменную среды FLASK_ENV и установить её значение в development перед запуском сервера:

$ export FLASK_ENV=development
$ flask run

(В Windows вам нужно использовать set вместо export).

Это делает следующее:

1. включает отладчик
2. включает автоматическое обновление
3. включает режим отладки в приложении Flask.

Вы также можете управлять режимом отладки отдельно от среды, экспортировав FLASK_DEBUG=1.

В документации Сервер разработки описаны другие параметры.

Скриншот отладчика в действии:

Дополнительную информацию об использовании отладчика можно найти в документации Werkzeug.

Есть в виду другой отладчик? См. Работа с отладчиками.

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

Современные веб-приложения используют осмысленные 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 'User %s' % escape(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 'Post %d' % post_id

@app.route('/path/<path:subpath>')
def show_subpath(subpath):
    # show the subpath after /path/
    return 'Subpath %s' % escape(subpath)

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

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

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

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

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

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

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

Генерация URL-адресов

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

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

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

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

from flask import Flask, url_for
from markupsafe import escape

app = Flask(__name__)

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

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

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

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. Аналогично, 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.

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

<!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 (например, потому что она получена из модуля, который преобразует разметку вики в HTML), вы можете пометить её как безопасную, используя класс Markup или используя фильтр |safe в шаблоне. Для получения дополнительных примеров обратитесь к документации Jinja 2.

Вот базовое введение в работу класса Markup:

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

1

Не знаете, что это за объект g? Это нечто, в чём вы можете хранить информацию для своих нужд. Обратитесь к документации этого объекта (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():

from flask import request

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 flask import request
from werkzeug.utils import secure_filename

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
    if request.method == 'POST':
        f = request.files['the_file']
        f.save('/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 преобразует их в объекты ответа за вас. Если вы явно хотите сделать это, вы можете использовать функцию 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().

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

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

Вам нужно только обернуть выражение возврата с помощью 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, которые поддерживают более сложные приложения.

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

Сессии

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

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

from flask import Flask, session, redirect, url_for, request
from markupsafe import escape

app = Flask(__name__)

# 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 'Logged in as %s' % escape(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'))

Упомянутая здесь escape() выполняет экранирование за вас, если вы не используете движок шаблонов (как в этом примере).

$ 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 приложения. Например, чтобы применить средство ProxyFix Werkzeug для работы за Nginx:

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

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

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

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

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

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

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