Einstieg
Installieren & Projekt anlegen
Django über pip installieren. Ein Projekt hält Einstellungen und URLs; eine App ist ein wiederverwendbares Modul mit Models und Views.
pip install django
django-admin startproject myproject
cd myproject
python manage.py startapp myappEntwicklungsserver starten
Startet den eingebauten Dev-Server mit Auto-Reload. Niemals in Produktion einsetzen.
python manage.py runserver
# Default: http://127.0.0.1:8000
python manage.py runserver 8080
python manage.py runserver 0.0.0.0:8000Migrations & Superuser
makemigrations erzeugt Migrationsdateien aus Modell-Änderungen. migrate wendet sie auf die DB an. createsuperuser legt ein Admin-Konto an.
python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuserProjektstruktur
manage.py ist das CLI-Tool. Das innere Paket hält die Projektkonfiguration; das App-Verzeichnis hält den App-Code.
myproject/
manage.py # CLI utility
myproject/
settings.py # Configuration
urls.py # Root URL dispatcher
wsgi.py # WSGI entry point
asgi.py # ASGI entry point
myapp/
models.py # Database models
views.py # View functions
admin.py # Admin registrationSettings-Grundlagen
INSTALLED_APPS listet die aktiven Apps. In Produktion DEBUG=False setzen und ALLOWED_HOSTS konfigurieren.
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'myapp',
]
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
DEBUG = True
ALLOWED_HOSTS = []Model-Felder
Ein Model definieren
Jede Model-Klasse mappt auf eine DB-Tabelle. Jedes Feld mappt auf eine Spalte. __str__ definiert den Anzeigenamen.
from django.db import models
class Article(models.Model):
title = models.CharField(max_length=200)
body = models.TextField()
published = models.DateTimeField(auto_now_add=True)
def __str__(self):
return self.titleHäufige Feldtypen
CharField verlangt max_length. auto_now_add setzt bei Erzeugung; auto_now aktualisiert bei jedem Speichern. EmailField/URLField ergänzen Validierung.
name = models.CharField(max_length=100)
description = models.TextField(blank=True)
price = models.DecimalField(max_digits=10, decimal_places=2)
quantity = models.IntegerField(default=0)
is_active = models.BooleanField(default=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
email = models.EmailField(unique=True)
url = models.URLField(blank=True)Feld-Optionen
null ist DB-Ebene; blank ist Validierungsebene. choices erzeugt ein Dropdown in Formularen und im Admin.
title = models.CharField(
max_length=200,
null=True, # DB allows NULL
blank=True, # Form allows empty
default='',
choices=[('draft', 'Draft'), ('pub', 'Published')],
help_text='Article title',
verbose_name='Article Title',
)Meta-Optionen
ordering setzt die Standard-Sortierung. db_table überschreibt den automatisch generierten Tabellennamen. constraints erzwingen DB-Ebene-Regeln.
class Meta:
ordering = ['-created_at']
db_table = 'articles'
verbose_name_plural = 'Articles'
constraints = [
models.UniqueConstraint(
fields=['title', 'author'],
name='unique_title_per_author',
)
]Model-Methoden & Properties
save() überschreiben für Logik vor dem Speichern. @property ergänzt berechnete Attribute. Immer super().save() aufrufen.
class Article(models.Model):
title = models.CharField(max_length=200)
views = models.IntegerField(default=0)
def __str__(self):
return self.title
def save(self, *args, **kwargs):
self.title = self.title.strip()
super().save(*args, **kwargs)
@property
def is_popular(self):
return self.views > 1000Model-Beziehungen
ForeignKey (Many-to-One)
ForeignKey erzeugt eine Many-to-One-Beziehung. related_name ermöglicht Rückwärtsabfragen: author.books.all().
class Author(models.Model):
name = models.CharField(max_length=100)
class Book(models.Model):
author = models.ForeignKey(
Author,
on_delete=models.CASCADE,
related_name='books',
)
title = models.CharField(max_length=200)OneToOneField
OneToOneField erzeugt eine Eins-zu-eins-Verknüpfung. Zugriff über user.profile oder profile.user.
class Profile(models.Model):
user = models.OneToOneField(
User,
on_delete=models.CASCADE,
)
bio = models.TextField()ManyToManyField
ManyToManyField erzeugt automatisch eine Junction-Tabelle. Hinzufügen/Entfernen: course.students.add(student).
class Student(models.Model):
name = models.CharField(max_length=100)
class Course(models.Model):
students = models.ManyToManyField(Student, blank=True)
title = models.CharField(max_length=200)on_delete-Optionen
CASCADE löscht Kinder, wenn das Elternteil gelöscht wird. SET_NULL verlangt null=True. PROTECT wirft ProtectedError.
# CASCADE - delete related objects
author = models.ForeignKey(Author, on_delete=models.CASCADE)
# SET_NULL - set to NULL (field must be nullable)
author = models.ForeignKey(Author, on_delete=models.SET_NULL, null=True)
# PROTECT - prevent deletion
author = models.ForeignKey(Author, on_delete=models.PROTECT)
# SET_DEFAULT - set to default value
author = models.ForeignKey(Author, on_delete=models.SET_DEFAULT, default=1)Verknüpfte Objekte abfragen
Vorwärtszugriff über den Feldnamen. Rückwärtszugriff über related_name (standardmäßig modelname_set).
# Forward query
book.author.name
# Reverse query (uses related_name)
author.books.all()
author.books.filter(title__contains='Django')
# Add/remove in M2M
course.students.add(student1, student2)
course.students.remove(student1)
course.students.clear()
# Check membership
student in course.students.all()ORM QuerySet
Objekte erzeugen & speichern
create() speichert sofort. get_or_create gibt (object, created_bool) zurück — atomares Holen oder Erzeugen.
# Method 1: Create and save separately
article = Article(title='Hello', body='World')
article.save()
# Method 2: Create in one step
article = Article.objects.create(title='Hello', body='World')
# Method 3: get_or_create
obj, created = Article.objects.get_or_create(
title='Hello', defaults={'body': 'World'}
)Einzelnes Objekt abrufen
get() wirft DoesNotExist, wenn nichts gefunden, MultipleObjectsReturned bei mehreren. first() zum sicheren Holen eines Objekts verwenden.
# Get by primary key
article = Article.objects.get(pk=1)
# Get by field
article = Article.objects.get(title='Hello')
# First/last (returns None if empty)
first = Article.objects.first()
last = Article.objects.last()
# Latest/earliest by field
latest = Article.objects.latest('created_at')Filter & Exclude
filter() gibt ein QuerySet zurück (lazy). Verkettungen wenden UND-Logik an. QuerySets werden erst beim Iterieren ausgewertet.
# Filter
Article.objects.filter(title__contains='Django')
Article.objects.filter(published=True)
# Exclude
Article.objects.exclude(views__lt=100)
# Chain filters (AND)
Article.objects.filter(author=1).exclude(draft=True)Field-Lookups
Lookups nutzen die Doppel-Unterstrich-Syntax. Häufig: exact, contains, icontains, gt, gte, lt, lte, in, startswith, range.
Article.objects.filter(title__icontains='django') # case-insensitive
Article.objects.filter(views__gte=100) # >=
Article.objects.filter(views__in=[100, 200, 300]) # IN
Article.objects.filter(created_at__year=2024) # date lookup
Article.objects.filter(title__startswith='Hello') # LIKE 'Hello%'
Article.objects.filter(title__isnull=True) # IS NULLSortierung & Slicing
Slicing setzt LIMIT auf DB-Ebene. Negative Indizierung wird bei QuerySets nicht unterstützt.
# Order by
Article.objects.order_by('-created_at') # descending
Article.objects.order_by('author', '-views')
# Slice (LIMIT/OFFSET)
Article.objects.all()[:5] # first 5
Article.objects.all()[5:10] # offset 5, limit 5
Article.objects.order_by('-views')[:3] # top 3
# Distinct
Article.objects.values('author').distinct()Update & Delete
update() ist effizient für Massenänderungen. save(update_fields=[...]) vermeidet Race Conditions. delete() kaskadiert standardmäßig.
# Bulk update
Article.objects.filter(draft=True).update(draft=False)
# Single update (only save this field)
article.title = 'New Title'
article.save(update_fields=['title'])
# Delete
article.delete() # returns (count, {model: count})
Article.objects.filter(views=0).delete() # bulk deleteORM Fortgeschritten
F-Ausdrücke
F() referenziert einen DB-Spaltenwert und ermöglicht atomare Updates, ohne das Objekt nach Python zu laden.
from django.db.models import F
# Atomic increment (no race condition)
Article.objects.filter(pk=1).update(views=F('views') + 1)
# Compare two fields
Article.objects.filter(views__gt=F('min_views'))
# Arithmetic on fields
Article.objects.annotate(ratio=F('views') / F('likes'))Q-Objekte für komplexe Abfragen
Q-Objekte ermöglichen ODER (|), UND (&) und NICHT (~) Logik. Ohne Q sind mehrere filter()-Aufrufe nur UND-verknüpft.
from django.db.models import Q
# OR
Article.objects.filter(Q(title__contains='Django') | Q(title__contains='Flask'))
# AND with NOT
Article.objects.filter(Q(published=True) & ~Q(views=0))
# OR + AND
Article.objects.filter(
(Q(author=1) | Q(author=2)) & Q(published=True)
)Aggregation
aggregate() gibt ein Dict mit Summen zurück. annotate() ergänzt berechnete Werte pro Objekt.
from django.db.models import Count, Sum, Avg, Max, Min
# Single aggregate
total = Article.objects.aggregate(total=Count('id'))
avg_views = Article.objects.aggregate(Avg('views'))
# Per-group aggregate
Author.objects.annotate(
article_count=Count('article'),
total_views=Sum('article__views'),
)Annotate
annotate() ergänzt berechnete Felder pro Objekt. Auf annotierten Feldern lässt sich filter() und order_by() anwenden.
from django.db.models import Count, Avg
# Add computed field to each object
authors = Author.objects.annotate(article_count=Count('book'))
# Filter on annotated field
Author.objects.annotate(
avg_rating=Avg('book__rating')
).filter(avg_rating__gte=4.0)select_related & prefetch_related
select_related nutzt SQL JOIN (vorwärts FK). prefetch_related nutzt eine zweite Abfrage (rückwärts/M2M). Beide verhindern N+1-Queries.
# select_related (FK/OneToOne - single query with JOIN)
books = Book.objects.select_related('author').all()
# book.author.name -> no extra query
# prefetch_related (M2M/reverse - second query)
authors = Author.objects.prefetch_related('books').all()
# author.books.all() -> no extra query
# Deep prefetch
Author.objects.prefetch_related('books', 'books__reviews').all()Function-Based Views
Einfache Function-View
Eine View nimmt ein HttpRequest und gibt ein HttpResponse zurück. render() lädt ein Template und füllt es mit Kontext.
from django.shortcuts import render
from django.http import HttpResponse
def hello(request):
return HttpResponse("Hello, World!")
def home(request):
context = {'title': 'Home', 'items': [1, 2, 3]}
return render(request, 'home.html', context)HttpRequest-Objekt
request.GET/POST sind QueryDict (sicherheitshalber .get() verwenden). request.user ist der authentifizierte Nutzer oder AnonymousUser.
def my_view(request):
method = request.method # 'GET' or 'POST'
get_data = request.GET.get('q') # query param
post_data = request.POST.get('name')
path = request.path # '/articles/1/'
user = request.user # current user
files = request.FILES # uploaded files
meta = request.META.get('HTTP_HOST')HttpResponse-Typen
JsonResponse serialisiert nach JSON. redirect() nimmt einen URL-Pfad oder eine benannte URL mit Argumenten.
from django.http import HttpResponse, JsonResponse
from django.shortcuts import redirect
def json_view(request):
return JsonResponse({'status': 'ok', 'count': 42})
def redirect_view(request):
return redirect('/home/')
return redirect('article_detail', pk=1)
def csv_view(request):
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="data.csv"'
return responseView-Decoratoren
login_required leitet unauthentifizierte Nutzer zu LOGIN_URL um. require_POST/GET beschränken HTTP-Methoden.
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_POST, require_GET
@login_required
def dashboard(request):
return render(request, 'dashboard.html')
@require_POST
def submit(request):
pass # Only accepts POST
@require_GET
def search(request):
pass # Only accepts GETFile-Upload-View
request.FILES enthält hochgeladene Dateien. Bei großen Dateien .chunks() verwenden, um nicht die ganze Datei in den Speicher zu laden.
def upload_file(request):
if request.method == 'POST':
uploaded = request.FILES['file']
Document.objects.create(file=uploaded)
# Or save manually
with open(f'media/{uploaded.name}', 'wb') as f:
for chunk in uploaded.chunks():
f.write(chunk)
return redirect('success')
return render(request, 'upload.html')Class-Based Views
TemplateView
TemplateView rendert ein statisches Template. get_context_data() überschreiben, um zusätzlichen Kontext zu ergänzen.
from django.views.generic import TemplateView
class AboutView(TemplateView):
template_name = 'about.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['title'] = 'About Us'
return contextListView
ListView paginiert automatisch und stellt object_list und page_obj im Kontext bereit. get_queryset() für Filterung überschreiben.
from django.views.generic import ListView
class ArticleListView(ListView):
model = Article
template_name = 'article_list.html'
context_object_name = 'articles'
paginate_by = 10
def get_queryset(self):
return Article.objects.filter(published=True)DetailView
DetailView holt ein einzelnes Objekt über pk oder slug aus der URL. get_object() für eigenes Holen überschreiben.
from django.views.generic import DetailView
class ArticleDetailView(DetailView):
model = Article
template_name = 'article_detail.html'
context_object_name = 'article'
def get_object(self):
return Article.objects.get(
slug=self.kwargs['slug'], published=True
)CreateView & UpdateView
CreateView/UpdateView behandeln Formularanzeige, Validierung und Speichern. form_valid() überschreiben, um vor dem Speichern Logik zu ergänzen.
from django.views.generic.edit import CreateView, UpdateView
class ArticleCreateView(CreateView):
model = Article
fields = ['title', 'body', 'author']
template_name = 'article_form.html'
success_url = '/articles/'
class ArticleUpdateView(UpdateView):
model = Article
fields = ['title', 'body']
template_name = 'article_form.html'Mixins
Mixins ergänzen wiederverwendbares Verhalten zu class-based views. Django liefert LoginRequiredMixin, PermissionRequiredMixin.
from django.contrib.auth.mixins import LoginRequiredMixin
class OwnerRequiredMixin:
def get_queryset(self):
return super().get_queryset().filter(owner=self.request.user)
class ArticleListView(LoginRequiredMixin, OwnerRequiredMixin, ListView):
model = Article
paginate_by = 10URL-Routing
Grundlegende URL-Konfiguration
path() mappt ein URL-Muster auf eine View. name= ermöglicht Reverse-URL-Lookup. <int:pk> fängt einen Integer ab.
from django.urls import path
from myapp import views
urlpatterns = [
path('', views.home, name='home'),
path('about/', views.about, name='about'),
path('article/<int:pk>/', views.article_detail, name='article_detail'),
]App-URLs einbinden
include() delegiert URL-Matching an die urls.py einer App. app_name erzeugt einen Namespace für URL-Reversing.
# myproject/urls.py
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('blog/', include('blog.urls')),
path('api/', include('api.urls')),
]
# blog/urls.py
app_name = 'blog'
urlpatterns = [
path('', views.list, name='list'),
path('<int:pk>/', views.detail, name='detail'),
]Path-Konverter
Path-Konverter wandeln URL-Segmente automatisch typum. Für komplexe Regex-Muster re_path verwenden.
path('article/<int:pk>/') # integer
path('article/<slug:slug>/') # slug string
path('article/<str:title>/') # non-slash string
path('user/<uuid:user_id>/') # UUID
path('file/<path:filepath>/') # any string including /
# Regex path (re_path)
from django.urls import re_path
re_path(r'^article/(?P<year>[0-9]{4})/$', views.year_archive)Benannte URLs & reverse()
Benannte URLs erlauben das Referenzieren von Routen per Name statt hartkodierter Pfade. reverse() erzeugt URLs in Python.
# urls.py
path('article/<int:pk>/', views.detail, name='article_detail')
# In views.py
from django.urls import reverse
url = reverse('article_detail', kwargs={'pk': 42})
# Returns '/article/42/'
# In templates
<a href="{% url 'article_detail' pk=article.pk %}">Read</a>URL-Namespaces
Namespaces verhindern Namenskollisionen zwischen Apps. Der Namespace muss zur app_name der App passen.
# myproject/urls.py
path('blog/', include(('blog.urls', 'blog'), namespace='blog'))
# blog/urls.py
app_name = 'blog'
urlpatterns = [
path('<int:pk>/', views.detail, name='detail'),
]
# Usage
reverse('blog:detail', kwargs={'pk': 1})
# Template: {% url 'blog:detail' pk=1 %}Templates (DTL)
Template-Vererbung
extends erbt von einem Basis-Template. Blocks definieren überschreibbare Bereiche. Ein Template kann nur einen Elternteil erweitern.
{# base.html #}
<html>
<body>
{% block content %}{% endblock %}
{% block sidebar %}{% endblock %}
</body>
</html>
{# article.html #}
{% extends 'base.html' %}
{% block content %}
<h1>{{ article.title }}</h1>
{% endblock %}Variablen & Tags
{{ }} gibt Variablen aus. {% %} führt Tags aus. forloop.counter beginnt bei 1; forloop.counter0 bei 0.
{# Variables #}
{{ article.title }}
{{ user.get_full_name }}
{{ article.tags.0 }}
{# Tags #}
{% if article.published %}
Published
{% elif article.draft %}
Draft
{% else %}
Archived
{% endif %}
{% for item in items %}
{{ forloop.counter }}: {{ item }}
{% empty %}
No items
{% endfor %}Template-Filter
Filter verändern die Variablenausgabe über die Pipe | Syntax. Manche nehmen Argumente nach einem Doppelpunkt. Filter lassen sich verketten.
{{ name|lower }}
{{ text|truncatewords:30 }}
{{ date|date:"Y-m-d" }}
{{ value|default:"N/A" }}
{{ list|length }}
{{ text|striptags }}
{{ price|floatformat:2 }}
{{ value|add:5 }}Eingebaute Template-Tags
csrf_token ist in allen POST-Formularen nötig. include rendert ein Sub-Template. load importiert eigene Tag-Bibliotheken.
{% url 'article_detail' pk=1 %}
{% csrf_token %}
{% load static %}
{% include 'header.html' %}
{% with total=items|length %}
{{ total }}
{% endwith %}
{% now "Y-m-d" %}
{% blocktrans %}Hello{% endblocktrans %}Eigene Template-Tags
Tags liegen im Verzeichnis app/templatetags/. @register.simple_tag für Funktionen; @register.filter für Wertmodifikatoren.
# templatetags/my_tags.py
from django import template
register = template.Library()
@register.simple_tag
def multiply(a, b):
return a * b
@register.filter
def cut(value, arg):
return value.replace(arg, '')
# In template:
{% load my_tags %}
{% multiply 3 4 %}
{{ "hello world"|cut:" " }}Formulare
Ein Formular definieren
forms.Form erzeugt ein eigenständiges Formular. Jedes Feld generiert automatisch HTML-Widgets. Feldtypen liefern Validierung.
from django import forms
class ContactForm(forms.Form):
name = forms.CharField(max_length=100)
email = forms.EmailField()
message = forms.CharField(widget=forms.Textarea)
subject = forms.ChoiceField(
choices=[('general', 'General'), ('bug', 'Bug Report')],
)ModelForm
ModelForm baut automatisch ein Formular aus einem Model. fields/exclude steuern, welche Felder erscheinen. widgets passen HTML an.
class ArticleForm(forms.ModelForm):
class Meta:
model = Article
fields = ['title', 'body', 'author']
# Or: fields = '__all__'
# Or: exclude = ['created_at']
widgets = {
'body': forms.Textarea(attrs={'rows': 10}),
}
labels = {'title': 'Article Title'}Formular-Validierung
clean_<field>() validiert ein einzelnes Feld. clean() validiert das ganze Formular. Bei Fehlschlag ValidationError werfen.
class SignupForm(forms.Form):
username = forms.CharField(max_length=50)
password = forms.CharField(widget=forms.PasswordInput)
def clean_username(self):
username = self.cleaned_data['username']
if User.objects.filter(username=username).exists():
raise forms.ValidationError("Username taken.")
return username
def clean(self):
cleaned = super().clean()
# Cross-field validation
return cleanedFormular im Template rendern
as_p/as_table/as_ul rendern alle Felder automatisch. Für eigenes Layout Felder einzeln rendern. csrf_token ist für POST nötig.
<form method="post">
{% csrf_token %}
{{ form.as_p }}
{{ form.as_table }}
{{ form.as_ul }}
{# Manual rendering #}
{{ form.title.label_tag }}
{{ form.title }}
{{ form.title.errors }}
<button type="submit">Submit</button>
</form>Formular in der View verarbeiten
request.POST übergeben, um das Formular zu binden. is_valid() führt die Validierung aus. save(commit=False) gibt ein ungespeichertes Objekt zurück.
def article_create(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
article = form.save(commit=False)
article.author = request.user
article.save()
form.save_m2m()
return redirect('article_detail', pk=article.pk)
else:
form = ArticleForm()
return render(request, 'form.html', {'form': form})Formular-Widgets
widgets steuern das HTML-Rendering. attrs-Dict für CSS-Klassen, Platzhalter oder HTML5-Input-Typen übergeben.
class UploadForm(forms.Form):
title = forms.CharField(
widget=forms.TextInput(attrs={'class': 'form-control'})
)
file = forms.FileField(widget=forms.ClearableFileInput)
date = forms.DateField(widget=forms.DateInput(attrs={'type': 'date'}))
tags = forms.MultipleChoiceField(
choices=TAG_CHOICES,
widget=forms.CheckboxSelectMultiple,
)Admin-Site
Model im Admin registrieren
@admin.register ist admin.site.register vorzuziehen. Models müssen registriert sein, um in der Admin-Oberfläche zu erscheinen.
from django.contrib import admin
from .models import Article
# Simple registration
admin.site.register(Article)
# With custom ModelAdmin
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
list_display = ('title', 'author', 'published')ModelAdmin anpassen
list_display zeigt Spalten in der Listenansicht. list_filter ergänzt Seitenleisten-Filter. search_fields aktiviert ein Suchfeld.
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
list_display = ('title', 'author', 'status')
list_filter = ('status', 'author', 'created_at')
search_fields = ('title', 'body')
ordering = ('-created_at',)
list_editable = ('status',)
list_per_page = 25
date_hierarchy = 'created_at'
readonly_fields = ('views', 'created_at')Inline-Admin
Inlines bearbeiten verknüpfte Models auf derselben Seite wie das Elternteil. extra=1 zeigt standardmäßig eine leere Zeile.
class ReviewInline(admin.TabularInline):
model = Review
extra = 1
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
inlines = [ReviewInline]
# TabularInline: compact table format
# StackedInline: full form fields stackedEigene Admin-Actions
Actions erscheinen im Dropdown der Listenseite. Sie erhalten request und queryset. message_user zeigt eine Flash-Meldung.
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
actions = ['publish_selected']
@admin.action(description='Publish selected')
def publish_selected(self, request, queryset):
updated = queryset.update(published=True)
self.message_user(request, f'{updated} articles published.')Admin-Site-Konfiguration
site_header/site_title fürs Branding überschreiben. Für mehrere Admin-Sites eigene AdminSite-Instanzen anlegen.
admin.site.site_header = 'My Site Admin'
admin.site.site_title = 'Admin Portal'
admin.site.index_title = 'Dashboard'
# Custom admin site
from django.contrib.admin import AdminSite
my_site = AdminSite(name='myadmin')
my_site.register(Article, ArticleAdmin)
# urls.py
path('myadmin/', my_site.urls)Authentifizierung
Eingebautes User-Model
Djangos User-Model hat username, password (gehasht), email, first_name, last_name und Rechte-Flags.
from django.contrib.auth.models import User
user = User.objects.get(username='admin')
user.is_staff # can access admin
user.is_superuser # has all permissions
user.is_active # account enabled
user.set_password('newpass') # hash password
user.save()
user.check_password('secret') # returns True/FalseLogin & Logout
authenticate() prüft Zugangsdaten (gibt User oder None zurück). login() erzeugt die Session. logout() löscht sie.
from django.contrib.auth import authenticate, login, logout
def login_view(request):
user = authenticate(request, username='admin', password='pass')
if user is not None:
login(request, user)
return redirect('dashboard')
return render(request, 'login.html')
def logout_view(request):
logout(request)
return redirect('home')Nutzer-Registrierung
UserCreationForm behandelt username, password und Passwort-Bestätigung mit eingebauter Validierung.
from django.contrib.auth.forms import UserCreationForm
def register(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
user = form.save()
login(request, user) # auto-login after register
return redirect('home')
else:
form = UserCreationForm()
return render(request, 'register.html', {'form': form})login_required-Decorator
login_required leitet zu LOGIN_URL um (Standard /accounts/login/). Für CBVs LoginRequiredMixin verwenden.
from django.contrib.auth.decorators import login_required
@login_required
def profile(request):
return render(request, 'profile.html')
@login_required(login_url='/custom-login/')
def settings(request):
return render(request, 'settings.html')
# Class-based view mixin
from django.contrib.auth.mixins import LoginRequiredMixin
class DashboardView(LoginRequiredMixin, ListView):
login_url = '/login/'
model = ArticlePasswort-Verwaltung
update_session_auth_hash verhindert den Logout nach Passwortänderung. Passwort-Validatoren erzwingen Regeln site-weit.
from django.contrib.auth import update_session_auth_hash
# Change password
user.set_password('newpass123')
user.save()
update_session_auth_hash(request, user) # keep user logged in
# Using form
from django.contrib.auth.forms import PasswordChangeForm
form = PasswordChangeForm(user, request.POST)
if form.is_valid():
form.save()Eigenes User-Model
AbstractUser ableiten, um Felder zu ergänzen. AUTH_USER_MODEL früh setzen — spätere Änderung ist schwierig.
from django.contrib.auth.models import AbstractUser
class CustomUser(AbstractUser):
bio = models.TextField(blank=True)
avatar = models.ImageField(upload_to='avatars/', blank=True)
phone = models.CharField(max_length=20, blank=True)
# settings.py
AUTH_USER_MODEL = 'myapp.CustomUser'
# Admin
from django.contrib.auth.admin import UserAdmin
@admin.register(CustomUser)
class CustomUserAdmin(UserAdmin):
passMiddleware
Eingebaute Middleware
Reihenfolge zählt! SecurityMiddleware zuerst, dann Sessions, dann Auth. CSRF-Checks laufen vor der View-Verarbeitung.
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',
]Eigene Function-Middleware
Function-Middleware nutzt das neue Factory-Muster. get_response ruft die nächste Middleware oder View auf.
def simple_middleware(get_response):
def middleware(request):
# Code before view (request phase)
response = get_response(request)
# Code after view (response phase)
return response
return middleware
# Example: timing middleware
import time
def timing_middleware(get_response):
def middleware(request):
start = time.time()
response = get_response(request)
response['X-Duration'] = str(time.time() - start)
return response
return middlewareClass-Based-Middleware
__init__ läuft einmalig beim Start. __call__ läuft pro Anfrage. process_view kann eine Antwort zurückgeben und die View überspringen.
class MyMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
# Request phase (before view)
response = self.get_response(request)
# Response phase (after view)
return response
def process_view(self, request, view_func, args, kwargs):
return None # or HttpResponse to short-circuitMiddleware-Reihenfolge & Fluss
Anfragen durchlaufen die Middleware von oben nach unten; Antworten steigen von unten nach oben auf. Security-Middleware zuerst platzieren.
# Request phase: top to bottom
# Response phase: bottom to top
MIDDLEWARE = [
'A', # req: 1st -> resp: last
'B', # req: 2nd -> resp: 2nd
'C', # req: 3rd -> resp: 1st
]
# Request flows: A -> B -> C -> view
# Response flows: view -> C -> B -> AMiddleware-Anwendungsfälle
Middleware kann kurzschließen (früh HttpResponse zurückgeben) oder Daten an request anhängen, die Views nutzen.
# IP restriction
class IPBlockMiddleware:
BLOCKED_IPS = ['192.168.1.100']
def __call__(self, request):
if request.META['REMOTE_ADDR'] in self.BLOCKED_IPS:
return HttpResponseForbidden('Blocked')
return self.get_response(request)
# Add context to request
class UserPrefMiddleware:
def __call__(self, request):
request.is_mobile = 'Mobile' in request.META.get('HTTP_USER_AGENT', '')
return self.get_response(request)Statische & Media-Dateien
Konfiguration statischer Dateien
STATIC_URL ist das URL-Präfix. STATICFILES_DIRS sind Quellorte (Dev). STATIC_ROOT ist das Sammelziel in Produktion.
# settings.py
STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / 'static'] # dev location
STATIC_ROOT = BASE_DIR / 'staticfiles' # collectstatic output
# Project structure:
# static/
# css/style.css
# js/app.js
# img/logo.pngStatische Dateien in Entwicklung
Django liefert statische Dateien nur bei DEBUG=True selbst aus. In Produktion einen Webserver (nginx) oder WhiteNoise verwenden.
# urls.py (dev only)
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
path('admin/', admin.site.urls),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
# Only active when DEBUG=TrueStatische Dateien in Templates
{% load static %} ist nötig. {% static %} löst mit ManifestStaticFilesStorage in Produktion zum gehashten Dateinamen auf.
{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">
<img src="{% static 'img/logo.png' %}" alt="Logo">
<script src="{% static 'js/app.js' %}"></script>
{# Dynamic static path #}
{% get_static_prefix as STATIC_URL %}
<img src="{{ STATIC_URL }}img/{{ theme }}.png">Media-Dateien konfigurieren
MEDIA_ROOT ist der Dateisystempfad; MEDIA_URL das URL-Präfix. upload_to kann ein Pfad-String oder eine Callable sein.
# settings.py
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'
# urls.py (dev)
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
# Model with file upload
class Document(models.Model):
file = models.FileField(upload_to='documents/')
image = models.ImageField(upload_to='images/')
# Access
doc.file.url # '/media/documents/file.pdf'
doc.file.path # '/full/path/to/file.pdf'collectstatic-Befehl
collectstatic vor dem Deployment ausführen. WhiteNoise lässt Django statische Dateien in Produktion ohne nginx ausliefern.
# Collect all static files into STATIC_ROOT
python manage.py collectstatic
# With clearing
python manage.py collectstatic --clear
# Production with WhiteNoise
# pip install whitenoise
MIDDLEWARE = [..., 'whitenoise.middleware.WhiteNoiseMiddleware', ...]
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'Signals
Eingebaute Signals
Signals erlauben entkoppelten Apps, auf Aktionen zu reagieren. post_save feuert nach abgeschlossenem save(); pre_save davor.
from django.db.models.signals import (
post_save, pre_save, post_delete, pre_delete,
m2m_changed,
)
from django.contrib.auth.signals import (
user_logged_in, user_logged_out,
)
# Common signals:
# pre_save / post_save - before/after model save
# pre_delete / post_delete - before/after model delete
# m2m_changed - M2M relationship changes
# user_logged_in / user_logged_outSignal-Empfänger verbinden
@receiver verbindet die Funktion mit dem Signal. sender beschränkt auf ein bestimmtes Model. created ist nur bei neuen Objekten True.
from django.db.models.signals import post_save
from django.dispatch import receiver
@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
if created:
Profile.objects.create(user=instance)
@receiver(post_save, sender=User)
def save_profile(sender, instance, **kwargs):
instance.profile.save()Signals trennen
disconnect() ist nützlich in Tests oder wenn kaskadierende Aktionen verhindert werden sollen. Immer receiver und sender zusammen angeben.
from django.db.models.signals import post_save
# Disconnect
post_save.disconnect(
receiver=create_profile,
sender=User,
)
# Temporarily disconnect in tests
post_save.disconnect(handler, sender=Article)
# ... do stuff without signal ...
post_save.connect(handler, sender=Article)Eigene Signals
Signals auf Modulebene definieren. send() benachrichtigt alle Empfänger. kwargs gehen an alle verbundenen Empfänger.
from django.dispatch import Signal, receiver
# Define a custom signal
order_created = Signal()
# Send the signal
order_created.send(
sender=Order,
order=order_instance,
user=request.user,
)
# Receive
@receiver(order_created, sender=Order)
def send_notification(sender, order, user, **kwargs):
pass # Send email notificationSignal-Anwendungsfälle & Fallstricke
Signal-Handler in AppConfig.ready() importieren, damit sie beim Start verbunden werden. Langsame Operationen vermeiden — für asynchrone Arbeit Celery nutzen.
# Good: Profile auto-creation
@receiver(post_save, sender=User)
def ensure_profile(sender, instance, created, **kwargs):
if created:
Profile.objects.get_or_create(user=instance)
# Register in AppConfig.ready()
# apps.py
class MyAppConfig(AppConfig):
name = 'myapp'
def ready(self):
from . import signals # noqaCaching
Cache-Konfiguration
Redis ist für Produktion empfohlen. LocMemCache ist prozesslokal (keine gemeinsame Nutzung zwischen Workern).
# settings.py - Memcached
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.PyMemcacheCache',
'LOCATION': '127.0.0.1:11211',
}
}
# Redis
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.redis.RedisCache',
'LOCATION': 'redis://127.0.0.1:6379',
}
}
# Local memory (dev)
CACHES = {
'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'}
}Low-Level-Cache-API
cache.get() gibt None für fehlende Keys zurück. get_or_set für set-if-not-exists-Atomizität verwenden.
from django.core.cache import cache
# Set
cache.set('key', 'value', timeout=300) # 5 minutes
cache.set_many({'a': 1, 'b': 2}, timeout=60)
# Get
value = cache.get('key') # None if missing
value = cache.get('key', 'default') # with default
data = cache.get_many(['a', 'b']) # dict
# Delete
cache.delete('key')
cache.clear() # delete all
# get_or_set (atomic)
value = cache.get_or_set('key', 'value', 300)Template-Caching
{% cache %} speichert gerenderte HTML-Fragmente. Variierende Argumente (User-ID, Seite) ergänzen, um falschen gecachten Inhalt zu vermeiden.
{% load cache %}
{# Cache block for 500 seconds #}
{% cache 500 sidebar %}
<div class="sidebar">
{{ expensive_data }}
</div>
{% endcache %}
{# Cache with varying key #}
{% cache 500 user_sidebar request.user.id %}
Welcome, {{ request.user.username }}
{% endcache %}Cache pro View
cache_page cacht das gesamte HttpResponse. Der Cache-Key enthält die URL, also bekommt jede URL einen eigenen Cache-Eintrag.
from django.views.decorators.cache import cache_page
@cache_page(60 * 15)
def article_list(request):
return render(request, 'list.html', {'articles': Article.objects.all()})
# With cache key prefix
@cache_page(60 * 15, key_prefix='articles')
def article_detail(request, pk):
...
# Class-based view
from django.utils.decorators import method_decorator
class ArticleListView(ListView):
@method_decorator(cache_page(60 * 15))
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)Cache-Strategien
vary_on_headers erzeugt separate Cache-Einträge pro Header-Wert. Für APIs nach Accept-Language oder Authorization variieren.
# Per-view cache with Vary headers
from django.views.decorators.vary import vary_on_headers
@cache_page(60 * 15)
@vary_on_headers('User-Agent')
def api_data(request):
...
# Model-level caching
def get_articles():
articles = cache.get('all_articles')
if articles is None:
articles = list(Article.objects.all())
cache.set('all_articles', articles, 300)
return articlesTesten
Tests schreiben
TestCase umwickelt Tests in einer DB-Transaktion (rollback). SimpleTestCase ist für Tests ohne DB-Zugriff (schneller).
from django.test import TestCase, SimpleTestCase
from .models import Article
class ArticleModelTest(TestCase):
def setUp(self):
self.article = Article.objects.create(
title='Test', body='Content'
)
def test_str(self):
self.assertEqual(str(self.article), 'Test')
def test_field_default(self):
self.assertEqual(self.article.views, 0)
# SimpleTestCase: no DB access
class MathTest(SimpleTestCase):
def test_addition(self):
self.assertEqual(1 + 1, 2)Testen mit dem Test-Client
self.client simuliert HTTP-Anfragen ohne Server-Start. .login() authentifiziert für nachfolgende Anfragen.
class ViewTest(TestCase):
def setUp(self):
self.user = User.objects.create_user('test', '[email protected]', 'pass')
def test_login(self):
response = self.client.post('/login/', {
'username': 'test', 'password': 'pass'
})
self.assertEqual(response.status_code, 302)
def test_protected_view(self):
self.client.login(username='test', password='pass')
response = self.client.get('/dashboard/')
self.assertEqual(response.status_code, 200)Model- & QuerySet-Tests
Testdaten entstehen in setUp() und werden nach jedem Test zurückgerollt. Mit .count() und Indizierung Ergebnisse prüfen.
class ArticleQuerySetTest(TestCase):
def setUp(self):
Article.objects.create(title='A', views=100, published=True)
Article.objects.create(title='B', views=50, published=False)
def test_published_filter(self):
published = Article.objects.filter(published=True)
self.assertEqual(published.count(), 1)
def test_ordering(self):
articles = Article.objects.order_by('-views')
self.assertEqual(articles[0].title, 'A')URL- & Formular-Tests
reverse() baut URLs aus Namen. resolve() prüft, auf welche View eine URL mappt. Formulare testen, indem data=-Dict übergeben wird.
from django.urls import reverse, resolve
class URLTest(TestCase):
def test_article_list_url(self):
url = reverse('article_list')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_resolve(self):
url = reverse('article_detail', kwargs={'pk': 1})
self.assertEqual(resolve(url).func, views.article_detail)
class FormTest(TestCase):
def test_valid_form(self):
form = ArticleForm(data={'title': 'Hi', 'body': '...'})
self.assertTrue(form.is_valid())Fixtures & Test-Befehle
Fixtures laden Testdaten aus JSON-Dateien. Konkrete Tests per App-, Klassen- oder Methodenpfad ausführen.
# Create fixture
python manage.py dumpdata myapp.Article --indent=2 > fixtures/articles.json
# Use in test
class FixtureTest(TestCase):
fixtures = ['articles.json']
def test_data_loaded(self):
self.assertEqual(Article.objects.count(), 10)
# Run tests
python manage.py test
python manage.py test myapp
python manage.py test myapp.tests.ArticleModelTestDjango REST Framework
DRF installieren & einrichten
rest_framework zu INSTALLED_APPS ergänzen. Standard-Auth/Permissions im REST_FRAMEWORK-Settings-Dict konfigurieren.
pip install djangorestframework
# settings.py
INSTALLED_APPS = [..., 'rest_framework', 'rest_framework.authtoken']
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': [
'rest_framework.authentication.TokenAuthentication',
'rest_framework.authentication.SessionAuthentication',
],
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.IsAuthenticated',
],
}Serializers
ModelSerializer generiert Felder automatisch aus dem Model. source= zieht aus verknüpften Objekten. validate_<field>() ergänzt Validierung.
from rest_framework import serializers
class ArticleSerializer(serializers.ModelSerializer):
author_name = serializers.CharField(source='author.username', read_only=True)
class Meta:
model = Article
fields = ['id', 'title', 'body', 'author', 'author_name']
read_only_fields = ['id', 'author_name']
def validate_title(self, value):
if len(value) < 5:
raise serializers.ValidationError("Title too short.")
return valueViewSets
ModelViewSet liefert CRUD (list, create, retrieve, update, destroy). get_queryset() für Filterung überschreiben.
from rest_framework import viewsets, permissions
class ArticleViewSet(viewsets.ModelViewSet):
queryset = Article.objects.all()
serializer_class = ArticleSerializer
permission_classes = [permissions.IsAuthenticatedOrReadOnly]
def get_queryset(self):
qs = super().get_queryset()
author = self.request.query_params.get('author')
if author:
qs = qs.filter(author__username=author)
return qs
def perform_create(self, serializer):
serializer.save(author=self.request.user)Routers
DefaultRouter generiert URL-Muster und eine API-Root-View automatisch. basename wird für URL-Benennung genutzt, wenn das queryset dynamisch ist.
from rest_framework.routers import DefaultRouter
from .views import ArticleViewSet
router = DefaultRouter()
router.register(r'articles', ArticleViewSet, basename='article')
# router.register(r'users', UserViewSet)
# urls.py
urlpatterns = [
path('api/', include(router.urls)),
]
# Generates: /api/articles/, /api/articles/{id}/Authentifizierung
Token-Auth nutzt einen einzelnen statischen Token. JWT stellt access- und refresh-Tokens aus. SimpleJWT ist die populärste JWT-Bibliothek.
# Token Authentication
from rest_framework.authtoken.views import obtain_auth_token
urlpatterns = [
path('api/token/', obtain_auth_token),
]
# JWT Authentication (pip install djangorestframework-simplejwt)
from rest_framework_simplejwt.views import (
TokenObtainPairView, TokenRefreshView,
)
urlpatterns = [
path('api/token/', TokenObtainPairView.as_view()),
path('api/token/refresh/', TokenRefreshView.as_view()),
]Permissions
SAFE_METHODS sind GET/HEAD/OPTIONS. has_object_permission prüft Zugriff pro Objekt. get_permissions() erlaubt Regeln pro Aktion.
from rest_framework import permissions
class IsOwnerOrReadOnly(permissions.BasePermission):
def has_object_permission(self, request, view, obj):
if request.method in permissions.SAFE_METHODS:
return True # GET, HEAD, OPTIONS
return obj.author == request.user
# Built-in: IsAuthenticated, IsAdminUser,
# IsAuthenticatedOrReadOnly, AllowAny
# Per-action
class ArticleViewSet(viewsets.ModelViewSet):
permission_classes = [IsOwnerOrReadOnly]
def get_permissions(self):
if self.action == 'create':
return [permissions.IsAuthenticated()]
return super().get_permissions()Deployment & Sicherheit
Produktions-Einstellungen
SECRET_KEY niemals in die Versionskontrolle committen. Umgebungsvariablen verwenden. DEBUG=False verhindert Info-Leaks in Fehlerseiten.
# settings.py
DEBUG = False
ALLOWED_HOSTS = ['example.com', 'www.example.com']
SECRET_KEY = os.environ['SECRET_KEY']
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'mydb',
'USER': os.environ['DB_USER'],
'PASSWORD': os.environ['DB_PASS'],
'HOST': 'localhost',
'PORT': '5432',
}
}Statische Dateien in Produktion
collectstatic sammelt alle statischen Dateien nach STATIC_ROOT. WhiteNoise liefert gzippte, gehashte Dateien direkt aus Django.
# Collect static files
python manage.py collectstatic --noinput
# WhiteNoise for serving static
MIDDLEWARE = [..., 'whitenoise.middleware.WhiteNoiseMiddleware', ...]
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
# Or with nginx:
# location /static/ { alias /path/to/staticfiles/; }Sicherheits-Einstellungen
SSL_REDIRECT erzwingt HTTPS. HSTS sagt Browsern, immer HTTPS zu verwenden. X_FRAME_OPTIONS verhindert Clickjacking.
# settings.py
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_HSTS_SECONDS = 31536000
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
SECURE_CONTENT_TYPE_NOSNIFF = True
X_FRAME_OPTIONS = 'DENY'
CSRF_TRUSTED_ORIGINS = ['https://example.com']WSGI/ASGI-Deployment
Gunicorn ist synchron (traditionelles Django). Uvicorn unterstützt ASGI (async views, WebSockets). Einen Prozess-Manager verwenden.
# Gunicorn (WSGI)
# pip install gunicorn
gunicorn myproject.wsgi:application --bind 0.0.0.0:8000 --workers 3
# Uvicorn (ASGI, for async/websockets)
# pip install uvicorn
uvicorn myproject.asgi:application --host 0.0.0.0 --port 8000 --workers 4
# Supervisor config
[program:django]
command=gunicorn myproject.wsgi:application
directory=/app
autostart=true
autorestart=trueProduktions-Checkliste
check --deploy führt Djangos Deployment-Checkliste aus. Es markiert fehlende Sicherheits-Einstellungen und Probleme der Produktionsreife.
# Run security check
python manage.py check --deploy
# Key items:
# - DEBUG = False
# - ALLOWED_HOSTS set
# - SECRET_KEY from env
# - HTTPS enabled (SECURE_SSL_REDIRECT)
# - HSTS configured
# - collectstatic run
# - Database (PostgreSQL/MySQL)
# - Caching (Redis/Memcached)
# - Error monitoring (Sentry)Verwandte Django-Snippets
Copy-paste ready code for common tasks.
Model Definition
Define a Django model with field types and meta options.
ORM QuerySet
Filter, exclude, annotate and chain QuerySets.
Class-Based Views
Use generic class-based views for common CRUD flows.
URL Routing
Wire URLs to views with path converters and includes.
ModelForms
Build forms from models with validation and widgets.
Template Tags
Use built-in tags and filters in Django templates.
Admin Customization
Customize the Django admin with list_display and actions.
Authentication
Login, logout, and protect views with auth decorators.
Was this helpful?