Python学习---Model拾遗[2]180318

Model的字段及字段参数：

Model字段：

数字
        字符串（带正则的字段）
        时间
        文件
       特殊字段：(一对一，一对多，多对多)

Models.py

class UserProfile(models.Model):
pwd = models.CharField(max_length=32)
email = models.EmailField() # 有Email验证功能，但是在model里未使用【ModelForm有用到】
timeStack = models.DateTimeField() # 时间模块
binary = models.BinaryField() # 二进制模块
file = models.FileField(upload_to='upload') # 页面生成input框，数据库内存储字符串，ModelForm里存储文件
# 页面生成input框，且上传图片会获取到文件大小并赋值给w和h
# 这里是利用Pillow模块实现，如未安装Pillow,使用ImageField会报错
w = models.IntegerField() # 获取Img的大小赋值给w
h = models.IntegerField() # 获取Img的大小赋值给h
img = models.ImageField(upload_to='img',width_field='w', height_field='h')# 注意w和h添加引号的

Model字段参数

Model参数： 用于指定数据库列的信息(eg.列名别名，是否添加索引等)

用于验证(admin, ModelForm)

关系(一对一，一对多，多对多)

null 数据库中字段是否可以为空
db_column 数据库中字段的列名
default 数据库中字段的默认值
primary_key 数据库中字段是否为主键
db_index 数据库中字段是否可以建立索引
unique 数据库中字段是否可以建立唯一索引
unique_for_date 数据库中字段【日期】部分是否可以建立唯一索引
unique_for_month 数据库中字段【月】部分是否可以建立唯一索引
unique_for_year 数据库中字段【年】部分是否可以建立唯一索引 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': '格式错误'} validators 自定义错误验证（列表类型），从而定制想要的验证规则

简单的使用：

from django.core.validators import RegexValidator
from django.core.validators import EmailValidator,
from django.core.validators import URLValidator,MinLengthValidator
from django.core.validators import DecimalValidator,
from django.core.validators import MaxLengthValidator,
from django.core.validators import MaxValueValidator,MinValueValidator
如：
test = models.CharField(
max_length=32,
error_messages={
'c1': '优先错信息1',
'c2': '优先错信息2',
'c3': '优先错信息3',
},
validators=[
RegexValidator(regex='root_\d+', message='错误了', code='c1'),
RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
EmailValidator(message='又错误了', code='c3'), ]
)

这里重点介绍Model中validators和error_message的用法：

models.py

from django.core.validators import RegexValidator
from django.core.validators import EmailValidator, URLValidator, DecimalValidator
from django.core.validators import MaxValueValidator, MinValueValidator
from django.core.validators import MaxLengthValidator, MinLengthValidator
class Regex(models.Model):
name = models.CharField(max_length=32, error_messages={'required':'Model里设置的错误信息error_message'},)
title = models.CharField(max_length=32, error_messages={'c1': '自定义关键字报错'},
validators=[
RegexValidator(regex='root_\d+', message='错误了', code='c1'),
RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
EmailValidator(message='Email错误了,未用到', code='c3'), ]
)

注意：
1.ModelForm里面定义Form的优先级高于Model
2.Model中title的error_message里面的自定义的代码是c1,页面显示的也是C1里面定义的内容，所以error_message比Validators的级别高。
3.如果想定义中文显示，只能去DjangoAdmin里面修改ModelForm了

admin.py

from django.contrib import admin
from app01 import models
admin.site.register(models.Regex)

页面显示：

初始化数据库

python manage.py makemigrations
python manage.py migrate

多表关系以及参数

外键：

ForeignKey(ForeignObject) # ForeignObject(RelatedField)
to, # 要进行关联的表名
to_field=None, # 要关联的表中的字段名称
on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为
- models.CASCADE，删除关联数据，与之关联也删除
- 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】 如： 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')
db_constraint=True # 是否在数据库中创建外键约束
parent_link=False # 在Admin中是否显示关联数据

一对一：

to
to_field
related_name
related_query_name
limti_choices_to = {}
verbose_name
select_related
prefetch_related
on_delete
db_constraint
parent_link： 是否创建父亲页面的显示

多对多：

【更多参考】http://www.cnblogs.com/wupeiqi/articles/6216618.html

Model之ORM操作大总结

基本操作+高级操作

# 增
models.Tb1.objects.create(c1='xx', c2='oo') # 增加一条数据，可以接受字典类型数据 **kwargs
obj = models.Tb1(c1='xx', c2='oo')
obj.save()
# 查
models.Tb1.objects.get(id=123) # 获取单条数据，不存在则报错（不建议）
models.Tb1.objects.all() # 获取全部
models.Tb1.objects.filter(name='seven') # 获取指定条件的数据
models.Tb1.objects.exclude(name='seven') # 获取指定条件的数据
# 删
models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据# 改
# 将指定条件的数据更新，均支持 **kwargs
models.Tb1.objects.filter(name='seven').update(gender='0') # 修改单条数据
obj = models.Tb1.objects.get(id=1)
obj.c1 = '111'
obj.save()
# 获取个数
models.Tb1.objects.filter(name='seven').count()
# 大于，小于
models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值
models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值
models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值
models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值
models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
# in
models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
# isnull
models.Tbl.objects.filter(pub_date__isnull=True) # 获取条件为空
# contains 模糊匹配
models.Tb1.objects.filter(name__contains="ven")
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
models.Tb1.objects.exclude(name__icontains="ven")
# range
models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and
# 其他类似
models.Tb1.objects.startswith()
istartswith, endswith, iendswith,
# order by
models.Tb1.objects.filter(name='seven').order_by('id') # asc
models.Tb1.objects.filter(name='seven').order_by('-id') # desc
# annotate ==》group by
from django.db.models import Count, Min, Max, Sum
# 对Values里面的id进行groupBy,所以values必须放前面
# 前面的filter表示sql里面的where; 如果filter放在后面则表示Having
models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
V = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
# SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id
v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
# SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id', distinct=True)).filter(uid__gt=1)
# SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1# 切片：limit 、offset
models.Tb1.objects.all()[10:20]
# regex正则匹配，iregex 不区分大小写
Entry.objects.get(title__regex=r'^(An?|The) +')
Entry.objects.get(title__iregex=r'^(an?|the) +')
# date
Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
# year
Entry.objects.filter(pub_date__year=2005)
Entry.objects.filter(pub_date__year__gte=2005)
# month
Entry.objects.filter(pub_date__month=12)
Entry.objects.filter(pub_date__month__gte=6)
# day
Entry.objects.filter(pub_date__day=3)
Entry.objects.filter(pub_date__day__gte=3)
# week_day
Entry.objects.filter(pub_date__week_day=2)
Entry.objects.filter(pub_date__week_day__gte=2)
# hour
Event.objects.filter(timestamp__hour=23)
Event.objects.filter(time__hour=5)
Event.objects.filter(timestamp__hour__gte=12)
# minute
Event.objects.filter(timestamp__minute=29)
Event.objects.filter(time__minute=46)
Event.objects.filter(timestamp__minute__gte=29)
# second
Event.objects.filter(timestamp__second=31)
Event.objects.filter(time__second=2)
Event.objects.filter(timestamp__second__gte=31)

高级操作和其他操作：

# F操作
from django.db.models import F
models.Tb1.objects.update(num=F('num')+1)# Q操作
#方式一：
Q(nid__gt=10)
Q(nid=8) | Q(nid__gt=10)
Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
# 方式二：
con = Q()
q1 = Q()
q1.connector = 'OR'
q1.children.append(('id', 1))
q1.children.append(('id', 10))
q1.children.append(('id', 9))
q2 = Q()
q2.connector = 'OR'
q2.children.append(('c1', 1))
q2.children.append(('c1', 10))
q2.children.append(('c1', 9))
con.add(q1, 'AND')
con.add(q2, 'AND')
models.Tb1.objects.filter(con)# extra： 自己写复杂是sql
extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
# select_params和select对应
# where 和 params对应
Tbl.objects.extra(select={'new_id': "1"},)
# select XXX, 1 from Entry; ==> 第二列的数据为1
Tbl.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
# select XXX, (select col from sometable where othercol > 1) as new_id from Entry;
Tbl.objects.extra(where=['headline=%s'], params=['Lennon'])
# select XXX from Entry where headline="Lennon";
Tbl.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) # 双引号内是or条件，逗号是and条件
# select XXX from Entry where (foo='a' or bar='a') and baz='a'; ==>类似于Q的写法
Tbl.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
# select XXX, (select col from sometable where othercol > 1) as new_id from Entry order by nid desc;# 执行原生SQL：适合sql复杂，Django解决不了用
from django.db import connection, connections
cursor = connection.cursor() # cursor = connections['default'].cursor() 可选择操作数据库
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
row = cursor.fetchone()
row = cursor.fetchmany()# 多个数据库的使用：
settings.py 这里定义了2个数据库，2个相同的数据库，可交叉使用，可一个读一个写
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
'default1': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db1.sqlite3'),
}
}
models.Regex.objects.filter(id__lt = 4).using('default1') # 使用default1上面调用原生态sql的时候也可以使用
from django.db import connection, connections
cursor = connections['default1'].cursor() # 使用default1数据库
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
row = cursor.fetchone()
row = cursor.fetchmany()

Model之QuerySet()方法剖析

##################################################################
# PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
##################################################################def all(self)
# 获取所有的数据对象def filter(self, *args, **kwargs)
# 条件查询
# 条件可以是：参数，字典，Qdef exclude(self, *args, **kwargs)
# 条件查询
# 条件可以是：参数，字典，Qdef select_related(self, *fields)
性能相关：表之间进行join连表操作，一次性获取关联的数据。
select_related()仅仅适用于外键字段进行关联，如果有多级的字段关联，多写2个下划线表示
model.tb.objects.all().select_related('外键字段')
model.tb.objects.all().select_related('外键字段__外键字段')
def prefetch_related(self, *lookups)
性能相关：多表连表操作时速度会慢，使用其执行多次SQL查询在Python代码中实现连表操作。
# 获取所有用户表
# 获取用户类型表where id in (用户表中的查到的所有用户ID)
models.UserInfo.objects.all().prefetch_related('外键字段')
# 第一次从数据库内获取符合条件的数据时，会获取到该数据中外键字段【假设有10个数据，其中2个符合要求】，从而在第三张表中查询符合条件的数据【2条数据】放入内存中，下次obj.user_type_cap获取内容的时候就会从内存中获取了，减少了数据库的操作。
from django.db.models import Count, Case, When, IntegerField
Article.objects.annotate(
numviews=Count(Case(
When(readership__what_time__lt=treshold, then=1),
output_field=CharField(),
))
) students = Student.objects.all().annotate(num_excused_absences=models.Sum(
models.Case(
models.When(absence__type='Excused', then=1),
default=0,
output_field=models.IntegerField()
)))def annotate(self, *args, **kwargs)
# 用于实现聚合group by查询
from django.db.models import Count, Avg, Max, Min, Sum v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
# SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
# SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
#SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1def distinct(self, *field_names)
# 用于distinct去重
models.UserInfo.objects.values('nid').distinct()
# select distinct nid from userinfo
注：只有在PostgreSQL中才能使用distinct进行去重def order_by(self, *field_names)
# 用于排序
models.UserInfo.objects.all().order_by('-id','age')def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
# 构造额外的查询条件或者映射，如：子查询 Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) def reverse(self):
# 倒序
models.UserInfo.objects.all().order_by('-nid').reverse()
# 注：如果存在order_by，reverse则是倒序，如果多个排序则一一倒序
这个reserve会检查是否有order_by,有则倒叙，无责不操作。 all().reserver() 无效果
def defer(self, *fields):
models.UserInfo.objects.defer('username','id')
或
models.UserInfo.objects.filter(...).defer('username','id')
#映射中排除某列数据 def only(self, *fields):
#仅取某个表中的数据
models.UserInfo.objects.only('username','id')
或
models.UserInfo.objects.filter(...).only('username','id') def using(self, alias):
指定使用的数据库，参数为别名（setting中的设置）##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
##################################################def raw(self, raw_query, params=None, translations=None, using=None):
# 执行原生SQL, 此时将数据库内查询的列对应到model里面的字段
models.UserInfo.objects.raw('select * from userinfo') # 如果SQL是其他表时，必须查询对象主键，且将名字设置为当前UserInfo对象的主键列名
user是userinfo的字段，caption是userType的字段
models.UserInfo.objects.raw('select id，caption as user from ’其他表') # 为原生SQL设置参数
models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,]) # 将获取的到列名转换为指定列名
name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
Person.objects.raw('SELECT * FROM some_other_table', translations=name_map) # 指定数据库
models.UserInfo.objects.raw('select * from userinfo', using="default") ################### 原生SQL ###################
from django.db import connection, connections
cursor = connection.cursor() # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
row = cursor.fetchone() # fetchall()/fetchmany(..)def values(self, *fields):
# 获取每行数据为字典格式def values_list(self, *fields, **kwargs):
# 获取每行数据为元祖def dates(self, field_name, kind, order='ASC'):
# 根据时间进行某一部分进行去重查找并截取指定内容
# kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
# order只能是："ASC" "DESC"
# 并获取转换后的时间
- year : 年-01-01 如果获取的是year关键字，则Django返回我们年 - month: 年-月-01 如果获取的是month关键字，则Django返回我们年月
- day : 年-月-日 ，如果获取的是day关键字，则Django返回我们年月日 models.DatePlus.objects.dates('ctime','day','DESC')def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
# 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
# kind只能是 "year", "month", "day", "hour", "minute", "second"
# order只能是："ASC" "DESC"
# tzinfo时区对象
models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai')) """
Datetimes模块需要Python安装如下的模块：
pip3 install pytz
import pytz
pytz.all_timezones
pytz.timezone(‘Asia/Shanghai’)
"""
def none(self):
# 空QuerySet对象####################################
# METHODS THAT DO DATABASE QUERIES #
####################################def aggregate(self, *args, **kwargs):
# 聚合函数，获取字典类型聚合结果，且只拿一条数据
from django.db.models import Count, Avg, Max, Min, Sum
result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
===> {'k': 3, 'n': 4} # 获取nid的数量，且可以有去重操作def count(self):
# 获取个数def get(self, *args, **kwargs):
# 获取单个对象def create(self, **kwargs):
# 创建对象def bulk_create(self, objs, batch_size=None):
# 批量插入
# batch_size表示一次插入的个数
objs = [
models.DDD(name='r11'),
models.DDD(name='r22')
]
models.DDD.objects.bulk_create(objs, 10) # 这里一条sql创建10次，objs内有2条，共20条def get_or_create(self, defaults=None, **kwargs):
# 如果存在，则获取，否则，创建
# 根据username进行查询【支持多个条件查询】，没有则根据查找的值 + defaults创建其他字段 obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2})
obj, created = models.UserInfo.objects.get_or_create(username='root1', pwd=’123456’,defaults={'email': '1111111','u_id': 2, 't_id': 2})
# 根据username&&pwd来查询对象，没有则根据usename,pwd 和default创建这个值
# obj永远表示获取的对象，有则直接获取，无责创建后获取
# created则表示是否创建了对象，只有true和false共2个值
# create仅仅能创建一个值def update_or_create(self, defaults=None, **kwargs):
# 如果存在，则更新，否则，创建
# defaults 指定创建时或更新时的其他字段
obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1})def first(self):
# 获取第一个def last(self):
# 获取最后一个def in_bulk(self, id_list=None):
# 根据主键ID进行查找
id_list = [11,21,31] # 等价于 model.objects.filter(id__in=[11,21,31])
models.DDD.objects.in_bulk(id_list)def delete(self):
# 删除def update(self, **kwargs):
# 更新def exists(self):
# 是否有结果

获取对象的指定列： values(),values_lis()获取的都是列表非对象

获取全部对象的全部列：all()，filter()获取的都是全部对象的全部列

defer()内写那一列就不获取该列的数据。但是任然可以使用defer()内的字段，因为你用的时候Django会自动发送一个sql请求去查找了。所以一个原则是：不需要谁就写谁，且拿到的是对象请求

only():表示只获取某几个字段，拿过来以后任然是对象类型

原生态的sql执行：
extra()方法
raw()方法
Connections()

Model之model错误信息操作

Model对象调用full_clean()方法后，full_clean()会自动去掉用Model函数中覆写的clean()方法执行我们创建内容的正确性。

注意：

1.对比Form，这个里面没有clean_字段名(),这个方法，因为Form是用户发送过来的请求

Model里面是我们自己创建的内容

2.full_clean()方法因为无法自动捕获异常，所以需要我们调用的时候，手动去捕获异常

models.py

from django.db import models
class U(models.Model):
id = models.AutoField(primary_key=True) # AutoField必须是主键，才能自定义该列
name = models.CharField(max_length=32)
email = models.CharField(max_length=32) # 自定义方法进行内容验证,能抛出异常【obj.full_clean()方法内调用clean()】
def clean(self):
if(self.name == 'root1002'):
print("这里是Model里面自定义的内容验证...")

views.py

from app01 import models
from django.shortcuts import render, HttpResponse
from django.forms import fields
from django.forms import63+ formsdef test(request):
# 这里的name=root1002会在Models.py中U的类中进行校验
obj = models.U(name='root1002', email='hhh@live.com')
try:
obj.full_clean()
except Exception as e:
print(e)
obj.save()

Model内部的full_clean()