Zum Inhalt springen
Backend

Django - Schnelle Webanwendungsentwicklung mit Python

Veröffentlicht am:
·4 Min. Lesezeit·Autor: MDS Software Solutions Group
pythondjangobackendorm

Django Schnelle Webanwendungsentwicklung

backend

Django - Schnelle Webanwendungsentwicklung mit Python

Django ist eines der beliebtesten Web-Frameworks der Welt, geschrieben in Python und konzipiert für die schnelle, pragmatische Anwendungsentwicklung. Seit seiner Entstehung im Jahr 2005 betreibt Django Tausende von Websites - von kleinen Startups bis hin zu Technologieriesen wie Instagram, Pinterest, Mozilla und Disqus. In diesem Artikel werden wir die wichtigsten Funktionen von Django ausführlich untersuchen, praktische Codebeispiele zeigen und erklären, warum dieses Framework eine hervorragende Wahl für moderne Backend-Projekte ist.

Was ist Django und die "Batteries Included"-Philosophie#

Django hebt sich von anderen Frameworks durch seine "Batteries Included"-Philosophie ab. Das bedeutet, dass das Framework einen vollständigen Satz an Werkzeugen mitbringt, die zum Erstellen einer Webanwendung benötigt werden - vom ORM-System über das Admin-Panel bis hin zu Authentifizierungsmechanismen und Formularverarbeitung. Sie müssen nicht nach externen Bibliotheken für grundlegende Aufgaben suchen.

Die wichtigsten Designprinzipien von Django sind:

  • DRY (Don't Repeat Yourself) - Vermeidung von Code- und Logikduplizierung
  • Schnelle Entwicklung - das Framework wurde entwickelt, um Sie so schnell wie möglich vom Konzept zur fertigen Anwendung zu bringen
  • Sicherheit - eingebauter Schutz gegen CSRF, XSS, SQL Injection und Clickjacking
  • Skalierbarkeit - Architektur, die Millionen von Benutzern bedienen kann

Der Einstieg in Django ist unkompliziert:

# Virtuelle Umgebung erstellen
python -m venv venv
source venv/bin/activate  # Linux/Mac
# venv\Scripts\activate   # Windows

# Django installieren
pip install django

# Neues Projekt erstellen
django-admin startproject myproject
cd myproject

# Anwendung erstellen
python manage.py startapp blog

# Entwicklungsserver starten
python manage.py runserver

Django ORM und Modelle#

Eine der größten Stärken von Django ist sein Object-Relational Mapping (ORM) - ein System, das Ihnen ermöglicht, mit Datenbanken über Python-Code statt rohen SQL-Abfragen zu interagieren. Das Django ORM unterstützt PostgreSQL, MySQL, SQLite, Oracle und viele weitere Datenbanken.

# blog/models.py
from django.db import models
from django.contrib.auth.models import User
from django.utils.text import slugify


class Category(models.Model):
    name = models.CharField(max_length=100, unique=True)
    slug = models.SlugField(max_length=100, unique=True)
    description = models.TextField(blank=True)

    class Meta:
        verbose_name_plural = "categories"
        ordering = ["name"]

    def __str__(self):
        return self.name

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)


class Post(models.Model):
    class Status(models.TextChoices):
        DRAFT = "draft", "Entwurf"
        PUBLISHED = "published", "Veröffentlicht"
        ARCHIVED = "archived", "Archiviert"

    title = models.CharField(max_length=200)
    slug = models.SlugField(max_length=200, unique_for_date="publish_date")
    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name="posts")
    category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True)
    body = models.TextField()
    publish_date = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)
    status = models.CharField(
        max_length=10, choices=Status.choices, default=Status.DRAFT
    )
    tags = models.ManyToManyField("Tag", blank=True)

    class Meta:
        ordering = ["-publish_date"]
        indexes = [
            models.Index(fields=["-publish_date"]),
            models.Index(fields=["slug"]),
        ]

    def __str__(self):
        return self.title


class Tag(models.Model):
    name = models.CharField(max_length=50, unique=True)
    slug = models.SlugField(max_length=50, unique=True)

    def __str__(self):
        return self.name

Die Arbeit mit dem ORM ist intuitiv und effizient:

# Datensätze erstellen
category = Category.objects.create(name="Python", slug="python")
post = Post.objects.create(
    title="Mein erster Beitrag",
    author=user,
    category=category,
    body="Artikelinhalt...",
    status=Post.Status.PUBLISHED,
)

# Gefilterte Abfragen
published_posts = Post.objects.filter(status=Post.Status.PUBLISHED)
python_posts = Post.objects.filter(category__name="Python")
recent_posts = Post.objects.filter(
    publish_date__year=2025
).select_related("author", "category")

# Aggregationen
from django.db.models import Count, Avg
stats = Post.objects.aggregate(
    total=Count("id"),
    avg_length=Avg(models.functions.Length("body")),
)

# Annotationen
categories_with_count = Category.objects.annotate(
    post_count=Count("post")
).order_by("-post_count")

Django REST Framework für APIs#

Django REST Framework (DRF) ist eine leistungsstarke Bibliothek, die Django um die Fähigkeit zum Erstellen von REST-APIs erweitert. Sie bietet Serialisierung, API-Views, Authentifizierung, Paginierung und vieles mehr.

pip install djangorestframework

# blog/serializers.py
from rest_framework import serializers
from .models import Post, Category, Tag


class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
        fields = ["id", "name", "slug"]


class CategorySerializer(serializers.ModelSerializer):
    post_count = serializers.IntegerField(read_only=True)

    class Meta:
        model = Category
        fields = ["id", "name", "slug", "description", "post_count"]


class PostListSerializer(serializers.ModelSerializer):
    author = serializers.StringRelatedField()
    category = CategorySerializer(read_only=True)

    class Meta:
        model = Post
        fields = [
            "id", "title", "slug", "author", "category",
            "publish_date", "status",
        ]


class PostDetailSerializer(serializers.ModelSerializer):
    author = serializers.StringRelatedField()
    category = CategorySerializer(read_only=True)
    tags = TagSerializer(many=True, read_only=True)

    class Meta:
        model = Post
        fields = [
            "id", "title", "slug", "author", "category",
            "body", "publish_date", "updated", "status", "tags",
        ]


# blog/views_api.py
from rest_framework import viewsets, permissions, filters
from rest_framework.decorators import action
from rest_framework.response import Response
from django_filters.rest_framework import DjangoFilterBackend
from django.db.models import Count


class PostViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.select_related("author", "category").prefetch_related("tags")
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_fields = ["status", "category__slug"]
    search_fields = ["title", "body"]
    ordering_fields = ["publish_date", "title"]

    def get_serializer_class(self):
        if self.action == "list":
            return PostListSerializer
        return PostDetailSerializer

    def perform_create(self, serializer):
        serializer.save(author=self.request.user)

    @action(detail=False, methods=["get"])
    def popular(self, request):
        popular_posts = self.get_queryset().annotate(
            tag_count=Count("tags")
        ).order_by("-tag_count")[:10]
        serializer = PostListSerializer(popular_posts, many=True)
        return Response(serializer.data)


# blog/urls.py
from rest_framework.routers import DefaultRouter

router = DefaultRouter()
router.register(r"posts", PostViewSet)

urlpatterns = router.urls

Admin-Panel - Automatisches CRUD#

Eines der markantesten Merkmale von Django ist das automatische Admin-Panel. Mit nur wenigen Zeilen Code erhalten Sie eine vollständige Oberfläche zur Verwaltung Ihrer Daten.

# blog/admin.py
from django.contrib import admin
from .models import Post, Category, Tag


@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ["name", "slug", "post_count"]
    prepopulated_fields = {"slug": ("name",)}
    search_fields = ["name"]

    def post_count(self, obj):
        return obj.post_set.count()
    post_count.short_description = "Anzahl der Beiträge"


@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ["title", "author", "category", "status", "publish_date"]
    list_filter = ["status", "category", "publish_date"]
    search_fields = ["title", "body"]
    prepopulated_fields = {"slug": ("title",)}
    raw_id_fields = ["author"]
    date_hierarchy = "publish_date"
    ordering = ["-publish_date"]
    list_editable = ["status"]
    list_per_page = 25

    fieldsets = (
        (None, {
            "fields": ("title", "slug", "author", "category")
        }),
        ("Inhalt", {
            "fields": ("body", "tags"),
        }),
        ("Veröffentlichung", {
            "fields": ("status",),
            "classes": ("collapse",),
        }),
    )


@admin.register(Tag)
class TagAdmin(admin.ModelAdmin):
    list_display = ["name", "slug"]
    prepopulated_fields = {"slug": ("name",)}

Das Admin-Panel ist nach dem Ausführen der Migrationen und dem Erstellen eines Superusers einsatzbereit:

python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser

URL-Routing und Views#

Django bietet ein flexibles URL-Routing-System basierend auf Mustern. Es unterstützt sowohl funktionsbasierte als auch klassenbasierte Views.

# myproject/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/", include("blog.urls")),
    path("", include("blog.web_urls")),
]


# blog/web_urls.py
from django.urls import path
from . import views

app_name = "blog"

urlpatterns = [
    path("", views.PostListView.as_view(), name="post_list"),
    path("category/<slug:slug>/", views.CategoryPostListView.as_view(), name="category"),
    path("<int:year>/<slug:slug>/", views.PostDetailView.as_view(), name="post_detail"),
    path("search/", views.SearchView.as_view(), name="search"),
]


# blog/views.py
from django.views.generic import ListView, DetailView
from django.db.models import Q
from .models import Post, Category


class PostListView(ListView):
    model = Post
    template_name = "blog/post_list.html"
    context_object_name = "posts"
    paginate_by = 10

    def get_queryset(self):
        return Post.objects.filter(
            status=Post.Status.PUBLISHED
        ).select_related("author", "category")


class CategoryPostListView(ListView):
    template_name = "blog/post_list.html"
    context_object_name = "posts"
    paginate_by = 10

    def get_queryset(self):
        self.category = Category.objects.get(slug=self.kwargs["slug"])
        return Post.objects.filter(
            category=self.category,
            status=Post.Status.PUBLISHED,
        )

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["category"] = self.category
        return context


class PostDetailView(DetailView):
    model = Post
    template_name = "blog/post_detail.html"
    context_object_name = "post"

    def get_queryset(self):
        return Post.objects.filter(
            status=Post.Status.PUBLISHED,
            publish_date__year=self.kwargs["year"],
        )


class SearchView(ListView):
    template_name = "blog/search_results.html"
    context_object_name = "results"
    paginate_by = 10

    def get_queryset(self):
        query = self.request.GET.get("q", "")
        if query:
            return Post.objects.filter(
                Q(title__icontains=query) | Q(body__icontains=query),
                status=Post.Status.PUBLISHED,
            )
        return Post.objects.none()

Templates und Formulare#

Das Template-System von Django ist leistungsstark und sicher - es escaped automatisch HTML und verhindert so XSS-Angriffe.

<!-- templates/blog/base.html -->
<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}Blog{% endblock %}</title>
</head>
<body>
    <nav>
        <a href="{% url 'blog:post_list' %}">Startseite</a>
        {% for category in categories %}
            <a href="{% url 'blog:category' category.slug %}">
                {{ category.name }}
            </a>
        {% endfor %}
    </nav>

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

<!-- templates/blog/post_detail.html -->
{% extends "blog/base.html" %}

{% block title %}{{ post.title }}{% endblock %}

{% block content %}
<article>
    <h1>{{ post.title }}</h1>
    <p>Autor: {{ post.author }} | {{ post.publish_date|date:"d.m.Y" }}</p>
    <div>{{ post.body|linebreaks }}</div>

    <div>
        {% for tag in post.tags.all %}
            <span class="tag">{{ tag.name }}</span>
        {% endfor %}
    </div>
</article>

{% if post.category %}
<h3>Weitere Beiträge in {{ post.category.name }}:</h3>
{% for related in related_posts %}
    <a href="{% url 'blog:post_detail' related.publish_date.year related.slug %}">
        {{ related.title }}
    </a>
{% endfor %}
{% endif %}
{% endblock %}

Django-Formulare validieren Daten automatisch und generieren HTML-Felder:

# blog/forms.py
from django import forms
from .models import Post


class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ["title", "category", "body", "tags", "status"]
        widgets = {
            "title": forms.TextInput(attrs={"class": "form-control"}),
            "body": forms.Textarea(attrs={"class": "form-control", "rows": 10}),
            "category": forms.Select(attrs={"class": "form-select"}),
        }

    def clean_title(self):
        title = self.cleaned_data["title"]
        if len(title) < 5:
            raise forms.ValidationError(
                "Der Titel muss mindestens 5 Zeichen lang sein."
            )
        return title


class ContactForm(forms.Form):
    name = forms.CharField(max_length=100, label="Vollständiger Name")
    email = forms.EmailField(label="E-Mail-Adresse")
    subject = forms.CharField(max_length=200, label="Betreff")
    message = forms.CharField(widget=forms.Textarea, label="Nachricht")

    def send_email(self):
        from django.core.mail import send_mail
        send_mail(
            subject=self.cleaned_data["subject"],
            message=self.cleaned_data["message"],
            from_email=self.cleaned_data["email"],
            recipient_list=["kontakt@example.com"],
        )

Authentifizierung und Berechtigungen#

Django verfügt über ein umfassendes Authentifizierungs- und Autorisierungssystem, das leicht an die Projektanforderungen angepasst werden kann.

# accounts/models.py
from django.contrib.auth.models import AbstractUser
from django.db import models


class CustomUser(AbstractUser):
    bio = models.TextField(blank=True)
    avatar = models.ImageField(upload_to="avatars/", blank=True)
    website = models.URLField(blank=True)

    def __str__(self):
        return self.username


# accounts/views.py
from django.contrib.auth.mixins import LoginRequiredMixin, PermissionRequiredMixin
from django.views.generic import CreateView


class CreatePostView(LoginRequiredMixin, CreateView):
    model = Post
    form_class = PostForm
    template_name = "blog/post_form.html"
    login_url = "/accounts/login/"

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


class AdminPostView(PermissionRequiredMixin, ListView):
    model = Post
    permission_required = "blog.change_post"
    template_name = "blog/admin_posts.html"


# DRF - JWT-Token-Authentifizierung
# pip install djangorestframework-simplejwt

# settings.py
REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": [
        "rest_framework_simplejwt.authentication.JWTAuthentication",
    ],
    "DEFAULT_PERMISSION_CLASSES": [
        "rest_framework.permissions.IsAuthenticatedOrReadOnly",
    ],
    "DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.PageNumberPagination",
    "PAGE_SIZE": 20,
}

Middleware und Signals#

Middleware ermöglicht die Verarbeitung von Anfragen und Antworten auf globaler Ebene, während Signals die Ausführung von Code als Reaktion auf Ereignisse in der Anwendung ermöglichen.

# blog/middleware.py
import time
import logging

logger = logging.getLogger(__name__)


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

    def __call__(self, request):
        start_time = time.time()
        response = self.get_response(request)
        duration = time.time() - start_time

        logger.info(
            f"{request.method} {request.path} - {response.status_code} "
            f"({duration:.3f}s)"
        )

        response["X-Request-Duration"] = f"{duration:.3f}s"
        return response


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

    def __call__(self, request):
        response = self.get_response(request)
        response["X-Content-Type-Options"] = "nosniff"
        response["X-Frame-Options"] = "DENY"
        response["Referrer-Policy"] = "strict-origin-when-cross-origin"
        return response


# blog/signals.py
from django.db.models.signals import post_save, pre_delete
from django.dispatch import receiver
from django.core.cache import cache
from .models import Post


@receiver(post_save, sender=Post)
def invalidate_post_cache(sender, instance, **kwargs):
    cache.delete(f"post_{instance.slug}")
    cache.delete("post_list")
    if instance.status == Post.Status.PUBLISHED:
        logger.info(f"Beitrag veröffentlicht: {instance.title}")


@receiver(pre_delete, sender=Post)
def cleanup_on_delete(sender, instance, **kwargs):
    cache.delete(f"post_{instance.slug}")
    logger.info(f"Beitrag gelöscht: {instance.title}")


# blog/apps.py
from django.apps import AppConfig


class BlogConfig(AppConfig):
    default_auto_field = "django.db.models.BigAutoField"
    name = "blog"

    def ready(self):
        import blog.signals  # noqa: F401

Django Channels - Echtzeit-WebSockets#

Django Channels erweitert Django um die Unterstützung asynchroner Protokolle, einschließlich WebSockets. Es ist ideal für Chat-Anwendungen, Live-Benachrichtigungen und Echtzeit-Updates.

pip install channels channels-redis

# settings.py
INSTALLED_APPS = [
    "daphne",
    "channels",
    # ... andere Apps
]

ASGI_APPLICATION = "myproject.asgi.application"

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


# chat/consumers.py
import json
from channels.generic.websocket import AsyncWebsocketConsumer


class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.room_name = self.scope["url_route"]["kwargs"]["room_name"]
        self.room_group_name = f"chat_{self.room_name}"

        await self.channel_layer.group_add(
            self.room_group_name, self.channel_name
        )
        await self.accept()

    async def disconnect(self, close_code):
        await self.channel_layer.group_discard(
            self.room_group_name, self.channel_name
        )

    async def receive(self, text_data):
        data = json.loads(text_data)
        message = data["message"]
        username = self.scope["user"].username

        await self.channel_layer.group_send(
            self.room_group_name,
            {
                "type": "chat_message",
                "message": message,
                "username": username,
            },
        )

    async def chat_message(self, event):
        await self.send(text_data=json.dumps({
            "message": event["message"],
            "username": event["username"],
        }))


# chat/routing.py
from django.urls import re_path
from . import consumers

websocket_urlpatterns = [
    re_path(r"ws/chat/(?P<room_name>\w+)/$", consumers.ChatConsumer.as_asgi()),
]

Celery für asynchrone Aufgaben#

Celery ist eine verteilte Aufgabenwarteschlange für die Verarbeitung asynchroner Operationen und Planung. In Kombination mit Django ermöglicht es die Ausführung zeitaufwändiger Operationen im Hintergrund.

pip install celery redis

# myproject/celery.py
import os
from celery import Celery

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

app = Celery("myproject")
app.config_from_object("django.conf:settings", namespace="CELERY")
app.autodiscover_tasks()


# settings.py
CELERY_BROKER_URL = "redis://localhost:6379/0"
CELERY_RESULT_BACKEND = "redis://localhost:6379/0"
CELERY_ACCEPT_CONTENT = ["json"]
CELERY_TASK_SERIALIZER = "json"
CELERY_RESULT_SERIALIZER = "json"
CELERY_TIMEZONE = "Europe/Berlin"


# blog/tasks.py
from celery import shared_task
from django.core.mail import send_mass_mail
from django.template.loader import render_to_string


@shared_task(bind=True, max_retries=3)
def send_newsletter(self, post_id):
    try:
        from .models import Post
        from django.contrib.auth.models import User

        post = Post.objects.get(id=post_id)
        subscribers = User.objects.filter(
            profile__newsletter=True
        ).values_list("email", flat=True)

        messages = []
        for email in subscribers:
            subject = f"Neuer Beitrag: {post.title}"
            body = render_to_string("blog/email/newsletter.txt", {"post": post})
            messages.append((subject, body, "noreply@example.com", [email]))

        send_mass_mail(messages, fail_silently=False)
    except Exception as exc:
        self.retry(exc=exc, countdown=60 * (self.request.retries + 1))


@shared_task
def generate_sitemap():
    from .models import Post
    posts = Post.objects.filter(status=Post.Status.PUBLISHED)
    # Sitemap-Generierungslogik
    return f"Sitemap mit {posts.count()} Beiträgen generiert"

Testen mit pytest-django#

Django integriert sich hervorragend mit pytest durch die Bibliothek pytest-django, die Fixtures, einen Test-Client und Werkzeuge zum Testen von Datenbanken bietet.

pip install pytest pytest-django factory-boy

# conftest.py
import pytest
from django.contrib.auth.models import User


@pytest.fixture
def user(db):
    return User.objects.create_user(
        username="testuser",
        email="test@example.com",
        password="testpass123",
    )


@pytest.fixture
def api_client():
    from rest_framework.test import APIClient
    return APIClient()


@pytest.fixture
def authenticated_client(api_client, user):
    api_client.force_authenticate(user=user)
    return api_client


# blog/tests/factories.py
import factory
from blog.models import Post, Category, Tag


class CategoryFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = Category

    name = factory.Sequence(lambda n: f"Kategorie {n}")
    slug = factory.LazyAttribute(lambda o: o.name.lower().replace(" ", "-"))


class PostFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = Post

    title = factory.Faker("sentence", nb_words=5)
    slug = factory.LazyAttribute(lambda o: o.title.lower().replace(" ", "-")[:200])
    author = factory.SubFactory("conftest.UserFactory")
    category = factory.SubFactory(CategoryFactory)
    body = factory.Faker("paragraphs", nb=3)
    status = Post.Status.PUBLISHED


# blog/tests/test_api.py
import pytest
from django.urls import reverse
from .factories import PostFactory, CategoryFactory


@pytest.mark.django_db
class TestPostAPI:
    def test_list_published_posts(self, api_client):
        PostFactory.create_batch(5, status="published")
        PostFactory.create_batch(3, status="draft")

        response = api_client.get(reverse("post-list"))
        assert response.status_code == 200
        assert len(response.data["results"]) == 5

    def test_create_post_authenticated(self, authenticated_client):
        category = CategoryFactory()
        data = {
            "title": "Ein neuer Testbeitrag",
            "body": "Inhalt des Testbeitrags",
            "category": category.id,
            "status": "draft",
        }
        response = authenticated_client.post(reverse("post-list"), data)
        assert response.status_code == 201
        assert response.data["title"] == "Ein neuer Testbeitrag"

    def test_create_post_unauthenticated(self, api_client):
        response = api_client.post(reverse("post-list"), {"title": "Test"})
        assert response.status_code == 403

    def test_search_posts(self, api_client):
        PostFactory(title="Python Django Tutorial", status="published")
        PostFactory(title="JavaScript React Guide", status="published")

        response = api_client.get(reverse("post-list"), {"search": "Python"})
        assert response.status_code == 200
        assert len(response.data["results"]) == 1

Leistungsoptimierung#

Django bietet zahlreiche Werkzeuge zur Optimierung der Anwendungsleistung. Die wichtigsten Techniken umfassen Caching und Datenbankabfrage-Optimierung.

Caching#

# settings.py
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "db": "1",
        },
    }
}

# blog/views.py
from django.views.decorators.cache import cache_page
from django.utils.decorators import method_decorator


@method_decorator(cache_page(60 * 15), name="dispatch")  # 15 Minuten Cache
class PostListView(ListView):
    model = Post
    paginate_by = 10

    def get_queryset(self):
        return Post.objects.filter(
            status=Post.Status.PUBLISHED
        ).select_related("author", "category").prefetch_related("tags")


# Template-Fragment-Caching
# {% load cache %}
# {% cache 300 post_sidebar %}
#   ... aufwändige Operation ...
# {% endcache %}


# Caching auf Abfrageebene
from django.core.cache import cache

def get_popular_posts():
    cache_key = "popular_posts"
    posts = cache.get(cache_key)
    if posts is None:
        posts = list(
            Post.objects.filter(status=Post.Status.PUBLISHED)
            .annotate(comment_count=Count("comments"))
            .order_by("-comment_count")[:10]
        )
        cache.set(cache_key, posts, timeout=60 * 30)
    return posts

Datenbankoptimierung#

# Vermeidung des N+1-Problems mit select_related und prefetch_related
posts = Post.objects.select_related(
    "author", "category"
).prefetch_related(
    "tags", "comments"
).filter(status="published")

# Nur benötigte Felder abrufen
titles = Post.objects.values_list("title", "slug", named=True)

# Massenoperationen
Post.objects.filter(status="draft", publish_date__lt=threshold).update(
    status="archived"
)

# Datenbankindizes in Modellen
class Post(models.Model):
    # ...
    class Meta:
        indexes = [
            models.Index(fields=["-publish_date"]),
            models.Index(fields=["status", "publish_date"]),
            models.Index(fields=["slug"]),
        ]

Django vs Flask - Vergleich#

| Merkmal | Django | Flask | |---------|--------|-------| | Philosophie | Batteries Included | Mikroframework | | ORM | Eingebaut | Keines (SQLAlchemy optional) | | Admin-Panel | Eingebaut | Keines (Flask-Admin optional) | | Formulare | Eingebaut | WTForms optional | | Authentifizierung | Eingebaut | Flask-Login optional | | Projektgröße | Groß und mittel | Klein und mittel | | Lernkurve | Mittel | Niedrig | | Flexibilität | Konvention über Konfiguration | Volle Flexibilität | | REST API | DRF (umfassend) | Flask-RESTful | | Async | Django Channels | Quart / Flask-SocketIO |

Wann sollte man Django wählen?

  • Aufbau großer, komplexer Anwendungen mit vielen Funktionen
  • Bedarf an einem sofort einsatzbereiten Admin-Panel
  • Projekte, die schnelles Prototyping erfordern
  • Anwendungen mit komplexen Datenmodellen

Wann sollte man Flask wählen?

  • Einfache APIs und Microservices
  • Projekte, die volle Kontrolle über die Architektur erfordern
  • Leichtgewichtige Anwendungen mit minimalen Abhängigkeiten

Fazit#

Django ist ein ausgereiftes, vielseitiges Framework, das die Entwicklung von Webanwendungen in Python erheblich beschleunigt. Dank seiner "Batteries Included"-Philosophie, dem leistungsstarken ORM, dem automatischen Admin-Panel und einem reichhaltigen Ökosystem an Bibliotheken wie DRF, Celery und Channels ist Django eine hervorragende Wahl für Projekte jeder Größenordnung.

Die wichtigsten Vorteile von Django sind Sicherheit, Leistung, ausgezeichnete Dokumentation und eine riesige Community. Das Framework zeichnet sich besonders beim Erstellen von Anwendungen mit komplexen Datenmodellen, REST-APIs und Content-Management-Systemen aus.

Benötigen Sie eine professionelle Webanwendung mit Django? Bei MDS Software Solutions Group sind wir auf die Entwicklung leistungsstarker, skalierbarer Backend-Lösungen mit Django, Django REST Framework und modernen Technologie-Stacks spezialisiert. Vom Architekturdesign über die API-Implementierung bis hin zum Produktions-Deployment - unser Team erfahrener Entwickler hilft Ihnen, jedes Projekt zum Leben zu erwecken. Kontaktieren Sie uns, um Ihre Anforderungen zu besprechen und ein kostenloses Angebot zu erhalten!

Autor
MDS Software Solutions Group

Team von Programmierexperten, die sich auf moderne Webtechnologien spezialisiert haben.

← Zurück zum Wissen
Django - Schnelle Webanwendungsentwicklung mit Python | MDS Software Solutions Group | MDS Software Solutions Group