Form验证笔记

views
    request.body
        request.POST(request.body)
        request.FILES(request.body)
        request.GET
        request.XXX.getlist

    request.Meta(...)
        request.method(POST,GET,PUT)
        request.path_info
        request.COOKIES

返回cookie
    response=HttpResponse(a)
    response.set_cookie()
    return response

    response['name']='alex' 创建响应头 name=alex

model操作
    表内容操作:
        models.TB.objects.create()
        models.TB.objects.create(**{})
        obj=models.TB(...)
        obj.save()

        models.TB.objects.all()
        models.TB.objects.all()[7:10]  切片数据

        models.TB.objects.update(...)
        models.TB.objects.filter(id__in=[1,2,3...])
        models.TB.objects.filter(单下划线id)
        models.TB.objects.filter(..).delete
        models.TB.objects.values  结果是字典
        models.TB.objects.values_list 结果是元组
        models.TB.objects.get
        models.TB.objects.filter().update()
        models.TB.objects.filter().first()
        models.TB.objects.filter(**{})
        models.TB.objects.filter(**{}).count()
        models.TB.objects.filter(双下划线跨表)
        models.TB.objects.filter(id__gt=1,name='root')  and关系
        models.TB.objects.filter(id__range=[1,3])
        ...                     (id__lt=1)
                                (id__lte=1)
                                (id__gte=1)

        models.TB.objects.exclude(id__gt=1)

        多对多:
            obj.set
            obj.add(1,2,3)
            obj.add([1,2,3])
            obj.remove([1,2,3])
            obj.clear()
            obj.all()

         models.TB.objects.all()
         [obj,obj]
         obj.fk.name

         models.TB.objects.all().order_by('')
         models.TB.objects.distinct()

        class A:
            name ..
            # b_set  通过A查B

        class B:
            caption ..
            fk=ForignKey(A)
            B.fk.A的列名  通过B查A

        多对多
         class A:
            name ..
            # b_set  通过A查B

        class B:
            caption ..
            r=M2M(a)

模板语言
        def func(request):
            return render(request,'index.html',{'val':[1,2,3]})

        index.html
            <h1>{{val.0}}</h1>

         继承
         extends  "layout.html"

        include加载组件

        simple_tag,filter

session
    基于 cookie做用户验证时:敏感信息不适合放在cookie中
    cookie:保存在用户浏览器端的键值对
    session:保存在服务器的键值对 依赖于cookie
    原理:生成一个随机字符串对应一个字典，value保存用户信息

    服务器session
        获取session
        request.session.get()
        设置session
        request,session[x]=x
        清空session
        request.session.clear()

    def使用
        # 获取、设置、删除Session中数据
        request.session['k1']
        request.session.get('k1',None)
        request.session['k1'] = 123
        request.session.setdefault('k1',123) # 存在则不设置
        del request.session['k1']

        # 所有 键、值、键值对
        request.session.keys()
        request.session.values()
        request.session.items()
        request.session.iterkeys()
        request.session.itervalues()
        request.session.iteritems()

        # 用户session的随机字符串
        request.session.session_key

        # 将所有Session失效日期小于当前日期的数据删除
        request.session.clear_expired()

        # 检查 用户session的随机字符串 在数据库中是否
        request.session.exists("session_key")

        # 删除当前用户的所有Session数据
        request.session.delete("session_key")

        request.session.set_expiry(value)
            * 如果value是个整数，session会在些秒数后失效。
            * 如果value是个datatime或timedelta，session就会在这个时间后失效。
            * 如果value是0,用户关闭浏览器session就会失效。
            * 如果value是None,session会依赖全局session失效策略。

    配置文件设置默认操作：
    settings.py配置
    SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
    SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
    SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
    SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
    SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
    SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
    SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）每次请求 超时时间起点重新计算

缓存
CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': [
                ('172.19.26.240:11211',10),
                ('172.19.26.242:11211',11),
            ]
        }
    }

信号
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          # 创建数据库连接时，自动触发

导入信号模块
    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指上述导入的内容

自定义信号
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 sg import pizza_done

pizza_done.send(sender='seven',toppings=123, size=456)