Django模型学习笔记（五）

无涯WuYa

发布于 2018-10-25 16:04:23

5510

发布于 2018-10-25 16:04:23

在前面的四节中介绍了django环境的搭建，项目创建，执行原理以及url的路由系统，本小节学习Django的模型部分，众所周知，django是MTV的开发模式，本小节说的就是M部分，也就是Model部分，即Django的模型部分。在Django的开发模式中，最简单的一点，也就是说对数据库的操作，可以通过app应用中的models.py模块来控制，下面就来详细的说明，来看看它有什么优势。

Django的项目创建好，在settings.py文件中，默认的数据库是sqlite3，先来看看该配置的代码：

DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3',
         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
     }
}

在settings.py的配置文件中，DATABASES中，可以配置连接的数据库，包含数据库的地址，名称，密码以及数据库的名称，像主流的数据库都提供了，只需要在DATABASES的配置中，编写连接的配置文件，如连接mysql的数据库配置文件为：

DATABASES = {
    'default': {        
'ENGINE': 'django.db.backends.mysql',        
'NAME': 'webSite',       
'USER': 'root',        
'PASSWORD': 'server',        
'HOST': 'localhost',        
'PORT': '3306'
    }
}

特别申明，这里填写的数据库webSite得提前创建好，在django的模型中，可以创建数据库中的表，但是不可以创建数据库的，如果填写的数据库不存在，启动开发者的服务后，就会提示错误。在Django的模型部分中，涉及的命令分别为：

python manage.py makemigrations

python manage.py migrate

操作Django的Model的步骤为：

1、创建数据库

2、配置Django项目的settings.py里连接数据库

3、创建Model，继承models.Model

4、执行生成数据库的表命令：

python manage.py check

python manage.py makemigrations

python manage.py migrate

5、修改model，再次从第四步开始执行

下面就按如上说的步骤来执行该过程，所要求的结果是在blog的app应用下，创建用户表，见app应用下blog下的models.py的

源码：

#!/usr/bin/env python
#coding:utf-8

from __future__ import unicode_literals
from django.db import models
 
# Create your models here.
class User(models.Model):
    username=models.CharField(max_length=20)
    password=models.CharField(max_length=16)
    age=models.IntegerField()
    address=models.CharField(max_length=200)
    email=models.EmailField()

执行命令，创建数据库中表，见执行命令的截图：

python manage.py makemigrations

python manage.py migrate

在如上的截图中，在app的应用下，创建好了user的表，并且创建成功，这里特别的注意，如果是Django的早期版本，执行的命令是python manage.py syncdb。这点特别需要注意，不过现在安装的都是新版本的。首次执行python manage..py migrate同时也会创建其他的表，因为本人之前已经执行过该命令，所以么有显示出创建的表，首次执行创建的表为：

这里我们先来看创建的blog_user的表，不是我们创建的user表吗？怎么表的名称是blog_user了？遇到这点千万不要惊讶，因为在django的项目下，有很多的app的应用的，如果N个app的应用下的model都创建了user表，如果再显示user的名称，那么到底是那个app的表了？所以这样也是为了区分，这里的user表就是blog下的user表，即blog_user。再来看models.py的文件源码：

#!/usr/bin/env python
#coding:utf-8

from __future__ import unicode_literals
from django.db import models
 
# Create your models here.
class User(models.Model):
    username=models.CharField(max_length=20)
    password=models.CharField(max_length=16)
    age=models.IntegerField()
    address=models.CharField(max_length=200)
    email=models.EmailField()

在执行命令后，就创建了表，在实际的数据库中，我们一般都是sql依据来创建对应的表的，在django中，就不需要了，直接通过django的model来创建表以及指定表的类型，众所周知，在数据库中，表的字段是很多的，在django中，表的字段与在数据库中是一一对应的，见在Django中经常使用的字段：

models.AutoField:自增列 models.CharField:字符串字段 models.BooleanField:布尔类型 models.DateField:日期类型date models.DateTmeField:日期类型 datetime models.EmailField:字符串类型 models.FloatField:浮点类型 models.IntegerField:整形 models.BigIntegerField:长整形 models.IPAddressField:字符串类型 models.NullBooleanField:允许为空的布尔类型 models.TextField:字符串,longtext models.TimeField:时间 models.URLField:字符串，地址 models.BinaryField 二进制 models.ForeignKey：一对多关系 models.ManyToManyField:多对多关系 models.OneToOneField:一对一

这样在django的model中，可以指定创建表的字段类型，事实上，在sql的语句中，我们知道可以指定表字段的类型，比如可以为空啊，唯一性约束等，在Django中表的字段类型为：

null=True:数据库字段是否可以为空 blank=True:添加数据时是否可允许空值 primary_key=False:设置主键后，就会代替原来的自增 auto_now:自动创建，无论添加或者修改，都是当前操作的时间 auo_now_add:自动创建，永远是创建时的时间 choice GENDER_CHOICE=( ('m','Male'), ('f',' 'Female') ) max_length:字段长度 default:默认值 verbose_name:admin中字段的显示名称 name|db_column:数据库中的字段名称 unique=True:不允许重复 db_index=True:数据库索引 editable=True:在admin里是否可编辑 error_messages=None:错误提示,默认的错误提示信息修改，见源码解读error_messages={'invalid':'请输入合法的主机名称'} auto_created=False:自动创建 htlp_text:在Admin中提示帮助信息

下面我们就在model的User类中指定表的字段类型，见修改后的源码：

#!/usr/bin/env python
#coding:utf-8

from __future__ import unicode_literals
from django.db import models
 
# Create your models here.
 class User(models.Model):
    username=models.CharField(max_length=20,unique=True)
    password=models.CharField('密码',max_length=16)
    age=models.IntegerField('年龄',blank=True)
    address=models.CharField(max_length=200,default='西安')
    email=models.EmailField('邮箱',null=True)    
    def __unicode__(self):        
        return self.username

编辑model的模型后，再次执行python makemigrations与python manage.py migrate，见截图：

执行python manage.py makemigrations命令的截图

执行python manage.py migrate命令的截图

我们看更新后的blog_user表，见截图：

依据截图可以看到，在django的模型中，创建好的表，会有一个默认的字段id,并且是自增性。在上面中说到，通过django的类型，可以实现对数据库的操作，事实上，对数据库的操作，并不是在创建表上面，更多的是插入数据，删除数据，更新数据，以及查询数据，下面就来实现这些部分。

在数据库表的操作部分代码，会全部写在app应用下的views.py模块中，来依次实现对数的插入，更新，查询，以及删除。

首先来实现插入，这里全部使用django的方式实现，不在使用sql语句的方式实现，见实现

往blog_user表中插入数据的源码：

#!/usr/bin/env python
#coding:utf-8

from django.shortcuts import render,render_to_response
from django.http import  HttpResponse
from  .models import *
# Create your views here.
 
def Insert(request):    
'''实现数据库的insert操作'''
    User.objects.create(
        username=u'wuya',
        password='admin',
        age=22,
        address=u'中国西安市',
        email=u'wuyaf@outlook.com'
    )    return HttpResponse('<center><h3>插入数据成功!</h3></center>')

配置url来访问，见配置的url源码：

from django.conf.urls import url,include,patterns
from django.contrib import admin

urlpatterns = patterns(
    url(r'^admin/', admin.site.urls),
)
urlpatterns+=patterns(    'blog.views',
    url(r'^blog/index/$', 'index'),
    url(r'^blog/login/$', 'login'),
    url(r'^blog/logout/$', 'logout'),
    url(r'^blog/list/(?P<id>\d*)/$', 'list', {'name': 'wuya'}),    
#实现对数据库的操作    
   url(r'^blog/insert/$', 'Insert'),)

启动开发者服务，在浏览器中访问http://127.0.0.1:8000/blog/insert/，如果显示如下截图，说明插入数据成功，见

截图：

在数据库中查询表，看数据插入了么有，见截图：

我想看到终于明白django的模型强大了吧，本来插入的sql语句很多的，但是在django的模型中，只需要2行代码就解决了，再次查看插入数据的代码：

#!/usr/bin/env python
#coding:utf-8

from django.shortcuts import render,render_to_response
from django.http import  HttpResponse
from  .models import *
# Create your views here.
 
def Insert(request):    
 
'''实现数据库的insert操作'''
    User.objects.create(
        username=u'wuya',
        password='admin',
        age=22,
        address=u'中国西安市',
        email=u'wuyaf@outlook.com'
    )    return HttpResponse('<center><h3>插入数据成功!</h3></center>')

下来实现对插入的数据进行删除的操作，在Django中，删除数据库的源码为：

#!/usr/bin/env python
#coding:utf-8

from django.shortcuts import render,render_to_response
from django.http import  HttpResponse
from  .models import *
# Create your views here.
 
def Insert(request):    
'''实现数据库的insert操作'''
    User.objects.create(
        username=u'wuya',
        password='admin',
        age=22,
        address=u'中国西安市',
        email=u'wuyaf@outlook.com'
    )    return HttpResponse('<center><h3>插入数据成功!</h3></center>')

def Delete(request,id):    
'''实现数据库的delete操作'''
    User.objects.get(id=id).delete()    
    return HttpResponse('<center>删除第%s条数据成功！</center>'%id)

在url中配置隐射，见配置的urls.py源码：

from django.conf.urls import url,include,patterns
from django.contrib import admin

urlpatterns = patterns(
    url(r'^admin/', admin.site.urls),
)
urlpatterns+=patterns(    'blog.views',
    url(r'^blog/index/$', 'index'),
    url(r'^blog/login/$', 'login'),
    url(r'^blog/logout/$', 'logout'),
    url(r'^blog/list/(?P<id>\d*)/$', 'list', {'name': 'wuya'}),    
    #实现对数据库的操作
    url(r'^blog/insert/$', 'Insert'),
    url(r'^blog/delete/(?P<id>\d*)/$','Delete'),)

启动Django的开发者服务，在浏览器中访问:http://127.0.0.1:8000/blog/delete/2/，显示如下，表示删除数据成功，见截图

在数据库中查看插入的数据，已经删除成功。

下来实现对数据的更新操作，因为之前在实战中，已经把添加的数据删除了，所以为了操作更新的数据，就得先插入一条数据，实现的方式很简单，就是在浏览器访问http://127.0.0.1:8000/blog/insert/，数据就插入成功。下来具体来看更新的操作，实现

的结果是把地址由"中国西安市"修改为“中国西安”，见数据库中的原数据，见截图

见在Django中实现对数据的更新源码：

#!/usr/bin/env python
#coding:utf-8

from django.shortcuts import render,render_to_response
from django.http import  HttpResponse
from  .models import *
# Create your views here.
 
def Insert(request):    
'''实现数据库的insert操作'''
    User.objects.create(
        username=u'wuya',
        password='admin',
        age=22,
        address=u'中国西安市',
        email=u'wuyaf@outlook.com'
    )    
   return HttpResponse('<center><h3>插入数据成功!</h3></center>')

def Delete(request,id):    
'''实现数据库的delete操作'''
    User.objects.get(id=id).delete()    
    return HttpResponse('<center><h3>删除数据成功!</h3></center>')

def Update(request,id,address):    
'''实现数据库的更新操作'''
    User.objects.filter(id=id).update(address=address)       return HttpResponse('<center><h3>更新数据成功!</h3></center>')

下来配置url，见urls.py的源码：

from django.conf.urls import url,include,patterns
from django.contrib import admin

urlpatterns = patterns(
    url(r'^admin/', admin.site.urls),
)

urlpatterns+=patterns(    'blog.views',
    url(r'^blog/index/$', 'index'),
    url(r'^blog/login/$', 'login'),
    url(r'^blog/logout/$', 'logout'),
    url(r'^blog/list/(?P<id>\D*)/$', 'list', {'name': 'wuya'}),    
    #实现对数据库的操作
    url(r'^blog/insert/$', 'Insert'),
    url(r'^blog/delete/(?P<id>\d*)/$','Delete'),
    url(r'^blog/update/(?P<id>\d*)/(?P<address>\D*)/$','Update'),)

在浏览器中访问:http://127.0.0.1:8000/blog/3/中国西安/，数据就会更新成功，见截图

见数据库中的截图，数据已经更新成功，见截图

最后，来看数据的查询部分，事实上，在对数据的操作部分中，查询部分是占用最多的，数据的展示说的简单点，就是通过查询来展示出来。在查询的部分，我们来查看各种不同情况的查询，先看源码部分：

from django.shortcuts import render,render_to_response
from django.http import  HttpResponse
from  .models import *
# Create your views here.
 
def Insert(request):    
'''实现数据库的insert操作'''
    User.objects.create(
        username=u'wuya',
        password='admin',
        age=22,
        address=u'中国西安市',
        email=u'wuyaf@outlook.com'
    )    
    return HttpResponse('<center><h3>插入数据成功!</h3></center>')

def Delete(request,id):    
'''实现数据库的delete操作'''
    User.objects.get(id=id).delete()    
    return HttpResponse('<center><h3>删除数据成功!</h3></center>')

def Update(request,id,address):    
'''实现数据库的更新操作'''
    User.objects.filter(id=id).update(address=address)       return HttpResponse('<center><h3>更新数据成功!</h3></center>')

def Select(request):    
'''实现数据库的查询操作'''
    #获取所有的数据
    obj=User.objects.all()    
    print obj.query    
    #见获取到的数据:
    for item in obj:        
        print item.username,item.password,item.age,item.address,item.email

    return HttpResponse('<h3>查询数据成功！</h3>')

见url部分的源码：

from django.conf.urls import url,include,patterns
from django.contrib import admin

urlpatterns = patterns(
    url(r'^admin/', admin.site.urls),
)

urlpatterns+=patterns(    'blog.views',
    url(r'^blog/index/$', 'index'),
    url(r'^blog/login/$', 'login'),
    url(r'^blog/logout/$', 'logout'),
    url(r'^blog/list/(?P<id>\D*)/$', 'list', {'name': 'wuya'}),    
    #实现对数据库的操作
    url(r'^blog/insert/$', 'Insert'),
    url(r'^blog/delete/(?P<id>\d*)/$','Delete'),
    url(r'^blog/update/(?P<id>\d*)/(?P<address>\D*)/$','Update'),
    url(r'^blog/select/$','Select'),)

在浏览器中访问http://127.0.0.1:8000/blog/select/，可以看到提示查询成功的信息，以及在控制器中显示打印的sql语句和结果，见截图：

见控制器台中的信息，见截图

为了更加看的方便点，我在pycharm启动开发者的服务，这样在IDE中看打印的信息更加直接，见截图：

见这些信息：

SELECT `blog_user`.`id`, `blog_user`.`username`, `blog_user`.`password`, `blog_user`.`age`, `blog_user`.`address`, `blog_user`.`email` FROM `blog_user` wuya admin 22 中国西安 wuyaf@outlook.com

第一句，这不就是sql语句吗，第二句就是查询出的结果，这些就是通过在views.py中的如下代码实现的，见源码：

def Select(request):    
'''实现数据库的查询操作'''

    #获取所有的数据
    obj=User.objects.all()    
    print obj.query
   #见获取到的数据:
    for item in obj:        
        print item.username,item.password,item.age,item.address,item.email    
    HttpResponse('<h3>查询数据成功！</h3>')

在本节中，从开始就说Django模型有多么强大，通过几行代码就是实现了数据的增加，删除，修改以及查询，但是在实际的数据库中，是通过查询sql语句来获取的，在Django中也是，我们可以把获取的对象给obj，然后调用query来查看执行的sql语句，具体代码为：

  obj=User.objects.all()    
   print obj.query

下面我们来看看其他的查询结果，分别来进行，比如获取所有数据的前2条，实现的源码为：

def Select(request):    
'''实现数据库的查询操作'''

    # #获取所有的数据
    # obj=User.objects.all()
    # print obj.query
    # #见获取到的数据:
    # for item in obj:
    #     print item.username,item.password,item.age,item.address,item.email

    #获取前二条的数据    
    obj=User.objects.all()[0:2]    
    print obj.query    
    return HttpResponse('<h3>查询数据成功！</h3>')

见控制器的信息：

实现对数据的排序，正序为正数，倒叙加-，见实现的源码以及打印的控制台的信息

def Select(request):    
'''实现数据库的查询操作'''

    # #获取所有的数据
    # obj=User.objects.all()
    # print obj.query
    # #见获取到的数据:
    # for item in obj:
    #     print item.username,item.password,item.age,item.address,item.email

    # #获取前二条的数据
    # obj=User.objects.all()[0:2]
    # print obj.query

    #实现数据的倒叙排序     obj=User.objects.all().order_by('-id')    
print obj.query    
for item in obj:        
    print item.id,item.username,item.password,item.address,item.age,item.email    
return HttpResponse('<h3>查询数据成功！</h3>')

见控制台的信息：

查询多少条数据，见实现的源码以及控制台的信息：

def Select(request):    
'''实现数据库的查询操作'''

    # #获取所有的数据
    # obj=User.objects.all()
    # print obj.query
    # #见获取到的数据:
    # for item in obj:
    #     print item.username,item.password,item.age,item.address,item.email

    # #获取前二条的数据
    # obj=User.objects.all()[0:2]
    # print obj.query

    # #实现数据的倒叙排序
    # obj=User.objects.all().order_by('-id')
    # print obj.query
    # for item in obj:
    #     print item.id,item.username,item.password,item.address,item.age,item.email

    #查询数量    
    obj=User.objects.all().count()    
    print u'数量为：',obj    
    return HttpResponse('<h3>查询数据成功！</h3>')

下来再来看模糊查询，见实现的源码以及控制台的输出：

def Select(request,username):    
'''实现数据库的查询操作'''

    # #获取所有的数据
    # obj=User.objects.all()
    # print obj.query
    # #见获取到的数据:
    # for item in obj:
    #     print item.username,item.password,item.age,item.address,item.email

    # #获取前二条的数据
    # obj=User.objects.all()[0:2]
    # print obj.query

    # #实现数据的倒叙排序
    # obj=User.objects.all().order_by('-id')
    # print obj.query
    # for item in obj:
    #     print item.id,item.username,item.password,item.address,item.age,item.email

    # #查询数量
    # obj=User.objects.all().count()
    # print u'数量为：',obj

    #对用户名进行模糊查询
    obj=User.objects.filter(username__contains=username)     print u'SQL:',obj.query    
    for item in obj:        
        print item.id,item.username,item.age,item.address,item.email       return HttpResponse('<h3>查询数据成功！</h3>')

见控制台的输出：