Este artigo primeiro apresenta o básico do sistema de templates Django, então discute como instalar e configurar o sistema de templates Django, então analisa profundamente a estrutura básica do template Django, o uso de tags e filtros, e explica como exibir os dados do modelo em o template Use um exemplo de um projeto real para demonstrar como usar o sistema de template Django em desenvolvimento real.

Introdução ao sistema de templates do Django

O sistema de template Django é um componente poderoso que nos permite gerar dinamicamente HTML, XML e outros textos estruturados com base nos dados fornecidos. O sistema de modelagem não é apenas fácil de usar, mas também rico em recursos. Ele inclui uma linguagem integrada: a Django Template Language (DTL), uma linguagem simples e não intrusiva para definir a estrutura e a lógica dos modelos.

Por exemplo, em um template Django, podemos usar variáveis e tags para gerar conteúdo dinamicamente:

# Django模板示例
{
   
   { book.title }} <!-- 输出: Python编程基础 -->
{% if user.is_authenticated %} <!-- 如果用户已登录 -->
  Hello, {
   
   { user.username }}! <!-- 输出: Hello, John! -->
{% endif %}

No código acima, as chaves { { }}são usadas para gerar o valor da variável e os rótulos {% %}são usados para executar operações lógicas.

A estrutura básica do modelo

Os templates Django são arquivos de texto compostos por uma série de sintaxe especial para gerar dinamicamente HTML, XML ou outras linguagens de marcação. Vamos dar uma olhada mais de perto na estrutura básica dos templates Django.

sintaxe do modelo

Os templates Django usam duas sintaxes principais:

Variáveis : envoltas em chaves duplas ({ { }}). Por exemplo { { variable }}, o Django irá substituí-lo pelo valor da variável.
Marcas : coloque-as entre chaves e sinais de porcentagem ({% %}). As tags fornecem a estrutura de controle do modelo, como loops, instruções condicionais e assim por diante. Por exemplo {% for item in list %}...{% endfor %}.

herança de modelo

O sistema de templates Django suporta herança de templates. Este é um princípio de design DRY (Don't Repeat Yourself). Você pode definir um modelo base (modelo base) e, em seguida, permitir que outros modelos herdem esse modelo base e cubram algumas partes dele.

Por exemplo, para definir um modelo base base.html:

<!-- base.html -->
<html>
<body>
{% block content %}{% endblock %}
</body>
</html>

Em seguida, defina um submodelo child.htmlque herde base.htmle substitua contento bloco:

<!-- child.html -->
{% extends "base.html" %}

{% block content %}
<p>Hello, Django!</p>
{% endblock %}

outros modelos

Além da herança, os templates Django também suportam incluir (incluir) outros templates, o que pode ajudá-lo a dividir os templates em partes pequenas e reutilizáveis.

Por exemplo, defina um modelo header.html:

<!-- header.html -->
<header>
  <h1>Welcome to My Website</h1>
</header>

Em seguida, inclua este modelo em outro modelo:

{% include "header.html" %}

<p>This is the main content...</p>

Configurando modelos Django

Configurar o sistema de template Django

O sistema de modelagem Django está incluído nos projetos Django por padrão. Você pode settings.pyencontrar as informações de configuração do modelo no arquivo do projeto:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        ...
    },
]

Você pode 'DIRS'adicionar o caminho para o modelo no item de configuração. Por padrão, o Django templatesprocura por arquivos de modelo em cada diretório do aplicativo.

Configurar o método de carregamento do modelo

O sistema de modelagem Django pode carregar modelos de vários locais. Por padrão, o Django templatesprocura por arquivos de modelo em cada diretório do aplicativo. Você pode adicionar diretórios de modelos adicionais modificando as opções TEMPLATESno arquivo de configuração 'DIRS'. Por exemplo, você pode adicionar um diretório de modelo global:

# settings.py

import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

TEMPLATES = [
    {
        ...
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        ...
    },
]

Nesta configuração, todos os arquivos de template estarão templatesem uma pasta na raiz do projeto.

Configurar o mecanismo de modelo

Na TEMPLATESconfiguração, 'BACKEND'as opções são usadas para especificar qual mecanismo de modelo usar. O Django usa seu próprio mecanismo de modelo por padrão, ou seja django.template.backends.django.DjangoTemplates, . Você também pode alternar para outros mecanismos de modelagem, como Jinja2:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.jinja2.Jinja2',
        ...
    },
]

Observe que diferentes mecanismos de modelo podem exigir configurações diferentes e fornecer linguagens de modelo diferentes.

Configurar tags e filtros de modelo personalizados

Se você tiver tags e filtros de modelo personalizados, precisará colocá-los em um templatetagsdiretório em um aplicativo. Em seguida INSTALLED_APPS, adicione o aplicativo à sua configuração e o Django carregará automaticamente suas tags e filtros de modelo personalizados:

# settings.py

INSTALLED_APPS = [
    ...
    'myapp',
    ...
]

Explicação detalhada das tags de modelo

As tags no sistema de template Django fornecem várias estruturas de controle, incluindo loops, instruções condicionais, herança de template e muito mais. Em seguida, apresentamos algumas tags comumente usadas em detalhes.

para etiqueta

forAs tags são usadas para percorrer sequências em modelos:

{% for item in item_list %}
    <p>{
   
   { item.name }}</p> <!-- 输出每个项目的名称 -->
{% endfor %}

se marcar

ifRótulos são usados para julgamento condicional. Você pode usar elife elsepara julgamento multiramificação:

{% if user.is_authenticated %}
    <p>Welcome back, {
   
   { user.username }}.</p> <!-- 如果用户已经认证，打印欢迎信息 -->
{% else %}
    <p>Please log in.</p> <!-- 如果用户未认证，提示用户登录 -->
{% endif %}

estende a tag e bloqueia a tag

extendsAs tags são usadas para herança de modelo e blockas tags são usadas para definir blocos que podem ser substituídos por modelos filhos:

<!-- base.html -->
<html>
<body>
{% block content %}{% endblock %}
</body>
</html>

<!-- child.html -->
{% extends "base.html" %}

{% block content %}
<p>Hello, Django!</p>
{% endblock %}

incluir etiqueta

includeAs tags são usadas para incluir outros modelos, tornando-os reutilizáveis:

{% include "header.html" %}

url tag

urlTags são usadas para gerar URLs. Ele aceita o nome de uma função de exibição ou o nome de um padrão de URL e argumentos opcionais e retorna o URL correspondente:

<a href="{% url 'home' %}">Home</a> <!-- 生成首页的URL -->

marca csrf_token

Ao usar um formulário POST, csrf_tokena tag é usada para gerar um token CSRF para evitar ataques de falsificação de solicitação entre sites:

<form method="post">
{% csrf_token %}
<!-- 表单内容 -->
</form>

filtro de modelo

Nos modelos Django, os filtros podem modificar as variáveis antes de serem exibidas. A sintaxe de um filtro é adicionar uma barra vertical (|) e o nome do filtro após o nome da variável. Se um filtro requer parâmetros, eles podem ser adicionados usando dois pontos (:). Vamos olhar mais de perto.

uso básico

Por exemplo, podemos usar datefiltros para formatar datas:

{
   
   { date_var|date:"F j, Y" }} <!-- 输出: July 8, 2023 -->

Use lowerum filtro para converter texto em minúsculas:

{
   
   { "Hello World"|lower }} <!-- 输出: hello world -->

filtro de link

Você também pode encadear vários filtros e eles serão executados da esquerda para a direita:

{
   
   { "Hello World"|lower|capfirst }} <!-- 输出: Hello world -->

filtro customizado

Além de usar os filtros integrados do Django, você também pode criar seus próprios filtros. Para fazer isso, você precisa criar um arquivo Python em um diretório em seu aplicativo templatetags, definir sua função de filtro nele e register.filterregistrá-lo com um decorador:

from django import template

register = template.Library()

@register.filter
def my_filter(value):
    # 这是一个简单的过滤器，它返回值的第一个字符
    return value[0]

Você pode então usar este filtro em seus modelos:

{
   
   { "Hello World"|my_filter }} <!-- 输出: H -->

Exibir dados do modelo em modelos Django

A estrutura do Django separa os dados do modelo das visualizações do modelo, o que nos permite exibir facilmente os dados do modelo nos modelos. Na função de exibição, podemos consultar os dados do modelo e depois passá-los para o modelo. Nos modelos, usamos uma sintaxe especial para acessar e exibir esses dados.

Preparar dados na exibição

Digamos que temos um Blogmodelo com um titlecampo e um contentcampo. Em nossa função de exibição, podemos consultar todos os blogs:

from django.shortcuts import render
from .models import Blog

def blog_list(request):
    blogs = Blog.objects.all()  # 查询所有的博客
    return render(request, 'blog_list.html', {'blogs': blogs})

exibir dados no modelo

Em seguida, em nosso blog_list.htmlmodelo, podemos usar fortags para iterar todos os blogs e usar a sintaxe variável para exibir o título e o conteúdo de cada blog:

{% for blog in blogs %}
<h2>{
   
   { blog.title }}</h2>  <!-- 展示博客标题 -->
<p>{
   
   { blog.content }}</p>  <!-- 展示博客内容 -->
{% endfor %}

Formatar dados usando filtros

Nos modelos, também podemos usar filtros para formatar os dados do modelo. Por exemplo, podemos usar datefiltros para formatar datas ou usar truncatecharsfiltros para limitar o tamanho do texto:

{% for blog in blogs %}
<h2>{
   
   { blog.title }}</h2>
<p>{
   
   { blog.publish_date|date:"F j, Y" }}</p>  <!-- 使用date过滤器格式化发布日期 -->
<p>{
   
   { blog.content|truncatechars:100 }}</p>  <!-- 使用truncatechars过滤器限制内容长度 -->
{% endfor %}

Usando modelos Django em projetos reais

O sistema de modelagem Django desempenha um papel importante no desenvolvimento real do projeto. Abaixo, tomamos um sistema de blog simples como exemplo para demonstrar como usar modelos Django em projetos reais.

Etapa 1: defina seu modelo

Primeiro, precisamos definir um modelo em nosso aplicativo. Neste exemplo, definimos um Postmodelo para representar postagens de blog:

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)  # 文章标题
    content = models.TextField()  # 文章内容
    pub_date = models.DateTimeField(auto_now_add=True)  # 发布日期

Etapa dois: criar uma exibição

Em seguida, precisamos criar uma exibição para lidar com as solicitações do usuário. Nesta visualização, podemos buscar todas as postagens do blog e passá-las para o modelo:

from django.shortcuts import render
from .models import Post

def post_list(request):
    posts = Post.objects.all()  # 获取所有的博客文章
    return render(request, 'blog/post_list.html', {'posts': posts})  # 将文章传递给模板

Passo 3: Modelos de Escrita

Em seguida, podemos criar um modelo para exibir as postagens do blog. Neste modelo, usamos fortags para percorrer todos os artigos e usamos variáveis para exibir o título e o conteúdo do artigo:

{% for post in posts %}
<h2>{
   
   { post.title }}</h2>
<p>{
   
   { post.content }}</p>
<p>Published on {
   
   { post.pub_date|date:"F j, Y" }}</p>
{% endfor %}

Etapa 4: configurar URLs

Por fim, precisamos urls.pyconfigurar a URL no arquivo para que os usuários possam acessar nossa view:

from django.urls import path
from . import views

urlpatterns = [
    path('posts/', views.post_list, name='post_list'),  # 当用户访问/posts/时，显示博客文章列表
]

Acima estão as etapas básicas para usar modelos Django em projetos reais. Por meio desse exemplo, podemos ver o poder e a flexibilidade do sistema de template Django, que pode nos ajudar a criar rapidamente páginas web dinâmicas.

Se for útil, preste mais atenção à conta pública pessoal do WeChat: [Perspectiva completa do Python] TeahLead_KrisChang, mais de 10 anos de experiência na indústria de Internet e inteligência artificial, mais de 10 anos de experiência em tecnologia e gerenciamento de equipes de negócios, Tongji Software Bacharel em engenharia, Fudan Engineering Management Master, arquiteto sênior de serviços em nuvem certificado pela Aliyun, chefe de negócios de produtos de IA com centenas de milhões de receita.

Solução completa do modelo Python Django e combate real