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

Вы хотите начать работу? Эта страница предоставляет хорошее введение в 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 или переключатель -m из Python с 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>.

@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_for() для построения URL вместо того, чтобы жёстко их кодировать в шаблонах?

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, escape, url_for

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 flask 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. Логика, которую применяет Flask для преобразования значений возврата в объекты ответа, следующая:

1. Если возвращается объект ответа правильного типа, он возвращается из представления напрямую.
2. Если это строка, создаётся объект ответа с этими данными и значениями по умолчанию.
3. Если возвращается кортеж, его элементы могут предоставить дополнительную информацию. Такие кортежи должны иметь вид (response, status, headers), (response, headers) или (response, status), где по крайней мере один элемент должен находиться в кортеже. Значение status переопределит код состояния, а headers может быть списком или словарем дополнительных значений заголовков.
4. Если ни одно из вышеперечисленных не срабатывает, 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

Сессии

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

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

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

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 приложения. Например, чтобы применить средства обработки Werkzeug 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? Перейдите к Вариантам развертывания.