Django基础之：ORM系统单表操作

一. ORM简介

1. web开发的分工模式

DBA（数据库管理员）+应用层开发。

一般中大型公司（或者数据量巨大、读取数据的需求频繁并且追求极致效率的公司）会有专门的DBA管理数据库，编写sql语句，对于应用层开发来说，不用写sql语句，直接调用他写的接口就行。所以在这种公司一般来说，开发人员应该'供'着DBA，因为你想写入或者取出的数据需要依赖于DBA去执行，或者是你写的比较复杂的sql语句需要让DBA帮你看一下，效率行不行、是不是需要优化等等，这就需要看你们的交情或者其心情了。哈哈（开个玩笑）。
应用程序开发+sql语句编写。

这种情况多存在于小公司，没有专门设置DBA岗位，要求开发人员什么都会一些，linux、数据库、前端等等，这样成本降低并且减少由于部门之间的沟通带来的损失，提高工作流程效率。
应用程序开发+ORM。

这种模式sql不用你写，你直接写类、对象，应为你对这些更加游刃有余。然后通过你写的类、对象，等等通过相应的转换关系直接转化成对应的原生sql语句，这种转化关系就是ORM：对象-关系-映射。你直接写一个类就是创建一张表，你实例化一个对象就是增加一条数据，这样以来，既可以避开写sql语句的麻烦，而且可以提升我们的开发效率。

2. ORM

MTV或者MVC框架中包括一个重要的部分，就是ORM，它实现了数据模型与数据库的解耦，即数据模型的设计不需要依赖于特定的数据库，通过简单的配置就可以轻松更换数据库，这极大的减轻了开发人员的工作量，不需要面对因数据库变更而导致的无效劳动.
ORM是“对象-关系-映射”的简称。（Object Relational Mapping，简称ORM）(将来会学一个sqlalchemy，是和他很像的，但是django的orm没有独立出来让别人去使用，虽然功能比sqlalchemy更强大，但是别人用不了)
类对象--->sql--->pymysql--->mysql服务端--->磁盘，orm其实就是将类对象的语法翻译成sql语句的一个引擎，明白orm是什么了，剩下的就是怎么使用orm，怎么来写类对象关系语句。

这样开发效率肯定是提升了，但是也有一点点缺陷就是通过ORM转化成的sql语句虽然是准确的，但是不一定是最优的。

　　原生sql和python的orm代码对比

#sql中的表                                                      

 #创建表:
     CREATE TABLE employee(                                     
                id INT PRIMARY KEY auto_increment ,                    
                name VARCHAR (20),                                      
                gender BIT default 1,                                  
                birthday DATA ,                                         
                department VARCHAR (20),                                
                salary DECIMAL (8,2) unsigned,                          
              );


  #sql中的表纪录                                                  

  #添加一条表纪录:                                                          
      INSERT employee (name,gender,birthday,salary,department)            
             VALUES   ("alex",1,"1985-12-12",8000,"保洁部");               

  #查询一条表纪录:                                                           
      SELECT * FROM employee WHERE age=24;                               

  #更新一条表纪录:                                                           
      UPDATE employee SET birthday="1989-10-24" WHERE id=1;              

  #删除一条表纪录:                                                          
      DELETE FROM employee WHERE name="alex"                             





#python的类
class Employee(models.Model):
     id=models.AutoField(primary_key=True)
     name=models.CharField(max_length=32)
     gender=models.BooleanField()
     birthday=models.DateField()
     department=models.CharField(max_length=32)
     salary=models.DecimalField(max_digits=8,decimal_places=2)


 #python的类对象
      #添加一条表纪录:
          emp=Employee(name="alex",gender=True,birthday="1985-12-12",epartment="保洁部")
          emp.save()
      #查询一条表纪录:
          Employee.objects.filter(age=24)
      #更新一条表纪录:
          Employee.objects.filter(id=1).update(birthday="1989-10-24")
      #删除一条表纪录:
          Employee.objects.filter(name="alex").delete()

二、单表操作

1.创建表

1. 首先我们先创建一个ORM项目

在你的app01项目中models就是以后我们创建数据模型的地方。

2. 通过类创建数据表

从django.db 引入models模块，创建表通过构建一个类去设定，数据库中不区分大小写，所以你的UserInfo在数据库中直接编译成了userinfo，此类必须继承models.Model类，通过设定类的静态属性就会转化成sql语句。

from django.db import models
# Create your models here.


class UserInfo(models.Model):
    """
    下面几个类的属性通过ORM映射就对应成了：
    create table userinfo(
        id int primary key auto_increment,
        name varchar(16),
        age int,
        current_date date)
    """
    id = models.AutoField(primary_key=True)

    name = models.CharField(max_length=16)

    age = models.IntegerField()

    current_date = models.DateField()

3. 在对应的数据库中生成表结构

上面我们已经通过类构建了一个表，但是还没有对应的生成真实的数据库中的表结构，所以我们要将上面的类生成真生的数据库中的表结构。对应只有行代码。

在terminal输入指令：

python manage.py makemigrations

我这里使用的是python3.6 是因为python版本较多，环境变量python3.6指向的是python3.6.8的解释器。

然后你看你的app01下面的migrations出现一个0001_initial.py的文件，这个文件是你执行了上述指令之后产生的脚本文件，这个文件就是一个记录。

接下来我们继续输入指令：

python manage.py migrate

这个指令其实就是执行第一个指令生成的记录也就是那个脚本文件，然后就会在你对应的数据库中生成一个真正的表，生成的表名字前面会自带应用的名字，例如：你的userinfo表在数据表里面叫做：app01_userinfo。

在执行 python manager.py makemigrations时
Django 会在相应的 app 的migrations文件夹下面生成 一个python脚本文件 
    
在执行 python manager.py migrate 时 Django才会生成数据库表，那么Django是如何生成数据库表的呢?

Django是根据 migrations下面的脚本文件来生成数据表的
    每个migrations文件夹下面有多个脚本，那么django是如何知道该执行那个文件的呢，django有一张django-migrations表，表中记录了已经执行的脚本，那么表中没有的就是还没执行的脚本，则 执行migrate的时候就只执行表中没有记录的那些脚本。
    有时在执行 migrate 的时候如果发现没有生成相应的表，可以看看在 django-migrations表中看看 脚本是否已经执行了，
    可以删除 django-migrations 表中的记录 和 数据库中相应的 表 ， 然后重新 执行

同步执行指令的原理

那么我们的数据表创建在那个数据库中了呢？我们之前没有给Django配置数据库呀？其实Django给我们默认配置了一个小型的数据库sqlit3，下面我们就会讲到。

4. 小型数据库sqlite3

我们先简单提一下这个小型数据库sqlite3，sqlite3数据库是Django给我们提供的一个数据库，一般工作中我们不会用这个数据库，这个数据库就是为了我们测试使用的。这个数据库就在我们的目录中：

我们的数据库是分为客户端和服务端的，现在只是将uerinfo表结构存储记录到我们的客户端上了，我们连接上在本机的sqlit3的服务端，才算是真正的创建了表结构。想要使用sqlit3服务端并且启动，先要在这个位置下载并安装对应的引擎：

这样，你的sqlit3服务端已经下载并安装成功了，接下来交给大家一个骚操作，将目录里面的sqlite3，拖拽到database中，这样客户端与服务端就连接成功了，就可以看到你刚才创建的那张表了。

我们看一下，这里有你的app01_userinfo这张表（app01是你在创建userinfo表时Django帮你自动拼接上的并且全部都是小写了），还有一些蓝色区域框起来的表，我们只是创建了一张表，为什么多出这么多张表结构了呢？

因为我们当初注册app01时，其实DJango已经注册了很多其他的内置应用，当我们执行migrations指令时，这些内置应用下面的models表也就一并注册了。我们现在知道我们创建的表成功了即可，其他的以后我们会讲到。

我们点击app01_userinfo这张表看一下：

这个已经有了我们之前创建的字段了，这个与我们之前讲的Navicat可视化工具比较类似，也可以手动添加更新数据。

但是我们工作中是要与类似于MySQL这样的数据库连接的，我们不用sqlits操作，刚才只是测试一下，接下来我们把这个连接删除，配置MySQL。

5. 配置MySAL数据库

若想将模型转为mysql数据库中的表，需要在settings中配置：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'ormtest',     　　 　  # 要连接的数据库，连接前需要创建好
        'USER':'root',　　　　　　  # 连接数据库的用户名
        'PASSWORD':'',　　　　　　  # 连接数据库的密码
        'HOST':'127.0.0.1',       # 连接主机，默认本级
        'PORT'：3306    　　　     #  端口 默认3306
    }
}

上面是给项目中的所有的应用都配置成MySQL数据库，当然我们也可以给单个应用配置数据库：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'ormtest',     　　 　  # 要连接的数据库，连接前需要创建好
        'USER':'root',　　　　　　  # 连接数据库的用户名
        'PASSWORD':'',　　　　　　  # 连接数据库的密码
        'HOST':'127.0.0.1',       # 连接主机，默认本级
        'PORT'：3306    　　　     #  端口 默认3306
    }，
    'app01': { #可以为每个app都配置自己的数据，并且数据库还可以指定别的，也就是不一定就是mysql，也可以指定sqlite等其他的数据库
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'ormtest',     　　 　  # 要连接的数据库，连接前需要创建好
        'USER':'root',　　　　　　  # 连接数据库的用户名
        'PASSWORD':'',　　　　　　  # 连接数据库的密码
        'HOST':'127.0.0.1',       # 连接主机，默认本级
        'PORT'：3306    　　　     #  端口 默认3306
    }
}

app配置单独的数据库

注意：NAME即数据库的名字，在mysql连接前该数据库必须已经创建，而上面的sqlite数据库下的db.sqlite3则是项目自动创建 USER和PASSWORD分别是数据库的用户名和密码。设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。接下来，我们要提前先给mysql创建ormtest的数据库。

从终端进入mysql，创建ormtest数据库：

create database ormtest;

以后工作中，一般有一个项目设置一个库，或者一个应用设置一个库，这得看自己公司具体情况。

从settings文件配置数据库：

pass

Django项目连接数据库：

　　现在必要的参数我们都配置好了，但是我们如何让你的项目连接数据库？怎么连接呢？django默认你导入的驱动是MySQLdb，可是MySQLdb 对于py3.4+版本有很大问题，所以我们需要的驱动是PyMySQL。所以，我们只需要找到项目名文件下的__init__,在里面写入：

再次生成表记录，创建数据表

可以通过pycharm给你们提供的功能，进行构建记录以及创建数据表：

或者是通过指令的形式：

python manage.py makemigrations

python manage.py migrate

这样，我们在打开我们的MySQL的ormtest数据库，看看是否创建成功了：

OK，这样你的你的数据库表就匹配成功啦！

6.更多的字段和参数

　　每个字段有一些特有的参数，例如，CharField需要max_length参数来指定VARCHAR数据库字段的大小。还有一些适用于所有字段的通用参数。这些参数在文档中有详细定义，这里我们只简单介绍一些最常用的：

更多字段：

'''
 
<1> CharField
        字符串字段, 用于较短的字符串.
        CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.
 
<2> IntegerField
       #用于保存一个整数.
 
<3> DecimalField
        一个浮点数. 必须 提供两个参数:
         
        参数    描述
        max_digits    总位数(不包括小数点和符号)
        decimal_places    小数位数
                举例来说, 要保存最大值为 999 (小数点后保存2位),你要这样定义字段:
                 
                models.DecimalField(..., max_digits=5, decimal_places=2)
                要保存最大值一百万(小数点后保存10位)的话,你要这样定义:
                 
                models.DecimalField(..., max_digits=17, decimal_places=10) #max_digits大于等于17就能存储百万以上的数了
                admin 用一个文本框(<input type="text">)表示该字段保存的数据.
 
<4> AutoField
        一个 IntegerField, 添加记录时它会自动增长. 你通常不需要直接使用这个字段;
        自定义一个主键：my_id=models.AutoField(primary_key=True)
        如果你不指定主键的话,系统会自动添加一个主键字段到你的 model.
 
<5> BooleanField
        A true/false field. admin 用 checkbox 来表示此类字段.
 
<6> TextField
        一个容量很大的文本字段.
        admin 用一个 <textarea> (文本区域)表示该字段数据.(一个多行编辑框).
 
<7> EmailField
        一个带有检查Email合法性的 CharField,不接受 maxlength 参数.
 
<8> DateField
        一个日期字段. 共有下列额外的可选参数:
        Argument    描述
        auto_now    当对象被保存时(更新或者添加都行),自动将该字段的值设置为当前时间.通常用于表示 "last-modified" 时间戳.
        auto_now_add    当对象首次被创建时,自动将该字段的值设置为当前时间.通常用于表示对象创建时间.
        （仅仅在admin中有意义...)
 
<9> DateTimeField
         一个日期时间字段. 类似 DateField 支持同样的附加选项.
 
<10> ImageField
        类似 FileField, 不过要校验上传对象是否是一个合法图片.#它有两个可选参数:height_field和width_field,
        如果提供这两个参数,则图片将按提供的高度和宽度规格保存.    
<11> FileField
     一个文件上传字段.
     要求一个必须有的参数: upload_to, 一个用于保存上载文件的本地文件系统路径. 这个路径必须包含 strftime #formatting,
     该格式将被上载文件的 date/time
     替换(so that uploaded files don't fill up the given directory).
     admin 用一个<input type="file">部件表示该字段保存的数据(一个文件上传部件) .
 
     注意：在一个 model 中使用 FileField 或 ImageField 需要以下步骤:
            （1）在你的 settings 文件中, 定义一个完整路径给 MEDIA_ROOT 以便让 Django在此处保存上传文件.
            (出于性能考虑,这些文件并不保存到数据库.) 定义MEDIA_URL 作为该目录的公共 URL. 要确保该目录对
             WEB服务器用户帐号是可写的.
            （2） 在你的 model 中添加 FileField 或 ImageField, 并确保定义了 upload_to 选项,以告诉 Django
             使用 MEDIA_ROOT 的哪个子目录保存上传文件.你的数据库中要保存的只是文件的路径(相对于 MEDIA_ROOT).
             出于习惯你一定很想使用 Django 提供的 get_<#fieldname>_url 函数.举例来说,如果你的 ImageField
             叫作 mug_shot, 你就可以在模板中以 {{ object.#get_mug_shot_url }} 这样的方式得到图像的绝对路径.
 
<12> URLField
      用于保存 URL. 若 verify_exists 参数为 True (默认), 给定的 URL 会预先检查是否存在( 即URL是否被有效装入且
      没有返回404响应).
      admin 用一个 <input type="text"> 文本框表示该字段保存的数据(一个单行编辑框)
 
<13> NullBooleanField
       类似 BooleanField, 不过允许 NULL 作为其中一个选项. 推荐使用这个字段而不要用 BooleanField 加 null=True 选项
       admin 用一个选择框 <select> (三个可选择的值: "Unknown", "Yes" 和 "No" ) 来表示这种字段数据.
 
<14> SlugField
       "Slug" 是一个报纸术语. slug 是某个东西的小小标记(短签), 只包含字母,数字,下划线和连字符.#它们通常用于URLs
       若你使用 Django 开发版本,你可以指定 maxlength. 若 maxlength 未指定, Django 会使用默认长度: 50.  #在
       以前的 Django 版本,没有任何办法改变50 这个长度.
       这暗示了 db_index=True.
       它接受一个额外的参数: prepopulate_from, which is a list of fields from which to auto-#populate
       the slug, via JavaScript,in the object's admin form: models.SlugField
       (prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields.
 
<13> XMLField
        一个校验值是否为合法XML的 TextField,必须提供参数: schema_path, 它是一个用来校验文本的 RelaxNG schema #的文件系统路径.
 
<14> FilePathField
        可选项目为某个特定目录下的文件名. 支持三个特殊的参数, 其中第一个是必须提供的.
        参数    描述
        path    必需参数. 一个目录的绝对文件系统路径. FilePathField 据此得到可选项目.
        Example: "/home/images".
        match    可选参数. 一个正则表达式, 作为一个字符串, FilePathField 将使用它过滤文件名. 
        注意这个正则表达式只会应用到 base filename 而不是
        路径全名. Example: "foo.*\.txt^", 将匹配文件 foo23.txt 却不匹配 bar.txt 或 foo23.gif.
        recursive可选参数.要么 True 要么 False. 默认值是 False. 是否包括 path 下面的全部子目录.
        这三个参数可以同时使用.
        match 仅应用于 base filename, 而不是路径全名. 那么,这个例子:
        FilePathField(path="/home/images", match="foo.*", recursive=True)
        ...会匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif
 
<15> IPAddressField
        一个字符串形式的 IP 地址, (i.e. "24.124.1.30").
<16> CommaSeparatedIntegerField
        用于存放逗号分隔的整数值. 类似 CharField, 必须要有maxlength参数.
'''

更多参数：

(1)null
 
如果为True，Django 将用NULL 来在数据库中存储空值。 默认值是 False.
 
(1)blank
 
如果为True，该字段允许不填。默认为False。
要注意，这与 null 不同。null纯粹是数据库范畴的，而 blank 是数据验证范畴的。
如果一个字段的blank=True，表单的验证将允许该字段是空值。如果字段的blank=False，该字段就是必填的。

(2)default
 
字段的默认值。可以是一个值或者可调用对象。如果可调用 ，每有新对象被创建它都会被调用，如果你的字段没有设置可以为空，那么将来如果我们后添加一个字段，这个字段就要给一个default值
 
(3)primary_key
 
如果为True，那么这个字段就是模型的主键。如果你没有指定任何一个字段的primary_key=True，
Django 就会自动添加一个IntegerField字段做为主键，所以除非你想覆盖默认的主键行为，
否则没必要设置任何一个字段的primary_key=True。
 
(4)unique
 
如果该值设置为 True, 这个数据字段的值在整张表中必须是唯一的
 
(5)choices
由二元组组成的一个可迭代对象（例如，列表或元组），用来给字段提供选择项。 如果设置了choices ，默认的表单将是一个选择框而不是标准的文本框，<br>而且这个选择框的选项就是choices 中的选项。
(6)db_index
　　如果db_index=True 则代表着为此字段设置数据库索引。


DatetimeField、DateField、TimeField这个三个时间字段，都可以设置如下属性。

(7)auto_now_add
    配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。

(8)auto_now
    配置上auto_now=True，每次更新数据记录的时候会更新该字段，标识这条记录最后一次的修改时间。

关于auto_now，你需要知道的事情：

当需要更新时间的时候，我们尽量通过datetime模块来创建当前时间，并保存或者更新到数据库里面，看下面的分析：
假如我们的表结构是这样的

class User(models.Model):
    username = models.CharField(max_length=255, unique=True, verbose_name='用户名')
    is_active = models.BooleanField(default=False, verbose_name='激活状态')

那么我们修改用户名和状态可以使用如下两种方法：

方法一：

User.objects.filter(id=1).update(username='nick',is_active=True)

方法二：

_t = User.objects.get(id=1)
_t.username='nick'
_t.is_active=True
_t.save()

方法一适合更新一批数据，类似于mysql语句update user set username='nick' where id = 1

方法二适合更新一条数据，也只能更新一条数据，当只有一条数据更新时推荐使用此方法，另外此方法还有一个好处，我们接着往下看

具有auto_now属性字段的更新
我们通常会给表添加三个默认字段 
- 自增ID，这个django已经默认加了，就像上边的建表语句，虽然只写了username和is_active两个字段，但表建好后也会有一个默认的自增id字段 
- 创建时间，用来标识这条记录的创建时间，具有auto_now_add属性，创建记录时会自动填充当前时间到此字段 
- 修改时间，用来标识这条记录最后一次的修改时间，具有auto_now属性，当记录发生变化时填充当前时间到此字段

就像下边这样的表结构

class User(models.Model):
    create_time = models.DateTimeField(auto_now_add=True, verbose_name='创建时间')
    update_time = models.DateTimeField(auto_now=True, verbose_name='更新时间')
    username = models.CharField(max_length=255, unique=True, verbose_name='用户名')
    is_active = models.BooleanField(default=False, verbose_name='激活状态')

当表有字段具有auto_now属性且你希望他能自动更新时，必须使用上边方法二的更新，不然auto_now字段不会更新，也就是：

_t = User.objects.get(id=1)
_t.username='nick'
_t.is_active=True
_t.save()

json/dict类型数据更新字段
目前主流的web开放方式都讲究前后端分离，分离之后前后端交互的数据格式大都用通用的jason型，那么如何用最少的代码方便的更新json格式数据到数据库呢？同样可以使用如下两种方法：

方法一：

data = {'username':'nick','is_active':'0'}
User.objects.filter(id=1).update(**data)

同样这种方法不能自动更新具有auto_now属性字段的值
通常我们再变量前加一个星号(*)表示这个变量是元组/列表，加两个星号表示这个参数是字典
方法二：

data = {'username':'nick','is_active':'0'}
_t = User.objects.get(id=1)
_t.__dict__.update(**data)
_t.save()

方法二和方法一同样无法自动更新auto_now字段的值
注意这里使用到了一个__dict__方法
方法三：

_t = User.objects.get(id=1)
_t.role=Role.objects.get(id=3)
_t.save()

#想让auto_now更新数据时自动更新时间，必须使用save方法来更新数据，所以很不方便，所以这个创建时自动添加时间或者更新时间的auto_now方法我们最好就别用了，比较恶心，并且支持我们自己来给这个字段更新时间：
models.py:
class Book(models.Model):
    name = models.CharField(max_length=32)
    date1 = models.DateTimeField(auto_now=True,null=True)
    date2 = models.DateTimeField(auto_now_add=True,null=True)

views.py:
        import datetime
        models.Book.objects.filter(id=1).update(
            name='chao',
            date1=datetime.datetime.now(),
            date2=datetime.datetime.now(),
        )

关于auto_now和auto_now_add

View Code

ORM字段与实际的mysql字段对应关系

'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',

2. 增：添加表记录

首先我们先要做一个简单的流程，方便我们测试：

#url:

urlpatterns = [

    url(r'^index/', views.index),
]

# views:

def index(request):

    return render(request,'index.html')

# html:
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap 101 Template</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">


</head>
<body>
<h1>欢迎访问index页面</h1>


</body>
</html>

然后我们通过在index函数中构建一些逻辑，展示我们对单表的增删改查。在研究增删改查之前我们一定要明确ORM的对应关系：

在python中orm的对应关系有三种：

　　　　类 ----------> 表

　　　　类的对象 ----------> 行(记录)

　　　　类的属性 ----------> 表的字段（重点）

我们要想操作一行的数据，就应该将相应的类引入，然后通过实例化对象增加数据。接下来，我们重新创建一个数据库为orm01，创建一个student表结构，从这个表中去研究单表的操作。

这里需要注意：

1. 更改settings里面的数据库配置：orm01.

2. 在models文件中创建student类：

class Student(models.Model):

    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    age = models.IntegerField()

3. 生成记录并且创建表结构

python manage.py makemigrations

python manage.py migrate

接下来我们就开始研究如何增加表记录。

方式1

从index函数中操作：

def index(request):
    # 实例化一个对象这就是一条记录
    student_obj = models.Student(
        name='王阔',
        age=18
    )
    # 将此记录增加到数据表中
    student_obj.save()
    return render(request,'index.html')

查看数据表：我们添加成功了。

方式2

我们通过方式1给student表中添加了一条表记录，但是上面那种方法不灵活，接下来我们介绍一种更加灵活的方法。

models.Student.objects

objects比较特殊，我们称它为类对应的控制器，这个控制器对象可以调用数据表相应的增删改查等方法，非常灵活。

models.Student.objects.create(
        name='傻强',
        age=20
    )

这样以来我们就添加成功了：

而且我们通过查询create方法的源码可以得知：

Creates a new object with the given kwargs, saving it to the database and returning the created object.

他可以创建一个新的对象保存到相应的数据表中，并且返回这个新创建的对象。那么接下来我们查看一下他的返回值并输入一下：

这样它既向我们的数据表中添加了值，又将创建的对象返回了：

new_obj = models.Student.objects.create(
        name='志远',
        age=19
    )
print(new_obj)  # Student object
print(new_obj.name)  # 志远

那么，以后我们就将这中（models类的对象）称之为model对象。（很重要一定要记住）

方式3：批量创建

我们以后工作中肯定会让你批量插入很多数据，怎么解决？有同学肯定会说循环create，但是每次create都需要操作数据库，这是一个IO操作，如果这样的话数据量越大，你的效率越低。所以针对这种情况我们可以通过批量创建。

假如我们依次插入20条数据：

obj_list = [models.Student(name=f'乔妹儿{i}', age=20) for i in range(1, 21)]
models.Student.objects.bulk_create(obj_list)

方式4:更新或增加

orm还有一种方法是对一条表记录进行更新或者增加的操作：有则更新无则增加，类似于字典的这个操作dic['name'] = 'barry'。

models.Student.objects.update_or_create(
        name='乔妹儿1',  # 筛选条件
        defaults={  # 需要更新或者增加的值
            'age': 1000,
        }

    )

3. 简单的查询

本来我们应该研究删除表记录，但是我们这里先要研究几个简单的查询，因为这些查询返回两种特殊的对象，对于不同的对象他们的删、改的的方法不同。

1.all()全部取出

通过all从orm取出来的是一个QuerySet类型，这里面有很多个Student类的对象也就是model对象，这个QuerySet类似于列表，但是不同与列表，后面我们会详细对比讨论，在这里我们知道可以循环遍历取值即可。

index函数： 
all_objs = models.Student.objects.all()
    print(all_objs)  # QuerySet类型 这里面有很多个Student类的对象也就是model对象。
    '''
    < QuerySet[ < Student: Student
    object >, < Student: Student
    object >, < Student: Student
    object >,...'...(remaining elements truncated)...']>
    '''
    # 通过遍历可以获取每个对象的name属性
    for i in all_objs:
        print(i.name)

model对象与queryset集合是我们经常用的两个对象，一定要分清楚。

上面我们for循环遍历时，每次都需要.name获取name属性，比较麻烦，我们可以不可以直接打印对象获取对应的姓名呢？这就要想到特殊的双下方法__str__.我们可以在Student类中定一个__str__方法，这样以后我们就可以用于调试了。

class Student(models.Model):

    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    age = models.IntegerField()

    def __str__(self):
        return self.name

2.filter(条件) 条件查询

通过条件查询获取结果，返回的也是QuerySet类型，如果查询不到内容不会报错，返回一个空的QuerySet集合。

objs = models.Student.objects.filter(age=20)
print(objs)
'''
<QuerySet [<Student: 傻强>, <Student: 乔妹儿2>, <Student: 乔妹儿3>, <Student: 乔妹儿4>, <Student: 乔妹儿5>, <Student: 乔妹儿6>, <Student: 乔妹儿7>, <Student: 乔妹儿8>, <Student: 乔妹儿9>, <Student: 乔妹儿10>, <Student: 乔妹儿11>, <Student: 乔妹儿12>, <Student: 乔妹儿13>, <Student: 乔妹儿14>, <Student: 乔妹儿15>, <Student: 乔妹儿16>, <Student: 乔妹儿17>, <Student: 乔妹儿18>, <Student: 乔妹儿19>, <Student: 乔妹儿20>]>
'''
objs = models.Student.objects.filter(id=2)
print(objs)  # <QuerySet [<Student: 傻强>]>
print(objs[0].id)  # 2 可以通过索引取值

objs = models.Student.objects.filter(name='太白')
print(objs) # <QuerySet []>

3.get(条件) 条件查询

这个get比较特殊，它返回的是model对象，通过get条件查询，查询的结果有且只有1个。

　　如果超过一个则报错为：get() returned more than one Student -- it returned 2(有几个显示几个)!

　　如果没有则报错为：Student matching query does not exist.

# obj = models.Student.objects.get(name='太白')  # 报错：Student matching query does not exist.
# obj = models.Student.objects.get(age=20)  # get() returned more than one Student -- it returned 20!
obj = models.Student.objects.get(id=1)
print(obj)  # model对象

所以一般如果我们使用get条件查询，前提一定要确定你的条件锁定的就是一条行记录。

4. 删：删除行记录

删除就要从你的对象性质来讨论了。

1. 调用model对象删除

这样就是删除单条记录

models.Student.objects.get(id=20).delete()

2.调用QuerySet集合删除

这样就是批量删除记录，满足条件的记录都会被删除。

models.Student.objects.filter(age=20).delete()

　　(等学到外键的时候再说) 在 Django 删除对象时，会模仿 SQL 约束 ON DELETE CASCADE 的行为，换句话说，删除一个对象时也会删除与它相关联的外键对象。例如：　

b = Blog.objects.get(pk=1)
# This will delete the Blog and all of its Entry objects.
b.delete()

　　要注意的是： delete() 方法是 QuerySet 上的方法，但并不适用于 Manager 本身。这是一种保护机制，是为了避免意外地调用 Entry.objects.delete() 方法导致所有的记录被误删除。如果你确认要删除所有的对象，那么你必须显式地调用：

Entry.objects.all().delete()

　　如果不想级联删除，可以设置为:

    
pubHouse = models.ForeignKey(to='Publisher', on_delete=models.SET_NULL, blank=True, null=True)

5.改：更新行记录

更新记录的方法只有一个就是update，此方法只能用于QuerySet集合，model对象是不可以使用的。也就是说update可以进行批量更新的操作，并且他会返回一个更新的行记录数量的返回值。

# 我先增加了一条name一样的行记录 
'''
# models.Student.objects.create(
       name='乔妹儿1',
       age=100    )

'''

count = models.Student.objects.filter(name='乔妹儿1').update(age=20)
print(count)  # 2 更新了2条

6.查：查看(获取)行记录

查询是数据库增删改查的重中之重，方法非常多，大家一定要好好练习。前三个我们都练习过了可以在练习一遍。

1.all()全部取出

通过object控制器调用，返回QuerySet类型。

index函数： 
all_objs = models.Student.objects.all()
    print(all_objs)  # QuerySet类型 这里面有很多个Student类的对象也就是model对象。
    '''
    < QuerySet[ < Student: Student
    object >, < Student: Student
    object >, < Student: Student
    object >,...'...(remaining elements truncated)...']>
    '''
    # 通过遍历可以获取每个对象的name属性
    for i in all_objs:
        print(i.name)

model对象与queryset集合是我们经常用的两个对象，一定要分清楚。

2.filter(条件) 条件查询

通过object控制器调用，返回QuerySet类型。

通过条件查询获取结果，返回的也是QuerySet类型，如果查询不到内容不会报错，返回一个空的QuerySet集合。

objs = models.Student.objects.filter(age=20)
print(objs)
'''
<QuerySet [<Student: 傻强>, <Student: 乔妹儿2>, <Student: 乔妹儿3>, <Student: 乔妹儿4>, <Student: 乔妹儿5>, <Student: 乔妹儿6>, <Student: 乔妹儿7>, <Student: 乔妹儿8>, <Student: 乔妹儿9>, <Student: 乔妹儿10>, <Student: 乔妹儿11>, <Student: 乔妹儿12>, <Student: 乔妹儿13>, <Student: 乔妹儿14>, <Student: 乔妹儿15>, <Student: 乔妹儿16>, <Student: 乔妹儿17>, <Student: 乔妹儿18>, <Student: 乔妹儿19>, <Student: 乔妹儿20>]>
'''
objs = models.Student.objects.filter(id=2)
print(objs)  # <QuerySet [<Student: 傻强>]>
print(objs[0].id)  # 2 可以通过索引取值

objs = models.Student.objects.filter(name='太白')
print(objs) # <QuerySet []>

还可以进行多条件查询：

# 先插入一些数据：
'''
    models.Student.objects.create(
        name='董伟华',
        age=19
    )
    models.Student.objects.create(
        name='周泽波',
        age=21
    )
    models.Student.objects.create(
        name='健身哥',
        age=18
    )
    models.Student.objects.create(
        name='张雨薇',
        age=20
    )
    models.Student.objects.create(
        name='王天琪',
        age=21
    )
    models.Student.objects.create(
        name='梁晨',
        age=18
    )
    models.Student.objects.create(
        name='扛把子',
        age=22
    )
    models.Student.objects.create(
        name='齐佳乐',
        age=20
    )
    '''
    objs = models.Student.objects.filter(name='健身哥', age=18)
    print(objs)  # <QuerySet [<Student: 健身哥>]>

还可以通过打散字典的形式进行筛选

models.Student.objects.filter(**{'id':27,'name':'健身哥','age':18}).update(age=20)

注意：

　　1. 一定要记住每个方法是通过哪种类型调用，以及返回哪种类型。这样我们方便可以通过链式点的操作进行复杂查询。

　　2. filter一种是关键字形式，一个是字符串形式，很重要，这两个就可以解决不同的需求了。

3.get(条件) 条件查询

通过object控制器调用，返回model对象

这个get比较特殊，它返回的是model对象，通过get条件查询，查询的结果有且只有1个。

　　如果超过一个则报错为：get() returned more than one Student -- it returned 2(有几个显示几个)!

　　如果没有则报错为：Student matching query does not exist.

# obj = models.Student.objects.get(name='太白')  # 报错：Student matching query does not exist.
# obj = models.Student.objects.get(age=20)  # get() returned more than one Student -- it returned 20!
obj = models.Student.objects.get(id=1)
print(obj)  # model对象

所以一般如果我们使用get条件查询，前提一定要确定你的条件锁定的就是一条行记录。

4.exclude排除

通过object对象或者QuerySet集合调用，返回QuserySet集合。

下面我们演示了上面说到的链式点操作，可以一直进行点的操作，因为此方法可以QuerySet集合调用，并且返回的还是QuerySet集合。

objs = models.Student.objects.exclude(id=1)
print(objs)

# 排除id为1的行记录，将剩下所有的返回

objs = models.Student.objects.filter(age=20).exclude(name='齐佳乐')
print(objs)  # <QuerySet [<Student: 乔妹儿1>, <Student: 乔妹儿1>, <Student: 健身哥>, <Student: 张雨薇>]>
objs = models.Student.objects.filter(age=20).exclude(name='齐佳乐').exclude(name='健身哥')
print(objs)  # <QuerySet [<Student: 乔妹儿1>, <Student: 乔妹儿1>,  <Student: 张雨薇>]>

5.order_by排序

通过object对象或者QuerySet集合调用，返回QuserySet集合。

# object对象调用
objs = models.Student.objects.order_by('age')  # 通过姓名升序排列
print(objs)

# queryset集合调用
objs = models.Student.objects.all().order_by('age')  # 通过姓名升序排列
print(objs)

通过年龄升序排列,相同年龄的按照id降序排列：

objs = models.Student.objects.all().order_by('age', '-id')
print(objs)

打印结果：
<QuerySet [<Student: id:30 name:梁晨 age:18>, <Student: id:1 name:王阔 age:18>, <Student: id:25 name:董伟华 age:19>, <Student: id:3 name:志远 age:19>, <Student: id:32 name:齐佳乐 age:20>, <Student: id:28 name:张雨薇 age:20>, <Student: id:27 name:健身哥 age:20>, <Student: id:24 name:乔妹儿1 age:20>, <Student: id:4 name:乔妹儿1 age:20>, <Student: id:29 name:王天琪 age:21>, <Student: id:26 name:周泽波 age:21>, <Student: id:31 name:扛把子 age:22>]>

6.reverse反转

通过order_by返回的QuerySet集合调用，返回一个QuerySet集合。

objs = models.Student.objects.reverse()
print(objs)  # 这样没有作用，all filter等都没有作用
objs = models.Student.objects.order_by('id').reverse()  # 只能通过order_by返回的QuerySet集合调用
print(objs)

7.count计数

通过QuerySet集合调用，返回一个元素个数。

num = models.Student.objects.all().count()
print(num)  # 12
num = models.Student.objects.filter(age=20).count()
print(num)  # 5

8.first返回第一个model对象

通过QuerySet集合调用，返回第一个model对象

obj = models.Student.objects.filter(age=20).first()
print(obj)

9.last返回最后一个model对象

通过QuerySet集合调用，返回最后一个model对象

obj = models.Student.objects.filter(age=20).last()
print(obj)

10.exists判断是否存在

通过QuerySet集合调用，返回bool值

flag = models.Student.objects.filter(age=25).exists()
print(flag)  # False

这里我们要说一句，他的效率是高的，尤其是作为if判断的条件。

# 虽然说你可以通过下面的方式判断，但是如果这个集合一下取出上百万条数据，那么你的效率就很低的，而exists翻译成sql语句是limit=1，也就是说它只看第一个对象存不存在就返回bool值了。
if Queryset集合：
    pass

我们也可以通过配置settings，每次执行orm语句时都将相应的sql语句展示出来，这样可以查看一下exists().

settings配置：

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

再次执行一次：

11.values_list

通过QuerySet集合调用，返回一个QuerySet集合

但是这个QuerySet集合比较特殊，这个里面的元素不是model对象，而是元组的形式。

query_tuple = models.Student.objects.filter(age=20).values_list()
print(query_tuple)
# <QuerySet [(4, '乔妹儿1', 20), (24, '乔妹儿1', 20), (27, '健身哥', 20), (28, '张雨薇', 20), (32, '齐佳乐', 20)]>
query_tuple = models.Student.objects.filter(age=20).values_list().exclude(name='齐佳乐')
print(query_tuple)
# < QuerySet[(4, '乔妹儿1', 20), (24, '乔妹儿1', 20), (27, '健身哥', 20), (28, '张雨薇', 20)] >

还可以指定想获取的字段：

query_tuple = models.Student.objects.filter(age=20).values_list('name','age')
print(query_tuple)
# <QuerySet [('乔妹儿1', 20), ('乔妹儿1', 20), ('健身哥', 20), ('张雨薇', 20), ('齐佳乐', 20)]>

12.values

通过QuerySet集合调用，返回一个QuerySet集合

但是这个QuerySet集合比较特殊，这个里面的元素不是model对象，而是字典的形式。

query_dict = models.Student.objects.filter(age=19).values()
print(query_dict)  # <QuerySet [{'id': 3, 'name': '志远', 'age': 19}, {'id': 25, 'name': '董伟华', 'age': 19}]>
query_dict = models.Student.objects.filter(age=19).values('name', 'age')
print(query_dict)  # <QuerySet [{'name': '志远', 'age': 19}, {'name': '董伟华', 'age': 19}]>

13.distinct去重

通过QuerySet集合调用，返回一个QuerySet集合

这里要注意一点：无论是all还是filter 你对整个对象去重是没有意义的，只要有一个字段不同，都不是重复的。

query_objs = models.Student.objects.filter(age=20).distinct()
print(query_objs)
# <QuerySet [<Student: id:4 name:乔妹儿1 age:20>, <Student: id:24 name:乔妹儿1 age:20>, <Student: id:27 name:健身哥 age:20>, <Student: id:28 name:张雨薇 age:20>, <Student: id:32 name:齐佳乐 age:20>]>

所以这个去重一般都用于values或者values_list。

query_objs = models.Student.objects.filter(age=20).values('age').distinct()
print(query_objs) # <QuerySet [{'age': 20}]>

14.基于双下划线的模糊查询

我们在使用filter方法时，一直在使用 = 条件，但是没有使用过> < >=等条件，这是因为ORM不支持这种写法，不用着急，我们可以根据另一种写法去实现。

query_objs = models.Student.objects.filter(age__gt=19)  # 大于
query_objs = models.Student.objects.filter(age__gte=19)  # 大于等于
query_objs = models.Student.objects.filter(age__lt=20)  # 小于
query_objs = models.Student.objects.filter(age__lte=20)  # 小于等于
query_objs = models.Student.objects.filter(age__range=[18, 20])  # 范围 左右都包含
query_objs = models.Student.objects.filter(name__contains='xiao')  # 针对字符串类型，内容含有
query_objs = models.Student.objects.filter(name__icontains='xiao')  # 针对字符串类型，内容含有 不区分大小写
query_objs = models.Student.objects.filter(name__startswith='x')  # 匹配以x开头
query_objs = models.Student.objects.filter(name__istartswith='x')  # 匹配以x开头，不区分大小写
query_objs = models.Student.objects.filter(name__endswith='o')  # 匹配以x结尾
query_objs = models.Student.objects.filter(name__iendswith='o')  # 匹配以x结尾，不区分大小写

15.日期

日期这个字段查询起来比较特殊，我们单独拿出来讲解，现在我们要重新创建一个表。

class Birthday(models.Model):

    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    date = models.DateField()

    def __str__(self):
        return self.name

别忘了生成记录以及创建到数据库中。

查看一下表结构：

注意date字段，这个字段要求的是date类型，我们如果存放的是datetime类型也是可以的，只不过只是显示年月日。

接下来我们给表中插入一些数据：

import datetime

    models.Birthday.objects.create(name='太白1', date=datetime.datetime.now())
    models.Birthday.objects.create(name='太白2', date='2000-04-25')
    models.Birthday.objects.create(name='太白3', date='2000-06-25')
    models.Birthday.objects.create(name='太白4', date='2000-08-26')
    models.Birthday.objects.create(name='太白5', date='2000-12-28')
    models.Birthday.objects.create(name='太白6', date='2001-03-26')
    models.Birthday.objects.create(name='太白7', date='2001-08-30')
    models.Birthday.objects.create(name='太白8', date='2003-01-13')
    models.Birthday.objects.create(name='太白9', date='2005-10-01')

对应的数据库的数据为：

查询2000年出生的人，这样写就会报错了：

 query_objs = models.Birthday.objects.filter(date='2000')
 print(query_objs)  
 # "'2000' value has an invalid date format. It must be in YYYY-MM-DD format."]

查询2000年出生的人：

query_objs = models.Birthday.objects.filter(date__year='2000')
print(query_objs)  # <QuerySet [<Birthday: 太白2>, <Birthday: 太白3>, <Birthday: 太白4>, <Birthday: 太白5>]>

查询2000年4月出生的人：

query_objs = models.Birthday.objects.filter(date__year='2000',date__month='04')
print(query_objs)  # <QuerySet [<Birthday: 太白2>]>

查询2000年大于4月小于12月出生的人：

query_objs = models.Birthday.objects.filter(date__year='2000', date__month__gt='04',date__month__lt='12')
print(query_objs)  # <QuerySet [<Birthday: 太白3>, <Birthday: 太白4>]>

posted @ 2020-02-27 15:54 太白*金星阅读(3036) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

太白金星

Django基础之：ORM系统 单表操作

一. ORM简介

1. web开发的分工模式

2. ORM

二、单表操作

1.创建表

1. 首先我们先创建一个ORM项目

2. 通过类创建数据表

3. 在对应的数据库中生成表结构

4. 小型数据库sqlite3

5. 配置MySAL数据库

6.更多的字段和参数

2. 增：添加表记录

方式1

方式2

方式3：批量创建

方式4:更新或增加

3. 简单的查询

1.all()全部取出

2.filter(条件) 条件查询

3.get(条件) 条件查询

4. 删：删除行记录

1. 调用model对象删除

2.调用QuerySet集合删除

5.改：更新行记录

6.查：查看(获取)行记录

1.all()全部取出

2.filter(条件) 条件查询

3.get(条件) 条件查询

4.exclude排除

5.order_by排序

6.reverse反转

7.count计数

8.first返回第一个model对象

9.last返回最后一个model对象

10.exists判断是否存在

11.values_list

12.values

13.distinct去重

14.基于双下划线的模糊查询

15.日期

公告

Django基础之：ORM系统单表操作