Web

 1 FBV本身就是一个函数，所以和给普通的函数加装饰器没差别
 2 
 3 
 4 def wrapper(func):
 5     def inner(*args, **kwargs):
 6         start_time = time.time()
 7         ret = func(*args, **kwargs)
 8         end_time = time.time()
 9         print("used:", end_time-start_time)
10         return ret
11     return inner
12 
13 
14 # FBV版添加班级
15 @wrapper
16 def add_class(request):
17     if request.method == "POST":
18         class_name = request.POST.get("class_name")
19         models.Classes.objects.create(name=class_name)
20         return redirect("/class_list/")
21     return render(request, "add_class.html")

 1 类中的方法与独立函数不完全相同，因此不能直接将函数装饰器应用于类中的方法 ，我们需要先将其转换为方法装饰器。
 2 
 3 Django中提供了method_decorator装饰器用于将函数装饰器转换为方法装饰器。
 4 
 5 # CBV版添加班级
 6 from django.views import View
 7 from django.utils.decorators import method_decorator
 8 
 9 class AddClass(View):
10 
11     @method_decorator(wrapper)
12     def get(self, request):
13         return render(request, "add_class.html")
14 
15     def post(self, request):
16         class_name = request.POST.get("class_name")
17         models.Classes.objects.create(name=class_name)
18         return redirect("/class_list/")
19 复制代码

def render(request, template_name, context=None, content_type=None, status=None, using=None):

    content = loader.render_to_string(template_name, context, request, using=using)
    return HttpResponse(content, content_type, status)

参数：
request： 用于生成响应的请求对象。
template_name：要使用的模板的完整名称，可选的参数
context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。
content_type：生成的文档要使用的MIME类型。默认为 DEFAULT_CONTENT_TYPE 设置的值。默认为‘text/html‘
status：响应的状态码。默认为200。
using: 用于加载模板的模板引擎的名称。

def redirect(to, *args, permanent=False, **kwargs):
    
    redirect_class = HttpResponsePermanentRedirect if permanent else HttpResponseRedirect
    return redirect_class(resolve_url(to, *args, **kwargs)


参数可以是：
一个模型：将调用模型的get_absolute_url() 函数
一个视图，可以带有参数：将使用urlresolvers.reverse 来反向解析名称
一个绝对的或相对的URL，将原封不动的作为重定向的位置。
默认返回一个临时的重定向；传递permanent=True 可以返回一个永久的重定向。

 1  m1.py:
 2         from django.utils.deprecation import MiddlewareMixin
 3 
 4         class Middle1(MiddlewareMixin):
 5             def process_request(self, request):
 6                 print(‘m1.process_request‘)
 7 
 8             def process_response(self, request, response):
 9                 print(‘m1.process_response‘)
10                 return response
11 
12         class Middle2(MiddlewareMixin):
13             def process_request(self, request):
14                 print(‘m2.process_request‘)
15 
16             def process_view(self, request, callback, callback_args, callback_kwargs):
17                 response = callback(request, *callback_args, **callback_kwargs)
18                 return response
19 
20             def process_response(self, request, response):
21                 print(‘m2.process_response‘)
22                 return response

<1> all():                 查询所有结果
 
<2> filter(**kwargs):      它包含了与所给筛选条件相匹配的对象
 
<3> get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
 
<4> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象
 
<5> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列
 
<6> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
 
<7> order_by(*field):      对查询结果排序
 
<8> reverse():             对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。
 
<9> distinct():            从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)
 
<10> count():              返回数据库中匹配查询(QuerySet)的对象数量。
 
<11> first():              返回第一条记录
 
<12> last():               返回最后一条记录
 
<13> exists():             如果QuerySet包含数据，就返回True，否则返回False

其中：
返回QuerySet对象的方法有
all()
filter()
exclude()
order_by()
reverse()
distinct()

特殊的QuerySet
values()       返回一个可迭代的字典序列
values_list() 返回一个可迭代的元祖序列

返回具体对象的
get()
first()
last()

返回布尔值的方法有：
exists()

返回数字的方法有
count()

方式1：ManyToManyField
方式2：自己建第三个表
方式3：两者结合   但只能查询所有和清空
    m = models.ManyToManyField(‘Boy‘, through=‘Boy‘, through_fields=(‘b‘, ‘g‘))

class Boy(models.Model):
    name = models.CharField(max_length=32)

class Girl(models.Model):
    nick = models.CharField(max_length=32)
    m = models.ManyToManyField(‘Boy‘)
    相当于建立了=>
      class Love(models.Model):
           b = models.ForeignKey(‘Boy‘, on_delete=models.CASCADE)
           g = models.ForeignKey(‘Girl‘, on_delete=models.CASCADE)

若要求男生女生只能约会一次：
class Meta:
     unique_together = [
         (‘b‘, ‘g‘)
     ]

查询：
1. 查询跟秦汉有关的姑娘
方法1：
obj = models.Boy.objects.filter(name="秦汉").first()
love_list = obj.love_set.all()
for row in love_list:
    print(row.g.nick)
方法2：
love_list = models.Love.objects.filter(b__name="秦汉")
for row in love_list:
    print(row.g.nick)
方法3
love_list = models.Love.objects.filter(b__name="秦汉").values(‘g__nick‘)
for item in love_list:
    print(item[‘g__nick‘])
方法4
love_list = models.Love.objects.filter(b__name="秦汉").select_related(‘g‘)
for obj in love_list:
    print(obj.g.nick)

使用m = models.ManyToManyField(‘Boy‘) 建立第三表后:
    # Girl
    obj = models.Girl.objects.filter(nick="小猫").first()
    print(obj.id, obj.nick)

    # 增
    obj.m.add(2)
    obj.m.add(1, 4)
    obj.m.add(*[3, ])

    # 删
    obj.m.remove(2)
    obj.m.remove(*[3, ])

    # 改 => 重置
    obj.m.set([1, ])
    #
    # 查
    boy_list = obj.m.all()  # 与小猫有关系的全拿到
    for i in boy_list:
         print(i.name)
    obj.m.all()  与小猫有关系的全删除

    # Boy 反向操作 小写表明_set.all()
    obj = models.Boy.objects.filter(name="方华").first()
    print(obj.id, obj.name, obj)
    v = obj.girl_set.all()
    print(v)

# 获取个数
 models.Tb1.objects.filter(name=‘seven‘).count()

 # 大于，小于
models.Tb1.objects.filter(id__gt=1)             # 获取id大于1的值
models.Tb1.objects.filter(id__gte=1)           # 获取id大于等于1的值
# models.Tb1.objects.filter(id__lt=10)         # 获取id小于10的值
# models.Tb1.objects.filter(id__lte=10)       # 获取id小于10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

# in
models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

# contains
models.Tb1.objects.filter(name__contains="ven")
models.Tb1.objects.filter(name__icontains="ven")  # icontains大小写不敏感

# range
models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
# 其他类似
startswith，istartswith, endswith, iendswith,

# order by
 models.Tb1.objects.filter(name=‘seven‘).order_by(‘id‘)    # asc
models.Tb1.objects.filter(name=‘seven‘).order_by(‘-id‘)   # desc

# group by
from django.db.models import Count, Min, Max, Sum
models.Tb1.objects.filter(c1=1).values(‘id‘).annotate(c=Count(‘num‘))
        
# limit 、offset
models.Tb1.objects.all()[10:20]

# regex正则匹配，iregex 不区分大小写

# F,Q,extra
# F
from django.db.models import F
models.UserInfo.objects.all().update(age=F(‘age‘)+1)  # F 代表数据库原来的值

# Q
Q使用有两种方式:
    models.UserInfo.objects.filter(id=1, name=‘alex‘)
    ==>
    condition = {
        ‘id‘: 1,
        ‘name‘: ‘root‘
    }
    models.UserInfo.objects.filter(**condition)
1. 对象方式
from django.db.models import Q
models.UserInfo.objects.filter(Q(id=1) | Q(name=‘alex‘)) models.UserInfo.objects.filter(Q(id=1) & Q(name=‘alex‘))
2. 方法方式
q1 = Q()
q1.connector = ‘OR‘
q1.children.append((‘id‘, 1))
q1.children.append((‘id‘, 10))
q1.children.append((‘id‘, 9))
q2 = Q()
q1.connector = ‘OR‘
q1.children.append((‘c1‘, 1))
q1.children.append((‘c1‘, 10))
q1.children.append((‘c1‘, 9))

con = Q()
con.add(q1, ‘AND‘)
con.add(q2, ‘AND‘)

简写为：
condition = {
    ‘k1‘: [1, 2, 3, 4],
    ‘k2‘: [1, ],
    ‘k3‘: [11, ]
}
con = Q()
for k, v in condition.items():
    q = Q()
    q.connector = ‘OR‘
    for i in v:
        q.children.append(‘id‘, i)
    con.add(q, ‘AND‘)
models.UserInfo.objects.filter(con)

# extra
    ‘‘‘
        select
            id,
            name,
            (select count(1) from tb) as n
        from xb
    ‘‘‘
    v = models.UserInfo.objects.all().extra(
        select={‘n‘: ‘select count(1) from app01_usertype where id=%s or id=%s‘,
                ‘m‘: ‘select count(1) from app01_usertype where id=%s or id=%s‘,
                },
            select_params=[1, 2, 3, 4])
    for obj in v:
        print(obj.id, obj.name, obj.n)

    models.UserInfo.objects.extra(
        where=[‘id = 1‘, "name=‘alex‘"]
    )

    models.UserInfo.objects.extra(
        where=["id=1 or id=%s", "name=%s "], params=[1, ‘alex‘]
    )

    models.UserInfo.objects.extra(
        tables=[‘app01_usertype‘],
    )
    类似于 select *from app01_userinfo, app01_usertype

                a.映射
                select
                select_params=None
                select 此处 from 表

                b.条件
                where=None
                params=None
                select *from 表 where 此处

                c.表
                table
                select *from 表，此处

                d.排序
                order_by = none
                select *from 表 order by 此处
            例如:
                models.UserInfo.object.extra(
                select = {‘newid‘: ‘select count(1) from app01_usertype where id>%s},select_params=[1,],
                where = [‘age‘>%s], params=[18,],
                order_by = {‘-age‘},
                tables= [‘app01_usertype‘]
                )
            =>
            select
                app01_userinfo.id,
                (select count(1) from app01_usertype where id>1)as newid
                from app01_userinfo,app01_usertype
                where app01_userinfo.age>18
                order by
                    app01_userinfo.age desc

def all(self)
    # 获取所有的数据对象

def filter(self, *args, **kwargs)
    # 条件查询
    # 条件可以是：参数，字典，Q

def exclude(self, *args, **kwargs)
    # 条件查询
    # 条件可以是：参数，字典，Q

def select_related(self, *fields)
    性能相关：表之间进行join连表操作，一次性获取关联的数据。

    总结：
    1. select_related主要针一对一和多对一关系进行优化。
    2. select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。

def prefetch_related(self, *lookups)
    性能相关：多表连表操作时速度会慢，使用其执行多次SQL查询在Python代码中实现连表操作。

    总结：
    1. 对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。
    2. prefetch_related()的优化方式是分别查询每个表，然后用Python处理他们之间的关系。

def annotate(self, *args, **kwargs)
    # 用于实现聚合group by查询

    from django.db.models import Count, Avg, Max, Min, Sum

    v = models.UserInfo.objects.values(‘u_id‘).annotate(uid=Count(‘u_id‘))
    # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

    v = models.UserInfo.objects.values(‘u_id‘).annotate(uid=Count(‘u_id‘)).filter(uid__gt=1)
    # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

    v = models.UserInfo.objects.values(‘u_id‘).annotate(uid=Count(‘u_id‘,distinct=True)).filter(uid__gt=1)
    # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

def distinct(self, *field_names)
    # 用于distinct去重
    models.UserInfo.objects.values(‘nid‘).distinct()
    # select distinct nid from userinfo

    注：只有在PostgreSQL中才能使用distinct进行去重

def order_by(self, *field_names)
    # 用于排序
    models.UserInfo.objects.all().order_by(‘-id‘,‘age‘)

def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    # 构造额外的查询条件或者映射，如：子查询

    Entry.objects.extra(select={‘new_id‘: "select col from sometable where othercol > %s"}, select_params=(1,))
    Entry.objects.extra(where=[‘headline=%s‘], params=[‘Lennon‘])
    Entry.objects.extra(where=["foo=‘a‘ OR bar = ‘a‘", "baz = ‘a‘"])
    Entry.objects.extra(select={‘new_id‘: "select id from tb where id > %s"}, select_params=(1,), order_by=[‘-nid‘])

 def reverse(self):
    # 倒序
    models.UserInfo.objects.all().order_by(‘-nid‘).reverse()
    # 注：如果存在order_by，reverse则是倒序，如果多个排序则一一倒序


 def defer(self, *fields):
    models.UserInfo.objects.defer(‘username‘,‘id‘)
    或
    models.UserInfo.objects.filter(...).defer(‘username‘,‘id‘)
    #映射中排除某列数据

 def only(self, *fields):
    #仅取某个表中的数据
     models.UserInfo.objects.only(‘username‘,‘id‘)
     或
     models.UserInfo.objects.filter(...).only(‘username‘,‘id‘)

 def using(self, alias):
     指定使用的数据库，参数为别名（setting中的设置）


##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################

def raw(self, raw_query, params=None, translations=None, using=None):
    # 执行原生SQL
    models.UserInfo.objects.raw(‘select * from userinfo‘)

    # 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名
    models.UserInfo.objects.raw(‘select id as nid from 其他表‘)

    # 为原生SQL设置参数
    models.UserInfo.objects.raw(‘select id as nid from userinfo where nid>%s‘, params=[12,])

    # 将获取的到列名转换为指定列名
    name_map = {‘first‘: ‘first_name‘, ‘last‘: ‘last_name‘, ‘bd‘: ‘birth_date‘, ‘pk‘: ‘id‘}
    Person.objects.raw(‘SELECT * FROM some_other_table‘, translations=name_map)

    # 指定数据库
    models.UserInfo.objects.raw(‘select * from userinfo‘, using="default")

    ################### 原生SQL ###################
    from django.db import connection, connections
    cursor = connection.cursor()  # cursor = connections[‘default‘].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    row = cursor.fetchone() # fetchall()/fetchmany(..)


def values(self, *fields):
    # 获取每行数据为字典格式

def values_list(self, *fields, **kwargs):
    # 获取每行数据为元祖

def dates(self, field_name, kind, order=‘ASC‘):
    # 根据时间进行某一部分进行去重查找并截取指定内容
    # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
    # order只能是："ASC"  "DESC"
    # 并获取转换后的时间
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日

    models.DatePlus.objects.dates(‘ctime‘,‘day‘,‘DESC‘)

def datetimes(self, field_name, kind, order=‘ASC‘, tzinfo=None):
    # 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是："ASC"  "DESC"
    # tzinfo时区对象
    models.DDD.objects.datetimes(‘ctime‘,‘hour‘,tzinfo=pytz.UTC)
    models.DDD.objects.datetimes(‘ctime‘,‘hour‘,tzinfo=pytz.timezone(‘Asia/Shanghai‘))

    """
    pip3 install pytz
    import pytz
    pytz.all_timezones
    pytz.timezone(‘Asia/Shanghai’)
    """

def none(self):
    # 空QuerySet对象


####################################
# METHODS THAT DO DATABASE QUERIES #
####################################

def aggregate(self, *args, **kwargs):
   # 聚合函数，获取字典类型聚合结果
   from django.db.models import Count, Avg, Max, Min, Sum
   result = models.UserInfo.objects.aggregate(k=Count(‘u_id‘, distinct=True), n=Count(‘nid‘))
   ===> {‘k‘: 3, ‘n‘: 4}

def count(self):
   # 获取个数

def get(self, *args, **kwargs):
   # 获取单个对象

def create(self, **kwargs):
   # 创建对象

def bulk_create(self, objs, batch_size=None):
    # 批量插入
    # batch_size表示一次插入的个数
    objs = [
        models.DDD(name=‘r11‘),
        models.DDD(name=‘r22‘)
    ]
    models.DDD.objects.bulk_create(objs, 10)

def get_or_create(self, defaults=None, **kwargs):
    # 如果存在，则获取，否则，创建
    # defaults 指定创建时，其他字段的值
    obj, created = models.UserInfo.objects.get_or_create(username=‘root1‘, defaults={‘email‘: ‘1111111‘,‘u_id‘: 2, ‘t_id‘: 2})

def update_or_create(self, defaults=None, **kwargs):
    # 如果存在，则更新，否则，创建
    # defaults 指定创建时或更新时的其他字段
    obj, created = models.UserInfo.objects.update_or_create(username=‘root1‘, defaults={‘email‘: ‘1111111‘,‘u_id‘: 2, ‘t_id‘: 1})

def first(self):
   # 获取第一个

def last(self):
   # 获取最后一个

def in_bulk(self, id_list=None):
   # 根据主键ID进行查找
   id_list = [11,21,31]
   models.DDD.objects.in_bulk(id_list)

def delete(self):
   # 删除

def update(self, **kwargs):
    # 更新

def exists(self):
   # 是否有结果

QuerySet方法大全

$.ajax({
        url: ‘要提交的地址‘,
        type:‘POST‘, //GET或者POST，提交方式
        data:{‘k1‘:‘v1‘, ‘k2‘:‘v2‘}, //提交的数据
        success:function(data){
            // 当服务端处理完毕后，自动执行的回调函数
            // 打他是返回的数据
        }
    })

def wrapper(func):
            def inner(*args, **kwargs):
                return func(*args, **kwargs)
            return inner
        1.指定方法加
        class Foo(View):
            @method_decorator(wrapper)
            def get(self):
                pass
            def post(self):
                pass

        2. 类上面加
        @method_decorator(wrapper, name=‘ dispatch‘) # dispath是在定义的方法之前先执行的方法,即给所有类中的方法加
        class Foo(View):
            def dispatch(self, request, *args, **kwargs):
                return xx

            def get(self):
                pass

            def post(self):
                pass

# 加入装饰器，则不需要验证csrf
from django.views.decorators.csrf import csrf_exempt

# 　FBV 应用装饰器
@csrf_exempt
def csrf1(request):
    if request.method == ‘GET‘:
        return render(request, ‘csrf1.html‘)
    else:
        return HttpResponse(‘ok‘)

大家都知道HTTP协议是无状态的。
无状态的意思是每次请求都是独立的，它的执行情况和结果与前面的请求和之后的请求都无直接关系，它不会受前面的请求响应情况直接影响，也不会直接影响后面的请求响应情况。
一句有意思的话来描述就是人生只如初见，对服务器来说，每次的请求都是全新的。
状态可以理解为客户端和服务器在某次会话中产生的数据，那无状态的就以为这些数据不会被保留。会话中产生的数据又是我们需要保存的，也就是说要“保持状态”。因此Cookie就是在这样一个场景下诞生。

def check_login(func):
    @wraps(func)
    def inner(request, *args, **kwargs):
        next_url = request.get_full_path()
        if request.get_signed_cookie("login", salt="SSS", default=None) == "yes":
            # 已经登录的用户...
            return func(request, *args, **kwargs)
        else:
            # 没有登录的用户，跳转刚到登录页面
            return redirect("/login/?next={}".format(next_url))
    return inner


def login(request):
    if request.method == "POST":
        username = request.POST.get("username")
        passwd = request.POST.get("password")
        if username == "xxx" and passwd == "dashabi":
            next_url = request.GET.get("next")
            if next_url and next_url != "/logout/":
                response = redirect(next_url)
            else:
                response = redirect("/class_list/")
            response.set_signed_cookie("login", "yes", salt="SSS")
            return response
    return render(request, "login.html")

def login(request):
    if request.method == ‘GET‘:
        return render(request, ‘login.html‘)

    else:
        user = request.POST.get(‘username‘)
        pwd = request.POST.get(‘password‘)
        if user == ‘cui‘ and pwd == ‘123‘:
            obj = redirect(‘/classes/‘)
            obj.set_cookie(‘ticket‘, ‘asdadsadasd‘, max_age=600)  # cookie 存活600s
            # obj.set_signed_cookie(‘ticket‘, "123123", salt=‘jjjjjj‘)   # 加盐操作，类似于加密操作
            return obj
        else:
            return render(request, ‘login.html‘, {‘msg‘: ‘用户名或者密码错误‘, })



def classes(request):
    tk = request.COOKIES.get(‘ticket‘)
    # tk = request.get_signed_cookie(‘ticket‘, salt=‘jjjjjj‘)
    if not tk:
        return redirect(‘/login/‘)
    class_list = sqlhelper.get_list("select id, title from class", [])
    return render(request, ‘classes.html‘, {‘class_lst‘: class_list})

SESSION_ENGINE = ‘django.contrib.sessions.backends.db‘   # 引擎（默认）  
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，默认修改之后才保存（默认）
 

def index(request):
        # 获取、设置、删除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失效策略。

 1 def login(request):
 2     if request.method == ‘GET‘:
 3         return render(request, ‘login.html‘)
 4     else:
 5         u = request.POST.get(‘user‘)
 6         p = request.POST.get(‘pwd‘)
 7         obj = models.UserAdmin.objects.filter(username=u, password=p).first()
 8         if obj:
 9             # 1.生成随机字符串
10             # 2. 通过cookie发生给客户端
11             # 3.服务端保存{随机字符串1:{‘xx‘}}
12             request.session[‘username‘] = obj.username
13 
14             return redirect(‘/index/‘)
15         else:
16             return render(request, ‘login.html‘, {‘msg‘: ‘error‘})
17 
18 def index(request):
19     # 1.获取客户端cookie中的随机字符串
20     # 2.去session中查找有没有随机字符串
21     # 3.去session对应的key的value中查看是否有username
22     v = request.session.get(‘username‘)
23     if v:
24         return HttpResponse(‘login successfully: %s ‘%v)
25     else:
26         return redirect(‘/index/‘)

Field
    required=True,               是否允许为空
    widget=None,                 HTML插件
    label=None,                  用于生成Label标签或显示内容
    initial=None,                初始值
    help_text=‘‘,                帮助信息(在标签旁边显示)
    error_messages=None,         错误信息 {‘required‘: ‘不能为空‘, ‘invalid‘: ‘格式错误‘}
    validators=[],               自定义验证规则
    localize=False,              是否支持本地化
    disabled=False,              是否可以编辑
    label_suffix=None            Label内容后缀
 
 
CharField(Field)
    max_length=None,             最大长度
    min_length=None,             最小长度
    strip=True                   是否移除用户输入空白
 
IntegerField(Field)
    max_value=None,              最大值
    min_value=None,              最小值
 
FloatField(IntegerField)
    ...
 
DecimalField(IntegerField)
    max_value=None,              最大值
    min_value=None,              最小值
    max_digits=None,             总长度
    decimal_places=None,         小数位长度
 
BaseTemporalField(Field)
    input_formats=None          时间格式化   
 
DateField(BaseTemporalField)    格式：2015-09-01
TimeField(BaseTemporalField)    格式：11:12
DateTimeField(BaseTemporalField)格式：2015-09-01 11:12
 
DurationField(Field)            时间间隔：%d %H:%M:%S.%f
    ...
 
RegexField(CharField)
    regex,                      自定制正则表达式
    max_length=None,            最大长度
    min_length=None,            最小长度
    error_message=None,         忽略，错误信息使用 error_messages={‘invalid‘: ‘...‘}
 
EmailField(CharField)      
    ...
 
FileField(Field)
    allow_empty_file=False     是否允许空文件
 
ImageField(FileField)      
    ...
    注：需要PIL模块，pip3 install Pillow
    以上两个字典使用时，需要注意两点：
        - form表单中 enctype="multipart/form-data"
        - view函数中 obj = MyForm(request.POST, request.FILES)
 
URLField(Field)
    ...
 
 
BooleanField(Field)  
    ...
 
NullBooleanField(BooleanField)
    ...
 
ChoiceField(Field)
    ...
    choices=(),                选项，如：choices = ((0,‘上海‘),(1,‘北京‘),)
    required=True,             是否必填
    widget=None,               插件，默认select插件
    label=None,                Label内容
    initial=None,              初始值
    help_text=‘‘,              帮助提示
 
 
ModelChoiceField(ChoiceField)
    ...                        django.forms.models.ModelChoiceField
    queryset,                  # 查询数据库中的数据
    empty_label="---------",   # 默认空显示内容
    to_field_name=None,        # HTML中value的值对应的字段
    limit_choices_to=None      # ModelForm中对queryset二次筛选
     
ModelMultipleChoiceField(ModelChoiceField)
    ...                        django.forms.models.ModelMultipleChoiceField
 
 
     
TypedChoiceField(ChoiceField)
    coerce = lambda val: val   对选中的值进行一次转换
    empty_value= ‘‘            空值的默认值
 
MultipleChoiceField(ChoiceField)
    ...
 
TypedMultipleChoiceField(MultipleChoiceField)
    coerce = lambda val: val   对选中的每一个值进行一次转换
    empty_value= ‘‘            空值的默认值
 
ComboField(Field)
    fields=()                  使用多个验证，如下：即验证最大长度20，又验证邮箱格式
                               fields.ComboField(fields=[fields.CharField(max_length=20), fields.EmailField(),])
 
MultiValueField(Field)
    PS: 抽象类，子类中可以实现聚合多个字典去匹配一个值，要配合MultiWidget使用
 
SplitDateTimeField(MultiValueField)
    input_date_formats=None,   格式列表：[‘%Y--%m--%d‘, ‘%m%d/%Y‘, ‘%m/%d/%y‘]
    input_time_formats=None    格式列表：[‘%H:%M:%S‘, ‘%H:%M:%S.%f‘, ‘%H:%M‘]
 
FilePathField(ChoiceField)     文件选项，目录下文件显示在页面中
    path,                      文件夹路径
    match=None,                正则匹配
    recursive=False,           递归下面的文件夹
    allow_files=True,          允许文件
    allow_folders=False,       允许文件夹
    required=True,
    widget=None,
    label=None,
    initial=None,
    help_text=‘‘
 
GenericIPAddressField
    protocol=‘both‘,           both,ipv4,ipv6支持的IP格式
    unpack_ipv4=False          解析ipv4地址，如果是::ffff:192.0.2.1时候，可解析为192.0.2.1， PS：protocol必须为both才能启用
 
SlugField(CharField)           数字，字母，下划线，减号（连字符）
    ...
 
UUIDField(CharField)           uuid类型