Метод колба: Как применить Цикл Колба в e-learning

Модель Колба и Фрая, обучение основанное на опытеTalent Management

Четырехэтапная цикличная модель Колба и Фрая с примерами из личного опыта, как полезный инструмент пониманиятого как обучаются взрослые люди

Эту статью я написала, чтобы поделиться одной полезной универсальной моделью обучения взрослых людей — моделью Колба и Фрая.

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

Любое  обучение эффективно, только если взрослый человек, во – первых,

самостоятельно стремится что – то узнать и это ему для чего – то очень надо и, во  – вторых, если новые знания и размышления интегрированы в реальный повседневный опыт для получения обратной связи.

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

Есть ещё линейное приращение знаний, которые полезным опытом так и не становятся, а остаются лежать на полочках в голове на уровне концепций и ментальных конструкций. Это про то, когда вроде и знаешь, а применить на практике — не можешь.
Чтобы описать как происходит обучение, основанное на опыте, в 1975 году британские ученые (они, правда, британские)) Колб и Фрай, предложили четырехэтапную цикличную модель.

Модель универсальная и её полезно понимать при планировании любого обучения.

1 этап — Конкретный опыт: момент, когда вы осознаёте, что существует то, чего вы не понимаете или должны понять лучше.

Я давно работаю в качестве главного эйчара и, поначалу, методы мои были вполне традиционными. В какой-то момент я начала осознавать, что доступные мне подходы к формированию мотивации и вовлеченности людей уже не приносят прежних результатов, особенно, когда трудно выразить конечный результат в чётких цифрах или качественных характеристиках. Фактически, они вообще перестают работать. Я столкнулась с тем, что при проведении внутреннего обучения наши тренеры, которые одновременно были менеджерами, вели занятия без заинтересованности в конечном результате. А что касается обучающихся — там всё было совсем грустно. Материал сложный, огромное количество мелких деталей, уникальное ПО. Люди учились формально, несмотря на то, что ошибки вели к браку и, конечно, к снижению зарплаты.

Денежные премии тренерам, как основное средство мотивации, результата не приносили. Я попробовала всякие немонетарные способы поощрения, но кардинально переломить ситуацию не удавалось.

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

2 этап — Осмысление: ряд действий, которые связаны с узнаванием большего, — наблюдение, сбор данных, размышление об опыте и о существующих проблемах.

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

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

И, конечно, о том, как чувствует себя сотрудник после того, как ему об этой ценности сообщили.

3 этап — Концептуализация: этап, на котором у вас начинают формироваться идеи, способные объяснить то, что вы стараетесь понять.

Я начала размышлять обо всех концепциях мотивации, начиная с Герцберга и заканчивая самодетерминацией Деси и Райана. Да, конечно, я знала о проектировании работы, целостности и важности, но это не получалось свести в стройную и понятную для меня модель, которую можно было бы реализовать в конкретной ситуации.  В какой-то момент мне попался ролик с TED-лекцией Дэна Пинка о загадке мотивации, который сильно меня впечатлил, так как всё, что говорил известный учёный в своей лекции, очень перекликалось с теми размышлениями над реальным конкретным опытом, которыми я была занята. Наверное, именно это выступление и было той последней каплей, которая упав, помогла мне глубоко понять какую роль в мотивации людей играют успех и признание их заслуг. Стало понятно, что работать нужно с общей культурой. Поскольку такая работа предполагает целый комплекс сложных и взаимосвязанных действий и занимает годы, а определенные результаты нужны были прямо сейчас, я выделила самые горячие точки и наметила план действий.

4-й этап — Проверка: этап, на котором вы видите, действительно ли вы достигли понимания и действуют ли  ваши идеи на практике.

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

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

Приходим к 1 этапу: Конкретный опыт: момент, когда вы осознаёте, что существует то, чего Вы не понимаете или должны понять лучше.

Весь цикл запускается снова.

Вот так работает модель Колба и Фрая. Надеюсь, эта информация была для вас полезной и поможет в реальной работе.

Как использовать цикл Колба при создании онлайн-курсов? — Личный опыт на vc.ru

4074 просмотров

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

План статьи:

• Что такое стили обучения
• Существующие модели обучения
• Описание модели Д.Колба
• Использование модели Колба для создания онлайн-обучения
• Практические упражнения на разных циклах обучения

Задача этой статьи не рассказать о модели Колба (уверены, что очень много уже написано), а показать какие упраженения можно использовать на разных стадиях обучения в онлайн. Поэтому, тем кто знаком с теорией, рекомендуем сразу переходить ко второй части статьи.

Итак, начнем с определений.

Хорошее определения стилей и стратегий обучения, как нам кажется, дает Cambridge University Press.

Стили обучения — это привычные модели восприятия, обработки или реакции на информацию. Стратегии обучения — это конкретные действия и/или методы, которые человек использует для обучения.

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

Какие существуют модели обучения?

Модель Колба

Теория экспериментального обучения Колба работает на двух уровнях: четырехступенчатый цикл обучения и четыре отдельных стиля обучения. Большая часть теории Колба касается внутренних когнитивных процессов учащегося.

Дэвид Колб описал процесс обучения взрослых, который состоит из четырех этапов:

• Конкретный опыт (КО)
• Мыслительные наблюдения (МН)
• Абстрактная концептуализация (АК)
• Активное экспериментирование (АЭ)

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

• Конвергенция (АК/АЭ)
• Дивегренция (отстранение) (КО/МН)
• Аккомодация (приспособление) (КО/АЭ)
• Ассимиляция (АК/МН)

Что можно использовать из модели Колба при построении онлайн-курсов?

Мы опредили несколько важных составляющих:

• Обязательна должна присутствовать практическая часть.
• В идеальном варианте онлайн-обучение должно начинаться с опыта или воспроизведения ситуации из реальной жизни. В обычных (офлайн) тренингах обучение начинается часто с групповых упражнений, где участники должны реализовать некий свой опыт для решения определенных бизнес-задач. Часто ситуации рассматриваются сложные, чтобы участники тренинга включились в процесс обучения. То есть тренинг начинается с личного опыта и дальше переходит к теории, упражнениям, анализу. Для онлайн-обучения включение опыта, как фазы обучения, можно сделать через симуляцию жизненной ситуации или вопросов, которые обращены к нужному опыту.
• Чередование фаз обучения: опыт – наблюдения – концептуализация – экспериментирование. Как бы не просто звучало это утверждение, но на практике встречаются курсы, которые не используют практические упражнения или построены таким образом, что сначала люди изучают теорию и потом уже выполняют практические упражнения.

Какие упражениня можно использовать на разных стадиях обучения в онлайн-обучении?

Фаза обучения — Конкретный опыт.

В модели Колба нельзя учиться, просто наблюдая или читая о ней. Чтобы эффективно учиться, человек, команда или организация должна переживать опыт или обучаться через опыт.

Конкретный опыт. Инженер https://pixabay.com/

Упражнения в онлайн-обучении

• Предложение вспомнить свою реальную, практическую деятельность
• Групповые задачи на примерах из практики
  
• Индивидуальное решение бизнес-задач
  
• Групповые обсуждения сложных вопросов с вовлечением участников
  
• Ролевые фразы и ролевые игры
  

Фаза обучения. Мыслительные наблюдения.

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

Наблюдения Pixabay. agnessse3

Упражнения в онлайн-обучении

• Призыв к участникам поделиться наблюдением
• Предложение поделиться мнением о примененных технологиях и их эффективности
  
• Анализ ситуации, анализ своего поведения
  
• Обратная связь другим участникам
  

Фаза обучения. Абстрактная концептуализация.

На этом этапе теория должна объяснить закономерности происходящего и как можно улучшить процессы за счет определенных технологий, моделей и идей.

Василий Кандинский Источник: https://ru.wikipedia.org/wiki/

Упражнения в онлайн-обучении

• Рассказ теории
• Приведение фактов
  
• Объяснение моделей и алгоритмов поведения

Фаза обучения. Активное экспериментирование.

На заключительном этапе обучения происходит обдумывание и применение полученных знаний на практике, пересмотр решения бизнес-задач в контексте новой информации.

Cамолет-братья-райт PIxabay

• Применение технологий в моделировании реальных ситуаций
• Ролевые и деловые игры
  
• Решение проблем, case-study
  
• Создание сценариев, презентаций, алгоритмов
  

При проведении упражнений в онлайн-обучении надо также учитывать готовность группы к обучению и уровень сопротивления участников. Цикл Колба является руководством к действию, но не догмой. Поэтому важно сказать, что фазы обучения можно менять местами, подстраиваясь под состояние группы.

Рекомендуем почитать статью Николая Рысёва «Как вести бизнес-тренинги онлайн».

Цикл Колба. Создание тренингов на основе цикла Колба.

В этой статье мы разберем цикл Колба и ее применение на практике.

Цикл Колба – это модель обучения, которая основана на принципе поэтапного формирования умственных действий обучаемого. Принципиальное отличие этой модели заключается в том, что она разработана именно для обучения взрослых людей, которые уже имеют личный опыт в изучении объектов и при этом обладают более устойчивой и выраженной мотивацией к обучению.

Автор методики

Ее автором является специалист по психологии обучения взрослых Дэвид Колб (David A. Kolb). По его мнению, процесс обучения представляет собой цикл или своеобразную спираль. Это своего рода цикл накопления личного опыта, в дальнейшем — обдумывания и размышления, и в итоге — действия. По мнению Девида Колба процесс обучения – это своеобразная спираль, главные этапы который составляют накопление личного опыта, его обдумывание, и последующее действие, которое является результатом.

Цикл Колба предполагает следующие этапы обучения:

1. Конкретный опыт (КО). Данный этап предполагает наличие у человека некоторого личного, конкретного опыта в том аспекте, который он планирует изучить.

2.Мыслительные наблюдения (МН). Данный этап предполагает обдумывание, анализ тех исходных знаний, которые есть у человека.

3.Абстрактная концептуализация (АК). В данном этапе происходит обобщение полученной информации и построение конкретной модели. Именно в этом периоде  тренинга происходит генерация новых идей, выстраивание  взаимосвязей между явлениями и добавления информации о закономерностях в изучаемой теме.

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

На основе принципов обучения Колба разработана схема наиболее эффективного проведения интерактивного обучения:

1. Мотивация и объявление новой темы.Данный этап называется также «проблематизация»  в среде тренеров.
   Его цель заключается в том, что привлечь внимание обучаемых к теме, вызвать интерес, сформировать ощущение значимости данного вопроса. Также на этом этапе используются упражнения, которые могут продемонстрировать участникам недостаток знаний в данной теме и мотивировать их на приобретение новых знаний.

Данный этап занимает 10% времени.

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

Данный этап занимает 20% времени.

3. Изучение нового материала.Это основной этап, который подразумевает получение учащимися новых знаний и умений. Участники получают ответы на те вопросы, которые были озвучены в начале обучения и научаются способам их практического разрешения. В изучении нового материала желательно также использовать упражнения и практические занятия.

Данный этап занимает 50% времени.

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

Данный этап занимает 10% времени.

5. Подведение итогов урока (дебрифинг, рефлексия).Заключительный этап, в ходе которого тренер спрашивает, что было полезно, эффективно, собирает пожелания и побуждает к дальнейшему самостоятельному изучению материала.

Данный этап занимает 10% времени.

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

Типы участников:

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

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

2. Мыслитель(Дивергентный стиль, связка личный опыт-размышления). Этот тип, аналогично Активисту, также любит получать знания в простой форме, в виде непринужденного  общения, однако он не спешит применять их на практике. Он старается разобраться до конца, задавая вопросы и многократно уточняя интересующие детали.

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

3. Теоретик(Ассимилирующий стиль, связка теория-размышления). Этот человек любит разбираться в теории самостоятельно, ценить основательность и структурность. Углубляясь в теорию, он иногда даже не доходит до практики.

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

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

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

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

Быстрый старт — Документация Flask (2.2.x)

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

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

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

 из фляги импорта фляги
приложение = фляга (__имя__)
@приложение.маршрут("/")
определение hello_world():
    вернуть "
Привет, мир!
"
 

Так что же делал этот код?

1. Сначала мы импортировали класс Flask . Экземпляр этот класс будет нашим приложением WSGI.

2. Далее мы создаем экземпляр этого класса. Первый аргумент – это имя модуля или пакета приложения. __имя__ — это удобный ярлык для этого, подходящий для большинства случаев. Это нужно для того, чтобы Flask знал, где искать такие ресурсы, как как шаблоны и статические файлы.

3. Затем мы используем route() декоратор, чтобы рассказать Flask какой URL должен запускать нашу функцию.

4. Функция возвращает сообщение, которое мы хотим отобразить в пользовательском браузер. Тип содержимого по умолчанию — HTML, поэтому HTML в строке будет отображаться браузером.

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

Для запуска приложения используйте фляга команда или python -m колба . Вам нужно сообщить Flask, где находится ваше приложение. с опцией --app .

 $ фляга --app привет запустить
 * Обслуживание приложения Flask «привет»
 * Работает на http://127.0.0.1:5000 (нажмите CTRL+C для выхода)
 

Поведение при обнаружении приложений

В качестве ярлыка, если файл называется app.py или wsgi.py , вы не обязательно использовать --app . Дополнительные сведения см. в разделе Интерфейс командной строки.

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

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

Если другая программа уже использует порт 5000, вы увидите OSError: [Errno 98] или OSError: [WinError 10013] при сервер пытается запуститься. См. Адрес уже используется, чтобы узнать, как справиться с этим.

Внешне видимый сервер

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

Если у вас отключен отладчик или вы доверяете пользователям в вашей сети, вы можете сделать сервер общедоступным, просто добавив --host=0. 0.0.0 в командную строку:

 $ прогон фляги --host=0.0.0.0
 

Это говорит вашей операционной системе прослушивать все общедоступные IP-адреса.

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

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

Предупреждение

Отладчик позволяет выполнять произвольный код Python из браузер. Он защищен штифтом, но по-прежнему представляет собой риск безопасности. Не запускайте сервер разработки или отладчик в производственная среда.

Чтобы включить режим отладки, используйте параметр --debug .

 $ flask --app hello --debug run
 * Обслуживание приложения Flask «привет»
 * Режим отладки: включен
 * Работает на http://127.0.0.1:5000 (нажмите CTRL+C для выхода)
 * Перезагрузка со статистикой
 * Отладчик активен!
 * PIN-код отладчика: nnn-nnn-nnn
 

См. также:

• Сервер разработки и интерфейс командной строки для получения информации о работе в режиме отладки.

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

• Logging and Handling Application Errors для регистрации ошибок и отображения хорошие страницы ошибок.

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

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

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

 из побега импорта markupsafe
@app.route("/<имя>")
привет привет (имя):
    return f"Привет, {escape(имя)}!"
 

Если пользователю удалось отправить имя , экранирование заставляет его отображаться как текст, а не запускать скрипт в браузере пользователя.

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

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

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

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

 @app.route('/')
индекс определения():
    вернуть 'Индексную страницу'
@app.route('/привет')
привет ():
    вернуть «Привет, мир»
 

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

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

Вы можете добавить переменные разделы в URL-адрес, пометив разделы <имя_переменной> . Затем ваша функция получает в качестве аргумента ключевого слова. При желании вы можете использовать конвертер для указания типа аргумента типа .

 из побега импорта markupsafe
@app.route('/пользователь/<имя пользователя>')
def show_user_profile (имя пользователя):
    # показать профиль пользователя для этого пользователя
    return f'Пользователь {escape(имя пользователя)}'
@app.route('/post/')
деф show_post (post_id):
    # показать пост с заданным id, id целое число
    вернуть f'Post {post_id}'
@app.route('/путь/<путь:подпуть>')
def show_subpath (подпуть):
    # показать подпуть после /path/
    return f'Подпуть {escape(подпуть)}'
 

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

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

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

 @app.route('/проекты/')
деф проекты():
    вернуть 'Страница проекта'
@app.route('/о')
защита о():
    вернуть 'О странице'
 

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

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

URL-адрес здания

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

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

1. Реверсирование часто более описательно, чем жесткое кодирование URL-адресов.

2. Вы можете изменить свои URL-адреса за один раз, вместо того, чтобы помнить об этом. вручную изменить жестко закодированные URL-адреса.

3. Создание URL прозрачно обрабатывает экранирование специальных символов.

4. Сгенерированные пути всегда абсолютны, что позволяет избежать неожиданного поведения относительных путей в браузерах.

5. Если ваше приложение размещено за пределами корня URL, например, в /myapplication вместо /, url_for() правильно обрабатывает это для вас.

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

 из flask import url_for
@app.route('/')
индекс определения():
    вернуть «индекс»
@app.route('/логин')
деф логин():
    вернуть «логин»
@app.route('/пользователь/<имя пользователя>')
профиль защиты (имя пользователя):
    вернуть профиль f'{имя пользователя}\'
с app.test_request_context():
    печать (url_for ('индекс'))
    печать (url_for ('логин'))
    печать (url_for ('логин', следующий = '/'))
    print(url_for('профиль', имя пользователя='Джон Доу'))
 

 /
/авторизоваться
/логин?следующий=/
/пользователь/Джон%20Доу
 

Методы HTTP

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

 из запроса на импорт фляги
@app.route('/логин', методы=['GET', 'POST'])
деф логин():
    если request.method == 'POST':
        вернуть do_the_login()
    еще:
        вернуть show_the_login_form()
 

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

Вы также можете разделить представления для разных методов на разные функции. Flask предоставляет ярлык для украшения таких маршрутов с помощью get() , post() и т. д. для каждого общий HTTP-метод.

 @app.get('/логин')
деф логин_получить():
    вернуть show_the_login_form()
@app.post('/логин')
деф логин_пост():
    вернуть do_the_login()
 

Если присутствует GET , Flask автоматически добавляет поддержку метода HEAD и обрабатывает запросов HEAD в соответствии с HTTP RFC. Так же, ВАРИАНТЫ автоматически внедряются для вас.

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

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

Чтобы сгенерировать URL-адреса для статических файлов, используйте специальное «статическое» имя конечной точки :

 url_for('статический', имя файла='style.css')
 

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

Шаблоны визуализации

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

Шаблоны можно использовать для создания любого типа текстового файла. Для веб-приложений вы в первую очередь для создания HTML-страниц, но вы также можете создавать уценку, обычный текст для электронная почта, что-нибудь еще.

Справку по HTML, CSS и другим веб-API см. в веб-документах MDN.

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

 из фляги импорта render_template
@app.route('/привет/')
@app.route('/hello/<имя>')
привет привет (имя = нет):
    вернуть render_template('hello.html', имя=имя)
 

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

Корпус 1 : модуль:

 /application. py
/шаблоны
    /hello.html
 

Чемодан 2 : упаковка:

 /заявка
    /__init__.py
    /шаблоны
        /hello.html
 

Для шаблонов вы можете использовать всю мощь шаблонов Jinja2. Голова в официальной документации по шаблону Jinja2 для получения дополнительной информации.

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

 

{% если имя%}
   
Здравствуйте, {{ имя }}!
 
{% еще %}
   
Привет, мир!
 
{% конец%}
 

Внутри шаблонов у вас также есть доступ к конфигурации , запрос , сеанс и г 1 объекты а также функции url_for() и get_flashed_messages() .

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

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

Вот основное введение в то, как Наценка класс работ:

 >>> из импорта markupsafe
>>> Markup('Привет, %s!') % 'хакер'
Разметка('Привет, <blink>hacker</blink>!')
>>> Markup.escape('хакер')
Разметка('<blink>hacker</blink>')
>>> Разметка('Размечено » HTML').striptags()
«Размеченный » HTML»
 

Изменено в версии 0.5: Автоматическое экранирование больше не включено для всех шаблонов. Следующее расширения для шаблонов вызывают автоматическое экранирование: .html , .htm , .xml , .xhtml . Шаблоны, загруженные из строки, будут иметь автоматическое экранирование отключено.

1

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

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

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

Локальные значения контекста

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

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

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

 из запроса на импорт фляги
с app.test_request_context('/hello', method='POST'):
    # теперь вы можете что-то делать с запросом, пока не
    # конец блока with, например основные утверждения:
    утверждать request.path == '/ привет'
    утверждать request.method == 'POST'
 

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

 с app.request_context(среда):
    утверждать request.method == 'POST'
 

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

Объект запроса задокументирован в разделе API, и мы не будем рассматривать его. это здесь подробно (см. Запрос ). Вот общий обзор некоторые из наиболее распространенных операций. Прежде всего, вы должны импортировать его из фляга модуль :

 из запроса на импорт фляги
 

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

 @app.route('/логин', методы=['POST', 'GET'])
деф логин():
    ошибка = Нет
    если request.method == 'POST':
        если действительный_логин (запрос. форма ['имя пользователя'],
                       request.form['пароль']):
            вернуть log_the_user_in (запрос. форма ['имя пользователя'])
        еще:
            ошибка = 'Неверное имя пользователя/пароль'
    # приведенный ниже код выполняется, если метод запроса
    # был GET или учетные данные недействительны
    вернуть render_template('login.html', ошибка=ошибка)
 

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

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

 поисковое слово = request.args.get('ключ', '')
 

Мы рекомендуем получить доступ к параметрам URL с помощью получить или перехватить KeyError , потому что пользователи могут изменить URL-адрес и представить им 400 страница плохого запроса в этом случае неудобна для пользователя.

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

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

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

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

 из запроса на импорт фляги
@app.route('/upload', методы=['GET', 'POST'])
защита загружаемого_файла():
    если request.method == 'POST':
        f = request.files['the_file']
        f.save('/var/www/uploads/uploaded_file.txt')
    ...
 

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

 из werkzeug. utils import secure_filename
@app.route('/upload', методы=['GET', 'POST'])
защита загружаемого_файла():
    если request.method == 'POST':
        файл = запрос.файлы['the_file']
        file.save(f"/var/www/uploads/{secure_filename(file.filename)}")
    ...
 

Несколько лучших примеров см. в разделе Загрузка файлов.

Печенье

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

Чтение файлов cookie:

 из запроса на импорт фляги
@app.route('/')
индекс определения():
    имя пользователя = request.cookies.get('имя пользователя')
    # используйте cookies. get(key) вместо cookies[key], чтобы не получать
    # KeyError, если файл cookie отсутствует.
 

Хранение файлов cookie:

 из фляги импортировать make_response
@app.route('/')
индекс определения():
    resp = make_response(render_template(...))
    resp.set_cookie('имя пользователя', 'имя пользователя')
    возврат соответственно
 

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

Иногда может потребоваться установить файл cookie в момент, когда ответ объект еще не существует. Это возможно за счет использования Шаблон отложенных обратных вызовов запроса.

Для этого также см. Об ответах.

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

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

 от прерывания импорта фляги, перенаправления, url_for
@app. route('/')
индекс определения():
    вернуть перенаправление (url_for ('логин'))
@app.route('/логин')
деф логин():
    прервать(401)
    this_is_never_executed()
 

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

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

 из фляги импорта render_template
@app.errorhandler(404)
деф page_not_found (ошибка):
    вернуть render_template('page_not_found.html'), 404
 

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

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

Об ответах

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

1. Если возвращается объект ответа правильного типа, он сразу вернулся с просмотра.

2. Если это строка, объект ответа создается с этими данными и параметры по умолчанию.

3. Если это итератор или генератор, возвращающий строки или байты, это рассматривается как потоковый ответ.

4. Если это словарь или список, объект ответа создается с использованием jsonify() .

5. Если кортеж возвращается, элементы в кортеже могут предоставить дополнительные Информация. Такие кортежи должны быть в форме (ответ, статус) , (ответ, заголовки) или (ответ, статус, заголовки) . Статус 9Значение 0016 будет переопределять код состояния и заголовков могут быть списком или словарем дополнительные значения заголовка.

6. Если ничего из этого не работает, Flask будет считать, что возвращаемое значение является допустимое приложение WSGI и преобразовать его в объект ответа.

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

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

 из фляги импорта render_template
@app.errorhandler(404)
определение не найдено (ошибка):
    вернуть render_template('error.html'), 404
 

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

 из фляги импортировать make_response
@app. errorhandler(404)
определение не найдено (ошибка):
    resp = make_response(render_template('error.html'), 404)
    resp.headers['X-Something'] = 'Значение'
    возврат соответственно
 

API с JSON

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

 @app.route("/me")
определение me_api():
    пользователь = get_current_user()
    возвращаться {
        "имя пользователя": user.username,
        "тема": user.theme,
        "изображение": url_for ("user_image", имя файла = user.image),
    }
@app.route("/пользователи")
защита пользователей_апи():
    пользователи = get_all_users()
    вернуть [user.to_json() для пользователя в пользователях]
 

Это ярлык для передачи данных в jsonify() , которая сериализует все поддерживаемые Тип данных JSON. Это означает, что все данные в словаре или списке должны быть Сериализуемый JSON.

Для сложных типов, таких как модели баз данных, вам понадобится библиотека сериализации, чтобы сначала преобразовать данные в допустимые типы JSON. Существует множество библиотек сериализации и расширений Flask API. поддерживается сообществом, которое поддерживает более сложные приложения.

сеансов

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

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

 из сеанса импорта фляги
# Установить секретный ключ на несколько случайных байтов. Держите это в секрете!
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'
@app. route('/')
индекс определения():
    если «имя пользователя» в сеансе:
        return f'Вы вошли как {session["username"]}'
    вернуть 'Вы не вошли в систему'
@app.route('/логин', методы=['GET', 'POST'])
деф логин():
    если request.method == 'POST':
        сеанс['имя пользователя'] = request.form['имя пользователя']
        вернуть перенаправление (url_for ('индекс'))
    возвращаться '''
        <метод формы="сообщение">
            

            

        
    '''
@app.route('/выход из системы')
выход из системы ():
    # удалить имя пользователя из сеанса, если оно там есть
    session.pop('имя пользователя', нет)
    вернуть перенаправление (url_for ('индекс'))
 

Как генерировать хорошие секретные ключи

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

 $ python -c 'импорт секретов; печать (secrets.token_hex())'
'192b9bdd22ab9ed4d12e236c78afcb9a393ec15f71bbf5dc987d54727823bcbf'
 

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

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

Мигающее сообщение

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

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

Регистрация

 app.logger.debug('Значение для отладки')
app.logger.warning('Произошло предупреждение (%d яблок)', 42)
app.logger.error('Произошла ошибка')
 

 из werkzeug.middleware.proxy_fix импортировать ProxyFix
app. wsgi_app = ProxyFix(app.wsgi_app)
 

 $ фляга --app привет запустить
 * Сервисное приложение Flask "привет"
 * Работает на http://127.0.0.1:5000/ (для выхода нажмите CTRL+C)
 

 $ flask --app hello --debug run
 * Сервисное приложение Flask "привет"
 * Режим отладки: включен
 * Работает на http://127.0.0.1:5000/ (для выхода нажмите CTRL+C)
 * Перезагрузка с помощью reloader inotify
 * Отладчик активен!
 * PIN-код отладчика: 223-456-919
 

 $ flask run --extra-files file1:dirA/file2:dirB/
 * Работает на http://127.0.0.1:8000/
 * Обнаружено изменение в '/path/to/file1', перезагрузка
 

 $ корпус фляги
Python 3.10.0 (по умолчанию, 27 октября 2021 г., 06:59:51) [GCC 11.1.0] в Linux
Приложение: пример [производство]
Экземпляр: /home/david/Projects/pallets/flask/instance
>>>
 

 $ экспорт FLASK_RUN_PORT=8000
$ фляжка
 * Работает на http://127. 0.0.1:8000/
 

$ прогон фляги
 * Совет: присутствуют файлы .env. Сделайте «pip install python-dotenv», чтобы использовать их.
 

 $ экспорт FLASK_SKIP_DOTENV=1
$ фляжка
 

 $ export FLASK_APP=hello
 

 импорт нажмите
из фляги импорт фляги
приложение = фляга (__имя__)
@app.cli.command("создать-пользователя")
@click.argument("имя")
деф create_user (имя):
    ...
 

 $ flask создать пользователя-админа
 

 импорт нажмите
из фляги импорт фляги
из flask.cli импортировать группу приложений
приложение = фляга (__имя__)
user_cli = группа приложений («пользователь»)
@user_cli.command('создать')
@click.argument('имя')
деф create_user (имя):
    ...
app.cli.add_command(user_cli)
 

 $ пользователь фляги создает демонстрацию
 

 из фляги импорта Blueprint
bp = Blueprint('студенты', __name__)
@bp.cli.command('создать')
@click. argument('имя')
деф создать (имя):
    ...
app.register_blueprint (бп)
 

 $ ученики фляги создают Алису
 

 п.н. = Blueprint('студенты', __name__, cli_group='other')
# или же
app.register_blueprint (bp, cli_group = 'другое')
 

$ фляга другое создание алиса
 

 п.н. = Blueprint('студенты', __name__, cli_group=Нет)
# или же
app.register_blueprint (bp, cli_group = нет)
 

$ фляга создать алису
 

 импорт нажмите
из flask.cli импортировать with_appcontext
@click.command()
@with_appcontext
определение do_work():
    ...
app.cli.add_command(do_work)
 

 из настройки импорта setuptools
настраивать(
    имя = 'фласк-мое-расширение',
    ...,
    entry_points={
        'фласк.команды': [
            'моя-команда = flask_my_extension.commands:cli'
        ],
    },
)
 

 импорт нажмите
@click.command()
деф кли():
    ...
 

 импорт нажмите
из фляги импорт фляги
из flask.cli импортировать FlaskGroup
определение create_app():
    приложение = Фласк('вики')
    # другая установка
    вернуть приложение
@click.group(cls=FlaskGroup, create_app=create_app)
деф кли():
    """Скрипт управления вики-приложением."""
 

 из настройки импорта setuptools
настраивать(
    имя = 'фласк-мое-расширение',
    ...,
    entry_points={
        'консольные_скрипты': [
            'вики=вики:кли'
        ],
    },
)
 

 $ pip install -e .
$ вики запустить
 

 из фляги импорта фляги
приложение = фляга (__имя__)
@app.route('/')
определение hello_world():
    вернуться 'Привет, мир!'
 

 $ экспорт FLASK_APP=hello. py
$ фляжка
 * Работает на http://127.0.0.1:5000/
 

 C:\путь\к\приложению>установить FLASK_APP=hello.py
 

 PS C:\путь\к\приложению> $env:FLASK_APP = "hello.py"
 

 $ экспорт FLASK_APP=hello.py
$ python -m запустить колбу
 * Работает на http://127.0.0.1:5000/
 

 $ flask run --host=0.0.0.0
 

 $ экспорт FLASK_ENV=развитие
$ фляжка
 

 @app.route('/')
индекс определения():
    вернуть 'Индексную страницу'
@app.route('/привет')
привет ():
    вернуть «Привет, мир»
 

 из побега импорта markupsafe
@app.route('/пользователь/<имя пользователя>')
def show_user_profile (имя пользователя):
    # показать профиль пользователя для этого пользователя
    return 'Пользователь %s' % escape(имя пользователя)
@app. route('/post/')
деф show_post (post_id):
    # показать пост с заданным id, id целое число
    вернуть 'Пост %d' % post_id
@app.route('/путь/<путь:подпуть>')
def show_subpath (подпуть):
    # показать подпуть после /path/
    return 'Подпуть %s' % escape(подпуть)
 

 @app.route('/проекты/')
деф проекты():
    вернуть 'Страница проекта'
@app.route('/о')
защита о():
    вернуть 'О странице'
 

 из фляги импорта фляги, url_for
побег от импорта markupsafe
приложение = фляга (__имя__)
@app.route('/')
индекс определения():
    вернуть «индекс»
@app.route('/логин')
деф логин():
    вернуть «логин»
@app.route('/пользователь/<имя пользователя>')
профиль защиты (имя пользователя):
    вернуть 'профиль {}\'.format(escape(имя пользователя))
с app.test_request_context():
    печать (url_for ('индекс'))
    печать (url_for ('логин'))
    печать (url_for ('логин', следующий = '/'))
    print(url_for('профиль', имя пользователя='Джон Доу'))
 

 /
/авторизоваться
/логин?следующий=/
/пользователь/Джон%20Доу
 

 из запроса на импорт фляги
@app.route('/логин', методы=['GET', 'POST'])
деф логин():
    если request.method == 'POST':
        вернуть do_the_login()
    еще:
        вернуть show_the_login_form()
 

 url_for('статический', имя файла='style.css')
 

 из фляги импорта render_template
@app.route('/привет/')
@app.route('/hello/<имя>')
привет привет (имя = нет):
    вернуть render_template('hello. html', имя=имя)
 

 /application.py
/шаблоны
    /hello.html
 

 /заявка
    /__init__.py
    /шаблоны
        /hello.html
 

 

{% если имя%}
   
Здравствуйте, {{ имя }}!
 
{% еще %}
   
Привет, мир!
 
{% конец%}
 

 >>> из импорта markupsafe
>>> Markup('Привет, %s!') % 'хакер'
Разметка(u'Привет, <blink>hacker</blink>!')
>>> Markup. escape('хакер')
Разметка(u'<blink>hacker</blink>')
>>> Разметка('Размечено » HTML').striptags()
u'Размеченный \xbb HTML'
 

 из запроса на импорт фляги
с app.test_request_context('/hello', method='POST'):
    # теперь вы можете что-то делать с запросом, пока не
    # конец блока with, например основные утверждения:
    утверждать request.path == '/ привет'
    утверждать request.method == 'POST'
 

 из запроса на импорт фляги
с app.request_context(среда):
    утверждать request.method == 'POST'
 

 из запроса на импорт фляги
 

 @app.route('/логин', методы=['POST', 'GET'])
деф логин():
    ошибка = Нет
    если request.method == 'POST':
        если действительный_логин (запрос. форма ['имя пользователя'],
                       request.form['пароль']):
            вернуть log_the_user_in (запрос. форма ['имя пользователя'])
        еще:
            ошибка = 'Неверное имя пользователя/пароль'
    # приведенный ниже код выполняется, если метод запроса
    # был GET или учетные данные недействительны
    вернуть render_template('login. html', ошибка=ошибка)
 

 поисковое слово = request.args.get('ключ', '')
 

 из запроса на импорт фляги
@app.route('/upload', методы=['GET', 'POST'])
защита загружаемого_файла():
    если request.method == 'POST':
        f = request.files['the_file']
        f.save('/var/www/uploads/uploaded_file.txt')
    ...
 

 из запроса на импорт фляги
из werkzeug.utils импортировать secure_filename
@app.route('/upload', методы=['GET', 'POST'])
защита загружаемого_файла():
    если request.method == 'POST':
        f = request.files['the_file']
        f.save('/var/www/uploads/' + secure_filename(f.filename))
    ...
 

 из запроса на импорт фляги
@app.route('/')
индекс определения():
    имя пользователя = request.cookies.get('имя пользователя')
    # используйте cookies.get(key) вместо cookies[key], чтобы не получать
    # KeyError, если файл cookie отсутствует.
 

 из фляги импортировать make_response
@app.route('/')
индекс определения():
    resp = make_response(render_template(...))
    resp.set_cookie('имя пользователя', 'имя пользователя')
    возврат соответственно
 

 от прерывания импорта фляги, перенаправления, url_for
@app.route('/')
индекс определения():
    вернуть перенаправление (url_for ('логин'))
@app.route('/логин')
деф логин():
    прервать(401)
    this_is_never_executed()
 

 из фляги импорта render_template
@app.errorhandler(404)
деф page_not_found (ошибка):
    вернуть render_template('page_not_found.html'), 404
 

 @app.errorhandler(404)
определение не найдено (ошибка):
    вернуть render_template('error.html'), 404
 

 @app.errorhandler(404)
определение не найдено (ошибка):
    resp = make_response(render_template('error.html'), 404)
    resp.headers['X-Something'] = 'Значение'
    возврат соответственно
 

 @app.route("/me")
определение me_api():
    пользователь = get_current_user()
    возвращаться {
        "имя пользователя": user. username,
        "тема": user.theme,
        "изображение": url_for ("user_image", имя файла = user.image),
    }
 

 @app.route("/пользователи")
защита пользователей_апи():
    пользователи = get_all_users()
    return jsonify([user.to_json() для пользователя среди пользователей])
 

 из flask import Flask, сеанс, перенаправление, url_for, запрос
побег от импорта markupsafe
приложение = фляга (__имя__)
# Установить секретный ключ на несколько случайных байтов. Держите это в секрете!
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'
@app.route('/')
индекс определения():
    если «имя пользователя» в сеансе:
        return 'Вошел в систему как %s' % escape(session['username'])
    вернуть 'Вы не вошли в систему'
@app.route('/логин', методы=['GET', 'POST'])
деф логин():
    если request.method == 'POST':
        сеанс['имя пользователя'] = request.form['имя пользователя']
        вернуть перенаправление (url_for ('индекс'))
    возвращаться '''
        <метод формы="сообщение">
            

            

        
    '''
@app.route('/выход из системы')
выход из системы ():
    # удалить имя пользователя из сеанса, если оно там есть
    session. pop('имя пользователя', нет)
    вернуть перенаправление (url_for ('индекс'))
 

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

 app.logger.debug('Значение для отладки')
app.logger.warning('Произошло предупреждение (%d яблок)', 42)
app.logger.error('Произошла ошибка')
 

 из werkzeug.middleware.proxy_fix импортировать ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)