程序设计应用2023-03-18

在first程序的里面views.py返回

def index(request):

    return HttpResponse("这是我的第一个Django网页")

 

 

还要主程序的urls.py引入

urlpatterns = [

    path('admin/', admin.site.urls),

    path('first/', views.index),

]

 

第三章 url的分发

url配置

url参数传递

反向解析url

url命名空间

 

虚拟路径和虚拟文件名显示给用户，这样比较安全

127.0.0.1:8000/first/ad

甚至可以这么配置，这里的views是导入的，from first import views

  path('first/ad', views.index),

 

多个配置指向同一个，以第一个为准。

 path('admin/', views.index),

 path('admin/', admin.site.urls),

 

 

主程序的setting.py里面的配置，是主程序的名字+urls。然后主程序下面有一个urls.py

ROOT_URLCONF = 'myDjango.urls'

 

 

re_path 模糊匹配

 

 

子项目也可以添加自己的urls.py

 

 

 

url pattern sample for re_path in Django

In Django, re_path() is a function that can be used to define URL patterns using regular expressions. Here's an example of how to use re_path() to define a URL pattern:

from django.urls import re_path
from . import views

# Define a URL pattern using a regular expression
urlpatterns = [
    re_path(r'^blog/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<slug>[\w-]+)/$', views.blog_post_detail),
]

In this example, the regular expression r'^blog/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<slug>[\w-]+)/$' is used to match URLs that follow this pattern: /blog/YYYY/MM/slug/, where YYYY is a four-digit year, MM is a two-digit month, and slug is a string of alphanumeric characters and hyphens.

The regular expression uses named groups to capture the values for the year, month, and slug parameters. These values will be passed to the views.blog_post_detail function as arguments when the URL is matched.

Note that re_path() is used instead of path() when you need to use regular expressions to define URL patterns.

 

url parameter vs kwargs parameter

In Django, both URL parameters and keyword arguments (kwargs) can be used to pass data to a view function, but they are used in different contexts.

URL parameters are used to capture parts of the URL path and pass them as arguments to a view function. They are defined using angle brackets <> and can be of various types, including integers (<int:parameter_name>), strings (<str:parameter_name>), and slugs (<slug:parameter_name>), among others.

For example, in the URL pattern /blog/<int:year>/<slug:slug>/, the year and slug values are extracted from the URL path and passed as arguments to the view function.

Keyword arguments, on the other hand, are used to pass named arguments to a view function. They are typically used in conjunction with the reverse() function to generate URLs dynamically based on the arguments passed to the view function.

For example, in the following view function:

def blog_post(request, year, slug):
    # do something with the year and slug arguments
    return HttpResponse("Blog post for year {} and slug {}".format(year, slug))

We can use the reverse() function to generate a URL for this view function based on the year and slug arguments: 

from django.urls import reverse

url = reverse('blog_post', kwargs={'year': 2023, 'slug': 'my-blog-post'})
# generates the URL '/blog/2023/my-blog-post/'

Overall, URL parameters are used to capture data from the URL path, while keyword arguments are used to pass data to a view function or generate URLs dynamically based on named arguments.

 

How url modules loaded in Django across root and sub applications?

In Django, URL modules are loaded automatically when the root URLconf module is loaded. This happens when the Django server starts up or when the urls.py module is imported by another module.

The root URLconf module is typically named urls.py and is located in the main application directory. It contains the main URL patterns for the application and serves as the entry point for all incoming requests.

When the Django server starts up, it looks for the urls.py module in the main application directory and loads it. The urlpatterns list in the root URLconf module can include patterns for the main application as well as patterns for any included sub-applications.

Sub-applications in Django are typically organized as separate modules, each with its own urls.py module that defines the URL patterns for that module. These sub-modules can be included in the root urls.py file using the include() function.

For example, if we have a sub-application named blog, we can include its URL patterns in the root urls.py file like this:

from django.urls import include, path

urlpatterns = [
    path('', include('mainapp.urls')),
    path('blog/', include('blog.urls')),
    # other URL patterns for the main application
]

In this example, the include() function is used to include the URL patterns defined in the blog.urls module. The blog module could have its own sub-modules with their own urls.py files that can be included in the blog.urls module in a similar way.

Overall, Django loads URL modules automatically when the root URLconf module is loaded, and sub-modules can be included in the root urls.py file using the include() function.

Explain the path function parameters in url patterns

In Django, the path() function is used to define URL patterns in the urls.py module. The path() function takes several parameters that define the URL pattern and any associated view function or options. The parameters for the path() function are as follows:

1. route: This is the first parameter and is a string that defines the URL pattern. It can include named groups enclosed in angle brackets (<>) to capture values from the URL. For example, the route "<str:slug>/edit/" matches any URL that ends in /edit/ and captures the value between the start of the URL and /edit/ as a string.

2. view: This parameter is required and specifies the view function that will be called when the URL pattern is matched. It can be a reference to a function or the name of a function as a string.

3. kwargs: This parameter is optional and can be used to pass additional keyword arguments to the view function.

4. name: This parameter is optional and provides a name for the URL pattern. It can be used to generate URLs for the pattern using the reverse() function.

5. regex: This parameter is optional and can be used to specify a regular expression to match the URL pattern instead of the route parameter.

6. unique: This parameter is optional and specifies whether the URL pattern is unique. If set to True, it means that this pattern cannot be used by any other URL pattern in the URLconf.

7. kwargs_format: This parameter is optional and specifies the format of keyword arguments that are passed to the view function. The default value is 'string', which means that keyword arguments are passed as strings. Other possible values are 'path' and 'querystring', which specify that keyword arguments should be passed as part of the URL path or in the query string, respectively.

Overall, the path() function is a flexible way to define URL patterns in Django, with options for capturing values from the URL, passing additional arguments to the view function, and generating URLs using the reverse() function.

Explain the re_path function parameters in url patterns

In Django, the re_path() function is used to define URL patterns using regular expressions. The re_path() function is similar to the path() function but allows for more complex URL patterns using regular expressions. The parameters for the re_path() function are as follows:

1. route: This is the first parameter and is a regular expression string that defines the URL pattern. The regular expression can include named groups enclosed in parentheses to capture values from the URL. For example, the route r'^articles/(?P<slug>[-\w]+)/$' matches any URL that starts with articles/ followed by a slug value, which is captured as a string.

2. view: This parameter is required and specifies the view function that will be called when the URL pattern is matched. It can be a reference to a function or the name of a function as a string.

3. kwargs: This parameter is optional and can be used to pass additional keyword arguments to the view function.

4. name: This parameter is optional and provides a name for the URL pattern. It can be used to generate URLs for the pattern using the reverse() function.

5. prefix: This parameter is optional and specifies a prefix to be added to the regular expression. It can be used to group related URL patterns together.

6. pattern: This parameter is optional and allows for more complex regular expressions to be used for the URL pattern.

7. unique: This parameter is optional and specifies whether the URL pattern is unique. If set to True, it means that this pattern cannot be used by any other URL pattern in the URLconf.

8. kwargs_format: This parameter is optional and specifies the format of keyword arguments that are passed to the view function. The default value is 'string', which means that keyword arguments are passed as strings. Other possible values are 'path' and 'querystring', which specify that keyword arguments should be passed as part of the URL path or in the query string, respectively.

Overall, the re_path() function provides more flexibility than the path() function for defining URL patterns using regular expressions. It can be useful for handling more complex URL patterns or for grouping related patterns together using a prefix.

 

Does re_path support wild character?

Yes, re_path() in Django supports wildcards, also known as "wildcard characters" or "globbing". In a regular expression pattern, a wildcard character is a symbol that matches any single character. The most commonly used wildcard character is the dot . which matches any single character except a newline.

For example, the regular expression pattern r'^books/(?P<book_id>\d+)/chapters/.*$' matches any URL that starts with books/ followed by a numeric book_id value, then chapters/ and any characters (including none) after it. The .* wildcard character matches any number of any characters, including none.

Another commonly used wildcard character is the question mark ?, which matches the preceding character zero or one times. For example, the regular expression pattern r'^articles/(?P<slug>[-\w]+)?/' matches any URL that starts with articles/ followed by an optional slug value, which is captured as a string.

Wildcards can be combined with other regular expression symbols to create more complex patterns for matching URLs in Django.

 

Difference between wildcards and regex pattern?

Wildcards and regular expression patterns are both used for pattern matching, but they have some important differences:

1. Wildcards are simpler and more limited than regular expression patterns. Wildcards usually only match a single character or a group of characters with a specific pattern. For example, the asterisk (*) is a wildcard that matches any sequence of characters, while the question mark (?) matches any single character.

2. Regular expression patterns are more powerful and flexible than wildcards. They allow for more complex pattern matching using a variety of special characters and syntax, such as character classes, groups, anchors, and quantifiers. Regular expression patterns can also be used to capture specific parts of a string for later use.

3. Wildcards are often used in file systems to match filenames or file extensions, while regular expression patterns are used in many programming languages and tools for pattern matching in text data.

4. Wildcards are generally easier to understand and use than regular expression patterns, especially for simpler pattern matching tasks. However, regular expression patterns are more expressive and can handle more complex pattern matching requirements.

In summary, wildcards are a simple and limited form of pattern matching, while regular expression patterns are a more powerful and flexible tool for pattern matching in text data. Both techniques have their own strengths and weaknesses and are used in different contexts depending on the requirements of the task.

 

python regex for Chinese characters

To match Chinese characters using Python regex, you can use the Unicode character range for Chinese characters, which is \u4e00-\u9fff. Here is an example of how to use this regex pattern in Python:

import re

text = "这是一段包含中文的文本。"
pattern = r'[\u4e00-\u9fff]+'

match = re.findall(pattern, text)
print(match)  # Output: ['这是一段包含中文的文本']

In this example, the re.findall() function is used to find all matches of the regex pattern in the text. The pattern r'[\u4e00-\u9fff]+' matches one or more Chinese characters in the text.

Note that the Unicode range for Chinese characters includes many other characters besides simplified and traditional Chinese characters, such as punctuation, symbols, and rare characters. If you only want to match simplified or traditional Chinese characters, you can use more specific Unicode ranges.

What does \u mean?

In Python, \u is an escape sequence used to represent a Unicode character in a string. It is followed by four hexadecimal digits that specify the Unicode code point of the character.

For example, the string "\u0041" represents the Unicode character "A", which has the hexadecimal code point 41 (65 in decimal). Similarly, the string "\u03C0" represents the Unicode character "π", which has the hexadecimal code point 3C0 (960 in decimal).

Here's an example of how to use \u to create a string with a Unicode character:

print("\u0041")  # Output: A
print("\u03C0")  # Output: π

In addition to \u, Python also supports other escape sequences for representing special characters in strings, such as \n for a newline character, \t for a tab character, and \\ for a literal backslash.

 

 

How can I add a new sub project in Django?

Django does not have the concept of sub-projects, but you can create a new app within an existing project to add new functionality. Here's how to create a new app within an existing Django project:

1. Open a terminal or command prompt and navigate to the root directory of your Django project.

2. Run the following command to create a new app:

    
3. python manage.py startapp app_name

   Replace app_name with the name of your new app. This will create a new directory with the same name as your app, and inside it, several files and directories that make up the basic structure of a Django app.

4. Open the settings.py file in your project directory and add the name of your new app to the INSTALLED_APPS list:

   python
5. INSTALLED_APPS = [ # ... 'app_name', ]

6. (Optional) Configure the app's models, views, and URLs by creating new files or modifying existing ones.

7. Run the following command to apply any database migrations for the new app:

    
8. python manage.py makemigrations app_name python manage.py migrate

9. (Optional) Add the app's URLs to your project's URL configuration by including them in the urlpatterns list in your project's urls.py file:

   python

6. from django.urls import include, path urlpatterns = [ # ... path('app_name/', include('app_name.urls')), ]

   Replace app_name with the name of your new app.

That's it! You've successfully added a new app to your existing Django project. You can now use the new app's functionality in your web application.

 

 

 

How to configure the url patterns for the app in project?

To configure URL patterns for an app in a Django project, you need to create a urls.py file in the app's directory and define the URL patterns for the app within that file.

Here are the general steps to configure URL patterns for an app in a Django project:

1. Create a urls.py file in the app's directory if it doesn't already exist.

2. Import the path function from Django's URL handling module:

   python
3. from django.urls import path

4. Define your app's URL patterns using the path function. For example, to define a URL pattern that maps to a view named my_view, you could use:

   python
5. from . import views urlpatterns = [ path('my-url/', views.my_view, name='my-view'), ]

   This creates a URL pattern that maps the URL path /my-url/ to the my_view function in the views module.

6. If you need to capture a variable from the URL path, you can use angle brackets to specify a named capture group, and the captured value will be passed as a parameter to the view function. For example:

   python
7. urlpatterns = [ path('books/<int:book_id>/', views.book_detail, name='book-detail'), ]

   This creates a URL pattern that captures an integer value from the URL path and passes it as a parameter named book_id to the book_detail function in the views module.

8. If you need to include URLs from other apps, you can use the include function:

   python
9. from django.urls import include, path urlpatterns = [ path('my-app/', include('my_app.urls')), ]

   This includes the URL patterns from the urls.py file in the my_app directory, prefixed with the string my-app/.

10. Finally, include your app's URL patterns in the project's URL patterns by editing the project's urls.py file:

    python

6. from django.urls import include, path urlpatterns = [ path('my-app/', include('my_app.urls')), ]

   This includes the URL patterns for your app under the URL path /my-app/.

That's it! You've successfully configured URL patterns for your app in a Django project. You can now define views for your app and map them to the appropriate URL patterns.

 

 

 

 

作者:Chuck Lu    GitHub