Установка flask python windows
У меня есть проект, который нужно сделать после создания веб-страницы, отображающей самую свежую погоду из моего CSV-файла.
Я хотел бы получить некоторые подробности о том, как это сделать (на самом деле не получить http://flask.pocoo.org/docs/installation/#installation установка установки)
Кто-нибудь может мне объяснить, как это сделать просто?
Я работаю в Windows 7 с Windows PowerShell.
7 ответов
Установите pip, как описано здесь: Как установить pip в Windows?
Это руководство по установке немного вводит в заблуждение, оно касается его фактического запуска в производственной среде.
Сначала установите колбу с помощью pip,
* Если pip не установлен, установите pip
Затем скопируйте приведенную ниже программу (hello.py)
Теперь запустите программу
Запуск на http://127.0.0.1:5000/ (нажмите CTRL + C, чтобы выйти) уш>
Просто скопируйте и вставьте указанную выше адресную строку в ваш браузер.
В Windows установка easy_install немного сложнее, но все же довольно проста. Самый простой способ сделать это — загрузить файл distribte_setup.py и запустить его. Самый простой способ запустить файл — открыть папку загрузок и дважды щелкнуть файл.
Затем добавьте команду easy_install и другие скрипты Python в путь поиска команд, добавив папку Scripts вашей установки Python в переменную среды PATH. Для этого щелкните правой кнопкой мыши значок «Компьютер» на рабочем столе или в меню «Пуск» и выберите «Свойства». Затем нажмите «Дополнительные параметры системы» (в Windows XP вместо этого перейдите на вкладку «Дополнительно»). Затем нажмите кнопку «Переменные среды». Наконец, дважды щелкните переменную «Path» в разделе «Системные переменные» и добавьте путь к папке Scripts вашего интерпретатора Python. Не забудьте отделить его от существующих значений точкой с запятой. Предполагая, что вы используете Python 2.7 по умолчанию, добавьте следующее значение:
; C: \ python27 \ Scripts И все готово! Чтобы убедиться, что это работает, откройте командную строку и выполните команду easy_install. Если у вас включен контроль учетных записей в Windows Vista или Windows 7, он должен запросить у вас права администратора.
Теперь, когда у вас есть easy_install, вы можете использовать его для установки pip:
Если вы являетесь пользователем PyCharm , установить его Flask довольно просто. Это также поможет пользователям без доступа к оболочке.
- Открыть настройки (Ctrl + Alt + s)>>
- Перейти к интерпретатору проекта>>
- Дважды нажмите pip >> Поиск фляги
- Выберите и нажмите Установить пакет (установите флажок Установить для пользователей сайта, если собираетесь использовать Flask только для этого проекта Готово .
Случаи, в которых колба не показана в пунктах: Открыть управление репозиторием>> Добавить (+)>> Добавьте следующий URL
Теперь вернемся к пункту, он покажет связанные пакеты с фляжкой,
Инсталляция¶
Flask зависит от некоторых внешних библиотек — таких, как Werkzeug и Jinja2. Werkzeug — это инструментарий для WSGI — стандартного интерфейса Python между веб-приложениями и различными серверами, предназначен как для разработки, так и развёртывания. Jinja2 занимается отображением шаблонов.
Итак, как же быстро получить всё необходимое на ваш компьютер? Есть много способов, которыми вы это можете проделать, но самый обалденный — это virtualenv, так что давайте глянем в первую очередь на него.
Для начала вам понадобится Python 2.6 или новее, так что убедитесь, что у вас инсталлирован свежий Python 2.x. При использовании Flask с Python 3 загляните в раздел python3-support .
virtualenv¶
Возможно, Virtualenv — именно то, что вы захотите использовать при разработке, а если у вас на рабочем сервере есть доступ к командной оболочке, вероятно, вы захотите использовать Virtualenv и здесь.
Какую из проблем решает virtualenv? Если вам нравится Python так, как он нравится мне, скорее всего, вы захотите использовать его и в других проектах — вне приложений, созданных на базе Flask.
Но чем больше у вас проектов, тем больше вероятность, что вы будете работать с разными версиями самого Python, или, по крайней мере, с различными версиями библиотек Python. Посмотрим правде в глаза: довольно часто библиотеки нарушают обратную совместимость, и маловероятно, что серьёзное приложение будет работать вообще без каких-либо зависимостей. Так что же делать, если два или более из ваших проектов имеют конфликтующие зависимости?
Наше спасение — Virtualenv! Virtualenv предоставляет несколько соседствующих друг с другом установленных версий Python, по одной для каждого проекта. На самом деле он реально не устанавливает различные версии Python, но обеспечивает хитрый способ создать для проектов несколько изолированных друг от друга окружений. Давайте посмотрим, как работает virtualenv.
Если вы работаете с MacOS X или с Linux, есть вероятность, что заработает одна из следующих двух команд:
Возможно, одна из этих команд установит virtualenv на вашей системе. А может быть, это позволит сделать ваш пакетный менеджер. Если вы используете Ubuntu, попробуйте:
Если у вас Windows и команда easy_install не работает, вам необходимо сначала установить её. Чтобы получить дополнительную информацию о том, как это можно сделать, проверьте раздел pip и setuptools в MS Windows . Установив данную команду, запустите её, как указано чуть выше, но без префикса sudo .
После того, как virtualenv была установлена, просто запустите командный интерпретатор и создайте ваше собственное окружение. Обычно в таких случаях я создаю папку проекта, а в ней — папку venv :
Теперь, когда вы захотите работать над проектом, вам необходимо лишь активировать соответствующее окружение. Под MacOS X и Linux, выполните следующее:
Если вы используете Windows, для вас подойдёт следующая команда:
В любом случае, теперь вы должны использовать ваш virtualenv (обратите внимание, как изменилось приглашение вашей командной оболочки — для того, чтобы показать активное окружение).
А если вы захотите вернуться обратно в «реальный мир», используйте команду:
Полсе этого подсказка вашей командной оболочки вернёт свой прежний привычный вид.
Теперь, двинемся дальше. Для того, чтобы Flask появился в вашем виртуальном окружении, введите команду:
Через несколько секунд вы сможете двинуться в дальнейший путь.
Установка непосредственно в систему¶
Возможен и такой вариант установки, но я бы вам его не рекомендовал. Просто запустите pip с привилегиями суперпользователя:
(Под Windows, запустите ту же команду, но только без sudo , внутри окна с командной строкой, запущенного с привилегиями администратора системы)
Жизнь на переднем краю¶
Если вы хотите работать с самой последней версией Flask, существует два пути: можно указать pip , чтобы он загрузил версию для разработки, или можно работать со срезом с текущего состояния репозитория git. В обоих случаях, рекомендуется пользоваться virtualenv.
Получите срез с последнего состояния git в новом окружении virtualenv и запустите в режиме разработки:
Будет скачана и активирована в virtualenv текущая версия, соответствующая последнему (головному) срезу из git. В дальнейшем, чтобы обновиться до последней версии, всё, что вам будет необходимо сделать — это выполнить git pull origin .
pip и setuptools в MS Windows¶
Иногда получение стандартных инструментов по работе с пакетами в Python — таких, как pip, setuptools и virtualenv может быть несколько мудрёным, но на самом деле в этом нет ничего сложного. Вам нужны два ключевых пакета — setuptools и pip — которые позволят вам инсталлировать всё остальное (в том числе virtualenv). К счастью, есть два готовых скрипта, запустив которые вы можете развернуть оба пакета «с нуля».
Если у вас их нет, скрипт get-pip.py осуществит инсталляцию обоих (вам не нужно будет запускать ez_setup.py).
Для инсталляции последней версии setuptools, вы можете использовать следующий скрипт, предназначенный для разворачивания «с нуля»:
Оба этих скрипта необходимо скачать и запустить двойным щелчком мыши. Если у вас уже есть pip, вы можете обновить его, запустив команду:
Чаще всего, получив приглашение командной строки, вы захотите иметь возможность набрать pip и python , что должно привести к запуску этих команд, однако в Windows этого автоматически не происходит, потому что операционная система не знает, где располагаются их исполнимые файлы (вы можете попробовать!).
Чтобы исправить это, вам необходимо перейти в папку, куда вы установили Python (например, C:\Python27 ), а затем в подпапки Tools , Scripts ; затем найти файл win_add2path.py и запустить его. Далее открыть новую Командную строку и проверить, что при вводе python запускается командный интерпретатор.
Наконец, для того, чтобы инсталлировать virtualenv, вы можете просто ввести:
Теперь, когда вы установили всё, что нужно, выполнив вышеизложенные инструкции, можно откинуться на спинку кресла.
#2 Установка Flask
Примечание: перед тем как двигаться дальше, нужно удостовериться, что в системе установлены Python и пакет virtualenv.
Создание виртуальной среды (Virtual Environment)
Виртуальная среда — это изолированная копия Python, куда устанавливаются пакеты, не затрагивающие глобальную версию Python. Начать нужно с создания папки flask_app . В ней будет храниться приложение Flask.
Важно не забыть сменить рабочий каталог на flask_app с помощью команды cd .
Следующий шаг — создание виртуальной среды внутри папки flask_app с помощью команды virtualenv .
После выполнения вышеуказанной команды в папке flask_app должна появиться еще одна под названием env . В ней будет храниться отдельная версия Python, включающая все исполняемые скрипты, как и в глобальной версии. Для использования среды ее нужно активировать.
В Linux и Mac OS это делается с помощью следующей команды.
Пользователям Windows нужно использовать следующую команду.
Стоит обратить внимание, что название виртуальной среды теперь написано в скобках перед активной строкой ввода, например, (env) . Это значит, что среда есть и активна. Теперь все установленные пакеты будут доступны только внутри этой среды.
Включение виртуальной среды временно меняет переменную окружения PATH . Так, если сейчас ввести в терминале python , будет вызван интерпретатор внутри среды, то есть, env , вместо глобального.
После окончания работы со средой, ее нужно выключить с помощью команды deactivate .
Эта же команда снова делает доступным глобальный интерпретатор Python.
Установка Flask
Для установки Flask внутри виртуальной среды нужно ввести следующую команду.
Проверить, прошла ли установка успешно, можно, вызвав интерпретатор Python и импортировав Flask.
How to install FLASK in Windows 10
Today we will see how to install FLASK in Windows 10. This is a framework written in Python designed to create web applications. Also, it offers to do it quickly and without having to enter and edit many lines of code. It is based on the WSGI specification by Werkzeug and the Jinja2 template engine. On the other hand, it has a BSD license. Some of its features are the following:
- It is based on Unicode
- WSGI compliant
- Allows the execution of individual tests
- It has development servers and debugging features
- Use Jinja2 template styles
- Allows the creation of secure cookies for sites
Prerequisite
As mentioned, this is an application written in Python. Consequently, it is essential to have this language installed. To know how to do it, see our tutorial.
How to download and install Flask in Windows 10. Step by step.
In the first place, it is necessary to create a folder where you will save the configuration of the app. With this in mind, we will create it inside Documents and call it my_flask.
Then open a CMD as an administrator from the folder location and run the following command:
With this command we have created the virtual environment of Flask. In effect, all you have to do is go to the folder and look at the content.
Back to the terminal, please run the following command to activate the environment:
Now, install Flask with the following command:
Installing Flask on Windows 10
Once Flask is downloaded and installed, the wizard recommends updating the pip. With this in mind, run the following command:
Updating the PIP version
Creating the configuration file.
Now it’s time to create an app.py file. Consequently, some advanced text editor like Notepad++ is recommended. Finally, save it in the newly created folder.
Creating the app.py file
Then, please establish the application with the following order:
Then open the app.py file and add the following lines:
Editing the configuration file
To run this environment go to the terminal and there run:
Then, select the assigned IP address in the terminal. Then open it in any browser.
Flask application running successfully in a browser
Ultimately we have seen how you install Flask on Windows 10. Besides, it is written in python so it has a great support. See you later!
Flask
Flask является микрофреймворком для создания вебсайтов на языке Python. В основу статьи положен перевод из официальной документации Flask. Поэтому в ней имеется обращение от первого лица, то есть от создателя фреймворка Армина Ронахера.
Flask в данном контексте переводится как пороховой рожок, на это указывает официальное лого.
Содержание
Предисловие [ править ]
Что значит «микро»? [ править ]
На мой взгляд «микро» в фреймворке относится не только к простоте и небольшому размеру базы, но это также может означать тот факт, что он не предлагает вам много проектных решений. Несмотря на то, что Flask использует нечто подобное в виде шаблонизатора, мы не будем принимать подобные решения для вашего хранилища данных или других частей. Тем не менее, для нас термин «микро» не означает, что вся реализация должна вписываться в один файл.
Одним из проектных решений во Flask является то, что простые задачи должны быть простыми; они не должны занимать много кода, и это не должно ограничивать вас. Поэтому мы сделали несколько вариантов дизайна, некоторые люди могут посчитать это удивительным и даже странным. Например, Flask использует локальные треды внутри объектов, так что вы не должны передавать объекты в пределах одного запроса от функции к функции, оставаясь в безопасном треде. Хоть это и очень простой подход, который позволяет сэкономить время, такое решение может вызвать некоторые проблемы для слишком больших приложений, поскольку изменения в этих локальных тредах-объектах могут произойти где угодно в этом треде. Для того, чтобы решить эти проблемы, мы не стали скрывать от вас локальные треды-объекты, вместо этого мы охватываем их и предоставляем вам много инструментов, чтобы сделать работу с ними настолько приятной, насколько это возможно.
Во Flask многие вещи предварительно сконфигурированы, на основе общей базовой конфигурации. Например, шаблоны и статические файлы сохранены в подкаталогах в пределах исходного дерева. Вы также можете изменить это, но обычно этого не требуется.
Основная причина почему Flask называется «микрофреймворком» — это идея сохранить ядро простым, но расширяемым. В нем нет абстрактного уровня базы данных, нет валидации форм или всего того, что уже есть в других библиотеках. Однако, Flask поддерживает расширения, которые могут добавить необходимую функциональность и имплементирует их так, как будто они уже были встроены изначально. В настоящее время уже есть расширения: формы валидации, поддержка закачки файлов, различные технологии аутентификации и многие другие.
Безопасность [ править ]
Ваше безопасное веб-приложение можно взломать различными способами, так как веб-программирование — это небезопасное занятие. Вы позволяете пользователям оставлять информацию на сервере, следовательно можно найти способ взломать ваше веб-приложение. Flask защищает вас от наиболее распространенных и известных способов взлома, такие как XSS (cross-site scripting). До тех пор, пока вы сами сознательно не отмечаете опасный html как безопасный, Flask и шаблонизатор Jinja2 защищают вас, но все равно могут найтись способы взломать ваш сайт.
Статус насчет Python 3 [ править ]
Werkzeug и Flask поддерживают Python 3.
Установка [ править ]
Имеются две зависимости:
Jinja2 — движок темплейтов
Werkzeug — набор инструментов WSGI, стандартного интерфейса Python для развертывания веб-приложений и взаимодействия между ними и различными серверами разработки.
Virtualenv — не является зависимостью. Это инструмент, который призван решить проблему обратной совместимости. Вы можете использовать различные версии Python или версии библиотек, это может вызвать конфликт зависимостей. Virtualenv решает эту проблему, создает изолированную среду для каждого проекта.
Под Windows [ править ]
Запустить командную строку cmd
Проще всего установить при помощи скрипта easy_install. В командной строке должно получиться что-то вроде этого:
C:\Python27\python.exe C:\Python27\Scripts\easy_install-2.7-script.py Flask
Установка зависимостей:
C:\Python27\python.exe C:\Python27\Scripts\easy_install-2.7-script.py Jinja2
C:\Python27\python.exe C:\Python27\Scripts\easy_install-2.7-script.py Werkzeug
C:\Python27\python.exe C:\Python27\Scripts\easy_install-2.7-script.py Virtualenv
Установка под Linux [ править ]
В терминале написать pip install flask
Краткая документация [ править ]
Простейший Hello world [ править ]
Создадим файл hello.py следующего содержания:
Проверим как установился Flask. Запустим скрипт:
C:\Python27\python.exe hello.py
Наберите в браузере в адресной строке http://localhost:5000/ и увидите надпись Hello World!
В версии Flask 1.0.2 процесс запуска изменился. Требуется следующая команда:
FLASK_APP=hello.py flask run
Не забудьте, для запуска сначала требуется перейти в консоли в папку, где хранится скрипт.
Разбор программы Hello world! [ править ]
Рассмотрим, как работает программа, которую вы запустили выше:
- Сначала мы импортируем Flask класс. Экземпляр этого класса будет нашим WSGI приложением. Первым аргументом является имя модуля приложения. Если вы используете один модуль (как в данном примере), вы должны использовать __name__, потому что в зависимости от того, было ли это начато как приложение или как импорт модуля, название будет другим (‘__main__’ по сравнению с реальным именем импорта).
- Далее мы создаем экземпляр этого класса. Мы передаем ему имя модуля или пакета. Это необходимо, так как Flask не знает, где искать шаблоны, статические файлы, и так далее.
- Затем мы используем route(). Декоратор говорит Flask, что URL должен вызывать нашу функцию.
- Функция задает имя, которое также используется для создания URL-адресов для этой функции, и возвращает сообщение, что мы хотим отобразить в браузере пользователя.
- Наконец, мы используем run() функцию для запуска локального сервера с нашим приложением. Условие __name__ == «__main__» означает, что сервер работает только в том случае, если скрипт выполняется непосредственно из Python интерпретатора и не используется в качестве импортированного модуля.
Общедоступный сервер [ править ]
Если вы запустите сервер, вы заметите, что он доступен только с вашего компьютера, а не с любого другого компьютера в сети. Это значение выставлено по умолчанию, потому что в режиме отладки пользователь приложения может выполнить произвольный код на вашем компьютере.
Если вы доверяете пользователям в вашей сети, вы можете сделать сервер общедоступным, просто изменив вызов run(), который должен выглядеть следующим образом:
Это говорит вашей операционной системе слушать на всех ip (интерфейсах).
Режим отладки [ править ]
Метод run() хорош для начала разработки на локальном сервере. Но это потребует ручного перезапуска сервера после каждого изменения в коде. Хорошо что Flask может справиться с этой проблемой. Если включить Debug Mode, сервер будет сам перегружаться после каждого изменения в коде. Еще вы получите полезный отладчик, на тот случай если что-то пойдет не так.
Есть два способа включить режим отладки:
app.debug = True
app.run()
Или
app.run(debug=True)
Оба метода дадут одинаковый эффект
Внимание
Несмотря на то, что интерактивный отладчик не работает в разветвленной среде (что делает его практически невозможным в использовании на производственных серверах), он все же позволяет выполнить произвольный код. Это делает его одним из основных рисков в безопасности, и поэтому он никогда не должен быть использован на производственных машинах.
Маршрутизация [ править ]
Современные веб-приложения имеют красивые URL. Это помогает людям помнить их, особенно это удобно для приложений, которые используются в мобильных устройствах с медленным сетевым подключением. Если пользователь может попасть на страницу через URL минуя главную страницу, то более вероятно, что он вернется в следующий раз.
Как вы видели выше, декоратор route() используется для связывания функций с URL. Вот несколько основных примеров:
Но это еще не все! Вы можете сделать некоторые части URL динамическими и применить несколько правил к функции.
Использование переменных [ править ]
Для добавления переменной части в URL вы можете пометить эти разделы, как <variable_name>. Такая часть затем передается как аргумент ключевого слова в вашу функцию. Дополнительно преобразователь может быть определен путем указания правила <converter:variable_name>. Вот некоторые хорошие примеры:
Имеются следующие конверторы
| int | Принимает целые числа |
| float | то же самое, что int, только с плавающей точкой |
| path | похоже на то, что установлено по умолчанию, но принимает слэши |
Уникальные линки и редирект [ править ]
Линки во Flask основаны на базе модуля маршрутизации от Werkzeug. Идея этого модуля заключается в обеспечении красивых и уникальных URL-адресов на основе правил ранее сформировавшихся в Apache и в HTTP серверах.
Используйте два правила:
Хоть эти примеры и выглядят очень похоже, они различаются по слэшу в конце URL. В первом случае, доступ без слэша вызывает редирект на канонические URL с обратным слэшем.
Во втором случае, без обратного слэша, URL определяется, как путь к файлу на UNIX-подобных системах. Доступ к URL со слэшем будет перенаправляться на ошибку 404 «не найдено».
Такое поведение позволяет пользователям получить доступ к странице, даже если они забыли ввести в конце обратный слэш. Кроме того, URL-адрес будет оставаться уникальным, и это поможет поисковым системам избегать повторного индексирования страницы.
Генерация URL [ править ]
Flask может генерировать URL. Для создания URL, используйте функцию url_for() . Она принимает имя функции в качестве первого аргумента, а также ряд ключевых аргументов, каждый из которых соответствует переменной части URL правила. Части неизвестной переменной добавляется к URL в качестве параметров запроса. Вот несколько примеров:
Здесь также используется метод test_request_context(), который объяснен ниже. Он говорит Flask, как нужно обрабатывать запрос, даже если мы взаимодействуем через шел Python. Почему мы используем построение URL вместо их жесткого задания в шаблонах? На то есть три хорошие причины:
- Реверсирование, зачастую является более описательным методом и позволяет изменять URL на одном дыхании.
- Автоматическое экранирование специальных символов, уникода. Вам даже не придется задумываться над этим.
- Если ваше приложение находится вне корневой URL (например, /myapplication вместо /), функция url_for () будет это правильно обрабатывать для вас.
HTTP методы [ править ]
HTTP (мы говорим о протоколе веб-приложения) знает различные способы доступа к URL-адресам. По умолчанию маршрут реагирует только на ответы GET-запросов, но это можно изменить путем предоставления методов, используя аргументы к декоратору route(). Вот несколько примеров:
Если присутствует GET, тогда HEAD будет добавлен автоматически. Вам не нужно об этом заботиться. Также будьте уверены, что HEAD поддерживает HTTP RFC зависимости, так что вы можете полностью игнорировать HTTP спецификации.
Если вы ничего не знаете про HTTP методы, приводим небольшую справку:
Браузер сообщает серверу, что желает получить информацию со страницы и просит отправить ее. Возможно, это самый распространенный метод.
- HEAD
Браузер сообщает серверу, что желает получить информацию, но интересуется только заголовком, а не содержанием страницы. Приложение допускает запрос, в случае если GET был получен.
- POST
Браузер сообщает серверу, что хочет запостить новую информацию по данному URL и сервер должен быть уверен, что сохранит ее и сделает один раз. Так обычно передается информация из HTML форм на сервер.
Очень схоже с POST, но сервер может инициировать сохранение информации несколько раз, переписывая старые значения более одного раза. Вы можете задаться вопросом: «Для чего это нужно?». Есть несколько хороших причин, чтобы делать это таким образом. Учтите, что соединение может быть потеряно во время передачи: в этой ситуации система между браузером и сервером может затребовать передачу во второй раз. С POST это невозможно, так как запрос возможен только один раз.
- DELETE
Удаление информации в полученной локации.
- OPTIONS
Быстрый способ для клиента выяснить какой из методов поддерживается по данному URL. Начиная с Flask 0.6 эта возможность имплементирована автоматически.
Самое интересное в том, что HTML4 и XHTML1 поддерживают методы GET и POST. Но с использованием JavaScript и будущих стандартов HTML можно использовать другие методы. Кроме того HTTP стал весьма популярным в последнее время и браузеры — уже не единственные клиенты, использующие протокол HTTP. Например, многие системы контроля версий используют его.
Статические файлы [ править ]
Динамическим веб-приложениям также требуются статические файлы. Обычно это css и javascript файлы. В идеале, ваш веб-сервер уже настроен, чтобы их обслуживать, но если вам потребуется, вы можете изменить настройки во Flask. Просто создайте папку с названием static в вашем пакете или рядом с модулем и она будет доступна в /static по применению.
Для генерации адресов для статических файлов, используйте специальное имя ‘static’:
Файл будет доступен в файловой системе по пути static/style.css
Рендеринг шаблонов [ править ]
Создание HTML из Python — это не удовольствие, а громоздкий процесс. Так как HTML обладает своей свободой, вы должны озаботиться безопасностью своего приложения. В связи с этим Flask автоматически настраивает для нас Jinja2 (механизм шаблонов).
Чтобы создать шаблон, можно использовать метод render_template(). Все, что вам нужно сделать, — это указать имя шаблона и переменные, которые вы хотите передать в шаблоны как ключевые аргументы. Вот простой пример того, как сделать шаблон:
Flask будет искать шаблоны в папке шаблонов. Таким образом, если ваше приложение представляет собой модуль, эта папка находится рядом с этим модулем, если же это пакет, то на самом деле внутри вашего пакета:
Случай с модулем:
Случай с пакетом:
Внутри шаблонов, вы также имеете доступ к реквестам, сессиям и g-объектам, а также можете использовать get_flashed_messages() функцию. G-объекты, имеется ввиду, если вам необходимо сохранить информацию для ваших нужд, смотрите документацию «Использование SQLite 3 во Flask».
Шаблоны особенно полезны, если используется наследование. Прочтите документацию как используется наследование в шаблонах. Наследование в шаблонах позволяет сохранить некоторые элементы на каждой страницы (например: заголовок, навигация и футер).
Включено автоматическое экранирование, что позволит избежать проблем, если имя содержит HTML-теги. Если доверяете переменной, а вы знаете, что это будет безопасно в HTML (например, потому что оно пришло от модуля, который преобразует вики-разметки в HTML), вы можете пометить его как безопасный с помощью Markup класса или с помощью |safe фильтра в шаблоне. В документации Jinja 2 представлено несколько примеров.
Вот пример, как работает класс разметки:
Доступ к данным запроса [ править ]
Для веб-приложений крайне важно реагировать на данные клиента отправляя их на сервер. Flask обеспечивает этой информацией — глобальный объект запроса. Если у вас есть некоторый опыт работы с Python, вы можете быть удивлены, как этот объект может быть глобальным, и как Flask удается оставаться потоко-безопасным. Ответ заключается в локальных контекстах:
Локальные контексты (Context Locals) [ править ]
Некоторые объекты во Flask — глобальные, но это не обычный вид глобальных объектов. Эти объекты являются на самом деле прокси к объектам, которые являются локальными для конкретного контекста. Это труднопроизносимо. Но на самом деле довольно легко понять.
Представьте, что контекст обрабатывает поток. Приходит запрос и веб-сервер решает породить новый поток (или что-то другое, основной объект может иметь дело с параллельными системами в отличие от потоков). Когда Flask начинает свою внутреннюю обработку запросов, он выясняет, какой текущий поток является активным контекстом и связывает текущее приложение и WSGI среду в этом контексте (потоке). Он делает это умно, таким образом, чтобы одно приложение может вызвать другое приложение без разрушения.
Итак, что же это значит для вас? В принципе, пока вы тестируете, вы можете полностью это игнорировать. Но вы можете заметить, что код, который зависит от объекта запроса может внезапно сломаться, потому что нет объекта запроса. Решением является создание объекта запроса для себя и привязка его к контексту. Самое простое решение для тестирования, это использование контекст менеджера test_request_context() В сочетании с постановкой, он свяжет тестовый запрос, так что вы можете взаимодействовать с ним. Вот пример:
Другая возможность состоит в передаче всей WSGI среды к методу request_context():
Объект запроса [ править ]
Объект запроса описан в разделе API, и мы не будем рассматривать его здесь подробно (см. запрос). Вот широкий обзор некоторых из наиболее распространенных операций. Прежде всего вы должны импортировать request из Flask:
В настоящее время метод запроса доступен с использованием атрибута method . Чтобы получить доступ к данным формы (данным, передаваемым в POST или PUT запросе), вы можете воспользоваться атрибутом form . Вот полный пример двух атрибутов, упомянутых выше:
Что произойдет, если ключ не существует в виде атрибута? В этом случае выбрасывается исключение KeyError . Вы можете поймать его как обычный KeyError , но если вы не сделаете этого, то вы увидите страницу с ошибкой HTTP 400 Bad Request. Таким образом, для многих ситуаций, вам не придется иметь дело с этой проблемой.
Чтобы получить доступ к параметрам, указанным в URL (?key=value), Вы можете использовать атрибут args :
Мы рекомендуем получать доступ к URL параметрам с использованием метода get или отлавливать KeyError , потому что пользователи могут изменить URL. Страница 400 bad request page в этом случае выглядит не дружественно.
Загрузка файла [ править ]
Через Flask легко использовать загрузку файлов. Просто убедитесь, что не забыли поставить атрибут enctype=»multipart/form-data» в вашей HTML форме, иначе браузер не передаст файлы.
Загруженные файлы сохраняются в память сервера или во временное хранилище в файловой системе. Вы можете получить доступ к этим файлам через атрибут files в объекте запроса. Каждый загруженный файл хранится в этом словаре. Он ведет себя так же, как стандартный объект file в Python, но имеет метод save(), который позволяет сохранить этот файл в файловую систему сервера. Вот простой пример, показывающий, как это работает:
Если вы хотите знать, как файл был назван клиентом, перед тем как он был загружен в ваше приложение, вы можете получить доступ к файлу через атрибут filename . Однако имейте в виду, что это значение может быть фальсифицировано. Если вы все же хотите использовать имя файла, который дал клиент, для хранения файлов на сервере, лучше передать его через secure_filename(), который предлагает Werkzeug:
Cookies [ править ]
Доступ к куки осуществляется через их атрибут. Для установки кукис, используйте метод set_cookie в объектах запроса. Данный атрибут представляет собой словарь со всеми переданными клиентскими кукис. Если вы хотите использовать сессии, то не используете куки напрямую, вместо них лучше использовать сессии Flask, что добавит вам некоторую безопасность поверх кукис.
Обратите внимание, что куки устанавливаются в объектах ответа. Которые обычно возвращаются как строки и Flask конвертируют в их объекты. Если вы хотите влиять на этот процесс, то используйте функцию make_response()
Редиректы и ошибки [ править ]
Для перенаправления пользователей в другое место используйте функцию redirect() А чтобы прервать запрос рано с кодом ошибки используйте функцию abort() .
Это довольно бессмысленный пример, потому что пользователи будут перенаправлены со страницы индекса. Они не смогут получить доступ (получат ошибку 401 — отказано в доступе), но это показывает, как это работает.
По умолчанию черно-белые страницы ошибок показываются в каждом коде ошибок. Если вы хотите настроить страницу ошибки, вы можете использовать декоратор errorhandler()
Об ответах [ править ]
Возвращаемые значения от обозревающей функции автоматически преобразуется в объект-ответ. То есть если возвращаемое значение является строкой, оно конвертируется в объект-ответ со строкой в ответе тела, код ошибки «200 OK» и text/html mimetype. Логика преобразования для возвращаемого значения выглядит следующим образом:
- Если объект-ответ возвращает правильный тип, то это есть прямое возвращение непосредственно от обозревающей функции.
- Если это строка, объект-ответ создается с этими данными и параметрами по умолчанию.
- Если кортеж возвращает элементы в кортеже, то он может предоставить дополнительную информацию. Такие наборы должны быть в форме (response, status, headers), где хотя бы один элемент должен быть в кортеже. Статус значения заменит статус кода и заголовков, которые могут быть списком или словарем в дополнительных значениях заголовка.
- Если ничего из этого не работает, Flask примет возвращаемые значения, как пригодные для применения в WSGI приложении и преобразует их в объекты-ответа.
Если вы хотите заполучить результаты объект-ответ внутри обзора, используйте функцию make_response()
Вам просто нужно обернуть возвращение выражения от make_response() и получить результат объекта, чтобы изменить его, а затем вернуть его обратно:
Сеансы [ править ]
В дополнение к объекту-запроса есть и второй объект под названием сессия, которая сохраняет информацию относящуюся к пользователю от одного запроса к другому. Это осуществляется поверх кукис и записывает куки криптографически. Это означает, что пользователь может посмотреть содержимое кукис, но не изменить его, так как они не знают закрытый ключ, который используется для подписи.
Для того, чтобы использовать сессии вы должны установить секретный ключ. Вот как работают сессии:
escape() — указывается в этом примере, так как в данном случае не используется шаблонизатор.
Как сгенерировать хороший секретный ключ?
Самый простой и наиболее доступный способ, сделать это на основе генератора псевдослучайных чисел.
Небольшое замечание о кукисах основанных на базе сессий: Flask примет значение, положит в объект-сессию и сериализует их в кукисы. Если вы обнаружили, что некоторые значения не сохранились между запросами, то учтите, что кукисы на самом деле активны, и вы не получите четкое сообщение об ошибке, поэтому проверяйте размер куки в ваших ответах на странице по сравнению с размером, который поддерживается веб-браузерами.
Фидбэк, система флэшинга [ править ]
Хорошие приложения и пользовательские интерфейсы, имеют систему обратной связи. Если пользователь не получает достаточно обратной связи, то в конечном итоге, он начнет ненавидеть ваше приложение. Flask дает простой путь, чтобы получить обратную связь с пользователем через флэшинг систему. Флэшинг система в основном записывает сообщения в конце запроса и доступна к нему на следующий (и только на следующий) запрос. Сообщение предоставляется обычно через разметку шаблона.
Для флэш-сообщения используйте метод flash() А чтобы получить сообщение, можете использовать get_flashed_messages(), которые также доступны в шаблонах.
Примеры использования можете посмотреть здесь
Логирование [ править ]
Вы можете оказаться в ситуации, когда вы имеете дело с данными, которые по идее должны быть правильными, но на самом деле это не так. Например, некоторый клиентский код, который посылает HTTP-запрос к серверу. Это может быть вызвано манипуляциями с данными со стороны пользователя, или падение клиентского кода. Вполне нормально ответить на это ошибкой 400 Bad Request, но бывают ситуации, когда несмотря на ошибку, код должен продолжать работать.
Если вы хотите видеть, что произошло что-то подозрительное, используйте логирование.
Подключение WSGI Middlewares [ править ]
Если вы хотите добавить WSGI middleware в ваше приложение, вы можете обернуть его внутри WSGI приложения. Например, если вы хотите добавить middleware от Werkzeug в работе, чтобы обойти ошибки в lighttpd, вы можете сделать это следующим образом:
Учебное пособие [ править ]
Мы назовем наш первый блог Flaskr, не стесняйтесь в выборе имени. В основном мы хотим сделать следующие вещи:
- Позволить пользователю входить и выходить с учетными данными, указанными в конфигурации. Только один пользователь поддерживается.
- Когда пользователь вошел в систему, он может добавить новую запись на страницу, состоящую из текстового названия и некоторого HTML текста. Этот HTML не будет проверен, потому что мы доверяем пользователю.
- Страница отображает все записи в обратном порядке (новые сверху), и пользователь может добавлять новые записи из формы вверху, если он залогинился.
Мы будем использовать напрямую SQLite3, потому что этого достаточно для приложения такого размера. Для приложений большого размера лучше использовать SQLAlchemy, которая обрабатывает подключения к базе данных более разумным способом и дает много возможностей в обработке запросов. Кроме того, есть еще одна из самых популярных баз данных — NoSQL, можно использовать ее, если она вам больше подходит. 
Шаг 0: Создание каталогов [ править ]
Вначале создадим каталоги, необходимые Вашему приложению:
Каталог flaskr не пакет Python, а лишь место размещения наших файлов. Непосредственно в эту папку поместим схему нашей базы данных и основной модуль. Файлы каталога static доступны для пользователей через HTTP, оттуда подгружаются css и javascript файлы. В каталоге templates Flask будет искать Jinja2-шаблоны, которые будут созданы в конце урока.
Шаг 1: Схема базы данных [ править ]
Создадим базу данных. Это не сложно, для этого приложения хватит одной таблицы и поддержки только SQLite. Просто поместим файл следующего содержания:
с именем schema.sql в только что созданный каталог flaskr .
Эта схема состоит из одной таблицы с названием entries . У каждой записи в таблице есть свой идентификатор id , заголовок title и текст text . Id — автоматически увеличивающееся натуральное число и первичный ключ. Два строковых значения не должны быть неопределёнными и пустыми ( not null ).
Шаг 2: Установочный код приложения [ править ]
Имея схему, можно создать модуль приложения. Назовем его flaskr.py , поместив в корень каталога flaskr . В начале добавим нужный список импорта и раздел конфигурационных определений. В небольших приложениях можно размещать определения непосредственно в модуле. Однако, правильнее было бы создать отдельный .ini или .pу файл, впоследствии загружая его или импортируя оттуда значения.
В файле flaskr.py :
Теперь можно создать практическое приложение и инициализировать его с конфигурацией из того же файла flaskr.py :
from_object() проанализирует данный объект (если это строка, то импортирует её) и найдёт все переменные (в верхнем регистре), определённые там. В нашем случае, конфигурация была в нескольких строках кода, приведенных выше. Её можно поместить в отдельный файл.
Обычно, хорошей идеей будет загрузка определений из конфигурационного файла. Это может сделать from_envvar() вместо from_object() .
Для изменения значений по умолчанию таким способом можно установить в переменной окружения FLASKR_SETTINGS название конфигурационного файла для загрузки. Флаг silent («тихо, безмолвно») отключает вывод сообщений Flask при отсутствии такой переменной окружения.
Секретный ключ ( SECRET_KEY ) необходим для безопасности клиентских сессий. Вдумчиво выбирайте ключевые слова: они должны быть настолько сложными, насколько это возможно.
Флаг отладки ( DEBUG ) включает или выключает интерактивный отладчик. Никогда не оставляйте режим отладки активным на производственном сервере, это позволит пользователям выполнять код на нём!
Добавим метод для подключения к указанной базе данных. Он может быть использован для соединения по запросу, а также из интерактивной оболочки Python или скрипта. Этот метод пригодится позже.
Наконец, если нужно запустить этот файл в качестве отдельного приложения, просто добавим в конец строку, запускающую сервер:
Для запуска приложения используйте команду python flaskr.py , выводящую сообщение о том, что сервер запустился, и адрес, по которому следует обращаться. Однако, открыв этот адрес в браузере, получим ошибку «404 Страница не найдена», ведь у нас пока нет содержимого для просмотра. Но на этом сосредоточимся чуть позже. Сначала нам нужна рабочая база данных.
Шаг 3: Создание базы данных [ править ]
Flaskr — приложение на основе базы данных, а, точнее, реляционной базы данных. Такие системы нуждаются в схеме, сообщающей, как хранить информацию. Поэтому, важно создать такую схему перед первым запуском сервера.
Такая схема может быть создана передачей файла schema.sql в sqlite3 :
Минусом этого решения является то, что для установки требуется приложение sqlite3 , которое установлено не в каждой системе. Кроме того, нужно указать путь к базе данных, где можно сделать ошибку. Хорошая идея — добавить функцию, которая инициализирует базу данных в самом приложении.
Желая поступить так, сначала Вы должны импортировать функцию contextlib.closing() из пакета contextlib . При использовании Python 2.5 необходимо импортировать with_statement из пакета __future__ (импорт из __future__ всегда должен быть первым в списке):
Теперь мы можем создать функцию с названием init_db() для инициализации базы данных. Для этого используем функцию connect_db , определённую ранее.
closing() — вспомогательная функция, позволяющая сохранить соединение открытым до конца блока with . Метод open_resource() поддерживает эту функциональность из коробки, так что его можно использовать в этом блоке. Функция открывает файл по пути (ваш flaskr каталог) и позволяет читать из него. Мы используем её здесь для выполнения скрипта с подключением к базе данных.
Соединяясь с базой данных, получаем объект связи (называемый db ), предоставляющий нам курсор cursor с методом для выполнения всего сценария. В конце нужно подтвердить ( commit ) изменения. SQLite3 и другие транзакционные базы данных не подтверждают операций без Вашего особого распоряжения.
Теперь у нас появилась возможность создать базу данных в оболочке Python, импортировав и вызвав созданную функцию:
Поиск и устранение неисправностей [ править ]
Получив сообщение об ошибке, что таблица не может быть найдена, убедитесь, что сделан вызов функции init_db() и правильно указаны названия таблиц (наиболее частая ошибка — путаница с множественным и единственным числом в названиях таблиц).
Шаг 4: Запрос подключения к базе данных [ править ]
Теперь мы знаем, как открыть соединения с базой данных и использовать их в скриптах, но как сделать эти запросы элегантно? Нам понадобится подключение к базе данных во всех наших функциях, так что имеет смысл инициализировать соединения перед каждым запросом и закрыть их после него.
Flask предоставляет такую возможность декораторами before_request() , after_request() и teardown_request() :
Функции, отмеченные before_request() срабатывают до запроса и передаются без аргументов. Функции, отмеченные after_request() вызываются после запроса и передают ответ для отправки клиенту. Они должны вернуть объект-ответ (response object) или другой объект. Но их исполнение не гарантировано при возникновении исключительной ситуации, в таких случаях работают функции с декоратором teardown_request() . Их вызов происходит после того, как ответ был построен. Они не имеют права изменять запрос, их возвращаемые значения игнорируются. Если исключение произошло во время обработки запроса, оно передается для каждой функции, в противном случае, пропускается (передаётся None ).
Мы сохраняем наше текущее подключение к базе данных в специальном объекте g , предоставляемым Flask. Этот объект хранит информацию только для одного запроса и доступен внутри каждой функции. Никогда не храните такие вещи в других объектах, иначе это не будет работать в многопоточной среде. Этот специальный объект g творит некую скрытую магию для самопроверки.
Совет [ править ]
Шаг 5: Функции представления [ править ]
Теперь, когда у нас уже есть соединения с базой данных, мы можем приступить к написанию функций представления. Нам понадобится четыре:
Вывод записей [ править ]
Этот вывод показывает все записи сохраненные в базе данных. Он мониторит корневой каталог приложения и выбирает по заголовку и тексту из базы данных. Запись с наибольшим идентификатором (новейшая запись) будет сверху. Ряды возвращаемые от курсора являются кортежем с колонками, и выбираются специфично по запросу. Это хорошо для небольших приложений, как здесь, но вы можете конвертировать их в словарь. Если вы заинтересованы, чтобы сделать это, то посмотрите как это сделано в Easy Querying.
Эта обзорная функция пропускает записи через словари в шаблоне show_entries.html и возвращает обработанное значение:
Добавление новых записей [ править ]
Эта страницы позволяет залогиненному пользователю добавлять новые записи. Это просто ответ на POST-запрос. Форма для данных показывается на странице отображения записей (show_entries). Если все сработало как надо, мы показываем (flash()) сообщение и производим перенаправление на страницу отображения записей:
Обратите внимание, что мы проверяем, залогинен ли пользователь, по ключу (ключ logged_in существует в пределах сессии и равен True).
Замечание о безопасности: убедитесь, что вы используете знаки вопроса (?) при составлении SQL-запроса, аналогично примеру выше. Если при составлении запроса вы используете форматированные строки, ваше приложение может быть уязвимо к атакам типа sql-injection. См. Using SQLite 3 with Flask
Функции login и logout [ править ]
Эти функции используются для входа и выхода пользователей сайта. Login проверяет имя пользователя и его пароль и устанавливает для сессии параметр logged_in. Если вход пользователя произошел успешно, то значение этого параметра устанавливается равным True, и пользователь перенаправляется обратно на страницу show_entries. Кроме того, пользователю выдается сообщение о том, что он успешно зашел на сайт. Если же происходит ошибка, то шаблон страницы логина выдает сообщение об этом, и запрос к пользователю повторяется.
В свою очередь, функция logout удаляет параметр logged_in из сессии. Здесь мы использовали следующий трюк: если мы будем использовать метод словаря (dict) pop(), и передадим в него второй параметр (значение по умолчанию), то метод удалит ключ из словаря, если он там есть, и не сделает ничего, если его нет. Трюк полезен, потому что нам не нужно проверять, был залогинен ли пользователь.
Шаг 6: Шаблоны [ править ]
Теперь мы можем начать работу с шаблонами. Если мы будем переходить по URL примера прямо сейчас, мы получим исключение, из-за того что Фласк не может найти шаблоны. Шаблоны используют синтаксис Jinja2, по умолчанию включено автоматическое экранирование символов. Это значит, что если вы не разметите значения в коде метками Markup или фильтром |safe в шаблоне, то Jinja2 будет обеспечивать экранирование спецсимволов вроде < или > их XML-эквивалентами.
Мы так же будем пользоваться наследованием шаблонов, что делает возможным повторное использование одного макета сайта на всех его страницах.
Поместите следующие шаблоны в папку templates:
layout.html [ править ]
Этот шаблон содержит основную структуру html, шапку и ссылку на вход на сайт (или на выход, если пользователь уже залогинен). Так же он показывает всплывающие сообщения, если таковые появятся. Блок может быть заменен блоком с таким же именем (body) в шаблоне-наследнике.
Словарь session доступен на уровне шаблонов, и вы можете использовать его для проверки, залогинен ли пользователь. Обратите внимание, что в Jinja вы можете получать отсутствующие атрибуты и элементы объектов/словарей, так что следующий код будет работать, даже если в сессии отсутствует параметр logged_in:
show_entries.html [ править ]
Этот шаблон расширяет предыдущий шаблон layout.html и показывает сообщения нашего блога. Обратите внимание, что цикл for перебирает сообщения, которые мы передали через функцию render_template(). Так же мы выводим форму для функции add_entry и используем POST-запрос.
login.html [ править ]
И наконец, шаблон для входа на сайт, который просто показывает пользователю форму логина:
Шаг 7. Добавляем стиль [ править ]
Теперь, когда все работает, самое время сделать наше приложение стильным. Просто создайте страницу стилей с названием style.css в папке static, которую мы создали раньше:
Бонус: тестируем приложение [ править ]
Теперь, когда вы закончили работу над этим приложением, и все работает как надо, будет хорошей идеей добавить автоматизированные тесты, чтобы упростить будущие модификации. Это приложение используется как пример для выполнения юнит-тестирования в разделе документации Testing Flask Applications. Сходите, посмотрите, как просто тестировать приложения на Flask-e
Flask Tutorial in Visual Studio Code
Flask is a lightweight Python framework for web applications that provides the basics for URL routing and page rendering.
Flask is called a "micro" framework because it doesn’t directly provide features like form validation, database abstraction, authentication, and so on. Such features are instead provided by special Python packages called Flask extensions. The extensions integrate seamlessly with Flask so that they appear as if they were part of Flask itself. For example, Flask doesn’t provide a page template engine, but installing Flask includes the Jinja templating engine by default. For convenience, we typically speak of these defaults as part of Flask.
In this Flask tutorial, you create a simple Flask app with three pages that use a common base template. Along the way, you experience a number of features of Visual Studio Code including using the terminal, the editor, the debugger, code snippets, and more.
The completed code project for this Flask tutorial can be found on GitHub: python-sample-vscode-flask-tutorial.
If you have any problems, you can search for answers or ask a question on the Python extension Discussions Q&A.
Prerequisites
To successfully complete this Flask tutorial, you must do the following (which are the same steps as in the general Python tutorial):
Install a version of Python 3 (for which this tutorial is written). Options include:
- (All operating systems) A download from python.org; typically use the Download button that appears first on the page.
- (Linux) The built-in Python 3 installation works well, but to install other Python packages you must run sudo apt install python3-pip in the terminal.
- (macOS) An installation through Homebrew on macOS using brew install python3 .
- (All operating systems) A download from Anaconda (for data science purposes).
On Windows, make sure the location of your Python interpreter is included in your PATH environment variable. You can check the location by running path at the command prompt. If the Python interpreter’s folder isn’t included, open Windows Settings, search for "environment", select Edit environment variables for your account, then edit the Path variable to include that folder.
Create a project environment for the Flask tutorial
In this section, you will create a virtual environment in which Flask is installed. Using a virtual environment avoids installing Flask into a global Python environment and gives you exact control over the libraries used in an application.
On your file system, create a folder for this tutorial, such as hello_flask .
Open this folder in VS Code by navigating to the folder in a terminal and running code . , or by running VS Code and using the File > Open Folder command.
In VS Code, open the Command Palette (View > Command Palette or ( ⇧⌘P (Windows, Linux Ctrl+Shift+P ) )). Then select the Python: Create Environment command to create a virtual environment in your workspace. Select venv and then the Python environment you want to use to create it.
Note: If you want to create an environment manually, or run into error in the environment creation process, visit the Environments page.
After your virtual environment creation has been completed, run Terminal: Create New Terminal ( ⌃⇧` (Windows, Linux Ctrl+Shift+` ) )) from the Command Palette, which creates a terminal and automatically activates the virtual environment by running its activation script.
Note: On Windows, if your default terminal type is PowerShell, you may see an error that it cannot run activate.ps1 because running scripts is disabled on the system. The error provides a link for information on how to allow scripts. Otherwise, use Terminal: Select Default Profile to set "Command Prompt" or "Git Bash" as your default instead.
Install Flask in the virtual environment by running the following command in the VS Code Terminal:
You now have a self-contained environment ready for writing Flask code. VS Code activates the environment automatically when you use Terminal: Create New Terminal. If you open a separate command prompt or terminal, activate the environment by running source .venv/bin/activate (Linux/macOS) or .venv\Scripts\Activate.ps1 (Windows). You know the environment is activated when the command prompt shows (.venv) at the beginning.
Create and run a minimal Flask app
In VS Code, create a new file in your project folder named app.py using either File > New from the menu, pressing Ctrl+N , or using the new file icon in the Explorer View (shown below).
In app.py , add code to import Flask and create an instance of the Flask object. If you type the code below (instead of using copy-paste), you can observe VS Code’s IntelliSense and auto-completions:
Also in app.py , add a function that returns content, in this case a simple string, and use Flask’s app.route decorator to map the URL route / to that function:
Tip: You can use multiple decorators on the same function, one per line, depending on how many different routes you want to map to the same function.
Save the app.py file ( ⌘S (Windows, Linux Ctrl+S ) ).
In the Integrated Terminal, run the app by entering python -m flask run , which runs the Flask development server. The development server looks for app.py by default. When you run Flask, you should see output similar to the following:
If you see an error that the Flask module cannot be found, make sure you’ve run python -m pip install flask in your virtual environment as described at the end of the previous section.
Also, if you want to run the development server on a different IP address or port, use the host and port command-line arguments, as with —host=0.0.0.0 —port=80 .
To open your default browser to the rendered page, Ctrl+click the http://127.0.0.1:5000/ URL in the terminal.
Observe that when you visit a URL like /, a message appears in the debug terminal showing the HTTP request:
Stop the app by using Ctrl+C in the terminal.
Tip: When using a different filename than app.py , such as webapp.py , you will need to define an environment variable named FLASK_APP and set its value to your chosen file. Flask’s development server then uses the value of FLASK_APP instead of the default file app.py . For more information, see Flask command line interface.
Run the app in the debugger
Debugging gives you the opportunity to pause a running program on a particular line of code. When a program is paused, you can examine variables, run code in the Debug Console panel, and otherwise take advantage of the features described on Debugging. Running the debugger also automatically saves any modified files before the debugging session begins.
Before you begin: Make sure you’ve stopped the running app at the end of the last section by using Ctrl+C in the terminal. If you leave the app running in one terminal, it continues to own the port. As a result, when you run the app in the debugger using the same port, the original running app handles all the requests and you won’t see any activity in the app being debugged and the program won’t stop at breakpoints. In other words, if the debugger doesn’t seem to be working, make sure that no other instance of the app is still running.
Replace the contents of app.py with the following code, which adds a second route and function that you can step through in the debugger:
The decorator used for the new URL route, /hello/<name> , defines an endpoint /hello/ that can accept any additional value. The identifier inside < and > in the route defines a variable that is passed to the function and can be used in your code.
URL routes are case-sensitive. For example, the route /hello/<name> is distinct from /Hello/<name> . If you want the same function to handle both, use decorators for each variant.
As described in the code comments, always filter arbitrary user-provided information to avoid various attacks on your app. In this case, the code filters the name argument to contain only letters, which avoids injection of control characters, HTML, and so forth. (When you use templates in the next section, Flask does automatic filtering and you won’t need this code.)
Set a breakpoint at the first line of code in the hello_there function ( now = datetime.now() ) by doing any one of the following:
- With the cursor on that line, press F9 , or,
- With the cursor on that line, select the Run > Toggle Breakpoint menu command, or,
- Click directly in the margin to the left of the line number (a faded red dot appears when hovering there).
The breakpoint appears as a red dot in the left margin:
Switch to the Run and Debug view in VS Code (using the left-side activity bar or ⇧⌘D (Windows, Linux Ctrl+Shift+D ) ). You may see the message "To customize Run and Debug create a launch.json file". This means that you don’t yet have a launch.json file containing debug configurations. VS Code can create that for you if you click on the create a launch.json file link:
Select the link and VS Code will prompt for a debug configuration. Select Flask from the dropdown and VS Code will populate a new launch.json file with a Flask run configuration. The launch.json file contains a number of debugging configurations, each of which is a separate JSON object within the configuration array.
Scroll down to and examine the configuration, which is named "Python: Flask". This configuration contains "module": "flask", , which tells VS Code to run Python with -m flask when it starts the debugger. It also defines the FLASK_APP environment variable in the env property to identify the startup file, which is app.py by default, but allows you to easily specify a different file. If you want to change the host and/or port, you can use the args array.
Note: If the env entry in your configuration contains "FLASK_APP": "$
/app.py" , change it to "FLASK_APP": "app.py" as shown above. Otherwise you may encounter error messages like "Cannot import module C" where C is the drive letter where your project folder resides.
Note: Once launch.json is created, an Add Configuration button appears in the editor. That button displays a list of additional configurations to add to the beginning of the configuration list. (The Run > Add Configuration menu command does the same action.).
Save launch.json ( ⌘S (Windows, Linux Ctrl+S ) ). In the debug configuration dropdown list select the Python: Flask configuration.
Start the debugger by selecting the Run > Start Debugging menu command, or selecting the green Start Debugging arrow next to the list ( F5 ):
Observe that the status bar changes color to indicate debugging:
A debugging toolbar (shown below) also appears in VS Code containing commands in the following order: Pause (or Continue, F5 ), Step Over ( F10 ), Step Into ( F11 ), Step Out ( ⇧F11 (Windows, Linux Shift+F11 ) ), Restart ( ⇧⌘F5 (Windows, Linux Ctrl+Shift+F5 ) ), and Stop ( ⇧F5 (Windows, Linux Shift+F5 ) ). See VS Code debugging for a description of each command.
Output appears in a "Python Debug Console" terminal. Ctrl+click the http://127.0.0.1:5000/ link in that terminal to open a browser to that URL. In the browser’s address bar, navigate to http://127.0.0.1:5000/hello/VSCode . Before the page renders, VS Code pauses the program at the breakpoint you set. The small yellow arrow on the breakpoint indicates that it’s the next line of code to run.
Use Step Over to run the now = datetime.now() statement.
On the left side of the VS Code window, you see a Variables pane that shows local variables, such as now , as well as arguments, such as name . Below that are panes for Watch, Call Stack, and Breakpoints (see VS Code debugging for details). In the Locals section, try expanding different values. You can also double-click values (or use Enter (Windows, Linux F2 ) ) to modify them. Changing variables such as now , however, can break the program. Developers typically make changes only to correct values when the code didn’t produce the right value to begin with.
When a program is paused, the Debug Console panel (which is different from the "Python Debug Console" in the Terminal panel) lets you experiment with expressions and try out bits of code using the current state of the program. For example, once you’ve stepped over the line now = datetime.now() , you might experiment with different date/time formats. In the editor, select the code that reads now.strftime("%A, %d %B, %Y at %X") , then right-click and select Evaluate in Debug Console to send that code to the debug console, where it runs:
Tip: The Debug Console also shows exceptions from within the app that may not appear in the terminal. For example, if you see a "Paused on exception" message in the Call Stack area of Run and Debug view, switch to the Debug Console to see the exception message.
Copy that line into the > prompt at the bottom of the debug console, and try changing the formatting:
Step through a few more lines of code, if you’d like, then select Continue ( F5 ) to let the program run. The browser window shows the result:
Change the line in the code to use different datetime format, for example now.strftime("%a, %d %b, %y at %X") , and then save the file. The Flask server will automatically reload, which means the changes will be applied without the need to restart the debugger. Refresh the page on the browser to see the update.
Close the browser and stop the debugger when you’re finished. To stop the debugger, use the Stop toolbar button (the red square) or the Run > Stop Debugging command ( ⇧F5 (Windows, Linux Shift+F5 ) ).
Tip: To make it easier to repeatedly navigate to a specific URL like http://127.0.0.1:5000/hello/VSCode , output that URL using a print statement. The URL appears in the terminal where you can use Ctrl+click to open it in a browser.
Go to Definition and Peek Definition commands
During your work with Flask or any other library, you may want to examine the code in those libraries themselves. VS Code provides two convenient commands that navigate directly to the definitions of classes and other objects in any code:
Go to Definition jumps from your code into the code that defines an object. For example, in app.py , right-click on the Flask class (in the line app = Flask(__name__) ) and select Go to Definition (or use F12 ), which navigates to the class definition in the Flask library.
Peek Definition ( ⌥F12 (Windows Alt+F12 , Linux Ctrl+Shift+F10 ) , also on the right-click context menu), is similar, but displays the class definition directly in the editor (making space in the editor window to avoid obscuring any code). Press Escape to close the Peek window or use the x in the upper right corner.
Use a template to render a page
The app you’ve created so far in this tutorial generates only plain text web pages from Python code. Although it’s possible to generate HTML directly in code, developers avoid such a practice because it opens the app to cross-site scripting (XSS) attacks. In the hello_there function of this tutorial, for example, one might think to format the output in code with something like content = "<h1>Hello there, " + clean_name + "!</h1>" , where the result in content is given directly to a browser. This opening allows an attacker to place malicious HTML, including JavaScript code, in the URL that ends up in clean_name and thus ends up being run in the browser.
A much better practice is to keep HTML out of your code entirely by using templates, so that your code is concerned only with data values and not with rendering.
- A template is an HTML file that contains placeholders for values that the code provides at run time. The templating engine takes care of making the substitutions when rendering the page. The code, therefore, concerns itself only with data values and the template concerns itself only with markup.
- The default templating engine for Flask is Jinja, which is installed automatically when you install Flask. This engine provides flexible options including automatic escaping (to prevent XSS attacks) and template inheritance. With inheritance, you can define a base page with common markup and then build upon that base with page-specific additions.
In this section, you create a single page using a template. In the sections that follow, you configure the app to serve static files, and then create multiple pages to the app that each contains a nav bar from a base template.
Inside the hello_flask folder, create a folder named templates , which is where Flask looks for templates by default.
In the templates folder, create a file named hello_there.html with the contents below. This template contains two placeholders named "name" and "date", which are delineated by pairs of curly braces, << and >> . As you can see, you can also include formatting code in the template directly:
Tip: Flask developers often use the flask-babel extension for date formatting, rather than strftime , as flask-babel takes locales and timezones into consideration.
In app.py , import Flask’s render_template function near the top of the file:
Also in app.py , modify the hello_there function to use render_template to load a template and apply the named values (and add a route to recognize the case without a name). render_template assumes that the first argument is relative to the templates folder. Typically, developers name the templates the same as the functions that use them, but matching names are not required because you always refer to the exact filename in your code.
You can see that the code is now much simpler, and concerned only with data values, because the markup and formatting is all contained in the template.
Start the program (inside or outside of the debugger, using ⌃F5 (Windows, Linux Ctrl+F5 ) ), navigate to a /hello/name URL, and observe the results.
Also try navigating to a /hello/name URL using a name like <a%20value%20that%20could%20be%20HTML> to see Flask’s automatic escaping at work. The "name" value shows up as plain text in the browser rather than as rendering an actual element.
Serve static files
Static files are of two types. First are those files like stylesheets to which a page template can just refer directly. Such files can live in any folder in the app, but are commonly placed within a static folder.
The second type are those that you want to address in code, such as when you want to implement an API endpoint that returns a static file. For this purpose, the Flask object contains a built-in method, send_static_file , which generates a response with a static file contained within the app’s static folder.
The following sections demonstrate both types of static files.
Refer to static files in a template
In the hello_flask folder, create a folder named static .
Within the static folder, create a file named site.css with the following contents. After entering this code, also observe the syntax highlighting that VS Code provides for CSS files, including a color preview:
In templates/hello_there.html , add the following line before the </head> tag, which creates a reference to the stylesheet.
Flask’s url_for tag that is used here, creates the appropriate path to the file. Because it can accept variables as arguments, url_for allows you to programmatically control the generated path, if desired.
Also in templates/hello_there.html , replace the contents <body> element with the following markup that uses the message style instead of a <strong> tag (and also displays a message if you just use a hello/ URL without a name):
Run the app, navigate to a /hello/name URL, and observe that the message renders in blue. Stop the app when you’re done.
Serve a static file from code
In the static folder, create a JSON data file named data.json with the following contents (which are meaningless sample data):
In app.py , add a function with the route /api/data that returns the static data file using the send_static_file method:
Run the app and navigate to the /api/data endpoint to see that the static file is returned. Stop the app when you’re done.
Create multiple templates that extend a base template
Because most web apps have more than one page, and because those pages typically share many common elements, developers separate those common elements into a base page template that other page templates can then extend (this is also called template inheritance.)
Also, because you’ll likely create many pages that extend the same template, it’s helpful to create a code snippet in VS Code with which you can quickly initialize new page templates. A snippet helps you avoid tedious and error-prone copy-paste operations.
The following sections walk through different parts of this process.
Create a base page template and styles
A base page template in Flask contains all the shared parts of a set of pages, including references to CSS files, script files, and so forth. Base templates also define one or more block tags that other templates that extend the base are expected to override. A block tag is delineated by <% block <name> %>and <% endblock %>in both the base template and extended templates.
The following steps demonstrate creating a base template.
In the templates folder, create a file named layout.html with the contents below, which contains blocks named "title" and "content". As you can see, the markup defines a simple nav bar structure with links to Home, About, and Contact pages, which you will create in a later section. Each link again uses Flask’s url_for tag to generate a link at runtime for the matching route.
Add the following styles to static/site.css , below the existing "message" style, and save the file. Note that this walkthrough doesn’t attempt to demonstrate responsive design; these styles simply generate a reasonably interesting result.
You can run the app at this point, but because you haven’t made use of the base template anywhere and haven’t changed any code files, the result is the same as the previous step. Complete the remaining sections to see the final effect.
Create a code snippet
Because the three pages you create in the next section extend layout.html , it saves time to create a code snippet to initialize a new template file with the appropriate reference to the base template. A code snippet provides a consistent piece of code from a single source, which avoids errors that can creep in when using copy-paste from existing code.
In VS Code, select File (Code on macOS) > Preferences > Configure User Snippets.
In the list that appears, select html. The option may appear as "html.json" in the Existing Snippets section of the list if you’ve created snippets previously.
After VS Code opens html.json , add the following entry within the existing curly braces (the explanatory comments, not shown here, describe details such as how the $0 line indicates where VS Code places the cursor after inserting a snippet):
Save the html.json file ( ⌘S (Windows, Linux Ctrl+S ) ).
Now, whenever you start typing the snippet’s prefix, such as flext , VS Code provides the snippet as an autocomplete option, as shown in the next section. You can also use the Insert Snippet command to choose a snippet from a menu.
For more information on code snippets in general, refer to Creating snippets.
Use the code snippet to add pages
With the code snippet in place, you can quickly create templates for the Home, About, and Contact pages.
In the templates folder, create a new file named home.html , Then start typing flext to see the snippet appear as a completion:
When you select the completion, the snippet’s code appears with the cursor on the snippet’s insertion point:
At the insertion point in the "title" block, write Home , and in the "content" block, write <p>Home page for the Visual Studio Code Flask tutorial.</p> , then save the file. These lines are the only unique parts of the extended page template:
In the templates folder, create about.html , use the snippet to insert the boilerplate markup, insert About us and <p>About page for the Visual Studio Code Flask tutorial.</p> in the "title" and "content" blocks, respectively, then save the file.
Repeat the previous step to create templates/contact.html using Contact us and <p>Contact page for the Visual Studio Code Flask tutorial.</p> in the two content blocks.
In app.py , add functions for the /about/ and /contact/ routes that refer to their respective page templates. Also modify the home function to use the home.html template.
Run the app
With all the page templates in place, save app.py , run the app, and open a browser to see the results. Navigate between the pages to verify that the page templates are properly extending the base template.
Note: If you’re not seeing the latest changes, you might need to do a hard refresh on the page to avoid seeing a cached file.
Optional activities
The following sections describe additional steps that you might find helpful in your work with Python and Visual Studio Code.
Create a requirements.txt file for the environment
When you share your app code through source control or some other means, it doesn’t make sense to copy all the files in a virtual environment because recipients can always recreate the environment themselves.
Accordingly, developers typically omit the virtual environment folder from source control and instead describe the app’s dependencies using a requirements.txt file.
Although you can create the file by hand, you can also use the pip freeze command to generate the file based on the exact libraries installed in the activated environment:
With your chosen environment selected using the Python: Select Interpreter command, run the Terminal: Create New Terminal command ( ⌃⇧` (Windows, Linux Ctrl+Shift+` ) )) to open a terminal with that environment activated.
In the terminal, run pip freeze > requirements.txt to create the requirements.txt file in your project folder.
Anyone (or any build server) that receives a copy of the project needs only to run the pip install -r requirements.txt command to reinstall the packages in the original environment. (The recipient still needs to create their own virtual environment, however.)
Note: pip freeze lists all the Python packages you have installed in the current environment, including packages you aren’t currently using. The command also lists packages with exact version numbers, which you might want to convert to ranges for more flexibility in the future. For more information, see Requirements Files in the pip command documentation.
Refactor the project to support further development
Throughout this Flask tutorial, all the app code is contained in a single app.py file. To allow for further development and to separate concerns, it’s helpful to refactor the pieces of app.py into separate files.
In your project folder, create a folder for the app, such as hello_app , to separate its files from other project-level files like requirements.txt and the .vscode folder where VS Code stores settings and debug configuration files.
Move the static and templates folders into hello_app , because these folders certainly contain app code.
In the hello_app folder, create a file named views.py that contains the routings and the view functions:
In the hello_app folder, create a file __init__.py with the following contents:
In the hello_app folder, create a file webapp.py with the following contents:
Open the debug configuration file launch.json and update the env property as follows to point to the startup object:
Delete the original app.py file in the project root, as its contents have been moved into other app files.
Your project’s structure should now be similar to the following:
Run the app in the debugger again to make sure everything works. To run the app outside of the VS Code debugger, use the following steps from a terminal:
- Set an environment variable for FLASK_APP . On Linux and macOS, use export set FLASK_APP=webapp ; on Windows use $env:FLASK_APP=webapp if you’re using PowerShell, or set FLASK_APP=webapp if you’re using Command Prompt.
- Navigate into the hello_app folder, then launch the program using python -m flask run .
Create a container for a Flask app using the Docker extension
The Docker extension makes it easy to build, manage, and deploy containerized applications from Visual Studio Code. If you’re interested in learning how to create a Python container for the Flask app developed in this tutorial, check out the Python in a container tutorial, which will walk you through how to:
- Create a Dockerfile file describing a simple Python container.
- Build, run, and verify the functionality of a Flask app.
- Debug the app running in a container.
If you have any problems, you can search for answers or ask a question on the Python extension Discussions Q&A.
Next steps
Congratulations on completing this walkthrough of working with Flask in Visual Studio Code!
The completed code project from this tutorial can be found on GitHub: python-sample-vscode-flask-tutorial.
Because this tutorial has only scratched the surface of page templates, refer to the Jinja2 documentation for more information about templates. The Template Designer Documentation contains all the details on the template language. You might also want to review the official Flask tutorial as well as the documentation for Flask extensions.
To try your app on a production website, check out the tutorial Deploy Python apps to Azure App Service using Docker Containers. Azure also offers a standard container, App Service on Linux, to which you deploy web apps from within VS Code.
You may also want to review the following articles in the VS Code docs that are relevant to Python: