Django立项和URL的使用(二)

时间  2020-12-02
标签 python web 正则表达式 数据库 django flask 浏览器 安全 服务器 app 栏目 Python 繁體版
原文   原文链接

Django立项和URL的使用

1，第一个Django项目

1，建立Django项目

  ㈠用命令行的方式

①建立项目：打开终端，使用命令：django-admin startproject [项目名称]便可建立。好比：python

django-admin startproject first_project

②运行项目：在终端，进入到项目文件夹中，而后执行如下命令便可运行：web

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项目，新建项目的截图以下：django

　　使用pycharm建立完项目后，仍是须要从新进入到命令行单首创建app的。flask

　　建立app：在cmd中进入项目文件夹，并处于虚拟环境，执行如下代码浏览器

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

②运行Django项目：安全

　　1，经过pycharm运行。直接点击右上角的绿色箭头按钮便可运行。服务器

　　2，修改端口号：右上角→项目配置→port。更改端口号，从新运行。app

　　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的关系

　　app是django项目的组成部分。一个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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程