目录
一、Model
二、admin
三、Form组件
四、Cookie
五、Session
六、分页
七、序列化
一、Model
数据库的配置
1、django默认支持sqlite，mysql, oracle,postgresql数据库。
<1> sqlite
django默认使用sqlite的数据库，默认自带sqlite的数据库驱动 , 引擎名称：django.db.backends.sqlite3
<2> mysql
引擎名称：django.db.backends.mysql
2、mysql驱动程序
- MySQLdb(mysql python2中用)
- mysqlclient
- MySQL
- PyMySQL(纯python的mysql驱动程序，python3用)
3、在django的项目中会默认使用sqlite数据库，在settings里有如下设置：
创建数据库表的步骤：
1、创建model；
2、创建生成数据库的py文件：python manage.py makemigrations ；
3、创建数据库表：python manage.py migrate；
注意：记得在settings里的INSTALLED_APPS中加入'app01',然后再同步数据库。
打开pycharm右侧的databases，把创建好的db.sqlite3数据库拖过去，就可以操作数据库表了，这里我们不用操心数据库名的问题；
如果我们想要使用别的数据库，比如Mysql需要修改如下：
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'books', #你的数据库名称
'USER': 'root', #你的数据库用户名
'PASSWORD': '', #你的数据库密码
'HOST': '', #你的数据库主机，留空默认为localhost
'PORT': '', #你的数据库端口
}
}
注意：
NAME即数据库的名字，在mysql连接前该数据库必须已经创建，而上面的sqlite数据库下的db.sqlite3则是项目自动创建 USER和PASSWORD分别是数据库的用户名和密码。 设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。 然后，启动项目，会报错：no module named MySQLdb 这是因为django默认你导入的驱动是MySQLdb，可是MySQLdb对于py3有很大问题，所以我们需要的驱动是PyMySQL 所以，我们只需要找到项目名文件下的__init__,在里面写入： import pymysql
pymysql.install_as_MySQLdb() 问题解决！
4、ORM(对象关系映射)
关系对象映射（Object Relational Mapping，简称ORM），用于实现面向对象编程语言里不同类型系统的数据之间的转换，换言之，就是用面向对象的方式去操作数据库的创建表以及增删改查等操作。
优点： 1、ORM使得我们的通用数据库交互变得简单易行，而且完全不用考虑该死的SQL语句。快速开发，由此而来。
2、可以避免一些新手程序猿写sql语句带来的性能问题。
缺点：1、性能有所牺牲，不过现在的各种ORM框架都在尝试各种方法，比如缓存，延迟加载登来减轻这个问题。效果很显著。
2、对于个别复杂查询，ORM仍然力不从心，为了解决这个问题，ORM一般也支持写raw sql。
3、通过QuerySet的query属性查询对应操作的sql语句
author_obj=models.Author.objects.filter(id=2)
print(author_obj.query)
ORM语法
1、创建表
- 基本结构
from django.db import models
class Userinfo(models.Model):
name = models.CharField(max_length=30)
email = models.EmailField()
memo = models.TextField()
- 模型常用的字段类型参数
<1> CharField
#字符串字段, 用于较短的字符串.
#CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数. <2> IntegerField
#用于保存一个整数. <3> FloatField
# 一个浮点数. 必须 提供两个参数:
#
# 参数 描述
# max_digits 总位数(不包括小数点和符号)
# decimal_places 小数位数
# 举例来说, 要保存最大值为 999 (小数点后保存2位),你要这样定义字段:
#
# models.FloatField(..., max_digits=5, decimal_places=2)
# 要保存最大值一百万(小数点后保存10位)的话,你要这样定义:
#
# models.FloatField(..., max_digits=19, decimal_places=10)
# admin 用一个文本框(<input type="text">)表示该字段保存的数据. <4> AutoField
# 一个 IntegerField, 添加记录时它会自动增长. 你通常不需要直接使用这个字段;
# 自定义一个主键：my_id=models.AutoField(primary_key=True)
# 如果你不指定主键的话,系统会自动添加一个主键字段到你的 model. <5> BooleanField
# A true/false field. admin 用 checkbox 来表示此类字段. <6> TextField
# 一个容量很大的文本字段.
# admin 用一个 <textarea> (文本区域)表示该字段数据.(一个多行编辑框). <7> EmailField
# 一个带有检查Email合法性的 CharField,不接受 maxlength 参数. <8> DateField
# 一个日期字段. 共有下列额外的可选参数:
# Argument 描述
# auto_now 当对象被保存时,自动将该字段的值设置为当前时间.通常用于表示 "last-modified" 时间戳.
# auto_now_add 当对象首次被创建时,自动将该字段的值设置为当前时间.通常用于表示对象创建时间.
#（仅仅在admin中有意义...) <9> DateTimeField
# 一个日期时间字段. 类似 DateField 支持同样的附加选项. <10> ImageField
# 类似 FileField, 不过要校验上传对象是否是一个合法图片.#它有两个可选参数:height_field和width_field,
# 如果提供这两个参数,则图片将按提供的高度和宽度规格保存.
<11> FileField
# 一个文件上传字段.
#要求一个必须有的参数: upload_to, 一个用于保存上载文件的本地文件系统路径. 这个路径必须包含 strftime #formatting,
#该格式将被上载文件的 date/time
#替换(so that uploaded files don't fill up the given directory).
# admin 用一个<input type="file">部件表示该字段保存的数据(一个文件上传部件) . #注意：在一个 model 中使用 FileField 或 ImageField 需要以下步骤:
#（1）在你的 settings 文件中, 定义一个完整路径给 MEDIA_ROOT 以便让 Django在此处保存上传文件.
# (出于性能考虑,这些文件并不保存到数据库.) 定义MEDIA_URL 作为该目录的公共 URL. 要确保该目录对
# WEB服务器用户帐号是可写的.
#（2） 在你的 model 中添加 FileField 或 ImageField, 并确保定义了 upload_to 选项,以告诉 Django
# 使用 MEDIA_ROOT 的哪个子目录保存上传文件.你的数据库中要保存的只是文件的路径(相对于 MEDIA_ROOT).
# 出于习惯你一定很想使用 Django 提供的 get_<#fieldname>_url 函数.举例来说,如果你的 ImageField
# 叫作 mug_shot, 你就可以在模板中以 {{ object.#get_mug_shot_url }} 这样的方式得到图像的绝对路径. <12> URLField
# 用于保存 URL. 若 verify_exists 参数为 True (默认), 给定的 URL 会预先检查是否存在( 即URL是否被有效装入且
# 没有返回404响应).
# admin 用一个 <input type="text"> 文本框表示该字段保存的数据(一个单行编辑框) <13> NullBooleanField
# 类似 BooleanField, 不过允许 NULL 作为其中一个选项. 推荐使用这个字段而不要用 BooleanField 加 null=True 选项
# admin 用一个选择框 <select> (三个可选择的值: "Unknown", "Yes" 和 "No" ) 来表示这种字段数据. <14> SlugField
# "Slug" 是一个报纸术语. slug 是某个东西的小小标记(短签), 只包含字母,数字,下划线和连字符.#它们通常用于URLs
# 若你使用 Django 开发版本,你可以指定 maxlength. 若 maxlength 未指定, Django 会使用默认长度: 50. #在
# 以前的 Django 版本,没有任何办法改变50 这个长度.
# 这暗示了 db_index=True.
# 它接受一个额外的参数: prepopulate_from, which is a list of fields from which to auto-#populate
# the slug, via JavaScript,in the object's admin form: models.SlugField
# (prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields. <13> XMLField
#一个校验值是否为合法XML的 TextField,必须提供参数: schema_path, 它是一个用来校验文本的 RelaxNG schema #的文件系统路径. <14> FilePathField
# 可选项目为某个特定目录下的文件名. 支持三个特殊的参数, 其中第一个是必须提供的.
# 参数 描述
# path 必需参数. 一个目录的绝对文件系统路径. FilePathField 据此得到可选项目.
# Example: "/home/images".
# match 可选参数. 一个正则表达式, 作为一个字符串, FilePathField 将使用它过滤文件名.
# 注意这个正则表达式只会应用到 base filename 而不是
# 路径全名. Example: "foo.*\.txt^", 将匹配文件 foo23.txt 却不匹配 bar.txt 或 foo23.gif.
# recursive可选参数.要么 True 要么 False. 默认值是 False. 是否包括 path 下面的全部子目录.
# 这三个参数可以同时使用.
# match 仅应用于 base filename, 而不是路径全名. 那么,这个例子:
# FilePathField(path="/home/images", match="foo.*", recursive=True)
# ...会匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif <15> IPAddressField
# 一个字符串形式的 IP 地址, (i.e. "24.124.1.30").
<16># CommaSeparatedIntegerField
# 用于存放逗号分隔的整数值. 类似 CharField, 必须要有maxlength参数.
- Field重要参数
<1> null ： 数据库中字段是否可以为空
<2> blank： django的 Admin 中添加数据时是否可允许空值
<3> default：设定缺省值
<4> editable：如果为假，admin模式下将不能改写。缺省为真
<5> primary_key：设置主键，如果没有设置django创建表时会自动加上：
id = meta.AutoField('ID', primary_key=True)
primary_key=True implies blank=False, null=False and unique=True. Only one
primary key is allowed on an object.
<6> unique：数据唯一
<7> verbose_name Admin中字段的显示名称
<8> validator_list：有效性检查。非有效产生 django.core.validators.ValidationError 错误
<9> db_column，db_index 如果为真将为此字段创建索引
<10>choices：一个用来选择值的2维元组。第一个值是实际存储的值，第二个用来方便进行选择。
如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),)
gender = models.CharField(max_length=2,choices = SEX_CHOICES)
2、操作表
a、基本操作
---------------------增(create , save) ---------------------
from app01.models import *
#create方式一: Author.objects.create(name='Alvin')
#create方式二: Author.objects.create(**{"name":"alex"})
#save方式一: author=Author(name="alvin")
author.save()
#save方式二: author=Author()
author.name="alvin"
author.save()
---------------------删（delete） -------------------------
Book.objects.filter(id=1).delete()
---------------------改（update和save）------------------
# 方法一，get只能得到一个对象
book = Book.objects.get(author='charlie')
book.price = 200
book.save()
# 方法二，推荐使用
Book.objects.filter(name='python').update(price=100)
注意：
<1> 第二种方式修改不能用get的原因是：update是QuerySet对象的方法，
get返回的是一个model对象，它没有update方法，而filter返回的是一个QuerySet对象
(filter里面的条件可能有多个条件符合，比如name＝'alvin',可能有两个name＝'alvin'的行数据)。
<2>在“插入和更新数据”小节中，我们有提到模型的save()方法，这个方法会
更新一行里的所有列。 而某些情况下，我们只需要更新行里的某几列。
---------------------查（filter，value等) ----------------------
# <1>filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
# <2>all(): 查询所有结果
# <3>get(**kwargs):
'''返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的
#对象超过一个或者没有都会抛出错误。'''
#下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------
# <4>values(*field):
'''返回一个ValueQuerySet——一个特殊的QuerySet，
运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列'''
# <5>exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
# <6>order_by(*field): 对查询结果排序
# <7>reverse(): 对查询结果反向排序
# <8>distinct(): 从返回结果中剔除重复纪录，all()后面跟去重没用，因为ID没有重复，只有在values()后面跟去重才有用，对某一个字段进行去重；
# <9>values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
# <10>count(): 返回数据库中匹配查询(QuerySet)的对象数量。
# <11>first(): 返回第一条记录
# <12>last(): 返回最后一条记录
# <13>exists(): 如果QuerySet包含数据，就返回True，否则返回False。
实例：
models文件内容
from django.db import models class Book(models.Model):
name = models.CharField(max_length=20)
price = models.IntegerField()
pub_data = models.DateField()
author = models.CharField(max_length=20,null=False)
def __str__(self):
return self.name class Author(models.Model):
name = models.CharField(max_length=20)
age = models.IntegerField()
view文件内容
#view.py
def addbook(request):
# 添加表记录方法一
book = Book(name='python',price=99,pub_data='2018-2-8',author='charlie')
book.save()
# 方法二
Book.objects.create(name='php',price=88,pub_data='2018-10-8',author='oldboy')
# Book.objects.create(**dic)添加字典内容
return HttpResponse('添加成功') def update(request):
# 方法一，get用于只得到一个对象，如果对象重复就报错
# 这种方法会把所有的字段都重新赋值，效率低
book = Book.objects.get(id=1)
book.price = 998
book.save()
# 方法二，推荐使用,update是Queryset方法，只更新查询到的记录
Book.objects.filter(name='python').update(price=150)
return HttpResponse('修改成功') def select(request):
book_list = Book.objects.all()
book_list = Book.objects.all()[:3]#前三个
book_list = Book.objects.all()[::2]#每两个取一个
book_list = Book.objects.all()[::-1]#倒着取
# value只取指定的字段，得到一个查询集，内容是一个字典
ret = Book.objects.filter(name='charlie').values('name','price')
# 得到一个查询集，内容是一个列表，列表元素是元组
ret = Book.objects.filter(name='charlie').values_list('name','price')
return render(request,'index.html',locals())
- 提示：对于每次创建一个对象，想显示对应的raw sql，需要在settings加上日志记录部分：
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
b、利用双下划线方法进行模糊匹配
# 获取个数
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 # isnull
Entry.objects.filter(pub_date__isnull=True) #某字段是否可以为空 # contains
#
models.Tb1.objects.filter(name__contains="ven") #内容里包含某字符串
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
models.Tb1.objects.exclude(name__icontains="ven") #内容里没有某字段（不区分大小写） # 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'))
SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id" # limit 、offset
#
models.Tb1.objects.all()[10:20] # regex正则匹配，iregex 不区分大小写
#
Entry.objects.get(title__regex=r'^(An?|The) +')
Entry.objects.get(title__iregex=r'^(an?|the) +') # date
#
Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1)) # year
#
Entry.objects.filter(pub_date__year=2005)
Entry.objects.filter(pub_date__year__gte=2005) # month
#
Entry.objects.filter(pub_date__month=12)
Entry.objects.filter(pub_date__month__gte=6) # day
#
Entry.objects.filter(pub_date__day=3)
Entry.objects.filter(pub_date__day__gte=3) # week_day
#
Entry.objects.filter(pub_date__week_day=2)
Entry.objects.filter(pub_date__week_day__gte=2) # hour
#
Event.objects.filter(timestamp__hour=23)
Event.objects.filter(time__hour=5)
Event.objects.filter(timestamp__hour__gte=12) # minute
#
Event.objects.filter(timestamp__minute=29)
Event.objects.filter(time__minute=46)
Event.objects.filter(timestamp__minute__gte=29) # second
#
Event.objects.filter(timestamp__second=31)
Event.objects.filter(time__second=2)
Event.objects.filter(timestamp__second__gte=31)
c、连表操作（了不起的双下划线）
- 外键参数设置
#Django升级到2版本之后models.ForeignKey()需要填写on_delect参数
on_delete=models.CASCADE, # 删除关联数据,与之关联也删除
on_delete=models.DO_NOTHING, # 删除关联数据,什么也不做，最好不要；
on_delete=models.PROTECT, # 删除关联数据,引发错误ProtectedError
on_delete=models.SET_DEFAULT #设置默认值，前提是ForeignKey必须设置的默认值；
on_delete=models.SET(...)
'''设置给定值，或者如果传入了callable，则调用它的结果。
在大多数情况下，为了避免在导入models.py时执行查询，必须传递callable'''
on_delete=models.SET_NULL, # 删除关联数据,与之关联的值设置为null（前提FK字段需要设置为可空,一对一同理）
# 例如：models.ForeignKey('关联表', on_delete=models.SET_NULL, blank=True, null=True)
- 一对多操作
- models.py
#models.py
from django.db import models class Book(models.Model):
'''书籍'''
name = models.CharField(max_length=20)
price = models.IntegerField()
pub_data = models.DateField()
publish = models.ForeignKey('Publish',on_delete=models.CASCADE) def __str__(self):
return self.name class Author(models.Model):
'''作者'''
name = models.CharField(max_length=20) class Publish(models.Model):
'''出版社'''
#一对多的外键要加在多的哪一张表里,一本书只能有一个出版社
name = models.CharField(max_length=30)
city = models.CharField(max_length=30)
- view.py
from django.shortcuts import render,HttpResponse
from app.models import * #-----------------------增----------------------- # 方式一，给publish_id赋值，django默认给你的外键字段添加_id
Book.objects.create(name='linux运维',price=88,pub_data='2016-10-8',publish_id=1)
# 方式二,给publish字段直接赋值，需要先得到一个对象
pulish_obj = Publish.objects.filter(name='西湖出版社')[0]
Book.objects.create(name='Java', price=188, pub_data='2016-1-23', publish=pulish_obj) #-----------------------删----------------------- Book.objects.filter(publish__name='西湖出版社').delete() #-----------------------改----------------------- Book.objects.filter(publish__name='人民出版社').update(price=300) #-----------------------查----------------------- #第一种方式：通过对象（不推荐使用）
# 正向
book_obj = Book.objects.get(name='python')
publish_obj = book_obj.publish
publish_name = publish_obj.name
#反向
pub_obj = Publish.objects.filter(name='西湖出版社')[0]
#下面的到一个查询集，内容是字典，取第一个字典
pub_name = pub_obj.book_set.all().values('name','price')[0] #第二种方式：通过filter(__)，推荐使用
#正向查询，指定出版社的书籍信息；从有外键的表查询为正向；
book_name = Book.objects.filter(publish__name='西湖出版社').values('name','price')[0]
# 反向查询，指定书籍的出版社信息，通过 类名__字段名
pub_name = Publish.objects.filter(book__name='python').values('name','city')[0]
#通过value(__)
book_name = Book.objects.filter(name='Java').values('publish__name','publish__city')[0]
# 查询所有在北京的出版社出版的书籍，得到一个列表
book_list = Publish.objects.filter(city='北京').values('book__name')
book_list2 = Book.objects.filter(publish__city='北京').values('name')
- 多对多操作、聚合查询aggregate( )、分组查询annotate（）
from django.db import models class Book(models.Model):
'''书籍'''
name = models.CharField(max_length=20)
price = models.IntegerField()
pub_data = models.DateField()
# 一对多，一本书只能有一个出版社
publish = models.ForeignKey('Publish',on_delete=models.CASCADE)
# 多对多，一本书可以有多个作者，系统会自动创建第三张表:app_book_authors
#但是不能直接对这张表进行操作，因为没有它的类
authors = models.ManyToManyField('Author')
def __str__(self):
return self.name class Publish(models.Model):
'''出版社'''
#一对多的外键要加在多的哪一张表里,一本书只能有一个出版社
name = models.CharField(max_length=30)
city = models.CharField(max_length=30)
def __str__(self):
return self.name class Author(models.Model):
'''作者'''
name = models.CharField(max_length=20)
age = models.IntegerField(default=20)
def __str__(self):
return self.name
models
from django.shortcuts import render,HttpResponse
from app.models import *
from django.db.models import Avg,Min,Max,Count,Sum #------------------增-------------------- #方式一
book_obj = Book.objects.get(id=4)
book_obj.authors.add(1)
book_obj.authors.add(*[2,3,])
#方式二
book_obj = Book.objects.get(id=4)
author_objs = Author.objects.all()
book_obj.authors.add(*author_objs) #------------------删-------------------- # 先得到一个书籍对象
book_obj = Book.objects.get(id=4)
#删除
book_obj.authors.remove(3)
book_obj.authors.remove(*[1,2,])
#清空
book_obj.authors.clear() #------------------改-------------------- #重置，以设置的为准，这里列表不加*,已经有的不动，新内容里没有的就删除
book_obj.authors.set([1,2,3]) #------------------查-------------------- #正向，找到id=2的书籍的所有作者
book_obj = Book.objects.get(id=2)
book_obj.authors.all()
#方式二
Book.objects.filter(id=2).values('authors__name')
# 反向，找到作者的所有书籍
author_obj = Author.objects.get(id=1)
author_obj.book_set.all()
#所有书籍名称和对应的作者名
book_list = Book.objects.all().values('name','authors__name')
#列举作者charlie的所有书籍
Book.objects.filter(authors__name="charlie") #-----------------聚合函数aggregate()------------------ #求所有书籍的平均价格
ret = Book.objects.all().aggregate(Avg('price'))#{'price__avg': 122.0}
# 也可以自定义名称，结果：{'avg_price': 122.0}
ret = Book.objects.all().aggregate(avg_price=Avg('price'))
#作者Charlie出的所有书，Count参数可以是book表里任意个字段，只是查有几条记录，查谁都一样
ret = Book.objects.filter(authors__name='charlie').aggregate(Count('name')) #-----------------分组函数annotate--------------------- #按作者名分组,求每个作者所有书籍的价格总和
ret = Book.objects.values('authors__name').annotate(Sum('price'))
'''
<QuerySet [{'authors__name': 'charlie', 'price__sum': 366},
{'authors__name': 'alex', 'price__sum': 88},
{'authors__name': 'james', 'price__sum': 188}]>
'''
#求每个出版社的最低价格的书
ret = Publish.objects.values('name').annotate(Min('book__price'))
- 对于多对多的操作，我们也可以手动创建第三张表，但是这样查询起来更加麻烦，所以不推荐；
#去掉authors = models.ManyToManyField('Author')
#创建新类
class Book_Author(models.Model):
#第三张表
book = models.ForeignKey('Book',on_delete=models.CASCADE)
author = models.ForeignKey('Author',on_delete=models.CASCADE)
def __str__(self):
return self.name
#添加
Book_Author.objects.create(book_id=3,author_id=1)
# 利用对象查询
book_obj = Book.objects.get(id=2)
author_name = book_obj.book_author_set.all()[0].author
print(author_name)
#双下划线查询
book_list1 = Author.objects.filter(name='charlie').values('book_author__book')
print(book_list1)
book_list2 = Book.objects.filter(book_author__author__name='charlie').values('name')
print(book_list2)
- F查询和Q查询
from django.db.models import F,Q #F 使用查询条件的值,专门取对象中某列值的操作
#给所有的书价格加10
Book.objects.all().update(price=F('price') + 10) # Q 进行条件或的查询,| 或，满足任意条件
ret = Book.objects.filter(Q(price=110)|Q(name='GO'))
#~ 非，不满足条件
ret = Book.objects.filter(~Q(name='GO'))
#书籍名称中包含某个字母
ret = Book.objects.filter(Q(name__contains='J'))
#Q查询和关键字查询结合使用，Q查询一定要放前面
ret = Book.objects.filter(Q(price=110),name='GO')
print(ret)
#Q(name__startswith='P') 书籍名称以字母P开头
3、补充整理
跨多张表查询，可以连续使用双下划线
- ForeignKey（）和ManyToManyField（）都可以通过related_name参数修改没有外键的那个表里隐藏的字段
class Book(models.Model):
'''书籍'''
name = models.CharField(max_length=20)
price = models.IntegerField()
pub_data = models.DateField()
authors = models.ForeignKey('Author',on_delete=models.CASCADE)
class Author(models.Model):
'''作者'''
name = models.CharField(max_length=20)
age = models.IntegerField(default=20)
country = models.ForeignKey('Country',on_delete=models.CASCADE)
class Country(models.Model):
'''国家'''
name = models.CharField(max_length=20)
#所有中国籍作者出的所有书籍
Book.objects.filter(authors__country__name='China')
#正向查找：Book.objects.filter(authors__name='charlie')
#反向查找：
obj = Authors.objects.filter(name='charlie').first()
obj.book_set.all()
#没有外键的表里其实隐藏了一个字段：类名_set,也可以修改这个字段名
class Book(models.Model):
authors = models.ForeignKey('Author',on_delete=models.CASCADE,related_name='book')
obj = Authors.objects.filter(name='charlie').first()
book_list = obj.book.all()#作者对应的所有书籍对象查询集[obj(name,price,..),obj(name,price,..),]
4、惰性机制
所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。
QuerySet特点：<1> 可迭代的；<2> 可切片
QuerySet的高效使用：
<1>Django的queryset是惰性的
Django的queryset对应于数据库的若干记录（row），通过可选的查询来过滤。例如，下面的代码会得
到数据库中名字为‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave")
上面的代码并没有运行任何的数据库查询。你可以使用person_set，给它加上一些过滤条件，或者将它传给某个函数，
这些操作都不会发送给数据库。这是对的，因为数据库查询是显著影响web应用性能的因素之一。 <2>要真正从数据库获得数据，你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql.
为了验证这些,需要在settings里加入 LOGGING(验证方式)
obj=models.Book.objects.filter(id=3)
for i in obj:
print(i) if obj:
print("ok") <3>queryset是具有cache的
当你遍历queryset时，所有匹配的记录会从数据库获取，然后转换成Django的model。这被称为执行
（evaluation）.这些model会保存在queryset内置的cache中，这样如果你再次遍历这个queryset，
你不需要重复运行通用的查询。但是如果你修改了数据库，就需要再查询一次，否则你查到的还是上次的
缓存数据。
obj=models.Book.objects.filter(id=3)
for i in obj:
print(i)
models.Book.objects.filter(id=3).update(title="GO")
obj_new=models.Book.objects.filter(id=3)
for i in obj:
print(i) #LOGGING只会打印一次 <4>简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些
数据！为了避免这个，可以用exists()方法来检查是否有数据： obj = Book.objects.filter(id=4)
# exists()的检查可以避免数据放入queryset的cache。
if obj.exists():
print("hello world!") <5>当queryset非常巨大时，cache会成为问题 处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统
进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法
来获取数据，处理完数据就将其丢弃。
objs = Book.objects.all().iterator()
# iterator()可以一次只从数据库获取少量数据，这样可以节省内存
for obj in objs:
print(obj.name)
#BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
for obj in objs:
print(obj.name) 当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使
用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询。 总结:
queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。
使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能
会造成额外的数据库查询。总之一句话，如果查询数据量巨大时，使用迭代器；如果数据量很小，而且又需要重复查询
时，使用查询集。
二、admin
admin是django强大功能之一，它能从数据库中读取数据，呈现在页面中，进行管理。默认情况下，它的功能已经非常强大，如果你不需要复杂的功能，它已经够用，但是有时候，一些特殊的功能还需要定制，比如搜索功能，下面这一系列文章就逐步深入介绍如何定制适合自己的admin应用。
如果你觉得英文界面不好用，可以在setting.py 文件中修改以下选项：
LANGUAGE_CODE = 'en-us' #LANGUAGE_CODE = 'zh-hans'
使用django admin 则需要以下步骤：
- 创建后台管理员
- 配置url
- 注册和配置django admin后台管理页面
1、创建后台管理员
python manage.py createsuperuser
2、配置后台管理url
url(r'^admin/', admin.site.urls)
3、注册和配置django admin 后台管理页面
a、注册：在admin中执行如下配置
from django.contrib import admin from app01 import models admin.site.register(models.UserType)
admin.site.register(models.UserInfo)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)
b、设置数据表字段的显示名称
#方式一
class UserType(models.Model):
name = models.CharField(max_length=50)
#meta表示数据库中显示的信息
class Meta:
db_table = 'UserType' #数据库表名
verbose_name = '用户类型' #数据库字段名
verbose_name_plural = '用户类型' #方式二
#修改models
class Book(models.Model):
'''书籍'''
name = models.CharField(max_length=20,verbose_name='名称')
price = models.IntegerField('价格')
c、自定义页面展示
from django.contrib import admin
from app.models import * #自定制admin类
class BookAdmin(admin.ModelAdmin):
#不可以显示多对多的关联字段,注意这些都是元组，注意末尾的逗号
list_display = ('id','name','price','pub_date',)
#可编辑
# list_editable = ('name','price','pub_date',)
# 设置字段可垂直搜索
filter_horizontal = ('authors',)
#设置每页显示的条目
# list_per_page = 2
#根据字段搜索,关联字段加__，三个字段中重复的部分都会被搜索到
search_fields = ('id','name','publish__name',)
#根据字段过滤
list_filter = ('pub_date','publish',)
#根据字段排序，可以多个字段，依次排序，‘-id’表示降序排
ordering = ('id',)
#添加书籍时隐藏字段，列表里必须是元组
fieldsets = [
#默认显示name,fieldes是固定的，后面跟列表
(None,{'fields':['name',]}),
#将下列字段以折叠的方式显示
('other information',{'fields':['price','pub_date','publish'],'classes':['collapse',]}),
] #将模型注册到admin
admin.site.register(Book,BookAdmin)
4、注册medel类到admin的两种方式：
- 使用register的方法
admin.site.register(Book,MyAdmin)
- 使用register的装饰器
@admin.register(Book)
5、装饰器使用方法
from django.contrib import admin
from app01.models import *
# Register your models here. # @admin.register(Book)#----->单给某个表加一个定制
class MyAdmin(admin.ModelAdmin):
list_display = ("title","price","publisher")
search_fields = ("title","publisher")
list_filter = ("publisher",)
ordering = ("price",)
fieldsets =[
(None, {'fields': ['title']}),
('price information', {'fields': ['price',"publisher"], 'classes': ['collapse']}),
] admin.site.register(Book,MyAdmin)
admin.site.register(Publish)
admin.site.register(Author)
三、Form组件
1、django中的Form一般有一下几种功能：
生成HTML标签
验证用户输入：ajax和form表单提交
HTML Form提交保留上次提交数据
初始化页面显示内容
2、用form表单提交的基本流程
a、在views.py中创建一个类:F(forms.Form)，如果正规操作，应该是在APP中新建一个forms.py文件，再导入；
b、类中创建字段（包含正则表达式和HTML插件）
c、用户以GET方式请求：
把obj=F()发送到前端，这里不用传入任何参数
{{ obj.user }}...前端自动生成input标签
d、用户以POST方式请求：
obj = Form1(request.POST)，对象中包含用户输入信息和错误信息
先验证用户输入是否正确，如果正确就跳转页面，如果错误就发送obj
{{ obj.errors.user.0 }} 前端显示错误信息
补充：
#mark_safe，不用加safe就可以直接渲染HTML标签
from django.utils.safestring import mark_safe
txt = mark_safe("<input type='text'/") # novalidate忽略浏览器的验证
<form action="/add_user/" method="POST" novalidate> # 上传文件记得加上enctype
<form action="/test/" method="POST" enctype="multipart/form-data" novalidate> # form表单自动生成input标签，编辑时将数据库查询内容作为input标签默认值
data = UserInfo.objects.filter(id=nid).first()
obj = F1({'username':data.username,'email':data.email})
实例：
- views.py中创建Form类和函数
from django.shortcuts import render,redirect,HttpResponse
from django import forms
from django.forms import fields class Form1(forms.Form):
user = fields.CharField(
min_length=6,
max_length=18,
required=True,
error_messages={
'required':'用户名不能为空',
'min_length':'用户名太短',
'max_length':'用户名太长',
}
)
pwd = fields.CharField(
min_length=10,
required=True,
error_messages = {
'required': '密码不能为空',
'min_length': '密码太短',
}
)
age = fields.IntegerField(
required=True,
error_messages={
'required': '年龄不能为空',
'invalid': '必须为数字',
}
)
email = fields.EmailField(
min_length=8,
required=True,
error_messages={
'required': '邮箱不能为空',
'invalid': '格式错误'
}
) def f1(request):
if request.method == 'GET':
#自动生成input标签
obj = Form1()
return render(request,'f1.html',{'obj': obj})
if request.method == 'POST':
obj = Form1(request.POST)
#验证是否成功
if obj.is_valid():
#如果成功，打印用户提交的数据，跳转
print("验证成功",obj.cleaned_data)
return redirect('http://www.baidu.com')
else:
print("验证失败", obj.errors)
return render(request, 'f1.html', {'obj': obj})
- f1.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
{% load staticfiles %}
</head>
<body>
<form action="/f1.html" method="POST" id="fm">
<p>用户名{{ obj.user }}{{ obj.errors.user.0 }}</p>
<p>密码{{ obj.pwd }}{{ obj.errors.pwd.0 }}</p>
<p>年龄{{ obj.age }}{{ obj.errors.age.0 }}</p>
<p>邮箱{{ obj.email }}{{ obj.errors.email.0 }}</p>
<input type="submit" value="提交"/>
<input type="button" value="ajax提交" id="ajaxSubmit"/>
</form>
</body>
</html>
3、创建Form类时，主要涉及到 【字段】 和 【插件】，字段用于对用户请求数据的验证，插件用于自动生成HTML;
- 常用的Django内置字段
Field
required=True, 是否允许为空
widget=None, HTML插件
label=None, 用于生成Label标签或显示内容
initial=None, 初始值
help_text='', 帮助信息(在标签旁边显示)
error_messages=None, 错误信息 {'required': '不能为空', 'invalid': '格式错误'}
show_hidden_initial=False, 是否在当前插件后面再加一个隐藏的且具有默认值的插件（可用于检验两次输入是否一直）
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, 最小值 #浮点型，十进制小数
DecimalField(IntegerField)
max_value=None, 最大长度
min_value=None, 最小长度
max_digits=None, 总长度
decimal_places=None, 小数位长度 #下拉框
ChoiceField(Field)
choices=(), 选项，如：choices = ((0,'上海'),(1,'北京'),)
required=True, 是否必填
widget=None, 插件，默认select插件
label=None, Label内容
initial=None, 初始值
help_text='', 帮助提示 TypedChoiceField(ChoiceField)
coerce = lambda val: val 对选中的值进行一次转换
empty_value= '' 空值的默认值 #多选框
MultipleChoiceField(ChoiceField) TypedMultipleChoiceField(MultipleChoiceField)
coerce = lambda val: val 对选中的每一个值进行一次转换
empty_value= '' 空值的默认值 #时间
DateField(BaseTemporalField) 格式：2015-09-01
TimeField(BaseTemporalField) 格式：11:12
DateTimeField(BaseTemporalField)格式：2015-09-01 11:12 #邮箱
EmailField(CharField) #自定制正则表达式
RegexField(CharField)
regex, 自定制正则表达式
max_length=None, 最大长度
min_length=None, 最小长度
error_message=None, 忽略，错误信息使用 error_messages={'invalid': '...'} #上传文件
FileField(Field)
allow_empty_file=False 是否允许空文件 ImageField(FileField)
...
注：需要PIL模块，pip3 install Pillow
以上两个字典使用时，需要注意两点：
- form表单中 enctype="multipart/form-data"
- view函数中 obj = MyForm(request.POST, request.FILES) #IP
GenericIPAddressField
protocol='both', both,ipv4,ipv6支持的IP格式
unpack_ipv4=False 解析ipv4地址，如果是::ffff:192.0.2.1时候，可解析为192.0.2.1， PS：protocol必须为both才能启用 #数据库操作相关字段
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
- 实例：
#views.py from django.shortcuts import render
from django import forms
from django.forms import fields,widgets class TestForm(forms.Form):
user = fields.CharField(
required=True,
min_length=3,
max_length=12,
error_messages={'required':'不能为空',},
#widgets定制HTML插件
# widget=widgets.Select,
label = '用户名',
label_suffix='->',
)
age = fields.IntegerField(max_value=100,min_value=18)
email = fields.EmailField()
#FileField和ImageField功能一样
img = fields.FileField()
#生成下拉框,initial默认选中,或者obj = TestForm({'city':2})也可以默认选择
city = fields.ChoiceField(
choices=[(1,'北京'),(2,'上海'),],
initial=2,
)
#多选框
hobby = fields.MultipleChoiceField(
choices=[(1,'足球'),(2,'篮球'),],
initial=[1,2],
)
country = fields.TypedChoiceField(
choices=[(1, '中国'), (2, '美国'), ],
initial=2,
#将传入的参数做一个数据类型转换 'country': 2
coerce=lambda x:int(x),
empty_value='null',#空值的默认值
) def test(request):
if request.method == 'GET':
obj = TestForm()
return render(request, 'test.html',locals())
else:
#上传的文件在request.FILES中
obj = TestForm(request.POST,request.FILES)
obj.is_valid()
print(obj.cleaned_data)
return render(request,'test.html',locals()) #test.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
{#上传文件记得加上enctype#}
<form action="/test/" method="POST" enctype="multipart/form-data" novalidate>
{% csrf_token %}
<p>{{ obj.user.label }}{{ obj.user }}</p>
<p>{{ obj.age.label }}{{ obj.age }}</p>
<p>{{ obj.email.label }}{{ obj.email }}</p>
<p>{{ obj.img.label }}{{ obj.img }}</p>
<p>{{ obj.city.label }}{{ obj.city }}</p>
<p>{{ obj.hobby.label }}{{ obj.hobby }}</p>
<p>{{ obj.country.label }}{{ obj.country }}</p>
<input type="submit" value="提交"/>
</form>
{# 可以全部自动生成一个标签，但是页面排版无法控制，不建议使用#}
{# {{ obj.as_p }}#}
</body>
</html>
4、Django内置插件
- 调用方法
#widgets定制HTML插件，每一个字段都有自己的默认插件，还可以定制属性
widget=widgets.TextInput(attrs={'class':'c1'}),
- Django内置插件
TextInput(Input)
NumberInput(TextInput)
EmailInput(TextInput)
URLInput(TextInput)
PasswordInput(TextInput)
HiddenInput(TextInput)
Textarea(Widget)
DateInput(DateTimeBaseInput)
DateTimeInput(DateTimeBaseInput)
TimeInput(DateTimeBaseInput)
CheckboxInput
Select
NullBooleanSelect
SelectMultiple
RadioSelect
CheckboxSelectMultiple
FileInput
ClearableFileInput
MultipleHiddenInput
SplitDateTimeWidget
SplitHiddenDateTimeWidget
SelectDateWidget
5、常用的选择插件
# 单radio，值为字符串
user = fields.CharField(
initial=2,
widget=widgets.RadioSelect(choices=((1,'上海'),(2,'北京'),))
) # 单radio，值为字符串
user = fields.ChoiceField(
choices=((1, '上海'), (2, '北京'),),
initial=2,
widget=widgets.RadioSelect
) # 单select，值为字符串
user = fields.CharField(
initial=2,
widget=widgets.Select(choices=((1,'上海'),(2,'北京'),))
) # 单select，值为字符串
user = fields.ChoiceField(
choices=((1, '上海'), (2, '北京'),),
initial=2,
widget=widgets.Select
) # 多选select，值为列表
user = fields.MultipleChoiceField(
choices=((1,'上海'),(2,'北京'),),
initial=[1,],
widget=widgets.SelectMultiple
) # 单checkbox
user = fields.CharField(
widget=widgets.CheckboxInput()
) # 多选checkbox,值为列表
user = fields.MultipleChoiceField(
initial=[2, ],
choices=((1, '上海'), (2, '北京'),),
widget=widgets.CheckboxSelectMultiple
)
6、在使用选择标签时，需要注意choices的选项是需要从数据库中获取，但是由于是静态字段 ***获取的值无法实时更新***，那么需要自定义__init__构造方法，方法给widget.choices重新从数据库中取值，这样每次页面一刷新就实例化一次form对象，就会执行一次init函数，也就是会从数据库中取一次值。
方式一：
from django.shortcuts import render
from django import forms
from django.forms import fields,widgets
from app.models import *#models.py中的类
class UserInfo(models.Model):
username = models.CharField(max_length=32)
email = models.EmailField(max_length=32)
def __str__(self):
return self.username #创建自定义form
class LoveForm(forms.Form):
price = fields.IntegerField()
user_id = fields.IntegerField(widget=widgets.Select)
#静态字段 获取的值无法实时更新，需要自定义构造方法
def __init__(self,*args,**kwargs):
# super必须在上面，它拷贝了所有的静态字段，下面才能去内部取字段
super(LoveForm,self).__init__(*args,**kwargs)
self.fields['user_id'].widget.choices = UserInfo.objects.values_list('id','username') def love(request):
obj = LoveForm()
return render(request,'love.html',locals())
方式二：
#使用django提供的ModelChoiceField和ModelMultipleChoiceField字段来实现 from django.forms.models import ModelChoiceField class LoveForm(forms.Form):
user_id2 = ModelChoiceField(
#这里无法显示数据库表中的ID以外的字段,需要models中的类加上个__str__方法，返回某个字段
#虽然一样可以实时更新，但是与数据库的格式关系太大，不能灵活显示每个字段，不建议使用
queryset=UserInfo.objects.all()
)
7、使用ajax提交
无法自动跳转页面，就是在views函数中设置redirect，ajax也不会听从，需要在前端ajax的回调函数自己使用js代码跳转，window.location.href = 'http://www.baidu.com'
错误信息需要自己显示到页面，obj.errors 类型<class 'django.forms.utils.ErrorDict'>继承dict，所以用json.dumps（）不会报错。
class AjaxForm(forms.Form):
price = fields.IntegerField()
user_id = fields.IntegerField(
widget=widgets.Select(choices=[(1, '中国'), (2, '美国'), ],)
) def ajax(request):
if request.method == 'GET':
#自动生成input标签，并没有开始做验证
obj = AjaxForm()
return render(request,'ajax.html',{'obj': obj})
if request.method == 'POST':
import json
response = {'status':True,'msg':None}
#并没有开始做验证
obj = AjaxForm(request.POST)
#is_valid做的验证
if obj.is_valid():
print("验证成功",obj.cleaned_data)
#ajax无法自动跳转，需要在前端手动设置
return HttpResponse(json.dumps(response))
else:
#<class 'django.forms.utils.ErrorDict'>继承dict
print("验证失败", obj.errors,type(obj.errors))
response['status'] = False
response['msg'] = obj.errors
return HttpResponse(json.dumps(response))
- ajax.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
{% load staticfiles %}
</head>
<body>
<form action="/ajax/" method="POST" novalidate id="fm">
{% csrf_token %}
{{ obj.as_p }}
<input type="button" value="ajax提交" id="ajaxSubmit"/>
</form>
<script src="{% static 'js/jquery-1.12.4.js' %}"></script>
<script>
$(function () {
$('#ajaxSubmit').click(function () {
$.ajax({
url:'/ajax/',
type:'POST',
data:$('#fm').serialize(),
dataType:'JSON',
success:function (arg) {
if(arg.status){
window.location.href = 'http://www.baidu.com';
}
console.log(arg);
}
})
})
})
</script>
</body>
</html>
8、在根据源码流程自定义方法
- clean_字段名，只能验证该字段自己的内容；
from django.core.exceptions import ValidationError class AjaxForm(forms.Form):
username = fields.CharField()
user_id = fields.IntegerField(
widget=widgets.Select(choices=[(1, '中国'), (2, '美国'), ],)
)
#自定义方法clean_字段名，
#必须返回值self.cleaned_data['username']
#如果出错：raise ValidationError('用户名已存在')
def clean_username(self):
v = self.cleaned_data['username']
if UserInfo.objects.filter(username=v).count():
#如果用户信息中有一个字段错了，整体就错误，显示具体错误的详细信息
raise ValidationError('用户名已存在')
return v
def clean_user_id(self):
return self.cleaned_data['user_id']
- 自定义self.clean()方法，对整体错误验证，错误信息放在__all__中，前端调用方法arg.msg.__all__
def clean(self):
'''
obj.errors错误信息
{
__all__:[],
username:[],
user_id:[],
}
'''
# Django的整体错误信息放在__all__中
v1 = self.cleaned_data.get('username')
v2 = self.cleaned_data.get('user_id')
if v1=='charlie' and v2==1:
raise ValidationError('整体错误信息')
return self.cleaned_data
- __all__源码分析
from django.core.exceptions import NON_FIELD_ERRORS #这里添加错误的时候k就是None
self.add_error(None, e)
#但是None又被替换成__all__，所以前端需要通过.all来取
NON_FIELD_ERRORS = '__all__' # js代码
console.log(arg.msg.__all__); #HTML模板
#模板语言里不支持双下划线格式，所以用obj.non_field_errors.0
9、is_valid()验证表单时，一共给我们留了三个钩子
# 自定义方法名必须是clean_字段名
def _clean_fields(self):
for name, field in self.fields.items():
# value_from_datadict() gets the data from the data dictionaries.
# Each widget type knows how to retrieve its own data, because some
# widgets split data over several HTML fields.
if field.disabled:
value = self.get_initial_for_field(field, name)
else:
value = field.widget.value_from_datadict(self.data, self.files, self.add_prefix(name))
try:
if isinstance(field, FileField):
initial = self.get_initial_for_field(field, name)
value = field.clean(value, initial)
else:
value = field.clean(value)
self.cleaned_data[name] = value
if hasattr(self, 'clean_%s' % name):
value = getattr(self, 'clean_%s' % name)()
self.cleaned_data[name] = value
except ValidationError as e:
self.add_error(name, e)
# 同时验证多个字段或者是联合字段，返回整体错误信息，放在__all__中
def _clean_form(self):
try:
cleaned_data = self.clean()
except ValidationError as e:
self.add_error(None, e)
else:
if cleaned_data is not None:
self.cleaned_data = cleaned_data
# 没有捕捉异常的代码，所以这个方法不能出错误
def _post_clean(self):
"""
An internal hook for performing additional cleaning after form cleaning
is complete. Used for model validation in model forms.
"""
pass
10、扩展：ModelForm
在使用Model和Form时，都需要对字段进行定义并指定类型，通过ModelForm则可以省去From中字段的定义
from django import forms
from crm import models class CustomerForm(forms.ModelForm):
class Meta:
model = models.CustomerInfo
# fields = ['name','consultant','status']
# 所有字段
fields = '__all__' widgets = {
'email' : forms.PasswordInput(attrs={'class':"alex"}),
}
实例：
# forms.py class EnrollmentForm(forms.ModelForm):
"""审核学员报名信息"""
def __new__(cls, *args, **kwargs):
# cls.base_fields获取数据库表里的所有字段名
for field_name in cls.base_fields:
field_obj = cls.base_fields.get(field_name)
# 定制生成的标签的class属性
field_obj.widget.attrs.update({'class': 'form-control'})
# 只读标签不可编辑
if field_name in cls.Meta.readonly_fields:
field_obj.widget.attrs.update({'disabled': 'true'})
return forms.ModelForm.__new__(cls) class Meta:
model = models.StudentEnrollment
fields = '__all__'
exclude = ['contract_approved_date']
readonly_fields = ['contract_agreed',] def clean(self):
"""负责验证disabled字段的值是否被改动了"""
if self.errors:
# 全局的错误信息,通过customer_form.errors调用
raise forms.ValidationError(("Please fix errors before re-submit."))
if self.instance.id is not None:
# 说明这是一个被修改过的表单，需要验证disabled字段
for field in self.Meta.readonly_fields:
old_field_val = getattr(self.instance,field) # 数据库里的数据
form_val = self.cleaned_data.get(field) # 表单里提交的数据
if old_field_val != form_val:
# 给单个字段添加错误信息
self.add_error(field,"Readonly Field:field should be '{value}',not'{new_value}'".
format(**{'value':old_field_val,'new_value':form_val}))
- views.py
from django.shortcuts import render,HttpResponse,redirect
from django.contrib.auth.decorators import login_required # 必须登陆才能看到页面
from crm import forms @login_required
def contract_audit(request,enrollment_id):
'''学员报名审核页'''
enrollment_obj = models.StudentEnrollment.objects.filter(id=enrollment_id).first()
if request.method == 'POST':
enrollment_form = forms.EnrollmentForm(instance=enrollment_obj,data=request.POST)
if enrollment_form.is_valid():
enrollment_form.save()
# 报名成功后，把学员加入数据库,stu_obj = (<Student: 铁锤>, True)
stu_obj = models.Student.objects.get_or_create(customer=enrollment_obj.customer)[0] # 加入学生表
stu_obj.class_grades.add(enrollment_obj.class_grade_id) # 加入班级表
stu_obj.customer.status = 1 # 修改状态
stu_obj.save()
# 修改报名表，是否审核通过，和审核通过时间
enrollment_obj.contract_approved = True
enrollment_obj.contract_approved_date = datetime.now()
enrollment_obj.save()
# 给用户发邮件
return redirect('/kingadmin/crm/customerinfo/%s/change/'%enrollment_obj.customer.id)
else:
# 创建form表单，发到前端
customer_form = forms.CustomerForm(instance=enrollment_obj.customer)
enrollment_form = forms.EnrollmentForm(instance=enrollment_obj)
return render(request,'crm/contract_audit.html',locals())
四、Cookie
cookie的工作原理是：由服务器产生内容，浏览器收到请求后保存在本地；当浏览器再次访问时，浏览器会自动带上cookie，这样服务器就能通过cookie的内容来判断这个是“谁”了。
1、获取Cookie：
request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
参数：
default: 默认值
salt: 加密盐
max_age: 后台控制过期时间
2、设置Cookie：
rep = HttpResponse(...) 或 rep ＝ render(request, ...) rep.set_cookie(key,value,...)
rep.set_signed_cookie(key,value,salt='加密盐',...)
参数：
key, 键
value='', 值
max_age=None, 超时时间
expires=None, 超时时间(IE requires expires, so set it if hasn't been already.)
path='/', Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问
domain=None, Cookie生效的域名
secure=False, https传输
httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）
- 由于cookie保存在客户端的电脑上，所以，JavaScript和jquery也可以操作cookie。
<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });
3、应用
from django.shortcuts import render,redirect
import datetime def login(request):
if request.method == 'POST':
name = request.POST.get('user')
pwd = request.POST.get('pwd')
if name == 'charlie' and pwd == '':
# redirect render 都有返回值，是一个字典，里面有键值对'sessionid':'5225rffg5hh5'
ret = redirect('/index/')
#给cookie添加一个键值对，下次再来发送请求的时候会带着它来，
#如果和这个一样，就不用重新登陆了，前提是在同一个客户端登陆
#设置cookie有效时间5秒
ret.set_cookie('username',name,max_age=5)
#设置有效期三天
ret.set_cookie('username',name,expires=datetime.datetime.utcnow()
+datetime.timedelta(days=3))
return ret
return render(request,'login.html') def index(request):
if request.COOKIES.get('username',None):
name = request.COOKIES.get('username',None)
return render(request,'index.html',locals())
else:
return redirect('/login/')
五、Session
cookie虽然在一定程度上解决了“保持状态”的需求，但是由于cookie本身最大支持4096字节，以及cookie本身保存在客户端，可能被拦截或窃取，因此就需要有一种新的东西，它能支持更多的字节，并且他保存在服务器，有较高的安全性。这就是session(session默认在服务器端保存15天)。
Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：
- 数据库（默认）
- 缓存
- 文件
- 缓存+数据库
- 加密cookie
1、数据库Session
Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。
a. 配置 settings.py
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，默认修改之后才保存（默认）
b. 使用
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失效策略。
2、缓存Session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.cache' # 引擎
SESSION_CACHE_ALIAS = 'default' # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置
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，默认修改之后才保存
b. 使用同上
3、文件Session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎
SESSION_FILE_PATH = None # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir() # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T
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，默认修改之后才保存 b. 使用同上
4、缓存+数据库Session
数据库用于做持久化，缓存用于提高效率
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db' # 引擎
b. 使用同上
5、加密cookie Session
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies' # 引擎
b. 使用同上
6、cookie 和Session的结合使用的两种方式
存储在服务端：通过cookie存储一个session_id，然后具体的数据则是保存在session中。如果用户已经登录，则服务器会在cookie中保存一个session_id，下次再次请求的时候，会把该session_id携带上来，服务器根据session_id在session库中获取用户的session数据。就能知道该用户到底是谁，以及之前保存的一些状态信息。这种专业术语叫做server side session。
将session数据加密，然后存储在cookie中。这种专业术语叫做client side session。flask采用的就是这种方式，但是也可以替换成其他形式。
7、应用
数据库session，需要执行python manage.py makemigrations命令，需要Django帮我们创建session表，用来保存session内容，否则会报错；
cookie是一个字典，里面默认有两个键值对：‘sessionid’,‘csrftoken’，session是一个字典对象，两个都可以用request.session['username']=name方法来添加键值对；
删除session:del request.session[key]
from django.shortcuts import render,redirect
import datetime def login(request):
if request.method == 'POST':
name = request.POST.get('user')
pwd = request.POST.get('pwd')
if name == 'charlie' and pwd == '':
#cookie + session
request.session['is_login']=True
request.session['user']=name
return redirect('/index/')
return render(request,'login.html') def index(request):
#cookie + session,加上None防止找不到报错
if request.session.get('is_login',None):
name = request.session.get('user',None)
return render(request,'index.html',locals())
else:
return redirect('/login/')
六、分页
1、代码实现简单的上一页、下一页
#index.html <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<ul>
{% for row in user_list %}
<li>{{ row.name }} - {{ row.age }}</li>
{% endfor %}
</ul>
<a href="/index.html?p={{ prev_page }}">上一页</a>
<a href="/index.html?p={{ next_page }}">下一页</a>
</body>
</html> #views.py from django.shortcuts import render USER_LIST = []
for i in range(1,1000):
temp = {'name':'root' + str(i),'age':i}
USER_LIST.append(temp) def index(request):
#简单的分页
per_page_count = 10
current_page = int(request.GET.get('p'))
#p=1 索引0-10
#p=2 索引10-20
#http://127.0.0.1:8005/index.html?p=1
start = (current_page-1)*per_page_count
end = current_page*per_page_count
user_list = USER_LIST[start:end]
if current_page <= 1:
prev_page = 1
next_page = current_page + 1
else:
prev_page = current_page - 1
next_page = current_page + 1
return render(request,'index.html',locals())
2、Django内置分页+扩展
-- Django自带的内置分页只能显示上一页和下一页按钮，不能显示中间的页码，所以这里需要扩展一下
- views.py
from django.shortcuts import render
from django.core.paginator import Paginator,EmptyPage,PageNotAnInteger USER_LIST = []
for i in range(1,230):
temp = {'name':'root' + str(i),'age':i}
USER_LIST.append(temp) #扩展自带分页
class CustomPaginator(Paginator):
def __init__(self,current_page,per_pager_num,*args,**kwargs):
#当前页
self.current_page = int(current_page)
#每页最多显示多少页码
self.per_pager_num = int(per_pager_num)
super(CustomPaginator,self).__init__(*args,**kwargs)
def page_num_range(self):
#如果总页数小于每页最多显示页码数量，就显示1-总页码
if self.num_pages < self.per_pager_num:
return range(1,self.num_pages+1)
#如果总页数有很多
part = int(self.per_pager_num/2)
if self.current_page <= part:
return range(1,self.per_pager_num+1)
#最后一页只显示最后10个页码即可
if (self.current_page+part) > self.num_pages:
return range(self.num_pages-self.per_pager_num+1,self.num_pages+1)
return range(self.current_page-part,self.current_page+part+1) def index1(request):
#django自带分页
current_page = request.GET.get('p')
#Paginator对象，每页显示10个页码，10条数据
paginator = CustomPaginator(current_page,11,USER_LIST,10)
try:
#Page对象
posts = paginator.page(current_page)
except PageNotAnInteger:
#如果输入不是数字，就显示第一页
posts = paginator.page(1)
except EmptyPage:
#如果输入为空或数字过大，就显示最后一页
posts = paginator.page(paginator.num_pages)
return render(request,'index1.html',locals())
- index1.html，在templates下新建include/pager.html，把所有关于分页的代码单独放到一个文件中，以后可以随时调用
#注意：这里使用include引用了文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<ul>
{% for row in posts %}
<li>{{ row.name }} - {{ row.age }}</li>
{% endfor %}
</ul>
{% include 'include/pager.html' %}
</body>
</html>
- 引用pager.html文件
<a href="/index1.html?p=1">首页</a>
{% if posts.has_previous %}
<a href="/index1.html?p={{ posts.previous_page_number }}">上一页</a>
{% endif %}
{% for i in paginator.page_num_range %}
{% if i == posts.number %}
<a style="font-size: 20px;color: blue;" href="/index1.html?p={{ i }}">{{ i }}</a>
{% else %}
<a href="/index1.html?p={{ i }}">{{ i }}</a>
{% endif %}
{% endfor %}
{% if posts.has_next %}
<a href="/index1.html?p={{ posts.next_page_number }}">下一页</a>
{% endif %}
<span>
[{{ posts.number }}/{{ paginator.num_pages }}]
</span>
<a href="/index1.html?p={{ paginator.num_pages }}">尾页</a>
2、自定义分页
— 分页功能在每个网站都是必要的，对于分页来说，其实就是根据用户的输入计算出应该在数据库表中的起始位置，并且需要在页面上显示分页的页面。如：［上一页］［1］［2］［3］［4］［5］［下一页］
1、设定每页显示数据条数
2、用户输入页码（第一页、第二页...）
3、设定显示多少页号
4、获取当前数据总条数
5、根据设定显示多少页号和数据总条数计算出，总页数
6、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置
7、在数据表中根据起始位置取值，页面上输出数据
8、输出分页html，如：［上一页］［1］［2］［3］［4］［5］［下一页］
实例：在APP中创建pager.py
#在APP中创建pager.py class Pagination(object):
def __init__(self,total_count,current_page,per_page_item_num=20,max_page_num=7):
#数据总条目
self.total_count = total_count
#当前页
try:
v = int(current_page)
if v <= 0:
v = 1
self.current_page = v
except Exception as e:
self.current_page = 1
#每页显示条目
self.per_page_item_num = per_page_item_num
#每页最多显示页码
self.max_page_num = max_page_num def start(self):
return (self.current_page-1)*self.per_page_item_num def end(self):
return self.current_page*self.per_page_item_num @property
def num_pages(self):
# 总页数
a,b = divmod(self.total_count,self.per_page_item_num)
if b == 0:
return a
return a+1 def page_num_range(self):
#如果总页数小于每页最多显示页码数量，就显示1-总页码
if self.num_pages < self.max_page_num:
return range(1,self.num_pages+1)
#如果总页数有很多
part = int(self.max_page_num/2)
if self.current_page <= part:
return range(1,self.max_page_num+1)
#最后一页只显示最后10个页码即可
if (self.current_page+part) > self.num_pages:
return range(self.num_pages-self.max_page_num+1,self.num_pages+1)
return range(self.current_page-part,self.current_page+part+1) def page_str(self):
page_list = []
first_page = '<li><a href="/index2.html?p=1">首页</a></li>'
page_list.append(first_page)
if self.current_page == 1:
prev_page = '<li><a href="#">上一页</a>'
else:
prev_page = '<li><a href="/index2.html?p=%s">上一页</a></li>'%(self.current_page-1)
page_list.append(prev_page)
for i in self.page_num_range():
if i == self.current_page:
temp = '<li class="active"><a href="/index2.html?p=%s">%s</a></li>' % (i, i)
else:
temp = '<li><a href="/index2.html?p=%s">%s</a></li>'%(i,i)
page_list.append(temp)
if self.current_page == self.num_pages:
next_page = '<li><a href="#">下一页</a></li>'
else:
next_page = '<li><a href="/index2.html?p=%s">下一页</a></li>' % (self.current_page + 1)
page_list.append(next_page)
last_page = '<li><a href="/index2.html?p=%s">尾页</a></li>'%self.num_pages
page_list.append(last_page)
return ''.join(page_list)
- 创建views函数
from django.shortcuts import render
from django.core.paginator import Paginator,EmptyPage,PageNotAnInteger USER_LIST = []
for i in range(1,600):
temp = {'name':'root' + str(i),'age':i}
USER_LIST.append(temp) def index2(request):
from app.pager import Pagination
current_page = request.GET.get('p')
page_obj = Pagination(600,current_page)
data = USER_LIST[page_obj.start():page_obj.end()]
return render(request,'index2.html',locals())
- 创建index2.html，这里需要引入bootstrap的一个组件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link rel="stylesheet" href="/static/bootstrap/css/bootstrap.css"/>
</head>
<body>
<ul>
{% for row in data %}
<li>{{ row.name }} - {{ row.age }}</li>
{% endfor %}
</ul>
<ul class="pagination">
{{ page_obj.page_str|safe }}
</ul>
</body>
</html>
总结，分页时需要做三件事：
创建处理分页数据的类
根据分页数据获取数据
输出分页HTML，即：［上一页］［1］［2］［3］［4］［5］［下一页］
七、序列化
序列化就是把对象转换成可以保存在本地文件中的数据类型，关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的Ajax请求一般返回的为Json格式。
1、Python中dumps就是序列化，loads就是反序列化；
2、JavaScript中
对象转换成字符串 -- str = JSON.stringify({'k':'v'})
字符串转换成对象 -- dict = JSON.parse(str)
3、三种情况
QuerySet内部是：
对象（用all，filter获取数据）：serializers.serializer('json',QuerySet)
字典（用values获取）：list(QuerySet)
元组（用values_list获取）：list(QuerySet)
from django.core import serializers
import json def get_data(request):
response = {'status': True, 'data': None}
try:
user_list = UserInfo.objects.all()
# serializers只能序列化queryset对象，转换为字符串
response['data'] = serializers.serialize('json', user_list)
#如果queryset内部是字典或元组，values和values_list获取，道理一样
user_list = UserInfo.objects.values('id','username')
#只需要把外部的queryset变成列表形式，就可以直接json序列化了
response['data'] = list(user_list)
except Exception as e:
response['status'] = False
ret = json.dumps(response)
return HttpResponse(ret)
4、由于json.dumps时无法处理datetime日期，所以可以通过自定义处理器来做扩展，如：
import json
from datetime import date
from datetime import datetime class JsonCustomEncoder(json.JSONEncoder):
def default(self, field):
if isinstance(field, datetime):
return field.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(field, date):
return field.strftime('%Y-%m-%d')
elif isinstance(field, Response):
return field.__dict__ # 对象以字典的方式输出
else:
return json.JSONEncoder.default(self, field) class Response:
def __init__(self):
self.status = True
self.data = 'charlie' data = {
'k1': datetime.now(),
'k2': Response(),
}
ds = json.dumps(data, cls=JsonCustomEncoder)
print(ds)
# {"k1": "2019-03-08 16:18:28", "k2": {"status": true, "data": "charlie"}}