django(4)

发布时间：2020-12-20 10:37:43 所属栏目：Python 来源：网络整理

导读：一、render内部原理 1、render的作用：返回一个html页面；并且还能够给该页面传数据。 2、 render的内部原理 (如下几句代码) from django.template import Template,Contextdef index(request): temp = Template('h1{{ user }}/h1') con = Context({"user":

一、render内部原理

1、render的作用：返回一个html页面；并且还能够给该页面传数据。

2、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)
    print(res) # <h1>{&#39;name&#39;: &#39;hh&#39;,&#39;password&#39;: &#39;123&#39;}</h1>
    return HttpResponse(res)

补充：

# FBV，自动给后面index加（）执行
url(r'^index/',views.index),

二、FBV与CBV

FBV(基于函数的视图)————》函数

CBV(基于类的视图)————》类

首先导入模块：views视图

from django.views import View

小结论：FBV和CBV在路由匹配上是一致的都是url后面跟函数的内存地址

# CBV的URL部分
url(r'^login/',views.MyLogin.as_view()),# 括号优先级最高！！！！
# 通过源码得出：（上下等价）括号优先级最高！！！！
url(r'^login/',views.view) # FBV和CBV在路由匹配上是一致的 都是url+函数的内存地址

# CBV的view视图函数部分
class MyLogin(View):
    def get(self,request):
        return render(request,'login.html')
    def post(self,request):
        return HttpResponse("from MyLogin post方法")

# CBV的html部分
<form action="" method='post'> # post注意点：去掉中间件
    username: <input type="text" name="username">
    <input type="submit">

关于post，去掉中间件

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware','django.contrib.sessions.middleware.SessionMiddleware','django.middleware.common.CommonMiddleware',# 'django.middleware.csrf.CsrfViewMiddleware',#就是它
    'django.contrib.auth.middleware.AuthenticationMiddleware','django.contrib.messages.middleware.MessageMiddleware','django.middleware.clickjacking.XFrameOptionsMiddleware',]

疑问：get请求来就会走类里面get方法,post请求来就会走类里面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,**kwargs)  # dispatch返回什么 浏览器就会收到什么
        # 对象在查找属性或者方法的时候 你一定要默念 先从对象自己这里找  然后从产生对象的类里面找  最后类的父类依次往后
        return view

    通过源码发现url匹配关系可以变形成
    url(r'^login/',views.view)  # FBV和CBV在路由匹配上是一致的 都是url后面跟函数的内存地址
    2.当浏览器中输入login 会立刻触发view函数的运行
    def dispatch(self,request,**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,**kwargs)  # 直接调用我们自己的写类里面的get方法
            # 源码中先通过判断请求方式是否符合默认的八个请求方法 然后通过反射获取到自定义类中的对应的方法执行

三、django settings源码

项目通常都会有两个配置文件：一个是暴露给用户可以配置的；一个是项目默认的配置。

3.1特点:当用户配置了就使用用户的，当用户没有配就使用项目默认的

3.2文件位置：

1.django中暴露给用户的配置默认就与项目同名的文件夹中

2.django项目内部默认的配置文件
from django.conf import global_settings

3.1疑问：为什么APPEND_SLASH=False必须使用大写，小写无效

前提:

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

3.4通常我们在django中使用配置文件一般都是按照一-下方式导入的

from django. conf import settings

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对象设置键值对
                    # 给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_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()  # 单例模式

参考settings源码写示例（必须得知道！）：

四、模板层

4.1html模板语法的分类：

1.{{}}  变量相关；在html页面中获取后端的值
2.{%%}  逻辑相关

4.2render为页面传值的两种写法。

render能返回一个html页面并为页面传数据。下面是传值的两种写法。

#1字典传输法
return render(request,'reg.html',{'n':n,'f':f})# 通过字典的键值对 指名道姓的一个个的传。如果这个函数数据特别多，一个一个k,v键值对的写，很累！

#2等价写法locals()
return render(request,locals())#Locals（），将所有函数内的名字全放到名称空间内了。该方法虽然好用 但是在某些情况下回造成资源的浪费

4.3模板层支持的数据类型（特例）

总结：

1python所有的数据类型都可以被传递到前端页面

2注意在传递函数的时候会自动加括号调用前端展示的是函数调用的之后的返回值
(ps:前端在调用函数的时候是不支持给函数传递额外参数的)
如果你想在前端获取后端传递的某个容器类型中的具体元素
那么你可以通过句点符来获取具体的元素
1. 索引
2.键

? 4.3.1传入的是对象:

<p>{{ obj }}</p> #显示对象的内存地址

#此时能在浏览器页面显示对象的属性值
<p>{{ obj.get_self }}</p>
<p>{{ obj.get_cls }}</p>
<p>{{ obj.get_static }}</p>

? 4.3.2传入的是函数

? 注意：django的模板语法不支持给函数传参!!!

1传函数名,会自动加括号调用该函数,前端展示的是函数调用之后的返回值:{{ index }};
2django的模板语法 不支持给函数传参!!!
3无返回值则页面显示None

? 4.3.3传入时间：可以显示时间

from datetime import 
datetimectime = datetime.now()

# 默认显示的时间格式
Sept. 18,2019,7:53 p.m.# 可通过|date过滤器显示不同格式的时间

4.4过滤器:|

length、default、filesizeformat、truncatewords

<h1>模板语法之标签:内部原理(会将|前面的当做第一个参数传入标签中)</h1>
# length
<p>{{ l|length }}</p>
<p>{{ n|length }}</p>
# default
<p>{{ ss|default:'当|左边的变量的值为空就会返回|右边的值' }}  default跟你后端get方法很想</p>
<p>{{ ss|default:'' }} default必须要有两个参数</p>
# filesizeformat 会将文件大小转换成MB
<p>{{ file_size|filesizeformat }}</p>
# truncatewords：6按照空格切分
<p>{{ info|truncatewords:3 }} #就是按空格截取  三个点不算</p>
# 按照字符切分三个点也算，也就意味着后面的数字起码得大于3
<p>{{ info1|truncatechars:6 }}</p>
# |date：2019-09-18
<p>{{ ctime|date:'Y-m-d' }} 只需要掌握年月日就可以了</p>#结果2019-09-18
# |add 拼接数字或字符串
<p>{{ s|add:'哈哈哈' }}</p>
# |slice 列表切片
<p>{{ l|slice:'0:3' }}</p># [1,2,3]
<p>{{ l|slice:'0:5:2' }}</p># [1,3,5]

4.5模板语法预防脚本攻击

在浏览器显示的时候，不识别语法！下面内容告诉你如何展示语法！

后端代码
yyy = '<script>alert(123)</script>'

前端代码
<p>{{ yyy }}</p>
# 在浏览器显示的时候，不识别语法！

前后端取消转义：前后端取消转义：|safe，将标签含义显示出来

? 前端转义：|safe

<p>{{ xxx|safe }}</p>

? 后端转义:需要导入模块

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

结论：

前后端取消转义:
    也及意味着前端的html代码 并不单单只能在html文件中书写
    你也可以在后端先生成html代码 然后直接传递给前端(******)

补充：

1.类的三种绑定方法

class Demo(object):
    def get_self(self):
        return '绑定给对象的方法'
    @classmethod
    def get_cls(cls):
        return '绑定给类的方法'
    @staticmethod
    def get_static():
        return '我是静态方法  其实就是函数'
    
    {#<p>{{ n }}</p>#}  <p>{{ n }}</p>

2.html前端页面的注释

{##}

标签：{%%} 逻辑相关

1for循环

# 将l列表中的每个值取出来
{% for foo in l %}   
<p>{{ foo }}</p>
{% endfor %}

{% for foo in l %}
    <p>{{ forloop }}</p>
{% endfor %}

2if判断

{% if xxx %}
if条件成立
{% elif xxx %}
elif条件成立
{% else %}
上面两者都不成立
{% endif %}

3.for循环+嵌套if判断

{% for %}
{{ forloop }}
{{ forloop.first }}
{{ forloop.last }}
{{ forloop.counter0 }}
{{ forloop.counter }}  数据库中的数据它的主键值 不可能是依次递增的  有可能被你删除了几条数据  主键值就不再连续的了
{% empty %}
当for循环对象不能被for循环的时候会走empty逻辑
{% endfor %}

for循环if嵌套案例

# 嵌套if判断
{% for foo in l %}
    {% if forloop.first %}
        {% elif forloop.last %}
        {% else %}
    {% endif %}
    {% empty %}
    <p>当for循环的对象为空的时候 会走empty</p>
{% endfor %}

刚开始没看懂：解读一下

loop判断当前循环是否是第一次或者最后一次

4with：django取值使用点语法取出列表中的值

l = [1,4,5,6,[12,{'name':'heiheihei'}]]
<p>
    django模板语法在取值的时候 统一使用句点符(大白话就是 点号   .)
    {% with l.6.3.name as ttt %}  可以给一个比较复杂的取值操作取一个别名 之后在with语句中 就可以使用该别名
        {{ ttt }}
        {{ l.6.3.name }}
    {% endwith %}
</p>

5for循环+字典取值

{#d = {"name":'jason','password':123}#}
{% 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.自定义固定的三步走战略:

1.必须在你的应用下新建一个名为templatetags文件夹
2.在该文件夹内新建一个任意名称的py文件
3.在该py文件中固定先写下面两句代码
from  django import template
register = template.Library()

2.自定义过滤器

# mytag页面
@register.filter(name='baby')
def mysum(a,b)：
    retunr a + b
# html页面
{% load mytag %}
{{ 123|baby:1}} #结果为124

2.自定义标签(支持传多个值)

语法：

# mytag页面
@register.simple_tag(name='jason')
def myplus(a,b,c,d,e):
    return None
# html页面
{% load mytag %}
{% jason 1 2 3 year=2 %}

案例

@register.simple_tag(name='jason')
def xxx(a,year):
    return '%s?%s|%s{%s'%(a,year)

{% load mytag %}
{% jason 1 2 3 year=2 %}
#结果：1?2|3{2

3.自定义inclusion_tag

当你的页面上有一部分html代码需要经常被各个地方使用，并且需要传参才能渲染出，那么你可以把该html代码部分制作成一个inclusion_tag，以便在任何页面都能使用

语法：@register.inclusion_tag(‘html页面的名字‘)

# mytag页面
@register.inclusion_tag('bigplus.html')
def mytag(n):
    ...
    # return {'l':l} # 两种return的方式！
    return locals()

# 访问的页面
{% load mytag %}
{% bigplus 5 %}
# bigplus.html
<ul>
    {% for foo in l %}
        <li>{{ foo }}</li>
    {% endfor %}
</ul>

注意两个return的方式

# 示例
@register.inclusion_tag('bigplus.html')
def bigplus(n):
    l = []
    for i in range(n):
        l.append('第%s项'%i)
    return {'l':l}
    # 或者
    return locals()

{% load mytag %}
{% bigplus 5 %}

<br>
{% bigplus 10 %}

四、模板继承（比模板导入用的多）

通过block语法给模板打上铆钉，然后其他页面继承过程，再在铆钉内写自己的内容

前言

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

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

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

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

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

继承

在其他页面通过“extend”关键字来继承母版。

全部继承过来！！

{% extends 'home.html' %}
#将home页面 继承过来#

修改

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

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

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

重复调用模板的内容：{{ block.super }}

{{ block.super }}

    {% include 'beautiful.html' %}

    <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>
    {{ block.super }}
    {{ block.super }}
    {{ block.super }}

五、模板导入

{% include ‘你想要导入的html文件名‘ %}

这个使用评率没有上面那个高，也是导入，它只在子html页面内找好位置直接使用即可

模型层单表的增删改查（重要）

单表操作的增删改查

关键性的参数：

1.auto_now ; 操作数据，刷新操作时间

auto_now_add；记录创建时间
链接数据库：直接两条命令

新建test.py文件：这样就不用使用网页测试了，直接在py文件中测试！

# test内的内容
import os
import sys

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

    import django
    django.setup()
    from app01 import models
    models.Book.objects.all()

增

增的两种方式：

# 增
# 方式1： create
book_obj  = models.Book.objects.create(title='三国',price=19.99,create_time='2019-11-11')
print(book_obj.title)

# 方式2：对象点save()方法。save方法效率极低！
from datetime import datetime
ctime = datetime.now()
book_obj = models.Book(title='jpm',price=96.66,create_time=ctime)
book_obj.save()

查

PK代替主键值:pk会自动查找到当前数据的主键字段

# 三张查找方法
print(models.Book.objects.all())
# 查询出来的结果是queryset对象

#<QuerySet [<Book: 三国演义>,<Book: jmp>,<Book: 西游记P>,<Book: 水浒传>,<Book: 三国演义>,<Book: 围城>,<Book: 床下有人>,<Book: 床下有人2>,<Book: 床下有人3>,<Book:jpm2>]>#


print(models.Book.objects.get(id=1)) # 不要轻易使用get
print(models.Book.objects.filter(pk=1))# pk会自动查找到当前数据的主键字段

改

# 1.update
models.Book.objects.filter(pk=1).update(title='三国演义')
# 2.对象.save()
book_obj = models.Book.objects.get(pk=1)
book_obj.price = 666.66
book_obj.save()

删

models.Book.objects.filter(pk=2).delete()

神奇的双下滑线方法

PK：自动找出主键。

value（值1，值2 ）。取出来的没有“ID”！

（12）用的不是很多。

# < 1 > all(): 查询所有结果

    # < 2 > filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
    # < 3 > get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。（源码就去搂一眼～诠释为何只能是一个对象）
    # < 4 > exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
    # print(models.Book.objects.exclude(pk=1))  # 只要pk不是1的数据全部查询出来


    # < 5 > order_by(*field): 对查询结果排序('-id') / ('price')
    # print(models.Book.objects.order_by('price'))  # 默认是升序
    # print(models.Book.objects.order_by('-price'))  # 加负号就是降序


    # < 6 > reverse(): 对查询结果反向排序 >> > 前面要先有排序才能反向
    # print(models.Book.objects.order_by('price').reverse())

    # < 7 > count(): 返回数据库中匹配查询(QuerySet)
    # print(models.Book.objects.count())  # 对查询出来的结果进行一个计数


    # 的对象数量。
    # < 8 > first(): 返回第一条记录
    # print(models.Book.objects.filter(pk=1).first())
    # < 9 > last(): 返回最后一条记录
    # print(models.Book.objects.all())
    # print(models.Book.objects.all().last())
    
    
    #10是最没用用的
    # < 10 > exists(): 如果QuerySet包含数据，就返回True，否则返回False
    # print(models.Book.objects.filter(pk=1000))
    # print(models.Book.objects.filter(pk=1000).exists())


    # < 11 > values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列
    # print(models.Book.objects.values('title','price'))  # 得到的结果是列表套字典



    # < 12 > values_list(*field): 它与values()
    # print(models.Book.objects.values_list('title','price'))  # 得到的结果是列表套元组


    # 非常相似，它返回的是一个元组序列，values返回的是一个字典序列
    # < 13 > distinct(): 从返回结果中剔除重复纪录
    """
    去重的前提是 一定要有完全重复的数据 才能去重
    """
    # print(models.Book.objects.filter(title='三国演义').distinct())
    # print(models.Book.objects.values('title','price','create_time').distinct())

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!