DJANGO
CHEAT SHEET.

Project Setup

# Install Django
pip install django

# Create project
django-admin startproject myproject

# Create app
python manage.py startapp myapp

# Run server
python manage.py runserver
python manage.py runserver 8080

# Database migrations
python manage.py makemigrations
python manage.py migrate
python manage.py migrate app_name

# Create superuser
python manage.py createsuperuser

# Shell
python manage.py shell

Project Structure

myproject/
├── manage.py
├── myproject/
│   ├── __init__.py
│   ├── settings.py      # project settings
│   ├── urls.py          # URL routing
│   └── wsgi.py          # WSGI entry
└── myapp/
    ├── __init__.py
    ├── admin.py         # admin registration
    ├── apps.py
    ├── models.py        # database models
    ├── views.py         # view functions/classes
    ├── urls.py          # app URLs
    ├── tests.py
    └── templates/       # HTML templates
        └── myapp/

Settings

# settings.py
# Add app to INSTALLED_APPS
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',  # add your app
]

# Database
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

# PostgreSQL
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydb',
        'USER': 'user',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

# Static files
STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / 'static']
STATIC_ROOT = BASE_DIR / 'staticfiles'

# Media files
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'

# Templates
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [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',
            ],
        },
    },
]

URL Routing

Project URLs (urls.py)

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

App URLs (myapp/urls.py)

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
    path('about/', views.about, name='about'),
    path('users//', views.user_detail, name='user_detail'),
    path('posts//', views.post_detail, name='post_detail'),
]

# With class‑based views
from .views import HomeView, AboutView

urlpatterns = [
    path('', HomeView.as_view(), name='home'),
    path('about/', AboutView.as_view(), name='about'),
]

URL Parameters

# Integer
path('user//', views.user_detail)

# String
path('post//', views.post_detail)

# Slug
path('post//', views.post_detail)

# UUID
path('order//', views.order_detail)

# Path (with slashes)
path('files//', views.file_view)

Views

Function‑Based Views

from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse, JsonResponse
from django.contrib.auth.decorators import login_required

def home(request):
    return render(request, 'home.html', {'title': 'Home'})

def about(request):
    return HttpResponse("About Page")

def user_detail(request, user_id):
    user = get_object_or_404(User, id=user_id)
    return render(request, 'user.html', {'user': user})

@login_required
def profile(request):
    return render(request, 'profile.html')

def api_data(request):
    data = {'name': 'Alice', 'age': 25}
    return JsonResponse(data)

Class‑Based Views

from django.views.generic import TemplateView, ListView, DetailView, CreateView, UpdateView, DeleteView
from django.contrib.auth.mixins import LoginRequiredMixin
from .models import Post

class HomeView(TemplateView):
    template_name = 'home.html'

class PostListView(ListView):
    model = Post
    template_name = 'posts/list.html'
    context_object_name = 'posts'
    paginate_by = 10
    ordering = ['-created_at']

class PostDetailView(DetailView):
    model = Post
    template_name = 'posts/detail.html'

class PostCreateView(LoginRequiredMixin, CreateView):
    model = Post
    fields = ['title', 'content']
    template_name = 'posts/form.html'
    success_url = '/'

    def form_valid(self, form):
        form.instance.author = self.request.user
        return super().form_valid(form)

Models

from django.db import models
from django.contrib.auth.models import User

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='posts')
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    is_published = models.BooleanField(default=True)

    class Meta:
        ordering = ['-created_at']

    def __str__(self):
        return self.title

    def get_absolute_url(self):
        from django.urls import reverse
        return reverse('post_detail', args=[str(self.id)])

Field Types

Django ORM (Queries)

CRUD

# Create
post = Post(title='Hello', content='World')
post.save()

Post.objects.create(title='Hello', content='World')

# Read
all_posts = Post.objects.all()
post = Post.objects.get(id=1)
posts = Post.objects.filter(is_published=True)
posts = Post.objects.filter(title__icontains='hello')
post = Post.objects.get(id=1)  # raises DoesNotExist if not found
post = Post.objects.first()
post = Post.objects.last()
count = Post.objects.count()

# Update
post = Post.objects.get(id=1)
post.title = 'New Title'
post.save()

Post.objects.filter(id=1).update(title='New Title')

# Delete
post = Post.objects.get(id=1)
post.delete()

Post.objects.filter(id=1).delete()

# Exists
exists = Post.objects.filter(id=1).exists()

# Order
posts = Post.objects.order_by('title')
posts = Post.objects.order_by('-created_at')

Filter Operators

# Exact match
Post.objects.filter(title__exact='Hello')
Post.objects.filter(title='Hello')

# Contains
Post.objects.filter(title__contains='ello')
Post.objects.filter(title__icontains='ello')  // case‑insensitive

# Starts / Ends
Post.objects.filter(title__startswith='He')
Post.objects.filter(title__endswith='lo')

# In
Post.objects.filter(id__in=[1, 2, 3])

# Greater / Less
Post.objects.filter(id__gt=5)
Post.objects.filter(id__gte=5)
Post.objects.filter(id__lt=10)
Post.objects.filter(id__lte=10)

# Range
Post.objects.filter(id__range=[1, 10])

# Date
Post.objects.filter(created_at__year=2024)
Post.objects.filter(created_at__month=1)
Post.objects.filter(created_at__day=15)
Post.objects.filter(created_at__date=datetime.date(2024, 1, 15))

# Is null
Post.objects.filter(content__isnull=True)

# Regex
Post.objects.filter(title__regex=r'^[A-Z].*')

Relationships

# ForeignKey (reverse)
user = User.objects.get(id=1)
posts = user.posts.all()  // using related_name

# Select related (join)
posts = Post.objects.select_related('author').all()

# Prefetch related
posts = Post.objects.prefetch_related('comments').all()

# Filter by related
posts = Post.objects.filter(author__username='alice')

# Aggregation
from django.db.models import Count, Sum, Avg, Max, Min
posts = Post.objects.values('author').annotate(total=Count('id'))
avg = Post.objects.aggregate(Avg('id'))

Templates

Template Syntax

{{ variable }}
{{ user.username }}
{{ post.title|upper }}
{{ post.content|truncatewords:30 }}
{{ post.created_at|date:"Y-m-d" }}
{{ value|default:"nothing" }}


{% if user.is_authenticated %}
    Welcome, {{ user.username }}
{% else %}
    Please login
{% endif %}

{% for post in posts %}
    
{{ post.title }}
    
{{ post.content }}
{% empty %}
    No posts
{% endfor %}


Home
Detail


{% load static %}



{# This is a comment #}


{% include 'header.html' %}


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

Filters

Forms

from django import forms
from .models import Post

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ['title', 'content']

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

Form in View

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

def create_post(request):
    if request.method == 'POST':
        form = PostForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('home')
    else:
        form = PostForm()
    return render(request, 'form.html', {'form': form})

Form in Template

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Submit</button>
</form>


<form method="post">
    {% csrf_token %}
    {% for field in form %}
        <div>
            {{ field.label_tag }}
            {{ field }}
            {{ field.errors }}
        </div>
    {% endfor %}
    <button type="submit">Submit</button>
</form>

Admin

from django.contrib import admin
from .models import Post

# Basic registration
admin.site.register(Post)

# Custom admin
@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ['title', 'author', 'created_at', 'is_published']
    list_filter = ['is_published', 'created_at']
    search_fields = ['title', 'content']
    prepopulated_fields = {'slug': ['title']}
    date_hierarchy = 'created_at'
    ordering = ['-created_at']
    fields = ['title', 'slug', 'content', 'author', 'is_published']

# Inline admin
class CommentInline(admin.TabularInline):  // or StackedInline
    model = Comment
    extra = 1

Authentication

# Login / Logout
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required

def login_view(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return redirect('home')
    return render(request, 'login.html')

def logout_view(request):
    logout(request)
    return redirect('home')

# User creation
from django.contrib.auth.models import User
user = User.objects.create_user('alice', 'alice@example.com', 'password')

# Current user
user = request.user

Messages

from django.contrib import messages

def my_view(request):
    messages.success(request, 'Operation successful!')
    messages.error(request, 'Something went wrong.')
    messages.warning(request, 'Warning message.')
    messages.info(request, 'Info message.')
    messages.debug(request, 'Debug message.')
    return render(request, 'page.html')

Middleware

# Custom middleware
class MyMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Before view
        response = self.get_response(request)
        # After view
        return response

# Add to settings.py
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'myapp.middleware.MyMiddleware',
]

REST Framework (DRF)

pip install djangorestframework

# settings.py
INSTALLED_APPS += ['rest_framework']

# Serializer
from rest_framework import serializers
from .models import Post

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ['id', 'title', 'content', 'author', 'created_at']

# API View
from rest_framework import generics
from .models import Post
from .serializers import PostSerializer

class PostListAPI(generics.ListCreateAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

class PostDetailAPI(generics.RetrieveUpdateDestroyAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

Best Practices

• Use environment variables – for sensitive settings (SECRET_KEY, DB credentials).
• Keep apps modular – each app should have a single responsibility.
• Use class‑based views – for reusability and consistency.
• Use templates inheritance – DRY (Don't Repeat Yourself).
• Add `@login_required` – to protect views.
• Use `get_object_or_404` – instead of `Model.objects.get()`.
• Add `__str__` – to models for readable representation.
• Use `prefetch_related` and `select_related` – to optimise queries.
• Use `django‑debug‑toolbar` – for development.
• Write tests – for your models and views.
• Use `python manage.py check` – to validate your project.
• Use `pip freeze > requirements.txt` – to track dependencies.
• Use `git` – for version control.