一 .模型 models
1 .常用模型
rom django.db import models
class School(models.Model):
pass
class Message(models.Model):
pass
class Teacher(models.Model):
pass
class Student(models.Model):
GENDER_CHOICES = (
('male', "男"),
('female', "女"),
('secret', "保密")
)
name = models.CharField(max_length=40, blank=True, verbose_name="姓名")
gender = models.CharField(max_length=6, choices=GENDER_CHOICES, default="secret", verbose_name="性别")
age = models.IntegerField(default=0, verbose_name="年龄")
rank = models.PositiveIntegerField(default=1, verbose_name="排名", unique=True)
discount = models.DecimalField(max_digits=3, decimal_places=2, verbose_name="折扣", default=1.0)
school = models.ForeignKey(to=School, verbose_name="学校", on_delete=models.CASCADE)
message = models.OneToOneField(to=Message, verbose_name="信息", on_delete=models.CASCADE)
teacher = models.ManyToManyField(verbose_name="老师", to=Teacher, blank=True)
introduce = models.TextField(blank=True, verbose_name="介绍")
grade = models.FloatField(default=0.0, verbose_name="成绩")
url = models.URLField(verbose_name="个人主页", max_length=100)
email = models.EmailField(verbose_name="邮箱")
image = models.ImageField(upload_to='img/%Y/%m/%d/', verbose_name='上传图片', null=True)
file = models.FileField(upload_to="file/%Y/%m/%d/", verbose_name="上传文件", blank=True)
is_deleted = models.BooleanField(verbose_name="已删除", default=False, blank=True)
time_added = models.DateTimeField(verbose_name="添加时间", auto_now_add=True, blank=True)
def delete(self, using=None, keep_parents=False):
self.is_deleted = True
# some actions
self.save()
def save(self, force_insert=False, force_update=False, using=None,
update_fields=None):
# some actions
self.name = self.name.capitalize() # 首字母大写
return super().save(force_insert=force_insert, force_update=force_update, using=using,
update_fields=update_fields)
def __repr__(self):
return "UserProfile:{}".format(self.name)
def __str__(self):
return self.name
class Meta:
ordering = ['-time_added']
verbose_name = "用户信息"
verbose_name_plural = verbose_name
db_table = "student_info"
unique_together = ("name", "gender")
# 1. python manage.py makemigrations 创建迁移的命令是
# 2.python manage.py migrate 执行迁移的命令
# https://www.cnblogs.com/yebaofang/p/9863678.html 遇到问题 降级django 或者 升级mysql
from django.db import models
# 班级
class Grades(models.Model):
gname = models.CharField(max_length=20)
gdate = models.DateTimeField()
ggirlnum = models.IntegerField()
gboynum = models.IntegerField()
isDelete = models.BooleanField(default=False)
def __str__(self): # (重写)
return self.gname
class Meta:
db_table = "grades" # 定义数据表名(推荐使用小写 数据表默认项目小写 类名)
ordering = []
# https://www.cnblogs.com/wt11/p/9660794.html
# https://blog.csdn.net/JamesPaul32/article/details/80776006
# 学生
class Students(models.Model):
sname = models.CharField(max_length=20)
sgender = models.BooleanField(default=True)
sage = models.IntegerField(db_column="age")
scontend = models.CharField(max_length=20)
isDelete = models.BooleanField(default=False)
# 是关联Grades 学生关联班级
grad= models.ForeignKey("Grades",on_delete=models.CASCADE)
# 一对多:models.ForeignKey(其他表)
# on_delete = models.CASCADE
# https://www.cnblogs.com/phyger/p/8035253.html
def getName(self):
return self.sname
def __str__(self): # (重写)
return self.sname
localTime = models.DateField(auto_now=True)
# """
# auto_now = True # 这个参数的默认值为false,设置为true时,能够在保存该字段时,将其值设置为当前时间,
# 并且每次修改model,都会自动更新。因此这个参数在需要存储“最后修改时间”的场景下,十分方便。需要注意的是,
# 设置该参数为true时,并不简单地意味着字段的默认值为当前时间,而是指字段会被“强制”更新到当前时间,
# 你无法程序中手动为字段赋值;如果使用django再带的admin管理器,那么该字段在admin中是只读的
# """
createTime = models.DateField(auto_now_add=True)
# """ # auto_now_add = True
# # 这个参数的默认值也为False,设置为True时,会在model对象第一次被创建时,将字段的值设置为创建时的时间,以后修改对象时,
# # 字段的值不会再更新。该属性通常被用在存储“创建时间”的场景下。与auto_now类似,auto_now_add也具有强制性,
# # 一旦被设置为True,就无法在程序中手动为字段赋值,在admin中字段也会成为只读的。"""
class Meta:
db_table = "students" # 定义数据表名(推荐使用小写 数据表默认项目小写 类名)
ordering = ['id'] # 对象默认排序字段 获取对象列表时使用
# https://www.cnblogs.com/wt11/p/9660794.html
# https://blog.csdn.net/JamesPaul32/article/details/80776006
V=models.CharField(max_length=None[, **options]) #varchar
V=models.EmailField([max_length=75, **options]) #varchar
V=models.URLField([verify_exists=True, max_length=200, **options]) #varchar
V=models.FileField(upload_to=None[, max_length=100, **options]) #varchar
#upload_to指定保存目录可带格式,
V=models.ImageField(upload_to=None[, height_field=None, width_field=None, max_length=100, **options])
V=models.IPAddressField([**options]) #varchar
V=models.FilePathField(path=None[, match=None, recursive=False, max_length=100, **options]) #varchar
V=models.SlugField([max_length=50, **options]) #varchar,标签,内含索引
V=models.CommaSeparatedIntegerField(max_length=None[, **options]) #varchar
V=models.IntegerField([**options]) #int
V=models.PositiveIntegerField([**options]) #int 正整数
V=models.SmallIntegerField([**options]) #smallint
V=models.PositiveSmallIntegerField([**options]) #smallint 正整数
V=models.AutoField(**options) #int;在Django代码内是自增
V=models.DecimalField(max_digits=None, decimal_places=None[, **options]) #decimal
V=models.FloatField([**options]) #real
V=models.BooleanField(**options) #boolean或bit
V=models.NullBooleanField([**options]) #bit字段上可以设置上null值
V=models.DateField([auto_now=False, auto_now_add=False, **options]) #date
#auto_now最后修改记录的日期;auto_now_add添加记录的日期
V=models.DateTimeField([auto_now=False, auto_now_add=False, **options]) #datetime
V=models.TimeField([auto_now=False, auto_now_add=False, **options]) #time
V=models.TextField([**options]) #text
V=models.XMLField(schema_path=None[, **options]) #text
——————————————————————————–
V=models.ForeignKey(othermodel[, **options]) #外键,关联其它模型,创建关联索引
V=models.ManyToManyField(othermodel[, **options]) #多对多,关联其它模型,创建关联表
V=models.OneToOneField(othermodel[, parent_link=False, **options]) #一对一,字段关联表属性
2. models字段介绍
1 创建类:继承model
class UserInfo(model.model):
user=CharFiled(是否为空 类型 长度 列名 索引)
3. 字段:
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=32)
class Group(models.Model):
# 自定义自增列
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32)
SmallIntegerField(IntegerField):
- 小整数 -32768 ~ 32767
PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正小整数 0 ~ 32767
IntegerField(Field)
- 整数列(有符号的) -2147483648 ~ 2147483647
PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正整数 0 ~ 2147483647
BigIntegerField(IntegerField):
- 长整型(有符号的) -9223372036854775808 ~ 9223372036854775807
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.2.1时候,可解析为192.0.2.1,开启刺功能,需要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)
- 二进制类型
DateTimeField
在Django中,代表时间字段的有三种:DateTimeField、DateField、TimeField,三种类型分别对应datetime()、date()、time(),都有auto_now和auto_now_add参数。
auto_now
默认值为False,设置为True时会在每次修改该对象时自动更新为当前时间,但是无法手动修改该字段的值。
auto_now_add
默认值为False,设置为True时会在创建对象时自动设置为当前时间,之后都不再修改,也不能手动修改其值。
默认当前时间,又能修改
有时候我们需要在创建对象时设置字段的值为当前时间,在后续时又能修改,使用auto_now或者auto_now_add都无法实现这一点。此时,可以使用default参数来设置默认值,如下
from django.db import models
from django.utils import timezone
class Message(models.Model):
add_date = models.DateTimeField(verbose_name='保存日期',default = timezone.now)
mod_date = models.DateTimeField(verbose_name='最后修改日期', auto_now = True)
4. models(表的关联)
ForeignKey对一
使用to指向被关联的模型,使用on_delete来规定被关联对象删除时该对象的处理方式。主要有两种取值,models.CASCADE和models.SET_NULL。models.CASCADE表示当被关联对象删除时删除该对象,
models.SET_NULL表示当被关联对象被删除时将该对象设置为空,此设置的前提是该字段要允许为空。
原生mysql
create table class(
id int primary key auto_increment,
course varchar(20) not null
);
select student.id,student.name,class.course from student left JOIN class on student.class_id=class.id;
create table student(
id int primary key auto_increment,
name varchar(20) not null,
class_id int not null,
constraint class_id foreign key(class_id ) references class(id)
on delete cascade
on update cascade
);
orm之model创建
class Classes(models.Model):
title=models.CharField(max_length=32)
# 学生表
class Student(models.Model):
username=models.CharField(max_length=32)
age= models.IntegerField()
gender=models. BooleanField()
# 一对多:就是主外键关系;(foreign key)
cs=models.ForeignKey(Classes)
学生表关联客户表, 学生一定是客户,客户不一定是学生.
create table customer(
id int primary key auto_increment,
name char(10),
qq int
);
create table stu(
id int primary key auto_increment,
name varchar(10),
cid int unique,
foreign key(cid) references customer(id)
);
ManyToManyField(多对多)
一个学生可以对应多个老师,一个老师也可以教多个学生,这就是一种多对多的关系
orm模型创建
class Teacher(models.Model):
'''老师表'''
teacher_name = models.CharField(max_length=30, verbose_name="老师", default="")
tel = models.CharField(max_length=30, verbose_name="电话", default="")
mail = models.CharField(max_length=30, verbose_name="邮箱", default="")
class Meta:
verbose_name = "老师"
verbose_name_plural = verbose_name
def __str__(self):
return self.teacher_name
class Student(models.Model):
'''学生表'''
student_id = models.CharField(max_length=30, verbose_name="学号", default="")
name = models.CharField(max_length=30, verbose_name="姓名", default="")
age = models.IntegerField(verbose_name="年龄", default="")
# 多对多
teachers = models.ManyToManyField(Teacher, verbose_name="老师")
class Meta:
verbose_name = "学生"
verbose_name_plural = verbose_name
def __str__(self):
return self.name
原生 mysql 语句创建
create table book(
id int primary key auto_increment,
name varchar(20) not null
);
create table author (
id int primary key auto_increment,
name varchar(20),
price float(5)
);
create table book2author(
id int primary key auto_increment,
book_id int,
author_id int,
foreign key(book_id) references book(id)
on delete cascade
on update cascade,
foreign key(author_id) references author(id)
on delete cascade
on update cascade,
unique(book_id,author_id)
);
OneToOne 一对一
当某个对象想扩展自另一个对象,那可以再这个对象的主键上添加一对一的关系。例如:
orm 模型表
class Place(model.Model):
address=models.CharField()
phone=models.Integer()
class Restaurant(Models.model):
place=models.OneToOneField(Plase)
原生sql语句
user 和 admin的一对一关系
create teable user(
id int premary key auto_increment,
name varchar(10)
on delete cascade
on update cascade# 只管理被关联的表
);
create table admin(
id int priment key auto_increment,
password varchar(10),
user_id int unique,
foreign key(user_id) references user(id)
);
5. 字段里面参数信息
class UserInfo(models.Model):
username=models.CharField(
null=True,
db_column="user",
max_length=32,
db_index=True, # 只能加速查找
verbose_name="用户名!!",
editable=False
# unique=True, # 加速查找限制列的唯一
# primary=True # 只能加速查找 限制列的唯一 不能为空
)
# primary_key 数据库中字段是否为主键
# db_index 数据库中字段是否可以建立索引
# unique 数据库中字段是否可以建立唯一索引
class SomeBody(models.Model):
caption=models.CharField(max_length=24),
pk=models.ForeignKey(
to="UserInfo", # ForeignKey 关联表
to_field="id" , # 表示与 UserInfo表的id关联
# related_name="b", # 反向操作时,使用的字段名,用于代替
related_query_name="b", # 反向操作时,使用的连接前缀,用于替换【表名】
)
class User(models.Model):
username=models.CharField(max_length=24,db_index=True)
par=models.ForeignKey(
to="Part",
to_field="id",
limit_choices_to={"id__gt":1} #只能在admin中生效 筛选出id大于一的
# 在Admin或ModelForm中显示关联数据时,提供的条件:
)
class Part(models.Model):
caption=models.CharField(max_length=24)
def __str__(self):
return self.caption
class Tag(models.Model):
title=models.CharField(max_length=24)
m=models.ManyToManyField( # ManyToManyField d多对多
to="User" , # 默认和user表的主键进行管理
# 表一
class User(models.Model):
username=models.CharField(max_length=24,db_index=True)
def __str__(self):
return self.username
# 表二
class Tag(models.Model):
title=models.CharField(max_length=24)
def __str__(self):
return self.title
# m=models.ManyToManyField( # ManyToManyField d多对多 使用 ManyToManyField 只能在第三章表 中创建三列数
# to="User" , # 默认和user表的主键进行管理
# )
# 自定义第三张表
class UserToTag(models.Model):
u=models.ForeignKey(to="User")
t=models.ForeignKey(to="Tag")
ctime=models.DateField()
class Meta: # 表示联合唯一 和 ManyToManyField 差不多
unique_together=[ # 表达的意思就是标签和同一个人不能出现多次 就一个人对应一个标签
("u","t"),
]
6. 元信息
class UserInfo(models.Model):
nid = models.AutoField(primary_key=True)
username = models.CharField(max_length=32)
class Meta:
# 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
db_table = "table_name"
# 联合索引
index_together = [
("pub_date", "deadline"),
]
# 联合唯一索引
unique_together = (("driver", "restaurant"),)
# admin中显示的表名称
verbose_name
# verbose_name加s
verbose_name_plural
在模型类中定义Meta类 用于设置元信息
class Meta:
db_table="" 定义数据表名(推荐使用小写 数据表默认项目小写 类名)
ordering=[] 对象默认排序字段 获取对象列表时使用
ordering=['id'] 升序
ordering=['-id'] 降序
class Meta:
db_table = "students" # 定义数据表名(推荐使用小写 数据表默认项目小写 类名)
ordering = ['id'] # 对象默认排序字段 获取对象列表时使用