day20 FORM补充

Posted wawahan

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了day20 FORM补充相关的知识，希望对你有一定的参考价值。

python-day20

1、FROM生成select标签的数据应该来源于数据库。

2、model 操作 F/Q  （组合查询）

3、model 多对多操作。

4、中间件 :在请求到达url前先会经过中间件，（比如：中间件进行缓存操作，或者黑名单）

5、缓存，django提供缓存功能

6、信号（钩子，保存数据前先执行那些类或者函数）

7、分页（待上传... ...） 

 

cookie：保存在客户端键值对

session：保存在服务器的一个key

 

 

一、form补充

class News_Type(models.Model):
    caption = models.CharField(max_length=32)
#1、国内新闻 2、国际新闻 3、宇宙新闻


class New_Text(models.Model):
    title = models.CharField(max_length=32)
    content  = models.CharField(max_length=32)
    newstype = models.ForeignKey(News_Type)

之前我们使用form生成一个select标签是用的自己写在内存中的数据。

choice = {
  (1，\'国内新闻\')  
  (2，\'国际新闻\') 
  (3，\'宇宙新闻\') 
}

以后我们就可以从数据库中获取
choice = News_Type.objects.all().value_list (\'id\',\'name\')

实例：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>AddData</title>
</head>
<body>
    <form action="/add_data/" method="POST">
        <div>
            {{ obj.name }}    <!-- 这些值都是从后端传递过来的，自动生成相应标签，对应着model中数据库表中的字段  -->
        </div>
        <div>
            {{ obj.age }}
        </div>
        <div>
            {{ obj.user_type }}
        </div>
        <input type="submit" value="提交">
    </form>
    <form action="/add_data/" method="POST">
        <div>
            {{ type.caption }}
        </div>
        <input type="submit" value="提交">
    </form>
</body>
</html>
前端
class add_Type(forms.Form):
    caption = forms.CharField(required=True, widget=forms.widgets.Input(attrs={"name":"caption","placeholder":"caption"}))
    #widget=forms.widgets.Input(attrs={"name":"caption","placeholder":"caption"} 给标签添加属性


class add_valide(forms.Form):
    name = forms.CharField(max_length=12, widget=forms.widgets.Input(attrs={"name":"name","placeholder":"name"}))
    age = forms.IntegerField(widget=forms.widgets.Input(attrs={"name":"age","placeholder":"age"}))
    choise = model.User_Type.objects.all().values_list("id","caption")
    # choise = { 这是内存模式的
    #         (1,\'CTO\')
    #         (2,\'CEO\')
    #         (3,\'CFO\')
    #     }
    user_type = forms.IntegerField(widget=forms.widgets.Select(choices=choise,attrs={"name":"user_type"}))

def add_data(request):
    if request.method == \'POST\':
        objPost_type = add_Type(request.POST)            #用户提交的类型数据
        objPost_userinfo = add_valide(request.POST)      #用户提交的用户信息数据
        post_user = objPost_userinfo.is_valid()          #form验证判断
        post_tye = objPost_type.is_valid()               #form验证判断
        if post_user or post_tye:                        #如果这两个判断中有一个是真
            if post_tye:                                 #如果类型为真
                cap = objPost_type.clean()[\'caption\']               #objPost_type.clean()是获取到用户提交的数值{"caption":"CTO"}
                model.User_Type.objects.create(caption=cap)         #创建用户类型
                return render(request, "add_data.html", {"obj": objPost_userinfo, "type": post_tye})
            else:                                                   #用户数据为真
                user_name = objPost_userinfo.clean()[\'name\']        #获取用户输入的name
                age = objPost_userinfo.clean()[\'age\']               #获取用户输入的age
                type = objPost_userinfo.clean()[\'user_type\']        #获取用户输入的用户类型
                model.UserInfo.objects.create(name=user_name,age=age,user_type_id=type)   #插入数据库user_type_id直接使用到了user_type_id这个虚拟字段
                return render(request, "add_data.html", {"obj": objPost_userinfo,"type":objPost_type})
    else:    #如果用户是get请求
        objGet = add_valide()          #获取form表单
        typeGet = add_Type()           #获取form表单
        print(model.User_Type.objects.all().values("caption"))
        print(model.UserInfo.objects.all().values("name","age","user_type__caption"))
        return render(request, "add_data.html", {"obj": objGet,"type":typeGet})  #直接把表单传递到前段，前段就生成了相应的标签
views.py

 这样就实现了后端从数据库中获取，并且form提供创建标签的功能

但是这么写use_type 的内容不会因为新插入数值而改变，需要重启程序

 

class add_valide(forms.Form):
    name = forms.CharField(max_length=12, widget=forms.widgets.Input(attrs={"name":"name","placeholder":"name"}))
    age = forms.IntegerField(widget=forms.widgets.Input(attrs={"name":"age","placeholder":"age"}))
    choise = model.User_Type.objects.all().values_list("id","caption")
    user_type = forms.IntegerField(widget=forms.widgets.Select(choices=choise,attrs={"name":"user_type"}))

注意：因为 choise = model.User_Type.objects.all().values_list("id","caption") 这一条是class add_valide的静态字段，在类加载之后就不会再变化了，及时数据库中有新值插入，也不会去重新加载。

所以针对add_valide进行改良

class add_valide(forms.Form):
    name = forms.CharField(max_length=12, widget=forms.widgets.Input(attrs={"name":"name","placeholder":"name"}))
    age = forms.IntegerField(widget=forms.widgets.Input(attrs={"name":"age","placeholder":"age"}))
    choise = model.User_Type.objects.all().values_list("id","caption")
    user_type = forms.IntegerField(widget=forms.widgets.Select(choices=choise,attrs={"name":"user_type"}))
    def __init__(self,*arg, **kwargs):   #init构造函数的特点就是每次请求来都会
        super(add_valide, self).__init__(*arg, **kwargs)
        self.fields[\'user_type\'].widget.choices = model.User_Type.objects.all().values_list("id","caption")
        #就是让 user_type = forms.IntegerField(widget=forms.widgets.Select(choices 重新赋值，赋值的内容是去数据库中获取

　

请求流程

else:    #如果用户是get请求
    objGet = add_valide()          #获取form表单
    typeGet = add_Type()           #获取form表单
    print(model.User_Type.objects.all().values("caption"))
    print(model.UserInfo.objects.all().values("name","age","user_type__caption"))
    return render(request, "add_data.html", {"obj": objGet,"type":typeGet})  #直接把表单传递到前段，前段就生成了相应的标签

每次请求来都会创建 add_valide()对象，创建对象的时候就会执行构造函数 init中的　

 self.fields[\'user_type\'].widget.choices = model.User_Type.objects.all().values_list("id","caption")

 

  二、Django数据操作之 F/Q

1、F 作用：找到某个值让这个值在自身基础上做操作（增加，减少或者字符串拼接）

需求，找到某一些人把他们的工资加500

在models中我们要实现这个需求用下面的方法是不成的

想法没有问题，但是实现不了，实现不了，实现不了
temp = salary + 500
models.UserINfo.objects.fileter().update(salary=temp)

在sql语句中：

update userinfo set salary=salary + 500

所以我们就要用F来实现

# F 使用查询条件的值
    
    from django.db.models import F
    models.Tb1.objects.update(num=F(\'num\')+1)


from django.db import connection
    cursor = connection.cursor()
    cursor.execute("""SELECT * from tb where name = %s""", [\'Lennon\'])
    row = cursor.fetchone()

 

F的具体实现：

models.UserINfo.objects.fileter().update(salary=F(\'salary\')+ 500)

 

2、Q作用：构造搜索条件

目前我们学到的搜索条件是：
models.IserInfo.objects.filter(id=123,name="alex")
或者：
d  = {\'id\':123,"name":"alex"}
models.UserInfo.objects.filter(**d) 默认这样的方式就是and搜索

如果想使用or操作或者其他复杂的操作就需要使用Q对象。

1	CTO
2       CTO
3	CEO
4	CFO
5	CFO
6	CFO

　想找到id是1或者2或者3的数据

con = Q()
        q1 = Q()
        q1.connector = \'OR\'
        q1.children.append((\'id\',1))
        q1.children.append((\'id\',2))
        q1.children.append((\'id\',3))
        text = model.UserInfo.objects.filter(q1)
        for i in text:
            print(i.id,i.name)

　想找到id是1或者2或者3的并且name=CEO的

con = Q()
        #先找到id的范围
        q1 = Q()
        q1.connector = \'OR\'
        q1.children.append((\'id\',1))
        q1.children.append((\'id\',2))
        q1.children.append((\'id\',3))

        #在指定name的要找的名字
        q2 = Q()
        q2.connector = "OR"
        q2.children.append((\'name\',"CEO"))

        #把q1和q2再放到一起做一个AND
        con.add(q1,\'AND\')
        con.add(q2,\'AND\')
        text = model.UserInfo.objects.filter(q1)

 

 

三、models 多对多

1、创建

  • Django自动创建第三张表：
class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField(max_length=3)
    user_type = models.ForeignKey(User_Type)

class Dianzan(models.Model):
    num = models.IntegerField(max_length=12)
    U = models.ManyToManyField(UserInfo)         #创建第三张表

 

  • 自己创建第三项表
class UserInfo(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField(max_length=3)
    user_type = models.ForeignKey(User_Type)

class Dianzan(models.Model):
    num = models.IntegerField(max_length=12)

class D2U(models.Model):
    D_id = models.ForeignKey(\'Dianzan\')
    U_id = models.ForeignKey(\'UserInfo\')
  • Django自动创建第三张表的处理：
class Boy(models.Model):
    name = models.CharField(max_length=12)
    g = models.ManyToManyField("Girl")


class Girl(models.Model):
    name = models.CharField(max_length=12)
表结构
b1 = model.Boy.objects.get(name="郭德纲")    #获取男孩名字
g1 = model.Girl.objects.get(name="王钢蛋")   #获取女孩名字
gs =  model.Girl.objects.all()
因为上面表结构中我们在boy表中定义了第三张表的字段，g，所以我们就可以通过这个字段来操作第三种功能表了
b1.g.add(g1)  #b1中有一个g的字段 这个g字段就代指的第三张表


# 添加数据
正向操作
#b1.g.add(g1)
#b1.g.add(*gs) #添加女孩对象的列表增加多条数据
因为增加到第三张表中的只是两张表的主键，也就是两张表的id，所以我们也可以只使用id作为add的参数,这样做就省去了上面再查询的过程
b1.g.add(1)
b1.g.add(*[1,2,3])

反向操作：
在女孩字段中隐含着一个boy_set字段


　　g1.boy_set.valuse() #反向查询


 
# 删除数据
#b1.g.clear()与b1男孩有关系的女孩全部删除
#b1.g.remove(g1)
#b1.g.remove(*g1_obj)
#b1.g.remove(1)
#b1.g.remove(*[1,2,3])

 

# 添加数据(反向操作)
#g1.boy_set.add(b1)
#g1.boy_set.add(*bs)
#g1.boy_set.add(1)
#g1.boy_set.add(*[1,2,3])

 
# 删除数据(反向操作)
#g1.boy_set.remove(b1)
#g1.boy_set.remove(*bs)
#g1.boy_set.remove(1)
#g1.boy_set.remove(*[1,2,3])
#g1.boy_set.clean()  #删除所有与g1有关系的男孩
 
# 获取数据
#b1.g.all()
#b1.g.all().filter(id=1)
 
# 获取数据（反向操作隐含着_set字段）
#g1.boy_set.all()
#g1.boy_set.all().filter(name=\'郭德纲\')
#all(),conten

#跨表查询，从girl表中的一个对象，通过关联表查询到boy表中的数据
#models.Girl.objects.all().valuse(\'id\',\'name\',\'boy__name\')
models.Girl.objects.filter(name=\'王钢蛋\').values(\'id\',\'name\',\'boy__name\')
#这样就查询到了王钢蛋的id name 还有和王钢蛋关联的男孩的名字






更新：django中没有提供更新，所以需要使用原生sql来实现


from django.db import connection
    # cursor = connection.cursor()
    # cursor.execute("""SELECT * from tb where name = %s""", [\'Lennon\'])
    # row = cursor.fetchone()




 




 


四、Django中间件：


1.中间件存在的位置




 


a、MIDDLEWARE_CLASSES 流程：




MIDDLEWARE_CLASSES = [
    \'django.middleware.security.SecurityMiddleware\',
    \'django.contrib.sessions.middleware.SessionMiddleware\',
    \'django.middleware.common.CommonMiddleware\',
    #\'django.middleware.csrf.CsrfViewMiddleware\',
    \'django.contrib.auth.middleware.AuthenticationMiddleware\',
    \'django.contrib.auth.middleware.SessionAuthenticationMiddleware\',
    \'django.contrib.messages.middleware.MessageMiddleware\',
    \'django.middleware.clickjacking.XFrameOptionsMiddleware\',
]





django的中间件本身就是一个类,所以我们也可以自己定义一个类


 




类路径：class1. models.py 
class M1:
    def process_request(self,request):
        print(\'我是中间件\')

在setting中添加这个类


MIDDLEWARE_CLASSES = [
　　 \'class1.models.M1\',
    \'django.middleware.security.SecurityMiddleware\',
    \'django.contrib.sessions.middleware.SessionMiddleware\',
    \'django.middleware.common.CommonMiddleware\',
    #\'django.middleware.csrf.CsrfViewMiddleware\',
    \'django.contrib.auth.middleware.AuthenticationMiddleware\',
    \'django.contrib.auth.middleware.SessionAuthenticationMiddleware\',
    \'django.contrib.messages.middleware.MessageMiddleware\',
    \'django.middleware.clickjacking.XFrameOptionsMiddleware\',
]




 


此时我们重启系统然后访问页面


显示：


我是中间件     <-------- 这个是关键！！
[01/Oct/2016 16:06:33] "GET /boy_2_girl/ HTTP/1.1" 200 2
[{\'boy__name\': \'郭德纲\', \'name\': \'林志玲\', \'id\': 5}]


 


与mange.py在同一目录下的文件夹 wupeiqi/middleware下的auth.py文件中的Authentication类


 2.中间件定义的方法名：




1、process_request（self,request）      　　　　　#请求时执行的方法
 
2、process_response(self,request,response)      #返回时执行的方法
　　return response      　　　　　　　　　　　　　　#返回时必须要return response

3、process_template_response(self,request,response)　　　　　#在views.py 的url函数中，返回中如果有render，才会执行这个方法　　　　　　　　　 

4、process_exception(self, request, exception)   　　　　　　　　　　　　　　　　#url函数中如果出现异常则会执行这个方法，并且执行的顺序是执行url函数前的方法，再执行url函数，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #如果url函数中有错误，则会执行在返回的函数中先执行后定义的中间件方法中的exception方法

5、process_view(self, request, callback, callback_args, callback_kwargs)   #执行完所有的request后再执行这个方法






def middle(request):
    print("views")
    obj = HttpResponse("OK")
    return obj  #  return 中有单独定义的redern方法才会触发process_template_response




 


以上方法的返回值可以是None和HttpResonse对象，如果是None，则继续按照django定义的规则向下执行，如果是HttpResonse对象，则直接将该对象返回给用户。


 


中间件执行的顺序






MIDDLEWARE_CLASSES = [
    \'class1.models.M1\',
    \'class1.models.M2\',
    \'django.middleware.security.SecurityMiddleware\',
    \'django.contrib.sessions.middleware.SessionMiddleware\',
    \'django.middleware.common.CommonMiddleware\',
    #\'django.middleware.csrf.CsrfViewMiddleware\',
    \'django.contrib.auth.middleware.AuthenticationMiddleware\',
    \'django.contrib.auth.middleware.SessionAuthenticationMiddleware\',
    \'django.contrib.messages.middleware.MessageMiddleware\',
    \'django.middleware.clickjacking.XFrameOptionsMiddleware\',
]



settings






class M1:
    def process_request(self,request):
        print("M1.process_request")

    def process_response(self,request,response):  #参数是django已经定义好的
        print("M1.process_response")
        return response



class M2:
    def process_request(self,request):
        print("M2.process_request")

    def process_response(self, resqust, response):
        print("M2.process_response")
        return response



中间件






def middle(request):
    print("views")
    return HttpResponse("ok")



url 函数


 


访问这个url函数，因为定义了中间件，所以所有的访问会经过中间件，中间件中的request是负责接受请求时执行的，response是返回时执行的


访问后返回的结果：




M1.process_request
M2.process_request
views
M2.process_response
M1.process_response





顺序是先经过所有的resquest，然后执行url函数，最后返回时在执行response


 


3、更多方法使用：






class M1:
    def process_request(self,request):
        print("M1.process_request")

    def process_response(self,request,response):
        print("M1.process_response")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("M1.process_view")

    def process_exception(self, request, exception):
        print("M1.exception ，url函数中出错了")

class M2:
    def process_request(self,request):
        print("M2.process_request")

    def process_response(self, resqust, response):
        print("M2.process_response")
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("M2.process_view")

    def process_exception(self, request, exception):
        print("M2.exception ，url函数中出错了")



更多中间件的使用


 




M1.process_request             #先执行request
M2.process_request　　　　

M1.process_view         　　　　#再返回去执行vies　　         
M2.process_view

#然后就执行url函数，如果出错了就执行exception，没有出错则执行response

M2.exception ，url函数中出错了    #因为出错了，所以出去的时候先执行M2
M1.exception ，url函数中出错了    

M2.process_response             #执行完exception后再返回去执行response 
M1.process_response





　　


 


4、不同版本中间件使用的区别：


在1.10之前就是按照上面的方法去写，但是之后需要在定义中间件的时候做一些改变






from django.utils import deprecation       #倒入这个类
class M1(deprecation.MiddlewareMixin):  #继承这个方法
    def process_request(self,request):
        print("M1.process_request")

    def process_response(self,request,response):
        print("M1.process_response")
        return response

class M2(deprecation.MiddlewareMixin):
    def process_request(self,request):
        print("M2.process_request")

    def process_response(self, resqust, response):
        print("M2.process_response")
        return response    



新版本django 中间件写法


 


 


5、新版本如果其中一个process_requset中return了，则后面的request都不执行了，然后执行process_request对应类中的process_response方法


 


b、原版本的流程：


这个与新版本不同的地方是如果在process_request中 return了，后面的process_request都不执行了，然后依次执行所有的process_response.


 




 


五、django缓存 


1、配置


由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。


Django中提供了6种缓存方式：


    

  • 开发调试
    • 

  • 内存
    • 

  • 文件
    • 

  • 数据库
    • 

  • Memcache缓存（python-memcached模块）
    • 

  • Memcache缓存（pylibmc模块）
    • 



 


 a、开发模式：




# 此为开始调试用，实际内部不做任何操作
    # 配置：
        CACHES = {
            \'default\': {
                \'BACKEND\': \'django.core.cache.backends.dummy.DummyCache\',     # 引擎
                \'TIMEOUT\': 300,                                               # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
                \'OPTIONS\':{
                    \'MAX_ENTRIES\': 300,                                       # 最大缓存个数（默认300）
                    \'CULL_FREQUENCY\': 3,                                      # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
                },
                \'KEY_PREFIX\': \'\',                                             # 缓存key的前缀（默认空）
                \'VERSION\': 1,                                                 # 缓存key的版本（默认1）
                \'KEY_FUNCTION\' 函数名                                          # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
            }
        }


    # 自定义key
    def default_key_func(key, key_prefix, version):
        """
        Default function to generate keys.

        Constructs the key used by all other methods. By default it prepends
        the `key_prefix\'. KEY_FUNCTION can be used to specify an alternate
        function with custom key making behavior.
        """
        return \'%s:%s:%s\' % (key_prefix, version, key)

    def get_key_func(key_func):
        """
        Function to decide which key function to use.

        Defaults to ``default_key_func``.
        """
        if key_func is not None:
            if callable(key_func):
                return key_func
            else:
                return import_string(key_func)
        return default_key_func





b、内存




# 此缓存将内容保存至内存的变量中
    # 配置：
        CACHES = {
            \'default\': {
                \'BACKEND\': \'django.core.cache.backends.locmem.LocMemCache\',
                \'LOCATION\': \'unique-snowflake\',
            }
        }

    # 注：其他配置同开发调试版本





c、文件




# 此缓存将内容保存至文件
    # 配置：

        CACHES = {
            \'default\': {
                \'BACKEND\': \'django.core.cache.backends.filebased.FileBasedCache\',
                \'LOCATION\': \'/var/tmp/django_cache\',
            }
        }
    # 注：其他配置同开发调试版本





d、数据库




# 此缓存将内容保存至数据库

    # 配置：
        CACHES = {
            \'default\': {
                \'BACKEND\': \'django.core.cache.backends.db.DatabaseCache\',
                \'LOCATION\': \'my_cache_table\', # 数据库表
            }
        }

    # 注：执行创建表命令 python manage.py createcachetable





e、Memcache缓存（python-memcached模块）




# 此缓存使用python-memcached模块连接memcache

    CACHES = {
        \'default\': {
            \'BACKEND\': \'django.core.cache.backends.memcached.MemcachedCache\',
            \'LOCATION\': \'127.0.0.1:11211\',
        }
    }

    CACHES = {
        \'default\': {
            \'BACKEND\': \'django.core.cache.backends.memcached.MemcachedCache\',
            \'LOCATION\': \'unix:/tmp/memcached.sock\',
        }
    }   

    CACHES = {
        \'default\': {
            \'BACKEND\': \'django.core.cache.backends.memcached.MemcachedCache\',
            \'LOCATION\': [
                \'172.19.26.240:11211\',
                \'172.19.26.242:11211\',
            ]
        }
    }





f、Memcache缓存（pylibmc模块）




# 此缓存使用pylibmc模块连接memcache
    
    CACHES = {
        \'default\': {
            \'BACKEND\': \'django.core.cache.backends.memcached.PyLibMCCache\',
            \'LOCATION\': \'127.0.0.1:11211\',
        }
    }

    CACHES = {
        \'default\': {
            \'BACKEND\': \'django.core.cache.backends.memcached.PyLibMCCache\',
            \'LOCATION\': \'/tmp/memcached.sock\',
        }
    }   

    CACHES = {
        \'default\': {
            \'BACKEND\': \'django.core.cache.backends.memcached.PyLibMCCache\',
            \'LOCATION\': [
                \'172.19.26.240:11211\',
                \'172.19.26.242:11211\',
            ]
        }
    }




2、应用


a. 全站使用




使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，
如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

    MIDDLEWARE = [
        \'django.middleware.cache.UpdateCacheMiddleware\',
        # 其他中间件...
        \'django.middleware.cache.FetchFromCacheMiddleware\',
    ]

    CACHE_MIDDLEWARE_ALIAS = ""
    CACHE_MIDDLEWARE_SECONDS = ""
    CACHE_MIDDLEWARE_KEY_PREFIX = ""





b、单独视图缓存




方式一：
        from django.views.decorators.cache import cache_page

        @cache_page(60 * 15)   #括号里面是超时时间
        def my_view(request):
            ...
方式二：
        from django.views.decorators.cache import cache_page

        urlpatterns = [
            url(r\'^foo/([0-9]{1,2})/$\', cache_page(60 * 15)(my_view)),   #这个单独试图支持分页
        ]
方式一和方式二实现效果是一样的。




c、局部视图使用




第一步. 引入TemplateTag

        {% load cache %}

第二步. 使用缓存

        {% cache 5000 缓存key %}   #5000的秒， 缓存key就是 放在缓存中的名字
            缓存内容
        {% endcache %}





更多猛戳这里




六、信号


Django中提供了“信号调度”，用于在框架执行操作时解耦。通俗来讲，就是一些动作发生的时候，信号允许特定的发送者去提醒一些接受者。


1、Django内置信号




Model signals
    pre_init                    # django的modal执行其构造方法前，自动触发
    post_init                   # django的modal执行其构造方法后，自动触发
    pre_save                    # django的modal对象保存前，自动触发
    post_save                   # django的modal对象保存后，自动触发
    pre_delete                  # django的modal对象删除前，自动触发
    post_delete                 # django的modal对象删除后，自动触发
    m2m_changed                 # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
    class_prepared              # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
Management signals
    pre_migrate                 # 执行migrate命令前，自动触发
    post_migrate                # 执行migrate命令后，自动触发
Request/response signals
    request_started             # 请求到来前，自动触发
    request_finished            # 请求结束后，自动触发
    got_request_exception       # 请求异常后，自动触发
Test signals
    setting_changed             # 使用test测试修改配置文件时，自动触发
    template_rendered           # 使用test测试渲染模板时，自动触发
Database Wrappers
    connection_created          # 创建数据库连接时，自动触发





 


对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数，放置位置最好放在project同名目录的__init__.py文件中




from django.core.signals import request_finished
from django.core.signals import request_started
from django.core.signals import got_request_exception

from django.db.models.signals import class_prepared
from django.db.models.signals import pre_init, post_init
from django.db.models.signals import pre_save, post_save
from django.db.models.signals import pre_delete, post_delete
from django.db.models.signals import m2m_changed
from django.db.models.signals import pre_migrate, post_migrate

from django.test.signals import setting_changed
from django.test.signals import template_rendered

from django.db.backends.signals import connection_created


def callback(sender, **kwargs):
    print("xxoo_callback")
    print(sender,kwargs)

xxoo.connect(callback)  
# xxoo指上述导入的内容 如： pre_migrate




 




from django.core.signals import request_finished
from django.dispatch import receiver

@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")





　　


2、自定义信号


a. 定义信号




import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])





 


b. 注册信号




def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)
 
pizza_done.connect(callback)





 


c. 触发信号




from 路径 import pizza_done
 
pizza_done.send(sender=\'seven\',toppings=123, size=456)





由于内置信号的触发者已经集成到Django中，所以其会自动调用，而对于自定义信号则需要开发者在任意位置触发。　　


更多内容：猛戳这里　　


 


　　




 


小知识点：


以get方式传值：




url：127.0.0.1:8000/index/?q=123





后台：




def add_url(request):
    q = request.GET.get("q",None)
    print(q)
    return HttpResponse(q)





　　


def middle(request):
print("views")
obj = HttpResponse("OK")
return obj  #  return 中有单独定义的redern方法才会触发process_template_response


以上是关于day20  FORM补充的主要内容，如果未能解决你的问题，请参考以下文章
 

 day20 装饰器补充


 DAY20Socket编程的补充2


 Django--系列学习


 SpringBoot中表单提交报错“Content type ‘application/x-www-form-urlencoded；charset=UTF-8‘ not supported“(代码片段


 VSCode 配置 用户自定义代码片段 自定义自动代码补充


 Python Day10（补充）