Home > Article > Backend Development > A deep dive into Django’s template engine and Flask’s Jinja2
A deep dive into Django’s template engine and Flask’s Jinja2
- PHPzOriginal
- 2023-09-28 11:39:291481browse
In-depth understanding of Django's template engine and Flask's Jinja2 requires specific code examples
Introduction:
Django and Flask are two commonly used and popular ones in Python Web framework. They both provide powerful template engines to handle the rendering of dynamic web pages. Django uses its own template engine, while Flask uses Jinja2. This article will take an in-depth look at Django’s template engine and Flask’s Jinja2, and provide some concrete code examples to illustrate their usage and differences.
1. Django template engine
- Creation and use of templates
In Django, you can create a template by creating an HTML file and using template syntax in it. Template files are usually stored in the application's "templates" directory.
For example, we can create a template called "hello.html" as follows:
<!DOCTYPE html>
<html>
<head>
<title>Hello</title>
</head>
<body>
<h1>Hello, {{ name }}!</h1>
</body>
</html>In the view function, we can use the render function to The data is passed to the template and rendered. For example, we can pass a variable named "name" to the template:
from django.shortcuts import render
def hello(request):
name = "John"
return render(request, 'hello.html', {'name': name})- Template syntax
Django's template engine provides a rich syntax to handle logic and data presentation. Here are some common examples of template syntax:
- Variables: Use double curly braces to enclose variable names, such as
{{ name }}. - Tags: Use curly braces and percent signs to include tags, such as
{% for item in items %} {% endfor %}. - Filter: You can use pipe symbols and filters after variables to process the output of variables. For example,
{{ name|title }}means converting the name variable to a capitalized form.
- Template inheritance
Django’s template engine also supports template inheritance. A base template can be created, and then other templates can inherit the base template and can override and extend some blocks of the base template.
For example, we can create a base template called "base.html" as follows:
<!DOCTYPE html>
<html>
<head>
<title>{% block title %}{% endblock %}</title>
</head>
<body>
<header>
{% block header %}{% endblock %}
</header>
<div class="content">
{% block content %}{% endblock %}
</div>
<footer>
{% block footer %}{% endblock %}
</footer>
</body>
</html> Then, in other templates we can use the extends key Words to inherit and extend the basic template, as shown below:
{% extends 'base.html' %}
{% block title %}Hello{% endblock %}
{% block header %}
<h1>Welcome to my website!</h1>
{% endblock %}
{% block content %}
<p>Hello, {{ name }}!</p>
{% endblock %}2. Creation and use of Flask’s Jinja2
-
Similar to Django, Flask uses Jinja2 as its Template engine. Likewise, templates can be created by creating an HTML file.
In Flask, template files are usually stored in the "templates" directory of the application.
For example, we can create a template named "hello.html" as follows:
<!DOCTYPE html>
<html>
<head>
<title>Hello</title>
</head>
<body>
<h1>Hello, {{ name }}!</h1>
</body>
</html>In the view function, you can use the render_template function to render Template and pass data. For example, we can pass a variable named "name" to the template:
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def hello():
name = "John"
return render_template('hello.html', name=name)- Template syntax
Jinja2's template syntax is similar to Django's template syntax, but with some subtle differences. Here are some common template syntax examples:
- Variables: Also use double curly braces to include variable names, such as
{{ name }}. - Control structure: Use curly braces and percent signs to include control structures, such as
{% for item in items %} {% endfor %}. - Filter: You can also use pipe symbols and filters after variables to process the output of variables. For example,
{{ name|title }}means converting the name variable to capitalized form. .
- Template inheritance
Jinja2 also supports template inheritance. It is also possible to create a base template, and other templates can inherit and override and extend some blocks of the base template.
For example, we can create a base template called "base.html" as follows:
<!DOCTYPE html>
<html>
<head>
<title>{% block title %}{% endblock %}</title>
</head>
<body>
<header>
{% block header %}{% endblock %}
</header>
<div class="content">
{% block content %}{% endblock %}
</div>
<footer>
{% block footer %}{% endblock %}
</footer>
</body>
</html> Then, use the extends keyword in other templates To inherit and extend the basic template, as shown below:
{% extends 'base.html' %}
{% block title %}Hello{% endblock %}
{% block header %}
<h1>Welcome to my website!</h1>
{% endblock %}
{% block content %}
<p>Hello, {{ name }}!</p>
{% endblock %}Conclusion:
Both Django’s template engine and Flask’s Jinja2 provide powerful functions to create dynamic web page renderings. There are some slight differences in syntax and usage between the two, but overall they are very similar. In actual development, you can choose to use one of them based on personal preferences or project needs.
The above is an in-depth understanding of Django's template engine and Flask's Jinja2. Through specific code examples, we have a clearer understanding of their usage and differences. I hope this article provides some help for you to understand and use these two template engines.
The above is the detailed content of A deep dive into Django’s template engine and Flask’s Jinja2. For more information, please follow other related articles on the PHP Chinese website!