Day 03 models模型
一. 配置MySQL
1,安装mysql:
sudo apt install mysql-server
(安装过程中输入密码并牢记)
2,安装后进入mysql:
mysql -u root -p
3,在Django中配置和使用mysql数据库
使用mysql数据库，settings中配置如下：
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'mydb',
'USER': 'root',
'PASSWORD': '123456',
'HOST': '127.0.0.1',
'PORT': '3306',
}
}
4, 添加PyMySQL
然后使用pip添加依赖包: pip install PyMySQL
并在工程目录下的__init__.py中添加以下代码来配置PyMySQL:
import pymysql
pymysql.install_as_MySQLdb()
二. models 字段类型
概述
django根据属性的类型确定以下信息
·当前选择的数据库支持字段的类型
·渲染管理表单时使用的默认html控件
·在管理站点最低限度的验证
django会为表增加自动增长的主键列，每个模型只能有一个主键列，如果使用选项设置某属性为主键列后，则django不会再生成默认的主键列
属性命名限制
·遵循标识符规则
·由于django的查询方式，不允许使用连续的下划线
定义属性时，需要字段类型，字段类型被定义在django.db.models.fields目录下，为了方便使用，被导入到django.db.models中
使用方式
·导入from django.db import models
·通过models.Field创建字段类型的对象，赋值给属性
逻辑删除和物理删除
对于重要数据都做逻辑删除，不做物理删除，实现方法是定义is_delete属性，类型为BooleanField，
默认值为False
is_delete = models.BooleanField(default=False)
常用字段类型：
·AutoField
·一个根据实际ID自动增长的IntegerField，通常不指定, 如果不指定，主键字段id将自动添加到模型中
·CharField(max_length=字符长度)
·字符串，默认的表单样式是 Input
·TextField
·大文本字段，一般超过4000使用，默认的表单控件是Textarea
·IntegerField
·整数
·DecimalField(max_digits=None, decimal_places=None)
·使用python的Decimal实例表示的十进制浮点数
·参数说明
·DecimalField.max_digits
·位数总数
·DecimalField.decimal_places
·小数点后的数字位数
·FloatField
·用Python的float实例来表示的浮点数
·BooleanField
·True/False 字段，此字段的默认表单控制是CheckboxInput
·NullBooleanField
·支持null、true、false三种值
·DateField([auto_now=False, auto_now_add=False])
·使用Python的datetime.date实例表示的日期
·参数说明
·DateField.auto_now
·每次保存对象时，自动设置该字段为当前时间，用于"最后一次修改"的时间戳，
它总是使用当前日期，默认为false
·DateField.auto_now_add
·当对象第一次被创建时自动设置当前时间，用于创建的时间戳，它总是使用创建时的日期，
默认为false
注意：auto_now_add, auto_now, and default 这些设置是相互排斥的，
他们之间的任何组合将会发生错误的结果
·TimeField
·使用Python的datetime.time实例表示的时间，参数同DateField
·DateTimeField
·使用Python的datetime.datetime实例表示的日期和时间，参数同DateField
·FileField
·一个上传文件的字段
·ImageField
·继承了FileField的所有属性和方法，但对上传的对象进行校验，确保它是个有效的image
模型中的字段类型
主键外键相关：
AutoField(auto_created=True, primary_key=True,verbose_name="用户id")
ForeignKey(类名)
ManyToManyField(类名)
OneToOneField(类名)
字符相关：
CharField(max_length=200)
TextField()
数字金钱相关
IntegerField()
FloatField()
DecimalField(max_digits=10, decimal_places=2)
日期时间相关：
DateField()
TimeField()
DateTimeField()
布尔值相关：
BooleanField()
NullBooleanField()
文件相关：
FileField()
ImageField() pip install pillow
class User(models.Model):
uid = models.AutoField(auto_created=True, primary_key=True,verbose_name="用户id")
name = models.CharField(max_length=200)
age = models.IntegerField()
sex = models.BooleanField(default=False)
info = models.TextField(null=True, blank=True)
salary = models.DecimalField(max_digits=10, decimal_places=2)
money = models.FloatField()
ismarried = models.NullBooleanField(default=False)
birthday = models.DateField(auto_now=True)
birthday2 = models.DateField(auto_now_add=True)
icon = models.FileField()
icon2 = models.ImageField()
TYPE=(
(1,"青铜"),
(2,"白银"),
(3,"黄金"),
)
user_type = models.IntegerField(choices=TYPE, default=1)
user_type2 = models.ForeignKey(UserType, on_delete=models.SET_DEFAULT, default=1)
idcard = models.OneToOneField(Idcard)
movies = models.ManyToManyField(Movie)
三. 常用字段参数
常用字段选项（通过字段选项，可以实现对字段的约束）：
1、 null=True
数据库中字段是否可以为空
2、 blank=True
django的 Admin 中添加数据时是否可允许空值
一般null=True & blank=True 搭配着用，出现null=True就用上blank=True
3、 primary_key = True
主键，对AutoField设置主键后，就会代替原来的自增 id 列
4、 auto_now 和 auto_now_add
auto_now 自动创建---无论添加或修改，都是当前操作的时间
auto_now_add 自动创建---永远是创建时的时间
5、 choices （后台admin下拉菜单）
USER_TYPE_LIST = (
(1, '超级用户'),
(2, '普通用户'),
)
user_type = models.IntegerField(choices=USER_TYPE_LIST,default=1,verbose_name='用户类型')
6、 max_length 最大长度
7、 default 默认值
8、 verbose_name Admin（后台显示的名称）中字段的显示名称
9、 name|db_column 数据库中的字段名称
10、unique=True 不允许重复
11、db_index = True 数据库索引,例如：如果你想通过name查询的更快的话，给他设置为索引即可
12、editable=True 在Admin里是否可编辑，不可编辑则不显示
13、设置表名
class Meta:
db_table = 'person'
14、on_delete：
四. models基本操作
一般的数据库操作流程：
1. 创建数据库，设计表结构和字段
2. 连接Mysql数据库，并编写数据访问层代码
3. 业务逻辑层去调用数据访问层执行数据库操作
Django通过Model操作数据库，不管你数据库的类型是MySql或者Sqlite，Django自动帮你生成相应数据库类型的SQL语句，所以不需要关注SQL语句和类型，对数据的操作Django帮我们自动完成。只要会写Model就可以了。
django使用对象关系映射（Object Relational Mapping，简称ORM）框架去操控数据库。
ORM(Object Relational Mapping)对象关系映射，是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。
单表增删改查
ORM:
模型 <=> 表
类结构 -> 表结构
对象 -> 表的一条数据
类属性 -> 表的字段
models基本操作
模型定义：
class Author(models.Model):
first_name = models.Charfield(max_length=20)
last_name = models.Charfield(max_length=20)
增：
1）创建对象实例，然后调用save方法：
obj = Author()
obj.first_name = 'zhang'
obj.last_name = 'san'
obj.save()
2）创建对象并初始化,再调用save方法:
obj = Author(first_name='zhang', last_name='san')
obj.save()
3）使用create方法
Author.objects.create(first_name='li', last_name='si')
4）使用get_or_create方法，可以防止重复
Author.objects.get_or_create(first_name='zhang', last_name='san')
删：
使用Queryset的delete方法：
Author.objects.filter(first_name='zhang').delete()
Author.objects.all().delete()
注意： objects不能直接调用delete方法。
使用模型对象的delete方法：
obj = Author.objects.get(id=5)
obj.delete()
改：
Author.objects.filter(last_name='dfdf').update(last_name='san')
模型没有定义update方法，直接给字段赋值，并调用save，能实现update的功能，比如：
obj = Author.objects.get(id=3)
obj.first_name = 'zhang'
obj.save()
save更新时会更新所有字段。如果只想更新某个字段，减少数据库操作，可以这么做：
obj.first_name = 'li'
obj.save(update_fields=['first_name'])
查：
get()：获取单条数据：
Author.objects.get(id=123)
如果没有找到符合条件的对象，会引发模型类.DoesNotExist异常
如果找到多个，会引发模型类.MultipleObjectsReturned 异常
first()：返回查询集(QuerySet)中的第一个对象
last()：返回查询集中的最后一个对象
count()：返回当前查询集中的对象个数
exists()：判断查询集中是否有数据，如果有数据返回True没有反之
all()：获取全部数据：
Author.objects.all()
values(): 获取指定列的值，可以传多个参数！返回包含字典的列表（保存了字段名和对应的值）
Author.objects.all().values('password')
values_list(): 获取指定列的值，可以传多个参数！返回包含元组列表（只保存值）
Author.objects.all().values_list('password')
进阶操作：
Author.objects.filter(name='seven').count()
Author.objects.filter(id__gt=1)
Author.objects.filter(id__gte=1)
Author.objects.filter(id__lt=10)
Author.objects.filter(id__lte=10)
Author.objects.filter(id__lt=10, id__gt=1)
Author.objects.filter(id__in=[11, 22, 33])
Author.objects.exclude(id__in=[11, 22, 33])
Author.objects.filter(name__contains="ven")
Author.objects.filter(name__icontains="ven")
Author.objects.filter(name__regex="^ven")
Author.objects.filter(name__iregex="^ven")
Author.objects.filter(age__range=[10, 20])
Author.objects.filter(name='seven').order_by('id')
Author.objects.filter(name='seven').order_by('-id')
Author.objects.all()[10:20]
page 页码
per_page 每页数量 =5
第1页(page=1)：0-4 => [0:5]
第2页(page=2): 5-9 => [5:10]
第3页(page=3): 10-14 => [10:15]
第4页(page=4): 15-19 => [15:20]
...
每一页数据范围：
[(page-1)*per_page: page*per_page]
使用aggregate()函数返回聚合函数的值
Avg：平均值
Count：数量
Max：最大
Min：最小
Sum：求和
from django.db.models import Count, Min, Max, Sum
Author.objects.aggregate(Max('age'))
五、Model连表结构
1.连表结构
一对多：models.ForeignKey(其他表)
多对多：models.ManyToManyField(其他表)
一对一：models.OneToOneField(其他表)
应用场景：
一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择）
例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】
多对多：在某表中创建一行数据时，有一个可以多选的下拉框。（猫眼App, 淘票票，格拉瓦电影）
例如：创建用户信息，需要为用户指定多个爱好。
一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了）
例如：有个身份证表，有个person表。每个人只能有一张身份证，
一张身份证也只能对应一个人，这就是一对一关系。
2.一对多关联
一对多关系，即外键
为什么要用一对多。先来看一个例子。有一个用户信息表，其中有个用户类型字段，存储用户的用户类型。如下：
class UserInfo(models.Model):
username = models.CharField(max_length=32)
age = models.IntegerField()
user_type = models.CharField(max_length=10)
不使用外键时用户类型存储在每一行数据中。
优点：如使用外键则只需要存储关联表的id即可，能够节省大量的存储空间。
同时使用外键有利于维持数据完整性和一致性。
缺点：数据库设计变的更复杂了。每次做DELETE 或者UPDATE都必须考虑外键约束。
模型定义：
class UserType(models.Model):
tname = models.CharField(max_length=20)
def __str__(self):
return self.tname
class User(models.Model):
name = models.CharField(max_length=20)
age = models.IntegerField()
user_type = models.ForeignKey(UserType, on_delete=models.SET_DEFAULT, default=1)
def __str__(self):
return self.name
我们约定：
正向操作: ForeignKey在User表里，如果根据User去操作就是正向操作。
反向操作: ForeignKey不在UserType里，如果根据UserType去操作就是反向操作。
一对多的关系的增删改查：
正向操作：
增
1）创建对象实例，然后调用save方法：
obj = User(name='li', age=44, user_type_id=2)
obj.save()
2）使用create方法
User.objects.create(name='li', age=44, user_type_id=2)
3）使用get_or_create方法，可以防止重复
User.objects.get_or_create(name='li', age=55, user_type_id=2)
4）使用字典。
dic = {'name':'zhangsan','age':18,'user_type_id':3}
User.objects.create(**dic)
5）通过对象添加
usertype = UserType.objects.get(id=1)
User.objects.create(name='li', age=55, user_type=usertype)
删
和普通模式一样删除即可。如：
User.objects.filter(id=1).delete()
改
和普通模式一样修改即可。如：
User.objects.filter(id=2).update(user_type_id=4)
查
正向查找所有用户类型为钻石用户的用户，使用双下划线：
users = User.objects.filter(user_type__tname__contains='钻石')
user = User.objects.filter(name="诸葛孔明10").first()
ut = user.user_type
print(user.user_type, type(user.user_type))
正向获取关联表中的属性可以直接使用点.语法，比如获取users查询集中第一个用户的tname：
users[0].user_type.tname
print(user.user_type_id, user.user_type.id)
反向操作：
增 (一般使用正向增即可)
通过UserType来创建user
1） 通过user_set的create方法
ut = UserType.objects.get(id=2)
ut.user_set.create(name='smith',age=33)
删
删除操作可以在定义外键关系的时候，通过on_delete参数来配置删除时做的操作。
on_delete参数主要有以下几个可选值：
models.CASCADE 默认值(Django1.11)，表示级联删除，
即删除UserType时，相关联的User也会被删除。
models.PROTECT 保护模式， 阻止级联删除。
models.SET_NULL 置空模式，设为null，null=True参数必须具备
models.SET_DEFAULT 置默认值 设为默认值，default参数必须具备
models.SET() 删除的时候重新动态指向一个实体访问对应元素，可传函数
models.DO_NOTHING 什么也不做。（Django1.11）
注意: 修改on_delete参数之后需要重新同步数据库，如果使用
UserType.objects.get(id=2).delete()
改
和普通模式一样，不会影响级联表。
因为User_Type表的主键id是自动生成的，修改User_Type其他字段，不会影响User级联表
UserType.objects.filter(pk=1).update(tname="星耀")
查
通过usertype对象来查用户类型为1的用户有哪些
obj=UserType.objects.get(id=1)
print(obj.user_set, type(obj.user_set))
obj.user_set.all()
print(users, type(users))
可以通过在定义foreignkey时指定related_name来修改默认的userinfo_set，
比如指定related_name为info
user_type = models.ForeignKey('UserType'，related_name='info')
指定related_name之后，反向查的时候就变成了：
obj.info.all()
获取用户类型为1且用户名为shuaige的用户
obj.info.filter(name='shuaige')
外键关系中，django自动给UserType加了一个叫做user的属性。
使用双下划线，可以通过user提供的信息来查usertype (了解)
user_type_obj = UserType.objects.get(user__name='zs')
3.多对多关联
多对多关系
针对多对多关系django会自动创建第三张表。也可以通过through参数指定第三张表。
用户和组是典型的多对多关系：
class Group(models.Model):
name = models.CharField(max_length=20)
def __str__(self):
return self.name
class User(models.Model):
name = models.CharField(max_length=64)
password = models.CharField(max_length=64)
groups = models.ManyToManyField(Group)
def __str__(self):
return self.name
操作：
增：
先分别创建user和group, 再使用add关联
user = User(name='aa', password='123')
user.save()
group = Group(name='g5')
group.save()
通过Manager对象使用add()方法
正向：user.groups.add(group)
反向：group.user_set.add(user)
两个都会增加一条user_id <=>group_id 的记录，但是不会重复
删：
和一对多类似，删除user或group会级联删除中间表user_groups表中的关联数据，
只能级联删除，无法设置on_delete选项
正向： User.objects.filter(pk=1).delete()
反向： Group.objects.filter(pk=2).delete()
改：
和一对多类似，只修改当前表
正向： User.objects.filter(pk=1).delete()
反向： Group.objects.filter(pk=2).delete()
查：
正向：
查询id=2的用户所在的所有组group
user = User.objects.get(id=2)
print(user.groups, type(user.groups))
print(user.groups.all())
print(len(user.groups.all()))
user.groups.all()
反向：
查询id=1的组中包含的所有用户
group = Group.objects.get(id=1)
group.user_set.all()
4.一对一关联
一对一关系
一对一不是数据库的一个连表操作，而是Django独有的一个连表操作。
一对一关系相当于是特殊的一对多关系，只是相当于加了unique=True。
一个人只能有一张身份证，一张身份证对应一个人，是一个典型的一对一关系。
class IdCard(models.Model):
idnum = models.IntegerField()
def __str__(self):
return str(self.idnum)
class Person(models.Model):
name = models.CharField(max_length=20)
idcard = models.OneToOneField(IdCard)
def __str__(self):
return self.name
一对一关系比较简单。两种表互相都有对方。比如：
正向：
user = User.objects.get(id=1)
print(user.idcard, type(user.idcard))
print(user.idcard.idcard_num)
反向：
idcard = Idcard.objects.get(id=1)
print(idcard.user, type(idcard.user))
print(idcard.user.name)
六、F函数和Q函数
F 查询：专门取对象中某列值的操作
Q 查询：对对象的复杂查询
导入Q,F对象 :
from django.db.models import Q,F
F:主要作用
1）和models自身的字段进行对比。比如：
Student.objects.filter(age__gt=F('age2'))
2） 对字段进行数学运算。比如：
Student.objects.filter(age__gt=F('age2') * 2)
Q:
且操作:
默认情况下Django的查询只是且操作如下：
找到用户为zhangsan并且age=18的数据
UserInfo.objects.filter(username='zhangsan',age='18')
或操作：
如果需要执行或操作 ，就需要使用到Q对象了
Q对象可以用 & | ~ (与，或，非)去连接
UserInfo.objects.filter(Q(age__gt=20) & Q(age__lt=50))
UserInfo.objects.filter(Q(age__gt=20) | Q(age__lt=50))
UserInfo.objects.filter(~Q(age__lt=50))
等于： WHERE question LIKE 'Who%' OR question LIKE 'What%'
如果Q和关键字参数一起使用的话，Q必须放在关键字参数前面：
Student.objects.get(Q(age__gt=20) | Q(age__lt=50), name__contains='zhang')
七、models的Manage
django通过models的manager来执行数据库操作。
每个django model至少有一个manager。
可以自定义manager。
自定义manager必须继承自models.Manager
给默认的manager改名：
class Person(models.Model):
...
people = models.Manager()
定制manager
1）增加额外的方法：
class BookManager(models.Manager):
def title_count(self, keyword):
return self.filter(title__icontains=keyword).count()
class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()
num_pages = models.IntegerField(blank=True, null=True)
objects = BookManager()
def __str__(self):
return self.title
2）修改默认manager的查询集
class DahlBookManager(models.Manager):
def get_queryset(self):
return super().get_queryset().filter(author='Roa')
class Book(models.Model):
title = models.CharField(max_length=100)
author = models.CharField(max_length=50)
objects = models.Manager()
dahl_objects = DahlBookManager()
3）使用多个manager
class MaleManager(models.Manager):
def get_queryset(self):
return super(MaleManager, self).get_queryset().filter(sex='M')
class FemaleManager(models.Manager):
def get_queryset(self):
return super(FemaleManager, self).get_queryset().filter(sex='F')
class Person(models.Model):
first_name = models.CharField(max_length=50)
last_name = models.CharField(max_length=50)
sex = models.CharField(
max_length=1,
choices=( ('M', 'Male'), ('F', 'Female') )
)
people = models.Manager()
men = MaleManager()
women = FemaleManager()
扫一扫
1933
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
