1. Django Cheat Sheet

pip install django

python -m venv venv
source venv/bin/activate  # On Linux/macOS
venv\Scripts\activate  # On Windows

django-admin startproject myproject
cd myproject

python manage.py startapp myapp

python manage.py runserver

from django.db import models

class MyModel(models.Model):
    name = models.CharField(max_length=100, help_text="Enter the name")
    description = models.TextField(blank=True, null=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    is_active = models.BooleanField(default=True)
    order = models.PositiveIntegerField(default=0)

    def __str__(self):
        return self.name

    class Meta:
        ordering = ['order', '-created_at']  # Default ordering
        verbose_name = "My Model Entry"
        verbose_name_plural = "My Model Entries"

from .models import MyModel

# Get all objects
all_objects = MyModel.objects.all()

# Filter objects
filtered_objects = MyModel.objects.filter(name__contains='keyword', is_active=True)

# Get a single object by primary key
single_object = MyModel.objects.get(pk=1)

# Get a single object, handling DoesNotExist exception
from django.shortcuts import get_object_or_404
single_object = get_object_or_404(MyModel, pk=1)

# Create a new object
new_object = MyModel.objects.create(name='New Object', description='...')

# Update an existing object
obj = MyModel.objects.get(pk=1)
obj.name = 'Updated Name'
obj.save()

# Delete an object
obj = MyModel.objects.get(pk=1)
obj.delete()

# Complex lookups with Q objects
from django.db.models import Q
objects = MyModel.objects.filter(Q(name__startswith='A') | Q(description__icontains='data'))

# Ordering
ordered_objects = MyModel.objects.order_by('name', '-created_at')

# Limiting results
limited_objects = MyModel.objects.all()[:10]

# Chaining queries
chained_objects = MyModel.objects.filter(is_active=True).order_by('name')

from django.db import connection

def my_raw_query():
    with connection.cursor() as cursor:
        cursor.execute("SELECT * FROM myapp_mymodel WHERE name = %s", ['My Name'])
        row = cursor.fetchone()
        return row

from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse, JsonResponse
from .models import MyModel

def my_view(request):
    data = MyModel.objects.all()  # Get all objects from MyModel
    context = {'data': data}
    return render(request, 'myapp/mytemplate.html', context)

def detail_view(request, pk):
    item = get_object_or_404(MyModel, pk=pk)
    return render(request, 'myapp/detail.html', {'item': item})

def json_response(request):
    data = {'message': 'Hello, world!'}
    return JsonResponse(data)

def http_response(request):
    return HttpResponse("<h1>Hello, world!</h1>", content_type="text/html")

from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
from django.urls import reverse_lazy
from .models import MyModel

class MyListView(ListView):
    model = MyModel
    template_name = 'myapp/mymodel_list.html'
    context_object_name = 'data'  # Renames the object_list in the template
    paginate_by = 10  # Enable pagination

class MyDetailView(DetailView):
    model = MyModel
    template_name = 'myapp/mymodel_detail.html'
    context_object_name = 'item'

class MyCreateView(CreateView):
    model = MyModel
    fields = ['name', 'description', 'is_active']  # Fields to include in the form
    template_name = 'myapp/mymodel_form.html'
    success_url = reverse_lazy('myapp:my_list_view')  # Redirect after successful creation

class MyUpdateView(UpdateView):
    model = MyModel
    fields = ['name', 'description', 'is_active']
    template_name = 'myapp/mymodel_form.html'
    success_url = reverse_lazy('myapp:my_list_view')

class MyDeleteView(DeleteView):
    model = MyModel
    template_name = 'myapp/mymodel_confirm_delete.html'
    success_url = reverse_lazy('myapp:my_list_view')

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('myapp/', include('myapp.urls', namespace='myapp')),  # Include app's URLs with namespace
]

from django.urls import path
from . import views

app_name = 'myapp'  # App namespace

urlpatterns = [
    path('', views.my_view, name='my_view'),
    path('list/', views.MyListView.as_view(), name='my_list_view'),
    path('detail/<int:pk>/', views.MyDetailView.as_view(), name='my_detail_view'),
    path('create/', views.MyCreateView.as_view(), name='my_create_view'),
    path('update/<int:pk>/', views.MyUpdateView.as_view(), name='my_update_view'),
    path('delete/<int:pk>/', views.MyDeleteView.as_view(), name='my_delete_view'),
]

<a href="{% url 'myapp:my_detail_view' item.pk %}">{{ item.name }}</a>

from django.urls import reverse

url = reverse('myapp:my_detail_view', kwargs={'pk': 1})

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}My Template{% endblock %}</title>
    {% load static %}
    <link rel="stylesheet" href="{% static 'myapp/css/style.css' %}">
</head>
<body>
    <header>
        <h1>{% block header %}My Website{% endblock %}</h1>
    </header>

    <main>
        {% block content %}
            <h1>Data from MyModel:</h1>
            <ul>
                {% for item in data %}
                    <li><a href="{% url 'myapp:my_detail_view' item.pk %}">{{ item.name }}</a> - {{ item.description }}</li>
                {% empty %}
                    <li>No data available.</li>
                {% endfor %}
            </ul>
        {% endblock %}
    </main>

    <footer>
        <p>&copy; 2025 My Website</p>
    </footer>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}My Website{% endblock %}</title>
</head>
<body>
    <header>
        <h1>{% block header %}My Website{% endblock %}</h1>
    </header>

    <main>
        {% block content %}{% endblock %}
    </main>

    <footer>
        <p>&copy; 2025 My Website</p>
    </footer>
</body>
</html>

{% extends 'base.html' %}

{% block title %}My Custom Title{% endblock %}

{% block content %}
    <h1>Data from MyModel:</h1>
    <ul>
        {% for item in data %}
            <li>{{ item.name }} - {{ item.description }}</li>
        {% endfor %}
    </ul>
{% endblock %}

from django import forms
from .models import MyModel

class MyForm(forms.Form):
    name = forms.CharField(label="Your Name", max_length=100,
                           widget=forms.TextInput(attrs={'class': 'form-control'}))
    email = forms.EmailField(label="Your Email",
                            widget=forms.EmailInput(attrs={'class': 'form-control'}))
    message = forms.CharField(widget=forms.Textarea(attrs={'class': 'form-control'}),
                              label="Your Message")
    agree = forms.BooleanField(label="I agree to the terms", required=True)

    # Custom validation
    def clean_name(self):
        name = self.cleaned_data['name']
        if len(name) < 3:
            raise forms.ValidationError("Name must be at least 3 characters long.")
        return name

class MyModelForm(forms.ModelForm):
    class Meta:
        model = MyModel
        fields = ['name', 'description', 'is_active']
        widgets = {
            'description': forms.Textarea(attrs={'rows': 4, 'cols': 40}),
        }
        labels = {
            'name': 'Model Name',
            'description': 'Model Description',
        }
        help_texts = {
            'name': 'Enter a descriptive name for the model.',
        }
        error_messages = {
            'name': {
                'required': 'Please enter a name.',
            },
        }

<form method="post">
    {% csrf_token %}
    {% if form.errors %}
        <div class="alert alert-danger">
            Please correct the errors below.
        </div>
    {% endif %}
    {{ form.as_p }}  {# Renders the form as a series of <p> tags #}
    {# Or render fields individually: #}
    {# <div class="form-group">
        {{ form.name.label_tag }}
        {{ form.name }}
        {{ form.name.errors }}
    </div> #}
    <button type="submit">Submit</button>
</form>

from django.shortcuts import render, redirect
from .forms import MyForm, MyModelForm

def my_form_view(request):
    if request.method == 'POST':
        form = MyForm(request.POST)
        if form.is_valid():
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            message = form.cleaned_data['message']
            # Process the data (e.g., save to database, send email)
            return redirect('success_url')  # Redirect to a success page
        else:
            # Form is invalid, display errors
            return render(request, 'myapp/myform.html', {'form': form})
    else:
        form = MyForm()
    return render(request, 'myapp/myform.html', {'form': form})

def my_model_form_view(request):
    if request.method == 'POST':
        form = MyModelForm(request.POST, request.FILES) # Include request.FILES for file uploads
        if form.is_valid():
            instance = form.save()  # Save the model instance
            # Or, to process data before saving:
            # new_instance = form.save(commit=False)
            # new_instance.some_field = 'some_value'
            # new_instance.save()
            return redirect('my_list_view')
        else:
            return render(request, 'myapp/mymodel_form.html', {'form': form})
    else:
        form = MyModelForm()
    return render(request, 'myapp/mymodel_form.html', {'form': form})

from django.contrib import admin
from .models import MyModel

admin.site.register(MyModel)

from django.contrib import admin
from .models import MyModel

@admin.register(MyModel)
class MyModelAdmin(admin.ModelAdmin):
    list_display = ('name', 'created_at', 'is_active')  # Columns to display in list view
    search_fields = ('name', 'description') # Enable search
    list_filter = ('is_active', 'created_at')          # Enable filtering
    ordering = ('name',)
    readonly_fields = ('created_at', 'updated_at')
    date_hierarchy = 'created_at' # Drill-down by date
    prepopulated_fields = {'slug': ('name',)} # Automatically populate slug field
    raw_id_fields = ('related_model',) # Use raw ID lookup for ForeignKey/ManyToManyField
    filter_horizontal = ('many_to_many_field',) # Use horizontal filter for ManyToManyField
    filter_vertical = ('another_many_to_many_field',) # Use vertical filter for ManyToManyField
    fieldsets = (
        (None, {
            'fields': ('name', 'description')
        }),
        ('Advanced options', {
            'classes': ('collapse',),
            'fields': ('is_active', 'order'),
        }),
    )
    actions = ['make_active', 'make_inactive']

    def make_active(self, request, queryset):
        queryset.update(is_active=True)
    make_active.short_description = "Mark selected entries as active"

    def make_inactive(self, request, queryset):
        queryset.update(is_active=False)
    make_inactive.short_description = "Mark selected entries as inactive"

from django.contrib import admin
from .models import MyModel, RelatedModel

class RelatedModelAdminInline(admin.TabularInline):  # Or admin.StackedInline
    model = RelatedModel
    extra = 1  # Number of empty forms to display
    fk_name = 'mymodel' # Specify the ForeignKey field name in RelatedModel

@admin.register(MyModel)
class MyModelAdmin(admin.ModelAdmin):
    inlines = [RelatedModelAdminInline]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',  # Or 'django.db.backends.mysql', 'django.db.backends.sqlite3'
        'NAME': 'mydatabase',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, 'myapp/static'),
]

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',
    'django.middleware.cache.UpdateCacheMiddleware', # Add for caching
    'django.middleware.cache.FetchFromCacheMiddleware', # Add for caching
]

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379',
    }
}

CACHE_MIDDLEWARE_ALIAS = 'default'
CACHE_MIDDLEWARE_SECONDS = 600  # Cache for 10 minutes
CACHE_MIDDLEWARE_KEY_PREFIX = ''

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.gmail.com'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = 'your_email@gmail.com'
EMAIL_HOST_PASSWORD = 'your_password'
DEFAULT_FROM_EMAIL = 'your_email@gmail.com'

pip install djangorestframework

from rest_framework import serializers
from .models import MyModel

class MyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = '__all__'  # Or specify a tuple of field names
        # or exclude = ('field1', 'field2')
        read_only_fields = ('created_at', 'updated_at') # Make fields read-only

    # Custom field validation
    def validate_name(self, value):
        if len(value) < 5:
            raise serializers.ValidationError("Name must be at least 5 characters long.")
        return value

    # Object-level validation
    def validate(self, data):
        if data['name'] == data['description']:
            raise serializers.ValidationError("Name and description cannot be the same.")
        return data

from rest_framework import generics, permissions, status
from rest_framework.response import Response
from .models import MyModel
from .serializers import MyModelSerializer

class MyModelList(generics.ListCreateAPIView):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly] # Require authentication for write operations

    def perform_create(self, serializer):
        serializer.save() # Save the object

class MyModelDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]

    def delete(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT) # Return 204 No Content on successful deletion

from django.urls import path
from . import views

urlpatterns = [
    path('mymodel/', views.MyModelList.as_view(), name='mymodel-list'),
    path('mymodel/<int:pk>/', views.MyModelDetail.as_view(), name='mymodel-detail'),
]

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from .models import MyModel
from .serializers import MyModelSerializer

class MyCustomAPIView(APIView):
    def get(self, request):
        data = MyModel.objects.all()
        serializer = MyModelSerializer(data, many=True)
        return Response(serializer.data)

    def post(self, request):
        serializer = MyModelSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

import TestCase
from .models import MyModel

class MyModelTest(TestCase):
    def setUp(self):
        MyModel.objects.create(name='Test Object', description='Test Description')

    def test_model_content(self):
        obj = MyModel.objects.get(name='Test Object')
        self.assertEqual(obj.description, 'Test Description')

from django.test import Client

class MyViewTest(TestCase):
    def setUp(self):
        self.client = Client()

    def test_my_view(self):
        response = self.client.get('/myapp/')
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, 'My Template')

from .settings import *

DEBUG = False
ALLOWED_HOSTS = ['yourdomain.com', 'www.yourdomain.com']
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')

pip install gunicorn

gunicorn myproject.wsgi:application --bind 0.0.0.0:8000

[Unit]
Description=My Django Project
After=network.target

[Service]
User=myuser
Group=mygroup
WorkingDirectory=/path/to/myproject
ExecStart=/path/to/venv/bin/gunicorn myproject.wsgi:application --bind 0.0.0.0:8000

[Install]
WantedBy=multi-user.target

sudo systemctl enable myproject
sudo systemctl start myproject

# settings.py
MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware',
    # ... other middleware ...
    'django.middleware.cache.FetchFromCacheMiddleware',
]

# settings.py
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379',  # Example using Redis
    }
}

CACHE_MIDDLEWARE_ALIAS = 'default'
CACHE_MIDDLEWARE_SECONDS = 600  # Cache for 10 minutes
CACHE_MIDDLEWARE_KEY_PREFIX = ''

from django.views.decorators.cache import cache_page

@cache_page(60 * 15)  # Cache for 15 minutes
def my_view(request):
    # ...
    return render(request, 'myapp/mytemplate.html', context)

{% load cache %}

{% cache 600 "my_template_fragment" %}
    {# Expensive template code here #}
{% endcache %}

from django.core.cache import cache

# Set a value
cache.set('my_key', 'my_value', 600)  # Cache for 10 minutes

# Get a value
value = cache.get('my_key')

# Delete a value
cache.delete('my_key')

from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import MyModel

@receiver(post_save, sender=MyModel)
def my_model_post_save(sender, instance, created, **kwargs):
    if created:
        # Perform actions when a new MyModel instance is created
        print(f"New MyModel instance created: {instance.name}")
    else:
        # Perform actions when a MyModel instance is updated
        print(f"MyModel instance updated: {instance.name}")

from django.apps import AppConfig

class MyappConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'myapp'

    def ready(self):
        import myapp.signals  # Import the signals module

from django.utils.translation import gettext as _

def my_view(request):
    message = _("Hello, world!")
    return render(request, 'myapp/mytemplate.html', {'message': message})

{% load i18n %}
<h1>{% trans "Hello, world!" %}</h1>

python manage.py makemessages -l de  # Create a translation file for German

from django.utils.translation import pgettext as _

message = _("context", "Hello, world!")

from django.utils.translation import ngettext

def my_view(request, count):
    message = ngettext(
        'There is %(count)d object',
        'There are %(count)d objects',
        count
    ) % {'count': count}
    return render(request, 'myapp/mytemplate.html', {'message': message})

<form action="{% url 'set_language' %}" method="post">
    {% csrf_token %}
    <input name="language" type="hidden" value="de">
    <button type="submit">Switch to German</button>
</form>

from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = 'My custom command'

    def add_arguments(self, parser):
        parser.add_argument('argument', nargs='?', type=str, help='An argument for the command')

    def handle(self, *args, **options):
        argument = options['argument']
        self.stdout.write(self.style.SUCCESS(f'Successfully executed mycommand with argument: {argument}'))

python manage.py mycommand "My Argument"

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

    def __call__(self, request):
        # Code to be executed for each request before the view (pre-processing)
        print("Before view")

        response = self.get_response(request)

        # Code to be executed for each request after the view (post-processing)
        print("After view")

        return response

MIDDLEWARE = [
    # ...
    'myapp.middleware.MyMiddleware',
]

class UploadFileForm(forms.Form):
    file = forms.FileField()

def upload_file(request):
    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            uploaded_file = request.FILES['file']
            # Process the uploaded file (e.g., save to MEDIA_ROOT)
            with open(os.path.join(settings.MEDIA_ROOT, uploaded_file.name), 'wb+') as destination:
                for chunk in uploaded_file.chunks():
                    destination.write(chunk)
            return HttpResponse("File uploaded successfully")
    else:
        form = UploadFileForm()
    return render(request, 'myapp/upload.html', {'form': form})

<form method="post" enctype="multipart/form-data">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Upload</button>
</form>

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

urlpatterns = [
    # ... your other URL patterns ...
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
        },
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': os.path.join(BASE_DIR, 'debug.log'),
        },
    },
    'loggers': {
        'django': {
            'handlers': ['console', 'file'],
            'level': 'INFO',
        },
    },
}

import logging

logger = logging.getLogger(__name__)

def my_view(request):
    logger.info("My view was accessed")
    try:
        # ... some code that might raise an exception ...
    except Exception as e:
        logger.exception("An error occurred")

pip install channels

ASGI_APPLICATION = 'myproject.asgi.application'

CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels_redis.core.RedisChannelLayer',
        'CONFIG': {
            "hosts": [('127.0.0.1', 6379)],
        },
    },
}

from channels.generic.websocket import WebsocketConsumer
import json

class MyConsumer(WebsocketConsumer):
    def connect(self):
        self.accept()

    def disconnect(self, close_code):
        pass

    def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']

        self.send(text_data=json.dumps({
            'message': message
        }))

from django.urls import re_path

from . import consumers

websocket_urlpatterns = [
    re_path(r'ws/myapp/$', consumers.MyConsumer.as_asgi()),
]

import os

from django.core.asgi import get_asgi_application
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import myapp.routing

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": AuthMiddlewareStack(
        URLRouter(
            myapp.routing.websocket_urlpatterns
        )
    ),
})

pip install django-allauth

INSTALLED_APPS = [
    # ...
    'django.contrib.sites',
    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    # ... include providers you want to use ...
    # 'allauth.socialaccount.providers.google',
]

AUTHENTICATION_BACKENDS = [
    'django.contrib.auth.backends.ModelBackend',
    'allauth.account.auth_backends.AuthenticationBackend',
]

SITE_ID = 1

LOGIN_REDIRECT_URL = '/'
ACCOUNT_EMAIL_REQUIRED = True
ACCOUNT_USERNAME_REQUIRED = False
ACCOUNT_AUTHENTICATION_METHOD = 'email'
ACCOUNT_EMAIL_VERIFICATION = 'mandatory'

from django.urls import include, path

urlpatterns = [
    path('accounts/', include('allauth.urls')),
]

pip install django-debug-toolbar

INSTALLED_APPS = [
    # ...
    'debug_toolbar',
]

MIDDLEWARE = [
    # ...
    'debug_toolbar.middleware.DebugToolbarMiddleware',
]

INTERNAL_IPS = [
    '127.0.0.1',
]

from django.urls import include, path

urlpatterns = [
    # ...
]

if settings.DEBUG:
    import debug_toolbar
    urlpatterns += [
        path('__debug__/', include(debug_toolbar.urls)),
    ]