CodeLife

vuePress-theme-reco yuqing521    2019 - 2020
CodeLife CodeLife

Choose mode

  • dark
  • auto
  • light
主页
分类
  • 日常
  • 后端
  • 基础知识
  • 前端
  • 读书
标签
时间轴
文档
  • vuepress-reco
Github
联系我
  • 关于我
  • CSDN
  • 掘金
author-avatar

yuqing521

22

文章

25

标签

主页
分类
  • 日常
  • 后端
  • 基础知识
  • 前端
  • 读书
标签
时间轴
文档
  • vuepress-reco
Github
联系我
  • 关于我
  • CSDN
  • 掘金
  • Django入门笔记3-数据库连接与DateBase API

    • 数据库连接
      • DateBase API
        • 创建对象
        • save
        • 复制已有对象
        • 查询对象
        • 获得所有对象
        • 获得满足过滤条件的部分对象
        • 获得某一个对象
        • 限制返回的对象数量
        • 更多查找条件
        • lte
        • exact
        • iexact
        • contains
        • icontains
        • startswith
        • endswith
        • istartswith
        • endswith
        • 对象的属性的属性
        • 对象的外键
        • Q对象
        • 更新对象
        • 更新单个对象
        • 更新外键
        • 更新多对多字段
        • 更新多个对象
        • 删除对象
        • 删除所有对象
        • 删除指定对象
        • SQL

    Django入门笔记3-数据库连接与DateBase API

    vuePress-theme-reco yuqing521    2019 - 2020

    Django入门笔记3-数据库连接与DateBase API


    yuqing521 2020-08-03 Django Restful FrameworkDjangoPython

    How to create a new project in Django | Hacker Noon

    # Django入门笔记3-数据库连接与DateBase API

    # 数据库连接

    MySQL

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': 'mydatabase',
            'USER': 'mydatabaseuser',
            'PASSWORD': 'mypassword',
            'HOST': '127.0.0.1',
            'PORT': '3306',
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    PostgreSQL

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.postgresql',
            'NAME': 'mydatabase',
            'USER': 'mydatabaseuser',
            'PASSWORD': 'mypassword',
            'HOST': '127.0.0.1',
            'PORT': '5432',
        }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

    MongoDB

    DATABASES = {
        'default': {
            'ENGINE': None, # 把默认的数据库连接至为None
        }
    }
    from mongoengine import connect
    connect('test') # 连接的数据库名称
    
    1
    2
    3
    4
    5
    6
    7

    编写 model.py 和 [serializer.py](http://serializer.py) 创建模型和序列化

    初始化模型及数据库

    创建映射文件

    python manage.py makemigrations
    
    1

    将映射文件中的映射到数据库中

    python manage.py migrate
    
    1

    # DateBase API

    创建model

    from django.db import models
    class Blog(models.Model):
      name = models.CharField(max_length=100)
      tagline = models.TextField()
      def __str__(self):
        return self.name
    
    class Author(models.Model):
      name = models.CharField(max_length=200)
      email = models.EmailField()
      def __str__(self):
        return self.name
    
    class Entry(models.Model):
      blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
      headline = models.charField(max_length=255)
      body_text = models.TextField()  
      pub_date = models.DateField()
      mod_date = models.DateField()
      authors = models.ManyToManyField(Author)
      n_comments = models.IntergerField()
      n_pingbacks = models.IntegerField()
      rating = models.IntegerField()
      def __str__(self):
        return self.headline
    
    class EntryDetail(models.Model):
      entry = models.OneToOneField(Entry, on_delete=models.CASCADE)
      details = models.TextField()1234567891011121314151617181920212223242526272829
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29

    # 创建对象

    # save

    需遵循如下步骤:

    1. 创建一个类的实例
    2. 在这个实例上调用save()
    # 创建实例
    >>> b1=Blog(name="Beatles Blog", tagline = "all the latest Beatles news.")
    >>> b2=Blog(name="Sue Blog", tagline = "all latest news about Sue.")
    >>> b3=Blog(name="Computer Science", tagline="Hello World!")
    
    # 保存对象
    >>> b1.save()
    >>> b2.save()
    >>> b3.save()
    
    1
    2
    3
    4
    5
    6
    7
    8
    9

    这在幕后执行了 INSERT SQL 语句。Django 在你显式调用 save() 才操作数据库。

    # 复制已有对象

    将想复制的对象的pk设为None,然后save()即可。

    >>> b = Blog.objects.all().get(pk=4)
    >>> b.pk = None
    >>> b.save()
    
    1
    2
    3

    需要注意的是, 这种方法并不会复制对象的ManyToManyField等属性,因此针对ManyToMany的情况,我们可以:

    entry = Entry.objects.all()[0]
    >>> old_authors = entry.authors.all()
    >>> entry.pk = None
    >>> entry.save()
    >>> entry.authors.set(old_authors)12345
    
    1
    2
    3
    4
    5

    而OneToOne的情况,我们可以:

    >>> EntryDetail.objects.create(entry=Entry.objects.all()[0], details="None")
    <EntryDetail: EntryDetail object (1)>
    >>> detail = EntryDetail.objects.all()[0]
    >>> detail.pk=None
    >>> detail.entry=Entry.objects.all()[1]
    >>> detail.save()123456
    
    1
    2
    3
    4
    5
    6

    # 查询对象

    在Django中,每一个model都至少有一个Manager,默认有一个Manager叫objects(即objects是django.db.models.manager.Manager的实例),我们通过调用这个变量的方法可以获得一个包含对象集合的QuerySet

    # 获得所有对象

    >>> Blog.objects.all()
    <QuerySet [<Blog: Beatles Blog>, <Blog: Sue Blog>, <Blog: Computer Science>]>12
    
    1
    2

    # 获得满足过滤条件的部分对象

    1. filter 返回满足条件的对象集合
    2. exclude 在所有对象的集合中排除满足条件的对象集合并返回
    >>> Blog.objects.filter(name="Computer Science")
    <QuerySet [<Blog: Computer Science>]>
    >>> Blog.objects.exclude(pk=1)
    <QuerySet [<Blog: Sue Blog>, <Blog: Compter Science>]>
    >>> Blog.objects.exclude(pk=3).filter(name__startswith="Beatles")
    <QuerySet [<Blog: Beatles Blog>]>123456
    
    1
    2
    3
    4
    5
    6

    上述例子中可以看出:1. 由于filter() exclude()均返回QuerySet(),因此可以链式调用2. 参数形式为field__lookuptype=filter_value,类似SQL语句中WHERE后面的写法。3. 关于name__startswith="Beatles",后面会有讲解。

    另外有一点需要注意,创建一个QuerySet不涉及任何数据库操作,只有在使用它的时候,才会去访问数据库。

    >>> q = Blog.objects.filter(name="Computer Science")
    >>> q = q.exclude(pk=1)
    >>> print(q)
    <QuerySet []>1234
    
    1
    2
    3
    4

    前面两句都是在创建一个QuerySet,只有最后一句才使用了它,因此整段代码只有在最后一句才真正访问了数据库。

    # 获得某一个对象

    如果能够确定某种过滤条件能而且只能返回一个对象,我们可以使用get()

    >>> Blog.objects.get(pk=1)
    <Blog: Beatles Blog>
    >>> Blog.objects.filter(pk=1)[0]
    <Blog: Beatles Blog>1234
    
    1
    2
    3
    4

    上述例子中,我们似乎可以看出get()与filter()+[0]可以做同一件事情,事实不是这样的,我们再举一个例子:

    >>> Blog.objects.get(pk=4)
    ...
    blog.models.DoesNotExist: Blog matching query does not exist.
    >>> Blog.objects.get(name__endswith="Blog")
    ...
    blog.models.MultipleObjectsReturned: get() returned more than one Blog -- it returned 2!
    >>> Blog.objects.filter(pk=4)
    <QuerySet []>
    >>> Blog.objects.filter(pk=4)[0]
    ...
    IndexError: list index out of range1234567891011
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    可以看出get()更加严格,无论是找不到对象,可以返回的对象不止一个,均会报错(DoesNotExist MultipleObjectsReturned)

    # 限制返回的对象数量

    1. 返回前2个对象
    >>> Blog.objects.all()[:2]
    <QuerySet [<Blog: Beatles Blog>, <Blog: Sue Blog>]>12
    
    1
    2
    1. 返回第2个到第3个对象
    >>> Blog.objects.all()[1:3]
    <QuerySet [<Blog: Sue Blog>, <Blog: Compter Science>]>12
    
    1
    2
    1. 返回第三个对象
    >>> Blog.objects.all()[2]
    <Blog: Compter Science>12
    
    1
    2

    # 更多查找条件

    我们在写一个SQL语句时,WHERE部分不仅仅局限于=,比如:

    WHERE pub_date <= '2018-02-19'WHERE 12
    
    1

    那么如何在Django中表示更多的查找条件呢?我们使用上文提到过的如下形式:

    field__lookuptype=filter_value1
    
    1

    # lte

    >>> Entry.objects.filter(pub_date__lte='2006-01-01')
    <QuerySet []>12
    
    1
    2

    # exact

    即相等

    >>> Entry.objects.filter(body_text__exact="None")
    <QuerySet [<Entry: Beatles' first song>]>12
    
    1
    2

    相当于

    >>> Entry.objects.filter(body_text="None")
    <QuerySet [<Entry: Beatles' first song>]>12
    
    1
    2

    # iexact

    在忽略大小写的情况下,是否相等。

    >>> Entry.objects.filter(body_text__iexact="none")
    <QuerySet [<Entry: Beatles' first song>]>12
    
    1
    2

    # contains

    字符串中是否包含给定字符串,相当于SQL语句中的LIKE

    >>> Entry.objects.filter(body_text__contains="No")
    <QuerySet [<Entry: Beatles' first song>]>12
    
    1
    2

    # icontains

    在忽略大小写的情况下,字符串中是否包含给定字符串。

    # startswith

    字符串是否以给定字符串开头

    # endswith

    字符串是否以给定字符串结尾

    # istartswith

    在忽略大小写的情况下,字符串是否以给定字符串开头

    # endswith

    在忽略大小写的情况下,字符串是否以给定字符串结尾

    # 对象的属性的属性

    当我们通过判断对象的属性的属性是否符合某个条件来查找对象时,不能使用.,应使用__

    >>> Entry.objects.filter(blog__name__contains="Sue")
    <QuerySet [<Entry: Beatles' first song>]>12
    
    1
    2

    # 对象的外键

    当我们通过对象的外键是否符合某个条件来查找对象时,有以下几种方式:1. 上文提到的一种方式

    >>> Entry.objects.filter(blog__name__contains="Sue")
    <QuerySet [<Entry: Beatles' first song>]>12
    
    1
    2
    1. 如果可以获得外键实例,可直接判断是否相等
    >>> b = Blog.objects.all().get(pk=2)
    >>> Entry.objects.filter(blog=b)
    <QuerySet [<Entry: Beatles' first song>]>123
    
    1
    2
    3
    1. 如果知道外键的id:
    >>> Entry.objects.filter(blog_id=2)
    <QuerySet [<Entry: Beatles' first song>]>12
    
    1
    2

    或者

    >>> Entry.objects.filter(blog=2)
    <QuerySet [<Entry: Beatles' first song>]>12
    
    1
    2

    或者

    >>> Entry.objects.filter(blog=b.id)
    <QuerySet [<Entry: Beatles' first song>]>12
    
    1
    2

    我们可以通过foreignkeyname_id的形式获得外键的id

    # Q对象

    Q对象可以做更加复杂的匹配,可以封装多个过滤条件。1. 封装单个过滤条件

    >>> Blog.objects.all().filter(Q(name__startswith="Beatles"))
    <QuerySet [<Blog: Beatles Blog>, <Blog: Beatles Blog>]>12
    
    1
    2
    1. 与 或 非
    Q(question__startswith="WHO") | ~Q(question__startswith="WHAT")1
    
    1
    1. 多个过滤条件
    Blog.objects.filter(Q(name__startswith("b")), Q(name__endswith("s")))1
    
    1

    当往Q输入多个参数时,它们之间的关系为AND


    # 更新对象

    # 更新单个对象

    更新普通字段

    >>> b.name="Beatles' Blog"
    >>> b.save()12
    
    1
    2

    # 更新外键

    首先创建一个Entry对象:

    entry = Entry(blog=b, headline="Beatles' first song",  body_text="None",pub_date=datetime.now(),n_comments=4,n_pingbacks=4,rating=4,mod_date=datetime.now())
    >>> entry.save()12
    
    1
    2

    修改entry的外键:

    b = Blog.objects.all().get(pk=2)
    >>> entry.blog = b
    >>> entry.save()
    >>> Entry.objects.all()[0].blog
    <Blog: Sue Blog>12345
    
    1
    2
    3
    4
    5

    # 更新多对多字段

    首先新建一个Author实例:

    >>> a1 = Author.objects.create(name="Sue", email="158@qq.com")
    >>> a2 = Author.objects.create(name="Bob", email="189@qq.com")12
    
    1
    2

    使用add()为authors字段添加一个实例

    >>> entry.authors.add(a1, a2)
    >>> Entry.objects.all()[0].authors.get(id=1)
    <Author: Sue>123
    
    1
    2
    3

    需要注意的是:1. add()方法后,不需要save()2. 这里使用create()创建对象,它是Manager的一个方法。也不需要save()

    # 更新多个对象

    使用update()并配合filter() all()等,对一个对象集合进行更新操作。update()返回需要更新的对象数(也许不是发生改变的对象数,因为有的对象已经有了最新值)

    >>> Entry.objects.filter(pub_date__year=2018).update(headline="Everything is the same.")
    312
    
    1
    2

    需要注意的是,使用这个方法只能更新外键或者没关系型字段


    # 删除对象

    使用delete()来删除的对象,为了避免误删除,Manager本身并没有暴露delete()方法。delete()返回删除的对象数量以及按照对象类型的分类汇总。

    # 删除所有对象

    >>> Blog.objects.all().delete()
    (7, {'blog.Entry_authors': 3, 'blog.EntryDetail': 0, 'blog.Entry': 1, 'blog.Blog': 3})12
    
    1
    2

    我们需要注意的是:1. 返回结果显示,此次删除操作删除了7个对象,3个Blog实例,1个Entry实例,3个Entry_authors中的对象。2. 默认情况下, delete()遵循级联删除的规则,即以被删除对象为外键的对象同时被删除。我们可以通过在定义model时添加on_delete参数来指定级联规则

    # 删除指定对象

    我们可以配合使用get() filter()等获得指定对象或包含指定对象集的QuerySet,然后调用delete()

    # SQL

    最后,我们也可以使用原生的SQL在访问数据库。