In Django, the URL dispatcher acts as the traffic controller for web requests. When a user accesses a specific URL, the routing system determines which view function handles the request and executes the corresponding logic. This mapping is typically defined in the urls.py file located in the project directory or within specific applications.

Basic Path Configuration

Global URL configurations are managed in the project's root urls.py file. To map a URL to a view, the path() function is used within the urlpatterns list.

# myproject/urls.py
from django.contrib import admin
from django.urls import path
from core.views import dashboard_view

urlpatterns = [
    path("admin/", admin.site.urls),
    path("dashboard/", dashboard_view),
]

In this example, accessing the /dashboard/ URL triggers the dashboard_view function. The corresponding view might look like this:

# core/views.py
from django.http import HttpResponse

def dashboard_view(request):
    return HttpResponse("Welcome to the main dashboard area.")

It is important to note that Django route definitions typically end with a trailing slash. Omitting this may result in 404 errors unless the APPEND_SLASH setting is modified.

Dynamic URL Routing

Static paths are limited in functionality. To handle dynamic data, such as querying blog posts by year, URL path converters are used. These converters capture specific segments of the URL and pass them as arguments to the view.

# myproject/urls.py
from django.urls import path
from core.views import archive_view

urlpatterns = [
    path('archive/<int:yr>/<int:mo>/', archive_view)
]

Here, <int:yr> and <int:mo> capture integer values for the year and month. The view function must accept these arguments.

# core/views.py
from django.http import HttpResponse

def archive_view(request, yr, mo):
    return HttpResponse(f"Displaying archives for {yr}, month {mo}.")

If the user visits /archive/2024/05/, the view receives 2024 as yr and 5 as mo. Path converters enforce data types; passing a non-integer where an integer is expected will result in a 404 error.

Regular Expression Routing

For complex URL patterns that require specific validation rules, such as strictly matching a four-digit year, re_path is used. This function allows standard regex syntax for pattern matching.

# myproject/urls.py
from django.urls import re_path
from core.views import strict_archive_view

urlpatterns = [
    re_path(r'^archive/(?P<yr>\d{4})/$', strict_archive_view)
]

The regex pattern \d{4} ensures exactly four digits are captured. The named group (?P<yr>...) passes the value to the view. Note that arguments captured by re_path are always passed as strings, requiring manual type conversion if integers are needed in the view.

Modular Routing with Include

To maintain a clean project structure, routing can be delegated to individual applications. This involves creating a urls.py file within the app directory and including it in the main project's urls.py.

First, define routes inside the application (e.g., a 'blog' app):

# blog/urls.py
from django.urls import path
from . import handlers

urlpatterns = [
    path('read/<int:post_id>/', handlers.view_post),
    path('modify/<int:post_id>/', handlers.edit_post),
]

Then, include these routes in the project's main urls.py:

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

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

This configuration ensures that requests starting with /blog/ are forwarded to the blog application's URL configuration. For instance, /blog/read/101/ triggers the view_post handler in the blog app.