{"id":120263,"date":"2024-12-18T01:30:05","date_gmt":"2024-12-18T01:30:05","guid":{"rendered":"\/tutorials\/?p=120263"},"modified":"2024-12-20T12:17:26","modified_gmt":"2024-12-20T12:17:26","slug":"django-url-patterns","status":"publish","type":"post","link":"\/my\/tutorials\/django-url-patterns","title":{"rendered":"Understanding Django URL patterns"},"content":{"rendered":"

Django URL patterns map views to specific web addresses. In practice, they enable users to access different content using their corresponding URLs. Meanwhile, URL patterns help developers handle various HTTP requests more efficiently since you can easily set the route.<\/p>

In this tutorial, we will explain all about Django URL patterns, including how to make one using regular expressions or path converters.<\/p>

\n\n\n\n\n\n\n<\/p>

What are Django URL patterns?<\/h2>

Django URL patterns route a view to a specific address, which users can use to view the content. They are essential for ensuring that Django views<\/a> have a corresponding URL, so when you host your Django project on a server<\/a>, it is accessible and doesn’t return a 404 error.<\/p>

Let’s consider a real-world example to demonstrate how they work. You have a view rendering the content of your about <\/strong>page. To make it accessible through domain.tld\/about<\/strong>, create a URL pattern routing the view to \/about<\/strong>.<\/p>

Set the URL pattern inside urls.py<\/strong>, which is located in the same folder as your Django views.py<\/strong>. This file defines which function in views.py <\/strong>will trigger when a user sends HTTP requests through the specified URL. <\/p>

If you want to learn more about using and managing views, check out our Django views article.<\/p>

\"\"<\/a><\/figure>

Project-level vs. app-level URLs<\/h2>

A complex Django project might consist of multiple smaller applications. For better organization, you can create URL patterns on the project or application level.<\/p>

Project-level URLs<\/strong><\/p>

Project-level URLs route requests on a wider scope, such as views for the admin page or between applications. You can define them in urls.py<\/strong> inside your project root directory next to settings.py<\/strong>.<\/p>

For example, if your website has a smaller blog and shop application, your project-level URLs might include \/admin<\/strong>, \/blog<\/strong>, and \/shop<\/strong>.<\/p>

App-level URLs<\/strong><\/p>

App-level URLs route views within the same application. For example, if your website has a blog section, the URLs might include \/blog\/post-id<\/strong>, \/blog\/archive<\/strong>, or \/blog\/author-id<\/strong>.<\/p>

To define app-level URLs, use urls.py <\/strong>inside your application folder. For example, specify blog-related URLs in myproject\/blog\/<\/strong>.<\/p>

Basic URL configuration<\/h2>

To map a URL pattern to a view, use urlpatterns<\/strong> and specify the address using the path()<\/strong> function in the urls.py <\/strong>file. Before doing so, import the path<\/strong> module and your views<\/strong> like so:<\/p>

from django.urls import path, include\nfrom . import views <\/pre>
Now, you can map a URL using the following syntax:<\/p>
urlpatterns = [ \n   path('url-name\/', views.view_name, name='url_name'),\n]<\/pre>
The ‘url-name\/’, views.view_name <\/strong>section maps a URL to a specific function in your views. Optionally, you can name this URL pattern by changing the ‘url_name<\/strong>’ which we will explain more later.<\/p>
For example, if you want to create a project-level URL pattern for your \/archive<\/strong> and \/disclaimer <\/strong>pages, the code might look as follows:<\/p>
from django.urls import path, include\nfrom . import views \n\nurlpatterns = [ \n   path('archive', views.archive,),\n   path('disclaimer', views.disclaimer,),\n]<\/pre>
URL routing with views<\/h2>
After setting up the URL patterns, create the functions that will run upon receiving user requests. Add them to your application’s views.py<\/strong> file.<\/p>
You can define functions to give various responses, but for this tutorial, we will show you how to render a specific page template. Begin by importing the render<\/strong> module.<\/p>
from django.shortcuts import render<\/pre>
Then, add your functions like so:<\/p>
def archive(request):\n    return render(request, 'archive.html')\n\ndef disclaimer(request):\n    return render(request, 'disclaimer.html')<\/pre>
In this code, we define two functions – archive<\/strong> and disclaimer<\/strong>. Both use the request<\/strong> object to process users’ HTTP requests and return the render <\/strong>function to show content from the Django templates<\/a>. <\/p>
Based on the URL patterns defined in the previous section’s code, accessing domain.tld\/archive<\/strong> will render archive.html<\/strong>, while domain.tld\/disclaimer<\/strong> will show the content of disclaimer.html<\/strong>.<\/p>
Dynamic URL patterns and parameters<\/h2>
Instead of setting up URL patterns for all pages, you can create a dynamic address that changes automatically based on specific variables.<\/p>
To do so, you must capture the URL parameters<\/strong> – values in the web address that change depending on the content the user accesses. For example, posts in a blog use different IDs in their URLs.<\/p>
You can capture the dynamic values using regular expressions and path converters. However, Modern Django recommends path converters since regular expressions are more prone to error. We’ll explain their differences in the later section.<\/p>
The step to map a dynamic URL pattern is the same as the static one. The difference is that you add the path converters to the URL part that will change its value. Here are some of the most used ones. <\/p>
Integer or int:<\/strong><\/p>
The integer path converter captures numbers from the URL, which is useful for mapping addresses to pages like post IDs. The code looks like this:<\/p>
path('article\/<int:id>\/', views.article_detail)<\/pre>
The example matches URLs like article\/10<\/strong> or article\/324<\/strong>.<\/p>
String or str:<\/strong><\/p>
The string converter captures a sequence of any characters, excluding an empty space and the forward-slash (\/<\/strong>) separator. Here’s a code example:<\/p>
path('user\/<str:username>\/', views.user_profile)<\/pre>
The pattern will match URLs like user\/hostinger <\/strong>or user\/vpsisfun<\/strong>.<\/p>
Slugs or slug:<\/strong><\/p>
Slug converters capture the permalinks of posts, which are strings of lowercase characters separated by hyphens or underscores. The code looks as follows:<\/p>
path('post\/<slug:slug>\/', views.blog_post)<\/pre>
The above example matches URLs such as user\/post-permalink<\/strong> or user\/first_post<\/strong>.<\/p>
UUID or uuid:<\/strong><\/p>
The UUID converter captures a universal unique identifier (UUID) string consisting of 32-character hexadecimal values. Here’s an example:<\/p>
path('order\/<uuid:id>\/', views.order_detail)<\/pre>
The code will match URLs like \/order\/123e4567-e89b-12d3-a456-426614174000\/<\/strong>. This converter is useful for mapping automatically generated IDs, such as invoices or order numbers.<\/p>
Path or path:<\/strong><\/p>
Use path: <\/strong>to capture strings consisting of characters, including the forward slash (\/<\/strong>) separator. The code looks as follows:<\/p>
path('files\/<path:file_path>\/', views.file_detail)<\/pre>
In the example, the pattern matches URLs like files\/images\/logo.png<\/strong>.<\/p>
Multiple converters<\/strong><\/p>
You can combine path converters in the same URL pattern to capture multiple dynamic values. Here’s an example:<\/p>
urlpatterns = [\n    path('product\/<slug:category>\/<int:id>\/', views.product_detail),\n]<\/pre>
The code snippet captures two parameters – slug, which is the product category, and the ID in integer. It means the pattern will match URLs like product\/shoes-and-sandals\/23<\/strong>.<\/p>
Named URL patterns<\/h2>
You can name your URL patterns to make it easier to reuse without having to rewrite the full address from scratch. In addition to improving code maintainability, doing so helps minimize issues.<\/p>
If you hardcode your URL patterns in multiple files like templates and views, you must modify them individually. Conversely, you only need to update named patterns on your urls.py<\/strong>, which is less prone to human error.<\/p>
For example, we’ll create a URL pattern called posted<\/strong>:<\/p>
patternsurl=[\n    path('post\/<int:id>\/', views.postid, name='postid'),\n]<\/pre>
To generate the URL pattern based on its name, use the reverse() f<\/strong>unction. It enables the name to resolve and include dynamic values, which the path converters represent. Your views <\/strong>code might look like this:<\/p>
from django.shortcuts import render, get_object_or_404\nfrom django.urls import reverse\nfrom .models import Post  # if you have a Post model\n\ndef postid(request, id):\n    post = get_object_or_404(Post, id=id)\n    post_url = reverse('postid', kwargs={'id': post.id})\n    return render(request, 'post_detail.html', {'post': post, 'post_url': post_url})<\/pre>
The reverse() <\/strong>function calls the URL named postid<\/strong>, which we previously set in urls.py.<\/strong> Then, kwargs<\/strong> pulls the value of the current post ID, passing it to the path converter placeholders.<\/p>
Once we have the URL pattern, the render()<\/strong> function processes the content, generating the post_detail.html <\/strong>template to users.<\/p>
Regular expressions vs. path converters<\/h2>
Django used regular expressions (regex) to create placeholders for dynamic URL parameters. However, it introduces path converters as a replacement in the newer versions.<\/p>
Regex uses a string of characters arranged in a particular syntax to match the data pattern. For example, you can create a post\/id<\/strong> URL pattern using this path converter:<\/p>
'post\/<int:id>\/'<\/pre>
However, your pattern might look as follows using regex:<\/p>
r'^post\/(?P<id>\\d+)\/<\/pre>
Here’s the comparison between regex and path converters in several aspects:<\/p>