Django_ORMday15\16我们学到的ORM都是最基本的增删改查.下面我们稍作升级,学习下高级点的增删改查.先创建一个新的APP项目
1 python3.5 manage.py startapp blog
1.编辑blog/models.py
1 from django.db import models 2 3 # Create your models here. 4 5 class Blog(models.Model): 6 name = models.CharField(max_length=100) 7 tagline = models.TextField() 8 9 def __str__(self): # __unicode__ on Python 2 10 return self.name 11 12 class Author(models.Model): 13 name = models.CharField(max_length=50) 14 email = models.EmailField() 15 16 def __str__(self): # __unicode__ on Python 2 17 return self.name 18 19 class Entry(models.Model): 20 blog = models.ForeignKey(Blog) 21 headline = models.CharField(max_length=255) 22 body_text = models.TextField() 23 pub_date = models.DateField() 24 mod_date = models.DateField() 25 authors = models.ManyToManyField(Author) 26 n_comments = models.IntegerField() 27 n_pingbacks = models.IntegerField() 28 rating = models.IntegerField() 29 30 def __str__(self): # __unicode__ on Python 2 31 return self.headline
2. 在配置文件中添加blog项目,这样blog/models.py文件才可以被引用
1 INSTALLED_APPS = [ 2 ‘django.contrib.admin‘, 3 ‘django.contrib.auth‘, 4 ‘django.contrib.contenttypes‘, 5 ‘django.contrib.sessions‘, 6 ‘django.contrib.messages‘, 7 ‘django.contrib.staticfiles‘, 8 ‘app01‘, 9 ‘blog‘, 10 ]
3. 初始化数据库
1 python3.5 manage.py makemigrations 生成配置文件 2 python3.5 manage.py migrate 初始化数据库
在自己写的脚本里调用Django models
我们直接在pycharm中运行这个脚本文件.发现报错:
% (desc, ENVIRONMENT_VARIABLE)) django.core.exceptions.ImproperlyConfigured: Requested setting DEFAULT_INDEX_TABLESPACE, but settings are not configured. You must either define the environment variable DJANGO_SETTINGS_MODULE or call settings.configure() before accessing settings.
为什么会报错? 说白了,你现在无法调用数据库的东西.如果你想在自己的脚本调用数据库的东西,你需要导入settings.我们之前在做命令行测试的时候,使用python3.5 manger.py shell进入到python命令行模式.因为maneger.py文件在执行时引入了系统环境变量.我们通过查看maneger.py代码可见:
1 #!/usr/bin/env python
2 import os
3 import sys
4
5 if __name__ == "__main__":
6 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day18_site.settings") #这里设置了环境变量,相当于Linux中用户环境变量一样
7 from django.core.management import execute_from_command_line
8 execute_from_command_line(sys.argv)
也就是说我们如果想让自己的脚本也可以调用数据库,就必须把settings.py文件引入到脚本里.
1 #!/usr/bin/evn python3.5 2 # -*- coding:utf-8 -*- 3 # Author:Zhou Ming 4 import os 5 import sys 6 base = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # 这里要加上否则找不到day18_site目录 7 sys.path.append(base) 8 9 os.environ[‘DJANGO_SETTINGS_MODULE‘] = ‘day18_site.settings‘ 10 import django 11 django.setup() 12 from blog import models 13 entry = models.Entry.objects.get(pk=1) 14 print(entry)
完成后,我们在直接运行此脚本程序就不会有报错了.我这里想，我们为什么要自己写orm_test.py文件呢？是因为我们在实际开发中，都是在视图文件views.py中直接写orm代码的，这样当访问进来后调用，但是在正式调用之前，我们是需要在一个.py文件里测试这些orm代码是否符合要求，所以要自己创建一个orm_test.py文件。 接下来看下ORM的一些基本语法创建 普通表的创建
>>> from blog.models import Blog
>>> b = Blog(name=‘Beatles Blog‘, tagline=‘All the latest Beatles news.‘)
>>> b.save()
处理带外键关联或多对多关联的对象 ForeignKey的关联
>>> from blog.models import Entry
>>> entry = Entry.objects.get(pk=1) # 先获取一个记录对象
>>> cheese_blog = Blog.objects.get(name="Cheddar Talk") # 获得一个blog对象实例
>>> entry.blog = cheese_blog #设置外键
#>>> entry.blog_id = cheese_blog.id #或者设置id设置外键,两种设置外键的方式结果是一样的
>>> entry.save() # 改完之后要保存
ManyToManyField关联
>>> from blog.models import Author
>>> joe = Author.objects.create(name="Joe") # 创建一个Author对象
>>> entry.authors.add(joe) # 添加,而不是=,这个是多对多方式
# 添加完成后,不需要进行保存
添加多个ManyToMany对象
>>> john = Author.objects.create(name="John")
>>> paul = Author.objects.create(name="Paul")
>>> george = Author.objects.create(name="George")
>>> ringo = Author.objects.create(name="Ringo")
>>> entry.authors.add(john, paul, george, ringo)
查询的例子:
1 all_entries = Entry.objects.all() #查询所有 2 Entry.objects.filter(pub_date__year=2006) #查询所有pub_date为2006年的纪录 3 Entry.objects.all().filter(pub_date__year=2006) #与上面那句一样,有的同学会以为这条是先查出来在过滤,不是,最终它和上面的那条语句会产生一摸一样的原生sql语句.所以是一样的 4 >>> Entry.objects.filter( #链式查询 5 ... headline__startswith=‘What‘ 6 ... ).exclude( 7 ... pub_date__gte=datetime.date.today #表示大于等于今天的的意思 8 ... ).filter( 9 ... pub_date__gte=datetime(2005, 1, 30) # 然后在取时间大于等于2005/1/30 10 ... ) 11 12 one_entry = Entry.objects.get(pk=1) #单条查询 13 14 Entry.objects.all()[:5] #查询前5条 ,好多同学以为查出所有的记录然后在截取前5条,其实不是的,最终转换的sql语句,就是limit 5 15 Entry.objects.all()[5:10] #你猜 limit5,10 16 17 Entry.objects.order_by(‘headline‘)[0] #按headline排序取第一条 18 19 Entry.objects.filter(pub_date__lte=‘2006-01-01‘) #相当于sql语句SELECT * FROM blog_entry WHERE pub_date <= ‘2006-01-01‘; 20 21 Entry.objects.get(headline__exact="Cat bites dog") #相当于SELECT ... WHERE headline = ‘Cat bites dog‘; 22 Blog.objects.get(name__iexact="beatles blog") #与上面相同,只是大小写不敏感 23 24 Entry.objects.get(headline__contains=‘Lennon‘) #相当 于SELECT ... WHERE headline LIKE ‘%Lennon%‘;
单表内查询语句
1 #This example retrieves all Entry objects with a Blog whose name is ‘Beatles Blog‘: 2 Entry.objects.filter(blog__name=‘Beatles Blog‘) 3 4 Blog.objects.filter(entry__headline__contains=‘Lennon‘) 反过来找 5 6
关联查询
接下来学习一个有点意思的F_expressions 对于同一表中不同字段进行对比查询,我们上面的例子中,我们建立的查询过滤条件或对比条件给到的都是一个常规的值,比如Entry.objects.all().filter(pub_date__year=2006) 2006就是一个常规的值 现在我们有一个需求,拿上面的Entry表举例:Entry表里有两个字段注释数 N comments 和 评论数N pingbacks 我现在想找,所有 N comments <= N pingbacks的记录条目. 我们看这里面的条件过滤就是使用同一个表中的两个字段.我们使用sql原生语句很好实现.但是在Django中的ORM如何实现呢? Django提供一个F()表达式,允许同表的不同字段进行比较.F()是一个实例.具体用法如下:
>>> from django.db.models import F
>>> Entry.objects.filter(n_comments__gt=F(‘n_pingbacks‘))
原生sql语句 :select n_comments,n_pingbacks from Entry where n_comments <= n_pingbacks
不仅可以直接比较,还可以对后面的条件进行运算后在进行比较,如:
>>> Entry.objects.filter(n_comments__gt=F(‘n_pingbacks‘) * 2)
甚至可以多个字段进行运算,2个至多个都行,如下:
>>> Entry.objects.filter(rating__lt=F(‘n_comments‘) + F(‘n_pingbacks‘))
原生sql语句: select n_comments,n_pingbacks,rating from blog_entry where rating > (n_comments + n_pingbacks)
找出在发布后三天后进行修改的条目
>>> from datetime import timedelta
>>> Entry.objects.filter(mod_date__gt=F(‘pub_date‘) + timedelta(days=3))
Caching and QuerySets缓存 和 结果集 为什么把缓存和结果集放到一起说呢? 每一个结果集都会包含一个缓存,来降低对数据库的访问.我们要理解这个,有助于我们写一个搞笑的orm的代码. 在一个刚创建的一个结果集.(什么是刚创建的?)假如我们执行一个orm代码使用filter()获得了的记录会存到QuerySets这个结果集里,紧接着我们要循环这些记录,这个时候我们就不需要去数据库中取了,而是循环结果集. 使用QuerySets 就非常的高效的使你的数据库查询结果提高利用率了.
>>> print([e.headline for e in Entry.objects.all()])
>>> print([e.pub_date for e in Entry.objects.all()])
上面的代码做了两次for循环,这两个for循环将会产生两次对数据库的查询.而不是查询一次存入QuerySets ,然后在对QuerySets进行循环. 并且两次的循环结果很可能不一样,因为每一次查询的结果集可能不一样. 要是用缓存和结果集,就要写成:
>>> queryset = Entry.objects.all() #这段代码并未真正的将数据从数据库读到内存中,它只是读了一小部分,这个只有当大数据查询能看到.比如你有100W条数据进行select,你会发现,你执行后立刻就返回了.你在print(queryset),只会打印前几十条,后面省略了只显示前几十条和总共的数量.其实是没取,不是省略.
# 在什么时候会去数据库中取呢?当你第一次真正去遍历它的时候,它才会去把数据从数据库中取出来.第二次就可以直接用了
>>> print([p.headline for p in queryset]) # Evaluate the query set.
>>> print([p.pub_date for p in queryset]) # Re-use the cache from the evaluation.
什么情况下不会被缓存? 下面例子的时候:
>>> queryset = Entry.objects.all() 前查出一部分
>>> print queryset[5] # Queries the database 只取一个值的时候
>>> print queryset[5] # Queries the database again
>>> queryset = Entry.objects.all()
>>> [entry for entry in queryset] # Queries the database
>>> print queryset[5] # Uses cache
>>> print queryset[5] # Uses cache
Complex lookups with Q objects（复杂查询） 我们在filter中实现sql原声语句中的and条件,如（接下来的语句都是在orm_test.py中书写的）:
1 Entry.objects.filter(n_comments__gt=F(‘n_pingbacks‘), 2 pub_date__lte=‘2006-01-01‘)
那如果我们要实现原生语句中的OR关系条件,应该如何书写呢?就不能使用filter了,要使用Q了 具体使用如下:
1 from django.db.models import Q 2 Q(question__startswith=‘What‘)
你可以使用"|"."|"表示or关系,","表示and的关系
1 Q(question__startswith=‘Who‘) | Q(question__startswith=‘What‘) 2 ＃上面的语句的意思就是: 3 ＃ WHERE question LIKE ‘Who%‘ OR question LIKE ‘What%‘
还可以使用~,表示非
1 Q(question__startswith=‘Who‘) | ~Q(pub_date__year=2005)
orm代码中的写法举例:
1 Poll.objects.get( 2 Q(question__startswith=‘Who‘), 3 Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)) 4 ) 5 ＃这句就如同: 6 ＃ SELECT * from polls WHERE question LIKE ‘Who%‘ 7 ＃ AND (pub_date = ‘2005-05-02‘ OR pub_date = ‘2005-05-06‘)
那我们想,在不使用Q的时候,我们直接些某一个字段=值,那这种普通的写法和Q()能在一起使用吗?可以,不过要保证Q()的方式在前面,而普通方式在后面的顺序. 如:
1 Poll.objects.get( 2 Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)), 3 question__startswith=‘Who‘) 4 下面这种写法就错了: 5 # INVALID QUERY 6 Poll.objects.get( 7 question__startswith=‘Who‘, 8 Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
更新 Updating multiple objects at once # Update all the headlines with pub_date in 2007.
1 Entry.objects.filter(pub_date__year=2007).update(headline=‘Everything is the same‘)
在原有数据的基础上批量自增
1 >>> Entry.objects.all().update(n_pingbacks=F(‘n_pingbacks‘) + 1)
注释:批量更新有一个要注意的点,就是只能对本表内的字段进行自增,不能对外键和manytomany进行自增 另外付值时也不能用外键或者manytomany
1 # THIS WILL RAISE A FieldError 2 >>> Entry.objects.update(headline=F(‘blog__name‘))
反向关联查询:我们知道整个Blog系统有如下几张表,
1 class Publisher(models.Model): 2 name = models.CharField(max_length=30,unique=True) # CharField后必须有(max_length=?) 3 address = models.CharField(max_length=50) 4 city = models.CharField(max_length=60) 5 state_province = models.CharField(max_length=30) 6 country = models.CharField(max_length=50) 7 website = models.URLField() 8 def __str__(self): 9 return "<%s>"%(self.name) 10 11 class Author(models.Model): 12 first_name = models.CharField(max_length=30) 13 last_name = models.CharField(max_length=40) 14 email = models.EmailField() 15 def __str__(self): 16 return "<%s %s>"%(self.first_name,self.last_name) 17 18 class Book(models.Model): 19 title = models.CharField(max_length=100) 20 authors = models.ManyToManyField(Author) 21 publisher = models.ForeignKey(Publisher) 22 publication_date = models.DateField()
其中Book表中publisher字段外键关联Publisher表类.所以我们可以在查询Book表publisher字段获得Publisher实例.那么在Django的ORM中能不能在被外键关联的表中获取,一个Publisher实例被几个Book记录关联.答案是能!!
1 from app01 import models as book_models 2 pub_obj = book_models.Publisher.objects.last() 3 print(pub_obj.name,pub_obj.book_set.select_related())
book_set是什么?我们在Publisher表里没有定义吧,而是自己生成的.只要你有反向关联,它就会自动的生成 返向关联表名_set,我们models文件中定义的是Book,但是在数据库中生成的却是app01_book,所以这里生成的是book_set,而不是Book_set. ＃而select_related() 就是把所有的跟我这个publisher实例关联的记录查出来的方法. 如果我们想查每一个publisher实例,被关联多少次
1 pub_objs = book_models.Publisher.objects.annotate(book_nums=Count(‘book‘)) 2 for publisher in pub_ojbs: #分类聚合 3 print(publisher.book_nums)
上面的写法实际上是分类的聚合.我们会问.annotate()是什么意思?
Aggregation（聚合）聚合是什么意思?比如说我想查出来我们班级里所有人的平均成绩. from django.db.models import Avg,Sum,Min,Max print(models.Entry.objects.all().aggregate(Avg(‘n_pingbacks‘),Sum(‘n_pingbacks‘), Min(‘n_pingbacks‘) ))
时间： 2024-11-01 13:58:49