八 .Django 模型(models)

一 .模型 models

1 .常用模型

https://www.django.cn/course/show-11.html

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字段介绍

注意:

存储字符串
PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
IPAddressField(Field)
UUIDField(Field)
EmailField
CommaSeparatedIntegerField(CharField)
DecimalField(Field)
 FilePathField(Field)
 CharField(Field)

    
这里里面自自带验证都是给admin管理后台同比如 email  ip  uu img 等

直接通过 models.userinfo.objects.create()   存储的字符串     需要model Form组件 来验证和约束
 

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']  # 对象默认排序字段  获取对象列表时使用

 7. 常用字段

<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参数.

8. filed字段的参数

<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 如果为真将为此字段创建索引

   

 9 .choices枚举

   用于场景 固定选项 动态还是要用FK
 
   choices：一个用来选择值的2维元组。第一个值是实际存储的值，第二个用来方便进行选择。
                如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),)
                gender = models.CharField(max_length=2,choices = SEX_CHOICES)

class msg(models.Model):
     
    choice = (
        (1, '技术部'),
        (2, '行政'),
        (3, '人事'),
        (4, "财务"),
    )
    group = models.IntegerField(choices=choice)

 https://www.cnblogs.com/wupeiqi/articles/6216618.html