补充一个filter中大于小于的用法

 models.course_info.objects.filter(id__gte=30).delete()

  

_exact 精确等于 like 'aaa'

 __iexact 精确等于 忽略大小写 ilike 'aaa'

 __contains 包含 like '%aaa%'

 __icontains 包含 忽略大小写 ilike '%aaa%',但是对于sqlite来说,contains的作用效果等同于icontains。

__gt 大于

__gte 大于等于

__lt 小于

__lte 小于等于

__in 存在于一个list范围内

__startswith 以...开头

__istartswith 以...开头 忽略大小写

__endswith 以...结尾

__iendswith 以...结尾,忽略大小写

__range 在...范围内

__year 日期字段的年份

__month 日期字段的月份

__day 日期字段的日

__isnull=True/False


例子:

>> q1 = Entry.objects.filter(headline__startswith="What")

>> q2 = q1.exclude(pub_date__gte=datetime.date.today())

>> q3 = q1.filter(pub_date__gte=datetime.date.today())

>>> q = q.filter(pub_date__lte=datetime.date.today())

>>> q = q.exclude(body_text__icontains="food")

  

 

 

这篇博客主要整理一下数据库表的查询,之前也一直没有搞的很清楚

首先我们先构建一个对多的表结构吧,我们搞一个省和市的例子

先看下省表

class pro(models.Model):
    pro_name = models.CharField(max_length=64)
    def __str__(self):
        return self.pro_name

  

在看下市表

class city(models.Model):
    city_name = models.CharField(max_length=64)
    city_pro = models.ForeignKey("pro",on_delete=models.CASCADE)

    def __str__(self):
        return self.city_name

  

然后我们创建数据,首先要创建省表中的数据,因为市表要关联省表,所以省表必须要先有数据

先构建省表中的数据,通过create方法

    s1 = "广州"
    s2 = "深圳"
    s3 = "东莞"
    for i in range(3):
        models.pro.objects.create(
            pro_name = s1 + str(i) 
        )
    for i in range(3):
        models.pro.objects.create(
            pro_name = s2 + str(i) 
        )
    for i in range(3):
        models.pro.objects.create(
            pro_name = s3 + str(i) 
        )

  

然后在构建市表的数据

    for i in range(3):
        pro_name = models.pro.objects.filter(id=1)
        print(pro_name[0].pro_name,"--------------------->")
        models.city.objects.create(
            city_name = s1 + str(i),
            city_pro = pro_name[0]
        )

    for i in range(3):
        pro_name = models.pro.objects.filter(id=2)
        print(pro_name[0].pro_name,"--------------------->")
        models.city.objects.create(
            city_name = s2 + str(i),
            city_pro = pro_name[0]
        )
    for i in range(3):
        pro_name = models.pro.objects.filter(id=3)
        print(pro_name[0].pro_name,"--------------------->")
        models.city.objects.create(
            city_name = s3 + str(i),
            city_pro = pro_name[0]
        )

  

市表关联省表的时候要十分注意,下面这段代码返回的是一个对象的列表,我们需要通过列表的索引来获取我们要的值

pro_name = models.pro.objects.filter(id=1)

  

city_pro = pro_name[0]

  

这样我们就创建好了省表和市表,且把数据也初始化ok了

省表

市表

 

 

做好准备工作后,我们就可以开始练习查询了

一、先说下单表查询

 1、查询所有的数据,用all方法

    res = models.pro.objects.all()
    for i in res:
        print(i)

  

2、使用filter方法过滤,filter方法

   res = models.city.objects.filter(id=2)
    print(res[0].city_pro)

  

 3、查看某个对象是否存在,exists方法

print(models.city.objects.filter(id=2).exists())

  

 4、统计数量,使用count方法

print(models.city.objects.filter(id=2).count())

  

 5、查看第一个对象和最后一个对象

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

    print(models.city.objects.last())

  

6、也可以传递一个字典进去

    dict_city = {"id":1,"city_name":"乌海0"}
    print(models.city.objects.filter(**dict_city).exists())

  

二、然后说一下一对多的查询

首先看下表的字段

 

 

 

1、先看正向查询,从有外键的表开始查询,这里要用到两个下划线的方法,由django为我们做跨表查询

 先看all方法,all方法返回的是一个对象

    res = models.city.objects.all()
    print(res[0].city_pro)

    print(res[1].city_pro)

  

结果

内蒙古0
内蒙古0

  

在values方法,返回的是一个字典,因为我们是通过city_pro字段去关联其他表,city_pro__pro_name,去查询其他的表的指定字段,记住这里是两个下划线,这里的filter中的字段可以city这个表的字段,也可以使用pro这个表的字段,但是如果是pro这个表的字段,则就需要使用两个下划线的功能

    res = models.city.objects.filter(city_pro__id=3).values("id","city_name","city_pro","city_pro__pro_name","city_pro__id")
    for i in res:
        print(i)

  

结果

{'id': 7, 'city_name': '临河0', 'city_pro': 3, 'city_pro__pro_name': '内蒙古2', 'city_pro__id': 3}
{'id': 8, 'city_name': '临河1', 'city_pro': 3, 'city_pro__pro_name': '内蒙古2', 'city_pro__id': 3}
{'id': 9, 'city_name': '临河2', 'city_pro': 3, 'city_pro__pro_name': '内蒙古2', 'city_pro__id': 3}

  

上面可以使用filter也可以使用all

    res = models.city.objects.all().values("id","city_name","city_pro","city_pro__pro_name","city_pro__id")
    for i in res:
        print(i)

  

结果

{'id': 1, 'city_name': '乌海0', 'city_pro': 1, 'city_pro__pro_name': '内蒙古0', 'city_pro__id': 1}
{'id': 2, 'city_name': '乌海1', 'city_pro': 1, 'city_pro__pro_name': '内蒙古0', 'city_pro__id': 1}
{'id': 3, 'city_name': '乌海2', 'city_pro': 1, 'city_pro__pro_name': '内蒙古0', 'city_pro__id': 1}
{'id': 4, 'city_name': '包头0', 'city_pro': 2, 'city_pro__pro_name': '内蒙古1', 'city_pro__id': 2}
{'id': 5, 'city_name': '包头1', 'city_pro': 2, 'city_pro__pro_name': '内蒙古1', 'city_pro__id': 2}
{'id': 6, 'city_name': '包头2', 'city_pro': 2, 'city_pro__pro_name': '内蒙古1', 'city_pro__id': 2}
{'id': 7, 'city_name': '临河0', 'city_pro': 3, 'city_pro__pro_name': '内蒙古2', 'city_pro__id': 3}
{'id': 8, 'city_name': '临河1', 'city_pro': 3, 'city_pro__pro_name': '内蒙古2', 'city_pro__id': 3}
{'id': 9, 'city_name': '临河2', 'city_pro': 3, 'city_pro__pro_name': '内蒙古2', 'city_pro__id': 3}

  

也可以使用values_list方法,返回的是一个列表

    res = models.city.objects.all().values_list("id","city_name","city_pro","city_pro__pro_name")
    for i in res:
        print(i)

  

结果

(1, '乌海0', 1, '内蒙古0')
(2, '乌海1', 1, '内蒙古0')
(3, '乌海2', 1, '内蒙古0')
(4, '包头0', 2, '内蒙古1')
(5, '包头1', 2, '内蒙古1')
(6, '包头2', 2, '内蒙古1')
(7, '临河0', 3, '内蒙古2')
(8, '临河1', 3, '内蒙古2')
(9, '临河2', 3, '内蒙古2')

  

 

2、然后看下反向查询,通过没有外键的表查询,这里我们要用set方法和两个下划线的方法

方法1

获取所有的省

res = models.pro.objects.all()

  

获取第一个省

temp = res[0]

  

获取第一个省下的所有的市,用city_set方法

print(temp.city_set.all())

  

结果

<QuerySet [<city: 乌海0>, <city: 乌海1>, <city: 乌海2>]>

  

方法2

 

    res = models.pro.objects.filter(id=3).first()

    print(res.city_set.all())

  

结果

<QuerySet [<city: 临河0>, <city: 临河1>, <city: 临河2>]>

  

 通过反向查找也可以使用values方法,但是其中的字段是下面这样的,values中的字段都是多表中的字段,但是如果要查询一表中的字段,也需要通过多表中的外键关联的字段加上两个下划线进行查询

city_list = models.pro.objects.get(id=1).city_set.values("city_pro","city_name","city_pro_id","id","city_pro__pro_name")

  

结果

{'city_pro': 1, 'city_name': '乌海0', 'city_pro_id': 1, 'id': 1, 'city_pro__pro_name': '内蒙古0'}
{'city_pro': 1, 'city_name': '乌海1', 'city_pro_id': 1, 'id': 2, 'city_pro__pro_name': '内蒙古0'}
{'city_pro': 1, 'city_name': '乌海2', 'city_pro_id': 1, 'id': 3, 'city_pro__pro_name': '内蒙古0'}

  

 

 

三、最后说一下多对多的查询

首先看下第三张表由django默认创建的场景

 

我们举一个这样的例子,书和作者的例子,一个书可以多个作者,一个作者也可以写多个书,所以书和作者就是一个多对多的关系

先在models中创建书这个表的对象

class Book(models.Model):
    book_name = models.CharField(max_length=64)

    def __str__(self):
        return self.book_name

  

然后在models中创建作者这个表的对象

class Auther(models.Model):
    auther_name = models.CharField(max_length=64)
    auther_book = models.ManyToManyField("Book")
    def __str__(self):
        return self.auther_name

  

我们这里注意到,只在作者这个表中有manyToManyField。我们在创建作者这个表的时候可以完全不关注auther_book这个字段,我们在创建书这个表的时候也可以完全不关注作者

这个字段,我们可以在后面为两张表创建关联关系

我们现在后台给书这个表写了一些数据,数据如下

 

 我们写一个前端的代码,实现的效果就是注册一个作者,然后可以选择你哪些书

前端代码如下

    <form action="/app1/many_to_many_func/" method="post">
        <p>
            名字:<input type="text" name="new_add_name">
        </p>

        <h1>请选择你的学校</h1>
        <select name="new_add_book" multiple="multiple">
            {% for i in book_list %}
                <option value ={{ i.id }}>
                        {{ i.book_name }}
                </option>
            {% endfor %}
        </select>
        <p><input type="submit" value="submit提交"></p>
    </form>

  

django后端接受数据的代码

def many_to_many_func(request):
    if request.method.lower() == "get":
        book_list_temp = models.Book.objects.all()
        return render(request, "test1.html", {"book_list": book_list_temp})

    else:
        auther_name = request.POST.get("new_add_name")
        # 获取前段发来的作者的名称
        
        book_list = request.POST.getlist("new_add_book")
        # 获取前端发来的书的列表,这里要通过getlist方法来获取
        
        models.Auther.objects.create(
            auther_name = auther_name
        )
        # 先为作者的数据库写入数据
        
        
        auther_name_obj = models.Auther.objects.filter(auther_name = auther_name).first()
        # 在数据库中获取这个作者的对象

        
        auther_name_obj.auther_book.add(*book_list)
        # 通过add方法为这个作者添加多对多的映射


        return HttpResponse("hahah")
    book_list_temp = models.Book.objects.all()
    return render(request, "test1.html", {"book_list": book_list_temp})

  

删除某个映射关系

        del_auther_obj = models.Auther.objects.filter(auther_name="zhouyongbo").first()
        del_auther_obj.auther_book.remove(14)

  

更新某个映射关系,记住,这里要传递一个可迭代的对象

        del_auther_obj = models.Auther.objects.filter(auther_name="zhouyongbo").first()
        # del_auther_obj.auther_book.remove(14)

        del_auther_obj.auther_book.set([18,14])

  

清空某个映射关系,记住,只要传递一个可迭代的对象

        del_auther_obj = models.Auther.objects.filter(auther_name="zhouyongbo").first()
        # del_auther_obj.auther_book.remove(14)

        # del_auther_obj.auther_book.set([18,14])

        del_auther_obj.auther_book.clear()

  

 

 上面讲的正向操作,反向操作按照下面方法在试一下

# 反向操作
# obj = models.Book.objects.get(id=1)
# obj.author_set.add(1)
# obj.author_set.add(1,2,3,4)
# ...

 

 

下面我们在来看下下第三种表由我们自己创建的情况

自己创建第三张表:
class Book(models.Model):
name = ..

class Author(models.Model):
name = ..

class A_to_B(models):
bid = ForeignKey(Book)
aid = ForeignKey(Author)


class Meta
uniqe_together = (
'bid','nid'
)

class Meta
uniqe_together = (
('bid1','nid1'),
('bid2','nid2'),
('bid3','nid3'),
)

 

posted on 2018-04-24 07:39  bainianminguo  阅读(206)  评论(0编辑  收藏  举报