ORM 的字段DateField 和DateTimeField 以及TimeField的区别
存储的内容不同
DateField:
date() 日期
DateTimeField:
datetime() 日期时间
TimeField:
time() 时间
这个三个字段都有两个关键的属性:auto_now_add 和 auto_add
auto_now_add:
创建的时候自动填充当前时间
auto_add:
每次修改的时候自动把当前时间更新
关系字段的设计原则
1. ForeignKey(to='类名' ,related_name='xxx) -> 1对多 , 外键通常设置在多的那一个模型类中
2. ManyToMany(to='类名',related_name='xxx') -> 多对多, 外键通常设置在正向查询比较多的那一个模型类中
related_name的作用:
下面我们定义两个模型,买主和水果.一个买主对应多个水果.
lass Buyer(models.Model):
name = models.CharField(verbose_name='买主名', max_length=10)
Alipay_id = models.CharField(verbose_name='支付宝账号')
age = models.IntegerField(verbose_name='买主年龄',blank = True)
class Fruit(models.Model):
buyer = models.ForeignKey(Buyer, related_name='buyer_fruit')
fruit_name = models.CharField(verbose_name='水果名', max_length=10)
weight = models.FloatField(verbose_name='水果重量')
如果我们要查询某个买主都买了哪些水果的时候,我们一般先找到买主,再根据买主找到它对应的水果.
也就是说如果从1找到多.
#首先获得水果模型中外键指向的表中对象:
buyer = Buyer.objects.filter(age = 100).first()
#然后通过‘_set’方法获得子表中的数据:
fruits = buyer.fruit_set.all()
"""
django 默认每个主表的对象都有一个是外键的属性,可以通过它来查询到所有属于主表的子表的信息。
这个属性的名称默认是以子表的名称小写加上_set()来表示,这里我们的主表是buyer,字表是fruit,所以主表外键的属性就是fruit_set
"""
上面的fruit_set是django为对象buyer默认创建的外键的属性,个人建议采用自定义的方式定义主表的外键,这样使用时更熟悉一些吧!而related_name就实现这个功能,在字表中定义外键时,增加related_name字段指定这个字表在主表中对应的外键属性, 如下:
#首先获得水果模型中外键指向的表中对象:
buyer = Buyer.objects.filter(age = 100).first()
#然后通过子表中自定义的外键获取子表的所有信息:
fruits = buyer.buyer_fruit.all()
ORM操作必知必会13条
values()简单的说,可以理解成展示models指定列的值
单表查询之神奇的双下划线
models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
models.Tb1.objects.filter(name__contains="ven") # 获取name字段包含"ven"的
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
models.Tb1.objects.filter(id__range=[1, 3]) # id范围是1到3的,等价于SQL的bettwen and
类似的还有:startswith,istartswith, endswith, iendswith
date字段还可以:
models.Class.objects.filter(first_day__year=2017)
ForeignKey操作
正向查找之对象查找
(跨表)
book_obj = models.Book.objects.first()
book_obj.publisher.name # 获取书的对象关联的外键对象,然后取到它的属性名字
正向查找之字段查找
(跨表)
publisher_name = models.Book.objects.values('publisher__name')
反向操作之对象查找
(跨表)
publisher_obj = models.Publisher.objects().first()
all_books = publisher_obj.book_set.all #找出第一个出版社所有的书籍
titles = all_books.values_list('title') # 找出第一个出版社所有的书籍的所有的书名
基于related_name的查找:
反向操作之字段查找(跨表)
titles = models.Publisher.objects.values_list('book_title')
分组和聚合
聚合
把一些数据求和或者求平均值或者求最大值或者求最小值,或者统计一些字段出现的个数.
使用的聚合函数是aggregate()
aggregate()
是QuerySet的一个终止子句,意思就是说,它返回一个包含了一些键值对的字典.
其中字典的键是聚合值得标识符,值时计算出来的聚合值.键的名称是按照字段和聚合函数的名称中间加单下划线自动生成出来的.也可以自己指定.
>>> from django.db.models import Avg, Sum, Max, Min, Count
>>> models.Book.objects.all().aggregate(Avg("price"))
{'price__avg': 13.233333}
>>> models.Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 13.233333}
如果你想不止一个聚合值,可以使用如下方式
>>> models.Book.objects.all().aggregate(Avg("price"), Max("price"), Min("price"))
{'price__avg': 13.233333, 'price__max': Decimal('19.90'), 'price__min': Decimal('9.90')}
分组
我们先复习一下Sql语句,假设有一张公司员工表:
我们使用原生的SQL语句,按照部门分组求平均工资
select dept,AVG(salary) from employee group by dept;
ORM查询
Employee.objects.values("dept").annotate(avg=Avg('salary)).values(dept,'avg')
连表查询的分组
SQL查询
select dept.name, AVG(salary) from employee inner join dept on (employee.dept_id=dept.id) group by dept_id;
ORM查询
models.Dept.objects.all().annotate(avg=Avg("employee__salary")).values('name','avg').
更过示例
统计一本书的作者的个数
book_list = models.Book.objects().all().annocate(author_num=Count('author'))
for book_obj in book_list:
print(book_obj.author_num)
统计出每个出版社买的最便宜的书的价格
publisher_list = models.Publisher.objects.annocate(min_price=Min("price"))
for publisher_obj in publisher_list:
print(publisher_obj.min_price)
方法二
models.Book.objects.values("publisher_name").annocate(min_price=Min('price'))
统计不止一个作者的图书
models.Book.objects.annocate(author_num=Count('author')).filter(author_num_gt=1)
根据一本图书作者数量的多少查询集QuerySet进行排序
models.Book.objects.annocate(author_num=Count('author')).order_by('author_num')
查询各个作者出的书的总价格
models.Author.objects.annocate(sum_price=Sum('book_price')).values()
F 查询和 Q查询
首先简单点说 F的功能就是取出某个字段的值.
之前我们所有的比较也好,过滤也好都是将一个字段的值与常量做比较.如果我们要比较两个字段的值,该怎么办呢?
Django提供了F()模块,F()可以在查询中引用字段,来比较同一个model实例中两个不同字段的值.
示例1 查询评论数大于收藏数的书籍
Book.objects.filter(comment_num_gt=F('keep_num'))
Django 支持F() 对象之间以及F()对象和常数之间的加减乘除和取模的操作
models.Book.objects.filter(comment_num_lt=F('keep_num')*2)
修改操作也可以使用F函数,比如将每一本书的价格提高30元
models.Book.objects.all().update(F('price')+30)
注意F查询一定是在查询的基础上,也就是它之前必须是一个QuerySet对象
如果要修改char字段咋办?
如: 把所有的书名后面加上(第一版)
models.Book.objects.all().update(title=Concat(F('title'),Value("(''),Value('第一版'),Value(")")))
Q查询
Q的作用是包装查询的对象,可以进行& 和 | 操作,还可以取反(非),我们进行的一般的filter,多参数查询一般都是AND进行操作,如果想要进行or语句操作,就可以使用Q查询.
示例1: 查询作者名是小仙女或者小魔女的
models.Book.objects.filter(Q(author_name='小仙女')|Q(author_name='小魔女'))
更加复杂的操作: 查询作者名字是小仙女并且不是2018年出版的书的书名
models.Book.objects.filter(Q(author_name='小仙女') & ~Q(publisher_date_year=2018)).values_list('title')
查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数(关键字参数或Q 对象)都将"AND”在一起。但是,如果出现Q 对象,它必须位于所有关键字参数的前面。
例如:查询出版年份是2017或2018,书名中带物语的所有书。
models.Book.objects.filter(Q(publisher_date_year=2018) | Q(publisher_date_year=2017),title_icontains='物语')
锁和事务
MySql锁概述
MySql不同的存储引擎支持不同的锁机制.例如MyISAM和MEMORY存储引擎采用的是表级锁,而BDB存储引擎采用的是页面锁,也支持表级锁.而InnoDB既支持行级锁,也支持表级锁,默认使用行级锁.
Mysql的锁的性能大致上可以从它的如下方面来考虑性能: 开销,加锁速度,死锁,粒度,并发性能
表级锁:
开销小,加锁快,不会出现死锁.锁定粒度大,发生锁冲突的概率最高,并发最低(因为它锁定的范围最大)
行级锁:
开销大,加锁慢,会出现死锁.锁定粒度小,发生锁冲突的概率最低,并发最高(因为它锁定的范围最小)
页面锁:
开销和加锁时间都是介于表级锁和行级锁之间.
我们的MySQL数据库 ORM中的锁和事务
锁
select_for_update(nowait=False,skip_locked=False)
返回一个锁住行直到事务结束的查询集,如果数据库支持,它将生成一个SELECT ... FOR UPDATE 语句
entries = Entry.objects.select_for_update().filter(author=request.user)
所有匹配的行将被锁定,直到事务结束.这意味着可以通过锁防止数据被其他事务修改.
一般情况下如果其他事务锁定了相关行,那么本查询将被阻塞,直到锁释放.
如果这不想要使查询阻塞的话,使用select_for_update(nowait=True)。 如果其它事务持有冲突的锁, 那么查询将引发 DatabaseError 异常。你也可以使用select_for_update(skip_locked=True)忽略锁定的行。 nowait和skip_locked是互斥的,同时设置会导致ValueError。
目前,postgresql,oracle和mysql数据库后端支持select_for_update()。 但是,MySQL不支持nowait和skip_locked参数。
使用不支持这些选项的数据库后端(如MySQL)将nowait=True或skip_locked=True转换为select_for_update()将导致抛出DatabaseError异常,这可以防止代码意外终止。
事务
# encoding:utf-8
__author__ = 'Fioman'
__time__ = '2019/3/4 10:17'
import os
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE','BMS.settings')
import django
django.setup()
import datetime
try:
from django.db import transaction
with transaction.atomic():
new_publisher = models.Publisher.objcets.create(name='火星出版社')
models.Book.objects.create(title='橘子物语',publisher_date=datetime.date.today(),publisher_id=10)
except Exception as e:
print(str(e))
Django ORM执行原生的SQL语句
返回QuerySet的方法大全
##################################################################
# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
##################################################################
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):
# 是否有结果
Django终端打印SQL语句
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
ORM表关系
一对一
# 作者
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
phone = models.CharField(max_length=11)
detail = models.OneToOneField(to="AuthorDetail")
def __str__(self):
return self.name
# 作者详情
class AuthorDetail(models.Model):
addr = models.CharField(max_length=64)
email = models.EmailField()
什么时候使用一对一?
当一张表的某一些字段查询的比较频繁,另外一些字段查询的不是特别频繁.把不怎么常用的字段,单独拿出来做成一张表,然后用一对一关联起来.
优势
既保证了数据完整的保存了下来,又能保证大部分的检索更快.
ORM中的用法
detail = models.OneToOneField(to="AuthorDetail")
# 先获取Author对象,然后利用detail对象中属性,获取detail字段的属性值.
models.Author.objects().get(id=1).detail.addr
多对多关联关系的三种方式
方式1: 自行创建第三张表
class Book(models.Model):
title = models.CharField(max_length=32, verbose_name="书名")
class Author(models.Model):
name = models.CharField(max_length=32, verbose_name="作者姓名")
# 自己创建第三张表,分别通过外键关联书和作者
class Author2Book(models.Model):
author = models.ForeignKey(to="Author")
book = models.ForeignKey(to="Book")
class Meta:
unique_together = ("author", "book")
方法二: 通过ManyToManyField自动创建第三张表
class Book(models.Model):
title = models.CharField(max_length=32, verbose_name="书名")
# 通过ORM自带的ManyToManyField自动创建第三张表
class Author(models.Model):
name = models.CharField(max_length=32, verbose_name="作者姓名")
books = models.ManyToManyField(to="Book", related_name="authors")
方法三:设置ManyToManyField并指定自行创建的第三张表
class Book(models.Model):
title = models.CharField(max_length=32, verbose_name="书名")
# 自己创建第三张表,并通过ManyToManyField指定关联
class Author(models.Model):
name = models.CharField(max_length=32, verbose_name="作者姓名")
books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book"))
# through_fields接受一个2元组('field1','field2'):
# 其中field1是定义ManyToManyField的模型外键的名(author),field2是关联目标模型(book)的外键名。
class Author2Book(models.Model):
author = models.ForeignKey(to="Author")
book = models.ForeignKey(to="Book")
class Meta:
unique_together = ("author", "book")
注意:
当我们需要在第三张关系表中存储额外的字段时,就要使用第三种方式。
但是当我们使用第三种方式创建多对多关联关系时,就无法使用set、add、remove、clear方法来管理多对多的关系了,需要通过第三张表的model来管理多对多关系。
我们应该使用哪一种呢?
看情况:
1. 如果你第三张表没有额外的字段,就用第一种
2.如果你第三张表有额外的字段,就用第三中或者第一种
元信息
ORM查询的练习
查找所有书名里包含番茄的书
models.Book.objects.filter(title_contains='沙河')
查找出版日期是2017年的书
models.Book.objects.filter(publisher_date__year=2018)
查找出版日期是2017年的书名
models.Book.objects.filter(publisher_date_year=2018).values('name')
查找价格大于10元的书
models.Book.objects.filter(price__gt=10)
将所有的书按照价格倒序排序
modes.Book.objcets.all().order_by('-price')
或者
models.Book.objcets.all().order_by('price').reverse()
查找价格大于10元的书名和价格
models.Book.objects.filter(price__gt=10).values('title','price')
查找memo字段是空的书
models.Book.objects.filter(memo=null)
查询所有的书关联的出版社
ret = models.Book.objects().all().values_list('publisher_name')
print(ret)
print(ret.distinct()) # 对QuerySet去重
查找在北京的出版社
models.Publisher.objects.filter(city='北京')
查找名字以沙河开头的出版社
models.Publisher.objects.filter(city__startwith='沙河')
查找作者名字里面带“小”字的作者
查找年龄大于30岁的作者
查找手机号是155开头的作者
查找手机号是155开头的作者的姓名和年龄
查找书名是“番茄物语”的书的出版社
查找书名是“番茄物语”的书的出版社所在的城市
models.Book.objects.filter(title='番茄物语').values('publisher_city')
查找书名是“番茄物语”的书的出版社的名称
models.Book.objects.filter(title='番茄物语').
查找书名是沙河异闻录的书的作者的爱好(跨两张表)
models.Book.objects.filter(title='沙河异闻录').values('authors__detail__hobby')
查找书名是“番茄物语”的书的所有作者
查找书名是“番茄物语”的书的作者的年龄
查找书名是“番茄物语”的书的作者的手机号码
查找书名是“番茄物语”的书的作者的地址
查找书名是“番茄物语”的书的作者的邮箱
csrf 的简单用法
什么是csrf?
跨站请求伪造,我们的服务器的后端对于表单的提交是通过action来判断的,如果不用csrf_token机制的话,就没办法区分这个提交是不是来自本站.Django 的csrf_token,Django的中间件会在我们每次提交表单的时候,从服务器那里生成一个csrf_token.在提交的时候,会用这个隐藏的值进行校验,如果校验成功,则表示是本站的请求,允许提交,如果没有,则提交不成功.{%csrf_token%}
分页
books/?page=1/ 展示相应页数的数据.
当数据库中数据有很多,我们通常会在前端页面做分页展示。
分页的数据可以在前端页面实现,也可以在后端实现分页。
后端实现分页的原理就是每次只请求一页数据。
准备工作
我们使用脚本批量创建一些测试数据(将下面的代码保存到bulk_create.py文件中放到Django项目的根目录,直接执行即可。):
import os
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "about_orm.settings")
import django
django.setup()
from app01 import models
bulk_obj = (models.Publisher(name='沙河第{}出版社'.format(i)) for i in range(300))
models.Publisher.objects.bulk_create(bulk_obj)
自定义分页
def publisher_list(request):
# 从URL中取当前访问的页码数
try:
current_page = int(request.GET.get('page'))
except Exception as e:
# 取不到或者页码数不是数字都默认展示第1页
current_page = 1
# 总数据量
total_count = models.Publisher.objects.count()
# 定义每页显示多少条数据
per_page = 10
# 计算出总页码数
total_page, more = divmod(total_count, per_page)
if more:
total_page += 1
# 定义页面上最多显示多少页码(为了左右对称,一般设为奇数)
max_show = 11
half_show = max_show // 2
# 计算一下页面显示的页码范围
if total_page <= max_show: # 总页码数小于最大显示页码数
page_start = 1
page_end = total_page
elif current_page + half_show >= total_page: # 右边越界
page_end = total_page
page_start = total_page - max_show
elif current_page - half_show <= 1: # 左边越界
page_start = 1
page_end = max_show
else: # 正常页码区间
page_start = current_page - half_show
page_end = current_page + half_show
# 数据索引起始位置
data_start = (current_page-1) * per_page
data_end = current_page * per_page
publisher_list = models.Publisher.objects.all()[data_start:data_end]
# 生成页面上显示的页码
page_html_list = []
page_html_list.append('<nav aria-label="Page navigation"><ul class="pagination">')
# 加首页
first_li = '<li><a href="/publisher_list/?page=1">首页</a></li>'
page_html_list.append(first_li)
# 加上一页
if current_page == 1:
prev_li = '<li><a href="#"><span aria-hidden="true">«</span></a></li>'
else:
prev_li = '<li><a href="/publisher_list/?page={}"><span aria-hidden="true">«</span></a></li>'.format(current_page - 1)
page_html_list.append(prev_li)
for i in range(page_start, page_end + 1):
if i == current_page:
li_tag = '<li class="active"><a href="/publisher_list/?page={0}">{0}</a></li>'.format(i)
else:
li_tag = '<li><a href="/publisher_list/?page={0}">{0}</a></li>'.format(i)
page_html_list.append(li_tag)
# 加下一页
if current_page == total_page:
next_li = '<li><a href="#"><span aria-hidden="true">»</span></a></li>'
else:
next_li = '<li><a href="/publisher_list/?page={}"><span aria-hidden="true">»</span></a></li>'.format(current_page + 1)
page_html_list.append(next_li)
# 加尾页
page_end_li = '<li><a href="/publisher_list/?page={}">尾页</a></li>'.format(total_page)
page_html_list.append(page_end_li)
page_html_list.append('</ul></nav>')
page_html = "".join(page_html_list)
return render(request, "publisher_list.html", {"publisher_list": publisher_list, "page_html": page_html})
稳扎稳打版
封装保存版本
class Pagination(object):
"""自定义分页(Bootstrap版)"""
def __init__(self, current_page, total_count, base_url, per_page=10, max_show=11):
"""
:param current_page: 当前请求的页码
:param total_count: 总数据量
:param base_url: 请求的URL
:param per_page: 每页显示的数据量,默认值为10
:param max_show: 页面上最多显示多少个页码,默认值为11
"""
try:
self.current_page = int(current_page)
except Exception as e:
# 取不到或者页码数不是数字都默认展示第1页
self.current_page = 1
# 定义每页显示多少条数据
self.per_page = per_page
# 计算出总页码数
total_page, more = divmod(total_count, per_page)
if more:
total_page += 1
self.total_page = total_page
# 定义页面上最多显示多少页码(为了左右对称,一般设为奇数)
self.max_show = max_show
self.half_show = max_show // 2
self.base_url = base_url
@property
def start(self):
return (self.current_page-1) * self.per_page
@property
def end(self):
return self.current_page * self.per_page
def page_html(self):
# 计算一下页面显示的页码范围
if self.total_page <= self.max_show: # 总页码数小于最大显示页码数
page_start = 1
page_end = self.total_page
elif self.current_page + self.half_show >= self.total_page: # 右边越界
page_end = self.total_page
page_start = self.total_page - self.max_show
elif self.current_page - self.half_show <= 1: # 左边越界
page_start = 1
page_end = self.max_show
else: # 正常页码区间
page_start = self.current_page - self.half_show
page_end = self.current_page + self.half_show
# 生成页面上显示的页码
page_html_list = []
page_html_list.append('<nav aria-label="Page navigation"><ul class="pagination">')
# 加首页
first_li = '<li><a href="{}?page=1">首页</a></li>'.format(self.base_url)
page_html_list.append(first_li)
# 加上一页
if self.current_page == 1:
prev_li = '<li><a href="#"><span aria-hidden="true">«</span></a></li>'
else:
prev_li = '<li><a href="{}?page={}"><span aria-hidden="true">«</span></a></li>'.format(
self.base_url, self.current_page - 1)
page_html_list.append(prev_li)
for i in range(page_start, page_end + 1):
if i == self.current_page:
li_tag = '<li class="active"><a href="{0}?page={1}">{1}</a></li>'.format(self.base_url, i)
else:
li_tag = '<li><a href="{0}?page={1}">{1}</a></li>'.format(self.base_url, i)
page_html_list.append(li_tag)
# 加下一页
if self.current_page == self.total_page:
next_li = '<li><a href="#"><span aria-hidden="true">»</span></a></li>'
else:
next_li = '<li><a href="{}?page={}"><span aria-hidden="true">»</span></a></li>'.format(
self.base_url, self.current_page + 1)
page_html_list.append(next_li)
# 加尾页
page_end_li = '<li><a href="{}?page={}">尾页</a></li>'.format(self.base_url, self.total_page)
page_html_list.append(page_end_li)
page_html_list.append('</ul></nav>')
return "".join(page_html_list)
封装保存版使用示例
def publisher_list(request):
# 从URL中取当前访问的页码数
current_page = int(request.GET.get('page'))
# 比len(models.Publisher.objects.all())更高效
total_count = models.Publisher.objects.count()
page_obj = Pagination(current_page, total_count, request.path_info)
data = models.Publisher.objects.all()[page_obj.start:page_obj.end]
page_html = page_obj.page_html()
return render(request, "publisher_list.html", {"publisher_list": data, "page_html": page_html})
Cookie和Session
为什么需要Cookie?
HTTP协议是无状态的协议,也就是说服务器不会记录上次的请求状态,它会把每一次的请求当成一个全新的请求.
如果我们需要保存用户的一些状态,就需要一种机制.然后就引入了Cookie机制,Cookie就是用来保存用户的请求状态的.
Cookie的原理
用户第一次请求的时候,服务器会先判断有没有session ID,如果没有在响应的时候就给用户分配一个,然后将一些数据保存都服务器上,然后响应的时候会将一些标识用户信息的内容响应给用户.用户收到这些响应之后,会将这些信息以键值对的形式保存在浏览器上,当再次访问的时候,浏览器会带上这些cookie,然后服务器就知道了具体是谁请求的了.
Django中Cookie的操作
request.COOKIES['key']
request.get_signed_cookie(key,default=RAISE_ERROR,salt='',max_age=None)
- 参数:
default: 默认值
salt: 加密盐
max_age: 后台控制过期时间
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")
cookie版登录
Session
Cookie虽然在一定程度上解决了“保持状态”的需求,但是由于Cookie本身最大支持4096字节,以及Cookie本身保存在客户端,可能被拦截或窃取,因此就需要有一种新的东西,它能支持更多的字节,并且他保存在服务器,有较高的安全性。这就是Session。
问题来了,基于HTTP协议的无状态特征,服务器根本就不知道访问者是“谁”。那么上述的Cookie就起到桥接的作用。
我们可以给每个客户端的Cookie分配一个唯一的id,这样用户在访问时,通过Cookie,服务器就知道来的人是“谁”。然后我们再根据不同的Cookie的id,在服务器上保存一段时间的私密资料,如“账号密码”等等。
总结而言:Cookie弥补了HTTP无状态的不足,让服务器知道来的人是“谁”;但是Cookie以文本的形式保存在本地,自身安全性较差;所以我们就通过Cookie识别不同的用户,对应的在Session里保存私密的信息以及超过4096字节的文本。
另外,上述所说的Cookie和Session其实是共通性的东西,不限于语言和框架。
什么是Session?
Session是另一种记录客户状态的机制,不同的是Cookie保存在客户端浏览器中,而Session保存在服务器上。客户端浏览器访问服务器的时候,服务器把客户端信息以某种形式记录在服务器上。这就是Session。客户端浏览器再次访问时只需要从该Session中查找该客户的状态就可以了。
如果说Cookie机制是通过检查客户身上的“通行证”来确定客户身份的话,那么Session机制就是通过检查服务器上的“客户明细表”来确认客户身份。Session相当于程序在服务器上建立的一份客户档案,客户来访的时候只需要查询客户档案表就可以了。
Cookie和Session的区别?
1. Cookie数据存放在浏览器客户端上,而Session是存放在服务器上
2.Cookie不是很安全,别人可以分析存在的本地的Cookie并进行Cookie欺诈,考虑到安全的话应该使用Session
3.session会在一定的时间内保存到服务器上,当访问量增多的时候,会比较占用服务器的性能,所以考虑到性能方面,应该多使用Cookie
4.单个cookie保存的数据不得多于4K,很多浏览器都限制一个站点最多保存20条cookie
5.所以个人建议:
将登录信息等重要的信息存放为Session
其他信息不是很私密的如果需要保存,可以存放到Cookie中.
Ajax请求
什么是JSON
- Json是指JavaScript对象表示法(JavaScript Object Notation)
- Json独立于语言
- Json具有自我描述性,更容易理解
- Json使用JavaScript语法来描述对象,但是Json仍然独立于语言和平台.Json解析题和Json库支持许多不同的编程语言
合格的json对象
["one", "two", "three"]
{ "one": 1, "two": 2, "three": 3 }
{"names": ["张三", "李四"] }
[ { "name": "张三"}, {"name": "李四"} ]
不合格的json对象
{ name: "张三", 'age': 32 } // 属性名必须使用双引号
[32, 64, 128, 0xFFF] // 不能使用十六进制值
{ "name": "张三", "age": undefined } // 不能使用undefined
{ "name": "张三",
"birthday": new Date('Fri, 26 Aug 2011 07:13:10 GMT'),
"getName": function() {return this.name;} // 不能使用函数和日期对象
}
stringify与parse方法
JavaScript中关于JSON对象和字符串转换的两个方法:
JSON.parse(): 用于将一个Json字符串转换为JavaScript对象
JSON.parse('{"name":"Q1mi"}');
JSON.parse('{name:"Q1mi"}') ; // 错误
JSON.parse('[18,undefined]') ; // 错误
JSON.stringify(): 用于将JavaScript值转换为JSON字符串
JSON.stringify({'name':'mengmeng'})
AJAX 简介
AJAX(Asynchronous Javascript And XML)翻译成中文就是“异步的Javascript和XML”。即使用Javascript语言与服务器进行异步交互,传输的数据为XML(当然,传输的数据不只是XML)。
AJAX 不是新的编程语言,而是一种使用现有标准的新方法。
AJAX 最大的优点是在不重新加载整个页面的情况下,可以与服务器交换数据并更新部分网页内容。(这一特点给用户的感受是在不知不觉中完成请求和响应过程)
AJAX 不需要任何浏览器插件,但需要用户允许JavaScript在浏览器上执行。
同步交互:客户端发出一个请求后,需要等待服务器响应结束后,才能发出第二个请求;
异步交互:客户端发出一个请求后,无需等待服务器响应结束,就可以发出第二个请求。
Ajax示例
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>AJAX局部刷新实例</title>
</head>
<body>
<input type="text" id="i1">+
<input type="text" id="i2">=
<input type="text" id="i3">
<input type="button" value="AJAX提交" id="b1">
<script src="/static/jquery-3.2.1.min.js"></script>
<script>
$("#b1").on("click", function () {
$.ajax({
url:"/ajax_add/",
type:"GET",
data:{"i1":$("#i1").val(),"i2":$("#i2").val()},
success:function (data) {
$("#i3").val(data);
}
})
})
</script>
</body>
</html>
HTML部分代码
def ajax_demo1(request):
return render(request, "ajax_demo1.html")
def ajax_add(request):
i1 = int(request.GET.get("i1"))
i2 = int(request.GET.get("i2"))
ret = i1 + i2
return JsonResponse(ret, safe=False)
views.py
urlpatterns = [
...
url(r'^ajax_add/', views.ajax_add),
url(r'^ajax_demo1/', views.ajax_demo1),
...
]
urls.py
Ajax的常见应用场景
搜索引擎根据用户输入的关键字,自动提示检索关键字。
还有一个很重要的应用场景就是注册时候的用户名的查重。
其实这里就使用了AJAX技术!当文件框发生了输入变化时,使用AJAX技术向服务器发送一个请求,然后服务器会把查询到的结果响应给浏览器,最后再把后端返回的结果展示出来。
整个过程中页面没有刷新,只是刷新页面中的局部位置而已!
当请求发出后,浏览器还可以进行其他操作,无需等待服务器的响应!
当输入用户名后,把光标移动到其他表单项上时,浏览器会使用AJAX技术向服务器发出请求,服务器会查询名为lemontree7777777的用户是否存在,最终服务器返回true表示名为lemontree7777777的用户已经存在了,浏览器在得到结果后显示“用户名已被注册!”。
整个过程中页面没有刷新,只是局部刷新了;
在请求发出后,浏览器不用等待服务器响应结果就可以进行其他操作;
Ajax的优缺点
优点:
AJAX使用JavaScript技术向服务器发送异步请求;
AJAX请求无须刷新整个页面;
因为服务器响应内容不再是整个页面,而是页面中的部分内容,所以AJAX性能高;
AJAX请求如何设置csrf_token
通过隐藏的input标签中的csrfmiddlewaretoken值,放置在data中发送
方法1
$.ajax({
url: "/cookie_ajax/",
type: "POST",
data: {
"username": "Q1mi",
"password": 123456,
"csrfmiddlewaretoken": $("[name = 'csrfmiddlewaretoken']").val() // 使用jQuery取出csrfmiddlewaretoken的值,拼接到data中
},
success: function (data) {
console.log(data);
}
})
方法2
通过获取返回的cookie中的字符串 放置在请求头中发送。
注意:需要引入一个jquery.cookie.js插件。
$.ajax({
url: "/cookie_ajax/",
type: "POST",
headers: {"X-CSRFToken": $.cookie('csrftoken')}, // 从Cookie取csrftoken,并设置到请求头中
data: {"username": "Q1mi", "password": 123456},
success: function (data) {
console.log(data);
}
})
或者用自己写一个getCookie方法:
function getCookie(name) {
var cookieValue = null;
if (document.cookie && document.cookie !== '') {
var cookies = document.cookie.split(';');
for (var i = 0; i < cookies.length; i++) {
var cookie = jQuery.trim(cookies[i]);
// Does this cookie string begin with the name we want?
if (cookie.substring(0, name.length + 1) === (name + '=')) {
cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
break;
}
}
}
return cookieValue;
}
var csrftoken = getCookie('csrftoken');
每一次都这么写太麻烦了,可以使用$.ajaxSetup()方法为ajax请求统一设置。
function csrfSafeMethod(method) {
// these HTTP methods do not require CSRF protection
return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
}
$.ajaxSetup({
beforeSend: function (xhr, settings) {
if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
xhr.setRequestHeader("X-CSRFToken", csrftoken);
}
}
});
注意:
如果使用从cookie中取csrftoken的方式,需要确保cookie存在csrftoken值。
如果你的视图渲染的HTML文件中没有包含 {% csrf_token %},Django可能不会设置CSRFtoken的cookie。
这个时候需要使用ensure_csrf_cookie()装饰器强制设置Cookie。
django.views.decorators.csrf import ensure_csrf_cookie
@ensure_csrf_cookie
def login(request):
pass
Ajax上传文件
XMLHttpRequest 是一个浏览器接口,通过它,我们可以使得 Javascript 进行 HTTP (S) 通信。XMLHttpRequest 在现在浏览器中是一种常用的前后台交互数据的方式。2008年 2 月,XMLHttpRequest Level 2 草案提出来了,相对于上一代,它有一些新的特性,其中 FormData 就是 XMLHttpRequest Level 2 新增的一个对象,利用它来提交表单、模拟表单提交,当然最大的优势就是可以上传二进制文件。下面就具体
首先看一下formData的基本用法:FormData对象,可以把所有表单元素的name与value组成一个queryString,提交到后台。只需要把 form 表单作为参数传入 FormData 构造函数即可:
介绍一下如何利用 FormData 来上传文件。
// 上传文件示例
$("#b3").click(function () {
var formData = new FormData();
formData.append("csrfmiddlewaretoken", $("[name='csrfmiddlewaretoken']").val());
formData.append("f1", $("#f1")[0].files[0]);
$.ajax({
url: "/upload/",
type: "POST",
processData: false, // 告诉jQuery不要去处理发送的数据
contentType: false, // 告诉jQuery不要去设置Content-Type请求头
data: formData,
success:function (data) {
console.log(data)
}
})
})
或者使用
var form = document.getElementById("form1");
var fd = new FormData(form);
这样也可以直接通过ajax的send()方法将fd发送到后台
注意:由于FormData是XMLHttpRequest Level2 新增的接口,现在低于IE10 的IE浏览器不支持FormData
练习(用户名是否已被注册)
功能介绍
在注册表单中,当用户填写了用户名后,把光标移开后,会自动向服务器发送异步请求。服务器返回这个用户名是否已经被注册过。
案例分析
页面中给出注册表单;
在username input标签中绑定onblur事件处理函数。
当input标签失去焦点后获取 username表单字段的值,向服务端发送AJAX请求;
django的视图函数中处理该请求,获取username值,判断该用户在数据库中是否被注册,如果被注册了就返回“该用户已被注册”,否则响应“该用户名可以注册”。
Form和ModelForm组件
Form介绍
我们之前在HTML页面中利用form表单向后端提交数据时,都会写一些获取用户输入的标签并且用form标签把它们包起来。
与此同时我们在好多场景下都需要对用户的输入做校验,比如校验用户是否输入,输入的长度和格式等正不正确。如果用户输入的内容有错误就需要在页面上相应的位置显示对应的错误信息.。
Django form组件就实现了上面所述的功能。
总结一下,其实form组件的主要功能如下:
- 生成页面可用的HTML标签
- 对用户提交的数据进行校验
- 保留上次输入内容
普通方式手写注册功能
def register(request):
if request.method == 'POST':
# 获取数据
username = request.POST.get('username')
password = request.POST.get('password')
# 判断数据
if not all([username, password, len(username) > 6, len(password) > 5]):
return render(request, 'register.html', {'error_msg': '用户名或密码错误,请重新输入'})
else:
return HttpResponse('注册成功!')
return render(request, 'register.html')
使用Django的Form类,来进行验证
首先,定义一个Form类,在forms.py中
from django import forms
# 按照Django form组件的要求写一个自己的类
class RegisterForm(forms.Form):
username = forms.CharField(label='用户名')
password = forms.CharField(label='密码')
再写一个视图函数
# 使用form组件实现注册方式
def register2(request):
form_obj = RegForm()
if request.method == "POST":
# 实例化form对象的时候,把post提交过来的数据直接传进去
form_obj = RegForm(request.POST)
# 调用form_obj校验数据的方法
if form_obj.is_valid():
return HttpResponse("注册成功")
return render(request, "register2.html", {"form_obj": form_obj})
Form常用的字段和插件
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)
)
使用form表单的自动解析方式,在后端使用Form表单书写字段,然后将form_obj传递给前端
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>注册2</title>
</head>
<body>
<form action="/register2/" method="post">
{% csrf_token %}
{{ form_obj.as_p }}
{{ form_obj.errors }}
<p><input type="submit" value="提交"></p>
</form>
</body>
</html>
单radio值为字符串
gender = forms.ChoiceField(
choices=((1, '男'), (2, '女'), (3, '保密')),
label='性别',
initial=3,
widget=widgets.RadioSelect,
)
单选select
hobby = forms.ChoiceField(
choices=((1,'篮球'),(2,'足球'),(3,'双色球'),),
label='爱好',
initial=3,
widget=forms.widgets.Select,
)
多选select
hobby1 = forms.MultipleChoiceField(
choices=((1,'篮球'),(2,'足球'),(3,'双色球')),
label='爱好',
initial=[1,3],
widget=forms.widgets.SelectMultiple,
)
单选checkbox
keep = forms.ChoiceField(
label='是否记住密码',
initial='checked',
widget=forms.widgets.CheckboxInput,
)
多选checkbox
hobby2 = forms.fields.MultipleChoiceField(
choices=((1, '篮球'), (2, '足球'), (3, '双色球')),
label='爱好',
initial=[1, 3],
widget=forms.widgets.CheckboxSelectMultiple,
)
choice字段注意事项
在使用选择标签的时候,需要注意choices的选项可以配置从数据库中获取,但是由于是静态字段,获取的值无法无法实时更新,需要重写构造方法从而实现choice实时更新.
方法一:
class Myform(forms.Form):
user = forms.ChoiceField(
# choices=((1,'上海'),(2,'北京')),
initial=2,
widget=widgets.Select,
)
def __init__(self, *args, **kwargs):
super(Myform,self).__init__(*args,**kwargs)
self.fields['user'].choices = Book.objects.all().values_list('id','caption')
方法二:
class BookForm(forms.Form):
authors = forms.models.ModelMultipleChoiceField(queryset=Book.objects.all()) #多选
authors = forms.models.ModelChoiceField(queryset=Book.objects.all()) # 单选
Django form的所有的内置字段
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类型
Django Form内置字段
字段校验
RegexValidator验证器
from django.forms import Form
from django.forms import widgets
from django.forms import fields
from django.core.validators import RegexValidator
class MyForm(Form):
user = fields.CharField(
validators=[RegexValidator(r'^[0-9]+$', '请输入数字'), RegexValidator(r'^159[0-9]+$', '数字必须以159开头')],
)
自定义验证函数
import re
from django.forms import Form
from django.forms import widgets
from django.forms import fields
from django.core.exceptions import ValidationError
# 自定义验证规则
def mobile_validate(value):
mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
if not mobile_re.match(value):
raise ValidationError('手机号码格式错误')
class PublishForm(Form):
title = fields.CharField(max_length=20,
min_length=5,
error_messages={'required': '标题不能为空',
'min_length': '标题最少为5个字符',
'max_length': '标题最多为20个字符'},
widget=widgets.TextInput(attrs={'class': "form-control",
'placeholder': '标题5-20个字符'}))
# 使用自定义验证规则
phone = fields.CharField(validators=[mobile_validate, ],
error_messages={'required': '手机不能为空'},
widget=widgets.TextInput(attrs={'class': "form-control",
'placeholder': u'手机号码'}))
email = fields.EmailField(required=False,
error_messages={'required': u'邮箱不能为空','invalid': u'邮箱格式错误'},
widget=widgets.TextInput(attrs={'class': "form-control", 'placeholder': u'邮箱'}))
Hook方法
除了以上两种方式外,我们还可以在Form类中定义钩子函数,来实现自定义的验证功能.
局部钩子
我们在Form类中定义clean_字段名()方法,就能够实现对特定字段进行校验
class LoginForm(forms.Form):
username = forms.CharField(
min_length=8,
label="用户名",
initial="张三",
error_messages={
"required": "不能为空",
"invalid": "格式错误",
"min_length": "用户名最短8位"
},
widget=forms.widgets.TextInput(attrs={"class": "form-control"})
)
...
# 定义局部钩子,用来校验username字段
def clean_username(self):
value = self.cleaned_data.get("username")
if "666" in value:
raise ValidationError("光喊666是不行的")
else:
return value
全局钩子
我们在Form类中定义clean()方法,就能够实现对字段进行全局校验
class LoginForm(forms.Form):
...
password = forms.CharField(
min_length=6,
label="密码",
widget=forms.widgets.PasswordInput(attrs={'class': 'form-control'}, render_value=True)
)
re_password = forms.CharField(
min_length=6,
label="确认密码",
widget=forms.widgets.PasswordInput(attrs={'class': 'form-control'}, render_value=True)
)
...
# 定义全局的钩子,用来校验密码和确认密码字段是否相同
def clean(self):
password_value = self.cleaned_data.get('password')
re_password_value = self.cleaned_data.get('re_password')
if password_value == re_password_value:
return self.cleaned_data
else:
self.add_error('re_password', '两次密码不一致')
raise ValidationError('两次密码不一致')
ModelForm
通常在Django项目中,我们编写的大部分都是与Django 的模型紧密映射的表单。 举个例子,你也许会有个Book 模型,并且你还想创建一个form表单用来添加和编辑书籍信息到这个模型中。 在这种情况下,在form表单中定义字段将是冗余的,因为我们已经在模型中定义了那些字段。
基于这个原因,Django 提供一个辅助类来让我们可以从Django 的模型创建Form,这就是ModelForm。
modelform的定义
class BookForm(forms.ModelForm):
class Meta:
model = models.Book
fields = "__all__"
labels = {
"title": "书名",
"price": "价格"
}
widgets = {
"password": forms.widgets.PasswordInput(attrs={"class": "c1"}),
}
class Meta下常用参数:
model = models.Book # 对应的Model中的类
fields = "__all__" # 字段,如果是__all__,就是表示列出所有的字段
exclude = None # 排除的字段
labels = None # 提示信息
help_texts = None # 帮助提示信息
widgets = None # 自定义插件
error_messages = None # 自定义错误信息
ModelForm的验证
与普通的Form表单验证类型类似,ModelForm表单的验证在调用is_valid() 或访问errors 属性时隐式调用。
我们可以像使用Form类一样自定义局部钩子方法和全局钩子方法来实现自定义的校验规则。
如果我们不重写具体字段并设置validators属性的化,ModelForm是按照模型中字段的validators来校验的。
save()方法
每个ModelForm还具有一个save()方法。 这个方法根据表单绑定的数据创建并保存数据库对象。 ModelForm的子类可以接受现有的模型实例作为关键字参数instance;如果提供此功能,则save()将更新该实例。 如果没有提供,save() 将创建模型的一个新实例:
>>> from myapp.models import Book
>>> from myapp.forms import BookForm
# 根据POST数据创建一个新的form对象
>>> form_obj = BookForm(request.POST)
# 创建书籍对象
>>> new_ book = form_obj.save()
# 基于一个书籍对象创建form对象
>>> edit_obj = Book.objects.get(id=1)
# 使用POST提交的数据更新书籍对象
>>> form_obj = BookForm(request.POST, instance=edit_obj)
>>> form_obj.save()
网友评论