django request life cycle flowchart
route matching
File name: urls.py
Professional Name: Routing Layer
urlpatterns = [ path('URL extension',Function name) ]
If the suffix name of the URL entered by the browser matches the URL suffix name of the path, then the subsequent function call will be automatically triggered, and the following route matching will be ended at the same time.
emphasize:
Problem with trailing slash in routing suffix
We can see through practice that if we don't write slashes, we can also match
principle:
Because django will process the data twice, when the first match is made, the match fails; django will automatically let the browser add a slash for the second judgment
Of course we don't need django to do this, we can add and modify a configuration
APPEND_SLASH = False # Default is not True
path converter
Application scenario: When the URL suffix is not fixed, we can use a converter to match
Five converters:
- 'int': IntConverter(),
- 'path': PathConverter(),
- 'slug': SlugConverter(),
- 'str': StringConverter(),
- 'uuid': UUIDConverter(),
The more commonly used ones are int (integer) and str (string)
for example:
path('index/<int:id>/<str:info>', view.index) here id and info is a variable, you can start it at will
Notice:
-
The content matched by the converter will be passed in as a keyword parameter of the view function
-
There are several suffixes here, then several parameters must be passed in the view function
-
The name of the converter must correspond to the formal parameter of the view function
for example:
def index(request, year, info): pass
re_path regular matching
Grammatical structures:
re_path(regular expression, function name)
Once the regularity of the URL suffix can match the content, the following function will be automatically executed, and the matching of the entire route will be ended.
eg:
re_path('^index$', views.index)
When the suffix of the web page is not fixed, you can use a converter to match
Unnamed grouping for regular matching
Unnamed grouping can also be understood as literal meaning, group matching that cannot be aliased
Here we need to have knowledge about regularization: regular expression
for example:
re_path('^index/(\d+)/', views.test)
The content matched by the regular expression will be passed to the view function as the keyword parameter of the view function. At this time, the corresponding formal parameter is required to correspond
Regular matching of named groups
We can also understand it literally as aliasing the matching content instead
For aliasing in regular expressions, we use the method of ?P<alias>
for example:
re_path('^index/?P<id>\d+/?P<info>.*?/', views.index)
The content matched by the regular expression will be passed to the view function as the keyword parameter of the view function. At this time, the corresponding formal parameter is required to correspond
Note: In subsequent use, we obtain the matched data in the form of aliases
django version difference
- In django1.11, only regular matching is supported, and the method is url()
- In django2, 3, 4 versions, you can use path(), re_path()>>>url()
reverse parsing
-
definition
As the function increases, more views will appear. Maybe the previously configured regular expression is not accurate enough, so the regular expression needs to be modified, but once the regular expression is modified, all the corresponding hyperlinks must be modified before. It is a troublesome thing, and some hyperlinks may be missed and forgotten to be modified. Is there a way to dynamically generate links based on regular expressions? It's the reverse analysis method.
Reverse parsing: return a result that can access the corresponding route
-
Application scenarios
- Hyperlinks in templates (eg: page jumps)
- Redirect in view
-
Instructions
-
Aliasing the correspondence in routing urls
re_path('^index/?P<id>\d+/', views.index, name='index_view') here name Corresponding data, we can get the previous suffix through this data, no matter how the suffix changes, it does not affect my ability to get
-
When defining the url, you need to define the namespace attribute for include and the name attribute for the url
When using, use the url tag in the template, use the reverse function in the view, and dynamically generate the address according to the regular expression to reduce the maintenance cost in the later period.url(r'^',include('index.urls',namespace='index')),
-
-
Use reverse parsing grammar
-
Use on HTML pages
{% url 'index_view' %}
-
rear end
from django.shortcuts import reverse reverse('index_view')
When redirecting, use the method: return redirect(reverse('index_view'))
-
Emphasis: The three methods of reverse parsing are the same as path() re_path() url()
Anonymous and named reverse parsing
-
Nameless reverse parsing
path('index/<str:info>/', views.index, name='index_view')
use:
In the view function: reverse('index_view', args=('jason',)) must pass the corresponding number of values according to the converter
In HTML file: {% url 'index_view' 'jason' %}
-
Famous reverse parsing
re_path('^index/?P<id>\d+/?P<info>.*?/', views.index, name='index_view')
use:
In the view function: reverse('index_view', kwargs={'id':id, 'info': info})
In HTML file: {% url 'index_view' 1 'jason' %}
route distribution
-
effect
django The applications in can have their own independent urls.py templates folder static folder able to be based on django The multiple applications developed are completely independent, which is convenient for group development
-
general route
path('app01/', include('app01.urls')), # Go to the routing layer of app01 path('app02/', include('app02.urls')), # Go to the routing layer of app02
-
sub route
path('after/', views.after) # Find data under app01 path('after/', views.after) # Find the data under app02
-
scenes to be used
When the project is very large and there are many applications, routing distribution can be used, which is very convenient!!!
namespace
Even if different apps use the same URL name, the URL namespace pattern allows you to uniquely reverse the named URL.
In a route distribution scenario, multiple applications cannot be resolved normally when reverse resolution alias conflicts are involved
-
Solution one
namespacenamespace path('app01/', include(('app01.urls', 'app01'), namespace='app01')) path('app01/', include(('app01.urls', 'app02'), namespace='app02'))
-
Solution two
Aliases do not conflict
You can also ensure that there are no duplicate aliases under the django project.
for example:
way 1:namespace total route add namespace url(r'^app01/',include('app01.urls',namespace='app01')), url(r'^app02/',include('app02.urls',namespace='app02')) Apply reverse parsing auto-suggestion reverse('app01:index_view') reverse('app02:index_view') {% url 'app01:index_view' %} {% url 'app02:index_view' %} way 2:Just make sure the reverse resolved aliases are not duplicated throughout the project!!! You can prefix the alias with the application name url(r'^index/',views.index,name='app01_index_view') url(r'^index/',views.index,name='app02_index_view')