一.Django中内部源码

1.render内部原理

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

render内部原理

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

2.FBV与CBV

视图函数层不只是只有函数,也可以是类

FBV(基于函数的视图):面向函数式编程

CBV(基于类的视图):面向对象式编程

现在写一个CBV的小例子

视图函数层生成一个类

views层

from django.views import View
class Login(View):
    def get(self,request):
        return render(request,'login.html')
    def post(self,request):
        return HttpResponse('收到了')

urls中编写对应的视图函数对应关系

urls层

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

当我们访问get请求就会走类的get方法,post请求就会走类里面的post方法,为什么????

首先我们从url中的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返回什么 浏览器就会收到什么
        view.view_class = cls
        view.view_initkwargs = initkwargs
        update_wrapper(view, cls.dispatch, assigned=())
        return view  # 该函数返回了函数名view

进as_view源码发现最后返回了一个函数名view

url(r'^login/', views.Login.as_view()) >>> url(r'^login/', views.Login.view)  # 这个对应关系就可以相当于view函数名

再次研究as_view中view函数

这个函数返回了一个对象的方法dispatch

我们再进入dispatch的源码查看

def dispatch(self, request, *args, **kwargs):
    # 我们先以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方法
# 源码中先通过判断请求方式是否符合默认的八个请求方法 然后通过反射获取到自定义类中的对应的方法执行

http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']

dispatch函数如果传入的是get方法,最后返回的就是get(request,*args,**kwargs),这就解释了为什么传入什么请求就能实现对应的方法

3.Django的settings内部源码

问题:在settings.py中的配置都是大写,一旦小写就不会有效果

研究前提:

1.django除了暴露给用户一个settings.py配置文件之外 自己内部还有一个全局的配置文件
2.我们在使用配置文件的时候 可以直接直接导入暴露给用户的settings.py也可以使用django全局的配置文件 并且后者居多
　　from django.conf import settings
3.django的启动入口是manage.py

进入settings源码

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()  # 单例模式

在启动Django时我们在manage.py中传入了参数

if __name__ == "__main__":
    # django在启动的时候 就会往全局的大字典中设置一个键值对  值是暴露给用户的配置文件的路径字符串
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day54.settings")

LazySettings最后是Settings对象加括号传参调用,我们进入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对象设置键值对
                # 给settings对象设置键值对  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'
                用户如果配置了就用用户的
                用户如果没有配置就用系统默认的
                其实本质就是利用字典的键存在就是替换的原理 实现了用户配置就用用户的用户没配置就用默认的
                """

在Settings类中先将全局设置(global_settings)中的大写设置全都添加到Settings对象

再把暴露给用户settings.py的大写设置添加给Settings对象

这时,用户如果配置了就用用户的,没有配置就用默认的,本质就是利用了字典的两次设置值会替换之前的值的原理

作业:参考django settings源码实现自己的项目也能够做到用户配置了就用用户的用户没有配置就用全局的

写在了另一个博客中

二.Django中的模板层(templates文件夹)

1.模板层中的模板语法

# 分为两大类
    1. {{ }} 存放的是变量相关
    2.{% %} 存放的逻辑相关

2.为模板传值

模板传值

def reg(request):
    i = 123
    f = 5.56
    s = '哈哈哈'
    l = [1,2,5,6,8,5]
    d = {'name':'sxc','age':18}
    t = (1,5,56,486,8)
    se = {5,566,86,86,5}

    def func():
        return 'func函数'

    class Demo():
        def get_obj(self):
            return '对象绑定方法'
        @classmethod
        def get_cls(cls):
            return '类绑定方法'
        @staticmethod
        def get_static():
            return '非绑定方法'
    obj = Demo()

    # 传值的方式有两种
    # 方式1,以字典的形式
    # return render(request,'reg.html',{'i',i})
    # 方式2,直接写locals(),会将所有的变量名都传入,浪费资源
    return render(request,'reg.html',locals())

view传递的值

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script>
</head>
<body>
<p>{{ i}}</p>
<p>{{ f }}</p>
<p>{{ s }}</p>
<p>{{ l }}</p>
<p>{{ d }}</p>
<p>{{ t }}</p>
<p>{{ se}}</p>
<p>{{ func }}</p>
<p>{{ obj.get_obj }}</p>
<p>{{ obj.get_cls }}</p>
<p>{{ obj.get_static }}</p>
</body>
</html>

html页面接收的值

结论:

　　基本数据类型都能传入

　　无参函数也能传入

　　无参的对象也能传入

　　有参函数或对象不能传值

点（.）在模板语言中有特殊的含义。当模版系统遇到点(".")，它将以这样的顺序查询：

字典查询（Dictionary lookup）
属性或方法查询（Attribute or method lookup）
数字索引查询（Numeric index lookup）

{# 取l中的第一个参数 #}
{{ l.0 }}
{# 取字典中key的值 #}
{{ d.name }}
{# 取对象的name属性 #}
{{ person_list.0.name }}
{# .操作只能调用不带参数的方法 #}
{{ person_list.0.dream }}

3.模板层的过滤器(Filtes)

在Django的模板语言中,通过使用过滤器来改变变量的显示

过滤器符号: |

过滤器语法:{{ value|filter_name:参数 }}

注意事项：

过滤器支持“链式”操作。即一个过滤器的输出作为另一个过滤器的输入。
过滤器可以接受参数，例如：{{ sss|truncatewords:30 }}，这将显示sss的前30个词。
过滤器参数包含空格的话，必须用引号包裹起来。比如使用逗号和空格去连接一个列表中的元素，如：{{ list|join:', ' }}
'|'左右没有空格没有空格没有空格

Django的模板语言中提供了大约六十个内置过滤器。

default

如果一个变量是false或者为空，使用给定的默认值。否则，使用变量的值。

{{ value|default:"nothing"}}

如果value没有传值或者值为空的话就显示nothing

length

返回值的长度，作用于字符串和列表。

返回value的长度，如 value=['a', 'b', 'c', 'd']的话，就显示4.

filesizeformat

将值格式化为一个 “人类可读的” 文件尺寸（例如 '13 KB', '4.1 MB', '102 bytes', 等等）。例如：

{{ value|filesizeformat }}

如果 value 是 123456789，输出将会是 117.7 MB。

slice

切片

{{value|slice:"2:-1"}}

date

格式化

{{ value|date:"Y-m-d H:i:s"}}

可用的参数：

格式化字符	描述	示例输出
a	`'a.m.'`或`'p.m.'`（请注意，这与PHP的输出略有不同，因为这包括符合Associated Press风格的期间）	`'a.m.'`
A	`'AM'`或`'PM'`。	`'AM'`
b	月，文字，3个字母，小写。	`'jan'`
B	未实现。
c	ISO 8601格式。（注意：与其他格式化程序不同，例如“Z”，“O”或“r”，如果值为naive datetime，则“c”格式化程序不会添加时区偏移量（请参阅`datetime.tzinfo`）。	`2008-01-02T10:30:00.000123+02:00`或`2008-01-02T10:30:00.000123`如果datetime是天真的
d	月的日子，带前导零的2位数字。	`'01'`到`'31'`
D	一周中的文字，3个字母。	`“星期五”`
e	时区名称可能是任何格式，或者可能返回一个空字符串，具体取决于datetime。	`''`、`'GMT'`、`'-500'`、`'US/Eastern'`等
E	月份，特定地区的替代表示通常用于长日期表示。	`'listopada'`（对于波兰语区域，而不是`'Listopad'`）
f	时间，在12小时的小时和分钟内，如果它们为零，则分钟停留。专有扩展。	`'1'`，`'1:30'`
F	月，文，长。	`'一月'`
g	小时，12小时格式，无前导零。	`'1'`到`'12'`
G	小时，24小时格式，无前导零。	`'0'`到`'23'`
h	小时，12小时格式。	`'01'`到`'12'`
H	小时，24小时格式。	`'00'`到`'23'`
i	分钟。	`'00'`到`'59'`
I	夏令时间，无论是否生效。	`'1'`或`'0'`
j	没有前导零的月份的日子。	`'1'`到`'31'`
l	星期几，文字长。	`'星期五'`
L	布尔值是否是一个闰年。	`True`或`False`
m	月，2位数字带前导零。	`'01'`到`'12'`
M	月，文字，3个字母。	`“扬”`
n	月无前导零。	`'1'`到`'12'`
N	美联社风格的月份缩写。专有扩展。	`'Jan.'`，`'Feb.'`，`'March'`，`'May'`
o	ISO-8601周编号，对应于使用闰年的ISO-8601周数（W）。对于更常见的年份格式，请参见Y。	`'1999年'`
O	与格林威治时间的差异在几小时内。	`'+0200'`
P	时间为12小时，分钟和'a.m。'/'p.m。'，如果为零，分钟停留，特殊情况下的字符串“午夜”和“中午”。专有扩展。	`'1 am'`，`'1:30 pm' / t3>，'midnight'，'noon'，'12：30 pm' / T10>`
r	RFC 5322格式化日期。	`'Thu, 21 Dec 2000 16:01:07 +0200'`
s	秒，带前导零的2位数字。	`'00'`到`'59'`
S	一个月的英文序数后缀，2个字符。	`'st'`，`'nd'`，`'rd'`或`'th'`
t	给定月份的天数。	`28` to `31`
T	本机的时区。	`'EST'`，`'MDT'`
u	微秒。	`000000` to `999999`
U	自Unix Epoch以来的二分之一（1970年1月1日00:00:00 UTC）。
w	星期几，数字无前导零。	`'0'`（星期日）至`'6'`（星期六）
W	ISO-8601周数，周数从星期一开始。	`1`，`53`
y	年份，2位数字。	`'99'`
Y	年，4位数。	`'1999年'`
z	一年中的日子	`0`到`365`
Z	时区偏移量，单位为秒。UTC以西时区的偏移量总是为负数，对于UTC以东时，它们总是为正。	`-43200`到`43200`

safe

Django的模板中会对HTML标签和JS等语法标签进行自动转义，原因显而易见，这样是为了安全。但是有的时候我们可能不希望这些HTML元素被转义，比如我们做一个内容管理系统，后台添加的文章中是经过修饰的，这些修饰可能是通过一个类似于FCKeditor编辑加注了HTML修饰符的文本，如果自动转义的话显示的就是保护HTML标签的源文件。为了在Django中关闭HTML的自动转义有两种方式，如果是一个单独的变量我们可以通过过滤器“|safe”的方式告诉Django这段代码是安全的不必转义。

比如：

value = "<a href='#'>点我</a>"

{{ value|safe}}

truncatechars

如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“...”）结尾。

参数：截断的字符数

{{ value|truncatechars:9}}

truncatewords

在一定数量的字后截断字符串。

{{ value|truncatewords:9}}

cut

移除value中所有的与给出的变量相同的字符串

{{ value|cut:' ' }}

如果value为'i love you'，那么将输出'iloveyou'.

join

使用字符串连接列表，例如Python的str.join(list)

timesince

将日期格式设为自该日期起的时间（例如，“4天，6小时”）。

采用一个可选参数，它是一个包含用作比较点的日期的变量（不带参数，比较点为现在）。例如，如果blog_date是表示2006年6月1日午夜的日期实例，并且comment_date是2006年6月1日08:00的日期实例，则以下将返回“8小时”：

{{ blog_date|timesince:comment_date }}

分钟是所使用的最小单位，对于相对于比较点的未来的任何日期，将返回“0分钟”。

timeuntil

似于timesince，除了它测量从现在开始直到给定日期或日期时间的时间。例如，如果今天是2006年6月1日，而conference_date是保留2006年6月29日的日期实例，则{{ conference_date | timeuntil }}将返回“4周”。

使用可选参数，它是一个包含用作比较点的日期（而不是现在）的变量。如果from_date包含2006年6月22日，则以下内容将返回“1周”：

{{ conference_date|timeuntil:from_date }}

<p>{{ i|length }}返回长度,如果不能返回就返回0</p>
<p>{{ l|length }}</p>
<p>{{ ''|default:'没有值就返回我' }}有就返回前面的,没有就返回后面的</p>
<p>{{ i|filesizeformat }}返回文件的大小</p>
<p>{{ l|slice:'0:5:2' }}切片,顾头不顾尾,可以指定步长</p>
<p>{{ s|truncatechars:8 }}截断的字符数,三个点也算</p>
<p>{{ s|truncatewords:2 }}按空格截取,三个点不算</p>
<p>{{ x|safe }}可以取消转义,给前端设置格式</p>
<p>{{ z }}</p>
<p>{{ c_time|date:'Y-m-d H:i:s' }}输出时间</p>
<p>{{ i|add:10 }}数字相加</p>
<p>{{ s|add:'hhaha' }}字符串的拼接</p>

常用过滤器的使用实例

自定义过滤器filter

自定义过滤器只是带有一个或两个参数的Python函数:

变量（输入）的值 - -不一定是一个字符串
参数的值 - 这可以有一个默认值，或完全省略

例如，在过滤器{{var | foo:'bar'}}中，过滤器foo将传递变量var和参数“bar”。

自定义filter代码文件摆放位置：

app01/
    __init__.py
    models.py
    templatetags/  # 在app01下面新建一个package package
        __init__.py
        app01_filters.py  # 建一个存放自定义filter的文件
    views.py

编写自定义filter

from django import template
register = template.Library()


@register.filter(name="cut")
def cut(value, arg):
    return value.replace(arg, "")


@register.filter(name="addSB")
def add_sb(value):
    return "{} SB".format(value)

使用自定义filter

{# 先导入我们自定义filter那个文件 #}
{% load app01_filters %}

{# 使用我们自定义的filter #}
{{ somevariable|cut:"0" }}
{{ d.name|addSB }}

3.模板层的标签(tags)

for循环

普通for循环

<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% endfor %}
</ul>

for循环可用的一些参数：

Variable	Description
`forloop.counter`	当前循环的索引值（从1开始）
`forloop.counter0`	当前循环的索引值（从0开始）
`forloop.revcounter`	当前循环的倒序索引值（从1开始）
`forloop.revcounter0`	当前循环的倒序索引值（从0开始）
`forloop.first`	当前循环是不是第一次循环（布尔值）
`forloop.last`	当前循环是不是最后一次循环（布尔值）
`forloop.parentloop`	本层循环的外层循环

for ... empty

<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% empty %}%
    <li>空空如也</li>
{% endfor %}
</ul>

if判断

if,elif和else

{% if user_list %}
  用户人数：{{ user_list|length }}
{% elif black_list %}
  黑名单数：{{ black_list|length }}
{% else %}
  没有用户
{% endif %}

当然也可以只有if和else

{% if user_list|length > 5 %}
  七座豪华SUV
{% else %}
    黄包车
{% endif %}

if语句支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not判断。

with

定义一个中间变量，多用于给一个复杂的变量起别名。

注意等号左右不要加空格。

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

或

{% with business.employees.count as total %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

模板语法中的字典也有三个方法

4.自定义标签过滤器 inclusion_tag

自定义固定的三步走战略:

　　1.必须在你的应用下新建一个名为templatetags文件夹

　　2.在该文件夹内新建一个任意名称的py文件

　　3.在该py文件中固定先写下面两句代码

from django import template
register = template.Library()

from django import template

register = template.Library()

# 自定义过滤器
@register.filter(name='baby')
def index(a,b):
    # 该过滤器只做一个加法运算  是|add建议版本
    """
    |length
    |add
    |default
    |filesizeformat
    |truncatewords
    |truncatechars
    |safe
    |slice

    :param a:
    :param b:
    :return:
    """
    print('下午刚起床 一脸懵逼')
    return a + b


# 自定义标签
# 支持传多个值
@register.simple_tag(name='jason')
def xxx(a,b,c,year):
    return '%s?%s|%s{%s'%(a,b,c,year)



# 自定义inclusion_tag
"""
接收用户传入的参数  然后作用于一个html页面
在该页面上渲染数据 之后将渲染好的页面
放到用户调用inclusion_tag的地方
"""

# 自定义inclusion_tag
@register.inclusion_tag('bigplus.html')
def bigplus(n):
    l = []
    for i in range(n):
        l.append('第%s项'%i)
    return {'l':l}

simple_tag

和自定义filter类似，只不过接收更灵活的参数。

定义注册simple tag

@register.simple_tag(name="plus")
def plus(a, b, c):
    return "{} + {} + {}".format(a, b, c)

使用自定义simple tag

{% load app01_demo %}

{# simple tag #}
{% plus "1" "2" "abc" %}

inclusion_tag

多用于返回html代码片段

示例：

templatetags/my_inclusion.py

from django import template

register = template.Library()


@register.inclusion_tag('result.html')
def show_results(n):
    n = 1 if n < 1 else int(n)
    data = ["第{}项".format(i) for i in range(1, n+1)]
    return {"data": data}

templates/snippets/result.html

<ul>
  {% for choice in data %}
    <li>{{ choice }}</li>
  {% endfor %}
</ul>

templates/index.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>inclusion_tag test</title>
</head>
<body>

{% load inclusion_tag_test %}

{% show_results 10 %}
</body>
</html>

5.模板(母版)的继承

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

模板一般情况下 应该至少有三个可以被修改的区域
{% block css %}
    子页面自己的css代码
{% endblock %}


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


{% block js %}
    子页面自己的js代码
{% endblock %}

母板

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Title</title>
  {% block page-css %}
  
  {% endblock %}
</head>
<body>

<h1>这是母板的标题</h1>

{% block page-main %}

{% endblock %}
<h1>母板底部内容</h1>
{% block page-js %}

{% endblock %}
</body>
</html>

注意：我们通常会在母板中定义页面专用的CSS块和JS块，方便子页面替换。

继承母板

在子页面中在页面最上方使用下面的语法来继承母板。

{% extends 'layouts.html' %}

块（block）

通过在母板中使用{% block xxx %}来定义"块"。

在子页面中通过定义母板中的block名来对应替换母板中相应的内容。

{% block page-main %}
  <p>世情薄</p>
  <p>人情恶</p>
  <p>雨送黄昏花易落</p>
{% endblock %}

组件

可以将常用的页面内容如导航条，页尾信息等组件保存在单独的文件中，然后在需要使用的地方按如下语法导

入即可。

{% include 'navbar.html' %}

6.模板(母版)的导入

{% include 'beautiful.html' %}

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

Day54 Django功能内部源码和模版层

一.Django中内部源码

1.render内部原理

2.FBV与CBV

3.Django的settings内部源码

二.Django中的模板层(templates文件夹)

1.模板层中的模板语法

2.为模板传值

3.模板层的过滤器(Filtes)

default

length

filesizeformat

slice

date

safe

truncatechars

truncatewords

cut

join

timesince

timeuntil

自定义过滤器filter

3.模板层的标签(tags)

for循环

if判断

with

4.自定义标签过滤器 inclusion_tag

simple_tag

inclusion_tag

5.模板(母版)的继承

母板

继承母板

块（block）

组件

6.模板(母版)的导入

猜你喜欢

Day54 Django功能内部源码和模版层

一.Django中内部源码

1.render内部原理

2.FBV与CBV

3.Django的settings内部源码

二.Django中的模板层(templates文件夹)

1.模板层中的模板语法

2.为模板传值

3.模板层的过滤器(Filtes)

default

length

filesizeformat

slice

date

safe

truncatechars

truncatewords

cut

join

timesince

timeuntil

自定义过滤器filter

3.模板层的标签(tags)

for循环

if判断

with

4.自定义标签 过滤器 inclusion_tag

simple_tag

inclusion_tag

5.模板(母版)的继承

母板

继承母板

块（block）

组件

6.模板(母版)的导入

猜你喜欢

4.自定义标签过滤器 inclusion_tag