render内部原理/FBV与CBV/Django settings源码(重要)/模板层/模型层/自定义标签与过滤器inclusion_tag/模板的继承与导入

基础要点

render返回一个html页面,并且还能够给该页面传数据

render内部原理

from django.template import Template,Context
​
def index(request):
    temp = Template('<h1>{{ user }}</h1>')
    con = Context({"user":{"name":'jason',"password":'123'}})
    res = temp.render(con)
    return HttpResponse(res)

FBV与CBV

视图函数并不只是指函数 也可以是类

  • FBV(基于函数的视图) 面向函数式编程
  • CBV(基于类的视图) 面向对象式编程

问题:基于CBV的视图函数

get请求来就会走类里面get方法,post请求来就会走类里面post方法 ,为什么???

# urls.py中
url(r'^login/',views.MyLogin.as_view())
​
​
# views.py中
from django.views import View
​
class MyLogin(View):
    def get(self,request):
        print("from MyLogin get方法")
        return render(request,'login.html')
    def post(self,request):
        return HttpResponse("from MyLogin post方法")

研究方向

1.从url入手

url(r'^login/',views.MyLogin.as_view())

由于函数名加括号执行优先级最高,所以这一句话一写完会立刻执行as_view()方法

@classonlymethod
def as_view(cls, **initkwargs):  # cls就是我们自己的写的类 MyLogin
    def view(request, *args, **kwargs):
        self = cls(**initkwargs)  # 实例化产生MyLogin的对象  self = MyLogin(**ininkwargs)
        if hasattr(self, 'get') and not hasattr(self, 'head'):
            self.head = self.get
            self.request = request
            self.args = args
            self.kwargs = kwargs
            # 上面的几句话都仅仅是在给对象新增属性
            return self.dispatch(request, *args, **kwargs)  # dispatch返回什么 浏览器就会收到什么
            # 对象在查找属性或者方法的时候 你一定要默念 先从对象自己这里找  然后从产生对象的类里面找  最后类的父类依次往后
        return view

通过源码发现url匹配关系可以变形成

url(r'^login/',views.view)  # FBV和CBV在路由匹配上是一致的 都是url后面跟函数的内存地址

2.当浏览器中输入login会立刻触发view函数的运行

def dispatch(self, request, *args, **kwargs):
    '''
    源码部分
    Try to dispatch to the right method; if a method doesn't exist,
    defer to the error handler. Also defer to the error handler if the
    request method isn't on the approved list.
    '''
    # 我们先以GET为例
    if request.method.lower() in self.http_method_names:  # 判断当前请求方法是否在默认的八个方法内
        # 反射获取我们自己写的类产生的对象的属性或者方法
        # 以GET为例  
        # handler = getattr(self,'get','取不到报错的信息')
        # handler = get(request)
        handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
    else:
        handler = self.http_method_not_allowed
    return handler(request, *args, **kwargs)  # 直接调用我们自己的写类里面的get方法
    # 源码中先通过判断请求方式是否符合默认的八个请求方法 然后通过反射获取到自定义类中的对应的方法执行

Django settings源码

前提:

  • 1.django除了暴露给用户一个settings.py配置文件之外,自己内部还有一个全局的配置文件
  • 2.我们在使用配置文件的时候 可以直接直接导入暴露给用户的settings.py也可以使用django全局的配置文件,并且后者居多
from django.conf import settings
  • 3.django的启动入口是manage.py 
import os
import sys
​
if __name__ == "__main__":
    # django在启动的时候 就会往全局的大字典中设置一个键值对  值是暴露给用户的配置文件的路径字符串
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day54.settings")
​
class Settings(object):
    def __init__(self, settings_module):  # settings_module = 'day54.settings'
        # update this dict from global settings (but only for ALL_CAPS settings)
        for setting in dir(global_settings):  # django全局配置文件
            # dir获取django全局配置文件中所有的变量名
            if setting.isupper():  # 判断文件中的变量名是否是大写 如果是大写才会执行/生效
                setattr(self, setting, getattr(global_settings, setting))  # 给settings对象设置键值对
                # store the settings module in case someone later cares
        self.SETTINGS_MODULE = settings_module  # 'day54.settings'
​
        mod = importlib.import_module(self.SETTINGS_MODULE)  # mod = 模块settings(暴露给用户的配置文件)
        for setting in dir(mod):  # for循环获取暴露给用户的配置文件中所有的变量名
            if setting.isupper():  # 判断变量名是否是大写
                setting_value = getattr(mod, setting)  # 获取大写的变量名所对应的值
                setattr(self, setting, setting_value)  # 给settings对象设置键值对
"""
d = {}
d['username'] = 'jason'
d['username'] = 'egon'
用户如果配置了就用用户的
用户如果没有配置就用系统默认的
其实本质就是利用字典的键存在就是替换的原理 实现了用户配置就用用户的用户没配置就用默认的
"""
​
class LazySettings(LazyObject):
     def _setup(self, name=None):
     # os.environ你可以把它看成是一个全局的大字典
        settings_module = os.environ.get(ENVIRONMENT_VARIABLE)  # 从大字典中取值DJANGO_SETTINGS_MODULE所对应的值:day54.settings
        # settings_module = 'day54.settings'
        self._wrapped = Settings(settings_module)  # Settings('day54.settings')
​
settings = LazySettings()  # 单例模式

模板层

模板语法有两大类:

  • {{}} 变量相关
  • {%%} 逻辑相关

过滤器:

  • |
|length
|add
|default
|filesizeformat
|truncatewords
|truncatechars
|safe
|slice

前后端取消转义:

前端:

  • | safe

后端:

from django.utils.safestring import mark_safe
​
zzz = mark_safe('<h1>阿萨德搜啊第三款垃圾袋</h1>')

常用模板语法:

  • | safe
  • | filesizeformat
  • | date

标签

{% for foo in user_list%}
{{ foo }}
{{ forloop }}
{% empty %}
# 当传递给我的循环对象是个空的情况下才会走empty下面的代码块
{% endfor %}
​
{% if flag %}
flag有值
{% elif tag %}
tag有值
{% else %}
两个都没值
{% endif %}
​
# 前端模板语法for循环和if判断也可以嵌套使用
​
{% with hobby.2.1.2.1.2.3.4.3 as h%}
{{ h }}
{{ hobby.2.1.2.1.2.3.4.3 }}
{% endwith %}

for循环里面的forloop对象作用在字典上(if判断也可以)

{% 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 %}

自定义标签与过滤器inclusion_tag

必备三步走战略

  • 1.在应用下新建一个名字必须叫做templatetags文件夹
  • 2.在新建的文件夹下新建一个任意名的py文件（my_tag.py）
  • 3.在新建的py文件中固定写下面两句话
from django import template
register = template.Library()
 

# 自定义过滤器
# 该过滤器只做一个加法运算  是|add建议版本
@register.filter(name='baby')
def index(a,b):
    return a+b
​
# 自定义标签
# 支持传多个值
@register.simple_tag(name='index')
def index(a,b,c,d):
    return a+b+c+d
​
# 自定义inclusion_tag
"""
接收用户传入的参数  然后作用于一个html页面
在该页面上渲染数据 之后将渲染好的页面
放到用户调用inclusion_tag的地方
"""
@register.inclusion_tag('login.html',name='xxx')
def index(n):
    # 产生login.html小页面所需要的数据
    return {"data":data}

html中如何使用自定义的过滤器，标签，inclusion_tag

# 先加载
{% load my_tag %}
​
{{ num|baby:10 }}
​
{% index 1 2 3 4 %}
​
{% xxx 10 %}

模板的继承与导入

  • 当多个页面整体的样式都大差不差的情况下 可以设置一个模板文件
  • 在该模板文件中 使用block块划分多个预期
  • 之后子版在使用模板的时候 可以通过block块的名字 来选定到底需要修改哪一部分区域

模板一般情况下 应该至少有三个可以被修改的区域

{% block css %}
子页面自己的css代码
{% endblock %}
​
{% block content %}
子页面自己的html代码
{% endblock %}
​
{% block js %}
子页面自己的js代码
{% endblock %}

继承模板

# 模板的继承  使用方式
# 一般情况下 模板上的block越多 页面的可扩展性就越强
{% extends 'home.html' %}
​
{% block css %}
<style>
h1 {
    color: red;
}
</style>
{% endblock %}
​
​
{% block content %}
<h1>登陆页面</h1>
<form action="">
    <p>username:<input type="text" class="form-control"></p>
    <p>password:<input type="text" class="form-control"></p>
    <input type="submit" class="btn btn-danger">
</form>
{% endblock %}
​
​
{% block js %}
{% endblock %}

模板的导入

  • 当你写了一个特别好看的form表单/列表标签等
  • 可以将它当成一个模块 哪个地方需要 就直接导入使用即可
{% include 'login.html' %}

PS:

  • 一个模板中通常block块儿越多页面的可扩展性越强
  • 一般习惯性的取三块内容(css,content,js)

模型层

单表操作

create_time = models.DateField()

关键性的参数

  • 1.auto_now:每次操作数据 都会自动刷新当前操作的时间
  • 2.auto_now_add:在创建数据的时候 会自动将创建时间记录下来 后续的修改不会影响该字段

注意:

  • 在django中 你可以写一个单独测试某一个py文件的测试脚本 不需要再频繁的走web请求
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zhukaijian/p/11545086.html