Шаблоны html простые: 15 бесплатных шаблонов для Вашего сайта на CSS

, поэтому мы должны добавить их сами.

Итак, правильный способ сделать это:

  

  {% csrf_token%}
  

Теперь это имеет смысл, верно? Без тега

Если вы посмотрите на частный метод _html_output , определенный в BaseForm , который используется всеми методами as _ * () , вы увидите, что это довольно сложный метод с 76 строками код, и он делает много вещей. Ничего страшного, потому что этот метод хорошо протестирован и является частью ядра форм API, лежащая в основе механика, которая заставляет все работать. При работе над собственной логикой отрисовки формы вам не нужно напишите код Python для выполнения этой работы.Гораздо лучше делать это с помощью движка шаблонов Django, так как вы можете добиться большего чистый и простой в обслуживании код.

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

В общем, вот оно, вкратце, что делает _html_output :

• Сгруппируйте ошибки, которые не привязаны к определенным полям (ошибки, не связанные с полями), и ошибки из скрытых полей;
• Поместите ошибки, не связанные с полями, и ошибки со скрытыми полями вверху формы;
• Перебрать все поля формы;
• Визуализировать поля формы одно за другим;
  • Отображает имя поля в теге метки;
  • Если есть ошибки поля, сначала визуализируйте список HTML с ошибками;
  • Визуализировать ввод HTML для поля;
  • Если есть текст справки, отобразите его после поля.

Вот как выглядит второе состояние формы, вызывающее все ошибки проверки:

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

  

  {% csrf_token%}

  {{form.non_field_errors}}

  {% для скрытого_поля в форме.hidden_fields%}
    {{hidden_field.ошибки}}
    {{hidden_field}}
  {% endfor%}

  

Вы заметите, что результат немного отличается, но все элементы присутствуют.Дело в том, что автомат создание HTML с помощью {{form}} использует преимущества языка Python, поэтому может играть с конкатенацией строк, объединением списков (ошибки без полей + ошибки со скрытыми полями) и тому подобное. Механизм шаблонов более ограничен и ограничен, но это не проблема. Мне нравится движок шаблонов Django, потому что он не позволяет выполнять большую часть логики кода в шаблоне.

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

  

  {% csrf_token%}

  {% if form.non_field_errors%}
    

      {% для ошибки в form.non_field_errors%}
        
 {{error}} 
      {% endfor%}
    
  {% endif%}

  {% для скрытого_поля в форме.hidden_fields%}
    {% if hidden_field.errors%}
      

        {% для ошибки в hidden_field.ошибки%}
          
 (Скрытое поле {{hidden_field.name}}) {{error}} 
        {% endfor%}
      
    {% endif%}
    {{hidden_field}}
  {% endfor%}

  
    {% для поля в form.visible_fields%}
      
    {% endfor%}
  

        
 {{field.label_tag}} 
        

          {% if field.errors%}
            

              {% для ошибки в field.errors%}
                
 {{error}} 
              {% endfor%}
            
          {% endif%}
          {{ поле }}
          {% если поле.help_text%}
            
 {{field.help_text}}
          {% endif%}
        
      

   Отправить 
  

Намного ближе, правда?

Теперь, когда мы знаем, как «расширить» разметку {{form}} , давайте попробуем сделать ее красивее. Возможно, используя библиотеку Bootstrap 4.

Доступ к полям формы по отдельности

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

Вот как мы можем ссылаться на поля формы одно за другим:

  

  {% csrf_token%}

  {{form.non_field_errors}}

  {{form.source.errors}}
  {{form.source}}

  


      

        
 {{form.name.label_tag}} 
        

          {{form.name.errors}}
          {{ форма.название }}
        
      

      

        
 {{form.email.label_tag}} 
        

          {{form.email.errors}}
          {{form.email}}
        
      

      

        
 {{form.message.label_tag}} 
        

          {{form.message.errors}}
          {{form.message}}
          

          {{form.message.help_text}}
        
      

  

   Отправить 
  

Это не очень СУХОЕ решение.Но хорошо знать, как это делать. Иногда у вас может быть очень конкретный вариант использования, который вам нужно будет самостоятельно разместить поля в HTML.

Расширение полей формы

Мы все еще можем копнуть глубже и расширить разметку {{field}} (или, если вы делаете это индивидуально, это могут быть поля {{form.name}} или {{form.email}} , например). Но теперь все становится немного сложнее, потому что мы говорим о виджетах.Например, поле name преобразуется в тег , а поле электронной почты преобразуется в тег, и, что еще более проблематично, поле сообщения преобразуется в тег.

На этом этапе Django использует небольшие шаблоны HTML для генерации вывод HTML полей.

Итак, давайте посмотрим, как это делает Django. Если мы откроем текст.html или email.html из папки виджетов, мы увидим, что он просто включает файл шаблона input.html:

  {% include "django / forms / widgets / input.html"%}  

Это говорит о том, что шаблон input.html , вероятно, является наиболее общим, особенности рендеринга могут быть внутри него. Итак, посмотрим:

В основном этот небольшой шаблон устанавливает тип ввода , это имя , которое используется для доступа к данным в запросе объект. Например, вход с именем «сообщение», если он отправлен на сервер, доступен через request.POST ['сообщение'] .

По-прежнему во фрагменте шаблона input.html он также устанавливает текущее значение поля или оставляет его пустым, если нет данных.Это важный момент в шаблоне, потому что именно он сохраняет состояние формы после того, как отправлено и не было успешно обработано (форма недействительна).

Наконец, он включает шаблон attrs.html, который отвечает за установка атрибутов, таких как maxlength , требуется , заполнитель , стиль или любой другой атрибут HTML. Его широкие возможности настройки в определении формы.

Если вам интересно узнать о атрибуте attrs.html , вот как это выглядит:

  {% для имени, значения в widget.attrs.items%}
  {%, если значение не False%}
    {{name}} {%, если значение не истинно%} = "{{value | stringformat: 's'}}" {% endif%}
  {% endif%}
{% endfor%}  

Теперь, если вы действительно хотите создать входные данные самостоятельно, вы можете сделать это следующим образом (только поле name для краткость):

Или немного лучше:

Возможно, вы уже поняли, что это не лучший способ работы с формами.И, может быть, вы тоже спрашиваете себя почему иногда мы называем определенный атрибут {{form.name. }} , а в других ситуациях мы используем {{form.name.field. }} .

Я не хочу сейчас вдаваться в подробности об этом, но в основном form.name — это BoundField (поле + данные) instance, а затем form.name.field — это определение поля, которое является экземпляром forms.CharField .Это почему одни значения доступны в экземпляре связанного поля, а другие — в определении поля char.

В любом определении формы __iter__ формы возвращает список из экземпляров BoundField , аналогично visible_fields () и hidden_fields () методы также возвращают экземпляров BoundField . Теперь, если вы получите доступ к form.fields , он относится к списку CharField , EmailField и всем другим определениям полей и т. Д.Если это тоже много информации для вас прямо сейчас, ничего страшного, вам не нужно беспокоиться об этом прямо сейчас.

Использование настраиваемых атрибутов HTML

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

forms.py

  класс ColorfulContactForm (forms.Форма):
    name = forms.CharField (
        max_length = 30,
        widget = forms.TextInput (
            attrs = {
                'стиль': 'цвет границы: синий;',
                'placeholder': 'Напишите здесь свое имя'
            }
        )
    )
    электронная почта = forms.EmailField (
        max_length = 254,
        widget = forms.EmailInput (attrs = {'style': 'border-color: green;'})
    )
    message = forms.CharField (
        max_length = 2000,
        widget = forms.Textarea (attrs = {'style': 'border-color: orange;'}),
        help_text = 'Напишите здесь свое сообщение!'
    )  

Далее мы собираемся изучить стороннюю библиотеку, которая может облегчить вам жизнь.

Использование настроек виджетов Django

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

Библиотека django-widget-tweaks — подходящий инструмент для этой работы. Это позволяет сохранить настройки формы по умолчанию и просто добавить что вам нужно. Это очень удобно, особенно при работе с ModelForms , так как сокращает объем кода. вы должны писать, чтобы выполнять простые задачи.

Я не буду вдаваться в подробности о django-widget-tweaks , потому что у меня есть статья, посвященная этому: Как использовать django-widget-tweaks.

Вот краткое руководство по началу работы:

Сначала установите его с помощью pip:

  pip install django-widget-tweaks  

Добавьте его в INSTALLED_APPS :

  INSTALLED_APPS = [
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.сессий ',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    'widget_tweaks',
]  

Загрузить в шаблон:

  {% load widget_tweaks%}



  
  


  ...   

И мы готовы его использовать! В основном мы будем использовать тег шаблона {% render_field%} . Ты сможешь посмотрите в следующем примере, что мы можем просто поместить атрибуты, как если бы мы делали это с необработанным HTML:

  

  {% csrf_token%}

  {{ форма.non_field_errors}}

  {% для скрытого_поля в форме.hidden_fields%}
    {{hidden_field.errors}}
    {{hidden_field}}
  {% endfor%}

  
    {% для поля в form.visible_fields%}
      
    {% endfor%}
  

        
 {{field.label_tag}} 
        

          {{field.errors}}
          {% render_field field placeholder = field.name%}
          {{field.help_text}}
        
      

   Отправить 
  

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

Визуализация бутстрапа 4 форм

В основном, чтобы использовать библиотеку Bootstrap 4, я просто включил ссылку CDN, которую они предоставляют, в свой шаблон:

Эта часть статьи будет более конкретной, поскольку я не буду исследовать особенности Bootstrap 4. выполнение.Их документация великолепна и богата примерами. Если вы не очень знакомы, вы можете перейти к Раздел Документация / Компоненты / Формы для получения дополнительной информации.

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

  

  {% csrf_token%}

  {% для скрытого_поля в форме.hidden_fields%}
    {{hidden_field}}
  {% endfor%}

  {% для поля в форме.visible_fields%}
    

      {{field.label_tag}}
      {{ поле }}
      {% if field.help_text%}
         {{field.help_text}} 
      {% endif%}
    
  {% endfor%}

   Отправить 
  

Однако поля ввода выглядят неработающими. Это связано с тем, что формы Bootstrap 4 ожидают элемента управления формой класса CSS в HTML-входы. Давайте исправим это с помощью того, что мы узнали в последнем разделе этой статьи:

  {% load widget_tweaks%}


  {% csrf_token%}

  {% для скрытого_поля в форме.hidden_fields%}
    {{hidden_field}}
  {% endfor%}

  {% для поля в form.visible_fields%}
    

      {{field.label_tag}}
      {% render_field field%}
      {% if field.help_text%}
         {{field.help_text}} 
      {% endif%}
    
  {% endfor%}

   Отправить 
  

Намного лучше. Теперь давайте посмотрим на ситуацию с проверкой и ошибками. Я собираюсь использовать компонент alert для не ошибки полей, а для полей я просто поиграю с правильными классами CSS, которые предоставляет Bootstrap 4.

  {% load widget_tweaks%}


  {% csrf_token%}

  {% для скрытого_поля в форме.hidden_fields%}
    {{hidden_field}}
  {% endfor%}

  {% if form.non_field_errors%}
    

      {% для ошибки в form.non_field_errors%}
        {{ ошибка }}
      {% endfor%}
    
  {% endif%}

  {% для поля в form.visible_fields%}
    

      {{field.label_tag}}

      {% if form.is_bound%}
        {% если поле.ошибки%}
          {% render_field field%}
          {% для ошибки в field.errors%}
            

              {{ ошибка }}
            
          {% endfor%}
        {% еще %}
          {% render_field field%}
        {% endif%}
      {% еще %}
        {% render_field field%}
      {% endif%}

      {% if field.help_text%}
         {{field.help_text}} 
      {% endif%}
    
  {% endfor%}

   Отправить 
  

И вот результат:

Это очень круто, потому что он отмечает зеленым цветом поля, прошедшие проверку:

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

Сначала я вызываю метод form.is_bound . Он сообщает нам, есть ли в форме данные или нет. Когда мы впервые инициализируем форму form = ContactForm () , метод form.is_bound () вернет False . После отправки form.is_bound () вернет True . Итак, мы можем поиграть с ним, чтобы узнать, произошел ли уже процесс проверки или нет.

Затем, когда проверка уже прошла, я просто помечаю поле CSS-классом .is-invalid и . Действителен , в зависимости от случая. Они отвечают за окрашивание компонентов формы в красный или зеленый цвет.

Повторное использование компонентов формы

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

включает / bs4_form.html

  {% load widget_tweaks%}

{% для скрытого_поля в форме.hidden_fields%}
  {{hidden_field}}
{% endfor%}

{% if form.non_field_errors%}
  

    {% для ошибки в form.non_field_errors%}
      {{ ошибка }}
    {% endfor%}
  
{% endif%}

{% для поля в form.visible_fields%}
  

    {{field.label_tag}}

    {% if form.is_bound%}
      {% if field.errors%}
        {% render_field field%}
        {% для ошибки в field.errors%}
          

            {{ ошибка }}
          
        {% endfor%}
      {% еще %}
        {% render_field field%}
      {% endif%}
    {% еще %}
      {% render_field field%}
    {% endif%}

    {% если поле.help_text%}
       {{field.help_text}} 
    {% endif%}
  
{% endfor%}  

Теперь определение нашей формы может быть таким простым, как:

  

  {% csrf_token%}
  {% include 'includes / bs4_form.html' с form = form%}
   Отправить 
  

Например, используя приведенный выше фрагмент кода, мы используем его для обработки UserCreationForm , которая является встроенной формой который живет внутри django.Модуль contrib.auth . Ниже результат:

Выводы

Эта статья стала больше, чем я ожидал. Сначала я подумал написать просто краткое руководство по форме рендеринг. Затем я вспомнил, что у меня уже есть подробное руководство, объясняющее как использовать django-widget-tweaks. Поэтому вместо этого я решил углубиться в детали и изучить некоторые механизмы API форм.

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

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

Как обычно, вы можете найти исходный код и все примеры на GitHub.

SimpleTemplate Engine — документация по бутылкам 0.13-dev

Bottle поставляется с быстрым, мощным и простым в освоении встроенным механизмом шаблонов, который называется SimpleTemplate или stpl для краткости.Это механизм по умолчанию, используемый помощниками view () и template () , но также может использоваться как автономный механизм шаблонов общего назначения. Этот документ объясняет синтаксис шаблона и показывает примеры для распространенных случаев использования.

Базовое использование API:

SimpleTemplate реализует BaseTemplate API:

 >>> из импорта бутылки SimpleTemplate
>>> tpl = SimpleTemplate ('Привет, {{имя}}!')
>>> тпл.render (имя = 'Мир')
u'Hello World! '
 

В этом документе мы используем помощник template () в примерах для простоты:

 >>> из шаблона импорта бутылки
>>> template ('Привет, {{имя}}!', name = 'World')
u'Hello World! '
 

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

 >>> из шаблона импорта бутылки
>>> my_dict = {'number': '123', 'street': 'Fake St.', 'city': 'Fakeville'}
>>> template ('Я живу по адресу {{number}} {{street}}, {{city}}', ** my_dict)
Я живу по адресу 123 Fake St., Fakeville '
 

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

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

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

Синтаксис SimpleTemplate компилируется непосредственно в байт-код python и выполняется при каждом вызове SimpleTemplate.render () . Не отображайте ненадежные шаблоны! Они могут содержать и выполнять вредоносный код Python.

Встроенные выражения

Вы уже узнали об использовании синтаксиса {{...}} из «Hello World!» пример выше, но есть еще кое-что: любое выражение Python разрешено в фигурных скобках, если оно оценивается как строка или что-то, что имеет строковое представление:

 >>> template ('Hello {{name}}!', Name = 'World')
u'Hello World! '
>>> template ('Привет {{name.title () if name else "stranger"}}! ', name = None)
u'Привет, незнакомец! '
>>> template ('Привет {{name.title () if name else "stranger"}}!', name = 'mArC')
u'Hello Marc! '
 

Содержащееся выражение python выполняется во время рендеринга и имеет доступ ко всем аргументам ключевого слова, переданным методу SimpleTemplate.render () . Специальные символы HTML экранируются автоматически, чтобы предотвратить атаки XSS. Вы можете начать выражение с восклицательного знака, чтобы отключить экранирование для этого выражения:

 >>> template ('Hello {{name}}!', Name = ' World ')
u'Привет, & lt; b & gt; World & lt; / b & gt ;! '
>>> template ('Hello {{! name}}!', name = ' World ')
u'Привет,  мир ! '
 

Встроенный код Python

Механизм шаблонов позволяет встраивать в шаблон строки или блоки кода Python.Строки кода начинаются с % , а блоки кода окружены маркерами <% и %> :

% name = "Bob" # строка кода Python
 Простой текст между ними 
<%
  # Блок кода Python
  name = name.title (). strip ()
%>
 Более простой текст 
 

Встроенный код Python следует обычному синтаксису Python, но с двумя дополнительными правилами синтаксиса:

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

 

  % за товар в корзине:
    
 {{item}} 
  % конец

 

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

 Эта строка содержит% и <%, но не содержит кода Python.
\% Эта текстовая строка начинается с токена "%".
\ <% Другая строка, которая начинается с токена, но отображается как текст.
{{'\\%'}} эта строка начинается с экранированного токена.

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

Обратите внимание, что % и <%%> работают в точно так же. Последнее - всего лишь удобный способ набирать меньше текста и избегать беспорядка в длинных сегментах кода. Это означает, что в блоках <%%> весь код с отступом должен заканчиваться концом , как в следующем примере:

 <%
    если some_condition:
        some_operation ()
    elif some_other_condition:
        some_other_operation ()
    еще:
        еще_another_operation ()
        если еще_another_condition:
          some_more_stuff ()
        конец
    конец
%>
 

Контроль пробелов

Кодовые блоки и строки кода всегда занимают всю строку.Пробел перед удалением сегмента кода. Вы не увидите пустых строк или висящих пробелов в шаблоне из-за встроенного кода:

 

 % если правда:
   содержание 
 % конец

 

Этот фрагмент отображает чистый и компактный HTML:

 

   содержание 

 

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

 
 \\
 %если правда:
 контент  \\
 %конец

 

На этот раз визуализированный шаблон выглядит так:

 
content 
 

Работает только непосредственно перед сегментами кода. Во всех остальных случаях вы можете управлять пробелами самостоятельно и не требует специального синтаксиса.

Функции шаблона

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

Изменено в версии 0.12: До этого выпуска include () и rebase () были ключевыми словами синтаксиса, а не функциями.

включает ( sub_template , ** переменные )

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

% include ('header.tpl', title = 'Заголовок страницы')
Содержание страницы
% include ('нижний колонтитул.tpl')
 

перебазировать ( имя , ** переменные )

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

% rebase ('base.tpl', title = 'Заголовок страницы')
 Содержание страницы ... 
 

Его можно комбинировать со следующим base.tpl :

 

  


  {{!база}}


 

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

определено ( имя )

Вернуть True, если переменная определена в текущем пространстве имен шаблона, В противном случае неверно.

получить ( имя , по умолчанию = нет )

Вернуть переменную или значение по умолчанию.

по умолчанию ( имя , по умолчанию )

Если переменная не определена, создайте ее с заданным значением по умолчанию. Верните переменную.

Вот пример, в котором все три функции используются для реализации необязательного шаблона. переменные по-разному:

% setdefault ('текст', 'Нет текста')
 
 {{get ('заголовок', 'Без заголовка')}} 
 
 {{текст}} 
%, если определено ("автор"):
  
 Автор {{автор}} 
% конец
 

class SimpleTemplate ( source = None , name = None , lookup = None , encoding = 'utf8' , ** settings ) [источник]

рендеринг ( * args , ** kwargs ) [источник]

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

создание шаблонов на Python с модулем Jinja

последнее изменение 6 июля 2020 г.

В руководстве по Jinja показано, как создавать шаблоны в Python с помощью модуля Jinja.

Модуль Python Jinja

Jinja - это шаблонизатор для Python. Это похоже на Шаблонизатор Django.

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

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

Установка Jinja

$ sudo pip3 установить jinja2
 

Мы используем инструмент pip3 для установки Jinja.

Разделители Jinja

Jinja использует различные разделители в строках шаблона.

• {%%} - выписки
• {{}} - выражения для печати в выводе шаблона
• {# #} - комментарии, которые не включаются в вывод шаблона
• # ## - строковые операторы

Простой пример Jinja

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

simple.py

#! / usr / bin / env python3

из шаблона импорта jinja2

name = input ("Введите свое имя:")

tm = Template ("Здравствуйте, {{имя}}")
сообщение = tm.рендеринг (имя = имя)

печать (сообщение)
 

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

из шаблона импорта jinja2
 

Мы импортируем объект Template из jinja2 модуль. Шаблон - это центральный объект шаблона. Это представляет собой скомпилированный шаблон и используется для его оценки.

tm = Template ("Здравствуйте, {{имя}}")
 

В нашем шаблоне используется синтаксис {{}} чтобы распечатать переменную. Переменная передается в render () метод.

msg = tm.render (имя = имя)
 

С помощью метода render () мы генерируем окончательный результат. Метод объединяет строку шаблона с данными, переданными в качестве аргумента. Переменная, передаваемая методу render () называется контекстной переменной .

$ ./simple.py
Введите ваше имя: Пол
Привет пол
 

Это пример вывода.

В следующем примере мы используем две переменные.

simple2.py

#! / usr / bin / env python3

из шаблона импорта jinja2

name = 'Питер'
возраст = 34

tm = Template ("Меня зовут {{имя}}, а мне {{возраст}}")
msg = tm.render (имя = имя, возраст = возраст)

печать (сообщение)
 

Строка шаблона отображает две переменные: имя и возраст. Этот раз переменные жестко запрограммированы.

$ ./simple2.py
Меня зовут Питер и мне 34 года
 

Это результат.

Jinja объектов

Мы можем работать с объектами в наших строках шаблона.

objects.py

#! / usr / bin / env python3

из шаблона импорта jinja2

класс Человек:

    def __init __ (я, имя, возраст):

        self.name = имя
        self.age = возраст

    def getAge (сам):
        вернуть self.age

    def getName (сам):
        вернуть self.name


person = Человек ('Питер', 34)

tm = Template ("Меня зовут {{per.getName ()}}, а я {{per.getAge ()}} ")
msg = tm.render (на = человека)

печать (сообщение)
 

В этом примере мы определяем объект Person . Получаем название и возраст через два геттера.

Словари

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

dicts.py

#! / usr / bin / env python3

из шаблона импорта jinja2

person = {'name': 'Person', 'age': 34}

tm = Template ("Меня зовут {{per.name}}, а я {{per.возраст }}")
# tm = Template ("Меня зовут {{per ['name']}}, а меня {{per ['age']}}")
msg = tm.render (на = человека)

печать (сообщение)
 

У нас есть личный словарь. Доступ к клавишам словаря осуществляется через точку оператор.

tm = Template ("Меня зовут {{per.name}}, а я {{per.age}}")
# tm = Template ("Меня зовут {{per ['name']}}, а меня {{per ['age']}}")
 

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

Необработанные данные Jinja

Мы можем использовать raw , endraw маркеров, чтобы избежать Разделители Jinja.

raw_data.py

#! / usr / bin / env python3

из шаблона импорта jinja2

данные = '' '
{% сырой %}
Его зовут {{name}}
{% endraw%}
'' '

tm = Шаблон (данные)
msg = tm.render (имя = 'Питер')

печать (сообщение)
 

Используя блок raw , endraw , мы избегаем синтаксис Jinja {{}} . Он напечатан в буквальном смысле.

Данные побега Джиндзя

Чтобы экранировать такие данные, как < или > символов, мы можем использовать фильтр или функцию escape () .

escape_data.py

#! / usr / bin / env python3

из шаблона импорта jinja2, побег

data = ' Сегодня солнечный день '

tm = Шаблон ("{{данные | e}}")
msg = tm.render (данные = данные)

печать (сообщение)
печать (escape (данные))
 

Пример экранирует < и > символов.

tm = Шаблон ("{{данные | e}}")
 

Используя фильтр e , данные экранируются. Применяются фильтры с | персонаж.

печать (escape (данные))
 

Функция escape делает то же самое.

Jinja для выражений

Выражение for используется для итерации по сбору данных. в шаблоне.

Теперь мы больше не используем простой строковый шаблон. Используем текстовый файл который загружается с помощью FileSystemLoader .

for_expr.py

#! / usr / bin / env python3

из jinja2 import Environment, FileSystemLoader

человек = [
    {'name': 'Андрей', 'age': 34},
    {'name': 'Mark', 'age': 17},
    {'name': 'Thomas', 'age': 44},
    {'name': 'Lucy', 'age': 14},
    {'name': 'Robert', 'age': 23},
    {'имя': 'Драгомир', 'возраст': 54}
]

file_loader = FileSystemLoader ('шаблоны')
env = Среда (loader = file_loader)

шаблон = env.get_template ('showpersons.txt')

output = template.render (люди = люди)
печать (вывод)
 

В этом примере шаблоном является файл showpersons.txt . Файл находится в каталоге templates .

человек = [
    {'name': 'Андрей', 'age': 34},
    {'name': 'Mark', 'age': 17},
    {'name': 'Thomas', 'age': 44},
    {'name': 'Lucy', 'age': 14},
    {'name': 'Robert', 'age': 23},
    {'имя': 'Драгомир', 'возраст': 54}
]
 

Данные представляют собой список словарей.

file_loader = FileSystemLoader ('шаблоны')
env = Среда (loader = file_loader)
 

Мы определяем FileSystemLoader . Шаблон получен из каталога шаблонов .

шаблон = env.get_template ('showpersons.txt')
 

Получаем шаблон с помощью метода get_template () .

шаблоны / showpersons.txt

{% на человека в лицах -%}
    {{person.name}} {{person.age}}
{% endfor%}
 

В файле шаблона мы используем выражение for для перебора Коллекция.Показываем имя и возраст человека. Характер тире рядом с символами% используется для управления пробелами.

Условные обозначения Jinja

Условные выражения - это выражения, которые оцениваются, когда определенное условие выполнено.

conditionals.py

#! / usr / bin / env python3

из jinja2 import Environment, FileSystemLoader

человек = [
    {'name': 'Андрей', 'age': 34},
    {'name': 'Mark', 'age': 17},
    {'name': 'Thomas', 'age': 44},
    {'name': 'Lucy', 'age': 14},
    {'name': 'Robert', 'age': 23},
    {'name': 'Dragomir', 'age': 54},
]

file_loader = FileSystemLoader ('шаблоны')
env = Среда (loader = file_loader)
окр.trim_blocks = Верно
env.lstrip_blocks = Верно
env.rstrip_blocks = Верно

шаблон = env.get_template ('showminors.txt')

output = template.render (люди = люди)
печать (вывод)
 

В примере печатаются только несовершеннолетние лица; несовершеннолетний - это лицо моложе 18 лет.

env.trim_blocks = Верно
env.lstrip_blocks = Верно
env.rstrip_blocks = Верно
 

Пробел в выводе можно контролировать с помощью атрибутов среды.

шаблоны / showminors.txt

{% на человека в лицах%}
    {% если человек.возраст <18%}
        {{- person.name}}
    {% endif%}
{% - endfor%}
 

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

$ ./conditionals.py
отметка
Люси
 

Это результат.

Суммарный фильтр Jinja

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

sum_filter.py

#! / usr / bin / env python3

из jinja2 import Environment, FileSystemLoader

cars = [
    {'name': 'Audi', 'price': 23000},
    {'name': 'Skoda', 'price': 17300},
    {'name': 'Volvo', 'price': 44300},
    {'name': 'Volkswagen', 'price': 21300}
]

file_loader = FileSystemLoader ('шаблоны')
env = Среда (loader = file_loader)

шаблон = env.get_template ('sumprices.txt')

output = template.render (cars = cars)
печать (вывод)
 

В этом примере мы используем фильтр сумма для вычисления сумма всех цен на автомобили.

cars = [
    {'name': 'Audi', 'price': 23000},
    {'name': 'Skoda', 'price': 17300},
    {'name': 'Volvo', 'price': 44300},
    {'name': 'Volkswagen', 'price': 21300}
]
 

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

шаблоны / sumprices.txt

Сумма цен на автомобили составляет {{cars | сумма (атрибут = 'цена')}}
 

В файле шаблона мы применяем фильтр к коллекции автомобилей. объект. Сумма рассчитывается из атрибута цена .

$ ./sum_filter.py
Сумма цен на машины составляет 105900.
 

Это результат.

Наследование шаблона Jinja

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

ineritance.py

#! / usr / bin / env python3

из jinja2 import Environment, FileSystemLoader

content = 'Это о странице'

file_loader = FileSystemLoader ('шаблоны')
env = Среда (loader = file_loader)

template = env.get_template ('about.html')

output = template.render (контент = контент)
печать (вывод)
 

Рендерим об.html файл. Он унаследован от base.html файл.

base.html

    
    
    
    


    {% блокировать содержание%}
    
    {% endblock%}


 

В базе .html мы объявляем два блока: заголовок и содержание. Эти блоки будут заполнены определенными тегами и текстом. в дочерних шаблонах.

about.html

{% extends 'base.html'%}

{% block title%} О странице {% endblock%}

{% блокировать содержание%}
 
 О странице 
 

    Это о странице

{% endblock%}
 

Файл шаблона about.html наследуется от base.html . Он добавляет данные, относящиеся к этой странице.Мы избегаем повторения кода; мы не повторяйте теги, одинаковые для обеих страниц, например body и html. и метатеги.

{% extends 'base.html'%}
 

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

{% block title%} О странице {% endblock%}
 

Определяем название.

{% блокировать содержание%}
 
 О странице 
 

    Это о странице

{% endblock%}
 

И мы определяем содержание.

Пример Jinja Flask

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

app.py

#! / usr / bin / env python3

from flask import Flask, render_template, request
app = Flask (__ имя__)

@ app.route ("/ приветствовать")
def greet ():
    имя пользователя = request.args.get ('имя')
    return render_template ('index.html', name = имя пользователя)

если __name__ == "__main__":
    app.run ()
 

В этом приложении Flask мы получаем имя пользователя и передаем его как в метод render_template () .Приветствие () функция реагирует на путь / greet .

шаблонов / index.html

    
    



    

        Привет, {{name}}
    



 

Это файл шаблона, расположенный в шаблонах каталог. Добавляем имя пользователя в файл шаблона с помощью {{name}} синтаксис.

$ python3 app.py
 * Запуск на http://127.0.0.1:5000/ (для выхода нажмите CTRL + C)
 

Запускаем сервер.

$ curl http://127.0.0.1:5000/greet?name=Peter





    
    



    

        Привет Питер
    



 

Подключаемся к приложению инструментом curl .Мы добавить параметр имени.

В этом руководстве мы рассмотрели модуль Python Jinja.

Список всех руководств по Python.

Создание простого сайта на основе шаблонов HTML + CSS

Подход к созданию многостраничного сайта

Начало работы

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

Создание веб-сайта на основе шаблонов

Следующие видео-демонстрации являются последовательными и хронологическими. Чтобы узнать, как создать гибкий, отзывчивый 6-страничный макет с мобильной навигацией, просмотрите все видео (всего ~ 3 часа).

Обратите внимание: в демонстрации реализации Javascript я говорю вам, что вы можете скопировать и вставить некоторый код javascript. Вы можете загрузить полный сценарий мобильного меню Javascript из упражнения 4. Это полный код, но когда сценарий впервые вводится в учебное пособие, он оказывается неполным и позже завершается.

Примечание о видео ниже

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

Часть 01 (14:56)

Создание снимков экрана для ваших страниц.

Часть 02 (12:48)

Создание масштабируемой векторной графики (SVG) в Illustrator.

Часть 03 (14:48)

Начало работы: перевод макета в структуру HTML.

Часть 04 (9:05)

На этом завершается базовая разметка HTML для шаблона.

Часть 05 (14:59)

Применение «сброса» и пользовательских таблиц стилей к шаблону.

Часть 06 (14:15)

Начните стилизацию глобальной «верхней» панели навигации.

Часть 07 (14:57)

Завершение стиля «nav # top»

Часть 08 (14:58)

Стилизация области «section # content» с помощью плавающих элементов, текстовых определений и добавление рисунка / подписи к снимку экрана.

Часть 09 (9:58)

Стилизация элементов нижнего колонтитула

Часть 10 (14:59)

Использование медиа-запросов для обеспечения гибкости дизайна

Часть 11 (14:09)

Использование javascript и стиля для скрытия / отображения мобильного меню

Часть 12 (14:39)

заставить раскрывающееся меню работать с кнопкой закрытия

Часть 13 (10:13)

Завершите оформление накладной панели мобильной навигации и кнопки закрытия

Часть 14 (7:16)

Распространение шаблонов для сайта и добавление контента для завершения сайта.

Пользовательские теги и фильтры шаблонов | Документация Django

Язык шаблонов Django имеет множество встроенных теги и фильтры, предназначенные для решения логика представления потребностей вашего приложения. Тем не менее, вы можете обнаружите, что вам нужна функциональность, не охватываемая ядром набор шаблонных примитивов. Вы можете расширить шаблонизатор, определение пользовательских тегов и фильтров с помощью Python, а затем их доступный для ваших шаблонов с помощью тега {% load%} .

Формат кода¶

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

Приложение должно содержать каталог templatetags на том же уровне, что и моделей.py , views.py и т. д. Если этого еще нет, создайте его - не забудьте файл __init__.py , чтобы убедиться, что каталог рассматривается как Пакет Python.

Сервер разработки

не перезапускается автоматически

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

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

Например, если ваши пользовательские теги / фильтры находятся в файле с именем poll_extras.py , макет вашего приложения может выглядеть так:

 опрос /
    __init__.py
    models.py
    templatetags /
        __init__.py
        poll_extras.py
    views.py
 

И в своем шаблоне вы должны использовать следующее:

Приложение, содержащее настраиваемые теги, должно находиться в INSTALLED_APPS в Чтобы тег {% load%} работал.Это функция безопасности: Он позволяет размещать код Python для многих библиотек шаблонов на одном хосте. machine без предоставления доступа ко всем из них для каждой установки Django.

Нет ограничений на количество модулей, которые вы помещаете в пакет templatetags . Просто имейте в виду, что оператор {% load%} загрузит теги / фильтры для данного имени модуля Python, а не для имени приложения.

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

 из шаблона импорта django

register = template.Library ()
 

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

За кадром

Чтобы получить массу примеров, прочтите исходный код фильтров Django по умолчанию. и теги. Они находятся в django / template / defaultfilters.py и django / template / defaulttags.py соответственно.

Для получения дополнительной информации о теге load прочтите его документацию.

Написание пользовательских шаблонных фильтров¶

Пользовательские фильтры - это функции Python, которые принимают один или два аргумента:

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

Например, в фильтре {{var | foo: "bar"}} фильтр foo будет передал переменную var и аргумент «bar» .

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

Вот пример определения фильтра:

 def cut (значение, аргумент):
    "" "Удаляет все значения аргумента из данной строки" ""
    возвращаемое значение.replace (arg, '')
 

А вот пример того, как будет использоваться этот фильтр:

 {{somevariable | cut: "0"}}
 

Большинство фильтров не принимают аргументов. В этом случае оставьте аргумент за рамками своего функция:

 def lower (value): # Только один аргумент."" "Преобразует строку во все строчные буквы" ""
    возвращаемое значение. lower ()
 

Регистрация пользовательских фильтров¶

django.template.Library. фильтр () ¶

После того, как вы написали определение фильтра, вам необходимо зарегистрировать его с помощью ваш экземпляр библиотеки , чтобы сделать его доступным для языка шаблонов Django:

 register.filter ('вырезать', вырезать)
register.filter ('нижний', нижний)
 

Библиотека .Метод filter () принимает два аргумента:

1. Название фильтра - строка.
2. Функция компиляции - функция Python (не имя функция как строка).

Вместо этого вы можете использовать register.filter () в качестве декоратора:

 @ register.filter (имя = 'вырезать')
def cut (значение, аргумент):
    возвращаемое значение.replace (arg, '')

@ register.filter
def lower (значение):
    возвращаемое значение. lower ()
 

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

Наконец, register.filter () также принимает три аргумента ключевого слова, is_safe , needs_autoescape и expects_localtime . Эти аргументы описаны в фильтрах и автоматическом экранировании и фильтры и часовые пояса ниже.

Шаблонные фильтры, ожидающие строк¶

django.template.defaultfilters. струнный фильтр () ¶

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

 из шаблона импорта django
из django.template.defaultfilters импортировать строковый фильтр

register = template.Library ()

@ register.filter
@stringfilter
def lower (значение):
    возвращаемое значение. lower ()
 

Таким образом, вы сможете передать этому фильтру, скажем, целое число, и он не вызовет AttributeError (поскольку целые числа не имеют значения lower () методы).

Фильтры и автоэкранирование¶

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

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

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

  Внутри эти строки имеют тип Сейфстринг . Вы можете проверить их используя код вроде:

   из django.utils.safestring import SafeString
  
  если isinstance (значение, SafeString):
      # Сделайте что-нибудь с "безопасной" строкой.
      ...
   

Код фильтра шаблона попадает в одну из двух ситуаций:

1. Ваш фильтр не вводит символы, небезопасные для HTML ( <, > , ', " или и ) в результат, которого еще не было.В в этом случае вы можете позволить Django позаботиться обо всех автоматических экранированиях. обработка для вас. Все, что вам нужно сделать, это установить флаг is_safe на True когда вы регистрируете свою функцию фильтра, например:

    @ register.filter (is_safe = True)
   def myfilter (значение):
       возвращаемое значение
    

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

   Вы можете понимать это как «этот фильтр безопасен - он не представить любую возможность небезопасного HTML ».

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

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

    @ register.filter (is_safe = True)
   def add_xx (значение):
       вернуть значение% sxx%
    

   Когда этот фильтр используется в шаблоне с включенным автоматическим экранированием, Django будет экранировать вывод, если ввод еще не отмечен как «безопасный».

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

   Будьте осторожны, решая, действительно ли ваш фильтр оставляет безопасные строки как безопасно. Если вы удаляете символов , вы можете случайно оставить несбалансированные HTML-теги или объекты в результате. Например, удаление > из ввода может превратить в , что потребует быть экранированным при выводе, чтобы избежать проблем. Точно так же удаление точка с запятой (; ) может превратиться в & amp; в и , который больше не действительный объект и, следовательно, требует дальнейшего экранирования.В большинстве случаев почти не будет это сложно, но следите за любыми подобными проблемами, когда просмотр вашего кода.

   Пометка фильтра is_safe принудит возвращаемое значение фильтра к строка. Если ваш фильтр должен возвращать логическое или другое нестроковое значение значение, помечая его как is_safe , вероятно, будет иметь непреднамеренное последствия (например, преобразование логического значения False в строку 'Ложь').

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

   Чтобы пометить вывод как безопасную строку, используйте django.utils.safestring.mark_safe () .

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

   Чтобы ваш фильтр знал текущее состояние автоматического экранирования, установите needs_autoescape пометить True при регистрации функции фильтрации. (Если вы не укажете этот флаг, по умолчанию будет Ложь ). Этот флаг сообщает Django, что ваша функция фильтра хочет передать дополнительное ключевое слово аргумент, называемый autoescape , то есть True , если автоматическое экранирование находится в эффект и Ложь в противном случае.Рекомендуется установить значение по умолчанию для autoescape параметр на True , так что если вы вызовете функцию из кода Python по умолчанию будет включено экранирование.

   Например, давайте напишем фильтр, который выделяет первый символ строка:

    из шаблона импорта django
   from django.utils.html import conditional_escape
   из django.utils.safestring import mark_safe
   
   register = template.Library ()
   
   @ register.filter (needs_autoescape = True)
   def initial_letter_filter (текст, autoescape = True):
       first, other = text [0], text [1:]
       если автоэскейп:
           esc = conditional_escape
       еще:
           esc = лямбда x: x
       результат = '% s % s'% (esc (первый), esc (другой))
       return mark_safe (результат)
    

   Флаг needs_autoescape и аргумент ключевого слова autoescape означают что наша функция будет знать, действует ли автоматическое экранирование, когда фильтр называется.Мы используем autoescape , чтобы решить, будут ли входные данные нужно пропустить через django.utils.html.conditional_escape или нет. (В последнем случае мы используем функцию идентичности как функцию «выхода».) Функция conditional_escape () похожа на escape () , за исключением того, что она только экранирует ввод , а не , а экземпляр SafeData . Если SafeData экземпляр передается в conditional_escape () , данные возвращаются без изменений.

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

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

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

Предотвращение XSS-уязвимостей при повторном использовании встроенных фильтров

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

В более старых версиях Django будьте осторожны при повторном использовании встроенных в Django фильтрует как autoescape по умолчанию Нет . Вам нужно будет пройти autoescape = True для автоматического экранирования.

Например, если вы хотите написать собственный фильтр под названием urlize_and_linebreaks , который объединил urlize и linebreaksbr фильтры, фильтр будет выглядеть так:

 из django.template.defaultfilters import linebreaksbr, urlize

@регистр.фильтр (needs_autoescape = True)
def urlize_and_linebreaks (текст, autoescape = True):
    вернуть разрывы строкbr (
        urlize (текст, autoescape = autoescape),
        autoescape = autoescape
    )
 

Тогда:

 {{comment | urlize_and_linebreaks}}
 

будет эквивалентно:

 {{комментарий | urlize | linebreaksbr}}
 

Фильтры и часовые пояса¶

Если вы пишете собственный фильтр, который работает с датой и временем объекты, вы обычно регистрируете его с помощью флага expects_localtime , установленного на Истинно :

 @register.фильтр (extends_localtime = True)
def businesshours (значение):
    пытаться:
        return 9 <= value.hour <17
    кроме AttributeError:
        возвращаться ''
 

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

Написание пользовательских тегов шаблона

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

Простые теги¶

django.template.Library. simple_tag () ¶

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

Чтобы упростить создание тегов этих типов, Django предоставляет вспомогательную функцию, simple_tag . Эта функция, которая является методом django.template.Library , принимает функцию, которая принимает любое количество arguments, оборачивает его в функцию рендеринга и другие необходимые биты упомянутый выше, и регистрирует его в системе шаблонов.

Наша функция current_time , таким образом, может быть записана так:

 дата и время импорта
из шаблона импорта django

register = template.Library ()

@ register.simple_tag
def current_time (форматная_строка):
    вернуть datetime.datetime.now (). strftime (format_string)
 

Несколько замечаний о вспомогательной функции simple_tag :

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

В отличие от других утилит тегов, simple_tag передает свой вывод через conditional_escape () , если контекст шаблона находится в режим автоэскейпа, чтобы гарантировать правильный HTML и защитить вас от XSS уязвимости.

Если дополнительное экранирование нежелательно, вам нужно будет использовать mark_safe () , если вы абсолютно уверены, что ваш код не содержит XSS-уязвимостей. Для создания небольших фрагментов HTML, использование format_html () вместо mark_safe () является настоятельно рекомендуется.

Если вашему тегу шаблона требуется доступ к текущему контексту, вы можете использовать принимает_контекст аргумент при регистрации вашего тега:

 @ register.simple_tag (take_context = True)
def current_time (контекст, формат_строка):
    часовой пояс = контекст ['часовой пояс']
    вернуть your_get_current_time_method (часовой пояс, format_string)
 

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

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

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

 register.simple_tag (лямбда x: x - 1, имя = 'minusone')

@ register.simple_tag (имя = 'minustwo')
def some_function (значение):
    возвращаемое значение - 2
 

simple_tag функции могут принимать любое количество позиционных или ключевых слов аргументы. Например:

 @register.simple_tag
def my_tag (a, b, * args, ** kwargs):
    предупреждение = kwargs ['предупреждение']
    profile = kwargs ['профиль']
    ...
    возвращаться ...
 

Тогда в шаблоне может быть любое количество аргументов, разделенных пробелами. передается в тег шаблона. Как и в Python, значения аргументов ключевого слова задаются знаком равенства (« = ») и должны указываться после позиционные аргументы. Например:

 {% my_tag 123 "abcd" book.title warning = message | lower profile = user.profile%}
 

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

 {% current_time "% Y-% m-% d% I:% M% p" как the_time%}
 Время {{the_time}}. 
 

Теги включения¶

django.template.Library. Тег_кнопки () ¶

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

Такие теги называются «тегами включения».

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

… и вывод будет примерно таким:

 

  
 Первый выбор 
  
 Второй вариант 
  
 Третий вариант 

 

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

 def show_results (опрос):
    choices = poll.choice_set.all ()
    return {'choices': choices}
 

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

 

{% за выбор в вариантах%}
    
 {{choice}} 
{% endfor%}

 

Теперь создайте и зарегистрируйте тег включения, вызвав include_tag () для объекта Library .Следуя нашему примеру, если указанный выше шаблон в файле с именем results.html в каталоге, который выполняет поиск загрузчик шаблонов, мы должны зарегистрировать тег следующим образом:

 # Здесь register - это экземпляр django.template.Library, как и раньше
@ register.inclusion_tag ('results.html')
def show_results (опрос):
    ...
 

В качестве альтернативы можно зарегистрировать тег включения с помощью django.template.Template экземпляр:

 из django.template.loader import get_template
t = get_template ('results.html ')
register.inclusion_tag (t) (show_results)
 

… при первом создании функции.

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

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

 @ register.inclusion_tag ('link.html', take_context = True)
def jump_link (контекст):
    возвращаться {
        'ссылка': контекст ['домашняя_ссылка'],
        'title': context ['home_title'],
    }
 

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

В этой строке register.inclusion_tag () мы указали take_context = True и название шаблона. Вот как может выглядеть шаблон link.html нравится:

 Перейти непосредственно к  {{title}} .
 

Затем, когда вы захотите использовать этот настраиваемый тег, загрузите его библиотеку и вызовите ее без аргументов, вот так:

Обратите внимание, что при использовании take_context = True нет необходимости передавать аргументы тега шаблона.Он автоматически получает доступ к контексту.

Для параметра take_context по умолчанию установлено значение False . Когда он установлен на Истинно , тегу передается объект контекста, как в этом примере. Это Единственная разница между этим случаем и предыдущим примером include_tag .

Include_tag функции могут принимать любое количество позиционных или ключевых слов. аргументы. Например:

 @ register.inclusion_tag ('my_template.html ')
def my_tag (a, b, * args, ** kwargs):
    предупреждение = kwargs ['предупреждение']
    profile = kwargs ['профиль']
    ...
    возвращаться ...
 

Тогда в шаблоне может быть любое количество аргументов, разделенных пробелами. передается в тег шаблона. Как и в Python, значения аргументов ключевого слова задаются знаком равенства (« = ») и должны указываться после позиционные аргументы. Например:

 {% my_tag 123 "abcd" book.title warning = message | lower profile = user.profile%}
 

Краткий обзор¶

Система шаблонов работает в два этапа: компиляция и рендеринг.К определить настраиваемый тег шаблона, вы указываете, как работает компиляция и как рендеринг работает.

Когда Django компилирует шаблон, он разбивает необработанный текст шаблона на «Узлы». Каждый узел является экземпляром django.template.Node и имеет метод render () . Скомпилированный шаблон - это список из объектов Node . Когда вы вызываете render () для скомпилированного объекта шаблона, шаблон вызывает render () на каждом узле в своем списке узлов с заданным контекстом.В все результаты объединяются вместе для формирования выходных данных шаблона.

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

Написание функции компиляции¶

Для каждого тега шаблона, с которым сталкивается синтаксический анализатор, он вызывает Python с содержимым тега и самим объектом парсера. Эта функция отвечает за возврат экземпляра Node на основе содержимого тега.

Например, давайте напишем полную реализацию нашего тега шаблона, {% current_time%} , который отображает текущую дату / время в формате параметру, указанному в теге, в синтаксисе strftime () . Это хорошо идея решить синтаксис тега прежде всего. В нашем случае, скажем, тег следует использовать так:

 
 Время: {% current_time "% Y-% m-% d% I:% M% p"%}. 
 

Синтаксический анализатор для этой функции должен захватить параметр и создать Узел объект:

 из шаблона импорта django

def do_current_time (парсер, токен):
    пытаться:
        # split_contents () знает, что строки в кавычках не следует разделять.tag_name, format_string = token.split_contents ()
    кроме ValueError:
        поднять template.TemplateSyntaxError (
            "Тег% r требует одного аргумента"% token.contents.split () [0]
        )
    если нет (format_string [0] == format_string [-1] и format_string [0] в ('"'," '")):
        поднять template.TemplateSyntaxError (
            "Аргумент тега% r должен быть в кавычках"% tag_name
        )
    return CurrentTimeNode (format_string [1: -1])
 

Примечания:

• синтаксический анализатор - объект синтаксического анализатора шаблона.Нам это не нужно в этом пример.
• token.contents - строка необработанного содержимого тега. В нашем Например, это 'current_time "% Y-% m-% d% I:% M% p"' .
• Метод token.split_contents () разделяет аргументы пробелами сохраняя строки в кавычках вместе. Более простой token.contents.split () не будет таким надежным, как наивно разделить на все пробелов, включая те, которые заключены в строки в кавычках.Это хорошо идея всегда использовать token.split_contents () .
• Эта функция отвечает за поднятие django.template.TemplateSyntaxError , с полезными сообщениями, для любая синтаксическая ошибка.
• Исключения TemplateSyntaxError используют переменную tag_name . Не жестко кодируйте имя тега в сообщениях об ошибках, потому что это связывает имя тега с вашей функцией. token.contents.split () [0] будет «всегда» именем вашего тега, даже если в теге нет аргументы.
• Функция возвращает CurrentTimeNode со всем, что нужно узлу. чтобы узнать об этом теге. В этом случае он передает аргумент - "% Y-% m-% d% I:% M% p" . Начальные и конечные котировки из тег шаблона удаляется в format_string [1: -1] .
• Синтаксический анализ находится на очень низком уровне. Разработчики Django экспериментировали с написанием небольших фреймворков поверх этой системы синтаксического анализа, используя методы, такие как грамматики EBNF, но эти эксперименты сделали шаблон двигатель слишком медленный.Это низкий уровень, потому что он самый быстрый.

Написание средства визуализации¶

Второй шаг в написании пользовательских тегов - определение подкласса Node , который имеет метод render () .

Продолжая приведенный выше пример, нам нужно определить CurrentTimeNode :

 дата и время импорта
из шаблона импорта django

класс CurrentTimeNode (template.Node):
    def __init __ (self, format_string):
        self.format_string = format_string

    def render (self, context):
        дата и время возврата.datetime.now (). strftime (self.format_string)
 

Примечания:

• __init __ () получает format_string из do_current_time () . Всегда передавайте любые параметры / параметры / аргументы на узел Node через его __init __ () .
• Метод render () - это то место, где на самом деле происходит работа.
• render () обычно должен терпеть неудачу, особенно в производственной среде. среда. Однако в некоторых случаях, особенно если контекст.template.engine.debug is True , этот метод может вызвать исключение, чтобы упростить отладку. Например, несколько основных тегов повышают django.template.TemplateSyntaxError , если они получают неправильный номер или тип аргументов.

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

Соображения об автоматическом экранировании¶

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

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

Кроме того, если тег шаблона создает новый контекст для выполнения некоторых суб-рендеринга, установите для атрибута auto-escape значение текущего контекста. Метод __init__ для класса Context принимает параметр, называемый autoescape , который можно использовать для этой цели. Например:

 из контекста импорта django.template

def render (self, context):
    # ...
    new_context = Контекст ({'var': obj}, autoescape = context.autoescape)
    # ... Сделайте что-нибудь с new_context...
 

Это не очень распространенная ситуация, но она полезна, если вы визуализируете шаблон себя. Например:

 def render (self, context):
    t = context.template.engine.get_template ('small_fragment.html')
    вернуть t.render (Context ({'var': obj}, autoescape = context.autoescape))
 

Если бы мы не передали текущее значение context.autoescape нашему новый Контекст в этом примере результат будет всегда автоматически экранирован, что может быть нежелательным, если шаблон Тег используется внутри блока {% autoescape off%} .

Соображения безопасности потоков¶

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

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

 {% для o в some_list%}
    
        ...
    
{% endfor%}
 

Наивная реализация CycleNode может выглядеть примерно так:

 импорт itertools
из шаблона импорта django

класс CycleNode (template.Node):
    def __init __ (self, cyclevars):
        self.cycle_iter = itertools.cycle (циклические переменные)

    def render (self, context):
        вернуться далее (self.cycle_iter)
 

Но предположим, что у нас есть два шаблона, отображающих фрагмент шаблона сверху на одновременно:

1. Поток 1 выполняет свою первую итерацию цикла, CycleNode.render () возвращает "row1"
2. Поток 2 выполняет свою первую итерацию цикла, CycleNode.render () возвращает "row2"
3. Поток 1 выполняет вторую итерацию цикла, CycleNode.render () возвращает "row1"
4. Поток 2 выполняет вторую итерацию цикла, CycleNode.рендеринг () возвращает "row2"

CycleNode повторяется, но повторяется глобально. Что касается потока 1 и поток 2, он всегда возвращает одно и то же значение. Это не то что мы хотим!

Для решения этой проблемы Django предоставляет render_context , связанный с с контекстом шаблона, который в настоящее время обрабатывается. В render_context ведет себя как словарь Python, и его следует использовать для сохранить состояние узла между вызовами метода визуализации .

Давайте реорганизуем нашу реализацию CycleNode , чтобы использовать render_context :

 класс CycleNode (template.Node):
    def __init __ (self, cyclevars):
        self.cyclevars = cyclevars

    def render (self, context):
        если я не в context.render_context:
            context.render_context [self] = itertools.cycle (self.cyclevars)
        cycle_iter = context.render_context [сам]
        вернуться далее (cycle_iter)
 

Обратите внимание, что хранить глобальную информацию, которая не изменится, совершенно безопасно. на протяжении всего срока службы Node как атрибута.В случае CycleNode , аргумент cyclevars не изменяется после того, как Node создан, поэтому нам не нужно помещать его в render_context . Но государство информация, относящаяся к текущему отображаемому шаблону, как и текущая итерация CycleNode , должна быть сохранена в рендеринг_контекст .

Примечание

Обратите внимание, как мы использовали self для определения конкретной информации CycleNode в пределах render_context .Может быть несколько CycleNodes в данного шаблона, поэтому нам нужно быть осторожными, чтобы не повредить другой узел государственная информация. Самый простой способ сделать это - всегда использовать self как ключ в render_context . Если вы отслеживаете несколько состояний переменных, сделайте render_context [self] словарем.

Регистрация тега¶

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

 register.tag ('текущее_время', do_current_time)
 

Метод tag () принимает два аргумента:

1. Название тега шаблона - строка. Если это не указано, будет использовано имя функции компиляции.
2. Функция компиляции - функция Python (не имя функция как строка).

Как и в случае регистрации фильтра, его также можно использовать в качестве декоратора:

 @ register.tag (name = "current_time")
def do_current_time (парсер, токен):
    ...

@ register.tag
def крик (парсер, токен):
    ...
 

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

Передача переменных шаблона в тег¶

Хотя вы можете передать любое количество аргументов тегу шаблона, используя token.split_contents () , все аргументы распаковываются как строковые литералы. Требуется немного больше работы, чтобы пройти динамический content (переменная шаблона) в тег шаблона в качестве аргумента.

В то время как предыдущие примеры форматировали текущее время в строку и вернул строку, предположим, вы хотите передать DateTimeField из объекта и иметь шаблон формат тега, дата-время:

 
 Это сообщение последний раз обновлялось в {% format_time blog_entry.date_updated "% Y-% m-% d% I:% M% p"%}. 
 

Изначально token.split_contents () вернет три значения:

1. Имя тега format_time .
2. Строка 'blog_entry.date_updated' (без окружающего Котировки).
3. Строка форматирования '"% Y-% m-% d% I:% M% p"' . Возвращаемое значение из split_contents () будет включать начальные и конечные кавычки для строковые литералы вроде этого.

Теперь ваш тег должен выглядеть так:

 из шаблона импорта django

def do_format_time (парсер, токен):
    пытаться:
        # split_contents () знает, что строки в кавычках не следует разделять.tag_name, date_to_be_formatted, format_string = token.split_contents ()
    кроме ValueError:
        поднять template.TemplateSyntaxError (
            «Тег% r требует ровно два аргумента»% token.contents.split () [0]
        )
    если нет (format_string [0] == format_string [-1] и format_string [0] в ('"'," '")):
        поднять template.TemplateSyntaxError (
            "Аргумент тега% r должен быть в кавычках"% tag_name
        )
    вернуть FormatTimeNode (date_to_be_formatted, format_string [1: -1])
 

Вы также должны изменить средство визуализации, чтобы получить фактическое содержимое date_updated свойство объекта blog_entry .Это может быть достигается с помощью класса Variable () в django.template .

Чтобы использовать класс Variable , создайте его экземпляр с именем переменной для быть разрешенным, а затем вызвать variable.resolve (context) . Так, например:

 класс FormatTimeNode (template.Node):
    def __init __ (self, date_to_be_formatted, format_string):
        self.date_to_be_formatted = template.Variable (date_to_be_formatted)
        self.format_string = format_string

    def render (self, context):
        пытаться:
            фактическая_дата = сам.date_to_be_formatted.resolve (контекст)
            вернуть actual_date.strftime (self.format_string)
        кроме template.VariableDoesNotExist:
            возвращаться ''
 

Разрешение переменной вызовет исключение VariableDoesNotExist , если оно не может разрешить переданную ему строку в текущем контексте страницы.

Установка переменной в контексте¶

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

Чтобы установить переменную в контексте, используйте назначение словаря в контексте объект в методе render () . Вот обновленная версия CurrentTimeNode , который устанавливает переменную шаблона current_time вместо выводя его:

 дата и время импорта
из шаблона импорта django

класс CurrentTimeNode2 (template.Node):
    def __init __ (self, format_string):
        себя.format_string = формат_строка
    def render (self, context):
        контекст ['current_time'] = datetime.datetime.now (). strftime (self.format_string)
        возвращаться ''
 

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

Вот как вы бы использовали эту новую версию тега:

 {% current_time "% Y-% m-% d% I:% M% p"%} 
 Время {{current_time}}.
 

Область действия переменной в контексте

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

Но есть проблема с CurrentTimeNode2 : имя переменной current_time жестко запрограммирован. Это означает, что вам нужно убедиться, что ваш шаблон не использует {{current_time}} где-либо еще, потому что {% current_time%} слепо перезапишет значение этой переменной.Уборщица решение - сделать так, чтобы тег шаблона указывал имя выходной переменной, вот так:

 {% current_time "% Y-% m-% d% I:% M% p" как my_current_time%}
 Текущее время: {{my_current_time}}. 
 

Для этого вам потребуется рефакторинг как функции компиляции, так и Node . класс, вот так:

 импорт ре

класс CurrentTimeNode3 (template.Node):
    def __init __ (self, format_string, var_name):
        self.format_string = format_string
        себя.var_name = var_name
    def render (self, context):
        контекст [self.var_name] = datetime.datetime.now (). strftime (self.format_string)
        возвращаться ''

def do_current_time (парсер, токен):
    # В этой версии для анализа содержимого тега используется регулярное выражение.
    пытаться:
        # Разделение по None == разделение по пробелам.
        tag_name, arg = token.contents.split (Нет, 1)
    кроме ValueError:
        поднять template.TemplateSyntaxError (
            "Тегу% r требуются аргументы"% token.contents.split () [0]
        )
    m = re.search (r '(. *?) as (\ w +)', arg)
    если не m:
        поднять template.TemplateSyntaxError ("тег% r имел недопустимые аргументы"% tag_name)
    format_string, var_name = m.groups ()
    если нет (format_string [0] == format_string [-1] и format_string [0] в ('"'," '")):
        поднять template.TemplateSyntaxError (
            "Аргумент тега% r должен быть в кавычках"% tag_name
        )
    return CurrentTimeNode3 (format_string [1: -1], var_name)
 

Разница здесь в том, что do_current_time () захватывает строку формата и имя переменной, передавая оба значения на CurrentTimeNode3 .

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

Разбор до следующего тега блока¶

Теги шаблонов могут работать в тандеме. Например, стандарт {% comment%} Тег скрывает все до {% endcomment%} . Чтобы создать такой шаблонный тег, используйте парсер .parse () в вашем функция компиляции.

Вот как можно реализовать упрощенный тег {% comment%} :

 def do_comment (парсер, токен):
    nodelist = parser.parse (('конец комментария',))
    parser.delete_first_token ()
    вернуть CommentNode ()

класс CommentNode (template.Node):
    def render (self, context):
        возвращаться ''
 

Примечание

Фактическая реализация {% comment%} немного отличается тем, что позволяет неработающим тегам шаблона появляться между {% comment%} и {% endcomment%} .Он делает это, вызывая parser.skip_past ('endcomment') вместо parser.parse (('endcomment',)) за которым следует parser.delete_first_token () , что позволяет избежать генерации список узлов.

parser.parse () принимает кортеж имен блочных тегов ‘’ для синтаксического анализа до ’’. Это возвращает экземпляр django.template.NodeList , который является списком все объекты Node , с которыми синтаксический анализатор столкнулся "до" " любой из тегов, указанных в кортеже.

В "nodelist = parser.parse (('endcomment',))" в приведенном выше примере, nodelist - это список всех узлов между {% comment%} и {% endcomment%} , не считая {% comment%} и {% endcomment%} сами себя.

После вызова parser.parse () , синтаксический анализатор еще не «поглотил» {% endcomment%} , поэтому код должен явно вызывать parser.delete_first_token () .

CommentNode.render () возвращает пустую строку. Что-нибудь между {% comment%} и {% endcomment%} игнорируются.

Разбор до следующего тега блока и сохранение содержимого¶

В предыдущем примере do_comment () отбрасывает все, что находится между {% comment%} и {% endcomment%} . Вместо этого можно что-то сделать с кодом между тегами блоков.

Например, вот пользовательский тег шаблона {% upper%} , в котором заглавные буквы все между собой и {% endupper%} .

использование:

 {% upper%} Это будет отображаться в верхнем регистре, {{your_name}}. {% Endupper%}
 

Как и в предыдущем примере, мы будем использовать parser.parse () . Но на этот раз мы передать полученный список узлов на узел :

 def do_upper (парсер, токен):
    nodelist = parser.parse (('конец',))
    parser.delete_first_token ()
    вернуть UpperNode (список узлов)

класс UpperNode (template.Node):
    def __init __ (себя, список узлов):
        себя.nodelist = список узлов
    def render (self, context):
        output = self.nodelist.render (контекст)
        вернуть output.upper ()
 

Единственная новая концепция здесь - это self.nodelist.render (context) в UpperNode.render () .

Дополнительные примеры сложного рендеринга см. В исходном коде {% для%} в django / template / defaulttags.py и {% if%} в django / template / smartif.py .

Создание тем - Пеликан 3.6.3 документация

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

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

Общие переменные

Все эти настройки будут доступны для всех шаблонов.

Переменная	Описание
выходной_файл	Имя файла, создаваемого в данный момент.Для например, когда Пеликан отображает главную страницу, выходной_файл будет «index.html».
артикулов	Список статей, упорядоченный по дате. Все элементы являются объектами Article , поэтому вы можете доступ к их атрибутам (например, заголовок, резюме, автор так далее.). Иногда это затеняется (например, в страницу тегов). Затем вы найдете информацию об этом в переменной all_articles .
даты	Тот же список статей, но упорядоченный по дате, по возрастанию.
черновики	Список проектов статей
тегов	Список кортежей (тегов, статей), содержащий все теги.
категории	Список кортежей (категорий, статей), содержащих все категории и соответствующие статьи (значения)
страниц	Список страниц
hidden_pages	Список скрытых страниц

Сортировка

оберток URL (в настоящее время категории, теги и авторы), имеют методы сравнения, позволяющие легко сортировать их по имени:

 {% для тега, статьи в тегах | sort%}
 

Если вы хотите отсортировать по разным критериям, сортировка Jinja У команды есть несколько опций.

Форматирование даты

Пеликан форматирует дату в соответствии с вашими настройками и локалью. ( DATE_FORMATS / DEFAULT_DATE_FORMAT ) и предоставляет locale_date атрибут. С другой стороны, атрибут дата будет быть объектом datetime. Если вам нужно настраиваемое форматирование даты отличается от ваших настроек, используйте фильтр Jinja strftime что идет с Пеликаном. Использование такое же, как в формате Python strftime, но фильтр сделает все правильно и отформатирует дату в соответствии с на локаль, указанную в ваших настройках:

 {{article.date | strftime ('% d% B% Y')}}
 

index.html

Это домашняя страница или индекс вашего блога, созданный по адресу index.html .

Если разбивка на страницы активна, последующие страницы будут находиться в индексе {number} .html .

Переменная	Описание
article_paginator	Объект пагинатора для списка статей
статей_страница	Текущая страница статей
статей_предыдущая_страница	Предыдущая страница статей ( Нет , если страница есть не существует)
article_next_page	Следующая страница статей ( Нет , если страница есть не существует)
date_paginator	Объект разбиения на страницы для списка статей, упорядоченный по дата по возрастанию.
date_page	Текущая страница статей, отсортированных по дате, по возрастанию.
даты_предыдущая_страница	Предыдущая страница статей, отсортированных по дате, по возрастанию ( Нет , если страница не существует)
даты_следующая_страница	Следующая страница статей, отсортированных по дате, по возрастанию ( Нет , если страница не существует)
имя_страницы	«index» - полезно для ссылок на страницы

автор.HTML

Этот шаблон будет обработан для каждого из существующих авторов, с вывод создается в соответствии с настройкой AUTHOR_SAVE_AS ( По умолчанию: author / {author_name} .html ). Если пагинация активна, последующие страницы будут по умолчанию находится по адресу author / {author_name} {number} .html .

Переменная	Описание
автор	Имя обрабатываемого автора
артикулов	Статьи этого автора
даты	Статьи этого автора, упорядоченные по дате, по возрастанию
article_paginator	Объект пагинатора для списка статей
статей_страница	Текущая страница статей
статей_предыдущая_страница	Предыдущая страница статей ( Нет , если страница есть не существует)
article_next_page	Следующая страница статей ( Нет , если страница есть не существует)
date_paginator	Объект разбиения на страницы для списка статей, упорядоченный по дата по возрастанию.
date_page	Текущая страница статей, отсортированных по дате, по возрастанию.
даты_предыдущая_страница	Предыдущая страница статей, отсортированных по дате, по возрастанию ( Нет , если страница не существует)
даты_следующая_страница	Следующая страница статей, отсортированных по дате, по возрастанию ( Нет , если страница не существует)
имя_страницы	AUTHOR_URL, где все после {slug} - удалено - полезно для нумерации ссылок

Категория

.HTML

Этот шаблон будет обработан для каждой из существующих категорий, с вывод создается в соответствии с настройкой CATEGORY_SAVE_AS ( По умолчанию: category / {category_name} .html ). Если пагинация активна, последующие страницы будут по умолчанию находится в категории category / {category_name} {number} .html .

Переменная	Описание
категория	Название обрабатываемой категории
артикулов	Статей в этой категории
даты	статей в этой категории, упорядоченных по дате, по возрастанию
article_paginator	Объект пагинатора для списка статей
статей_страница	Текущая страница статей
статей_предыдущая_страница	Предыдущая страница статей ( Нет , если страница есть не существует)
article_next_page	Следующая страница статей ( Нет , если страница есть не существует)
date_paginator	Объект разбиения на страницы для списка статей, упорядочено по дате, по возрастанию
date_page	Текущая страница статей, отсортированных по дате, по возрастанию
даты_предыдущая_страница	Предыдущая страница статей, отсортированных по дате, по возрастанию ( Нет , если страница не существует)
даты_следующая_страница	Следующая страница статей, отсортированных по дате, по возрастанию ( Нет , если страница не существует)
имя_страницы	CATEGORY_URL, где все после {slug} - удалено - полезно для нумерации ссылок

статья.HTML

Этот шаблон будет обрабатываться для каждой статьи с вывод создается в соответствии с настройкой ARTICLE_SAVE_AS ( По умолчанию: {article_name} .html ). Следующие переменные доступны, когда рендеринг.

Переменная	Описание
артикул	Отображаемый объект статьи
категория	Название категории для текущей статьи

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

Например, вы можете добавить в свою статью поле под названием FacebookImage . метаданные, как показано ниже:

 Название: Питон люблю больше музыки
Дата: 06.11.2013, 10:06
Теги: личные, питон
Категория: Техника
Слизень: python-je-l-aime-a-mourir
Автор: Фрэнсис Кабрель
FacebookImage: http://franciscabrel.com/images/pythonlove.png
 

Эти новые метаданные будут доступны как статья .facebookimage в вашем article.html шаблон. Это позволит вам, например, указать изображение для тегов открытого графика Facebook, которое будет изменяться для каждой статьи:

page.html

Этот шаблон будет обрабатываться для каждой страницы с вывод создается в соответствии с настройкой PAGE_SAVE_AS ( По умолчанию: страниц / {page_name} .html ). Следующие переменные доступны, когда рендеринг.

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

tag.html

Этот шаблон будет обрабатываться для каждого тега с вывод создается в соответствии с настройкой TAG_SAVE_AS ( По умолчанию: тег / {tag_name} .html ). Если пагинация активна, последующие страницы будут по умолчанию размещаются в теге / {tag_name} {number}.html .

Переменная	Описание
тег	Имя обрабатываемого тега
артикулов	Статьи, связанные с этим тегом
даты	статей, связанных с этим тегом, но упорядоченных по дате, по возрастанию
article_paginator	Объект пагинатора для списка статей
статей_страница	Текущая страница статей
статей_предыдущая_страница	Предыдущая страница статей ( Нет , если страница есть не существует)
article_next_page	Следующая страница статей ( Нет , если страница есть не существует)
date_paginator	Объект разбиения на страницы для списка статей, упорядочено по дате, по возрастанию
date_page	Текущая страница статей, отсортированных по дате, по возрастанию
даты_предыдущая_страница	Предыдущая страница статей, отсортированных по дате, по возрастанию ( Нет , если страница не существует)
даты_следующая_страница	Следующая страница статей, отсортированных по дате, по возрастанию ( Нет , если страница не существует)
имя_страницы	TAG_URL, где все после {slug} удаляется - полезны для нумерации ссылок

period_archives.HTML

Этот шаблон будет обрабатываться для каждого года ваших сообщений, если путь для YEAR_ARCHIVE_SAVE_AS определяется, каждый месяц, если MONTH_ARCHIVE_SAVE_AS определен, и каждый день, если определен DAY_ARCHIVE_SAVE_AS .

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

Вы можете увидеть пример того, как использовать период в «простой» теме. period_archives.html шаблон.

Учебное пособие по шаблонам

Django - Создание простого шаблона

Добро пожаловать в учебник по шаблонам Django. В этом уроке мы создадим очень простой шаблон Django. Я уже опубликовал пару руководств по началу работы с Python Django Framework. В этом руководстве по шаблонам Django мы увидим, как создать простой шаблон.

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

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

Что такое шаблон?

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

Шаблоны в Django

Если я скажу вам, что такое шаблоны в Django, то ответ будет: «Шаблон Django - это последовательность текста, которая помогает отделить уровень представления документа от его данных».

Почему именно шаблоны?

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

.

из django.http import HttpResponse def index (запрос): return HttpResponse ("

Добро пожаловать в приложение Python Django для почтовой системы

")

из django.http import HttpResponse def index (request): return HttpResponse (" Добро пожаловать в приложение Python Django почтовой системы ")

Как видите, мы жестко запрограммировали HTML внутри HttpResponse, и это неудобный способ создания страницы.Потребуется больше усилий. А также, когда нам нужно изменить дизайн страницы, нам нужно сместить код Python. Вот почему мы отделяем уровень представления от кода Python. И мы узнаем, КАК это сделать, в этом руководстве по шаблонам Django .

Учебное пособие по шаблонам Django

Теперь давайте приступим к нашему руководству по шаблонам Django, поскольку теперь мы знаем, зачем нам это нужно. Я использую PyCharm (но поскольку Community Edition не поддерживает Django, вам нужно использовать PowerShell для командной строки для создания проекта, затем вы можете открыть проект в PyCharm или любом другом редакторе исходного кода, таком как Sublime и т. Д.c.

Создание нового проекта Django

• Запустите эту команду, чтобы создать новый проект.

django-admin startproject MyDjangoApp

django-admin startproject MyDjangoApp

• Теперь откройте созданный проект с помощью PyCharm. (Вы также можете использовать Sublime Notepad ++).

Создание views.py

Чтобы определить наши представления внутри проекта, мы создадим новый файл с именем views. admin /', admin.firsttemplate / ', views.index),

]

Что мы сделали?

Приведенный выше код очень прост, и мы уже делали это в предыдущем уроке о , создавая простое представление в django.

Создание шаблона

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

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

• Щелкните правой кнопкой мыши папку шаблонов, которую мы создали, и перейдите в новый-> html файл , введите имя файла и нажмите «Создать». Я создал index.html.

Наш первый шаблон

Наш первый шаблон

• Выше вы видите очень простой HTML-файл.И это на самом деле наш шаблон.

Определение каталога шаблонов в настройках

• Недостаточно только создания папки, нам нужно определить папку в settings.py . См. Изображение ниже.

• Этот шаг очень важен, иначе вы получите TemplateNotFoundException .

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

Шаблон будет отображаться в режиме просмотра. Но на этот раз нам не нужно жестко кодировать html внутри нашего кода Python.Поскольку мы уже разделили html, теперь это отдельный файл.

Для визуализации созданного шаблона выполните следующие действия.

• Войдите в файл views.py , который мы создали. И напишите следующий код.

из django.http import HttpResponse # импорт загрузки из шаблона django из загрузчика импорта django.template # наше представление, которое является функцией с именем index def index (запрос): # получение нашего шаблона шаблон = загрузчик.get_template ('index.html') # рендеринг шаблона в HttpResponse вернуть HttpResponse (template.render ())

из django.http import HttpResponse # импорт загрузки из шаблона django из загрузчика импорта django.template # наше представление, которое является функцией с именем index # получение нашего шаблона template = loader.get_template ('index.html') # рендеринг шаблона в HttpResponse return HttpResponse (template.render ())

Что мы сделали?

В приведенном выше коде сначала мы импортировали загрузчик. Нам нужно загрузить шаблон.

Затем у нас есть функция с именем index, и на самом деле запрос принимает наше представление.

Внутри функции мы создали наш шаблон из загрузчика.

И, наконец, мы визуализируем шаблон в HttpResponse.

Запуск вашего проекта

• Теперь попробуем запустить наш проект. Итак, снова запустите команду python manage.py runserver в терминале внутри PyCharm.
• http://127.0.0.1:8000/firsttemplate/
• Перейдите по указанному выше URL-адресу, и вы увидите созданный нами шаблон.

• БИНГО! наш шаблон успешно обработан.

Передача значений в шаблон

• Мы также можем передавать значения в наш шаблон. Это необходимо, когда мы создаем динамическое веб-приложение. Итак, давайте посмотрим, как мы можем это сделать. Это довольно просто. Просто следуйте этим шагам.
• Перейдите в файл шаблона index.html и измените его следующим образом:

Профиль пользователя

<таблица> Имя {{имя}} Имя отца {{fname}} Курс {{курс}} Адрес {{адрес}}

1 2 3 4 5 6 7 8 9 10 11 12 13 140002 18 19 20 21 22 23 24 25 26 27 28 29 31

Профиль пользователя Имя {{name}} Имя отца {{fname}} Курс {{course}} Адрес {{address}}

Что мы сделали?

В приведенном выше html файле мы только что создали простую таблицу.И там, где мы хотим передать значение переменной, мы написали переменную вместо статического HTML. Просто помните, где бы мы ни поместили переменную на html-странице, нам нужно записать ее между {{}}.

• Теперь при рендеринге шаблона мы передадим необходимые значения. Итак, войдите в файл views.py и измените его следующим образом.

из django.http import HttpResponse # импорт загрузки из шаблона django из джанго.загрузчик импорта шаблонов # наше представление, которое является функцией с именем index def index (запрос): # получение нашего шаблона template = loader.get_template ('index.html') # создание значений для передачи context = { 'name': 'Белал Хан', 'fname': 'Азад Хан', 'course': 'Python Django Framework', 'адрес': 'Канке, Ранчи, Индия', } # рендеринг шаблона в HttpResponse # но на этот раз передача контекста и запроса вернуть HttpResponse (template.рендеринг (контекст, запрос))

1 2 3 4 5 6 7 8 9 10 11 12 13 140002 18 19 20 21 22 23 24

из django.http import HttpResponse # импорт загрузки из шаблона django из загрузчика импорта django.template # наше представление, которое является функцией с именем index def index (request): наш шаблон # получение template = loader.get_template ('index.html') # создание значений для передачи context = { 'name': 'Belal Khan', 'fname': 'Azad Khan' , 'course': 'Python Django Framework', 'address': 'Kanke, Ranchi, India', } # рендеринг шаблона в HttpResponse # но на этот раз передача контекста и запрос возврат HttpResponse (template. No related posts. alexxlab Автор записи Добавить комментарий Отменить ответ Ваш адрес email не будет опубликован. Обязательные поля помечены * Комментарий * Имя * Email * Сайт