How does URL routing work?

Question

Accepted Answer

**URL routing** (the URLconf) maps incoming request URLs to the **views** that handle them. Django matches the requested URL against a list of patterns and calls the corresponding view, extracting any parameters from the URL. ## Defining URL patterns ```python # urls.py from django.urls import path from . import views urlpatterns = [ path("", views.home, name="home"), # / path("articles/", views.article_list, name="article_list"), # /articles/ path("articles//", views.article_detail, name="detail"), # /articles/5/ path("articles//", views.by_slug, name="by_slug"), # /articles/my-post/ ] ``` Each `path()` maps a URL pattern to a view function. Django tries them top-to-bottom and uses the first match. ## Capturing URL parameters ```python path("articles//", views.article_detail) # captures an integer as `pk` # the view receives the captured value as a parameter def article_detail(request, pk): # pk = 5 for /articles/5/ article = Article.objects.get(pk=pk) ``` Path converters (``, ``, ``, ``) capture and type-convert parts of the URL, passing them to the view as arguments. ## Named URLs and reverse resolution (important!) ```python path("articles//", views.article_detail, name="detail") # the `name` ``` ```python # generate URLs by NAME instead of hardcoding them — DRY and refactor-safe from django.urls import reverse url = reverse("detail", kwargs={"pk": 5}) # → "/articles/5/" redirect("detail", pk=5) # in views ``` ```html Read more ``` **Named URLs** are crucial: by referring to URLs by their `name` (via `{% url %}` in templates and `reverse()` in code) instead of hardcoding paths, you can change the URL structure in one place without breaking every link — a DRY, refactor-safe practice. ## Including app URLs (modular routing) ```python # project urls.py — delegate to each app's URLconf from django.urls import include, path urlpatterns = [ path("blog/", include("blog.urls")), # /blog/... handled by the blog app path("shop/", include("shop.urls")), path("admin/", admin.site.urls), ] ``` `include()` delegates a URL prefix to an app's own `urls.py`, keeping routing modular and each app self-contained. ## Why it matters URL routing is fundamental to every Django application — it defines your site's URL structure and is how requests reach the right view. Understanding it is essential everyday knowledge: knowing how to define URL patterns, capture and type-convert parameters from URLs (path converters like ``), and organize routing modularly with `include()` (delegating to per-app URLconfs) is necessary for building any multi-page app or API. Critically important is the **named-URL / reverse-resolution** practice — referring to URLs by their `name` via `{% url %}` and `reverse()` rather than hardcoding paths — which embodies Django's DRY philosophy and is a major maintainability win: it lets you restructure URLs in one place without hunting down and updating every hardcoded link across templates and code. This is a best practice that distinguishes well-built Django projects from fragile ones. URL routing connects the entry point (URLs) to the logic (views), completing the request-handling picture alongside models and templates, making it core, must-know material for organizing and maintaining any Django application.