Django ORM（基础）
Django 框架十分强大，自带数据库操作功能。Django 跟 SQLAchemy 一样，也是通过ORM（Object Relational Mapping，关系对象映射）的方式对数据库进行操作，django中遵循 Code Frist （根据代码中定义的类来自动生成数据库表）的原则。
一、创建表
1、在SQLite中创建表
1.1、在app中的models.py中先写类：
from django.db import models
# Create your models here. class UserInfo(models.Model):
# id列，Django框架会默认生成id(自增，主键)，也可以通过AutoField类型自定义主键，不过Django框架默认生成ID列会失效
# 用户名列，字符串类型，最大长度长度
username = models.CharField(max_length=32)
password = models.CharField(max_length=64)
AutoField(Field)
- int自增列，必须填入参数 primary_key=True BigAutoField(AutoField)
- bigint自增列，必须填入参数 primary_key=True 注：当model中如果没有自增列，则自动会创建一个列名为id的列
from django.db import models class UserInfo(models.Model):
# 自动创建一个列名为id的且为自增的整数列
username = models.CharField(max_length=) class Group(models.Model):
# 自定义自增列
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=) SmallIntegerField(IntegerField):
- 小整数 - ～ PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正小整数 ～
IntegerField(Field)
- 整数列(有符号的) - ～ PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正整数 ～ BigIntegerField(IntegerField):
- 长整型(有符号的) - ～ 自定义无符号整数字段 class UnsignedIntegerField(models.IntegerField):
def db_type(self, connection):
return 'integer UNSIGNED' PS: 返回值为字段在数据库中的属性，Django字段默认的值为：
'AutoField': 'integer AUTO_INCREMENT',
'BigAutoField': 'bigint AUTO_INCREMENT',
'BinaryField': 'longblob',
'BooleanField': 'bool',
'CharField': 'varchar(%(max_length)s)',
'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
'DateField': 'date',
'DateTimeField': 'datetime',
'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
'DurationField': 'bigint',
'FileField': 'varchar(%(max_length)s)',
'FilePathField': 'varchar(%(max_length)s)',
'FloatField': 'double precision',
'IntegerField': 'integer',
'BigIntegerField': 'bigint',
'IPAddressField': 'char(15)',
'GenericIPAddressField': 'char(39)',
'NullBooleanField': 'bool',
'OneToOneField': 'integer',
'PositiveIntegerField': 'integer UNSIGNED',
'PositiveSmallIntegerField': 'smallint UNSIGNED',
'SlugField': 'varchar(%(max_length)s)',
'SmallIntegerField': 'smallint',
'TextField': 'longtext',
'TimeField': 'time',
'UUIDField': 'char(32)', BooleanField(Field)
- 布尔值类型 NullBooleanField(Field):
- 可以为空的布尔值 CharField(Field)
- 字符类型
- 必须提供max_length参数， max_length表示字符长度 TextField(Field)
- 文本类型 EmailField(CharField)：
- 字符串类型，Django Admin以及ModelForm中提供验证机制 IPAddressField(Field)
- 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制 GenericIPAddressField(Field)
- 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
- 参数：
protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
unpack_ipv4， 如果指定为True，则输入::ffff:192.0..1时候，可解析为192.0.2.，开启刺功能，需要protocol="both" URLField(CharField)
- 字符串类型，Django Admin以及ModelForm中提供验证 URL SlugField(CharField)
- 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号） CommaSeparatedIntegerField(CharField)
- 字符串类型，格式必须为逗号分割的数字 UUIDField(Field)
- 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证 FilePathField(Field)
- 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
- 参数：
path, 文件夹路径
match=None, 正则匹配
recursive=False, 递归下面的文件夹
allow_files=True, 允许文件
allow_folders=False, 允许文件夹 FileField(Field)
- 字符串，路径保存在数据库，文件上传到指定目录
- 参数：
upload_to = "" 上传文件的保存路径
storage = None 存储组件，默认django.core.files.storage.FileSystemStorage ImageField(FileField)
- 字符串，路径保存在数据库，文件上传到指定目录
- 参数：
upload_to = "" 上传文件的保存路径
storage = None 存储组件，默认django.core.files.storage.FileSystemStorage
width_field=None, 上传图片的高度保存的数据库字段名（字符串）
height_field=None 上传图片的宽度保存的数据库字段名（字符串） DateTimeField(DateField)
- 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] DateField(DateTimeCheckMixin, Field)
- 日期格式 YYYY-MM-DD TimeField(DateTimeCheckMixin, Field)
- 时间格式 HH:MM[:ss[.uuuuuu]] DurationField(Field)
- 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型 FloatField(Field)
- 浮点型 DecimalField(Field)
- 10进制小数
- 参数：
max_digits，小数总长度
decimal_places，小数位长度 BinaryField(Field)
- 二进制类型
models字段类型
class User(models.Model):
name = models.CharField(max_length=32)
pwd = models.CharField(max_length=32)
#class User(models.Model):
# name = models.CharField(max_length=32,db_index=True)
# pwd = models.CharField(max_length=32,db_index=True)
class Meta:
#指定数据库表名：tb1，如果不指定表名将会默认生成表名：app名称 + 下划线 + 类名
db_table = "tb1" #索引，mysql每一列加上索引就会生成一个文件，因此当上面被注释的User表生成是mysql数据库就会生成一个表，两个文件，
#因此不想数据库生成太多索引文件，又想个别列名能够支持索引查询，这个时候就需要用到联合索引，
index_together = [ # 联合索引，只会生成一个索引文件 但是有一个缺点就是，遵循最左前缀模式查询
("name", 'pwd'),
] # 最左前缀的模式：
# select * from where name='xx'
# select * from where name='xx' and email = 'xx'
# select * from where email = 'xx' # 无法命中索引 #联合唯一索引，与上面的联合索引一样，就是多了一个列名组合唯一的限制
unique_together = (("driver", "restaurant"),) #admin中的配置
verbose_name = “name” #在admin中会将name显示成names，多加一个“s”
verbose_name_plural=““name”” #在admin中会将name显示成name，显示原生自定义的名字
db_table、联合索引、联合唯一索引
null 数据库中字段是否可以为空
db_column 数据库中字段的列名
db_tablespace
default 数据库中字段的默认值
primary_key 数据库中字段是否为主键
db_index 数据库中字段是否可以建立索引
unique 数据库中字段是否可以建立唯一索引
unique_for_date 数据库中字段【日期】部分是否可以建立唯一索引
unique_for_month 数据库中字段【月】部分是否可以建立唯一索引
unique_for_year 数据库中字段【年】部分是否可以建立唯一索引 verbose_name Admin中显示的字段名称
blank Admin中是否允许用户输入为空
editable Admin中是否可以编辑
help_text Admin中该字段的提示信息
choices Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1) 想要在HTML中显示choice中的字段值,而不是数学索引，需要用到{{k.get_带choices参数的字段_display}}方法 error_messages 自定义错误信息（字典类型），从而定制想要显示的错误信息；
字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
如：{'null': "不能为空.", 'invalid': '格式错误'} validators 自定义错误验证（列表类型），从而定制想要的验证规则
from django.core.validators import RegexValidator
from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
如：
test = models.CharField(
max_length=32,
error_messages={
'c1': '优先错信息1',
'c2': '优先错信息2',
'c3': '优先错信息3',
},
validators=[
RegexValidator(regex='root_\d+', message='错误了', code='c1'),
RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
EmailValidator(message='又错误了', code='c3'), ]
)
models中的参数
1.2、在settings.py中注册app:
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'app1',
]
1.3、在控制台输出cmd 命令：
python3 manage.py makemigrations #相当于在该app的migrations目录，记录下该app下modes.py所有表结构类型的改动（普通增删改查不记录）
python3 manage.py migrate #将刚刚对于表结构的改动作用至数据库
2、在MySQL中创建表
2.1、在上面步骤1.1 先写类、1.2 注册app的基础上，在与Django project中与project同名目录下的__init__.py文件中配置如下代码：
import pymysql
pymysql.install_as_MySQLdb()
注：# 由于Django内部连接MySQL时使用的是MySQLdb模块，而python3中还无此模块，所以需要使用pymysql来代替
2.2，在settings.py中更改数据库配置
#将原先数据库配置注释，使用mysql配置
# DATABASES = {
# 'default': {
# 'ENGINE': 'django.db.backends.sqlite3',
# 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
# }
# } DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'test1', # 数据库名称
'USER': 'root', # 用户名
'PASSWORD': '123456', # 密码
'HOST': 'localhost', # ip
'PORT': '3306', # 端口
}
}
2.3、执行命令
python3 manage.py makemigrations
python3 manage.py migrate
注：配置好数据库为mysql后，重新启动Django工程，如果报错mysql django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.3 or newer is required;的话， 这是因为 mysql client 端的版本小于1.3.3。最简单的解决办法是：
#找到Django的安装路径的mysql配置下的base.py，如C:\Python36\Lib\site-packages\django\db\backends\mysql\base.py（根据实际安装路径）
#注释这句断言：
#if version < (1, 3, 3):
#raise ImproperlyConfigured("mysqlclient 1.3.3 or newer is required; you have %s" % Database.__version__)
二、增删改查
利用Django的ORM连接数据库进行增删改查和其他一些进阶操作。
1、增：
# 第一种方式
models.UserInfo.objects.create(username='root', password='123')
# 第二种方式
dic = {'username': 'root1', 'password': '456'}
models.UserInfo.objects.create(**dic)
#第三种方式
obj = models.UserInfo(username='root2', password='789')
obj.save()
2、删：
models.UserInfo.objects.filter(id="2").delete()
3、改：
models.UserInfo.objects.filter(id=1).update(password="111")
4、查：
models.User.objects.filter(id=1) #id=1
models.User.objects.filter(id=1,name='root') #id=1 and name = root
models.User.objects.filter(id__gt=1) #id>1
models.User.objects.filter(id__lt=1) #id<1
models.User.objects.filter(id__gte=1) #id>=1
models.User.objects.filter(id__lte=1) #id<=1
models.Tb1.objects.filter(id__lt=10, id__gt=1) #1<id<10 dic = {'name': 'xx', 'age__gt': 19} #**字典形式多条件查询
models.User.objects.filter(**dic) models.Business.objects.all() #QuerySet ,内部元素都是对象 [obj(id,caption,code),obj(id,caption,code),obj(id,caption,code) ]
models.Business.objects.all().values('id','caption') # QuerySet ,内部元素都是字典 [{'id':1,'code': 'QA'},{'id':2,'code': 'PM'},...]
models.Business.objects.all().values_list('id','caption') # QuerySet ,内部元素都是元组 [(1,"QA"),(2,"PM")] models.Business.objects.get(id=1) # 获取到的一个对象，如果不存在就报错
models.Business.objects.filter(id=1).first() # 获取到的一个对象，如果不存在返回NONE
5、更多进阶操作：
# 获取个数
#
# models.Tb1.objects.filter(name='seven').count() # 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)
进阶操作
注：all()、all().values()、all().values_list()示例：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<h1>业务线列表(对象)</h1>
<ul>
{% for row in v1 %}
<li>{{ row.id }} - {{ row.caption }} - {{ row.code }}</li>
{% endfor %}
</ul>
<h1>业务线列表（字典）</h1>
<ul>
{% for row in v2 %}
<li>{{ row.id }} - {{ row.code }}</li>
{% endfor %}
</ul>
<h1>业务线列表（元组）</h1>
<ul>
{% for row in v3 %}
<li>{{ row.0 }} - {{ row.1 }}</li>
{% endfor %}
</ul>
</body>
</html>
templates模板中的模板语言
from django.shortcuts import render
from app1 import models def business(request):
v1 = models.Business.objects.all()
# QuerySet [obj(id,caption,code),obj(id,caption,code),obj(id,caption,code) ] v2 = models.Business.objects.all().values("id", "code")
# QuerySet [{'id':1,'code': 'QA'},{'id':2,'code': 'PM'},...] v3 = models.Business.objects.all().values_list('id', 'code')
# QuerySet [(1,"QA"),(2,"PM")]
return render(request, 'business.html', {'v1': v1, 'v2': v2, 'v3': v3})
views.py中all()、all().values()、all().values_list()示例
三、ORM基础操作示例：
简单模拟用户登陆跳转后台，实现编辑用户、新增用户、删除用户、查看用户详情等功能小示例
1、templates:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form action="/app2/login/" method="POST" enctype="multipart/form-data">
<p>
<input type="text" name="user" placeholder="用户名" />
</p>
<p>
<input type="password" name="pwd" placeholder="密码" />
</p>
<input type="submit" value="提交"/>
</form>
</body>
</html>
login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
body {
margin: 0;
} .menu {
display: block;
padding: 5px; }
</style>
</head>
<body>
<div style="height: 48px;background-color: antiquewhite;color: burlywood">
oms后台
</div>
<div>
<div style="position: absolute;top:48px;bottom: 0;left: 0;width: 200px;background-color: sandybrown;">
<a class="menu" href="/app2/user_info/">用户管理</a>
<a class="menu" href="/app2/user_group/">用户组管理</a>
</div>
<div style="position:absolute;top:48px;left: 210px;bottom: 0;right: 0;overflow: auto">
<h3>添加用户</h3> <form method="POST" action="/app2/user_info/">
<input type="text" name="user"/>
<input type="text" name="pwd"/>
<input type="submit" value="添加"/>
</form> <h3>用户列表</h3>
<ul>
{% for row in user_list %}
<li>
<a href="/app2/userDetail-{{ row.id }}">{{ row.username }}</a> |
<a href="/app2/userDel-{{ row.id }}">删除</a> |
<a href="/app2/userEdit-{{ row.id }}">编辑</a>
</li>
{% endfor %}
</ul>
</div> </div> </body>
</html>
user_info.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
body{
margin: 0;
}
.menu{
display: block;
padding: 5px; }
</style>
</head>
<body>
<div style="height: 48px;background-color: antiquewhite;color: burlywood">
oms后台
</div>
<div>
<div style="position: absolute;top:48px;bottom: 0;left: 0;width: 200px;background-color: sandybrown;">
<a class="menu" href="/app2/user_info/">用户管理</a>
<a class="menu" href="/app2/user_group/">用户组管理</a>
</div>
<div style="position:absolute;top:48px;left: 210px;bottom: 0;right: 0;overflow: auto">
<h1>编辑用户</h1>
<form method="post" action="/app2/userEdit-{{ obj.id }}/">
<input style="display: none" type="text" name="id" value="{{ obj.id }}" />
<input type="text" name="username" value="{{ obj.username }}" />
<input type="text" name="password" value="{{ obj.password }}"/>
<input type="submit" value="提交" />
</form>
</div> </div> </body>
</html>
user_edit.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
body{
margin: 0;
}
.menu{
display: block;
padding: 5px; }
</style>
</head>
<body>
<div style="height: 48px;background-color: antiquewhite;color: burlywood">
oms后台
</div>
<div>
<div style="position: absolute;top:48px;bottom: 0;left: 0;width: 200px;background-color: sandybrown;">
<a class="menu" href="/app2/user_info/">用户管理</a>
<a class="menu" href="/app2/user_group/">用户组管理</a>
</div>
<div style="position:absolute;top:48px;left: 210px;bottom: 0;right: 0;overflow: auto">
<h1>用户详细信息</h1>
<h5>id:{{ obj.id }}</h5>
<h5>name:{{ obj.username}}</h5>
<h5>password:{{ obj.password }}</h5>
</div> </div> </body>
</html>
user_detail.html
2、app中的models.py:
from django.db import models
# Create your models here. class UserInfo(models.Model):
# id列，Django框架会默认生成id(自增，主键)，也可以通过AutoField类型自定义主键，不过Django框架默认生成ID列会失效
# 用户名列，字符串类型，最大长度长度
username = models.CharField(max_length=32)
password = models.CharField(max_length=64)
models.py
2、app中的urls.py：
from django.conf.urls import url
from app2 import views
urlpatterns = [
url(r'^orm', views.orm_action),
url(r'^login', views.login),
url(r'^oms', views.oms),
url(r'^user_info', views.user_info),
url(r'^userDetail-(?P<nid>\d+)', views.user_detail),
url(r'^userDel-(?P<nid>\d+)', views.user_del),
url(r'^userEdit-(?P<nid>\d+)', views.user_edit),
]
urls.py
3、app中的views.py：
from django.shortcuts import render
from django.shortcuts import redirect
from app2 import models # 登录
def login(request):
if request.method == "GET":
return render(request, 'login.html')
elif request.method == "POST":
u = request.POST.get('user')
p = request.POST.get('pwd')
# 两种方式判断数据库中是否有匹配的数据
# obj = models.UserInfo.objects.filter(username=u,password=p).first() # 推荐这一种
# count = models.UserInfo.objects.filter(username=u, password=p).count()
obj = models.UserInfo.objects.filter(username=u, password=p).first()
if obj:
return redirect('/app2/user_info')
else:
return render(request, 'login.html')
else:
# PUT,DELETE,HEAD,OPTION...
return redirect('/login') # 后台页面
def user_info(request):
if request.method == "GET":
user_list = models.UserInfo.objects.all()
print(user_list.query) # .query 查看原生sql语句
return render(request, "user_info.html", {"user_list": user_list})
elif request.method == "POST":
u = request.POST.get("user")
p = request.POST.get("pwd")
models.UserInfo.objects.create(username=u, password=p)
# 添加用户后返回添加页面查看新增数据
# 方式一
# user_list = models.UserInfo.objects.all()
# return render(request, "user_info.html", {"user_list": user_list})
# 方式二 有效避免重复代码
return redirect("/app2/user_info") # 查看用户详情
def user_detail(request, nid):
# 取单条数据的两种方式
# 第一种（推荐）
obj = models.UserInfo.objects.filter(id=nid).first()
# 第二种（当数据为空，直接报错）
# models.UserInfo.objects.get(id=nid)
return render(request, "user_detail.html", {"obj": obj}) # 删除用户
def user_del(request, nid):
models.UserInfo.objects.filter(id=nid).delete()
return redirect("/app2/user_info") # 编辑用户
def user_edit(request, nid):
if request.method == "GET":
obj = models.UserInfo.objects.filter(id=nid).first()
return render(request, "user_edit.html", {"obj": obj})
elif request.method == "POST":
user_id = request.POST.get('id')
u = request.POST.get('username')
p = request.POST.get('password')
models.UserInfo.objects.filter(id=user_id).update(username=u, password=p)
return redirect("/app2/user_info")
views.py
四、QuerySet方法详细
1、支持链式查询QuerySet方法：
def all(self)
# 获取所有的数据对象 def filter(self, *args, **kwargs)
# 条件查询
# 条件可以是：参数，字典，Q def exclude(self, *args, **kwargs)
# 条件查询
# 条件可以是：参数，字典，Q 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) # 支持having子句，放在最开始的地方就是where子句，放在这边就是having子句
# 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) # distinct=True去重
# 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进行去重，不支持mysql数据库 def order_by(self, *field_names)
# 用于排序
models.UserInfo.objects.all().order_by('-id','age') def reverse(self):
# 倒序
models.UserInfo.objects.all().order_by('-nid').reverse()
# 这个需要跟order_by配合使用,如果不存在order_by,则没有任何效果
# 如果存在order_by，reverse则是倒序，如果多个排序则一一倒序 def defer(self, *fields):
#查询表中的数据，排除username、id列数据,将剩余列数据组合成querySet对象进行返回
models.UserInfo.objects.defer('username','')
models.UserInfo.objects.filter(...).defer('username','id') def only(self, *fields):
#查询表中的数据，仅取username、id列中的数据组合成querySet对象进行返回，与defer相反
models.UserInfo.objects.only('username','id')
models.UserInfo.objects.filter(...).only('username','id') def using(self, alias):
models.Blog.objects.filter(name="root").filter("id=1").all().using(alias="default1") #这个看你settings里面的设置
#指定使用的数据库进行操作（从settings中读取DATABASES配置），使用场景：比如数据库的读写分离，读的是A库，写的是B库 # 在原生的sql语句中会遇到一些复杂的sql，如msyql自定义的函数和过程、额外的查询条件、映射、子查询
def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) #tables可不传，实例化的时候已传表名，order_by看使用场景使用 ## select与select_params配合,以%s进行传参，参数可以是元组，是可迭代的序列即可
Entry.objects.extra(select={'new_id': "%s"}, select_params=(1,))#select的参数，%s 就会替换成 1
#select *,1 as cid from Entry
Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
#select *,(select col from sometable where nid = 1) as new_id from Entry
Entry.objects.extra(select={'new_id': "func(1)"}) #可以直接放函数
#select func(1) as new_id ##where与params配合,加额外的where条件语句,以%s进行传参，参数可以是元组，是可迭代的序列即可
Entry.objects.extra(where=["name='a' OR age = 22"]) # or
Entry.objects.extra(where=["age = 22", "name='a'"]) # and
Entry.objects.extra(where=["func(arg)=2000"], params=[''])
Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) #性能相关的内置方法
def select_related(self, *fields)
#1、
users = User.objects.all()
for row in users:
#仅仅是用户表的数据不会再去请求数据库,user_type表需要再次发送请求，但是如果这边10条用户表的数据有十条,总共就会请求10+1次数据库
print(row.name,row.sex)
print(row.ut.type_name) #再次请求一次数据库 #2、
users = User.objects.all().values("name","sex","ut__type_name") #如果是这种的话，就会只请求一次数据库，但数据不是querySet对象类型 #3、
#只拿ut对应的user_type表一次性拿过来
users = User.objects.all().select_related("ut") #只关联ut这张表，取出来，其他的表都不关联，因为一张表里面可以有多个外键
for row in users:
print(row.name,row.sex)
print(row.ut.type_name)
print(row.tu.name) #tu没有加进去，所以这边会再次django发送数据库请求 def prefetch_related(self, *lookups)
#一般在生产环境，很少连表查询，因为这样效率很低，我们一般都是空间换时间，所以这个就会用到prefetch_related，用到这个，会做多次查询，保证每次都是单表查询
users = User.objects.filter(ut_id__gt=30).prefetch_related('ut') #这边也可以多加几个外键
#解析步骤
## select * from users where id > 30 当然这边不会用*的，一般会把所有字段都打印出来，效率更高
## 获取上一步中所有ut_id = [1,2]的数据
## select * from user_type where id in [1,2]
#这边django已经通过以上步骤，把要查询的数据放到内存中，所有就不用向数据库发送请求了，就可以直接从内存中获取
for row in users:
print(row.name,row.sex)
print(row.ut.type_name)
支持链式查询的QuerySet方法
2、不支持链式查询QuerySet方法：
def raw(self, raw_query, params=None, translations=None, using=None):
# 执行原生SQL
models.UserInfo.objects.raw('select * from userinfo')
#obj = User.objects.raw('select id,name,password from tb ') # 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名，
models.UserInfo.objects.raw('select id as nid from 其他表')
#可以下面的方式将tb2里面的数据复制在tb中
#obj = User.objects.raw('select nid as id,username as name,email as password from tb2 ') # 为原生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时区对象
#指定时区需要下载pytz库
"""
pip3 install pytz
import pytz
pytz.all_timezones
pytz.timezone(‘Asia/Shanghai’)
"""
models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai')) def none(self):
# 返回一个空QuerySet对象
不支持链式查询的QuerySet方法
3、数据库操作：
如：批量插入数据库，对整个数据做聚合操作
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')) # distinct=True 先去重，再执行聚合 相当于sql如下： #select count(nid) as n from user 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': '','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': '','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) #相当于in操作 def delete(self):
# 删除 def update(self, **kwargs):
# 更新 def exists(self):
# 是否有结果 METHODS THAT DO DATABASE QUERIES
直接对数据库操作
4、QuerySet序列化：
#第一种
##使用Django内置的方法对queryset类型的数据进行序列化 from django.core import serializers
ret = models.BookType.objects.all()
data = serializers.serialize("json", ret) #第二种
##使用json.dumps对queryset类型的数据进行序列化
####当list中queryset类型中没有复杂的数据类型（如：时间类型）可以直接使用json.dumps
import json
#ret = models.BookType.objects.all().values('caption')
ret = models.BookType.objects.all().values_list('id','caption')
ret=list(ret)
result = json.dumps(ret) ####当list中queryset类型中没有复杂的数据类型（如：时间）可以直接使用json.dumps
import json
from datetime import date
from datetime import datetime #自定义encoder
class JsonCustomEncoder(json.JSONEncoder): def default(self, field): if isinstance(field, datetime.datetime):
return field.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(field, date):
return field.strftime('%Y-%m-%d')
else:
return json.JSONEncoder.default(self, field) #再序列化带有类似于ctime复杂的数据类型
ret = models.BookType.objects.all().values_list('caption','ctime') ret=list(ret) result = json.dumps(ret, cls=JsonCustomEncoder)
QuerySet序列化的两种方式
五、Model利用钩子进行数据验证（弱）
django Model也是支持数据验证的，只是这个数据验证比较弱而已，只能支持单个的验证，但是对于组合的、固定的，就无法进行相关数据验证了
1、models.py
class User(models.Model):
name = models.CharField(max_length=32,db_index=True) #创建索引
email = models.EmailField(max_length=30)
#Model通过clean()函数设置钩子
def clean(self): #Model内部对所有字段进行正则验证，完毕之后才会执行这个clean方法
from django.core.exceptions import ValidationError
c = User.objects.filter(name=self.name).count()
if c:
raise ValidationError
2、views.py
from app01 import models def index(request):
obj = models.User(name="root",email="root")
obj.full_clean() #没有这个，name是不做验证的，有了full_clean是需要做验证的，验证不通过是要报错的，所以验证的时候，我们直接自己抓异常，进行异常处理
obj.save() return HttpResponse("hello")