Django
Plantilla
Buscar..
Variables
Se puede acceder a las variables que ha proporcionado en el contexto de su vista usando la notación de doble refuerzo:
En tus views.py :
class UserView(TemplateView):
""" Supply the request user object to the template """
template_name = "user.html"
def get_context_data(self, **kwargs):
context = super(UserView, self).get_context_data(**kwargs)
context.update(user=self.request.user)
return context
En user.html :
<h1>{{ user.username }}</h1>
<div class="email">{{ user.email }}</div>
La notación de puntos tendrá acceso:
- propiedades del objeto, por ejemplo,
user.usernameserá{{ user.username }} - búsquedas de diccionario, por ejemplo,
request.GET["search"]será{{ request.GET.search }} - los métodos sin argumentos, por ejemplo,
users.count()serán{{ user.count }}
Las variables de la plantilla no pueden acceder a los métodos que toman argumentos.
Las variables también pueden ser probadas y repartidas en:
{% if user.is_authenticated %}
{% for item in menu %}
<li><a href="{{ item.url }}">{{ item.name }}</a></li>
{% endfor %}
{% else %}
<li><a href="{% url 'login' %}">Login</a>
{% endif %}
Se accede a las URL utilizando el formato {% url 'name' %} , donde los nombres corresponden a los nombres en urls.py
{% url 'login' %} - Probablemente se procesará como /accounts/login/
{% url 'user_profile' user.id %} - Los argumentos para las URL se proporcionan en orden
{% url next %} - Las URL pueden ser variables
Plantillas en vistas basadas en clase
Puede pasar datos a una plantilla en una variable personalizada.
En tus views.py :
from django.views.generic import TemplateView
from MyProject.myapp.models import Item
class ItemView(TemplateView):
template_name = "item.html"
def items(self):
""" Get all Items """
return Item.objects.all()
def certain_items(self):
""" Get certain Items """
return Item.objects.filter(model_field="certain")
def categories(self):
""" Get categories related to this Item """
return Item.objects.get(slug=self.kwargs['slug']).categories.all()
Una lista simple en tu item.html :
{% for item in view.items %}
<ul>
<li>{{ item }}</li>
</ul>
{% endfor %}
También puede recuperar propiedades adicionales de los datos.
Asumiendo que su Item modelo tiene un campo de name :
{% for item in view.certain_items %}
<ul>
<li>{{ item.name }}</li>
</ul>
{% endfor %}
Plantillas en vistas basadas en funciones
Puede utilizar una plantilla en una vista basada en funciones de la siguiente manera:
from django.shortcuts import render
def view(request):
return render(request, "template.html")
Si desea utilizar variables de plantilla, puede hacerlo de la siguiente manera:
from django.shortcuts import render
def view(request):
context = {"var1": True, "var2": "foo"}
return render(request, "template.html", context=context)
Luego, en template.html , puede referirse a sus variables así:
<html>
{% if var1 %}
<h1>{{ var2 }}</h1>
{% endif %}
</html>
Filtros de plantillas
El sistema de plantillas de Django tiene etiquetas y filtros incorporados, que son funciones dentro de la plantilla para representar contenido de una manera específica. Se pueden especificar varios filtros con canalizaciones y los filtros pueden tener argumentos, al igual que en la sintaxis variable.
{{ "MAINROAD 3222"|lower }} # mainroad 3222
{{ 10|add:15}} # 25
{{ "super"|add:"glue" }} # superglue
{{ "A7"|add:"00" }} # A700
{{ myDate | date:"D d M Y"}} # Wed 20 Jul 2016
Puede encontrar una lista de los filtros integrados disponibles en https://docs.djangoproject.com/en/dev/ref/templates/builtins/#ref-templates-builtins-filters .
Creando filtros personalizados
Para agregar sus propios filtros de plantilla, cree una carpeta llamada templatetags dentro de la carpeta de su aplicación. Luego agregue un __init__.py , y el archivo de su archivo que contendrá los filtros:
#/myapp/templatetags/filters.py
from django import template
register = template.Library()
@register.filter(name='tostring')
def to_string(value):
return str(value)
Para usar realmente el filtro necesitas cargarlo en tu plantilla:
#templates/mytemplate.html
{% load filters %}
{% if customer_id|tostring = customer %} Welcome back {% endif%}
Trucos
A pesar de que los filtros parecen simples al principio, permite hacer algunas cosas ingeniosas:
{% for x in ""|ljust:"20" %}Hello World!{% endfor %} # Hello World!Hello World!Hel...
{{ user.name.split|join:"_" }} ## replaces whitespace with '_'
Ver también etiquetas de plantillas para más información.
Evitar que los métodos sensibles sean llamados en plantillas
Cuando un objeto se expone al contexto de la plantilla, sus métodos sin argumentos están disponibles. Esto es útil cuando estas funciones son "captadores". Pero puede ser peligroso si estos métodos alteran algunos datos o tienen algunos efectos secundarios. Aunque es probable que confíe en el autor de la plantilla, es posible que no esté al tanto de los efectos secundarios de una función o que piense que debe llamar al atributo incorrecto por error.
Dado el siguiente modelo:
class Foobar(models.Model):
points_credit = models.IntegerField()
def credit_points(self, nb_points=1):
"""Credit points and return the new points credit value."""
self.points_credit = F('points_credit') + nb_points
self.save(update_fields=['points_credit'])
return self.points_credit
Si escribes esto, por error, en una plantilla:
You have {{ foobar.credit_points }} points!
Esto incrementará el número de puntos cada vez que se llame a la plantilla. Y puede que ni siquiera lo note.
Para evitar esto, debe establecer el atributo alters_data en True a los métodos que tienen efectos secundarios. Esto hará que sea imposible llamarlos desde una plantilla.
def credit_points(self, nb_points=1):
"""Credit points and return the new points credit value."""
self.points_credit = F('points_credit') + nb_points
self.save(update_fields=['points_credit'])
return self.points_credit
credit_points.alters_data = True
El uso de {% extiende%}, {% incluye%} y {% bloques%}
resumen
{% extiende%} : esto declara que la plantilla dada como argumento es la principal de la plantilla actual. Uso:
{% extends 'parent_template.html' %}.{% block%} {% endblock%} : esto se usa para definir secciones en sus plantillas, de modo que si otra plantilla extiende esta, podrá reemplazar cualquier código html que se haya escrito dentro de ella. Los bloques se identifican por su nombre. Uso:
{% block content %} <html_code> {% endblock %}.{% include%} : esto insertará una plantilla dentro de la actual. Tenga en cuenta que la plantilla incluida recibirá el contexto de la solicitud y que también puede asignarle variables personalizadas. Uso básico:
{% include 'template_name.html' %}, uso con variables:{% include 'template_name.html' with variable='value' variable2=8 %}
Guía
Supongamos que está creando su código del lado frontal con diseños comunes para todos los códigos y no desea repetir el código para cada plantilla. Django te da en las etiquetas construidas para hacerlo.
Supongamos que tenemos un sitio web de blog con 3 plantillas que comparten el mismo diseño:
project_directory
..
templates
front-page.html
blogs.html
blog-detail.html
1) Definir el archivo base.html ,
<html>
<head>
</head>
<body>
{% block content %}
{% endblock %}
</body>
</html>
2) blog.html en blog.html como,
{% extends 'base.html' %}
{% block content %}
# write your blog related code here
{% endblock %}
# None of the code written here will be added to the template
Aquí blog.html el diseño base para que su diseño HTML ahora esté disponible en el blog.html blog.html. El concepto de { % block %} es la herencia de la plantilla que le permite crear una plantilla básica "esqueleto" que contiene todos los elementos comunes de su sitio y define los bloques que las plantillas secundarias pueden anular.
3) Ahora suponga que todas sus 3 plantillas también tienen la misma división de HTML que define algunas publicaciones populares. En lugar de escribirse 3 veces, cree una nueva plantilla posts.html .
blog.html
{% extends 'base.html' %}
{% block content %}
# write your blog related code here
{% include 'posts.html' %} # includes posts.html in blog.html file without passing any data
<!-- or -->
{% include 'posts.html' with posts=postdata %} # includes posts.html in blog.html file with passing posts data which is context of view function returns.
{% endblock %}