Eric The Coder Blog

Eric The Coder Blog

Ultimate Django Sheet Cheat

Ultimate Django Sheet Cheat

Django memory aid : Everything you need to remember to create a Python Django Web Application

Follow me!:

Start a new Django project

# Create et access project folder
~$  mkdir project_name
~$  cd project_name

# Create Python virtual env 
~$  python3 -m venv venv

# Activate virtual env
~$  source venv/bin/activate

# If you want to deactivate virtual env
~$  deactivate

# Install django (~= same as 3.1.*)
~$  pip install django~=3.1.0 

# New django project (from project_name folder)
~$  django-admin startproject config .

# Create app (from project_name folder)
~$  python startapp app_name

Migration: Django create a database table for each models present in your app using thoses commands:

  • Makemigrations: Create a file under app_name/migrations with the database structure to create
    ~$  python makemigrations
  • Migrate: Will read the migrations files and create the actual database and tables
    ~$  python migrate

Create superuser for authenficiation/admin panel

~$  python createsuperuser

Start server

~$  python runserver  => ex.


# Create a requirements file that contain all your projet dependencies
~$  pip freeze > requirements.txt

# Install your project requirements (if a requirements file exist) 
~$  pip install -r requirements.txt

Other commands

# Django shell (Run projet code direclty)
~$ python shell

# example of code to run in the shell:
 >>> from app_name.models import User
 >>> user1 = User.objects.first()

# Prepare static folders for production
$ python collectstatic

# Take all data from app blog and export in json
python dumpdata blog >myapp.json

# Take all data in json file and import in app data table
python loaddata myapp.json

Project config

# Add app to
INSTALLED_APPS = [ … , 'app_name' ]

# App templates folder
create folder appfolder/templates/appname

# Project templates folder: 
create folder projectname/templates

# template config
Project templates 
        { …
                'DIRS': [BASE_DIR / 'templates', ],
        … }

# Create Static folder: 

# Static folder ( 
STATIC_URL = '/static/'
STATIC_ROOT = 'static_root'

# To use PostgresSQL
# pip install psycopg2
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'blog',
        'USER': 'admin',
        'PASSWORD': '123456',
        'HOST': 'localhost',
        'PORT': '5432'

Create data model: Theses models can be created as database tables with the migrations commands

# The id fields is automaticly created by Django for each model that why it's not show below

from django.db import models

class Customer(models.Model)
    name = models.Charfield('Customer', max_length=120)
    age = models.IntegerField()
    note = models.TextField(blank=True, null = True)
    email = models.EmailField(max_length=255, blank=True, null=True)
    credit = models.FloatField(blank=True)
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    # Select Field (return value, display value)
        ('Customer', 'Customer'),
        ('Supplier', 'Supplier'),
        ('Student', 'Student'),

    type = models.CharField(choices=TYPE_CHOICES)

Model string representation

class Customer(models.Model):
    name = models.Charfield('Customer', max_length=120)
    age = models.IntegerField()

    def __str__(self): 

Relationship between models

# One-to-Many: (use double quotes if the entity is not yet declare) ex. "Supplier"
supplier = models.ForeignKey(Supplier, blank=True, null=True, on_delete=models.CASCADE)

# on_delete can be set to models.CASCADE, models.ST_DEFAULT or models.SET_NULL

# Many-to-Many: 
tags = models.ManyToManyField(Tag, blank=True)

# One to One 
User = models.OneToOneField(User, on_delete=models.CASCADE)

# Overwrite save method
def save(self, (*args, **kwargs):
    if not self.slug:
        self.slug = slugify(self.title)

    super().save(*args, **kwargs)

Admin panel: Every Django projects come with an Admin Panel that can be open at /admin url (ex: localhost:8000/admin)

To display the model in the Admin panel register the model in the app_name/ file

from .models import Blog

Customize Admin Panel

For each models you can specify the fields you want to use

# Custom model Admin ( 
class BlogAdmin(admin.ModelAdmin)
    fields = ("title", "description") # Fields to use for add/edit/show page
    list_display = ("title", "description") # fields to display in search page
    list_display_links = ("title") # fields that will be a link in search page
    ordering("date_created",) # Ordering allowed in the search page
    search_fields("title", "description") # Search fields allowed in the search page

# Register app, BlogAdmin)

Routing: Django routing info is store in project_folder/ file

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/',, # pre-created admin urls routes
    path('', include('app_name.urls')) # include your app urls

the 'include()' method allow to link another file created in your app folder (app_name/

from django.urls import path
from . import views

url patterns = [ 
    path('posts', views.index, name='posts.index'),
    path('posts/create/', views.create, name='posts.create',
    path('posts/<int:id>/',, name=''),
    path('posts/<int:id>/edit/', views.edit, name='posts.edit'),
    path('posts/<int:id>/delete/', views.delete, name='posts.delete'),

Static route

from django.conf import settings
from django.conf.urls.static import static

urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

Function Based Views

from django.shortcuts import render, redirect
from .models import Post
from .forms import PostForm

def index(request):
    # Get all Posts
    posts = Post.objects.all()

    # Render app template with context
    return render(request, 'appfolder/index.html', {'posts': posts})

def show(request, id):
    post = Post.objects.get(id=id)
    return render(request, 'appfolder/show.html', {'post': post})

def create(request):
    form = PostForm(request.POST or None)
    if form.is_valid():
        # optionally we can access form data with form.cleaned_data['first_name']
        post =
        post.user = request.user
        return redirect('/posts')

    return render(request, 'appfolder/create.html', {'form': form)

def edit(request, id):
    post = Post.objects.get(id=id)
    form = PostForm(request.POST or None, instance=post)
    if form.is_valid():
        return redirect('/posts')

    return render(request, 'appfolder/edit.html', {'form': form)

def delete(request, id):
    post = Post.objects.get(id=id)
    return redirect('/posts')

Class based Views

from django.views.generic import TemplateView, ListView, DetailView, CreateView, UpdateView, DeleteView

class LandingPageView(TemplateView):
    template_name = 'landing.html'

    # Optional: Change context data dict
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['title'] = 'Landing Page'
        return context

class PostsListView(ListView):
    queryset = Post.objects.all()

  # Optional
    # context_object_name = "posts" (default: post_list)
    # template_name = 'posts.html' (default: posts/post_list.html) 

class PostsDetailView(DetailView):
    model = Post # object var in template

  # Optional
    # template_name = 'post.html' (default: posts/post_detail.html)

class PostsCreateView(CreateView):
    form_class = PostForm

    template_name = 'posts/post_create.html' # no default value

    def get_success_url(self):
        return reverse('posts-list')

    # Optional: Overwrite form data (before save)
    def form_valid(self, form):
        if self.request.user.is_authenticated:
   = self.request.user

        return super().form_valid(form)

class PostsUpdateView(UpdateView):
    model = Post
    form_class = PostForm
    template_name = 'posts/post_update.html'

    def get_success_url(self):
        return reverse('post-list')

    # Optional: Change context data dict
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['submit_text'] = 'Update'
        return context

class PostsDeleteView(DeleteView):
    model = Post
    template_name = 'posts/post_delete.html'
    success_url = reverse_lazy('posts-list')

# route declaration
path('<int:pk>/update/', PostsUpdateView.as_view(), name='post-update')

Django Template: Templates are store in project_folder/templates or in your app_folder/templates/app_name/*.html

{% extends 'base.html' %}
{% block content %}     
{% endblock %} 

{% include 'header.html' %} 

{% if user.username = 'Mike' %}
    <p>Hello Admin</p>   
{% else %}   
    <p>Hello User</p>
{% endif %} 

{% for product in products %}   
  <p>The product name is {{ product }}<p>
{% endfor %} 

{{ var_name }}

Template variables formating
{{ title | lower }} 
{{ | truncatwords:50 }}
{{ | date:"D M Y" }}
{{ list_items | slice:":3" }}
{{ total | default:"nil" }}

Current path (ex. posts/1/show)
{{ request.path }}   

URL by name with param
{% url 'posts.delete' %}

Use static in template: 
{% load static %}
{% static 'css/main.css' %}

Model Managers and Querysets: Model manager allow model database reads and writes

# One line create and save
Article.objects.create(name='Item 1', price=19.95) 

# Read all

# Create
user = User.objects.first()
article = Article(user=user, name='Item 1', price=19.95)

# Save

# Read one

# Select Related (to avoid n+1 query)
posts = Post.objects.select_related('user', 'category').all()

# Read or render a 404 not found page
from django.shortcuts import get_object_or_404
article = get_object_or_404(Article, id=512)

# Filter 
Article.objects.filter(model='dyson', name__icontains='dyson') # __icontains    
Article.objects.filter(year__gt=2016) # __gt = greater than 
Article.objects.filter(year__lt=2001) # __lt = less than 

# Filter on relationship sub model field

# Ordering 
Article.objects.order_by('name')     # ascending
Article.objects.order_by('-name')   # descending

# Slicing return first

# Slicing return last

# Slicing limit/offset

# Updating
article = Article.objects.first() = 'new name'

# One line update
Article.objects.filter(id=4).update(name='new name')

# Deleting
article = Article.objects.first()

# One line delete

# Delete all

# Set ForeignKey field value
model1 = Model(name='dyson')
article.model = model1

# Get ForeignKey value

# Add Many-to-Many

Form (

from django import forms
class ArticleForm(forms.Form): 
    name = forms.Charfield(max_length=100)
    description = forms.Charfield(blank=True, null = True)

# Model Form 
from django.forms import ModelForm
from .models import Article
class ArticleForm(ModelForm):
    class Meta:
        model = Article
        fields = ['name', 'description', 'price'] # Use '__all__' for all fields

# Render form in template
<form method=“post” action=“” novalidate> 
    {% csrf_token %}
    {{ form }} 
    <button type="submit">Submit</button>

# Bootstrap (pip install django-crispy-forms + installed_apps: 'crispy_forms')
{% load crispy_forms_tags %}
{{ form|crispy }}
{{|as_crispy_field }}

# crispy-tailwind
pip install crispy-tailwind


# template usage
{% load tailwind_filters %}
{{ form|crispy}}

Form validation

from django.core.exceptions import ValidationError

# field validation 
def clean_first_name(self):
    data = self.cleaned_data['first_name']
    if data = 'Mike':
        raise ValidationError('Your name must not be Mike')

    return data

# form validation 
def clean(self):
    first_name = self.cleaned_data['first_name']
    last_name = self.cleaned_data['last_name']
    if first_name + last_name = 'MikeTaylor':
        raise ValidationError('Your name must not be Mike Taylor')

Flash messages

messages.success(request, 'Login successful')
messages.error(request, 'Login error')

# Message tags
# debug, info, success, warning and error

# Display flash in template 
{% if messages %} 
    {% for message in messages %} 
        {% message %} 
        {% message.tags %}

User model (pre-created)

# Get a reference to Django pre-created User model
from django.contrib.auth import get_user_model

User = get_user_model()

# Or if you want to custom user model
from django.contrib.auth.models import AbstractUser

class User(AbstractUser): 
    # add custom fields and methods

# To make Django use that model go to and add: AUTH_USER_MODEL = 'app_name.User'

Authentification: LoginView

# LoginView is already pre-created by Django
from django.contrib.auth.views import LoginView

# Add a url to reach that view
path('login/', LoginView.as_view(), name='login')

# By default the LoginView will try to open a template name 'registration/login.html' and send a login form with it.

# Create a template under registration/login.html
{% extends "base.html" %}
{% block content %}
    <form method="post">
        {% csrf_token %}
        {{ form }}
        <button type="submit">Login</button>
{% endblock content %}

# When user click the Login button, the LoginView will try to authenticate the user with the form username ans password. 

# If successful il will then login the user and redirect to LOGIN_REDIRECT_URL specified in your

Authentification: LogoutView

# LogoutView is already pre-created by Django
from django.contrib.auth.views import LogoutView

# Add a url to reach that view
path('logout/', LoginView.as_view(), name='logout')

# Include a link in a template
<a> href="{% url 'logout' %}">Logout</a>

# After link is execute, the user will be logout and redirect to LOGOUT_REDIRECT_URL specified in your

Authentification: SignupView

# Create a SignupView (that view is not created by default)
# import sinupview form pre-created by Django
from django.contrib.auth.forms import UserCreationForm
from django.views.generic import CreateView

class SignupView(CreateView):
    template_name = 'registration/signup.html'
    form_class = UserCreationForm

    def get_success_url(self):
        return reverse("login")

# Create template: registration/signup.html
{% extends "base.html" %}
{% block content %}
    <form method="post">
        {% csrf_token %}
        {{ form }}
        <button type="submit">Signup</button>
{% endblock content %}

# Add a url to reach that view
from posts.views import SignupView

path('signup/', SignupView.as_view(), name='signup')

# Optional: Customize the UserCreationForm
# (
from django.contrib.auth import get_user_model
from django.contrib.auth.forms import UserCreationForm

User = get_user_model()
class CustomUserCreationForm(UserCreattionForm):
    class Meta:
        model = User
        fields = ['username']
        fields_classes = {'username': UsernameField}

Optional pre-created authentification routes

urlpatterns += path('', include('django.contrib.auth.urls'))
# /login, /lougout, /signup, etc.

Template Authentification helpers

# Authentication links
<a href="{% url 'login' %}">Login</a>
<a href="{% url 'signup' %}">Signup</a>
<a href="{% url 'logout' %}">Logout</a>

# Check if user login
{% if request.user.is_authenticated %}
    Logged in as: {{ request.user.username }}
{% endif %}

Authorization: LoginRequiredMixin and login_required

from django.contrib.auth.mixins import LoginRequiredMixin

# Restrict views to auth user only (
class PostsCreateView(LoginRequiredMixin, generic.CreateView):

from django.contrib.auth.decorators import login_required

def search_page(request):

Manual Authentification, Login and Logout

from django.contrib.auth import authenticate, login

def login_page(request):
    if request.method == "POST":
        username = request.POST.get("username")
        password = request.POST.get("password")
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return redirect("index")

return render(request, "registration/login.html", {})

def logout_page(request):
    return redirect("index")

User Change password

# set_password will hash the password
user.set_password('raw password')

Send Email

EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"

# Send email function
from import send_mail

    subject = "A new post has been created",
    messsage = "Go to the web site to see the detail",
    from_email = "",
    recipient_list = [""]


from django.db.models.signals import post_save, pre_save

def post_user_created_signal(sender, instance, created, **kwargs):
    if created:

# Launch the post_user_create_singal method if User model is save
post_save.connect(post_user_created_signal, sender=User)


from .models import Product, Category
from django.shortcuts import HttpResponse
from faker import Faker

def seed(request):

    category = Category() = "Sports"

    category = Category() = "Home"

    fake = Faker()
    for _ in range(100):
        product = Product() = fake.unique.word()
        product.short_description = fake.sentence()
        product.main_picture = fake.image_url()
        product.price = fake.random_digit() * 10
        product.category =  Category.objects.order_by('?').first()

    return HttpResponse('Seeded')

.env key/value file

$ pip install django-dotenv

add code to file

import dotenv

def main():
    """Run administrative tasks."""
    dotenv.read_dotenv() #add this line

Create a file name '.env' in the root folder of your project

SECRET_KEY = 'your secret key'

In change security related settings to point to the .env file

import os
SECRET_KEY = os.environ.get('SECRET_KEY')
Share this