Skip to main content

Overview

Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. It follows a "batteries-included" philosophy, providing almost everything you need to build a robust web application out of the box.

Why Django?​

Building web applications often involves repetitive tasks: handling database schemas, authenticating users, managing content, and processing forms. Django exists to take care of these "plumbing" tasks so you can focus on writing your app without reinventing the wheel. It prioritizes security, scalability, and maintainability, making it suitable for both small projects and massive, high-traffic sites.

Core Concepts​

  • Models (ORM): Define your data structure using Python classes. Django's Object-Relational Mapper handles the database schema and provides a rich API for querying data.
  • Views: The logic of your application. A view is a Python function or class that receives a web request and returns a web response (like HTML, JSON, or a redirect).
  • Templates: A powerful engine that separates the design (HTML) from the logic (Python). It allows you to generate dynamic content using a simple, designer-friendly syntax.
  • URL Routing: A clean, elegant way to map URL patterns to your views using regular expressions or simple path strings.
  • Admin Interface: One of Django's most popular features. It automatically generates a professional, production-ready administrative interface for managing your site's content based on your models.

How it Works​

Django follows a "Model-Template-View" (MTV) architectural pattern, which is a slight variation of the traditional MVC.

  1. Request: A user requests a URL in their browser.
  2. URL Dispatcher: Django looks at the URL and finds the matching pattern in your urls.py.
  3. View: The dispatcher calls the associated view function or class.
  4. Model: The view interacts with the database through the ORM to fetch or save data.
  5. Template: The view passes the data to a template.
  6. Response: The template renders the final HTML (or other format) and the view returns it as an HttpResponse to the user.

Use Cases​

1. Defining a Data Model​

Create a database table by defining a class in models.py.

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    pub_date = models.DateTimeField("date published")
    content = models.TextField()

    def __str__(self):
        return self.title

2. Creating a View​

Handle a request and return a response in views.py.

from django.http import HttpResponse
from .models import Article

def index(request):
    latest_articles = Article.objects.order_by("-pub_date")[:5]
    output = ", ".join([a.title for a in latest_articles])
    return HttpResponse(output)

3. Mapping a URL​

Connect your view to a URL in urls.py.

from django.urls import path
from . import views

urlpatterns = [
    path("articles/", views.index, name="index"),
]

4. Using the Admin​

Register your model to manage it via the automatic UI.

from django.contrib import admin
from .models import Article

admin.site.register(Article)

When to Use Django​

  • Use it when you need to build a complex, data-driven web application quickly.
  • Use it when security is a top priority (Django has built-in protection against SQL injection, XSS, CSRF, and clickjacking).
  • Use it when you want a framework that "just works" with a large ecosystem of third-party packages.
  • Don't use it when you are building a very simple microservice that only needs a few lines of code; a micro-framework like Flask or FastAPI might be lighter.
  • Don't use it when you need absolute control over every low-level detail of the HTTP stack, as Django's abstractions can sometimes feel restrictive for highly non-standard requirements.

Stack Compatibility​

  • Databases: Officially supports PostgreSQL, MariaDB, MySQL, Oracle, and SQLite.
  • Servers: Works with any WSGI-compliant server (like Gunicorn or uWSGI) and ASGI-compliant servers (like Daphne or Uvicorn) for async support.
  • Python: Requires Python 3.12 or later.
  • Frontend: Agnostic. Works well with traditional server-side templates, or as a backend API for React, Vue, or Angular.

Getting Started Pointers​

Limitations & Assumptions​

  • Monolithic by default: While you can build microservices, Django is designed as a full-stack framework.
  • Opinionated: Django has a "Django way" of doing things. Deviating from its patterns can lead to friction.
  • Synchronous Roots: While Django has added significant async support, many parts of the ecosystem (especially some database drivers and middleware) are still primarily synchronous.

FAQ​

  • Is Django only for big projects? No, it's great for small projects too because it handles so much boilerplate for you.
  • Does Django support NoSQL? Not officially. Django's ORM is built for relational databases. There are third-party projects for NoSQL support, but they may not support all Django features.
  • Can I use Django for APIs? Yes! While Django has built-in support for returning JSON, the Django REST Framework (DRF) is the industry standard for building robust APIs with Django.
  • Is Django fast? Yes. While Python is slower than some languages, Django's performance is more than sufficient for the vast majority of web applications. Bottlenecks are usually in the database or network, not the framework itself.