@app.route('/api/v1', методы=["GET"]) 
 @app. route('/api/v1/', методы=["GET"]) 
 def info_view(): 
 #бла-бла-бла еще код 
 

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

Запросы Flask и БД

По своей сути работа веб-фреймворка заключается в обработке входящих HTTP-запросов и возврате HTTP-ответов. Представление, написанное ранее, на самом деле не имеет ничего общего с HTTP-запросами, кроме URI, к которому осуществляется доступ. Он не обрабатывает никаких данных. Давайте посмотрим, как ведет себя Flask, когда данные нуждаются в обработке.

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

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

 
 @app.route('/a/sample//route) 
 def some_view(variable): 
     # какой-то код бла-бла-бла 
 

Для связи с базой данных в представлении необходимо использовать объект db , который был заполнен в начале скрипта. Его атрибут сеанса — это ваше подключение к базе данных, когда вы хотите внести изменения.Если вы просто хотите запросить объекты, объекты, созданные из db. Model , имеют свой собственный уровень взаимодействия с базой данных через атрибут запроса .

Наконец, любой ответ, который вы хотите от представления, более сложного, чем строка, должен быть создан преднамеренно. Раньше вы строили ответ, используя словарь «jsonified», но были сделаны определенные предположения (например, код состояния 200, сообщение о состоянии «ОК», Content-Type «text/plain»). Любой особый соус, который вы хотите добавить в свой HTTP-ответ, должен быть добавлен намеренно.

Зная эти факты о работе с представлениями Flask, вы сможете создать представление, задачей которого является создание новых объектов Task . Давайте посмотрим на код (ниже) и рассмотрим его по частям.

from datetime import datetime 
 from flask import request, Response 
 from flask_sqlalchemy import SQLAlchemy 
 import json 
 from .models import Task, User 
 
 app = Flask(__name__) 
 app.config['SQLALCHEMY_DATABASE_URI'] = os. environ.get ('DATABASE_URL', '') 
 db = SQLAlchemy(приложение) 
 
 INCOMING_DATE_FMT = '%d/%m/%Y %H:%M:%S' 
 
 @app.route('/api/v1/accounts//tasks', method=['POST']) 
 def create_task(username): 
     """Создать задачу для одного пользователя."" 
     user = Пользователь .query.filter_by(username=username).first() 
     if user: 
         task = Task( 
             name=request.form['name'], 
             note=request.form['note'], 
      .now(), 
             due_date=datetime.strptime(due_date, INCOMING_DATE_FMT) if due_date else Нет, 
             Completed=bool(request.form['completed']), 
             user_id=user.id, 
         ) 
         db.session.add(task) 
         db.session.commit() 
           response = {'msg'}: 0   output = {'msg'}: 0   output = {'msg'}: 0   output = {'msg'}: 0  ( 
             mimetype="application/json", 
             response=json.dumps(output), 
             status=201 
         ) 
           return response 
 

Начнем с декоратора @app. route . Маршрут — '/api/v1/accounts//tasks' , где — это переменная маршрута.Поместите в угловые скобки любую часть маршрута, которую вы хотите сделать переменной, затем включите эту часть маршрута на следующей строке в список параметров с тем же именем . Единственными параметрами, которые должны быть в списке параметров, должны быть переменные в вашем маршруте.

Далее идет запрос:

  пользователь = User.query.filter_by(username=username).first()
  

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

 
 задача = задача( 
     имя=запрос.форма['имя'], 
     примечание=запрос.форма['примечание'], 
     создание_дата=datetime.now(), 
     due_date=datetime.strptime(due_date, INCOMING_DATE_FMT), если due_date else Нет, 
    complete=bool(request.form['completed']), 
     user_id=user.id, 
 ) 
 

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

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

 
 db.session.add(задача) 
 db.session.commit() 
 

Создание нового экземпляра Task — это здорово, но его конструкция не имеет встроенной связи с таблицами в базе данных. Чтобы вставить новую строку в соответствующую таблицу SQL, вы должны использовать сеанс , прикрепленный к объекту db . db.session.add(task) создает новый экземпляр Task для добавления в таблицу, но еще не добавляет его. Хотя здесь это делается только один раз, вы можете добавить столько вещей, сколько хотите, перед фиксацией. db.session.commit() принимает все поэтапные изменения или «фиксирует» и применяет их к соответствующим таблицам в базе данных.

 
 output = {'msg': 'posted'} 
 response = Response( 
     mimetype="application/json", 
     response=json.дампы(выход), 
     status=201 
 ) 
 

Ответ является фактическим экземпляром объекта Response с его mimetype , телом и статусом , установленными преднамеренно. Цель этого представления — предупредить пользователя о том, что он создал что-то новое. Видя, как это представление должно быть частью внутреннего API, который отправляет и получает JSON, тело ответа должно быть сериализуемым JSON. Словаря с простым строковым сообщением должно хватить. Убедитесь, что он готов к передаче, вызвав json.сбрасывает в ваш словарь, что превратит ваш объект Python в действительный JSON. Это используется вместо jsonify , поскольку jsonify создает фактический объект ответа, используя его ввод в качестве тела ответа. Напротив, json.dumps просто берет заданный объект Python и, если возможно, преобразует его в допустимую строку JSON.

По умолчанию код состояния любого ответа, отправленного с помощью Flask, будет 200 . Это будет работать в большинстве случаев, когда вы не пытаетесь отправить обратно сообщение определенного уровня перенаправления или уровня ошибки.Так как этот случай явно сообщает интерфейсу, когда был создан новый элемент, установите код состояния 201 , что соответствует созданию нового элемента.

И все! Это базовое представление для создания нового объекта Task в Flask с учетом текущей настройки вашего приложения To-Do List. Подобные представления могут быть созданы для перечисления, редактирования и удаления задач, но этот пример дает представление о том, как это можно сделать.

Большая картина

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

Узнайте больше о Python на PyCon Cleveland 2018.

Макет проекта — Документация Flask (2.0.x)

Создайте каталог проекта и введите его:

 $ mkdir фляга-учебник
$ cd фляга-учебник
 

Затем следуйте инструкциям по установке, чтобы установить создайте виртуальную среду Python и установите Flask для своего проекта.

В учебнике предполагается, что вы работаете с flask-tutorial каталог с этого момента. Имена файлов в верхней части каждого блока кода относительно этого каталога.

Приложение Flask может состоять из одного файла.

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

приложение = фляга (__имя__)


@app.route('/')
привет ():
    вернуться 'Привет, мир!'
 

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

Каталог проекта будет содержать:

• flaskr/ , пакет Python, содержащий код вашего приложения и файлы.

• tests/ , каталог, содержащий тестовые модули.

• venv/ , виртуальная среда Python, в которой Flask и другие зависимости установлены.

• Установочные файлы, сообщающие Python, как установить ваш проект.

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

• Любые другие файлы проекта, которые вы можете добавить в будущем.

В конце макет вашего проекта будет выглядеть так:

 /домашний/пользователь/Проекты/фласк-учебник
├── колба/
│ ├── __init__.py
│ ├── db.py
│ ├── схема.sql
│ ├── auth.py
│ ├── blog.py
│ ├── шаблоны/
│ │ ├── base.html
│ │ ├── авторизация/
│ │ │ ├── login.html
│ │ │ └── регистр.HTML
│ │ └── блог/
│ │ ├── create.html
│ │ ├── index.html
│ │ └── update.html
│ └── статический/
│ └── style.css
├── тесты/
│ ├── conftest.py
│ ├── data.sql
│ ├── test_factory.py
│ ├── test_db.py
│ ├── test_auth.py
│ └── test_blog.py
├── venv/
├── setup.py
└── МАНИФЕСТ.in
 

Если вы используете систему управления версиями, создаются следующие файлы во время работы вашего проекта следует игнорировать. Могут быть другие файлы в зависимости от используемого вами редактора.В общем, игнорируйте файлы, которые вы не написать. Например, с git:

 в/в/

*.pyc
__pycache__/

пример/

.pytest_cache/
.покрытие
htmlcov/

расстояние/
строить/
*.яйцо-информация/
 

Перейдите к настройке приложения.

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

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

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

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

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

приложение = фляга (__имя__)

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

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

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

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

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

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

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

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

BashFishCMDPowershell

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

 $ set -x FLASK_APP привет
$ фляжка
 * Работает на http://127.0.0.1:5000/
 

 > установить FLASK_APP = привет
>бег из фляги
 * Работает на http://127.0.0.1:5000/
 

 > $env:FLASK_APP = "привет"
>бег из фляги
 * Работает на http://127.0.0.1:5000/
 

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

В качестве ярлыка, если файл называется app.py или wsgi.py , вы не нужно устанавливать переменную среды FLASK_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-адреса.

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

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

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

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

Недопустимое имя импорта

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

Наиболее распространенная причина — опечатка или то, что вы на самом деле не создавали приложение объект.

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

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

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

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

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

BashFishCMDPowershell

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

 $ set -x FLASK_ENV разработка
$ фляжка
 

 > установить FLASK_ENV=развитие
>бег из фляги
 

 > $env:FLASK_ENV = "разработка"
>бег из фляги
 

См. также:

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

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

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

 из побега импорта markupsafe

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

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

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

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

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

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

 @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()
 

Если присутствует GET , Flask автоматически добавляет поддержку метода HEAD и обрабатывает запросов HEAD в соответствии с HTTP RFC.Так же, ОПЦИИ автоматически реализуется за вас.

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

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

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

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

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

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

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

Для рендеринга шаблона вы можете использовать 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 для получения дополнительной информации.

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

 

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

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

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

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

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

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

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

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

Для веб-приложений очень важно реагировать на данные, которые клиент отправляет на сервер. В 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() метод:

 с приложением.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('логин.html', ошибка=ошибка)
 

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

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

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

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

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

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

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

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

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

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

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

 от Werkzeug.утилиты импорта 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

@приложение.маршрут('/')
индекс определения():
    вернуть перенаправление (url_for ('логин'))

@app.route('/логин')
деф логин():
    прервать(401)
    this_is_never_executed()
 

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

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

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

@приложение. обработчик ошибок (404)
деф page_not_found (ошибка):
    вернуть render_template('page_not_found.html'), 404
 

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

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

Об ответах

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

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

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

3. Если это dict, объект ответа создается с использованием jsonify .

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

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

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

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

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

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

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

 из фляги импортировать make_response

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

API с JSON

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

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

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

 из фляги импортировать jsonify

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

сеансов

В дополнение к объекту запроса существует также второй объект с именем сеанс , который позволяет хранить информацию, специфичную для пользователя от одного запроса к другому. Это реализовано поверх файлов 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 ('индекс'))
    возвращение '''
        <метод формы="сообщение">
            

            

        
    '''

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

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

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

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

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

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

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

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

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

Регистрация

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

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

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

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

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

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

Перехват в ПО промежуточного слоя WSGI

Чтобы добавить промежуточное ПО WSGI в приложение Flask, оберните его атрибут wsgi_app . Например, чтобы применить Werkzeug’s промежуточное ПО ProxyFix для работы позади Nginx:

 от Werkzeug.промежуточное ПО.proxy_fix импорт ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
 

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

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

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

Дополнительные сведения о расширениях Flask см. в разделе Расширения.

Мерная колба и колба Флоренции — это одно и то же? – Restaurantnorman.com

Мерная колба и колба Флоренции — это одно и то же?

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

Почему ее называют флорентийской флягой?

У флорентийской фляги круглое дно с одной длинной горловиной. Фляга названа в честь Флоренции, Италия. Традиционные флорентийские фляги обычно не имеют шлифованного стекла на довольно длинном горлышке, но обычно имеют небольшую кромку или фланец вокруг кончика горлышка.

В чем разница между колбой Флоренса и колбой Эрленмейера?

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

Колба Эрленмейера или химический стакан более точны?

Анализ и обсуждение

Стеклянная посуда	Средний фактический объем воды (мл)	Процентная ошибка
Мерная колба	99,7	0. 3%
Градуированный цилиндр	97,8	2,2%
Стакан	96,5	3,5%
Колба Эрленмейера	82,7	17,4%

Является ли колба Эрленмейера точной?

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

Что используется для хранения химикатов в колбе?

5) Железное кольцо - застежка из железа, используемая для удерживания стеклянных стаканов или колб при их нагревании. 10) Проволочная сетка — устанавливается поверх железного кольца для поддержки мензурок, чашек для выпаривания и другого оборудования во время нагревания. 11) Держатель для пробирок — используется для удержания или поддержки пробирок с химическими веществами при их перемещении или нагревании.

Почему мы используем кольцевую подставку для термосов?

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

Что используется для захвата или удерживания пробирок, когда они горячие?

Железное кольцо — используется для удерживания предметов над пламенем горелки Бунзена. Кольцевая подставка - используется для удержания различных предметов. Подставка для пробирок Используется для хранения группы пробирок.

Какие меры предосторожности необходимо соблюдать при использовании Scoopula?

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

Как выглядит колба?

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

Как выглядит мензурка?

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

Как выглядит мерная колба?

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

Когда бы вы использовали мензурку?

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

Используйте Flask Blueprint для разработки своих приложений — Real Python

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

В этом уроке вы узнаете:

• Что такое чертежи фляг и как они работают
• Как создать и использовать Flask Blueprint для организации кода
• Как улучшить возможность повторного использования кода с помощью собственного или стороннего проекта Flask Blueprint

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

Как выглядит приложение Flask

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

  $ pip install Flask==1.1.1
  

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

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

Файл app. py будет содержать определение приложения и его представлений.

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

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

Следующий блок кода представляет собой полный исходный код вашего приложения:

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

приложение = фляга (__имя__)

@app.route('/')
индекс определения():
    вернуть "Это пример приложения"
  

Этот код создает объект app , принадлежащий классу Flask . Функция просмотра index() связана с маршрутом / с помощью декоратора app.route .Чтобы узнать больше о декораторах, ознакомьтесь с Primer on Python Decorators и Python Decorators 101.

Вы можете запустить приложение с помощью следующей команды:

По умолчанию Flask запустит приложение, указанное вами в app.py , на порту 5000. Во время работы приложения перейдите по адресу http://localhost:5000 с помощью веб-браузера. Вы увидите страницу с сообщением . Это пример приложения .

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

Как выглядит чертеж фляги

Flask Blueprints инкапсулирует функциональные возможности , такие как представления, шаблоны и другие ресурсы.Чтобы понять, как будет работать Flask Blueprint, вы можете реорганизовать предыдущее приложение, переместив представление index в Flask Blueprint. Для этого вам нужно создать Flask Blueprint, который содержит представление index , а затем использовать его в приложении.

Вот как выглядит структура файла для этого нового приложения:

  приложение/
|
├── app.py
└── example_blueprint.py
  

example_blueprint.py будет содержать реализацию Flask Blueprint.Затем вы измените app.py , чтобы использовать его.

В следующем блоке кода показано, как можно реализовать этот Flask Blueprint в example_blueprint.py . Он содержит представление на маршруте /, которое возвращает текст . Это пример приложения :

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

example_blueprint = Blueprint('example_blueprint', __name__)

@example_blueprint.route('/')
индекс определения():
    вернуть "Это пример приложения"
  

В приведенном выше коде вы можете увидеть шаги, общие для большинства определений Flask Blueprint:

1. Создайте объект Blueprint с именем example_blueprint .
2. Добавьте представлений к example_blueprint с помощью декоратора route .

Следующий блок кода показывает, как ваше приложение импортирует и использует Flask Blueprint:

  из фляги импорта Фляга
из example_blueprint импортировать example_blueprint

приложение = фляга (__имя__)
app.register_blueprint (example_blueprint)
  

Чтобы использовать любой Flask Blueprint, вы должны импортировать его, а затем зарегистрировать в приложении, используя register_blueprint() . Когда Flask Blueprint регистрируется, приложение расширяется за счет его содержимого.

Вы можете запустить приложение с помощью следующей команды:

Во время работы приложения перейдите по адресу http://localhost:5000 с помощью веб-браузера. Вы увидите страницу с сообщением . Это пример приложения .

Как работают чертежи фляги

В этом разделе вы подробно узнаете, как реализуется и используется Flask Blueprint. Каждый Flask Blueprint представляет собой объект , который работает очень похоже на приложение Flask.Они оба могут иметь ресурсы, такие как статические файлы, шаблоны и представления, связанные с маршрутами.

Однако Flask Blueprint на самом деле не является приложением. Его необходимо зарегистрировать в приложении, прежде чем вы сможете его запустить. Когда вы регистрируете Flask Blueprint в приложении, вы на самом деле расширяете приложение содержимым Blueprint.

Это ключевая концепция любого чертежа фляги. Они записывают операции, которые будут выполнены позже, когда вы зарегистрируете их в приложении. Например, когда вы связываете представление с маршрутом в схеме элементов Flask, он записывает эту ассоциацию, которая будет установлена ​​позже в приложении при регистрации схемы.

Создание чертежа колбы

Давайте вернемся к определению Flask Blueprint, которое вы видели ранее, и подробно рассмотрим его. Следующий код показывает создание объекта Blueprint :

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

example_blueprint = Blueprint('example_blueprint', __name__)
  

Обратите внимание, что в приведенном выше коде некоторые аргументы указываются при создании объекта Blueprint .Первый аргумент, "example_blueprint" , — это имя Blueprint , которое используется механизмом маршрутизации Flask. Второй аргумент, __name__ , — это имя импорта Blueprint , которое Flask использует для поиска ресурсов Blueprint.

Существуют и другие необязательные аргументы, которые вы можете указать для изменения поведения Blueprint:

• static_folder: папка, в которой можно найти статические файлы Blueprint

• static_url_path: URL-адрес для обслуживания статических файлов из

• template_folder: папка, содержащая шаблоны Blueprint

• url_prefix: путь для добавления ко всем URL-адресам Blueprint

• субдомен: субдомен, на котором маршруты этого Blueprint будут соответствовать по умолчанию

• url_defaults: словарь значений по умолчанию, которые будут получать представления этого Blueprint

• root_path: путь к корневому каталогу Blueprint, значение которого по умолчанию получается из имени импорта Blueprint

Обратите внимание, что все пути, кроме root_path , относятся к каталогу Blueprint.

Объект Blueprint example_blueprint имеет методы и декораторы, которые позволяют записывать операции, выполняемые при регистрации Flask Blueprint в приложении для его расширения. Одним из наиболее часто используемых декораторов является маршрут . Это позволяет вам связать функцию просмотра с маршрутом URL. Следующий блок кода показывает, как используется этот декоратор:

  @example_blueprint.route('/')
индекс определения():
    вернуть "Это пример приложения"
  

Вы декорируете index() , используя example_blueprint.route и свяжите функцию с URL /.

Объекты Blueprint также предоставляют другие методы, которые могут оказаться полезными:

• .errorhandler() для регистрации функции обработчика ошибок
• .before_request() для выполнения действия перед каждым запросом
• . after_request() для выполнения действия после каждого запроса
• .app_template_filter() для регистрации шаблонного фильтра на уровне приложения

Вы можете узнать больше об использовании Blueprints и класса Blueprint в документации Flask Blueprints.

Регистрация схемы элементов в приложении

Напомним, что Flask Blueprint на самом деле не является приложением. Когда вы регистрируете Flask Blueprint в приложении, вы расширяете приложение его содержимым. Следующий код показывает, как вы можете зарегистрировать ранее созданный Flask Blueprint в приложении:

  из фляги импорта Фляга
из example_blueprint импортировать example_blueprint

приложение = фляга (__имя__)
app.register_blueprint (example_blueprint)
  

Когда вы звоните по номеру .register_blueprint() , вы применяете все операции, записанные в Flask Blueprint example_blueprint к app . Теперь запросы к приложению для URL-адреса / будут обслуживаться с использованием .index() из схемы Flask.

Вы можете настроить, как Flask Blueprint расширяет приложение, указав некоторые параметры для register_blueprint :

• url_prefix — необязательный префикс для всех маршрутов Blueprint.
• субдомен — это субдомен, которому будут соответствовать маршруты Blueprint.
• url_defaults — это словарь со значениями по умолчанию для аргументов представления.

Возможность выполнять некоторые настройки во время регистрации, а не во время создания, особенно полезна, когда вы используете один и тот же Flask Blueprint в разных проектах.

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

Как использовать Flask Blueprints для разработки кода вашего приложения

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

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

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

Понимание важности макета проекта

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

  электронная коммерция/
|
├── статический/
| ├── логотип.png
| ├── main.css
| ├── generic.js
| └── product_view.js
|
├── шаблоны/
| ├── логин.html
| ├── forgot_password.html
| ├── signup.html
| ├── checkout.html
| ├── cart_view.html
| ├── index.html
| ├── products_list.html
| └── product_view.html
|
├── app.py
├── config.py
└── models.py
  

Код этого приложения организован с использованием следующих каталогов и файлов:

• static/ содержит статические файлы приложения.
• шаблонов/ содержит шаблоны приложения.
• models.py содержит определение моделей приложения.
• app.py содержит логику приложения.
• config.py содержит параметры конфигурации приложения.

Это пример того, сколько приложений начинается. Хотя этот макет довольно прост, у него есть несколько недостатков, которые возникают по мере увеличения сложности приложения.Например, вам будет сложно повторно использовать логику приложения в других проектах, потому что вся функциональность собрана в app.py . Если вы вместо этого разделите эту функциональность на модули, то сможете повторно использовать полные модули в разных проектах .

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

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

Организация ваших проектов

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

1. API Blueprint , позволяющий внешним системам искать и извлекать информацию о продукте
2. Authentication Blueprint , позволяющий пользователям входить в систему и восстанавливать свой пароль
3. Схема корзины для функций корзины и оформления заказа
4. Общий чертеж для домашней страницы
5. Products Blueprint для поиска и просмотра продуктов

Если вы используете отдельный каталог для каждого Flask Blueprint и его ресурсов, то макет проекта будет выглядеть следующим образом:

  электронная коммерция/
|
├── апи/
| ├── __инит__.пи
| └── api.py
|
├── авторизация/
| ├── шаблоны/
| | └── авторизация/
| | ├── логин.html
| | ├── forgot_password.html
| | └── signup. html
| |
| ├── __init__.py
| └── auth.py
|
├── тележка/
| ├── шаблоны/
| | └── тележка/
| | ├── checkout.html
| | └── view.html
| |
| ├── __init__.py
| └── cart.py
|
├── общее/
| ├── шаблоны/
| | └── общее/
| | └── index.html
| |
| ├── __init__.py
| └── general.py
|
├── товары/
| ├── статический/
| | └── вид.js
| |
| ├── шаблоны/
| | └── товары/
| | ├── list.html
| | └── view.html
| |
| ├── __init__.py
| └── products.py
|
├── статический/
| ├── логотип.png
| ├── main.css
| └── generic.js
|
├── app.py
├── config.py
└── models.py
  

Чтобы организовать код таким образом, вы перемещаете все представления из app.py в соответствующий Flask Blueprint. Вы также переместили шаблоны и неглобальные статические файлы. Эта структура упрощает поиск кода и ресурсов, связанных с заданной функциональностью.Например, если вы хотите найти логику приложения о продуктах, вы можете перейти к схеме продуктов в products/products.py вместо прокрутки app.py .

Давайте посмотрим на реализацию продуктов Blueprint в products/products.py :

  из flask import Blueprint, render_template
из ecommerce.models импортировать продукт

products_bp = Blueprint('products_bp', __name__,
    template_folder = 'шаблоны',
    static_folder='статический', static_url_path='активы')

@products_bp.маршрут('/')
список определений():
    продукты = Продукт.запрос.все()
    вернуть render_template('products/list.html', products=products)

@products_bp.route('/view/')
вид защиты (идентификатор_продукта):
    продукт = Product.query.get(product_id)
    вернуть render_template('products/view.html', product=product)
  

Этот код определяет products_bp Flask Blueprint и содержит только код, связанный с функциональностью продукта. Поскольку этот Flask Blueprint имеет свои собственные шаблоны, вам необходимо указать template_folder относительно корня Blueprint при создании объекта Blueprint . Поскольку вы укажете static_folder='static' и static_url_path='assets' , файлы в ecommerce/products/static/ будут обслуживаться по URL-адресу /assets/ .

Теперь вы можете переместить остальные функции вашего кода в соответствующий Flask Blueprint. Другими словами, вы можете создавать Blueprints для API, аутентификации, корзины и общего функционала. После того, как вы это сделаете, в app.py останется только код, связанный с инициализацией приложения и регистрацией Flask Blueprint:

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

из электронной коммерции.импорт api.api api_bp
из ecommmerce.auth.auth импортировать auth_bp
из ecommmerce.cart.cart импорта cart_bp
из ecommmerce.general.general импортировать general_bp
из ecommmerce.products.products import products_bp

приложение = фляга (__имя__)

app.register_blueprint(api_bp, url_prefix='/api')
app.register_blueprint (auth_bp)
app.register_blueprint(cart_bp, url_prefix='/cart')
app. register_blueprint (general_bp)
app.register_blueprint(products_bp, url_prefix='/products')
  

Теперь app.py просто импортирует и регистрирует Blueprints для расширения приложения.Поскольку вы используете url_prefix , вы можете избежать коллизий URL-адресов между маршрутами Flask Blueprint. Например, URL-адреса /products/ и /cart/ разрешаются в разные конечные точки, определенные в схемах products_bp и cart_bp для одного и того же маршрута / .

Включая шаблоны

В Flask, когда представление отображает шаблон, файл шаблона ищется во всех каталогах, которые были зарегистрированы в пути поиска шаблона приложения .По умолчанию этот путь — ["/templates"] , поэтому поиск шаблонов осуществляется только в каталоге /templates внутри корневого каталога приложения.

Если вы установите аргумент template_folder при создании Blueprint, то его папка templates будет добавлена ​​в путь поиска шаблонов приложения при регистрации Flask Blueprint. Однако, если есть дублированные пути к файлам в разных каталогах, которые являются частью пути поиска шаблона, то будет иметь приоритет , в зависимости от их порядка регистрации.

Например, если представление запрашивает шаблон view.html и в пути поиска шаблона есть файлы с таким же именем в разных каталогах, то один из них будет иметь приоритет над другим. Поскольку может быть трудно запомнить порядок старшинства, лучше избегать размещения файлов по одному и тому же пути в разных каталогах шаблонов. Вот почему следующая структура шаблонов в приложении имеет смысл:

  электронная коммерция/
|
└── товары/
    └── шаблоны/
        └── товары/
            ├── поиск.HTML
            └── view.html
  

Поначалу может показаться излишним, чтобы имя Flask Blueprint появлялось дважды:

1. Как корневой каталог Blueprint
2. Внутри каталога шаблонов

Однако знайте, что таким образом можно избежать возможных коллизий имен шаблонов между разными чертежами. Используя эту структуру каталогов, любые представления, требующие шаблона view.html для продуктов, могут использовать products/view.html в качестве имени файла шаблона при вызове render_template . Это позволяет избежать конфликтов с view.html , который принадлежит схеме элементов корзины.

И последнее замечание: важно знать, что шаблоны в каталоге шаблонов приложения имеют больший приоритет , чем шаблоны в каталоге шаблонов Blueprint. Это может быть полезно знать, если вы хотите переопределить шаблоны Flask Blueprint без фактического изменения файла шаблона.

Например, если вы хотите переопределить шаблон products/view.html в схеме продуктов, вы можете сделать это, создав новый файл products/view.html в каталоге приложения templates :

  электронная коммерция/
|
├── товары/
| └── шаблоны/
| └── товары/
| ├── search.html
| └── view. html
|
└── шаблоны/
        └── товары/
            └── view.html
  

Когда вы сделаете это, ваша программа будет использовать шаблонов/продуктов/представлений.html вместо products/templates/products/view.html всякий раз, когда для представления требуется шаблон products/view.html .

Предоставление функций, отличных от представлений

До сих пор вы видели только Blueprints, которые расширяют приложения представлениями, но Flask Blueprints не обязательно должны предоставлять только представления! Они могут расширять приложения с помощью шаблонов , статических файлов и фильтров шаблонов . Например, вы можете создать Flask Blueprint , чтобы предоставить набор значков и использовать его в своих приложениях.Это будет файловая структура для такого Blueprint:

  приложение/
|
└── иконки/
    ├── статический/
    | ├── add.png
    | ├── удалить.png
    | └── save.png
    |
    ├── __init__. py
    └── icons.py
  

Статическая папка содержит файлы значков и icons.py — это определение Flask Blueprint.

Вот как может выглядеть icons.py :

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

icons_bp = Blueprint('icons_bp', __name__,
    static_folder = 'статический',
    static_url_path='значки')
  

Этот код определяет icons_bp Flask Blueprint, который предоставляет файлы в статическом каталоге по URL-адресу /icons/ .Обратите внимание, что этот Blueprint не определяет никакого маршрута.

Когда вы можете создавать Blueprints, которые упаковывают представления и другие типы контента, вы делаете свой код и активы более пригодными для повторного использования в ваших приложениях. Вы узнаете больше о повторном использовании Flask Blueprint в следующем разделе.

Как использовать схемы Flask для улучшения повторного использования кода

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

Вы также можете использовать чертежи, созданные другими разработчиками, для ускорения своей работы. Хотя централизованного репозитория для существующих Flask Blueprints нет, вы можете найти их с помощью индекса пакетов Python, поиска GitHub и поисковых систем в Интернете. Вы можете узнать больше о поиске пакетов PyPI в статье Что такое Pip? Руководство для новых питонистов.

Существуют различные схемы Flask Blueprints и расширения Flask (которые реализованы с использованием Blueprints), которые предоставляют функции, которые могут оказаться полезными:

• Аутентификация
• Генерация администратора/CRUD
• Функциональность CMS
• И многое другое!

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

Заключение

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

Вы узнали:

• Что такое Чертежи фляги и как они работают
• Как вы можете внедрить и использовать чертеж фляги
• Как Flask Blueprints может помочь вам организовать код вашего приложения
• Как можно использовать Flask Blueprints для облегчения повторного использования ваших собственных и сторонних компонентов
• Как использование Flask Blueprint в вашем проекте может сократить время разработки

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

12 способов отличить поддельную гидрофлягу - Найди отличия

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

Может быть очень сложно сказать, какие гидрофласки настоящие, а какие поддельные.

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

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

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

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

Я начал с наиболее очевидных отличий и постепенно дошел до более тонких и мелких различий.

1. Текст логотипа

Глядя на текст логотипа в нижней части Hydro Flask, вы можете увидеть некоторые очевидные различия между настоящим брендом Hydro Flask и поддельным брендом Hydro Flask.

Фальшивый шрифт Hydro Flask выглядит явно иначе, и между буквами y и d в слове «Hydro» имеется значительный разрыв.

Буква r в поддельном логотипе имеет более заметную верхнюю кривую, а буква s в настоящем Hydro Flask шире, чем s на поддельном.

Настоящий логотип выглядит именно так, как вы ожидаете от логотипа, в то время как поддельный выглядит так, будто в нем есть пробелы, которых вы не ожидаете от такого дорогого брендового предмета.

2. Нижний текст

Нижняя часть Hydro Flask — один из главных способов отличить настоящий Hydro Flask от подделки.

Я сделал полную статью и видео о различиях между днищами Hydro Flasks.

Вкратце:

• На настоящих гидрофласках текст напечатан прописными и строчными буквами, тогда как на поддельных гидрофлаксах текст выгравирован прописными буквами.
• Фляги Real Hydro имеют надписи «HydroFlask.com», «Сделано в Китае», «Изоляция TempShield», а также код продукта и размер. В то время как поддельные гидрофласки имеют только размер плюс «18/8 НЕРЖАВЕЮЩАЯ СТАЛЬ» и «ДИЗАЙН В ИЗГИБЕ ИЛИ» внизу.

3. Варианты цвета/размера

Многие из этих поддельных веб-сайтов или продавцов eBay продают гидрофласки цветов или размеров, которые на самом деле никогда не производились.

Каждый раз, когда вы видите черно-белый Hydro Flask, вы знаете, что это подделка, потому что Hydro Flask никогда не производила эти цвета.

Я лично купил 2 подделки Hydro Flask в цветах омбре (2 тона).

Хотя Hydro Flask ДЕЙСТВИТЕЛЬНО производила эти цвета в прошлом, они выпускались только в размере 40 унций.

Однако я получил эти цвета в размере 32 унции. Hydro Flask никогда не производила эти цвета в размере 32 унции, поэтому очевидно, что это подделка.

Также, когда Hydro Flask выпустила ограниченную серию цветов омбре, у них были разные цветные крышки и разные бумажные конверты. Нажмите здесь, чтобы узнать больше о том, производила ли Hydro Flask цвета с эффектом омбре.

4. Цена

Одной из причин, по которой люди склоняются к покупке поддельной гидрофляги, является цена.

Гидрофласки стоят дорого, поэтому логично, что люди хотят сэкономить при покупке.

Зачем платить 45 долларов, если за тот же товар можно заплатить 30 или даже 20-25 долларов?

Тем не менее, Hydro Flask накладывает жесткие ограничения на то, за сколько дилерам разрешено продавать свою продукцию, и у них есть «минимальная рекламируемая цена».

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

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

5. Репутация продавца

Другим четким показателем того, настоящий ваш Hydro Flask или нет, является репутация продавца и вероятность того, что он продаст вам подлинную продукцию.

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

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

См. товары со скидкой на распродаже на HydroFlask.com

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

Нажмите здесь, чтобы увидеть подлинный магазин Hydro Flask на Amazon

Есть множество других уважаемых продавцов.Как правило, это такие компании, как REI, у которых есть магазины по всей стране.

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

См. Hydro Flasks для продажи на REI.com

Чего следует избегать, так это хитрых интернет-магазинов, которые либо пытаются имитировать Hydro Flask, используя свой логотип, либо хитрых продавцов на ebay.

Большинство Hydro Flasks на Ebay являются подделками, и ниже вы можете увидеть изображение явно поддельных Hydro Flasks.

Я точно знаю, что ни красный, ни белый, ни черный и белый цвета никогда не производились компанией Hydro Flask.

6. Крышка – резиновое уплотнение

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

Фальшивые компании проделали очень хорошую работу, имитируя крышки Hydro Flask.

Однако я заметил 2 небольших отличия в крышке.

Первый цвет и форма резиновой прокладки.

В оригинальной Hydro Flask резиновая прокладка прозрачного белого цвета, тогда как в поддельной Hydro Flask резиновая прокладка черного цвета.

Второе, что я заметил, это разделение внутреннего и внешнего пластика крышки на подделке Hydro Flasks. Этого разделения не было на настоящих Hydro Flasks.

7. Упаковка

Настоящие и поддельные Hydro Flask имеют разную основу.

Моя настоящая Hydro Flask была доставлена ​​в коричневой картонной коробке и упакована в белую перерабатываемую упаковку с логотипом Hydro Flask.

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

8. Печатный буклет

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

Фальшивая Hydro Flask вообще не поставлялась с печатной листовкой.

9. Рукав с принтом

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

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

Настоящая Hydro Flask имеет более металлический шрифт, а также поддерживает 3 разных языка, в то время как на подделке отображается только английский.

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

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

10. Наклейка со штрих-кодом

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

На наклейке со штрих-кодом поддельной Hydro Flask:

• На ней было написано авторское право 2016
• На ней было написано «Lava», которая отличается от цвета бутылки, которую я получил хотя они были 2 уникальных цвета.

  11. Внутренний базовый пузырь

  Это начинает действительно вдаваться в мельчайшие детали и небольшие различия, но я заметил, что в настоящем Hydro Flask (зеленый) внутренний пузырь был немного больше, чем в поддельном Hydro Flask.

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

  12. Новый дизайн горлышка

  Новые гидрофласки имеют другой дизайн горловины, чем старые гидрофласки.

  Они имеют более длинную плоскую полосу из нержавеющей стали на горлышке бутылки по сравнению со старым закругленным горлышком из нержавеющей стали.

  Поддельные гидрофласки по-прежнему имеют старый дизайн.

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

  13. Удержание льда

  Я думал, что удержание льда будет простым способом отличить настоящую гидрофлягу от поддельной.

  Однако, когда я провел тест на поддельный и настоящий лед Hydro Flask, я обнаружил, что они работают почти одинаково.

  Фальшивые гидрофляги по-прежнему имеют вакуумную изоляцию и могут удерживать лед в течение чрезвычайно длительного периода времени.

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

  R Товарный знак не соответствует подлинности

  Более новые Hydro Flasks уменьшили изображение своего логотипа и удалили (R) как из символа логотипа, так и из текста логотипа.

  Тем не менее, старые гидрофласки имели это (R), так что это не лучший способ отличить настоящий гидрофласк от подделки.

  Где купить настоящие гидрофляги

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

  Лично я купил все свои Hydro Flasks непосредственно у самого бренда.

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

  Перейдите на сайт HydroFlask.com и посмотрите все настоящие аутентичные гидрофласки

  В качестве альтернативы, если хотите, вы также можете купить гидрофласки на Amazon.com.

  Вы можете спросить: «Являются ли гидрофласки на Amazon настоящими?» и ответ да они.

  Tall Ridge является эксклюзивным продавцом Hydro Flasks на Amazon, и они просто представляют бренд на этой платформе. Все гидрофласки, купленные в Tall Ridge на Amazon, являются подлинными. Узнайте больше о настоящих гидрофласках на Amazon.

  Некоторые люди предпочитают Amazon, особенно если у них уже есть Amazon Prime.

  Цены обычно аналогичны ценам на веб-сайте Hydro Flask, но иногда на Amazon доступны цвета, отличные от HydroFlask.com. Как работают термосы-термосы? - Объясните этот материал Реклама

  Криса Вудфорда. Последнее обновление: 18 августа 2021 г.

  Люди и в лучшие времена могут быть довольно противоречивыми. Когда холодно, мы хотим согреться; когда жарко, мы хотим охладиться. Это потому что мы теплокровные существа, которым необходимо поддерживать температуру нашего тела более или менее менее постоянная, около 37 ° C (98,6 ° F), просто чтобы выжить. Вакуум в этом отношении фляги немного похожи на людей: им нравится держать вещи при постоянной температуре. Если вы положите в них горячие напитки, они сохранят их горячими; если положить в них холодные напитки, они держите их в прохладе.Они просты, аккуратны и эффективны, но как именно они работают?

  Фото: Типичный термос Thermos®. Термосы широко известны как Термосы для немецкой компании, основанной Райнхольдом Бюргером, которая в 1904 году внедрила технологию в производство.

  Как распространяется тепло

  Прежде чем мы сможем понять, почему флаконы такие фантастические, нам нужно понять немного больше о том, как тепло распространяется.

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

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

  Радиация немного отличается от проводимости и конвекции.Когда объекты горячие, они излучают свет. Вот почему лагерные костры светятся красным, оранжевым, и желтый. Это происходит потому, что атомы в горячих объектах становятся «возбужденными» и нестабильными, когда они получают дополнительную тепловую энергию от Пожар. Поскольку они нестабильны, атомы быстро возвращаются в исходное положение. нормальное состояние — и испускают имеющуюся у них энергию в виде света. (Читать далее о том, как и почему это происходит в нашей более длинной статье о свете.) Иногда мы можем видеть свет, который излучают атомы, а иногда нет. Если свет, который они излучают, слишком красный для наших глаз, это называется инфракрасное излучение и вместо того, чтобы видеть его, мы чувствуем его как тепло.Вы можете почувствовать инфракрасное излучение, испускаемое горячими предметами, даже если вы их не касаетесь (поэтому проводимости нет) и нет воздух или жидкость, присутствующие для переноса тепла (так что нет конвекция). Излучение объясняет, почему мы можем чувствовать тепло, исходящее от лампы накаливания старого образца, хотя они окружены стеклом с вакуумом внутри.

  Более подробно о тепловой энергии вы можете прочитать в нашей основной статье о тепле.

  Рекламные ссылки

  Почему ваш кофе остывает

  Предположим, вы только что заварили горячий кофе.Вы будете хорошо знать, что вам нужно пить быстро, прежде чем остынет, — но почему остынет? кипячение вода имеет температуру 100°C (212°F), а комнатная температура, скорее всего, будет 15-20°C (60-70°F), в зависимости от погода и включено ли у вас отопление. Поскольку вода в твоем напитке такая намного жарче, чем в комнате, тепло быстро уходит от кофейника в окрестности. Некоторое количество тепла будет теряться за счет теплопроводности: потому что ваш кофейник стоит на столе или столешнице, тепло будет течь прямо вниз и исчезнуть таким образом.Воздух прямо над и все вокруг горшка будет согрето им и начнет двигаться, поэтому больше тепла будет теряться конвекцией. И некоторое количество тепла также будет потеряно излучением.

  Художественное произведение: Ваш кофе охлаждается за счет теплопроводности, конвекции и излучения.

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

  Как работают термосы

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

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

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

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

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

  Внутри термоса

  Давайте быстро посмотрим, что происходит внутри колбы:

  1. Навинчивающаяся пробка.
  2. Внешний корпус из пластика или нержавеющей стали.
  3. Внешний слой из стекла, покрытого светоотражающим материалом (или из нержавеющей стали в небьющихся колбах).
  4. Вакуум.
  5. Внутренний слой из стекла (или нержавеющей стали в небьющихся колбах).
  6. Одна или несколько опор удерживают внутренний вакуумный контейнер на месте.
  7. Дополнительная изоляция снижает потери тепла и защищает колбу от ударов.

  Фото: Внизу: Вот как это выглядит в реальности. Это внутренний вакуумный контейнер нашего синего термоса, покрытый отражающим металлом, и он соответствует пунктам 3, 4 и 5 на схеме выше. Горлышко контейнера (куда вы наливаете и наливаете напитки) смотрит вправо, и я держу контейнер за его нижнюю опору (поз. 6 на схеме выше).

  Фото: Вверху: Вот контейнер, установленный во внешнем синем пластиковом корпусе, если смотреть снизу вверх (с отвинченным основанием фляги). В этой колбе внутренний вакуумный контейнер и внешний пластиковый контейнер разделены воздухом (поз. 7). Черная круглая штука вверху представляет собой единую пластиковую подставку, разделяющую внутренний и внешний контейнеры (деталь 6).

  Кто изобрел термос?

  Ученые также используют вакуумные колбы, но они склонны называть их сосудами Дьюара или бутылками Дьюара.Это потому, что идея была первоначально задумана в начале 1890-х годов шотландским ученым по имени сэр Джеймс. Дьюар (1842–1923) . Согласно биографии Джона Роулинсона (см. ссылки ниже), Дьюар использовал свои колбы только для охлаждения лабораторных химикатов, не предвидя огромного коммерческого рынка для сохранять напитки горячими и, следовательно, так и не запатентовал эту идею. (На самом деле он запатентовал часть своей идеи — удаление воздуха из сосуда для создания вакуума — но недостаточно, чтобы защитить все изобретение вакуумной колбы.)

  Фото: На этом фото ученый НАСА наливает очень холодный жидкий азот из сосуда Дьюара. Фотография Тома Чиды предоставлена ​​НАСА.

  Термосы

  были разработаны Райнхольдом Бергером и Альбертом Ашенбреннером, партнерами немецкой стеклодувной компании Burger and Aschenbrenner. Дьюар нанял немцев для изготовления колб для своих собственных лабораторных экспериментов, и они быстро осознали их коммерческий потенциал, подав заявку на немецкий патент. (DE170057: Сосуд с двойными стенками, закрывающими вакуумированную полость) в 1903 г.В 1904 году они основали компанию Thermos для продвижения своей идеи, которая фактически была коммерческой эксплуатацией оригинального изобретения Джеймса Дьюара.

  Вот один из оригинальных патентов США, выданных Бёргеру в декабре 1907 года (патент США № 872,795: Сосуд с двойными стенками и пространством для вакуума между стенками, который вы, вероятно, узнаете как перевод названия немецкого патента). . Как вы можете видеть, сравнивая эту диаграмму с моей собственной иллюстрацией выше, основная идея мало изменилась: в вакуумных колбах по-прежнему используется контейнер для жидкости с двойными стенками и вакуумом между стенками, чтобы остановить потерю тепла.

  Изображение: патент Райнхольда Бургера на термос-термос, выданный в 1907 году. Изображение предоставлено Управлением по патентам и товарным знакам США.

  Рекламные ссылки

  Узнать больше

  На этом сайте

  Видео

  Патенты

  Книги

  Для юных читателей

  • How Does Heat Move by Alicia Klepeis, Cavendish Square, 2019. Это довольно солидное введение в теплопроводность, конвекцию, излучение и основы кинетической теории для детей 8–10 лет.
  • Энергия очевидца Джека Чаллонера и Дэна Грина. Дорлинг Киндерсли (Дания), 2016. В нем рассказывается об истории того, как люди использовали энергию и использовали ее удивительным образом. Лучше всего подходит для детей 9–12 лет.
  • Жара Дарлин Стилл. Raintree, 2012. Полноценное введение в науку о тепле — что это такое, как оно перемещается и как оно меняет вещи. Он включает в себя несколько основных упражнений, глоссарий и некоторые рекомендации для дальнейшего чтения. 7–9 лет.

  Для читателей постарше

  Артикул

  Пожалуйста, НЕ копируйте наши статьи в блоги и другие веб-сайты

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

  Авторские права на текст © Chris Woodford 2008, 2021. Все права защищены. Полное уведомление об авторских правах и условия использования.

  Thermos является зарегистрированным товарным знаком Thermos LLC.

  Подписывайтесь на нас

  Сохранить или поделиться этой страницей

  Нажмите CTRL + D, чтобы добавить эту страницу в закладки на будущее или рассказать о ней своим друзьям:

  Цитировать эту страницу

  Вудфорд, Крис.

  No related posts.