models文件详细讲解

模型操作

# 增

models.Tb1.objects.create(c1='xx', c2='oo')  增加一条数据,可以接受字典类型数据 **kwargs
obj = models.Tb1(c1='xx', c2='oo')
obj.save()
#新增与更新(defaults=需要更新的字段内容,status/ip=条件)
LoginLog.objects.update_or_create(defaults={'tel':'13632353107'},status='1235',ip='1.1.1.1')

# 查
count = LoginLog.objects.count()        #获取总行数
log = LoginLog.objects.order_by('id')[(int(page)-1)*int(limit):int(limit)*int(page)]     #分页方法

models.Tb1.objects.get(id=123)         # 获取单条数据,不存在则报错(不建议)
models.Tb1.objects.all()               # 获取全部
obj = models.Tb1.objects.filter(name='seven') # 获取指定条件的数据
    obj = models.Tb1.objects.filter(name='seven',age='19') # 获取指定多条件的数据

obj = models.Tb1.objects.filter(name='seven').first()   # 获取指定条件的第一条数据
count = models.Tb1.objects.filter(name='seven').count()   # 计算获取到的指定条件数据的个数 
Test.objects.order_by("id")    #数据排序
Test.objects.filter(name="runoob").order_by("id")    # 上面的方法可以连锁使用


# 删

models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据

# 改
models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新,均支持 **kwargs
obj = models.Tb1.objects.get(id=1)
obj.c1 = '111'
obj.save()                                                 # 修改单条数据

###比较符号
    exclude 不等于
    __gt 大于       #如obj = models.Tb1.objects.filter(name__gt=18)     
    __gte 大于等于  如 LoginLog.objects.filter(tel=1363235318).filter(loginTime__gte="9999-1-1")
    __lt 小于
    __lte 小于等于
    __contains  类似 like %v%
    _range 范围 如:User.objects.filter(adddate_range=[begin_date,end_date])

字段类型

- AutoField(Field)   
    - int自增列,必须添入参数 primary_key=True

- BigAutoField(AutoField)
    - bigint自增列,必须填入参数 primary_key=True

- 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      存储组件,默认
    
- ImageField(FileField)
    - 字符串,路径保存在数据库,文件上传到指定目录
    - 参数:
        upload_to = ""      上传文件的保存路径
        storage = 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)
    - 二进制类型

字段中的参数详解:

null                数据库中字段是否可以为空(null=True)
db_column           数据库中字段的列名(db_column="test")
db_tablespace
default             数据库中字段的默认值
primary_key         数据库中字段是否为主键(primary_key=True)
db_index            数据库中字段是否可以建立索引(db_index=True)
unique              数据库中字段是否可以建立唯一索引(unique=True)
unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
unique_for_year     数据库中字段【年】部分是否可以建立唯一索引
auto_now            更新时自动更新当前时间
auto_now_add        创建时自动更新当前时间
verbose_name        Admin中显示的字段名称
blank               Admin中是否允许用户输入为空 表单提交时可以为空
editable            Admin中是否可以编辑
help_text           Admin中该字段的提示信息
choices             Admin中显示选择框的内容,用不变动的数据放在内存中从而避免跨表操作 如:gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
error_messages      自定义错误信息(字典类型),从而定制想要显示的错误信息;字典健:null, blank, invalid, invalid_choice, unique, and unique_for_date 如:{'null': "不能为空.", 'invalid': '格式错误'}

类中方法详解

- 基础样例
class BorrowStatus(models.Model):
    """借还状态"""
    id = models.AutoField(verbose_name='状态ID',primary_key=True,unique=True)
    statusName = models.CharField(max_length=20,verbose_name='状态名称')
    def __str__(self):  #被调用返回字段名,如admin列表中显示的字段,被外健链接显示的字段
        return self.statusName
    class Meta:     
        verbose_name = '状态参数'           #定义admin模块显示中文
        verbose_name_plural = '状态参数'        #定义admin模块详情显示中文

- 当前模块外健跟系统内部模块外健链接
from django.contrib.auth.models import User
class BorrowStatus(models.Model):
    """借还状态"""
    id = models.AutoField(verbose_name='状态ID',primary_key=True,unique=True)
    statusName = models.CharField(max_length=20,verbose_name='状态名称')
    def __str__(self):
        return self.statusName
# 建立外建
class BorrowInfo(models.Model):
    """借书信息"""
    borrowId = models.AutoField(verbose_name='订单编号',primary_key=True,unique=True)
    # 当前模块内部建立外健
    bookName = models.ForeignKey('BorrowStatus',on_delete=models.SET_NULL,null=True)
    # 导入User模块外部建立外健
    operation = models.ForeignKey(User,on_delete=models.SET_NULL,null=True,verbose_name='操作员')
   
# 选择下拉框 choices
class UserInfo(models.Model):
    USER_TYPE_LIST = ((1,'user'),(2,'admin'),)
    user_type = models.IntegerField(choices=USER_TYPE_LIST,default=1)

一对多,多对多,一对一

    连表结构
    一对多:models.ForeignKey(其他表)
    多对多:models.ManyToManyField(其他表)
    一对一:models.OneToOneField(其他表)
    
    应用场景:
    一对多:当一张表中创建一行数据时,有一个单选的下拉框(可以被重复选择)
    例如:创建用户信息时候,需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。
    多对多:在某表中创建一行数据是,有一个可以多选的下拉框
    例如:创建用户信息,需要为用户指定多个爱好
    一对一:在某表中创建一行数据时,有一个单选的下拉框(下拉框中的内容被用过一次就消失了
    例如:原有含10列数据的一张表保存相关信息,经过一段时间之后,10列无法满足需求,需要为原来的表再添加5列数据
 
 ForeignKey(ForeignObject) # ForeignObject(RelatedField)
    to,                         # 要进行关联的表名
    to_field=None,              # 要关联的表中的字段名称
    on_delete=None,             # 当删除关联表中的数据时,当前表与其关联的行的行为
                                    - models.CASCADE,删除被关联数据,与之关联(FK表的那行数据)也删除
                                    - models.DO_NOTHING,删除被关联数据,引发错误IntegrityError
                                    - models.PROTECT,删除被关联数据,引发错误ProtectedError
                                    - models.SET_NULL,删除被关联数据,与之关联的值设置为null(前提FK字段需要设置为可空)
                                    - models.SET_DEFAULT,删除被关联数据,与之关联的值设置为默认值(前提FK字段需要设置默认值)
                                    - models.SET,删除关联数据,
                                                  a. 与之关联的值设置为指定值,设置:models.SET(值)
                                                  b. 与之关联的值设置为可执行对象的返回值,设置:models.SET(可执行对象)

                                                    def func():
                                                        return 10

                                                    class MyModel(models.Model):
                                                        user = models.ForeignKey(
                                                            to="User",
                                                            to_field="id"
                                                            on_delete=models.SET(func),)
    related_name=None,          # 反向操作时,使用的字段名,用于代替 【表名_set】 如:related_name=b, 反向查询obj.表名_set.all() 就换成obj.b.all()
    related_query_name=None,    # 反向操作时,使用的连接前缀,用于替换【表名】     如: models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
    limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时,提供的条件:
                                # 如:
                                        - limit_choices_to={'nid__gt': 5}
                                        - limit_choices_to=lambda : {'nid__gt': 5}

                                        from django.db.models import Q
                                        - limit_choices_to=Q(nid__gt=10)
                                        - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                        - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
    db_constraint=True          # 是否在数据库中创建外键约束
    parent_link=False           # 在Admin中是否显示关联数据


OneToOneField(ForeignKey)
    to,                         # 要进行关联的表名
    to_field=None               # 要关联的表中的字段名称
    on_delete=None,             # 当删除关联表中的数据时,当前表与其关联的行的行为

                                ###### 对于一对一 ######
                                # 1. 一对一其实就是 一对多 + 唯一索引
                                # 2.当两个类之间有继承关系时,默认会创建一个一对一字段
                                # 如下会在A表中额外增加一个c_ptr_id列且唯一:
                                        class C(models.Model):
                                            nid = models.AutoField(primary_key=True)
                                            part = models.CharField(max_length=12)

                                        class A(C):
                                            id = models.AutoField(primary_key=True)
                                            code = models.CharField(max_length=1)

ManyToManyField(RelatedField)
    to,                         # 要进行关联的表名
    related_name=None,          # 反向操作时,使用的字段名,用于代替 【表名_set】 如: obj.表名_set.all()
    related_query_name=None,    # 反向操作时,使用的连接前缀,用于替换【表名】     如: models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
    limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时,提供的条件:
                                # 如:
                                        - limit_choices_to={'nid__gt': 5}
                                        - limit_choices_to=lambda : {'nid__gt': 5}

                                        from django.db.models import Q
                                        - limit_choices_to=Q(nid__gt=10)
                                        - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                        - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
    symmetrical=None,           # 仅用于多对多自关联时,symmetrical用于指定内部是否创建反向操作的字段
                                # 做如下操作时,不同的symmetrical会有不同的可选字段
                                    models.BB.objects.filter(...)

                                    # 可选字段有:code, id, m1
                                        class BB(models.Model):

                                        code = models.CharField(max_length=12)
                                        m1 = models.ManyToManyField('self',symmetrical=True)

                                    # 可选字段有: bb, code, id, m1
                                        class BB(models.Model):

                                        code = models.CharField(max_length=12)
                                        m1 = models.ManyToManyField('self',symmetrical=False)

    through=None,               # 自定义第三张表时,使用字段用于指定关系表
    through_fields=None,        # 自定义第三张表时,使用字段用于指定关系表中哪些字段做多对多关系表
    
    注意:这样定义后不能进行增删改,但是可以通过members字段进行查、进行clear(唯一优点)
                                    from django.db import models

                                    class Person(models.Model):
                                        name = models.CharField(max_length=50)

                                    class Group(models.Model):
                                        name = models.CharField(max_length=128)
                                        members = models.ManyToManyField(
                                            Person,
                                            through='Membership',
                                            through_fields=('group', 'person'),
                                        )

                                    class Membership(models.Model):
                                        group = models.ForeignKey(Group, on_delete=models.CASCADE)
                                        person = models.ForeignKey(Person, on_delete=models.CASCADE)
                                        inviter = models.ForeignKey(
                                            Person,
                                            on_delete=models.CASCADE,
                                            related_name="membership_invites",
                                        )
                                        invite_reason = models.CharField(max_length=64)
    db_constraint=True,         # 是否在数据库中创建外键约束
    db_table=None,              # 默认创建第三张表时,数据库中表的名称

你可能感兴趣的:(models文件详细讲解)