python django基础四 ORM简介

ORM，全称是object relation mapping。翻译过来，就是对象关系映射。

主要来学习MySQL操作，MySQL是一个软件。它的优点：1.免费 2.开源

pymysql，就是Mysql给Python提供的接口。早期的接口叫mysqldb

ORM可以实现不写sql语句，就可以实现操作数据库。

核心是：用python类操作表，用对象操作记录。

ORM把相应的类和属性操作，转换为sql语句，来操作数据库。它做了一个翻译的过程！

ORM的优点：

不需要自己写SQL，对于类的操作，会转换成相应的SQL语句，来操作数据库。(核心功能)

它不属于硬编码，它不针对于MySQL。比如公司发展了，需要换成oracle数据库。

ORM的缺点：

它有一个翻译的过程。所以不如直接写SQL操作的执行效率低。

上图有一个错误，类型是date，不是data。

sql中的表

create table employee(

id int primary key auto_increment,

name varchar(20),

gander bit default 1,

birthday date,

salary decimal(8,2) unsigned,

departement varchar(20)

)

#decimal[(m[,d])] [unsigned] [zerofill]

#参数解释：准确的小数值，M是整数部分总个数（负号不算），D是小数点后个数。 M最大值为65，D最大值为30。

UNSIGNED #无符号

#添加一条表记录

insert employee (name,gender,birthday,salary,department) values ('alex',1,'1996-12-12',8000,'保洁部');

#查询一条表记录

select * from employee where age=24;

#更新一条表记录

update employee set birthday='1995-12-12' where id=1;

#删除一条表记录

delete from employee where name='alex'

python 类创建方法

#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()

     #第二种:
     book_obj=Employee.objects.create(name="alex",gender=True,birthday="1985-12-12",epartment="保洁部")

 #查询一条表纪录: Employee.objects.filter(age=24)
 #更新一条表纪录: Employee.objects.filter(id=1).update(birthday="1989-10-24")
 #删除一条表纪录: Employee.objects.filter(name="alex").delete()

objects：表示管理器。
Book.objects：表示管理book表。
book.objects.create：表示增加操作。

QuerySet和model对象的区别:

只有model对象，才能调用属性。
queryset不能直接调用属性，因为它是一个列表。

单表操作

在app01下的models.py中创建模型：

class Book(models.Model):

     id=models.AutoField(primary_key=True)

     title=models.CharField(max_length=32)

     state=models.BooleanField()

     pub_date=models.DateField()

     price=models.DecimalField(max_digits=8,decimal_places=2)

     publish=models.CharField(max_length=32)

ORM没法创建数据库，它只能操作表！
类名，首先字母要大写，它必须继承models.Model。这是固定写法！

settings配置

修改mysite下的settings.py文件里面的INSTALLED_APPS。注册你的app，最后一行添加

INSTALLED_APPS = [

    'django.contrib.admin',

    'django.contrib.auth',

    'django.contrib.contenttypes',

    'django.contrib.sessions',

    'django.contrib.messages',

    'django.contrib.staticfiles',

    'app01',

]

不注册它，你的数据库就不知道该给哪个app创建表。

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

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql',   # 数据库引擎mysql

        'NAME': 'book',       # 你要存储数据的库名，事先要创建之

        'USER': 'root',      # 数据库用户名

        'PASSWORD': '',      # 密码

        'HOST': 'localhost', # 主机

        'PORT': '',      # 数据库使用的端口

    }

}

mysql> create database test

django连接MySQL，使用的是pymysql模块，必须得安装2个模块。否则后面会创建表不成功！或者提示no module named MySQLdb

pip3 install pymysql

pip3 install mysqlclient

我们只需要找到app01(应用名)文件下的__init__,在里面写入：

import pymysql

pymysql.install_as_MySQLdb()

接下来要在pycharm的teminal中通过命令创建数据库的表了。有2条命令，分别是：

python manage.py makemigrations

#它的作用相当于 在该app下建立 migrations目录，并记录下你所有的关于modes.py的改动，比如0001_initial.py， 但是这个改动还没有作用到数据库文件

python manage.py migrate

#它是将该改动作用到数据库文件，比如创建表，修改表字段之类的操作。

注意: 如果想打印orm转换过程中的sql，需要在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',

        },

    }

}

删除数据库test

mysql> drop database test;

Query OK, 11 rows affected (0.13 sec)

mysql> create database test;

Query OK, 1 row affected (0.00 sec)

删除app01目录下的migrations文件夹不能随便删除误删搞别人的也行

python manage.py makemigrations

D:\python_work_s18\djangotest>python manage.py makemigrations

(0.000) SELECT @@SQL_AUTO_IS_NULL; args=None

(0.000) SELECT VERSION(); args=None

(0.001) SHOW FULL TABLES; args=None

CREATE TABLE `django_migrations` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `app` varchar(255) NOT NULL, `name`

varchar(255) NOT NULL, `applied` datetime(6) NOT NULL); (params None)

(0.048) CREATE TABLE `django_migrations` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `app` varchar(255) NOT NULL,

 `name` varchar(255) NOT NULL, `applied` datetime(6) NOT NULL); args=None

(0.001) SELECT engine FROM information_schema.tables WHERE table_name = 'django_migrations'; args=['django_migrations']

python manage.py migrate

就可以看到 sql 语句

查询API

<1> all():                  查询所有结果

<2> filter(**kwargs):       它包含了与所给筛选条件相匹配的对象

<3> get(**kwargs):          返回与所给筛选条件相匹配的对象，返回结果有且只有一个，

                            如果符合筛选条件的对象超过一个或者没有都会抛出错误。

<4> exclude(**kwargs):      它包含了与所给筛选条件不匹配的对象

<5> order_by(*field):       对查询结果排序

<6> reverse():              对查询结果反向排序

<8> count():                返回数据库中匹配查询(QuerySet)的对象数量。

<9> first():                返回第一条记录

<10> last():                返回最后一条记录

<11> exists():              如果QuerySet包含数据，就返回True，否则返回False

<12> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列

                            model的实例化对象，而是一个可迭代的字典序列

<13> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

<14> distinct():            从返回结果中剔除重复纪录

它返回的是QuerySet数据类型对象，它是django orm 特有的数据类型。

数据格式为：[model对象1，model对象2，model对象3 ...]

#修改urls.py，增加query路径

def query(request):

    ret=Book.objects.all()

    print(ret)

    return HttpResponse('查询成功')

修改views.py，增加query视图函数

def query(request):

    ret = Book.objects.all()

    print(ret)

    return HttpResponse("查询成功")

访问页面，效果如下：

queryset不能直接调用属性，因为它是一个列表。

既然是列表，就可以使用for循环，打印title属性。

all查询所有结果

def query(request):

    ret=Book.objects.all()

    print(ret)

    for i in ret:

        print(i.title)

    return HttpResponse('查询成功')

控制台输出书名

python葵花宝典
西游记

filter(**kwargs): 它包含了与所给筛选条件相匹配的对象

修改query视图函数

def query(request):

    ret = Book.objects.filter(title='北京折叠')#如果多个内容一样 会返回相同条数

    print(ret)

for i in res:
    print(i.price)

return HttpResponse("查询成功")

def query(request):

    ret = Book.objects.filter(title='北京折叠')

    print(ret)

    return HttpResponse("查询成功")

虽然可以通过切片来调用属性，但是不推荐使用。
因为它的长度是不固定的。

需要使用for循环来执行。

first(): 返回第一条记录

first用来取一条记录，如果返回结果有多条，只会取第一条。

它的返回结果是model对象。

修改query视图函数

def query(request):

    obj = Book.objects.all().first()

    print(obj.title)

    return HttpResponse("查询成功")

查看sql，发现它使用order by排序。对主键nid，做了升序，并且使用limit 1返回一条结果。

ret的返回结果一个是model对象，那么就可以直接调用对象了。所以输出：北京折叠

last(): 返回最后一条记录

last用来取最后一条记录，如果返回结果有多条，只会取最后一条。

它的返回结果是model对象。可以直接调用属性！

def query(request):

    obj = Book.objects.all().last()

    print(obj)

    print(obj.title)

    return HttpResponse("查询成功")

查看sql，发现它使用order by排序。对主键nid，做了降序，并且使用limit 1返回一条结果。

所以最后输出：放风筝的人3

还可以对all()进行切片操作

def query(request):

    obj = Book.objects.all()[1:3]

    print(obj)

    for i in obj:

        print(i.title)

    return HttpResponse("查询成功")

[1:3]，返回2条记录。切片原则：顾头不顾尾。

get(**kwargs): 返回与所给筛选条件相匹配的对象

def query(request):

    obj = Book.objects.get(nid=2)

    print(obj)

    print(obj.title)

    return HttpResponse("查询成功")

查看sql，发现它对应的where条件是nid = 2。返回结果的title属性为：放风筝的人

但是使用first，它会执行order by

总结：

使用get有且只有一个结果时才有意义。

推荐使用get时，利用主键查询，因为主键是唯一的。

exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象

def query(request):

    obj = Book.objects.exclude(price=100)

    print(obj)

    for i in obj:

        print(i.title,i.price)

    return HttpResponse("查询成功")

查看sql，发现它对应的where条件用了Not，返回结果是QuerySet

order_by(*field): 对查询结果排序

order_by，默认是升序，它的返回结果是QuerySet

修改query视图函数

def query(request):

    obj = Book.objects.order_by("price")

    print(obj)

    for i in obj:

        print(i.title,i.price)

    return HttpResponse("查询成功")

每次for循环查看结果，太麻烦了。可以在models.py里面增加一个__str__方法。

修改models.py，增加__str__方法，完整代码如下：

修改models.py，增加__str__方法，完整代码如下：

复制代码

from django.db import models

# Create your models here.

class Book(models.Model):

    nid = models.AutoField(primary_key=True)

    title = models.CharField(max_length=32, unique=True)

    price = models.DecimalField(max_digits=8, decimal_places=2,null=True)

    pub_date = models.DateField()

    publish = models.CharField(max_length=32)

    is_pub = models.BooleanField(default=False)

    def __str__(self):

        return '{}:{}'.format(self.title,self.price)

修改views.py下的query方法，代码如下：

def query(request):

    obj = Book.objects.order_by("price")

    print(obj)

    return HttpResponse("查询成功")

def query(request):

    obj = Book.objects.order_by("price")

    print(obj)

    return HttpResponse("查询成功")

刷新页面，查看控制台输出信息：

(0.001) SELECT `app01_book`.`nid`, `app01_book`.`title`, `app01_book`.`price`, `app01_book`.`pub_date`, `app01_book`.`publish`, `app01_book`.`is_pub` FROM `app01_book` ORDER BY `app01_book`.`price` ASC LIMIT 21; args=()

<QuerySet [<Book: 水浒传:11.00>, <Book: 北京折叠:11.11>, <Book: 放风筝的人:14.11>, <Book: 西游记:233.00>]>

(0.001) SELECT `app01_book`.`nid`, `app01_book`.`title`, `app01_book`.`price`, `app01_book`.`pub_date`, `app01_book`.`publish`, `app01_book`.`is_pub` FROM `app01_book` ORDER BY `app01_book`.`price` ASC LIMIT 21; args=()

<QuerySet [<Book: 水浒传:11.00>, <Book: 北京折叠:11.11>, <Book: 放风筝的人:14.11>, <Book: 西游记:233.00>]>

可以直接看到title和价格！

注意：只有QuerySet数据类型对象，才能调用order_by

reverse(): 对查询结果反向排序

它的返回结果是QuerySet

举例：

修改query方法

def query(request):

    obj = Book.objects.all().order_by("price").reverse()

    print(obj)

    return HttpResponse("查询成功")

它的sql语句用的是desc

count(): 返回数据库中匹配查询的对象数量。

def query(request):

    obj = Book.objects.all().count()

    print(obj)

    return HttpResponse("查询成功")

obj的返回结果为4

exists(): 如果QuerySet包含数据，就返回True，否则返回False

如果数据库有1000万本，all 这样一查，数据库就崩溃了。

def query(request):

    ret = Book.objects.all()

    if ret:

        print('ok')

    return HttpResponse("查询成功")

def query(request):

    ret = Book.objects.all().exists()

    if ret:

        print('ok')

    return HttpResponse("查询成功")

ret结果为ok，它用limit 1。它只查询了一条记录！

即使数据库记录过多，也不影响。这样才是合理的！

values(*field): 返回一个ValueQuerySet

修改query视图函数

def query(request):

    ret = Book.objects.all().values("title")

    print(ret)

    return HttpResponse("查询成功")

刷新页面，查看控制台输出信息：

(0.000) SELECT `app01_book`.`title` FROM `app01_book` LIMIT 21; args=()

<QuerySet [{'title': '北京折叠'}, {'title': '放风筝的人'}, {'title': '水浒传'}, {'title': '西游记'}]>

(0.000) SELECT `app01_book`.`title` FROM `app01_book` LIMIT 21; args=()

<QuerySet [{'title': '北京折叠'}, {'title': '放风筝的人'}, {'title': '水浒传'}, {'title': '西游记'}]>

values返回的是QuerySet，列表的每一个元素都是字典。

values可以接收多个参数，比如

ret = Book.objects.all().values("title","price")

字典的key，就是参数。一个字典，对应一条记录。

跟上面讲的QuerySet区别就在于：

不加values，QuerySet存放的是model对象。

加了values之后，QuerySet存放的是字典。

查询某一个字段时，推荐使用values

values_list(*field): values返回的是一个字典序列

它与values()非常相似，它返回的是一个元组序列

它的返回结果是一个特殊的QuerySet，列表每一个元素都是元组

修改query视图函数

def query(request):

    book_list = Book.objects.all().values_list("title","price","pub_date")

    print(book_list)

    return HttpResponse("查询成功")

刷新页面，查看控制台输出信息：

<QuerySet [('北京折叠', Decimal('11.11'), datetime.date(2012, 12, 12)), ('放风筝的人', Decimal('14.11'), datetime.date(2017, 12, 12)), ('西游记', Decimal('233.00'), datetime.date(2018, 7, 1)), ('水浒传', Decimal('11.00'), datetime.date(2018, 7, 2))]>

values_list和values的区别在于：values_list的类型是元组，vallues是字典。

distinct(): 从返回结果中剔除重复纪录

使用原生sql查询价格，去除重复的值

mysql> select distinct(price) from app01_book;

+--------+

| price  |

+--------+

| 100.00 |

| 233.00 |

|  11.00 |

+--------+

3 rows in set (0.00 sec)

举例：查看所有书籍的价格以及出版社，价格和出版社同时不能重复

修改query视图函数

def query(request):

    ret = Book.objects.all().values("price","publish").distinct()

    print(ret)

    return HttpResponse("查询成功")

刷新页面，查看控制台输出信息：

<QuerySet [{'publish': '苹果出版社', 'price': Decimal('100.00')}, {'publish': '橘子出版社', 'price': Decimal('233.00')}, {'publish': '橘子出版社', 'price': Decimal('11.00')}]>

(0.000) SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; args=None

(0.001) SELECT DISTINCT `app01_book`.`price`, `app01_book`.`publish` FROM `app01_book` LIMIT 21; args=()

发现结果只有3条，它使用了组合去重。2个字段，同时不唯一！

基于双下划线的模糊查询

Book.objects.filter(price__in=[100,200,300])#支持多个选择价格分别等于100 200 300

Book.objects.filter(price__gt=100) #大于

Book.objects.filter(price__lt=100)#小于
Book.objects.filter(price__lte=100)#小于等于
Book.objects.filter(price__gte=100)#大于等于
Book.objects.filter(price__range=[100,200])#2个数值之间的范围
Book.objects.filter(title__contains="python")#是否包含 模糊匹配
Book.objects.filter(title__icontains="python")#不区分大小写
Book.objects.filter(title__startswith="py")#以什么开头的
Book.objects.filter(pub_date__year=2012)#查询某年

删除表纪录

删除方法就是 delete()。它运行时立即删除对象而不返回任何值。例如：

model_obj.delete()

ret = Book.objects.filter(price=100).delete() #删除价格等于100的

ret = Book.objects.filter(price__lte=100).delete()#价格小于100的，并将第一条记录删除

修改delbook视图函数

def delbook(request,id):

    ret = Book.objects.filter(nid=id).delete()

    print(ret)

    print(ret,type(ret))

    if ret[0]:

        return HttpResponse("删除成功")

    else:

        return HttpResponse("删除失败")

再次访问url：http://127.0.0.1:8000/delbook/4

修改表纪录

注意：修改是基于查询的结果来修改的。所以是先有查询，再有修改！

def change(request):

    nid = 1

    ret = Book.objects.filter(nid=nid).update(price=1000)

    print(ret)

    return HttpResponse("修改成功")

def change(request):

    nid = 1

    ret = Book.objects.filter(nid=nid).update(price=1000)

    print(ret)

    return HttpResponse("修改成功")

访问页面

查看控制台输出信息：

(0.001) UPDATE `app01_book` SET `price` = '1000.00' WHERE `app01_book`.`nid` = 1; args=('1000.00', 1)

1

(0.001) UPDATE `app01_book` SET `price` = '1000.00' WHERE `app01_book`.`nid` = 1; args=('1000.00', 1)

1

ret的返回结果为1，表示修改成功！

Book.objects.filter(nid=nid).update(price=133,is_pub=1)#修改西游记的价格为133以及is_pub修改为1