Django——模型层

模型层（ORM语法）

• models.py

class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    register_time = models.DateField()  # 年月日
    """
    DateField
    DateTimeField
        两个重要参数 
        auto_now:每次操作数据的时候 该字段会自动将当前时间更新
        auto_now_add:在创建数据的时候会自动将当前创建时间记录下来 之后只要不认为的修改 那么就一直不变
    """
    def __str__(self):
        return '对象:%s'%self.name


class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    publish_date = models.DateField(auto_now_add=True)

    # 一对多
    publish = models.ForeignKey(to='Publish')
    # 多对多
    authors = models.ManyToManyField(to='Author')


class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=64)
    email = models.EmailField()
    # varchar(254)  该字段类型不是给models看的 而是给后面我们会学到的校验性组件看的

    def __str__(self):
        return '对象:%s'%self.name


class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    # 一对一
    author_detail = models.OneToOneField(to='AuthorDetail')


class AuthorDetail(models.Model):
    phone = models.BigIntegerField()  # 电话号码用BigIntegerField或者直接用CharField
    addr = models.CharField(max_length=64)

单表查询（增删改查）

• 增

# 添加数据的两种方式：
#    create()
#    obj = models.XXX(xxx=xxx,...) obj.save()
res = models.User.objects.create(name='jason',age=18,register_time='2002-1-21')
print(res)
import datetime
ctime = datetime.datetime.now()
user_obj = models.User(name='egon',age=84,register_time=ctime)
user_obj.save()

• 删

# 删除数据的两种方式：
#    delete() 删除匹配到的所有数据
#    对象.delete() 指定删除某条数据
res = models.User.objects.filter(pk=2).delete()
print(res)
    """
    pk会自动查找到当前表的主键字段 指代的就是当前表的主键字段
    用了pk之后 你就不需要指代当前表的主键字段到底叫什么了
        uid
        pid
        sid
        ...
    """
user_obj = models.User.objects.filter(pk=1).first()
user_obj.delete()

• 改

# 修改数据的两种方式：
#    update() 修改匹配到的所有数据
#    对象.属性=值 修改指定对象的指定属性对象.save()保存
models.User.objects.filter(pk=4).update(name='egonDSB')

user_obj = models.User.objects.get(pk=4)
user_obj = models.User.objects.filter(pk=6)
    """
    get方法返回的直接就是当前数据对象
    但是该方法不推荐使用
        一旦数据不存在该方法会直接报错
        而filter则不会
            所以我们还是用filter
    """
user_obj.name = 'egonPPP'
user_obj.save()

常见的十几种查询方法

• all() 查询所有数据
• filter() 带有过滤条件的查询
• get() 直接拿数据对象 但是条件不存在直接报错
• first() 获取QuerySet对象中的第一个元素

res = models.User.objects.all().first()
print(res)

• last() 获取QuerySet对象中的最后一个元素

res = models.User.objects.all().last()
print(res)

• values() 可以指定获取的数据字段
• values_list()

res = models.User.objects.values('name','age') # 返回值可以看成是一个列表套字典
print(res) # <QuerySet [{'name': 'jason', 'age': 18}, {'name': 'egon', 'age': 84}]>

res = models.User.objects.values_list('name','age') # 返回值可以看成是一个列表套元组
print(res) # <QuerySet [('jason', 18), ('egon', 84)]>

# 查看内部封装的sql语句
print(res.query) # SELECT `app01_user`.`name`, `app01_user`.`age` FROM `app01_user`
'''
注意：只有queryset对象才能够.query查看内部sql语句
'''

# 其他查看内部sql语句的办法：将下列代码复制到配置文件中,再执行打印语句即可打印内部sql语句
print(res) # SELECT `app01_user`.`name`, `app01_user`.`age` FROM `app01_user` LIMIT 21; args=()
"""
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}
"""

• distinct() 去重

res = models.User.objects.values('name','age').distinct()
print(res)
'''
注意：去重一定要是两条完全相同的数据才能够去重
使用去重时必须要将主键考虑进来
'''

• order_by() 分组

    res = models.User.objects.order_by('age')  # 默认升序
    res = models.User.objects.order_by('-age')  # 降序
    print(res)

• reverse() 反转(ps:前提必须是已经排序过的数据 order_by())

res = models.User.objects.all()
res1 = models.User.objects.order_by('age').reverse()
print(res)
print(res1)

• count() 统计当前数据的个数

res = models.User.objects.count()
print(res)

• exclude() 将符合括号内条件的数据排除在外

res = models.User.objects.exclude(name='jason')
print(res)

• exists() 判断数据是否存在，返回的是布尔值（基本不用，数据本身就自带布尔值）

res = models.User.objects.filter(pk=10).exists()
print(res)

测试脚本

"""
当你只是想测试django中的某一个py文件内容 那么你可以不用书写前后端交互的形式
而是直接写一个测试脚本即可

脚本代码无论是写在应用下的tests.py还是自己单独开设py文件都可以
"""
# 测试环境的准备 去manage.py中拷贝前四行代码 然后自己写两行
import os
import sys

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings")
    import django
    django.setup()
    # 在这个代码块的下面就可以测试django里面的单个py文件了
    '''
    注意：测试代码必须写在测试环境中，
    	即所有的要执行的测试代码都必须写在django.setup()后面（包括模块得导入）
    '''

神奇的双下划线查询

• 年龄大于35岁的数据

# __gt
res = models.User.objects.filter(age__gt=35)
print(res)

• 年龄小于35岁的数据

# __lt
res = models.User.objects.filter(age__lt=35)
print(res)

• 年龄大于等于32岁、小于等于32岁的数据

# __gte  __lte
res = models.User.objects.filter(age__gte=32)  # 大于等于
print(res)
res = models.User.objects.filter(age__lte=32) # 小于等于
print(res)

• 年龄是18 或者32或者40的数据

# __in
res = models.User.objects.filter(age__in=[18,32,40])
print(res)

• 年龄在18到40岁之间的数据

# __range
res = models.User.objects.filter(age_range=[18,40]) # 顾头也顾尾
print(res)

• 查询名字中含有p的数据(区分大小写)

# __contains
res = models.User.objects.filter(name__contains='p') # 区分大小写
print(res) # <QuerySet [<User: 对象:ppp>]>

• 查询名字中含有p的数据(不区分大小写)

# name__icontains
res = models.User.objects.filter(name__icontains='p') # 区分大小写
print(res) # <QuerySet [<User: 对象:PPP>, <User: 对象:ppp>]>

• 查询名字以j开头(结尾)的数据

# __startswith
res = models.User.objects.filter(name__startswith='j')
print(res) # <QuerySet [<User: 对象:jason>]>
# __endswith
res = models.User.objects.filter(name__endswith='p')
print(res) # <QuerySet [<User: 对象:ppp>]>

• 查询注册时间是2020年、1月的数据

# __year 年、__month 月、__day 日
res = models.User.objects.filter(register_time__month='1')
res = models.User.objects.filter(register_time__year='2020')
print(res)

多表操作

• 一对多外键增删改查

# 一对多外键增删改查
# 增
# 1  直接写实际字段 id
models.Book.objects.create(title='论语',price=899.23,publish_id=1)
models.Book.objects.create(title='聊斋',price=444.23,publish_id=2)
models.Book.objects.create(title='老子',price=333.66,publish_id=1)
# 2  虚拟字段 对象
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.create(title='红楼梦',price=666.23,publish=publish_obj)

# 删
models.Publish.objects.filter(pk=1).delete()  # 级联删除

# 修改
# 1 实际字段修改
models.Book.objects.filter(pk=1).update(publish_id=2) 
# 2 虚拟字段修改
publish_obj = models.Publish.objects.filter(pk=1).first()
models.Book.objects.filter(pk=1).update(publish=publish_obj) 

• 多对多外键增删改查

# 如何给书籍添加作者？
book_obj = models.Book.objects.filter(pk=1).first()
print(book_obj.authors)  # 就类似于你已经到了第三张关系表了
book_obj.authors.add(1)  # 书籍id为1的书籍绑定一个主键为1 的作者
book_obj.authors.add(2,3)

author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=2).first()
author_obj2 = models.Author.objects.filter(pk=3).first()
book_obj.authors.add(author_obj)
book_obj.authors.add(author_obj1,author_obj2)
"""
add给第三张关系表添加数据
   括号内既可以传数字也可以传对象 并且都支持多个
"""

# 删
book_obj.authors.remove(2)
book_obj.authors.remove(1,3)

author_obj = models.Author.objects.filter(pk=2).first()
author_obj1 = models.Author.objects.filter(pk=3).first()
book_obj.authors.remove(author_obj,author_obj1)
"""
remove
   括号内既可以传数字也可以传对象 并且都支持多个
"""


# 修改
book_obj.authors.set([1,2])  # 括号内必须给一个可迭代对象
book_obj.authors.set([3])  # 括号内必须给一个可迭代对象

author_obj = models.Author.objects.filter(pk=2).first()
author_obj1 = models.Author.objects.filter(pk=3).first()
book_obj.authors.set([author_obj,author_obj1])  # 括号内必须给一个可迭代对象
"""
set
   括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个
"""

# 清空
# 在第三张关系表中清空某个书籍与作者的绑定关系
book_obj.authors.clear()
"""
clear
    括号内不要加任何参数
    
"""

正向反向的概念

# 正向：外键字段在我手上那么，我查你就是正向
# 反向：外键字段如果不在手上，我查你就是反向
  book >>>外键字段在书那(正向)>>> publish
  publish >>>外键字段在书那(反向)>>> book
'''
正向查找：按字段
反向查找：表名小写
'''

跨表查询(重点)

• 子查询(基于对象的跨表查询)

# 结合练习题来加强理解
# 1.查询书籍主键为1的出版社 （书查出版社，主键字段在书这边，正向）
    book_obj = models.Book.objects.filter(pk=1).first()
    res = book_obj.publish
    print(res, res.name)
# 2.查询书籍主键为2的作者（书查作者，主键字段在书这边，正向）
    book_obj = models.Book.objects.filter(pk=2).first()
    # res = book_obj.authors  # app01.Author.None
    res = book_obj.authors.all()  # <QuerySet [<Author: Author object>, <Author: Author object>]>
    print(res)
# 3.查询作者jason的电话号码（作者查作者详情，主键字段在作者这边，正向）
    author_obj = models.Author.objects.filter(name='jason').first()
    res = author_obj.author_detail
    print(res)
    print(res.phone)
'''
建议：写orm语句与写sql语句类似，不要想着一次性写完，写一点看一点
正向什么时候需要加.all():
	当结果可能有多个的时候需要加.all() （多对多关系）
	当结果为一个则直接拿到数据对象无需.all()（一对一、一对多）
'''
# 4.查询出版社是北方出版社出版的书（出版社查书，主键字段在书这边，反向）
    publish_obj = models.Publish.objects.filter(name='北方出版社').first()
    res = publish_obj.book_set # app01.Book.None
    res = publish_obj.book_set.all()
    print(res)

# 5.查询作者是jason写过的书（作者查书，主键字段在书这边，反向）
    author_obj = models.Author.objects.filter(name='jason').first()
    res = author_obj.book_set.all()
    print(res)

# 6.查询手机号是110的作者姓名（作者详情查作者，主键在作者这边，反向）
    author_detail_obj = models.AuthorDetail.objects.filter(phone='110').first()
    res = author_detail_obj.author
    print(res)

'''
反向查询什么时候需要加_set.all():
	当查询结果可能是多个时就必须加_set.all() （多对多、一对多）
	当查询结果只有一个时，不需要加_set.all() （一对一）
'''

• 联表查询(基于双下划线的跨表查询)

# 结合练习题来加强理解
# 1.查询jason的手机号和作者姓名
'''
正向：
	res = models.Author.objects.filter(name='jason').values('name', 'author_detail__phone')
	print(res)
反向：
    res = models.AuthorDetail.objects.filter(author__name='jason').values('author__name', 'phone')
    print(res)
'''
# 2.查询书籍主键为1的出版社名称和书的名称
'''
正向：
    res = models.Book.objects.filter(pk=1).values('title', 'publish__name')
    print(res)
反向：
    res = models.Publish.objects.filter(book__pk=1).values('book__title', 'name')
    print(res)
'''
# 3.查询书籍主键为1的作者姓名
'''
正向：
    res = models.Book.objects.filter(pk=1).values('authors__name')
    print(res)
反向：
    res = models.Author.objects.filter(book__pk=1).values('name')
    print(res)
'''
# 4.查询书籍主键是1的作者的手机号
'''
正向：
    res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
    print(res)
反向：
    res = models.AuthorDetail.objects.filter(author__book__pk=1).values('phone')
    print(res)
'''

聚合查询

# 聚合查询 aggregate()
# 通常情况下都是配合分组一起使用
    '''
    只要是与数据库相关的模块
        基本都在django.db.models中
        如果上述没有那么应该在django.db中
    '''
    from django.db.models import Max,Min,Sum,Count,Avg
    # 1 所有书的平均价格
    res = models.Book.objects.aggregate(Avg('price'))
    print(res)
    # 2.上述方法一次性使用
    res = models.Book.objects.aggregate(Max('price'),Min('price'),Sum('price'),Count('pk'),Avg('price'))
    print(res)

分组查询

# 分组查询：annotate()
'''
MYSQL分组查询，分组之后默认只能获取分组的依据，无法直接获取其他字段（开启了严格模式）
	严格模式：ONLY_FULL_GROUP_BY
'''
from django.db.models import Max,Min,Sum,Count,Avg
 # 1.统计每一本书的作者个数
# models后面.什么就按什么分组
res = models.Book.objects.annotate() # 按图书分组

res = models.Book.objects.annotate(author_num=Count('authors')).values('title','author_num')
# author_num是我们自定义的字段名,用来存储每本书对应的作者个数
res = models.Book.objects.annotate(author_num=Count('authors__id')).values('title','author_num')
print(res)
'''
原生SQL语句
SELECT
	title,
	count( app01_book_authors.author_id ) 
FROM
	app01_book
	INNER JOIN app01_book_authors ON app01_book.id = app01_book_authors.book_id 
GROUP BY
	title
'''

# 2.统计每个出版社卖的最便宜的书的价格
res = models.Publish.objects.annotate(min_price=Min('book__price')).values('name', 'min_price')
print(res)
'''
原生SQL语句
SELECT 
	NAME,
	min( app01_book.price ) 
FROM
	app01_publish
	INNER JOIN app01_book ON app01_publish.id = app01_book.publish_id 
GROUP BY
	NAME
'''

# 3.统计不止一个作者的图书
'''
拿到题目分步骤走
	1、先对图书进行分组，得到每本书对应的作者数
	2、进一步过滤，得到作者数大于一的图书
'''
res = models.Book.objects.annotate(author_num=Count('authors')).filter(author_num__gt=1).values('title', 'author_num')
print(res)
'''
链式操作：只要orm语句得出的结果还是一个queryset对象，那么就可以无限制的.queryset对象下的方法

原生SQL语句
SELECT
	title,
	COUNT( app01_book_authors.author_id ) AS author_num 
FROM
	app01_book
	INNER JOIN app01_book_authors ON app01_book.id = app01_book_authors.book_id 
GROUP BY
	title 
HAVING
	COUNT( app01_book_authors.author_id )>1
'''


# 4.查询每个作者出的书的总价格
res = models.Author.objects.annotate(sum_price=Sum('book__price')).values('name', 'sum_price')
print(res)
'''
原生SQL语句
SELECT 
	app01_author.NAME,
	SUM( app01_book.price ) 
FROM
	app01_author
	INNER JOIN app01_book_authors ON app01_author.id = app01_book_authors.author_id
	INNER JOIN app01_book ON app01_book_authors.book_id = app01_book.id 
GROUP BY
	app01_author.NAME

按照指定字段进行分组
	models.Book.objects.values('price').annotate()
	如果出现分组报错问题，先看看数据库有没有开严格模式
'''

F与Q查询

• F查询

# 当我们将表中的两个字段的数据进行比较来做筛选条件时可使用F查询
# F查询：能帮助我们直接获取表中某个字段对应的数据
from django.db.models import F
# 1.查询卖出数大于库存数的书籍
res = models.Book.objects.filter(maichu__gt=F('kucun'))
print(res)
# 2.将所有书籍的价格提升500块
models.Book.objects.update(price=F('price')+500)
# 3.将所有书的名称后面加上爆款两个字
# 在操作字符类型的数据的时候 F不能够直接做到字符串的拼接
# 可以通过下面的方式实现字符串拼接
from django.db.models.functions import Concat
from django.db.models import Value
models.Book.objects.update(title=Concat(F('title'), Value('爆款')))
# 如果直接拼接就会报错
models.Book.objects.update(title=F('title')+'爆款')
# django.db.utils.InternalError: (1292, "Truncated incorrect DOUBLE value: '爆款'")

• Q查询

# 默认filter()内参数与参数之间通过逗号分隔，是and关系
# Q查询：能够改变filter()中参数与参数之间的关系
#	, and关系   | or关系   ~ not关系
# , and关系
res = models.Book.objects.filter(Q(maichu__gt=100),Q(price__lt=600))
# | or关系
res = models.Book.objects.filter(Q(maichu__gt=100)|Q(price__lt=600))
# ~ not关系
res = models.Book.objects.filter(~Q(maichu__gt=100)|Q(price__lt=600))

# Q的高阶用法  能够将查询条件的左边也变成字符串形式
q=Q()
q.connector='or' # 指定关系模式，默认是and关系
q.children.append(('maichu_gt', 100))
q.children.append(('price_lt', 100))
res = models.Book.objects.filter(q) # filter支持直接传q对象
print(res)

django中如何开启事务

'''
事务的四大特性（ACID）：
	A 原子性：不可分割的最小单位、要么全部成功要么全部失败回滚
	C 一致行：与原子性相辅相成、一个事务在执行前后必须处于一致
	I 隔离性：一个事务的执行不会受到其他事务的干扰
	D 持久性：一个事务一旦被提交，就永久有效
'''
# 暂时只需掌握Django中如何开启事务
# mysql中通过start transaction开启事务
# django中通过导入transaction模块开启事务
    from django.db import transaction
    try: #可以对事务捕获异常，当事务出错时进行另外的处理
        with transaction.atomic():
            # sql1
            # sql2
            ...
            # 在with代码快内书写的所有orm操作都是属于同一个事务
    except Exception as e:
        print(e)
    print('执行其他操作')

orm中常用字段及参数

AutoField	# orm会自动帮我们建一个名为id的主键字段
	主键字段 primary_key=True
  
CharField				varchar
	verbose_name	字段的注释
  	max_length		长度
  
IntegerField			int
BigIntegerField			bigint

DecimalField
	max_digits=8
  	decimal_places=2

EmailFiled				varchar(254)

DateField				date
DateTimeField			datetime
	auto_now:每次修改数据的时候都会自动更新当前时间
  	auto_now_add:只在创建数据的时候记录创建时间后续不会自动修改了
    
BooleanField(Field)				- 布尔值类型
	该字段传布尔值(False/True) 	数据库里面存0/1

TextField(Field)					- 文本类型
	该字段可以用来存大段内容(文章、博客...)  没有字数限制


FileField(Field)					- 字符类型
   upload_to = "/data"
  给该字段传一个文件对象，会自动将文件保存到/data目录下然后将文件路径保存到数据库中
  /data/a.txt

# 更多字段
直接参考博客:https://www.cnblogs.com/Dominic-Ji/p/9203990.html
        
# 自定义字段
class MyCharField(models.Field):
    def __init__(self, max_length, *args, **kwargs):
        self.max_length = max_length
        # 调用父类Field下的__init__方法
        super().__init__(max_length=max_length, *args, **kwargs) # 必须以关键字的形式传入
    def db_type(self, connection):
        # 返回真正的数据类型及其他约束条件
        return 'char(%s)'%self.max_length
# 使用
myfield = MyCharField(max_length=23, null=True)

# 外键字段及参数
unique=True
	ForeignKey(unique=True)   ===			OneToOneField()
  # 你在用前面字段创建一对一 orm会有一个提示信息 orm推荐你使用后者但是前者也能用
  
db_index
	如果db_index=True 则代表着为此字段设置索引
  '''
  索引：就像书的目录，方便快速找到索引对应的数据
  '''
to_field
	设置要关联的表的字段  默认不写关联的就是另外一张的主键字段

on_delete
	当删除关联表中的数据时，当前表与其关联的行的行为。
  """
  django2.X及以上版本 需要你自己指定外键字段的级联更新级联删除
  """

数据库查询优化

• only与defer

"""
orm语句的特点:
	惰性查询：只有当后面用到了orm语句所查询出的参数时才会执行，否则orm就会自动识别不执行
"""
# res = models.Book.objects.all()
# print(res)  # 要用数据了才会走数据库查询

# 想要获取书籍表中所有书的名字
res = models.Book.objects.values('title')
for d in res:
    print(d.get('title'))

# only与defer
res = models.Book.objects.only('title')
res = models.Book.objects.all() # all已经包含了所有的数据，因此直接点字段就不会走数据库
res = models.Book.objects.defer('title') # 与only的效果刚好相反
for d in res:
	print(d.title) 
    	# 点only括号内的字段不会走数据库
        # 点defer括号内的字段会重新走数据库查询
     print(d.price) 
    	# 点only括号外的字段，会重新走数据库查询
        # 点defer括号外的字段，不会走数据库
'''
总结：
	only括号外的字段不在查询出的对象里，查询该字段会重新走数据库
	only括号内的字段就无需走数据库了
defer与only相反
	defer括号内的字段不在查询出的对象里，查询该字段会重新走数据库
	defer括号外的字段无需走数据库
'''

• select_related与prefetch_related

# select_related与prefetch_related 都与跨表操作有关
# select_related
res = models.Book.objects.all()	# 每循环一次就要走一次数据库查询
res = models.Book.objects.select_related('publish') # INNER JOIN 是联表操作
res = models.Book.objects.prefetch_related('publish') # IN 子查询
for i in res:	
    print(i.publish.name)
    
'''
总结：
select_related内部就是连表操作，一次性将大表里的所有数据全部封装给查询出来的对象
select_related(外键字段1__外键字段2__外键字段3)
此时无论是点book表的字段还是点publish表的字段都无需再走数据库查询了
注意：select_related括号内只能放外键字段且只能是一对多、一对一的表间关系，
	如果是多对多就会报错
	
prefetch_related内部就是子查询，会将查询出来的所有结果也给你封装到对象中
select_related与prefetch_related给用户的感觉是没有什么差距的，
但是这两个方法各有优缺点，必须结合实际情况来考虑用谁
'''

choices参数(数据库字段设计常见)

'''针对某个可以列举完全的可能性字段，
只要某个字段的可能性是可以列举完全，那么不出意外就用choices参数'''
class User(models.Model):
    username = models.CharField(max_length=32)
    age = models.IntegerField()
    # 性别
    gender_choices = (
        (1,'男'),
        (2,'女'),
        (3,'其他'),
    )
    gender = models.IntegerField(choices=gender_choices)
    # 成绩
    score_choices = (
        ('A','优秀'),
        ('B','良好'),
        ('C','及格'),
        ('D','不合格'),
    )
    # 保证字段类型跟列举出来的元祖第一个数据类型一致即可
    score = models.CharField(choices=score_choices,null=True)
    """
    该gender字段存的还是数字 但是如果存的数字在上面元祖列举的范围之内
    那么可以非常轻松的获取到数字对应的真正的内容
    
    1.gender字段存的数字不在上述元祖列举的范围内容
    2.如果在 如何获取对应的中文信息
    """
    
# choices使用：通过get_字段名_display()得形式来获取对应信息，
#			如果没有对应关系，那么字段里是什么就输出什么
from app01 import models
# choices在存的时候没有列举出来的数字也能够存入
# models.Test_User.objects.create(username='yumi', age=18, gender=1)
# models.Test_User.objects.create(username='rem', age=17, gender=0)
# models.Test_User.objects.create(username='egon', age=18, gender=2)
# choices在取得时候，通过get_gender_display()来获取对应信息，如果是没有对应关系，那么字段是什么就输出什么
obj = models.Test_User.objects.filter(pk=1).first()
print(obj.get_gender_display())

# 实际项目案例
# CRM相关内部表
class School(models.Model):
    """
    校区表
    如：
        北京沙河校区
        上海校区
    """
    title = models.CharField(verbose_name='校区名称', max_length=32)

    def __str__(self):
        return self.title

class Course(models.Model):
    """
    课程表
    如：
        Linux基础
        Linux架构师
        Python自动化开发精英班
        Python自动化开发架构师班
        Python基础班
        go基础班
    """
    name = models.CharField(verbose_name='课程名称', max_length=32)

    def __str__(self):
        return self.name

class Department(models.Model):
    """
    部门表
    市场部     1000
    销售       1001

    """
    title = models.CharField(verbose_name='部门名称', max_length=16)
    code = models.IntegerField(verbose_name='部门编号', unique=True, null=False)

    def __str__(self):
        return self.title

class UserInfo(models.Model):
    """
    员工表
    """

    name = models.CharField(verbose_name='员工姓名', max_length=16)
    email = models.EmailField(verbose_name='邮箱', max_length=64)
    depart = models.ForeignKey(verbose_name='部门', to="Department",to_field="code")
    user=models.OneToOneField("User",default=1)
    def __str__(self):
        return self.name

class ClassList(models.Model):
    """
    班级表
    如：
        Python全栈  面授班  5期  10000  2017-11-11  2018-5-11
    """
    school = models.ForeignKey(verbose_name='校区', to='School')
    course = models.ForeignKey(verbose_name='课程名称', to='Course')
    semester = models.IntegerField(verbose_name="班级(期)")


    price = models.IntegerField(verbose_name="学费")
    start_date = models.DateField(verbose_name="开班日期")
    graduate_date = models.DateField(verbose_name="结业日期", null=True, blank=True)
    memo = models.CharField(verbose_name='说明', max_length=256, blank=True, null=True, )

    teachers = models.ManyToManyField(verbose_name='任课老师', to='UserInfo',limit_choices_to={'depart':1002})
    tutor = models.ForeignKey(verbose_name='班主任', to='UserInfo',related_name="class_list",limit_choices_to={'depart':1006})


    def __str__(self):
        return "{0}({1}期)".format(self.course.name, self.semester)


class Customer(models.Model):
    """
    客户表
    """
    qq = models.CharField(verbose_name='qq', max_length=64, unique=True, help_text='QQ号必须唯一')

    name = models.CharField(verbose_name='学生姓名', max_length=16)
    gender_choices = ((1, '男'), (2, '女'))
    gender = models.SmallIntegerField(verbose_name='性别', choices=gender_choices)

    education_choices = (
        (1, '重点大学'),
        (2, '普通本科'),
        (3, '独立院校'),
        (4, '民办本科'),
        (5, '大专'),
        (6, '民办专科'),
        (7, '高中'),
        (8, '其他')
    )
    education = models.IntegerField(verbose_name='学历', choices=education_choices, blank=True, null=True, )
    graduation_school = models.CharField(verbose_name='毕业学校', max_length=64, blank=True, null=True)
    major = models.CharField(verbose_name='所学专业', max_length=64, blank=True, null=True)

    experience_choices = [
        (1, '在校生'),
        (2, '应届毕业'),
        (3, '半年以内'),
        (4, '半年至一年'),
        (5, '一年至三年'),
        (6, '三年至五年'),
        (7, '五年以上'),
    ]
    experience = models.IntegerField(verbose_name='工作经验', blank=True, null=True, choices=experience_choices)
    work_status_choices = [
        (1, '在职'),
        (2, '无业')
    ]
    work_status = models.IntegerField(verbose_name="职业状态", choices=work_status_choices, default=1, blank=True,
                                      null=True)
    company = models.CharField(verbose_name="目前就职公司", max_length=64, blank=True, null=True)
    salary = models.CharField(verbose_name="当前薪资", max_length=64, blank=True, null=True)

    source_choices = [
        (1, "qq群"),
        (2, "内部转介绍"),
        (3, "官方网站"),
        (4, "百度推广"),
        (5, "360推广"),
        (6, "搜狗推广"),
        (7, "腾讯课堂"),
        (8, "广点通"),
        (9, "高校宣讲"),
        (10, "渠道代理"),
        (11, "51cto"),
        (12, "智汇推"),
        (13, "网盟"),
        (14, "DSP"),
        (15, "SEO"),
        (16, "其它"),
    ]
    source = models.SmallIntegerField('客户来源', choices=source_choices, default=1)
    referral_from = models.ForeignKey(
        'self',
        blank=True,
        null=True,
        verbose_name="转介绍自学员",
        help_text="若此客户是转介绍自内部学员,请在此处选择内部学员姓名",
        related_name="internal_referral"
    )
    course = models.ManyToManyField(verbose_name="咨询课程", to="Course")

    status_choices = [
        (1, "已报名"),
        (2, "未报名")
    ]
    status = models.IntegerField(
        verbose_name="状态",
        choices=status_choices,
        default=2,
        help_text=u"选择客户此时的状态"
    )

    consultant = models.ForeignKey(verbose_name="课程顾问", to='UserInfo', related_name='consultanter',limit_choices_to={'depart':1001})

    date = models.DateField(verbose_name="咨询日期", auto_now_add=True)
    recv_date = models.DateField(verbose_name="当前课程顾问的接单日期", null=True)
    last_consult_date = models.DateField(verbose_name="最后跟进日期", )

    def __str__(self):
        return self.name

class ConsultRecord(models.Model):
    """
    客户跟进记录
    """
    customer = models.ForeignKey(verbose_name="所咨询客户", to='Customer')
    consultant = models.ForeignKey(verbose_name="跟踪人", to='UserInfo',limit_choices_to={'depart':1001})
    date = models.DateField(verbose_name="跟进日期", auto_now_add=True)
    note = models.TextField(verbose_name="跟进内容...")

    def __str__(self):
        return self.customer.name + ":" + self.consultant.name

class Student(models.Model):
    """
    学生表（已报名）
    """
    customer = models.OneToOneField(verbose_name='客户信息', to='Customer')
    class_list = models.ManyToManyField(verbose_name="已报班级", to='ClassList', blank=True)

    emergency_contract = models.CharField(max_length=32, blank=True, null=True, verbose_name='紧急联系人')
    company = models.CharField(verbose_name='公司', max_length=128, blank=True, null=True)
    location = models.CharField(max_length=64, verbose_name='所在区域', blank=True, null=True)
    position = models.CharField(verbose_name='岗位', max_length=64, blank=True, null=True)
    salary = models.IntegerField(verbose_name='薪资', blank=True, null=True)
    welfare = models.CharField(verbose_name='福利', max_length=256, blank=True, null=True)
    date = models.DateField(verbose_name='入职时间', help_text='格式yyyy-mm-dd', blank=True, null=True)
    memo = models.CharField(verbose_name='备注', max_length=256, blank=True, null=True)

    def __str__(self):
        return self.customer.name

class ClassStudyRecord(models.Model):
    """
    上课记录表 （班级记录）
    """
    class_obj = models.ForeignKey(verbose_name="班级", to="ClassList")
    day_num = models.IntegerField(verbose_name="节次", help_text=u"此处填写第几节课或第几天课程...,必须为数字")
    teacher = models.ForeignKey(verbose_name="讲师", to='UserInfo',limit_choices_to={'depart':1002})
    date = models.DateField(verbose_name="上课日期", auto_now_add=True)

    course_title = models.CharField(verbose_name='本节课程标题', max_length=64, blank=True, null=True)
    course_memo = models.TextField(verbose_name='本节课程内容概要', blank=True, null=True)
    has_homework = models.BooleanField(default=True, verbose_name="本节有作业")
    homework_title = models.CharField(verbose_name='本节作业标题', max_length=64, blank=True, null=True)
    homework_memo = models.TextField(verbose_name='作业描述', max_length=500, blank=True, null=True)
    exam = models.TextField(verbose_name='踩分点', max_length=300, blank=True, null=True)

    def __str__(self):
        return "{0} day{1}".format(self.class_obj, self.day_num)

class StudentStudyRecord(models.Model):
    '''
    学生学习记录
    '''
    classstudyrecord = models.ForeignKey(verbose_name="第几天课程", to="ClassStudyRecord")
    student = models.ForeignKey(verbose_name="学员", to='Student')
    record_choices = (('checked', "已签到"),
                      ('vacate', "请假"),
                      ('late', "迟到"),
                      ('noshow', "缺勤"),
                      ('leave_early', "早退"),
                      )
    record = models.CharField("上课纪录", choices=record_choices, default="checked", max_length=64)
    score_choices = ((100, 'A+'),
                     (90, 'A'),
                     (85, 'B+'),
                     (80, 'B'),
                     (70, 'B-'),
                     (60, 'C+'),
                     (50, 'C'),
                     (40, 'C-'),
                     (0, ' D'),
                     (-1, 'N/A'),
                     (-100, 'COPY'),
                     (-1000, 'FAIL'),
                     )
    score = models.IntegerField("本节成绩", choices=score_choices, default=-1)
    homework_note = models.CharField(verbose_name='作业评语', max_length=255, blank=True, null=True)
    note = models.CharField(verbose_name="备注", max_length=255, blank=True, null=True)

    homework = models.FileField(verbose_name='作业文件', blank=True, null=True, default=None)
    stu_memo = models.TextField(verbose_name='学员备注', blank=True, null=True)
    date = models.DateTimeField(verbose_name='提交作业日期', auto_now_add=True)

    def __str__(self):
        return "{0}-{1}".format(self.classstudyrecord, self.student)
         
"""
chocies参数使用场景是非常广泛的
"""

MTV与MVC模型

# MTV:Django号称是MTV模型
M:models
T:templates
V:views
# MVC:其实django本质也是MVC
M:models
V:views
C:controller
  
# vue框架:MVVM模型

多对多关系的三种创建方式

# 全自动：利用orm自动帮我们创建第三张关系表
class Student(models.Model):
    stu_name = models.CharField(max_length=30)
    course = models.ManyToManyField('Course')

class Course(models.Model):
    cname = models.CharField(max_length=30)


# 纯手动
class Student(models.Model):
    stu_name = models.CharField(max_length=30)
    course = models.ManyToManyField('Course')

class Course(models.Model):
    cname = models.CharField(max_length=30)
    
class Student2Course(models.Model):
    stu_id = models.ForeignKey(to='Student')
    cid = models.ForeignKey(to='Course')
    
    
# 半自动
class Student(models.Model):
    stu_name = models.CharField(max_length=30)
    course = models.ManyToManyField('Course',
                                    through='Student2Course',
                                    through_fields=('stu', 'course'))
    
class Course(models.Model):
    cname = models.CharField(max_length=30)
    
class Student2Course(models.Model):
    # 关联字段
    stu = models.ForeignKey(to='Student')
    course = models.ForeignKey(to='Course')
    
    
'''
全自动
	优点：代码书写便捷，orm都帮我写好了，并且还给我们提供了操作第三张表得方法
	缺点：可扩展性太差，无发对第三张关系表添加字段

纯手动（不建议使用）
	优点：由于所有的外键都是自己写，可扩展性加强了
	缺点：无法使用orm所提供的简单方法了
		(正反向查询、双下划线查询、set、add、remove、claear)

半自动（推荐使用、留后路）
	优点：可以使用orm提供的正反向查询，也增强了可扩展性
	缺点：但是orm提供的set、add、remove、claear这四个方法无法使用
	through参数后面跟自己建的第三张关系表
	through_fields参数后面跟元组
		元组内字段的先后顺序判断：
            本质：通过第三张表查询对应的表，需要哪个字段就把哪个字段放在前面
            大白话：当前表是谁 就把对应的关联字段放前面
'''