URL Routing in Django

What is URL routing in Django?

URL routing in Django is the process of directing incoming HTTP requests to the appropriate view based on the URL pattern defined in the `urls.py` file. It uses functions like path() and re_path() to match URL patterns with corresponding views. Django evaluates each pattern in order and calls the view associated with the first matching pattern to generate a response.

Different Ways to Handle URLs in Django

• Using include():

In Django, include() is used to link an app's `urls.py` file to the main project `urls.py`. It helps organize URLs by keeping each app's routes separate and modular. This makes the project easier to manage, especially with multiple apps.

• Using Named URLs:

Named URLs in Django allow you to give a URL pattern a unique name for easy reference. You can use these names in templates and views instead of hardcoding the actual URL paths.

• Using Namespace URLs:

A namespace in Django URL routing gives a unique name to an app's URL patterns, helping to avoid conflicts and making it easier to reference URLs clearly across different apps in the project.

Project-Level URL Routing in Django

In Django, project URL routing is the system that directs web requests to the right view functions. It is defined in the main urls.py file located in the project root directory, typically alongside settings.py. This file usually includes the following:

Admin route: for accessing the Django admin panel.

App routes: using include(), it links to each app's own urls.py for better modularity.

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

urlpatterns = [
    path('admin/', admin.site.urls),

    # Includes blog app's URLs
    path('blog/', include('blog.urls')),

    # Includes core app's URLs present inside apps/core
    path('', include('apps.core.urls'))
]

App-Level URL Routing in Django

App-level URL routing in Django allows each app to manage its own URL patterns through a separate urls.py file. This approach keeps the project well-organized and makes each app more modular and easier to maintain.

The app's URLs are then linked to the main project's `urls.py` using the include() function.

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

# Required when using namespace in project urls
app_name = 'core'

# Assigns a unique name to the URL for easy referencing, such as `core:home` and `core:about`
urlpatterns = [
    # Home page view: URL 'core:home' is mapped to the 'home' view
    path('', views.home, name='home'),

    # About page view: URL 'core:about' is mapped to the 'about' view
    path('about/', views.about, name='about'),
]

Reverse vs Redirect in Django

In Django, reverse() is used to generate the URL for a given view by its name, while redirect() is used to send the user to a different URL.

• reverse():

  It generates a URL dynamically from a view's name and its parameters. Use it when you need to create URLs for redirects, links, or templates. It ensures flexibility and avoids hardcoding URLs in your code.

• redirect():

  It sends the user to another page, either by URL or using the name of a view, typically after a form submission or action is performed.

# views.py
from django.shortcuts import render, redirect
from django.urls import reverse

# Render the profile page, passing the 'id' to the template
def profile(request, id):
    return render(request, 'profile.html', {'id': id})

# View to redirect the user to the profile page with id=123
def redirect_to_profile(request):
    # Generate URL for 'profile' view → '/profile/123/'
    # Use app namespace if defined
    url = reverse('core:profile', kwargs={'id': 123}) 
    
    # Redirect user to the generated URL
    return redirect(url)

Exercise