zoukankan      html  css  js  c++  java
  • Django立项和URL的使用(二)

    Django立项和URL的使用

    1,第一个Django项目

    1,创建Django项目

      ㈠用命令行的方式

    ①创建项目:打开终端,使用命令:django-admin startproject [项目名称]即可创建。比如:

    django-admin startproject first_project

    ②运行项目:在终端,进入到项目文件夹中,然后执行以下命令即可运行:

    python manage.py runserver

    这样可以在本地访问你的网站,默认端口号是8000,这样就可以在浏览器中通过http://127.0.0.1:8000/来访问你的网站啦。如果想要修改端口号,那么在运行的时候可以指定端口号,python manage.py runserver 9000这样就可以通过9000端口来访问啦。另外,这样运行的项目只能在本机上能访问,如果想要在其他电脑上也能访问本网站,那么需要指定ip地址为0.0.0.0。示例为:python manage.py runserver 0.0.0.0:8000

    ③创建应用(app):一个项目类似于是一个架子,但是真正起作用的还是app。在终端进入到项目所在的路径,然后执行python manage.py startapp [app名称]创建一个app。

      ㈡用pycharm的方式

    ①创建项目:用pycharm新建一个Django项目,新建项目的截图如下:

      使用pycharm创建完项目后,还是需要重新进入到命令行单独创建app的。

      创建app:在cmd中进入项目文件夹,并处于虚拟环境,执行以下代码

    python manage.py startapp book
    # book为app的名称,可修改

    ②运行Django项目:

      1,通过pycharm运行。直接点击右上角的绿色箭头按钮即可运行。

      2,修改端口号:右上角→项目配置→port。更改端口号,重新运行。

      3,如何让同局域网的其他电脑访问本机的项目:

        1,让项目运行时,host为0.0.0.0。

          在终端,使用命令

    python manage.py runserver 0.0.0.0:8000

          在pycharm,右上角→项目配置→host。改成 0.0.0.0

        2,并且在settings.py中的ALLOWED_HOSTS = [' 里面填上自己的那个ip ']

          注意:要关闭自己电脑的防火墙。

      4,注意:用pycharm运行项目,要避免一个项目运行多次。可以通过勾选pycharm中只用单一实例选项避免该问题发生。

    2,项目结构介绍

    1. manage.py:以后和项目交互基本上都是基于这个文件。一般都是在终端输入python manage.py [子命令]。可以输入python manage.py help看下能做什么事情。除非你知道你自己在做什么,一般情况下不应该编辑这个文件。
    2. settings.py:本项目的设置项,以后所有和项目相关的配置都是放在这个里面。
    3. urls.py:这个文件是用来做url与视图函数映射的。以后来了一个请求,就会从这个文件中找到匹配的视图函数。
    4. wsgi.py:专门用来做部署的。项目与WSGI协议兼容的web服务器入口,部署的时候需要用到的,一般也不需要修改的。

    3,project和app的关系

      appdjango项目的组成部分。一个app代表项目中的一个模块,所有URL请求的响应都是由app来处理。比如豆瓣,里面有图书,电影,音乐,同城等许许多多的模块,如果站在django的角度来看,图书,电影这些模块就是app,图书,电影这些app共同组成豆瓣这个项目。因此这里要有一个概念,django项目由许多app组成,一个app可以被用到其他项目,django也能拥有不同的app

    4,Django推荐的项目规范

    按照功能或者模块进行分层,分成一个一个app。所有和某个模块相关的视图都写在对应的app的views.py中,并且模型和其他的也是类似。然后django已经提供了一个比较方便创建app的命令叫做python manage.py startapp [app的名称]。把所有的代码写在各自的app中。

    5,DEBUG模式

    1,如果开启了DEBUG模式,那么以后我们修改了Django项目的代码,然后按下ctrl+s,那么Django就会自动给我们重启项目,无需手动重启项目。

    2,如果开启了DEBUG模式,那么以后Django项目中的代码出现bug了,那么在浏览器中和控制台会打印出错信息。

    3,在生产环境中,禁止开启DEBUG模式,不然可能会泄露代码,造成很大的安全隐患。

    4,关闭DEBUG模式:DEBUG=False,当设置False之后,需要设置ALLOWED_HOSTS的参数,否则不能正常运行。

    6,ALLOWED_HOSTS

    这个变量是用来设置以后别人只能通过这个变量中的ip地址或者域名来进行访问该项目。

    127.0.0.1代表的是本机的ip地址。

    2,URL分发器

    1,视图

    视图一般都写在app的views.py中。

    ①视图的第一个参数永远都是request(一个HttpRequest)对象。这个对象存储了请求过来的所有信息,包括携带的参数以及一些头部信息等。在视图中,一般是完成逻辑相关的操作。比如这个请求是添加一篇博客,那么可以通过request来接收到这些数据,然后存储到数据库中,最后再把执行的结果返回给浏览器。

    ②视图函数的返回结果必须是django.http.response.HttpResponseBase对象或者子类的对象。示例代码如下:

    from django.http import HttpResponse  # 导入对象
    def book_list(request):  # ①第一个参数永远都是request。
        return HttpResponse("书籍列表!")  # ②返回值为HttpResponseBase对象或者子类的对象。

    当想了解HttpResponse时,可以ctrl+b。

    2,URL映射

    视图写完后,要与URL进行映射,也即用户在浏览器中输入什么url的时候可以请求到这个视图函数。在用户输入了某个url,请求到我们的网站的时候,django会从项目的urls.py文件中寻找对应的视图。在urls.py文件中有一个urlpatterns变量,以后django就会从这个变量中读取所有的匹配规则。匹配规则需要使用django.urls.path函数进行包裹,这个函数会根据传入的参数返回URLPattern或者是URLResolver的对象。示例代码如下:

    from django.contrib import admin
    from django.urls import path
    from book import views
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('book/',views.book_list)
    ]

    注意点:

    ①为什么会去urls.py文件中寻找映射呢?

        是因为在 'settings.py' 文件中配置了 'ROOT_URLCONF' 为 'urls.py' 。所有的django会去 'urls.py' 中去寻找。

    ②在 'urls.py' 中我们所有的映射,都应该放在 'urlpatterns' 这个变量中。

    ③所有的映射不是随便写的,而是使用 'path' 函数或者 're_path' 函数进行包装的。

    3,URL中添加参数(两种)

    ①采用在url中使用变量的方式

    比如简书的文章详情页面的url就可以写成https://www.jianshu.com/p/<id>,其中id就是文章的id。实现:在path的第一个参数中,使用<参数名>的方式可以传递参数。然后在视图函数中也要写一个参数,视图函数中的参数必须和url中的参数名称保持一致,不然就找不到这个参数。另外,url中可以传递多个参数。

    url.py

    from django.contrib import admin
    from django.urls import path
    from book import views
    from django.http import HttpResponse
    
    def index(request):
        return HttpResponse('首页')
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('',index),
        path('book/',views.book),
        path('book/detail/<book_id>/<category_id>',views.book_detail),
    ]

    views.py

    def book_detail(request,book_id):    # 传递一个参数
        #可以从数据库由根据book_id提取这个图书的信息。
        text = "您获取的图书id是:%s" % book_id
        return HttpResponse(text)
    
    def book_detail(request,book_id,category_id):  # 传递多个参数
        #可以从数据库由根据book_id提取这个图书的信息。
        text = "您获取的图书id是:%s,图书分类是%s" % (book_id, category_id)
        return HttpResponse(text)

    ②采用查询字符串的方式

    在url中,不需要单独的匹配查询字符串的部分。只需要在视图函数中使用request.GET.get('参数名称')的方式来获取。示例代码如下:

    urls.py

    path('book/author/',views.author_detail)

    views.py

    def author_detail(request):
        author_id = request.GET.get('id')  # author_id = request.GET['id']
        text = '作者的id是:%s' % author_id
        return HttpResponse(text)

    因为查询字符串使用的是GET请求,所以我们通过request.GET来获取参数。并且因为GET是一个类似于字典的数据类型,所有获取值跟字典的方式都是一样的。以后在访问的时候就是通过/book/detail/?id=1即可将参数传递过去。

    4,url参数的内置转换器:

    自定义转换器详见本文后面。

    在url中使用变量,添加参数,为了限定该变量的类型,故采用转换器来限定。

    from django.urls import converters  # 导入转换器,选中converters,ctrl+b查看源码
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('book/publisher/<int:publisher_id>',views.publisher_detail)  # 若不标明转换器,默认str转换器
    ]

    str:除了斜杠/以外所有的字符都是可以的。

    int:只有是一个或者多个的阿拉伯数字。

    path:所有的字符都是满足的。

    uuid:只有满足uuid.uuid4()这个函数返回的字符串的格式。可以作为数据库表中的主键。

    slug:英文中的横杆或者英文字符或者阿拉伯数字或者下划线才满足。

    5,URL中包含另外一个urls模块

     在我们的项目中,不可能只有一个app,如果把所有的app的views中的视图都放在urls.py中进行映射,肯定会让代码显得非常乱。因此django给我们提供了一个方法,可以在app内部包含自己的url匹配规则,而在项目的urls.py中再统一包含这个app的urls。

    ①应该使用`include`函数包含子`urls.py`,并且这个`urls.py`的路径是相对于项目的路径。示例代码如下:

    # first_project/urls.py文件:
    
    from django.contrib import admin
    from django.urls import path,include
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('book/',include("book.urls"))  # include下的路径相对于项目而言
    ]

     ②在urls.py文件中把所有的和book这个app相关的url都移动到app/urls.py中了,然后在first_project/urls.py中,通过include函数包含book.urls,以后在请求book相关的url的时候都需要加一个book的前缀。

    # book/urls.py文件:
    
    from django.urls import path
    from . import views
    
    urlpatterns = [
        path('',views.book),
        path('detail/<book_id>',views.book_detail),
        path('list/',views.book_list),
    ]

     ③`url`是会根据主`urls.py`和app中的`urls.py`进行拼接的,因此注意不要多加斜杠。以后访问书的列表的url的时候,就通过/book/list/来访问,访问书籍详情页面的url的时候就通过book/detail/<id>来访问。

    6,url命名与反转url

    ①为什么需要url命名?

    因为url是经常变化的。如果在代码中写死可能会经常改代码。给url取个名字,以后使用url的时候就使用他的名字进行反转就可以了,就不需要写死url了。

    ②如何给一个url指定名称?

    在path函数中,传递一个name参数就可以指定。示例代码如下:

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

    ③应用命名空间:

    在多个app之间,有可能产生同名的url。这时候为了避免反转url的时候产生混淆,可以使用应用命名空间,来做区分。定义应用命名空间非常简单,只要在`app`的`urls.py`中定义一个叫做`app_name`的变量,来指定这个应用的命名空间即可。示例代码如下:

    # 应用命名空间
    app_name = 'front'
    
    urlpatterns = [
        path('',views.index,name='index'),
        path('login/',views.login,name='login')
    ]

    以后在做反转的时候就可以使用`应用命名空间:url名称`的方式进行反转。示例代码如下:

    # reverse 将path中的视图函数转换为url,提前是需要给url指定一个名字
    # redirect 重定向函数
    login_url = reverse('front:login') return redirect(login_url) # return redirect(reverse('front:login'))

    ④应用(app)命名空间和实例命名空间:

    避免一个app同时映射多个url,产生错误的问题。

    一个app,可以创建多个实例。可以使用多个url映射同一个app。所以这就会产生一个问题。以后在做反转的时候,如果使用应用命名空间,那么就会发生混淆。为了避免这个问题。我们可以使用实例命名空间。实例命名空间也是非常简单,只要在`include`函数中传递一个`namespace`变量即可。示例代码如下:

    urlpatterns = [
        path('',include('front.urls')),
        # 同一个app下有两个实例
        path('cms1/',include('cms.urls',namespace='cms1')),
        path('cms2/',include('cms.urls',namespace='cms2')),
    ]

    以后在做反转的时候,就可以根据实例命名空间来指定具体的url。示例代码如下:

    def index(request):
        username = request.GET.get('username')
        if username:
            return HttpResponse('CMS首页')
        else:
            current_namespace = request.resolver_match.namespace # 获取当前的命名空间
            return redirect(reverse('%s:login'%current_namespace))  # 这里使用得到的namespace

    front:用来管理前台相关的代码的

    cms:用来管理后台相关的代码的

    指定

    # cms.urls.py 文件
    
    from django.urls import path
    from . import views
    
    app_name = 'cms'
    
    urlpatterns = [
        path('',views.index,name = 'index'),
        path('login/',views.login,name = 'login')
    ]
    
    # cms.views.py 文件
    
    from django.http import HttpResponse
    from django.shortcuts import redirect,reverse
    
    
    def index(request):
        username = request.GET.get('username')
        if username:
            return HttpResponse('CMS首页')
        else:
            # 获取当前的命名空间
            current_namespace = request.resolver_match.namespace # 获取当前的
            return redirect(reverse('%s:login'%current_namespace))  # 这里使用得到的namespace
    
    def login(request):
        return HttpResponse('CMS登录页面')
    
    # front.urls.py 文件
    
    from django.urls import path
    from . import views
    
    app_name = 'front'
    
    urlpatterns = [
        path('',views.index,name = 'index'),
        path('signin/',views.login,name='login')
    ]
    
    # front.views.py 文件
    
    from django.http import HttpResponse
    from django.shortcuts import redirect,reverse
    
    def index(request):
        # ?username = xxx
        username = request.GET.get('username')
        if username:
            return HttpResponse('前台首页')
        else:
            return redirect(reverse('front:login'))
    
    def login(request):
        return HttpResponse('前台登录页面')
    
    # urls.py 文件
    
    from django.contrib import admin
    from django.urls import path,include
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('',include('front.urls')),
        path('cms1/', include('cms.urls',namespace='cms1')),
        path('cms2/', include('cms.urls',namespace='cms2')),
    示例

    如果指定实例命名空间,那么前提必须要先指定应用命名空间。也就是在子`urls.py`中添加`app_name`变量。

    7,path函数

    path函数的定义为:path(route,view,name=None,kwargs=None)。以下对这几个参数进行讲解。

    ①route参数

    url的匹配规则。这个参数中可以指定url中需要传递的参数,比如在访问文章详情页的时候,可以传递一个id。传递参数是通过<>尖括号来进行指定的。并且在传递参数的时候,可以指定这个参数的数据类型,比如文章的id都是int类型,那么可以这样写<int:id>,以后匹配的时候,就只会匹配到id为int类型的url,而不会匹配其他的url,并且在视图函数中获取这个参数的时候,就已经被转换成一个int类型了。其中还有几种常用的类型:

    str:非空的字符串类型。默认的转换器。但是不能包含斜杠。

    int:匹配任意的零或者正数的整形。到视图函数中就是一个int类型。
    slug:由英文中的横杠-,或者下划线_连接英文字符或者数字而成的字符串。

    uuid:匹配uuid字符串。

    path:匹配非空的英文字符串,可以包含斜杠。

    ②view参数:

    可以为一个视图函数或者是类视图.as_view()或者是django.urls.include()函数的返回值。

    ③name参数:

    这个参数是给这个url取个名字的,这在项目比较大,url比较多的时候用处很大。

    ④kwargs参数:

    有时候想给视图函数传递一些额外的参数,就可以通过kwargs参数进行传递。这个参数接收一个字典。传到视图函数中的时候,会作为一个关键字参数传过去。比如以下的url规则:

    from django.urls import path
     from . import views
    
     urlpatterns = [
         path('blog/<int:year>/', views.year_archive, {'foo': 'bar'}),
     ]
    

    那么以后在访问blog/1991/这个url的时候,会将foo=bar作为关键字参数传给year_archive函数。

    ⑤re_path函数

    有时候我们在写url匹配的时候,想要写使用正则表达式来实现一些复杂的需求,那么这时候我们可以使用re_path来实现。⑴re_path的参数和path参数一模一样,只不过第一个参数也就是route参数re_path在写url的时候可以用正则表达式,功能更加强大。

    ⑵所有的route字符串前面都加了一个r,表示这个字符串是一个原生字符串。在写正则表达式中是推荐使用原生字符串的,这样可以避免在python这一层面进行转义。而且,使用正则表达式捕获参数的时候,是用一个圆括号进行包裹,然后这个参数的名字是通过尖括号<year>进行包裹,之后才是写正则表达式的语法。
    一些使用re_path的示例代码如下:

    # article.urls.py 文件
    from django.urls import re_path
    from . import views
    
    urlpatterns = [
            # r"": 代表的是原生字符串(raw)
            # ^"": 以什么开头
            # $"": 以什么结尾
            # (): 在正则表达式里面定义一个需要捕获的参数,则使用()包裹起来
            # ?P: 给捕获的变量取名字,写在?P后面
            # <>: 表明这个名字叫做什么名字
            # d: 代表0-9之间的数字,如果需要四个,则写成d{4}
        re_path(r'^$',views.article),
            # 定义一个需要捕获的参数取名为year,后面为四个数字,并以/结尾
        re_path(r'^list/(?P<year>d{4})/$',views.article_list), 
        re_path(r'^list/(?P<month>d{2})/$',views.article_list_month), ]

    article.views.py文件

    from django.http import HttpResponse
    
    def article(request):
        return HttpResponse('文章首页')
    
    def article_list(request,year):
        text = '您输入的年份是:%s' % year
        return HttpResponse(text)
    
    def article_list_month(request,month):
        text = '您输入的月份是:%s' % month
        return HttpResponse(text)
    
    # urls.py文件
    from django.urls import path,include
    
    urlpatterns = [
        path('article/',include('article.urls'))
    ]
    article.views.py文件

    按住alt+1可以实现项目(project)栏的打开和关闭

    ⑥include函数

    在项目变大以后,经常不会把所有的url匹配规则都放在项目的urls.py文件中,而是每个app都有自己的urls.py文件,在这个文件中存储的都是当前这个app的所有url匹配规则。然后再统一注册到项目的urls.py文件中。include函数有多种用法,这里讲下两种的用法。

    ①include(module,namespace=None):直接把其他app的urls包含进来。

    module:子url的模块字符串。

    namespace:实例命名空间。这个地方需要注意一点。如果指定实例命名空间,那么前提必须要先指定应用命名空间。也就是在子`urls.py`中添加`app_name`变量。

    示例代码如下:

    # movie.urls.py 文件
    from django.contrib import admin from django.urls import path,include urlpatterns = [ path('admin/', admin.site.urls), path('book/',include("book.urls")) ]

    当然也可以传递namespace参数来指定一个实例命名空间,但是在使用实例命名空间之前,必须先指定一个应用命名空间。示例代码如下:

    # 主urls.py文件:
    from django.urls import path,include
    urlpatterns = [
        path('movie/',include('movie.urls',namespace='movie'))
    ]
    

    然后在movie/urls.py中指定应用命名空间。实例代码如下:

    from django.urls import path
    from . import views
    
    # 应用命名空间
    app_name = 'movie'
    
    urlpatterns = [
        path('',views.movie,name='index'),
        path('list/',views.movie_list,name='list'),
    ]
    

    ②include(pattern_list):可以包含一个列表或者一个元组,这个元组或者列表中又包含的是path或者是re_path函数。

        path('movie/',include([
            path('',views.movie),
            path('list/',views.movie_list),
        ]))

    ③include((pattern,app_namespace),namespace=None):在包含某个app的urls的时候,可以指定命名空间,这样做的目的是为了防止不同的app下出现相同的url,这时候就可以通过命名空间进行区分。`include`函数的第一个参数既可以为一个字符串,也可以为一个元组,如果是元组,那么元组的第一个参数是子`urls.py`模块的字符串,元组的第二个参数是应用命名空间。也就是说,应用命名空间既可以在子`urls.py`中通过`app_name`指定,也可以在`include`函数中指定。示例代码如下:

    from django.contrib import admin
    from django.urls import path,include
    
     urlpatterns = [
         path('admin/', admin.site.urls),
         path('book/',include(("book.urls",'book')),namespace='book')
     ]
    

    但是这样做的前提是已经包含了应用命名空间。即在myapp.urls.py中添加一个和urlpatterns同级别的变量app_name。

    ⑦URL映射指定默认参数:

    使用path或者是re_path的后,在route中都可以包含参数,而有时候想指定默认的参数,这时候可以通过以下方式来完成。示例代码如下:

    from django.urls import path
    from . import views
    
    urlpatterns = [
        path('books/', views.books),
        path('books/page/<int:page>/', views.books),
    ]
    
    # views (in views.py)
    book_list = [
        '三国演义',
        '水浒传',
        '西游记',
        '红楼梦'
    ]
    def books(request, page=0): 

    当在访问books/的时候,因为没有传递page参数,所以会匹配到第一个url,这时候就执行view.books这个视图函数,而在books函数中,又有page=1这个默认参数。因此这时候就可以不用传递参数。而如果访问book_list/0的时候,因为在传递参数的时候传递了page,因此会匹配到第二个url,这时候也会执行views.books,然后把传递进来的参数传给books函数中的page。

    ⑧url反转reverse:

    之前我们都是通过url来访问视图函数。有时候我们知道这个视图函数,但是想反转回他的url。这时候就可以通过reverse来实现。示例代码如下:

    reverse("list")
    > /book/list/

    如果有应用命名空间或者有实例命名空间,那么应该在反转的时候加上命名空间。示例代码如下:

    reverse('book:list')
    > /book/list/

    如果这个url中需要传递参数,那么可以通过kwargs来传递参数。示例代码如下:

    reverse("book:detail",kwargs={"book_id":book_id})
    > /book/detail/...
    

    因为django中的reverse反转url的时候不区分GET请求和POST请求,因此不能在反转的时候添加查询字符串的参数。如果想要添加查询字符串的参数,只能手动的添加。示例代码如下:

    login_url = reverse('login') + "?next=/"

    示例代码:

    # front.veiws.py文件
    
    from django.http import HttpResponse
    from django.shortcuts import reverse,redirect
    
    def index(request):
        username = request.GET.get('username')
        if username:
            return HttpResponse("首页")
        else:
            # login_url = reverse('login')  # 反转
            # return redirect(login_url)  # 跳转
    
            # return redirect(reverse('login'))
    
            # kwargs:keyword arguments关键字参数
            return redirect(reverse('detail',kwargs={'article_id:1'}))
    
            # 如果碰见/login/?next=xxx,只能手动添加。
            # return redirect(reverse('login') + '?next=/')
    
    def login(request):
        return HttpResponse('登录页面')
    
    def article_detail(request,article_id):
        text = '您的文章id是:%s' % article_id
        return HttpResponse(text)
    
    
    # urls.py文件
    
    from django.urls import path
    from front import views
    
    urlpatterns = [
        path('',views.index,name = 'index'),
        path('login/',views.login,name = 'login'),
        path('detail/<article_id>',views.article_detail,name = 'detail'),
    ]
    front.veiws.py文件+urls.py文件

    ⑨自定义URL(PATH)转换器:

    之前已经学到过一些django内置的url转换器(python内置转换器见2.4),包括有int、uuid等。有时候这些内置的url转换器并不能满足我们的需求,因此django给我们提供了一个接口可以让我们自己定义自己的url转换器。

    自定义url转换器按照以下五个步骤来走就可以了:

    ①定义一个类,直接继承自object就可以了。
    ②在类中定义一个属性regex,这个属性是用来限制url转换器规则的正则表达式。
    ③实现to_python(self,value)方法,这个方法是将url中的值转换一下,然后传给视图函数的。
    ④实现to_url(self,value)方法,这个方法是在做url反转的时候,将传进来的参数转换后拼接成一个正确的url。
    ⑤ 将定义好的转换器,使用`django.urls.converters.register_converter`方法注册到django中。

    比如写一个匹配四个数字年份的url转换器。示例代码如下:

    # article.converters.py文件
    
    from django.urls import converters,register_converter
    
    # 建立转换规则
    class CateforyConverter(object):
        regex = r'w+|(w++w+)+'
    
        def to_python(self,value):
            # python+django+flask  →
            # ['python', 'django', 'flask']
            result = value.split('+')
            return result
    
        def to_url(self,value):
            # ['python', 'django', 'flask']  →
            # python+django+flask
            if isinstance(value,list):
                result = '+'.join(value)
                return result
            else:
                raise RuntimeError('转换url的时候,分类必须为列表!')
    
    register_converter(CateforyConverter,'cate')  # 进行注册

    其他相关文件:

    # article.urls.py 文件
    
    from django.urls import re_path,path
    from . import views
    
    urlpatterns = [
        path('',views.article),
        # w:0-9,a-z,A-Z,_
        # +:表示普通的加号,一个斜杠一个加。转义成普通加号。
        # +:表示前面字符一个或者多个
    
        # re_path(r'list/(?P<categories>w+|(w++w+)+)',views.article_list),
        path('list/<cate:categories>/',views.article_list,name = 'list'),
    
        path('detail/<int:article_id>',views.article_detail,name = 'detail')
    ]
    
    
    # article.veiws.py 文件
    
    from django.http import HttpResponse
    from django.shortcuts import reverse
    
    def article(request):
        return HttpResponse('文章首页')
    
    def article_list(request,categories):
        print(type(categories))  # 显示为列表类型
        print('categories:%s' %categories)
        print(reverse('list',kwargs={'categories':categories}))
        text = '您填写的分类为:%s' % categories
        return HttpResponse(text)
    
    def article_detail(request,article_id):
        reverse('detail',kwargs={'article_id':article_id})
        print(type(article_id))
        return HttpResponse('文章详情')
    
    # urls.py文件
    
    from django.urls import path,include
    
    urlpatterns = [
        path('article/',include('article.urls'))
    ]
    article.urls.py & article.veiws.py & urls.py

    所展示示例需求:

    ## 需求:
    实现一个获取文章列表的demo,用户可以根据`/articles/文章分类/`的方式来获取文章。其中文章分类采用的是`分类1+分类2+分类3...`的方式拼接的,并且如果只有一个分类,那就不需要加号。示例如下:
    ```
    # 1. 第一种:获取python分类下的文章
    /articles/python/
    # 2. 第二种:获取python和django分类下的文章
    /articles/python+django/
    # 3. 第三种:获取python和django和flask分类下的文章
    /articles/python+django+flask/
    以此类推...
    ```
    
    在“文章分类”参数传到视图函数之前要把这些分类分开来存储到列表中。
    比如参数是`python+django`,那么传到视图函数的时候就要变成`['python','django']`。
    
    以后在使用reverse反转的时候,限制传递“文章分类”的参数应该是一个列表,并且要将这个列表变成`python+django`的形式。
    展示示例需求

     同时需要在__init__文件中导入converters.py文件,使得converters.py载入运行

    from . import converters
    

      

    若需转载,请下方评论区或者私信联系笔者。 ---Qiuma

  • 相关阅读:
    C# 不用添加WebService引用,调用WebService方法
    贪心 & 动态规划
    trie树 讲解 (转载)
    poj 2151 Check the difficulty of problems (检查问题的难度)
    poj 2513 Colored Sticks 彩色棒
    poj1442 Black Box 栈和优先队列
    啦啦啦
    poj 1265 Area(pick定理)
    poj 2418 Hardwood Species (trie树)
    poj 1836 Alignment 排队
  • 原文地址:https://www.cnblogs.com/wuqiuming/p/10081936.html
Copyright © 2011-2022 走看看