【python之django1.11框架三】路由层，视图层，模板层的介绍

1. 路由层

# 路由匹配
url(r'test',views.test),
url(r'testadd',views.testadd)
"""
url方法第一个参数是正则表达式
	只要第一个参数正则表达式能够匹配到内容 那么就会立刻停止往下匹配
	直接执行对应的视图函数

在输入url的时候会默认加斜杠
	django内部帮你做到重定向
		一次匹配不行
		url后面加斜杠再来一次
"""
# 取消自动加斜杠（setting.py文件中新增以下配置）
APPEND_SLASH = False/True	# 默认是自动加斜杠的（默认为True）

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    # 首页
    url(r'^$',views.home),
    # 路由匹配
    url(r'^test/$',views.test),
    url(r'^testadd/$',views.testadd),
    # 尾页(了解)
    url(r'',views.error),
]

1. 无名分组

"""
分组:就是给某一段正则表达式用小括号扩起来
"""
url(r'^test/(\d+)/',views.test)

def test(request,xx):
    print(xx)
    return HttpResponse('test')
  
# 无名分组就是将括号内正则表达式匹配到的内容当作位置参数传递给后面的视图函数

2. 有名分组

"""
可以给正则表达式起一个别名
"""
url(r'^testadd/(?P<year>\d+)',views.testadd)

def testadd(request,year):
    print(year)
    return HttpResponse('testadd')

# 有名分组就是将括号内正则表达式匹配到的内容当作关键字参数传递给后面的视图函数

3. 无名有名是否可以混合使用？

"""
不能混用
但是同一个分组可以使用N多次
"""

# 单个的分组可以使用多次
url(r'^index/(\d+)/(\d+)/(\d+)/',views.index),
url(r'^index/(?P<year>\d+)/(?P<age>\d+)/(?P<month>\d+)/',views.index),

def index(request,*args,**kwargs):
    print(args)
    print(kwargs)
    return HttpResponse('index')

4. 反向解析

# 通过一些方法得到一个结果 该结果可以直接访问对应的url，从而触发视图函数

# 1. 先给路由与视图函数起一个别名。（别名不能冲突，需要唯一）
url(r'^func_kkk/', views.func, name='ooo')

# 反向解析
# 2.后端反向解析
from django.shortcuts import reverse

reverse('ooo') # 在视图函数中可以获取url  /func_kkk/
# 3.前端反向解析
<a href="{% url 'ooo' %}">111</a>

5. 无名有名分组反向解析

# 无名分组反向解析
	url(r'^index/(\d+)/',views.index,name='xxx')

# 前端
	{% url 'xxx' 123 %}
# 后端
	reverse('xxx', args=(1,)) # 不带参数会报错  /index/1/

# 案例：
def edit(request,edit_id):
	reverse('xxx',args=(edit_id,))
	
{%for user_obj in user_queryset%}
	<a href="{% url 'xxx' user_obj.id %}">编辑</a>
{%endfor%}

• 有名分组反向解析

   url(r'^func/(?P<year>\d+)/',views.func,name='ooo')
# 前端
	<a href="{% url 'ooo' year=123 %}">111</a>  了解
	<a href="{% url 'ooo' 123 %}">222</a>  	常用

# 后端	
	 # 有名分组反向解析 写法1  了解
   print(reverse('ooo', kwargs={'year':123})) # /func/123/
   # 简便的写法  跟无名分组一样的操作即可
   print(reverse('ooo',args=(111,)))  # /func/111/

6. 路由分发

"""
django的每一个应用都可以有自己的templates文件夹 urls.py static文件夹

利用路由分发之后 总路由不再干路由与视图函数的直接对应关系
而是做一个分发处理
	识别当前url是属于哪个应用下的 直接分发给对应的应用去处理
"""

# 总路由
from django.conf.urls import url, include

from app01 import urls as app01_urls
from app02 import urls as app02_urls
urlpatterns = [
    # 1.路由分发
    url(r'^app01/',include(app01_urls)),  # 只要url前缀是app01开头 全部交给app01处理
    url(r'^app02/',include(app02_urls))   # 只要url前缀是app02开头 全部交给app02处理
  
    # 2.终极写法  推荐使用
    url(r'^app01/',include('app01.urls')),
    url(r'^app02/',include('app02.urls'))
    # 注意事项:总路由里面的url千万不能加$结尾
]

# 子路由
# app01 urls.py
from django.conf.urls import url
from app01 import views

urlpatterns = [
    url(r'^reg/',views.reg)
]
# app02 urls.py
from django.conf.urls import url
from app02 import views

urlpatterns = [
    url(r'^reg/',views.reg)
]

7. 名称空间

# 当多个应用出现了相同的别名 我们研究反向解析会不会自动识别应用前缀
"""
正常情况下的反向解析是没有办法自动识别前缀的
"""

# 名称空间
	# 总路由
    url(r'^app01/',include('app01.urls',namespace='app01')),
    url(r'^app02/',include('app02.urls',namespace='app02'))
  # 解析的时候
  	# app01
  	urlpatterns = [
    url(r'^reg/',views.reg,name='reg')
		]
    # app02
    urlpatterns = [
    url(r'^reg/',views.reg,name='reg')
		]
    
  	reverse('app01:reg')
    reverse('app02:reg')
    
    {% url 'app01:reg' %}
    {% url 'app02:reg' %}
# 其实只要保证名字不冲突 就没有必要使用名称空间！！
"""
一般情况下 有多个app的时候我们在起别名的时候会加上app的前缀
这样的话就能够确保多个app之间名字不冲突的问题
"""
urlpatterns = [
    url(r'^reg/',views.reg,name='app01_reg')
]
urlpatterns = [
    url(r'^reg/',views.reg,name='app02_reg')
]

2. django版本区别

"""
1.django1.X路由层使用的是url方法
	而在django2.X和3.X版本中路由层使用的是path方法
	url()第一个参数支持正则
	path()第一个参数是不支持正则的 写什么就匹配什么
	
	如果习惯使用path那么也给你提供了另外一个方法
		from django.urls import path, re_path
		from django.conf.urls import url
		
		re_path(r'^index/',index),
    	url(r'^login/',login) # 如果非要写url，则这样导入。但不推荐
  2.X和3.X里面的re_path就等价于1.X里面的url
 
2.虽然path不支持正则 但是它的内部支持五种转换器
	path('index/<int:id>/',index)
	# 将第二个路由里面的内容先转成整型然后以关键字的形式传递给后面的视图函数

	def index(request,id):
    print(id,type(id))
    return HttpResponse('index')
    
  # 5个转换器
  1. str,匹配除了路径分隔符（/）之外的非空字符串，这是默认的形式
  2. int,匹配正整数，包含0。
  3. slug,匹配字母、数字以及横杠、下划线组成的字符串。
  4. uuid,匹配格式化的uuid，如 075194d3-6885-417e-a8a8-6c931e272f00。
  5. path,匹配任何非空字符串，包含了路径分隔符（/）（不能用？）
	
3.除了有默认的五个转换器之外 还支持自定义转换器(了解)
class MonthConverter:
    regex='\d{2}' # 属性名必须为regex

    def to_python(self, value):
        return int(value)

    def to_url(self, value):
        return value # 匹配的regex是两个数字，返回的结果也必须是两个数字
	
	# 使用方法
	from django.urls import path,register_converter
	from app01.path_converts import MonthConverter

	# 先注册转换器
	register_converter(MonthConverter,'mon')

	from app01 import views

	urlpatterns = [
      path('articles/<int:year>/<mon:month>/<slug:other>/', 	views.article_detail, name='aaa'),
    ]


4.模型层里面1.X外键默认都是级联更新删除的
但是到了2.X和3.X中需要你自己手动配置参数
	models.ForeignKey(to='Publish') # 1.x
	models.ForeignKey(to='Publish',on_delete=models.CASCADE...) # 2.x和3.x
"""

3. 视图层

1. JsonResponse对象

import json
from django.http import JsonResponse
def ab_json(request):
    user_dict = {'username':'haha的世界','pwd':'123'}

    # 先转成json格式字符串
    # json_str = json.dumps(user_dict,ensure_ascii=False)
    # 将该字符串返回
    # return HttpResponse(json_str)
    
    # 直接返回的方式
    return JsonResponse(user_dict, json_dumps_params={'ensure_ascii':False}) # 不进行ascii编码
    
    # Error: In order to allow non-dict objects to be serialized set the safe parameter to False.
    # l = [111,222,333,444,555]
    # return JsonResponse(l,safe=False)  
    # 默认只能序列化字典 序列化其他需要加safe参数	

2. form表单上传文件及后端如何操作

"""
form表单上传文件类型的数据
	1.method必须指定成post
	2.enctype必须换成formdata
"""
def ab_file(request):
    if request.method == 'POST':
        # print(request.POST)  # 只能获取普通的简直对数据 文件不行
        print(request.FILES)  # 获取文件数据
        # <MultiValueDict: {'file': [<InMemoryUploadedFile: u=1288812541,1979816195&fm=26&gp=0.jpg (image/jpeg)>]}>
        file_obj = request.FILES.get('file')  # 文件对象
        print(file_obj.name)
        with open(file_obj.name,'wb') as f:
            for line in file_obj.chunks():  # 推荐加上chunks方法 其实跟不加是一样的都是一行行的读取
                f.write(line)

    return render(request,'form.html')

3. request对象方法

"""
request.method
request.POST
request.GET
request.FILES # 获取上传的文件

request.body  # 原生的浏览器发过来的二进制数据 
request.path 
request.path_info   # 与request.path 相同
request.get_full_path()  能过获取完整的url及问号后面的参数 
"""
    print(request.path)  # /app01/index/
    print(request.path_info)  # /app01/index/
    print(request.get_full_path())  # /app01/index/?username=jason

4. FBV与CBV

# 视图函数既可以是函数也可以是类
def index(request):
  return HttpResponse('index')

# CBV
# CBV路由 urls.py
url(r'^login/',views.MyLogin.as_view())

# views.py
from django.views import View

class MyLogin(View):
	def get(self,request):
    	return render(request,'form.html')

	def post(self,request):
    	return HttpResponse('post方法')

"""
FBV和CBV各有千秋
CBV特点
	能够直接根据请求方式的不同直接匹配到对应的方法执行
"""

4. 模板层

1. 模版语法传值

def index(request):
    # 模版语法可以传递的后端python数据类型
    n = 123
    f = 11.11
    s = '我也想奔现'
    b = True
    l = ['小红','姗姗','花花','茹茹']
    t = (111,222,333,444)
    d = {'username':'jason','age':18,'info':'这个人有点意思'}
    se = {'晶晶','洋洋','嘤嘤'}

    def func():
        print('我被执行了')
        return '你的另一半在等你'

    class MyClass(object):
        def get_self(self):
            return 'self'

        @staticmethod
        def get_func():
            return 'func'

        @classmethod
        def get_class(cls):
            return 'cls'
        
        # 对象被展示到html页面上 就类似于执行了打印操作也会触发__str__方法
        def __str__(self):
            return '到底会不会？'  
        
    obj = MyClass()

    # return render(request,'index.html',{})  # 一个个传
    return render(request,'index.html',locals())


<p>{{ n }}</p>
<p>{{ f }}</p>
<p>{{ s }}</p>
<p>{{ b }}</p>
<p>{{ l }}</p>
<p>{{ d }}</p>
<p>{{ t }}</p>
<p>{{ se }}</p>
<p>传递函数名会自动加括号调用 但是模版语法不支持给函数传额外的参数:{{ func }}</p>
<p>传类名的时候也会自动加括号调用(实例化){{ MyClass }}</p>
<p>内部能够自动判断出当前的变量名是否可以加括号调用 如果可以就会自动执行  针对的是函数名和类名</p>
<p>{{ obj }}</p>
<p>{{ obj.get_self }}</p>
<p>{{ obj.get_func }}</p>
<p>{{ obj.get_class }}</p>


# django模版语法的取值 是固定的格式 只能采用“句点符” .
<p>{{ d.username }}</p>
<p>{{ l.0 }}</p>
<p>{{ d.hobby.3.info }}</p>
# 即可以点键也可以点索引 还可以两者混用

2. 过滤器(过滤器只能最多有两个参数)

# 过滤器就类似于是模版语法内置的 内置方法

# 基本语法
{{数据|过滤器:参数}}


<h1>过滤器</h1>
<p>统计长度:{{ s|length }}</p>
<p>默认值(第一个参数布尔值是True就展示第一个参数的值否在展示冒号后面的值):{{ b|default:'啥也不是' }}</p>
<p>文件大小:{{ file_size|filesizeformat }}</p>
<p>日期格式化:{{ current_time|date:'Y-m-d H:i:s' }}</p>
<p>切片操作(支持步长):{{ l|slice:'0:4:2' }}</p>
<p>切取字符(包含三个点):{{ info|truncatechars:9 }}</p>
<p>切取单词(不包含三个点 按照空格切):{{ egl|truncatewords:9 }}</p>
<p>切取单词(不包含三个点 按照空格切):{{ info|truncatewords:9 }}</p>
<p>移除特定的字符:{{ msg|cut:' ' }}</p>
<p>拼接操作:{{ l|join:'$' }}</p>
<p>拼接操作(数值加法):{{ n|add:10 }}</p>
<p>拼接操作(字符串拼接):{{ s|add:msg }}</p>
<p>转义:{{ hhh|safe }}</p>
<p>转义:{{ res }}</p> # 通过后端转义，前端直接显示

# 转义
# 前端 用过滤器
	|safe
# 后端 使用模块
from django.utils.safestring import mark_safe
res = mark_safe('<h1>新新</h1>')

3. 标签

# for循环
{% for foo in l %}
   <p>{{ forloop }}</p> # 内置变量
   <p>{{ foo }}</p>  # 一个个元素
{% endfor %}
{'parentloop': {}, 'counter0': 0, 'counter': 1, 'revcounter': 6, 'revcounter0': 5, 'first': True, 'last': False}

# if判断
{% if b %}
    <p>baby</p>
{% elif s %}
    <p>都来把</p>
{% else %}
    <p>老baby</p>
{% endif %}


# for与if混合使用
{% for foo in lll %}
    {% if forloop.first %}
        <p>这是第一次</p>
    {% elif forloop.last %}
        <p>这是最后一次啊</p>
    {% else %}
        <p>{{ foo }}</p>
    {% endif %}
    {% empty %}
        <p>for循环的可迭代对象内部没有元素 根本没法循环</p>
{% endfor %}

# 处理字典其他方法
{% for foo in d.keys %}
    <p>{{ foo }}</p>
{% endfor %}
{% for foo in d.values %}
    <p>{{ foo }}</p>
{% endfor %}
{% for foo in d.items %}
    <p>{{ foo }}</p> # 元组
{% endfor %}


# with起别名
{% with d.hobby.3.info as nb  %}
    <p>{{ nb }}</p>
    在with语法内就可以通过as后面的别名快速的使用到前面非常复杂获取数据的方式
    <p>{{ d.hobby.3.info }}</p>
{% endwith %}

4. 自定义过滤器、标签、inclusion_tag

"""
三步走
	1.在应用下创建一个名字“必须”叫templatetags文件夹
	2.在该文件夹内创建“任意”名称的py文件 eg:mytag.py
	3.在该py文件内"必须"先书写下面两句话(单词一个都不能错)
		from django import template
		
		register = template.Library()
"""

# 自定义过滤器，最多两个参数
from django import template
		
register = template.Library()
		
@register.filter(name='baby')
def my_sum(v1, v2):
    return v1 + v2
# 使用
{% load mytag %}
<p>{{ n|baby:666 }}</p>


# 自定义标签(参数可以有多个)			类似于自定义函数
@register.simple_tag(name='plus')
def index(a,b,c,d):
    return '%s-%s-%s-%s'%(a,b,c,d)
# 使用
标签多个参数彼此之间空格隔开
<p>{% plus 'jason' 123 123 123 %}</p>


# 自定义inclusion_tag
"""
内部原理
	先定义一个方法 
	在页面上调用该方法 并且可以传值
	该方法会生成一些数据然后传递给一个html页面
	之后将渲染好的结果放到调用的位置
"""
@register.inclusion_tag('left_menu.html')
def left(n):
    data = ['第{}项'.format(i) for i in range(n)]
    # 第一种 
    # return {'data':data}  # 将data传递给left_menu.html
    # 第二种
    return locals()  # 将data传递给left_menu.html
  
{% left 5 %}

# left_menu.html
<ul>
    {% for foo in data %}
        <li>{{ foo }}</li>
    {% endfor %}
</ul>

# 总结:当html页面某一个地方的页面需要传参数才能够动态的渲染出来，并且在多个页面上都需要使用到该局部 那么就考虑将该局部页面做成inclusion_tag形式 （类似 组件）

5. 模版的继承

"""
页面整体都相同 只是某一些局部在做变化	
"""
# 模版的继承 继承的模版页面
{% extends 'home.html' %}

# 继承了之后子页面跟模版页面长的是一模一样的 你需要在模版页面上提前划定可以被修改的区域
{% block content %}
	模版内容
{% endblock %}

# 子页面就可以声明想要修改哪块划定了的区域
{% block content %}
	子页面内容	
{% endblock %}


# 一般情况下模版页面上应该至少有三块可以被修改的区域
1.css区域
2.html区域
3.js区域
{% block css %}

{% endblock %}
  
{% block content %}

{% endblock %}
  
{% block js %}

{% endblock %}
# 每一个子页面就都可以有自己独有的css代码 html代码 js代码

6. 模版的导入

"""
将页面的某一个局部当成模块的形式
哪个地方需要就可以直接导入使用即可
"""
{% include 'wasai.html' %}