一、创建model
django.db.models是django自带的创建数据库的ORM。
在models.py中以继承models.Model创建表后，需要在setttngs中确保添加了当前应用，并执行
python3 manage.py makemigrations app[应用名称]
python3 manage.py migrate app[应用名称]
来生成迁移文件并提交到数据库执行建表操作。
一、创建单张表
# models.py from django.db import models
class Person(models.Model): name = models.CharField(max_length=30) age = models.CharField(max_length=30)
from app02.models import Person p1 = Person(name="Jan", age=20) # 声明一个实例，也就是一条记录 p1.save() # 必须保存 p2 = Person() p2.name = "Li" p2.age = 18 # 可以声明一个实例，也可以修改一个字段，同样需要提交 p2.save()
二、创建一对一表
当一张既有的表需要扩充字段时，为了保持原有的表字段和结构不变，可以创建另一张表存储扩充的字段；第二张表的主键和第一张表的主键一一对应。
# models.py from django.db import models class Place(models.Model): name = models.CharField(max_length=50) address = models.CharField(max_length=80)
class Restaurant(models.Model): place = models.OneToOneField(Place,on_delete=models.CASCADE,primary_key=True) serves_hot_dogs = models.BooleanField(default=False) serves_pizza = models.BooleanField(default=False)
>>> p1 = Place(name='Demon Dogs', address='944 W. Fullerton') >>> p1.save() >>> p2 = Place(name='Ace Hardware', address='1013 N. Ashland') >>> p2.save()
>>> r1 = Restaurant(place=p1, serves_hot_dogs=True, serves_pizza=False) # 插入记录时，如果需要同时插入扩充的字段，就在后面继续添加扩充表 >>> r1.save()
>>> p1.restaurant
>>> r2.place
>>> hasattr(p2, 'restaurant') # 可以用hasattr检查是否已插入扩充字段
三、创建多对一表
# models.py from django.db import models class Reporter(models.Model): first_name = models.CharField(max_length=30) last_name = models.CharField(max_length=30) email = models.EmailField() class Article(models.Model): headline = models.CharField(max_length=100) pub_date = models.DateField() reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)
>>> r1 = Reporter(first_name='John', last_name='Smith', email='john@example.com') >>> r1.save() # 一定要save，否则下面的Article外键无法绑定需要的reporter字段 >>> r2 = Reporter(first_name='Paul', last_name='Jones', email='paul@example.com') >>> r2.save() >>> from datetime import date >>> a1 = Article(id=None, headline="This is a test", pub_date=date(2005, 7, 27), reporter=r1) # 正向添加-添加记录时需要指定reporter >>> a1.save()
>>> a2 = Article.objects.create(headline="Paul's story", pub_date=date(2006, 1, 17), reporter=r2) # 正向添加-用管理器的方式添加，不需要save()
>>> r2.article_set.create(headline="John's second story", pub_date=date(2005, 7, 29)) # 反向添加-注意r2.article_set的方式
>>> r3 = Reporter(first_name="Jan", last_name="--", email="jan@example.com")
>>> r3.save()
>>> r3.article_set.add(a2) # 反向添加一个对象
>>> r3.artilce_set.remove(a2) # 反向删除
add()和remove()是django默认的用于处理一对多或者多对多的增删操作。对于ForeignKey，只有“一”的那张表可以使用add和remove来一次性添加一个或者多个“多”的记录。对于ManyToManyField，两张表都可以使用add和remove添加或者删除一个或者多个记录。
四、创建多对多表
# models.py from django.db import models class Publication(models.Model): title = models.CharField(max_length=30) def __str__(self): return self.title class Meta: ordering = ('title',) class Article(models.Model): headline = models.CharField(max_length=100) publications = models.ManyToManyField(Publication) def __str__(self): return self.headline class Meta: ordering = ('headline',)
>>> p1 = Publication(title='The Python Journal') >>> p1.save() >>> p2 = Publication(title='Science News') >>> p2.save() >>> p3 = Publication(title='Science Weekly') >>> p3.save()
>>> a1 = Article(headline='Django lets you build Web apps easily')
>>> a1.save()
>>> a1.publications.add(p1,p2,p3) # 直接用add添加一个或多个记录
>>> a2 = Article(headline='NASA uses Python') >>> a2.save()
>>> new_publication = a2.publications.create(title='Highlights for Children') # 或者直接用管理器(models.objects.create)创建一条记录并添加进去
>>> p2.article_set.all() # 可以通过article_set访问
>>> a4 = Article(headline='NASA finds intelligent life on Earth') # 反向添加记录：可以先写好记录，再添加给另一张表 >>> a4.save() >>> p2.article_set.add(a4)
>>> new_article = p2.article_set.create(headline='Oxygen-free diet works wonders') # 或者也用管理器的方式添加
二、Field和字段
| 名称 | 解释 |
| AutoField | 一个根据实际ID自动增长的IntegerField，通常不指定；如果不指定，一个主键字段将自动添加到模型中 |
| BooleanField | true/false 字段，此字段的默认表单控制是CheckboxInput |
| NullBooleanField | 支持null、true、false三种值 |
| CharField(max_length=字符长度) | 字符串，默认的表单样式是 TextInput |
| TextField | 大文本字段，一般超过4000使用，默认的表单控件是Textarea |
| IntegerField | 整数 |
| DecimalField(max_digits=None, decimal_places=None) | 使用python的Decimal实例表示的十进制浮点数；DecimalField.max_digits=位数总数，DecimalField.decimal_places=小数点后的数字位数 |
| FloatField | 用Python的float实例来表示的浮点数 |
| DateField[auto_now=False, auto_now_add=False]) |
使用Python的datetime.date实例表示的日期； 参数DateField.auto_now：每次保存对象时，自动设置该字段为当前时间，用于"最后一次修改"的时间戳，它总是使用当前日期，默认为false； 参数DateField.auto_now_add：当对象第一次被创建时自动设置当前时间，用于创建的时间戳，它总是使用当前日期，默认为false 该字段默认对应的表单控件是一个TextInput. 在管理员站点添加了一个JavaScript写的日历控件，和一个“Today"的快捷按钮，包含了一个额外的invalid_date错误消息键 auto_now_add, auto_now, and default 这些设置是相互排斥的，他们之间的任何组合将会发生错误的结果 |
| TimeField | 使用Python的datetime.time实例表示的时间，参数同DateField |
| DateTimeField | 使用Python的datetime.datetime实例表示的日期和时间，参数同DateField |
| FileField | 一个上传文件的字段 |
| ImageField | 继承了FileField的所有属性和方法，但对上传的对象进行校验，确保它是个有效的image |
通过字段选项，可以实现对字段的约束；在字段对象时通过关键字参数指定。
| 名称 | 解释 |
| null | 如果为True，Django 将空值以NULL 存储到数据库中，默认值是 False |
| blank | 如果为True，则该字段允许为空白，默认值是 False；对比：null是数据库范畴的概念，blank是表单验证证范畴的 |
| db_column | 字段的名称，如果未指定，则使用属性的名称 |
| db_index | 若值为 True, 则在表中会为此字段创建索引 |
| default | 默认值 |
| primary_key：若为 True | 则该字段会成为模型的主键字段 |
| unique | 如果为 True, 这个字段在表中必须有唯一值；唯一索引 |
| auto_now | 创建时生成创建时间 |
| auto_now_add | 更新时自动更新当前时间 |
| choices | admin: 默认元组列表，user_type=[(1, "普通用户"), (2, "VIP用户"), (3, "超级用户")];modesl.IntegerField(choices=user_type)；在admin中会自动显示这几个分类，但是对表无影响，可以是任意整数 |
| verbose_name | admin: 别名，支持中文 |
| editable | admin: 是否可以被编辑 |
| error_message | admin: 自定义错误信息 |
| help_text | admin: 帮助信息 |
三、自定义管理器
objects是Manager类型的对象，用于与数据库进行交互。当定义模型类时没有指定管理器，则Django会为模型类提供一个名为objects的管理器，当为模型类指定管理器后，django不再为模型类生成名为objects的默认管理器。
管理器是Django的模型进行数据库的查询操作的接口，Django应用的每个模型都拥有至少一个管理器。
自定义管理器类主要用于两种情况：向管理器类中添加额外的方法，或者修改管理器返回的原始查询集：重写get_queryset()方法。
from django.db import models class BookInfoManager(models.Model): """ 可以重写Model中的方法 """ def get_queryset(self): return super(BookInfo, self.get_queryset().filter(isdelete=False)) # 创建BookInfo def create(self, name, pub_date): b = BookInfo() b.name = name b.headline = pub_date b.isdelete = False return b class BookInfo(models.Model): name = models.CharField(max_length=20) headline = models.CharField(default="this's a python book") isdelete = models.BooleanField(default=False) # 自定义管理器被定义时，继承了默认管理器 manager = BookInfoManager() # BookInfo.manager.create(name="Jan")
四、数据库操作
1、多对一操作
1.批量添加
# models.py from django.db import models class Province(models.Model): name = models.CharField(max_length=32) class City(models.Model): name = models.CharField(max_length=32) pro = models.ForeignKey("Province", to_field="id", on_delete=models.CASCADE)
# app01/insert_records.py import os, django # 添加django的环境配置 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "app.settings") django.setup() from app01.models import Province, City city_dict = {"东莞": 2, "深圳": 2, "惠州": 2, "河源": 2, "泰安": 3, "青岛": 3, "济南": 3, "张家口": 1,"邢台": 1} province_dict = {"河北": 1, "山东": 3, "广东": 2,}
province_records_dict = {id: Province(id=id, name=name) for name, id in province_dict.items()} print(province_records_dict) # 先创建Province Province.objects.bulk_create(province_records_dict.values()) # 再创建City city_records_list = [City(pro=province_records_dict[id], name=name) for name, id in city_dict.items()] print(city_records_list) City.objects.bulk_create(city_records_list) print("ok")
2.正向查询与反向查询
# 1.all - 查找全city表中的全部记录，返回所有的querySet City.objects.all() # 正向查询：指定获取的字段，外表需要用外键+双下划线的形式访问外键表中的字段；如果有两个表中的字段，相当于对两个表同时进行操作 City.objects.all().values("id", "name", "pro__id", "pro_name")
# 反向查询：默认会将外键表的模型类小写当做id，相当于city__id，它同样支持表名+双下划线+字段的形式查询
Province.objects.all().values("id", "name", "city", "city__name", "city__id")
# 2.filter - 过滤器
# 正向过滤： 根据某个外键表或者外表中的字段对外表记录进行过滤查询
City.objects.all().filter(pro__name="河北") # 过滤字段
# 反向过滤： 根据某个外键表或者外表中的字段对外键表进行过滤查询
Province.objects.all().filter(name="河北")[0].city_set.all()
3、多对多操作
1.批量添加
# models.py from django.db import models class Book(models.Model): name = models.CharField(max_length=32) class Author(models.Model): name = models.CharField(max_length=32) book = models.ManyToManyField(Book, related_name="book")
import os, django # 添加django的环境配置 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "app.settings") django.setup() from app01.models import * Book.objects.all().delete() Author.objects.all().delete() book_dict = {1: "Python", 2: "Go", 3: "Linux", 4: "PHP"} author_dict = {1: "Jan", 2: "Li", 3: "wise"} together_dict = { "Jan": ["Python", "Go"], "Li": ["Linux", "Go"], "wise": ["PHP", "Go", "Python"] } # 根据以上信息创建ManyToMany # 先创建两个表的记录 book_records_list = {name: Book(id=id, name=name) for id, name in book_dict.items()} Book.objects.bulk_create(book_records_list.values()) author_records_list = {name: Author(id=id, name=name) for id, name in author_dict.items()} Author.objects.bulk_create(author_records_list.values()) # 再根据关系写入数据库 for key, vlist in together_dict.items(): # 获取书名对应的querySet for i in vlist: author_records_list[key].book.add(book_records_list[i])
2、正向查询与反向查询
# 正向查找 Author.objects.get(id=1).book.all() # 反向查找
Book.objects.get(id=1).book.all() # 这里写.book.all()是因为在Author模型类中声明了related_name，默认的话是author_set.all()
Book.objects.get(id=1).book.all().values("id", "name", "book__name")
# 遍历
for item in Author.objects.values("id", "name", "book"):
print(item["id"], item["name"], item["book"])
3、基本查询
1.返回querySet集合的方法
| 名称 | 解释 |
| filter | 过滤器 |
exclude |
排除满足条件的对象 |
| order_by | 查询结果排序 |
| annotate | 分组函数，在分组后的数据集上进行操作 |
| distinct | 去重 |
| values | 将querySet以字典形式返回到一个查询集里 |
| raw | 处理一个原始的sql语句 |
| aggregate | 聚合函数，在每个记录上进行操作 |
2.返回单个对象
| 名称 | 函数 |
| get() | 返回单个满足条件的对象 |
| first() | 返回第一个对象 |
| last() | 返回最后一个对象 |
| exists() | 判断查询集中是否有数据，如果有则返回True |
| count() | 返回当前查询的总条数 |
| select_related() | 返回当前querySet的前一条和后一条数据 |
3.字段查询
实现where子名，作为方法filter()、exclude()、get()的参数。语法：属性名称__比较运算符=值。
1.exact：表示判等，大小写敏感；如果没有写“ 比较运算符”，表示判等filter(isDelete=False)
2.contains：是否包含，大小写敏感
exclude(btitle__contains='传')
3.startswith、endswith：以value开头或结尾，大小写敏感
exclude(btitle__endswith='传')
4.isnull、isnotnull：是否为null
filter(btitle__isnull=False)
5.在前面加个i表示不区分大小写，如iexact、icontains、istarswith、iendswith
6.in：是否包含在范围内
filter(pk__in=[1, 2, 3, 4, 5])
7.gt、gte、lt、lte：大于、大于等于、小于、小于等于
filter(id__gt=3)
8.对year、month、day、week_day、hour、minute、second：对日期间类型的属性进行运算
filter(bpub_date__year=1980) filter(bpub_date__gt=date(1980, 12, 31))
9.查询的快捷方式：pk，pk表示primary key，默认的主键是id
filter(pk__lt=6)
4、跨表查询
多对一或者多对多都可以使用模型类+双下划线+字段名的形式进行跨表操作。
Author.objects.filter(book__name="Go")
Book.objects.filter(book__name="Jan"）
5、聚合函数
使用aggregate()函数返回聚合函数的值，函数包括(Avg，Count，Max，Min，Sum)。
from django.db.models import Max maxDate = list.aggregate(Max('bpub_date'))
6、其它相关
# 1. Cast，用于做类型转换 # v = models.UserInfo.objects.annotate(c=Cast('pwd', FloatField())) # 2. Coalesce，从前向后，查询第一个不为空的值 # v = models.UserInfo.objects.annotate(c=Coalesce('name', 'pwd')) # v = models.UserInfo.objects.annotate(c=Coalesce(Value('666'),'name', 'pwd')) # 3. Concat，拼接 # models.UserInfo.objects.update(name=Concat('name', 'pwd')) # models.UserInfo.objects.update(name=Concat('name', Value('666'))) # models.UserInfo.objects.update(name=Concat('name', Value('666'),Value('999'))) # 4.ConcatPair，拼接（仅两个参数） # v = models.UserInfo.objects.annotate(c=ConcatPair('name', 'pwd')) # v = models.UserInfo.objects.annotate(c=ConcatPair('name', Value('666'))) # 5.Greatest，获取比较大的值;least 获取比较小的值; # v = models.UserInfo.objects.annotate(c=Greatest('id', 'pwd',output_field=FloatField())) # 6.Length，获取长度 # v = models.UserInfo.objects.annotate(c=Length('name')) # 7. Lower,Upper,变大小写 # v = models.UserInfo.objects.annotate(c=Lower('name')) # v = models.UserInfo.objects.annotate(c=Upper('name')) # 8. Now，获取当前时间 # v = models.UserInfo.objects.annotate(c=Now()) # 9. substr，子序列 # v = models.UserInfo.objects.annotate(c=Substr('name',1,2)) # ########### 时间类函数 ########### # 1. 时间截取，不保留其他：Extract, ExtractDay, ExtractHour, ExtractMinute, ExtractMonth,ExtractSecond, ExtractWeekDay, ExtractYear, # v = models.UserInfo.objects.annotate(c=functions.ExtractYear('ctime')) # v = models.UserInfo.objects.annotate(c=functions.ExtractMonth('ctime')) # v = models.UserInfo.objects.annotate(c=functions.ExtractDay('ctime')) # # v = models.UserInfo.objects.annotate(c=functions.Extract('ctime', 'year')) # v = models.UserInfo.objects.annotate(c=functions.Extract('ctime', 'month')) # v = models.UserInfo.objects.annotate(c=functions.Extract('ctime', 'year_month')) """ MICROSECOND SECOND MINUTE HOUR DAY WEEK MONTH QUARTER YEAR SECOND_MICROSECOND MINUTE_MICROSECOND MINUTE_SECOND HOUR_MICROSECOND HOUR_SECOND HOUR_MINUTE DAY_MICROSECOND DAY_SECOND DAY_MINUTE DAY_HOUR YEAR_MONTH """ # 2. 时间截图，保留其他：Trunc, TruncDate, TruncDay,TruncHour, TruncMinute, TruncMonth, TruncSecond, TruncYear # v = models.UserInfo.objects.annotate(c=functions.TruncHour('ctime')) # v = models.UserInfo.objects.annotate(c=functions.TruncDate('ctime')) # v = models.UserInfo.objects.annotate(c=functions.Trunc('ctime','year'))
4、F对象和Q对象
1.F对象
如果需要在等号右侧需要使用当前querySet中的字段，就需要用到F对象。
from django.db.models import F
1.右侧需要用到本表字段，用F对象
Book.objects.all().update(price=F('price') + 20) 2.django支持对F()对象使用算数运算 list.filter(bread__gte=F('bcommet') * 2) 3.F()对象中还可以写作“模型类__列名”进行关联查询 list.filter(isDelete=F('heroinfo__isDelete')) 4.对于date/time字段，可与timedelta()进行运算 list.filter(bpub_date__lt=F('bpub_date') + timedelta(days=1))
2.Q对象
过滤器的方法中关键字参数查询，会合并为And进行；需要进行or查询，使用Q()对象。Q对象(django.db.models.Q)用于封装一组关键字参数，这些关键字参数与“比较运算符”中的相同。
from django.db.models import Q
1.基本操作:
Author.objects.filter(Q(name="Jan")) # 等价于Author.objects.filter(name="Jan")
2.Q对象可以使用&（and）、|（or）操作符组合起来:
Author.objects.filter(Q(name="Jan") | Q(name="Wise")) # 等价于Author.objects.filter(name__in=["Jan", "Wise"])
3.支持联表查询
Author.objects.filter(Q(book__name="Go") & Q(id__lt=2))
3.当操作符应用在两个Q对象时，会产生一个新的Q对象
list.filter(pk_ _lt=6).filter(bcommet_ _gt=10)
list.filter(Q(pk_ _lt=6) | Q(bcommet_ _gt=10))
