Система шаблонов Django: как использовать для создания динамических сайтов

Пройдите тест, узнайте какой профессии подходите

Сколько вам лет

До 18

От 18 до 24

От 25 до 34

От 35 до 44

От 45 до 49

От 50 до 54

Больше 55

Для кого эта статья:

Python-разработчики, желающие углубить знания в Django
Новички в веб-разработке, заинтересованные в изучении фреймворка Django
Опытные разработчики, ищущие советы по оптимизации и расширению функциональности шаблонов Django
Django — это грозное оружие в арсенале каждого Python-разработчика. И система шаблонов — один из тех механизмов, которые делают Django столь мощным фреймворком. Представьте: вы можете писать HTML-код, динамически вставлять в него данные и управлять логикой отображения — и всё это без необходимости смешивать представление с бизнес-логикой! Неважно, разрабатываете ли вы свой первый проект или уже создали десятки приложений на Django — глубокое понимание системы шаблонов даст вам серьёзное преимущество. 🚀

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

Основы системы шаблонов в Django

Система шаблонов Django — это мощный инструмент, позволяющий отделить логику представления от бизнес-логики приложения. По сути, шаблоны — это текстовые файлы, которые могут генерировать любой текстовый формат (HTML, XML, CSV и т.д.). Они содержат статические части желаемого документа, а также специальный синтаксис, описывающий, как должны быть вставлены динамические части.

Шаблоны Django основываются на нескольких ключевых концепциях:

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

Рассмотрим пример простого шаблона:

HTML

Скопировать код

<!DOCTYPE html>
<html>
<head>
<title>{{ page_title }}</title>
</head>
<body>
<h1>{{ header }}</h1>

{% if user_list %}
<ul>
{% for user in user_list %}
<li>{{ user.username|title }}</li>
{% endfor %}
</ul>
{% else %}
<p>Пользователи не найдены.</p>
{% endif %}
</body>
</html>

В этом примере:

{{ page_title }} и {{ header }} — переменные
{% if %}, {% for %} — теги, управляющие логикой
{{ user.username|title }} — использование фильтра title, который делает первую букву каждого слова заглавной

Элемент	Синтаксис	Назначение
Переменная	`{{ variable }}`	Вставляет значение переменной из контекста
Тег	`{% tag %}`	Выполняет логические операции
Фильтр	`{{ variable\|filter }}`	Модифицирует значение переменной
Комментарий	`{# comment #}`	Не отображается в финальном HTML

Система шаблонов Django спроектирована с учетом безопасности. Она автоматически экранирует потенциально опасные символы (например, HTML-теги) в переменных, чтобы предотвратить XSS-атаки. Если вам необходимо отключить это поведение, используйте фильтр safe или тег {% autoescape off %}.

Александр Петров, Django-разработчик с 7-летним опытом

Когда я только начинал работать с Django, мне было сложно понять, как правильно структурировать шаблоны. В одном из проектов я создал страницу с формой регистрации, но столкнулся с проблемой: форма не отображалась корректно на мобильных устройствах.
Проблема заключалась в неправильном понимании работы контекста шаблона. Я передавал объект формы, но не учитывал, что некоторые поля требуют специальной обработки. После изучения документации я осознал, что Django автоматически экранирует HTML в переменных, а для поля с CAPTCHA требовалось использовать фильтр safe.
Мой код изменился с:
HTML
Скопировать код
{{ form.captcha }}
на:
HTML
Скопировать код
{{ form.captcha|safe }}
Это простое изменение решило проблему, и с тех пор я очень внимательно отношусь к контексту и безопасности шаблонов. Сейчас это кажется очевидным, но для новичка такие нюансы могут быть неочевидны.

Настройка и структура шаблонов при создании приложения

При создании нового приложения на Django необходимо правильно настроить и структурировать шаблоны. Рассмотрим этот процесс пошагово. 🛠️

1. Настройка путей к шаблонам

В файле settings.py проекта необходимо указать, где Django должен искать шаблоны:

Python

Скопировать код

TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]

Здесь важны два параметра:

DIRS — список директорий, в которых Django будет искать шаблоны
APP_DIRS: True — указывает Django искать шаблоны в подкаталоге templates каждого установленного приложения

2. Структура каталогов

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

Вариант 1: Шаблоны на уровне проекта

plaintext

Скопировать код

myproject/
templates/
base.html
home.html
app1/
feature.html
app2/
dashboard.html

Вариант 2: Шаблоны на уровне приложений

plaintext

Скопировать код

myproject/
app1/
templates/
app1/
feature.html
app2/
templates/
app2/
dashboard.html

Второй вариант предпочтительнее, так как:

Улучшает модульность приложений
Предотвращает конфликты имен шаблонов
Облегчает перенос приложений между проектами

Обратите внимание на дополнительную вложенность (app1/templates/app1/feature.html) — это предотвращает конфликты имен при использовании APP_DIRS: True.

3. Использование шаблонов в представлениях

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

Python

Скопировать код

# Представление на основе функции
def home_view(request):
context = {'title': 'Главная страница'}
return render(request, 'myapp/home.html', context)

# Представление на основе класса
class HomeView(TemplateView):
template_name = 'myapp/home.html'

def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['title'] = 'Главная страница'
return context

Тип представления	Способ указания шаблона	Способ передачи контекста
Функция	Аргумент функции `render()`	Словарь `context`
`TemplateView`	Атрибут `template_name`	Метод `get_context_data()`
`ListView`	Атрибут `template_name`	Автоматически передает `object_list`
`DetailView`	Атрибут `template_name`	Автоматически передает `object`

4. Контекстные процессоры

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

Python

Скопировать код

# myapp/context_processors.py
def site_settings(request):
return {
'site_name': 'Мой сайт на Django',
'current_year': datetime.datetime.now().year
}

# Добавление в settings.py
TEMPLATES = [
{
# ...
'OPTIONS': {
'context_processors': [
# ...
'myapp.context_processors.site_settings',
],
},
},
]

После этих настроек переменные site_name и current_year будут доступны во всех шаблонах проекта.

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

Наследование шаблонов — одна из самых мощных функций системы шаблонов Django. Эта концепция позволяет создать базовый "скелет" сайта с общими элементами (header, footer, меню) и затем расширять его для отдельных страниц. 🏗️

Рассмотрим пример создания структуры шаблонов с наследованием:

1. Базовый шаблон (base.html)

HTML

Скопировать код

<!DOCTYPE html>
<html>
<head>
<title>{% block title %}Мой сайт{% endblock %}</title>
<link rel="stylesheet" href="/static/css/main.css">
{% block extra_css %}{% endblock %}
</head>
<body>
<header>
<nav>
<ul>
<li><a href="{% url 'home' %}">Главная</a></li>
<li><a href="{% url 'about' %}">О нас</a></li>
<li><a href="{% url 'contact' %}">Контакты</a></li>
</ul>
</nav>
</header>

<main>
{% block content %}
<p>Содержимое по умолчанию</p>
{% endblock %}
</main>

<footer>
{% block footer %}
<p>© {{ current_year }} Мой сайт</p>
{% endblock %}
</footer>

<script src="/static/js/main.js"></script>
{% block extra_js %}{% endblock %}
</body>
</html>

2. Дочерний шаблон (home.html)

django

Скопировать код

{% extends "base.html" %}

{% block title %}Главная – {{ block.super }}{% endblock %}

{% block content %}
<h1>Добро пожаловать на сайт!</h1>
<p>Это главная страница нашего сайта.</p>

<div class="featured-products">
<h2>Рекомендуемые продукты</h2>
{% for product in featured_products %}
<div class="product-card">
<h3>{{ product.name }}</h3>
<p>{{ product.description }}</p>
<p class="price">{{ product.price }} руб.</p>
</div>
{% empty %}
<p>Нет доступных продуктов.</p>
{% endfor %}
</div>
{% endblock %}

{% block extra_css %}
<link rel="stylesheet" href="/static/css/home.css">
{% endblock %}

{% block extra_js %}
<script src="/static/js/slider.js"></script>
{% endblock %}

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

Тег {% extends "base.html" %} указывает, что шаблон наследуется от base.html
Теги {% block %} определяют области, которые дочерний шаблон может переопределять
{{ block.super }} вставляет содержимое блока из родительского шаблона

Вложенное наследование

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

django

Скопировать код

{# admin/base_admin.html #}
{% extends "base.html" %}

{% block title %}Админ-панель – {{ block.super }}{% endblock %}

{% block content %}
<div class="admin-sidebar">
<ul>
<li><a href="{% url 'admin:dashboard' %}">Дашборд</a></li>
<li><a href="{% url 'admin:users' %}">Пользователи</a></li>
<li><a href="{% url 'admin:settings' %}">Настройки</a></li>
</ul>
</div>

<div class="admin-content">
{% block admin_content %}{% endblock %}
</div>
{% endblock %}

А затем использовать его для конкретных административных страниц:

django

Скопировать код

{# admin/dashboard.html #}
{% extends "admin/base_admin.html" %}

{% block admin_content %}
<h1>Дашборд</h1>
<div class="stats">
<p>Пользователей: {{ user_count }}</p>
<p>Заказов сегодня: {{ today_orders }}</p>
</div>
{% endblock %}

Марина Соколова, Full-stack разработчик

На одном из проектов мне пришлось реализовать сайт с тремя совершенно разными дизайнами для разных разделов — основного сайта, личного кабинета пользователя и административной панели. Казалось бы, нужно создать три отдельных базовых шаблона, но такой подход привел бы к дублированию кода.
Я решила использовать многоуровневое наследование шаблонов Django. Сначала создала "скелетный" base.html с минимальной структурой, общими метатегами и подключением основных скриптов. Затем создала три наследующих от него шаблона: basemain.html, baseaccount.html и base_admin.html — каждый со своей навигацией, стилями и базовой структурой.
Самое интересное произошло, когда потребовалось добавить систему уведомлений, которая должна была работать одинаково во всех разделах. Вместо дублирования кода я добавила в base.html блок для уведомлений:
django
Скопировать код
{% block notifications %}
<div id="notification-container"></div>
<script src="/static/js/notifications.js"></script>
{% endblock %}
Этот блок автоматически унаследовали все дочерние шаблоны. Когда позже потребовалось изменить логику уведомлений, мне нужно было отредактировать только один файл!
Этот случай показал мне, насколько мощной может быть система наследования шаблонов Django при правильном планировании.

Включение шаблонов

Помимо наследования, Django позволяет включать один шаблон в другой с помощью тега {% include %}. Это удобно для повторяющихся компонентов:

django

Скопировать код

{# components/product_card.html #}
<div class="product-card">
<h3>{{ product.name }}</h3>
<p>{{ product.description }}</p>
<p class="price">{{ product.price }} руб.</p>
<button class="add-to-cart" data-id="{{ product.id }}">В корзину</button>
</div>

{# products.html #}
{% extends "base.html" %}

{% block content %}
<h1>Наши продукты</h1>

<div class="product-grid">
{% for product in products %}
{% include "components/product_card.html" with product=product %}
{% endfor %}
</div>
{% endblock %}

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

Теги и фильтры для динамического отображения данных

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

Основные встроенные теги

{% if %} — условные выражения
{% for %} — циклы
{% url %} — генерация URL по имени представления
{% csrf_token %} — защита от CSRF-атак в формах
{% block %} — определение блоков для наследования
{% include %} — включение других шаблонов

Рассмотрим примеры использования тегов:

Условный рендеринг с if

django

Скопировать код

{% if user.is_authenticated %}
<p>Привет, {{ user.username }}!</p>
{% if user.is_staff %}
<a href="{% url 'admin:index' %}">Админка</a>
{% endif %}
<a href="{% url 'logout' %}">Выйти</a>
{% else %}
<a href="{% url 'login' %}">Войти</a>
<a href="{% url 'register' %}">Зарегистрироваться</a>
{% endif %}

Циклы с for

HTML

Скопировать код

<ul class="users-list">
{% for user in users %}
<li{% if user.is_active %} class="active"{% endif %}>
{{ user.username }}
{% if forloop.first %} (новейший пользователь){% endif %}
</li>
{% empty %}
<li>Нет пользователей</li>
{% endfor %}
</ul>

<p>Всего пользователей: {{ users|length }}</p>

В циклах for доступна специальная переменная forloop с атрибутами:

forloop.counter — текущая итерация (начиная с 1)
forloop.counter0 — текущая итерация (начиная с 0)
forloop.first — True если это первая итерация
forloop.last — True если это последняя итерация

Основные встроенные фильтры

Фильтр	Описание	Пример
default	Возвращает значение по умолчанию если переменная пуста	{{ value	default:"Нет данных" }}
length	Возвращает длину списка или строки	{{ items	length }}
date	Форматирует дату	{{ today	date:"d.m.Y" }}
truncatechars	Обрезает строку до указанной длины	{{ text	truncatechars:50 }}
pluralize	Добавляет окончание множественного числа	{{ itemcount }} item{{ itemcount	pluralize }}
safe	Отключает экранирование HTML	{{ html_content	safe }}

Цепочки фильтров

Фильтры можно объединять в цепочки:

django

Скопировать код

{{ text|lower|truncatewords:30 }}

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

Создание собственных тегов и фильтров

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

Для начала создайте в приложении папку templatetags и файлы __init__.py и custom_tags.py:

Python

Скопировать код

# myapp/templatetags/custom_tags.py
from django import template
from django.utils.html import mark_safe
import markdown

register = template.Library()

@register.filter
def markdown_format(text):
"""Преобразует текст в формате Markdown в HTML"""
return mark_safe(markdown.markdown(text))

@register.simple_tag
def get_trending_posts(count=5):
"""Возвращает популярные посты"""
from blog.models import Post
return Post.objects.filter(published=True).order_by('-views')[:count]

@register.inclusion_tag('components/user_badge.html')
def user_badge(user):
"""Отображает значок пользователя"""
return {'user': user}

В этом примере созданы:

Фильтр markdown_format
Простой тег get_trending_posts
Инклюзивный тег user_badge, который рендерит отдельный шаблон

Для использования в шаблоне:

django

Скопировать код

{% load custom_tags %}

<article>
{{ post.content|markdown_format }}
</article>

<div class="trending">
<h3>Популярные статьи</h3>
<ul>
{% get_trending_posts as trending_posts %}
{% for post in trending_posts %}
<li><a href="{{ post.get_absolute_url }}">{{ post.title }}</a></li>
{% endfor %}
</ul>
</div>

<div class="comment">
{% user_badge comment.author %}
<p>{{ comment.text }}</p>
</div>

Контекстные теги

Для более сложной логики можно создать контекстный тег:

Python

Скопировать код

@register.tag
def display_comments(parser, token):
"""Отображает комментарии с пагинацией"""
bits = token.split_contents()
if len(bits) != 2:
raise template.TemplateSyntaxError(
"%r принимает один аргумент" % bits[0]
)
return CommentsNode(bits[1])

class CommentsNode(template.Node):
def __init__(self, post_var):
self.post_var = template.Variable(post_var)

def render(self, context):
post = self.post_var.resolve(context)
comments = post.comments.filter(approved=True)
context.push()
context['comments'] = comments
output = template.loader.get_template('components/comments.html').render(context)
context.pop()
return output

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

django

Скопировать код

{% load custom_tags %}

<article>
{{ post.content|markdown_format }}
</article>

<section class="comments">
{% display_comments post %}
</section>

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

Практические решения типичных задач с шаблонами Django

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

1. Пагинация

Пагинация — распространенная задача при отображении длинных списков данных:

Python

Скопировать код

{# views.py #}
from django.core.paginator import Paginator

def post_list(request):
posts_list = Post.objects.all()
paginator = Paginator(posts_list, 10) # 10 постов на страницу

page = request.GET.get('page')
posts = paginator.get_page(page)

return render(request, 'blog/post_list.html', {'posts': posts})

HTML

Скопировать код

{# templates/blog/post_list.html #}
<div class="posts">
{% for post in posts %}
<article class="post">
<h2><a href="{{ post.get_absolute_url }}">{{ post.title }}</a></h2>
<p>{{ post.summary }}</p>
</article>
{% empty %}
<p>Нет доступных постов.</p>
{% endfor %}
</div>

<div class="pagination">
{% if posts.has_previous %}
<a href="?page=1">&laquo; первая</a>
<a href="?page={{ posts.previous_page_number }}">предыдущая</a>
{% endif %}

<span class="current">
Страница {{ posts.number }} из {{ posts.paginator.num_pages }}.
</span>

{% if posts.has_next %}
<a href="?page={{ posts.next_page_number }}">следующая</a>
<a href="?page={{ posts.paginator.num_pages }}">последняя &raquo;</a>
{% endif %}
</div>

2. Формы и валидация

Отображение форм с валидацией и сообщениями об ошибках:

Python

Скопировать код

{# forms.py #}
from django import forms

class ContactForm(forms.Form):
name = forms.CharField(max_length=100)
email = forms.EmailField()
message = forms.CharField(widget=forms.Textarea)

Python

Скопировать код

{# views.py #}
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
# Обработка данных
messages.success(request, 'Сообщение отправлено!')
return redirect('contact')
else:
form = ContactForm()

return render(request, 'contact.html', {'form': form})

HTML

Скопировать код

{# templates/contact.html #}
{% extends "base.html" %}

{% block content %}
<h1>Свяжитесь с нами</h1>

{% if messages %}
<div class="messages">
{% for message in messages %}
<div class="alert {% if message.tags %}alert-{{ message.tags }}{% endif %}">
{{ message }}
</div>
{% endfor %}
</div>
{% endif %}

<form method="post">
{% csrf_token %}

{% if form.non_field_errors %}
<div class="alert alert-danger">
{% for error in form.non_field_errors %}
{{ error }}
{% endfor %}
</div>
{% endif %}

<div class="form-group">
{{ form.name.label_tag }}
{{ form.name }}
{% if form.name.errors %}
<div class="error">
{% for error in form.name.errors %}
{{ error }}
{% endfor %}
</div>
{% endif %}
</div>

<div class="form-group">
{{ form.email.label_tag }}
{{ form.email }}
{% if form.email.errors %}
<div class="error">
{% for error in form.email.errors %}
{{ error }}
{% endfor %}
</div>
{% endif %}
</div>

<div class="form-group">
{{ form.message.label_tag }}
{{ form.message }}
{% if form.message.errors %}
<div class="error">
{% for error in form.message.errors %}
{{ error }}
{% endfor %}
</div>
{% endif %}
</div>

<button type="submit" class="btn btn-primary">Отправить</button>
</form>
{% endblock %}

3. Кастомные теги шаблона для повторяющейся логики

Создадим тег для отображения рейтинга в виде звезд:

Python

Скопировать код

{# templatetags/rating_tags.py #}
from django import template
register = template.Library()

@register.inclusion_tag('components/star_rating.html')
def star_rating(value, max_stars=5):
"""Отображает рейтинг в виде звезд"""
return {
'stars': range(int(value)),
'empty_stars': range(max_stars – int(value)),
'value': value,
'max_stars': max_stars
}

HTML

Скопировать код

{# templates/components/star_rating.html #}
<div class="rating" title="{{ value }} из {{ max_stars }}">
{% for star in stars %}
<span class="star filled">★</span>
{% endfor %}
{% for star in empty_stars %}
<span class="star">☆</span>
{% endfor %}
<span class="rating-value">{{ value }}/{{ max_stars }}</span>
</div>

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

django

Скопировать код

{% load rating_tags %}

<div class="product">
<h2>{{ product.name }}</h2>
{% star_rating product.average_rating %}
<p>{{ product.description }}</p>
</div>

4. AJAX-загрузка контента

Реализация частичной подгрузки контента без перезагрузки страницы:

Python

Скопировать код

{# views.py #}
def load_comments(request, post_id):
post = get_object_or_404(Post, id=post_id)
comments = post.comments.all()[:10]
return render(request, 'blog/comments_partial.html', {'comments': comments})

HTML

Скопировать код

{# templates/blog/post_detail.html #}
{% extends "base.html" %}

{% block content %}
<article>
<h1>{{ post.title }}</h1>
<div class="content">{{ post.content|safe }}</div>
</article>

<h2>Комментарии</h2>
<div id="comments-container">
<p>Загрузка комментариев...</p>
</div>

<button id="load-more">Загрузить еще</button>
{% endblock %}

{% block extra_js %}
<script>
document.addEventListener('DOMContentLoaded', function() {
// Загрузка комментариев при открытии страницы
fetch('/posts/{{ post.id }}/comments/')
.then(response => response.text())
.then(html => {
document.getElementById('comments-container').innerHTML = html;
});

// Обработка кнопки "Загрузить еще"
document.getElementById('load-more').addEventListener('click', function() {
let offset = document.querySelectorAll('#comments-container .comment').length;
fetch(`/posts/{{ post.id }}/comments/?offset=${offset}`)
.then(response => response.text())
.then(html => {
let tempDiv = document.createElement('div');
tempDiv.innerHTML = html;
let newComments = tempDiv.querySelectorAll('.comment');
let container = document.getElementById('comments-container');

newComments.forEach(comment => {
container.appendChild(comment);
});

if (newComments.length === 0) {
document.getElementById('load-more').style.display = 'none';
}
});
});
});
</script>
{% endblock %}

HTML

Скопировать код

{# templates/blog/comments_partial.html #}
{% for comment in comments %}
<div class="comment">
<div class="comment-header">
<span class="author">{{ comment.author.username }}</span>
<span class="date">{{ comment.created_at|date:"d.m.Y H:i" }}</span>
</div>
<div class="comment-body">
{{ comment.text }}
</div>
</div>
{% empty %}
<p>Нет комментариев. Будьте первым!</p>
{% endfor %}

5. Оптимизация запросов в шаблонах

Проблема N+1 запросов часто возникает в шаблонах. Решение — использовать select_related и prefetch_related:

Python

Скопировать код

{# views.py – без оптимизации #}
def article_list(request):
articles = Article.objects.all()
return render(request, 'articles/list.html', {'articles': articles})

{# В шаблоне – каждое обращение к article.author вызывает отдельный SQL-запрос #}
{% for article in articles %}
<h2>{{ article.title }}</h2>
<p>Автор: {{ article.author.username }}</p>
{% endfor %}

Python

Скопировать код

{# views.py – с оптимизацией #}
def article_list_optimized(request):
# Один SQL-запрос для статей и их авторов
articles = Article.objects.select_related('author').all()

# Для связи many-to-many или обратной связи one-to-many
articles_with_comments = Article.objects.prefetch_related('comments').all()

return render(request, 'articles/list.html', {'articles': articles})

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

6. Кэширование шаблонов

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

django

Скопировать код

{% load cache %}

{% cache 600 sidebar request.user.id %}
<div class="sidebar">
<h3>Категории</h3>
<ul>
{% for category in categories %}
<li><a href="{{ category.get_absolute_url }}">{{ category.name }}</a></li>
{% endfor %}
</ul>

<h3>Популярные статьи</h3>
<ul>
{% for article in popular_articles %}
<li><a href="{{ article.get_absolute_url }}">{{ article.title }}</a></li>
{% endfor %}
</ul>
</div>
{% endcache %}

В этом примере боковая панель кэшируется на 600 секунд (10 минут). Включение request.user.id в ключ кэша обеспечивает уникальный кэш для каждого пользователя.

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

Читайте также

Проверь как ты усвоил материалы статьи

Пройди тест и узнай насколько ты лучше других читателей

Что необходимо создать для начала работы с шаблонами в Django?

1 / 5

Свежие материалы

Видео уроки по анализу данных

6 сентября 2024

Как использовать API ChatGPT: руководство для начинающих

6 сентября 2024

Как скачать и установить Python на Android

6 сентября 2024

Система шаблонов Django: как использовать для создания динамических сайтов

Основы системы шаблонов в Django

Настройка и структура шаблонов при создании приложения

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

Теги и фильтры для динамического отображения данных

Практические решения типичных задач с шаблонами Django

Загрузка...