zoukankan html css js c++ java

多对多三种创建方式,forms组件,cookie和session组件

一.多对多三种创建方式

1.全自动

优点:不需要手动创建第三张表

缺点:由于第三张表不是手动创建的,是orm自动创建的,也就意味着无法进行扩展,也就是加入其它字段

# 第一种方式,全自动
class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    author = models.ManyToManyField(to='Author')


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

全自动

2.纯手动

优点:第三张表自己创建,所以可以添加任意字段,扩展性较高

缺点:缺少了多对多字段,orm查询不方便

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)


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


class Book2Author(models.Model):
    book = models.ForeignKey(to='Book')
    author = models.ForeignKey(to='Author')
    create_time = models.DateTimeField(auto_now_add=True)  # 可以扩展字段,扩展性较强

纯手动

3.半自动

优点:结合了全自动和纯手动的两个优点

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    author = models.ManyToManyField(to='Author',through='Book2Author',through_fields=('book','author'))
    # through告诉orm两个表之间的多对多关系是由Book2Author表记录的
    # through_fields告诉orm记录多对多关系时使用through_fields的book和author字段来记录

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


class Book2Author(models.Model):
    book = models.ForeignKey(to='Book')
    author = models.ForeignKey(to='Author')
    create_time = models.DateTimeField(auto_now_add=True)  # 可以扩展字段,扩展性较强

半自动

使用情况:

在不需要添加其它字段的业务逻辑较为简单的情况下可以使用第一种方式,其它情况下都推荐使用第三种方式,第二种方式不推荐

二.forms组件

1.自己手动实现一个注册功能

当用户的用户名包含'sb'时,提示用户名不符合规定

当用户的密码小于三位时,提示密码不能小于三位

def login(request):
    errors = {'username':'', 'password':''}
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        if '666' in username:
            errors['username'] = '用户名不符合规定'
        if len(password) < 3:
            errors['password'] = '密码不能小于三位'
    return render(request,'login.html',locals())

views.py

<!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>
<form action="" method="post">
    <p>username:<input type="text" name="username"><span style="color: red">{{ errors.username }}</span></p>
    <p>password:<input type="password" name="password"><span style="color: red">{{ errors.password }}</span></p>
    <input type="submit">
</form>
</body>
</html>

1.前端页面搭建                 >>>        渲染页面
2.将数据传输到后端做校验        >>>        校验数据
3.展示错误信息                >>>        展示信息

使用form组件之后能够直接帮我们完成上述的三步操作

1.渲染前端页面
2.校验数据是否合法
3.展示错误信息

2.form组件的基本用法

1.写一个继承了forms.Form的类

from django import forms

class LoginForm(forms.Form):
    username = forms.CharField(max_length=8,min_length=3)
    password = forms.CharField(max_length=8,min_length=2)
    email = forms.EmailField()

2.基本使用

# 1.将需要校验的数据,以字典的方式传递给自定义的累,实例化生成对象
from app01 import views
form_obj =views.LoginForm({'username':'sxc','password':'1','email':'321'})

# 2.对象.is_valid()来查看数据是否全部合法,只有全部合法才会为True
form_obj.is_valid()
False

# 3.对象.errors查看错误原因
form_obj.errors
{'password': ['Ensure this value has at least 2 characters (it has 1).'], 'email': ['Enter a valid email address.']}

# 4.对象.cleaned_data查看合法的数据
form_obj.cleaned_data
{'username': 'sxc'}

注意:1.自定义类中的所有字段都需要传值,当少一个字段时也会返回False

　　 2.但是我们可以额外传入类中没有定义的字段,只要类中的字段满足时就会返回True

3.form组件渲染页面

三种方式

第一种,封装程度太高

{#    第一种渲染方式,不推荐,封装程度太高,一般用于本地测试#}
    {{ form_obj.as_p }}
    {{ form_obj.as_table }}
    {{ form_obj.as_ul }}

第二种,书写麻烦

{#    第二种渲染方式,可扩展性高,但是书写麻烦#}
    <p>{{ form_obj.username.label }}{{ form_obj.username }}</p>
    <p>{{ form_obj.password.label }}{{ form_obj.password }}</p>
    <p>{{ form_obj.email.label }}{{ form_obj.email }}</p>

第三种,推荐

{#    第三种渲染方式,推荐#}
    {% for foo in form_obj %}
    <p>{{ foo.label }}{{ foo }}</p>
    {% endfor %}

注意:1.form组件在渲染页面的时候,只会获取用户在自定义类中定义的标签,提交按钮需要自己手动添加

　　 2.input框的label注释,不指定的情况下,默认使用的是类中字段的首字母大写,可以在自定义类的时候指定默认值

4.后端校验并展示错误信息

在校验数据的时候,前后端都可以校验,做一个双重校验

但是,前端的校验是可以可无的,因为很容易被修改,而后端的校验是必须要有的

上图就是前端自动识别后作出的校验

前端取消浏览器校验功能只要在form标签指定novalidate属性即可

<form action="" method="post" novalidate>

此时,我们就可以进行后端校验的测试

def form_login(request):
    # 1.先生成一个空的自定义对象
    form_obj = LoginForm()
    # 2.获取前端提交的数据进行校验
    if request.method == 'POST':
        # 校验form组件中的数据需要传入一个字典,而request.POST获取的数据就是一个字典
        form_obj = LoginForm(request.POST)
        if form_obj.is_valid():
            pass
    return render(request,'form_login.html',locals())

后端代码,foo.errors可以拿到错误信息,但会展示成列表的形式,加.0就能正常展示

{% for foo in form_obj %}
    <p>{{ foo.label }}{{ foo }}<span style="color:red;">{{ foo.errors.0 }}</span></p>
    {% endfor %}

输入不能为空可以修改为可以为空,只需要在限制条件required=False即可

email = forms.EmailField(label='邮箱',required=False,error_messages={
        'invalid':'邮箱格式不正确',
    })  # email必须是邮箱格式

补充:

自定义类中的限制条件也可以写正则表达式

# 先导入正则相关的模块
from django.core.validators import RegexValidator

# 在自定义类中声明的字段添加validators参数即可
phone = forms.CharField(
        validators=[RegexValidator(r'^[0-9]+$', '请输入数字'), RegexValidator(r'^159[0-9]+$', '数字必须以159开头')],
    )

5.form组件之钩子函数

局部钩子函数(针对某一个字段做出的额外校验)

# 局部钩子函数
    def clean_username(self):
        username = self.cleaned_data.get('username')
        if 'sb' in username:
            self.add_error('username','不能有非法字符')
        return username

全局钩子函数(针对多个字段做校验)

# 全局钩子函数(针对多个字段做校验)
    def clean(self):
        password = self.cleaned_data.get('password')
        confirm_password = self.cleaned_data.get('confirm_password')
        if password != confirm_password:
            self.add_error('confirm_password','两次密码不一致')
        return self.cleaned_data

6.form组件其他字段及操作方式

字段中的一些主要属性

required    是否必填
label         注释信息
error_messages    报错信息
initial        默认值
widget       控制标签属性和样式

from django.forms import widgets  # 先导入
widget=widgets.PasswordInput() 控制标签属性 
widget=widgets.PasswordInput(attrs={'class':'form-control c1 c2','username':'jason'})

常用字段与插件

创建Form类时，主要涉及到【字段】和【插件】，字段用于对用户请求数据的验证，插件用于自动生成HTML;

initial

初始值，input框里面的初始值。

class LoginForm(forms.Form):
    username = forms.CharField(
        min_length=8,
        label="用户名",
        initial="张三"  # 设置默认值
    )
    pwd = forms.CharField(min_length=6, label="密码")

error_messages

重写错误信息。

class LoginForm(forms.Form):
    username = forms.CharField(
        min_length=8,
        label="用户名",
        initial="张三",
        error_messages={
            "required": "不能为空",
            "invalid": "格式错误",
            "min_length": "用户名最短8位"
        }
    )
    pwd = forms.CharField(min_length=6, label="密码")

password

class LoginForm(forms.Form):
    ...
    pwd = forms.CharField(
        min_length=6,
        label="密码",
        widget=forms.widgets.PasswordInput(attrs={'class': 'c1'}, render_value=True)
    )

radioSelect

单radio值为字符串

class LoginForm(forms.Form):
    username = forms.CharField(
        min_length=8,
        label="用户名",
        initial="张三",
        error_messages={
            "required": "不能为空",
            "invalid": "格式错误",
            "min_length": "用户名最短8位"
        }
    )
    pwd = forms.CharField(min_length=6, label="密码")
    gender = forms.fields.ChoiceField(
        choices=((1, "男"), (2, "女"), (3, "保密")),
        label="性别",
        initial=3,
        widget=forms.widgets.RadioSelect()
    )

单选Select

class LoginForm(forms.Form):
    ...
    hobby = forms.ChoiceField(
        choices=((1, "篮球"), (2, "足球"), (3, "双色球"), ),
        label="爱好",
        initial=3,
        widget=forms.widgets.Select()
    )

多选Select

class LoginForm(forms.Form):
    ...
    hobby = forms.MultipleChoiceField(
        choices=((1, "篮球"), (2, "足球"), (3, "双色球"), ),
        label="爱好",
        initial=[1, 3],
        widget=forms.widgets.SelectMultiple()
    )

单选checkbox

class LoginForm(forms.Form):
    ...
    keep = forms.ChoiceField(
        label="是否记住密码",
        initial="checked",
        widget=forms.widgets.CheckboxInput()
    )

多选checkbox

class LoginForm(forms.Form):
    ...
    hobby = forms.MultipleChoiceField(
        choices=((1, "篮球"), (2, "足球"), (3, "双色球"),),
        label="爱好",
        initial=[1, 3],
        widget=forms.widgets.CheckboxSelectMultiple()
    )

三.cookie和seesion

cookie

Cookie的由来

大家都知道HTTP协议是无状态的。

无状态的意思是每次请求都是独立的，它的执行情况和结果与前面的请求和之后的请求都无直接关系，它不会受前面的请求响应情况直接影响，也不会直接影响后面的请求响应情况。

一句有意思的话来描述就是人生只如初见，对服务器来说，每次的请求都是全新的。

状态可以理解为客户端和服务器在某次会话中产生的数据，那无状态的就以为这些数据不会被保留。会话中产生的数据又是我们需要保存的，也就是说要“保持状态”。因此Cookie就是在这样一个场景下诞生。

什么是Cookie

Cookie具体指的是一段小信息，它是服务器发送出来存储在浏览器上的一组组键值对，下次访问服务器时浏览器会自动携带这些键值对，以便服务器提取有用信息。

Cookie的原理

cookie的工作原理是：由服务器产生内容，浏览器收到请求后保存在本地；当浏览器再次访问时，浏览器会自动带上Cookie，这样服务器就能通过Cookie的内容来判断这个是“谁”了。

Django中操作Cookie

Django返回给客户端浏览器的都必须是HttpResponse对象

return HttpResponse()
return render()
return redirect()
# 等价于下面的
obj1 = HttpResponse()
return obj1
obj2 = render()
return obj2
obj3 = redirect()
return obj3

设置cookie利用HttpResponse对象

obj.set_cookie('k1','v1')

获取cookie

request.COOKIE.get()

删除cookie

obj.delete_cookie('k1')

设置超时时间

max_age=None, 超时时间
expires=None, 超时时间(IE requires expires, so set it if hasn't been already.)(针对IE浏览器的)

from functools import wraps

def login_auth(func):
    @wraps(func)
    def inner(request,*args,**kwargs):
        target_url = request.get_full_path()
        if request.COOKIES.get('name'):
            res = func(request,*args,**kwargs)
            return res
        else:
            # 把用户登录前的页面放到url后缀中
            r_url = '/lg/?next=%s'%target_url
            return redirect(r_url)
    return inner


def lg(request):
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        if username == 'sxc' and password == '123':
            # 取出url后缀,如果用户之前在其他界面old_url就是其他页面,如果就是登录界面,就跳转到主页
            print(request.GET.get('next'))
            old_url = request.GET.get('next','/home/')
            # 保存用户状态
            obj = redirect(old_url)
            obj.set_cookie('name','sxc',max_age=80)
            return obj
    return render(request,'lg.html')

@login_auth
def home(request):
    return HttpResponse('这是home页面,登录才能看')

@login_auth
def index(request):
    return HttpResponse('这是index页面,登录才能看')

# 删除cookie
def logout(request):
    obj = redirect('/lg/')
    obj.delete_cookie('name')
    return obj

登录验证小例子

session

Session的由来

Cookie虽然在一定程度上解决了“保持状态”的需求，但是由于Cookie本身最大支持4096字节，以及Cookie本身保存在客户端，可能被拦截或窃取，因此就需要有一种新的东西，它能支持更多的字节，并且他保存在服务器，有较高的安全性。这就是Session。

问题来了，基于HTTP协议的无状态特征，服务器根本就不知道访问者是“谁”。那么上述的Cookie就起到桥接的作用。

我们可以给每个客户端的Cookie分配一个唯一的id，这样用户在访问时，通过Cookie，服务器就知道来的人是“谁”。然后我们再根据不同的Cookie的id，在服务器上保存一段时间的私密资料，如“账号密码”等等。

总结而言：Cookie弥补了HTTP无状态的不足，让服务器知道来的人是“谁”；但是Cookie以文本的形式保存在本地，自身安全性较差；所以我们就通过Cookie识别不同的用户，对应的在Session里保存私密的信息以及超过4096字节的文本。

另外，上述所说的Cookie和Session其实是共通性的东西，不限于语言和框架。

session就是保存在服务器上的键值对
    session虽然是保存在服务器上的键值对
    但是它是依赖于cookie工作的
    
    服务端返回给浏览器一个随机的字符串
    浏览器以键值对的形式保存
    sessionid:随机字符串
    
    浏览器在访问服务端的时候  就会将随机字符串携带上
    后端获取随机串与后端的记录的做比对
        随机字符串1:数据1
        随机字符串2:数据2

Django中Session相关方法

设置session

request.session['name'] = 'sxc'
"""
上面这一句话发生了三件事
    1.django 内部自动生成一个随机字符串
    2.将随机字符串和你要保存的数据 写入django_session表中(现在内存中生成一个缓存记录 等到经过中间件的时候才会执行)
    3.将产生的随机字符串发送给浏览器写入cookie
        sessionid:随机字符串
"""

获取session

request.session.get('name')
"""
上面这一句话发生了三件事
    1.django内部会自动从请求信息中获取到随机字符串
    2.拿着随机字符串去django_session表中比对
    3.一旦对应上了就将对应的数据解析出来放到request.session中
"""

# 获取、设置、删除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的key
request.session.session_key

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

# 检查会话session的key在数据库中是否存在
request.session.exists("session_key")

# 删除当前会话的所有Session数据
request.session.delete()  # 删除的是浏览器的sessionid信息
　　
# 删除当前的会话数据并删除会话的Cookie。
request.session.flush() # 将浏览器和服务端的全部删除
    这用于确保前面的会话数据不可以再次被用户的浏览器访问
    例如，django.contrib.auth.logout() 函数中就会调用它。

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

Session流程解析

Django session默认的超时时间是14天(面试容易问)

Django_session表中的一条记录针对一个浏览器,一个浏览器只会有一条记录

总结:你在后期可以将一些数据保存到session表中,保存的数据可以在后端任意位置获取到

查看全文

相关阅读:
hihoCoder#1128 二分·二分查找
 hihoCoder#1127 二分图三·二分图最小点覆盖和最大独立集
 hihoCoder#1122 二分图二•二分图最大匹配之匈牙利算法
 hihoCoder#1105 题外话·堆
 Ajax详细剖析
 web框架之--Tornado
web框架之--先来个介绍
 前端之--Jquery-玩穿它！
前端之--DOM详解应用
 前端之--JavaScript作用域--超细讲解

原文地址：https://www.cnblogs.com/sxchen/p/11582010.html