Guide to URL configuration in Django framework

Django is a powerful web application framework, and URL configuration is a very critical part of the Django framework. This article will introduce the basic knowledge of URL configuration and its specific implementation methods and usage scenarios in the Django framework.

1. Basic knowledge of URL configuration

URL stands for Uniform Resource Locator (Uniform Resource Locator). It is the only address used to identify resources on the Web. It usually consists of protocol, domain name and path. .

In the Django framework, URL configuration refers to the process of binding client requests to corresponding view functions. When the client sends a request, Django will find the corresponding view function based on the rules defined in the URL configuration, and hand the request to this view function for processing. Therefore, the role of URL configuration is to distribute to different view functions for different request paths.

2. How to implement URL configuration

In the Django framework, URL configuration can be implemented in two ways: function-based view and class-based view.

1. Function-based view

Function-based view refers to directly binding the request path to the corresponding function. This binding method is very simple, and its code implementation As follows:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('about/', views.about, name='about'),
    path('contact/', views.contact, name='contact'),
]

In the above code implementation, a new urlpatterns variable is defined by importing the path module in the Django framework. This variable is a list, in which each element is a path and a view function. Correspondence. For example, the first element represents binding the empty path (that is, when there is no path information after the domain name) with the view function index, the second element represents binding the /about/ path with the view function about, and the third element represents Indicates that the /contact/ path is bound to the view function contact.

2. Class-based view

Class-based view refers to directly binding the request path to the corresponding class method. This binding method is compared to the function-based view. The view is more flexible and easy to expand. The code implementation is as follows:

from django.urls import path
from .views import IndexView, AboutView, ContactView

urlpatterns = [
    path('', IndexView.as_view(), name='index'),
    path('about/', AboutView.as_view(), name='about'),
    path('contact/', ContactView.as_view(), name='contact'),
]

In the above code implementation, a new urlpatterns variable is defined by importing the IndexView, AboutView and ContactView classes in the views module, in which each element They are all corresponding relationships between paths and class views. For example, the first element represents binding the empty path (that is, when there is no path information after the domain name) with the IndexView class view, the second element represents binding the /about/ path with the AboutView class view, and the third element represents Indicates that the /contact/ path is bound to the ContactView class view.

3. Usage scenarios of URL configuration

URL configuration is usually used to solve the following two problems:

1. Distribution request

When the client sends a request, the Django framework will hand over the request to the URL configuration for parsing, and then forward the request to the corresponding view function or class method for processing. The URL configuration is like a router, responsible for routing client requests to the correct handler function.

2. Generate URL

In addition to distributing requests, URL configuration is also often used to generate URLs. Because the Django framework allows us to refer to a specific URL path through the URL name, this URL name will be automatically converted to the corresponding URL path. For example:

<a href="{% url 'about' %}">关于我们</a>

In the above code, we refer to the URL path named 'about' through the template tag {% url 'about' %}. The final effect is to generate the URL path of /about/.

4. Advanced applications of URL configuration

In the Django framework, in addition to being used for basic request distribution and URL generation, URL configuration can also be applied to the following advanced scenarios:

1. URL parameter passing

In URL configuration, we can define the variable type and variable name of the URL path by using . For example:

from django.urls import path
from .views import post_detail

urlpatterns = [
    path('post/<int:pk>/', post_detail, name='post_detail'),
]

In the above code, we use to define an integer parameter pk of the post_detail path. This parameter is separated by a colon to the end of the path and passed as a parameter in the view function.

2. URL character matching

In URL configuration, we can use regular expressions to match certain specific characters of the request path. This method is very flexible. For example:

from django.urls import re_path
from .views import search

urlpatterns = [
    re_path(r'^search/(?P<keyword>w+)/$', search, name='search'),
]

In the above code, we use the re_path method to define a path matching rule, which contains a keyword parameter and can match path characters containing letters, numbers, and underscores.

3. URL namespace

In the Django framework, URL namespace refers to grouping the URLs of one or more applications for better visibility within the application. Management URL. For example:

from django.urls import path, include
from myapp1.views import index as myapp1_index
from myapp2.views import index as myapp2_index

myapp1_patterns = [
    path('', myapp1_index, name='index'),
]

myapp2_patterns = [
    path('', myapp2_index, name='index'),
]

urlpatterns = [
    path('myapp1/', include((myapp1_patterns, 'myapp1'), namespace='myapp1')),
    path('myapp2/', include((myapp2_patterns, 'myapp2'), namespace='myapp2')),
]

In the above code, we use the include function to introduce the URL configuration of each application into the Django framework, and set a namespace for the URL configuration of each application. This ensures that there will be no conflicts between URLs in different applications, and also facilitates URL references in templates.

Summary

This article introduces the basic knowledge, implementation methods and advanced applications of URL configuration in the Django framework. I hope it can help readers better understand the URL configuration in the Django framework and be able to Flexibly apply URL configuration in actual development.

The above is the detailed content of Guide to URL configuration in Django framework. For more information, please follow other related articles on the PHP Chinese website!