django入门 笔记(一) 安装

感谢原作者

参考文档：https://my.oschina.net/u/3758825/blog/1612098

python官方教程：https://docs.python.org/3.7/tutorial/index.html

Python 3.7.2官方文档：https://docs.python.org/3.7/index.html

django1.X路由的url与2.X路由path语法理解区别

 

Django2.0 path与Django1.x url的总结

2.X 用path	1.X 用url
from django.contrip import admin  #这个一样 from django.urls import path   #这个引入path #下面用path urlpatterns=[path('admin/',admin.site.urls) ]	from django.contrip import admin  #这个一样 from django.conf.urls import url  #这个引入url #下面用url urlpatterns=[url('admin/',admin.site.urls) ]

 

Python环境与Django版本对应表：

Django version	Python versions
1.8	2.7, 3.2 (until the end of 2016), 3.3, 3.4, 3.5
1.9, 1.10	2.7, 3.4, 3.5
1.11	2.7, 3.4, 3.5, 3.6
2.0	3.4, 3.5, 3.6
2.1	3.5, 3.6, 3.7

自从1.0版本开始，Django按照以下形式命名版本编号：
按照A.B或A.B.C的形式命名版本编号。A.B是主版本号，包含新功能以及对原有功能的改进，每一个新版本都向前兼容，Django大概每8个月就会发布一个主版本；C是小版本号，包含bug的修改等，每当有需要时就会发布。在Django正式版本发布之前，还会发布alpha、beta和RC版本。另外Django长期支持的版本用LTS表示。
Django推荐使用Python 3进行开发，而最后一个支持Python 2.7的版本是Django 1.11 LTS，上面是Django对Python版本的支持情况（截至2017年11月）。

 

一、安装django（原作1.9.2，我安装的python3\django2.1.7）

django优秀的开源框架，提供了一个admin的后台，很快就可以有一个admin后台.

django的官方地址是：https://www.djangoproject.com/，官方的介绍：Django 是一个高级别的 Python Web 框架，鼓励迅速发展和清洁、 务实的设计。所以你可以集中精力编写您的应用程序而无需重新发明轮子。它是自由和开放源码。具体详细的信息可以看官方的document的说明。

安装好python，然后如下，

pip  install django   (默认安装最新版本)

pip install django==1.11.7   (安装指定的版本)

pip install django==1.11.7 -i http://pypi.douban.com/simple --trusted-host pypi.douban.com ( 用豆瓣的镜像安装)

 

会直接安装好django，进入到python的命令行模式，可以查看django框架是否可以导入，以及查看它的版本，见截图：

1)Django管理项目的内置命令

manage.py是每个Django项目中自动生成的一个用于管理项目的脚本文件，manage.py接受的是Django提供的内置命令。

详细的命令可以查询，输入python manage.py

内置命令包含

• check  检查整个Django项目是否存在常见问题。默认情况下，所有应用都将被选中。可以通过提供app的名字检查指定的应用：
• dbshell    数据库命令行
• diffsettings 显示当前设置文件与Django的默认设置之间的差异。
• flush 从数据库中删除所有数据。已应用的迁移不会被清除。只删除具体数据，不删除数据表！如果您希望从空数据库启动并重新运行所有迁移，则应该删除并重新创建数据库，然后再运行migrate，这样会连原来的数据表都删了。
• makemigrations  根据检测到的模型创建新的迁移。迁移的作用，更多的是将数据库的操作，以文件的形式记录下来，方便以后检查、调用、重做等等。尤其是对于Git版本管理，它无法获知数据库是如何变化的，只能通过迁移文件中的记录来追溯和保存。
• migrate 使数据库状态与当前模型集和迁移集同步。说白了，就是将对数据库的更改，主要是数据表设计的更改，在数据库中真实执行。例如，新建、修改、删除数据表，新增、修改、删除某数据表内的字段等等。
• runserver 启用Django为我们提供的轻量级的开发用的Web服务器。默认情况下，服务器运行在IP地址127.0.0.1的8000端口上。如果要自定义服务器端口和地址，可以显式地传递一个IP地址和端口号给它。
• shell  启动命令行环境。默认使用基本的python交互式解释器。这个命令非常常用，是我们测试和开发过程中不可或缺的部分！ 这个命令和直接运行python或bpython进入shell的区别是：你可以在这个shell里面调用当前项目的model.py中的api，对于操作数据，还有一些小测试非常方便
• startapp  创建新的app。默认情况下，会在这个新的app目录下创建一系列文件模版，比如models.py、views.py、admin.py等等。
• startproject  新建工程。默认情况下，新目录包含manage.py脚本和项目包（包含settings.py和其他文件）。
• test  运行所有已安装的app的测试代码。

其实有三种方式在cmd窗口中执行Django提供的内置命令：

$ django-admin <command> [options]
$ python manage.py <command> [options]
$ python -m django <command> [options]

其中 
1、django-admin是用于管理Django的命令行工具集，当我们成功安装Django后，在操作系统中就会有这个命令，但是根据安装方式或者系统环境的不同，你可能需要配置一下调用路径。在Linux下，该命令一般位于site-packages/django/bin，最好做一个链接到/usr/local/bin，方便调用。Windows下可以配置系统环境变量

2、manage.py则是每个Django项目中自动生成的一个用于管理项目的脚本文件，需要在cmd窗口中cd到Django项目的manage.py所在的目录后通过python命令执行。

其中的command是Django内置的或者你自定义的命令。

当然你可以在在pycharm中启动manage.py时设置参数。

 

2)内置app，比如auth提供的命令

内置app，比如auth等提供的命令项。它们只在对应的app启用的时候才可用。

python manage.py changepassword username 修改用户密码
                               createsuperuser  创建超级管理员
                               clearsessions  
                               collectstatic

                                dumpdata appname >appname.json  导出数据

                                loaddata appname.json   导入数据

3) 共有参数

–pythonpath PYTHONPATH 
–settings SETTINGS 
–traceback 
–verbosity {0,1,2,3}, -v {0,1,2,3} 
–no-color
 

二、新建一个Django项目

方法1)在pycharm中，点击File>New Project>选择Django,以及python对应的版本>点击Create，Django工程创建就完成了

方法2）命令创建， 先cd  C:\Python27\Scripts    ， 然后  python django-admin.py  startproject webSite

新建工程（命令行） >django-admin startproject mysite    //mysite为工程名

然后打开pycharm,查看目录结构如下： 

templates是存储html,css,js等文件(注意：我实践后发现新建项目，没有自动创建templates这个目录)

webSite目录文件为：

        __init__.py：让Python把该目录看成一个package使需的文件，而不是一个文件的目录

        settings.py：Django项目的设置和设置，数据库，时区等等的配置，都是在这个配置文件下

        urls.py：Django项目的url设置，可以理解为Django网站的目录,后面在介绍url隐射的时候

manage.py：一个命令行工具，允许以多种方式与python进行交互。

启动Django项目，访问8000端口OK

在Diango中，它自带了独立的服务器，即框架就是服务，不需要额外的服务器，Django框架中，有一个轻量级，内建的服务器，有了这个服务器，在开发的环境模式下，就不需要额外的apache等web容器了，启动的方式是：manage.py runserver。

方法1）命令启动 python manage.py runserver

（注意：我实践后发现，执行runnerserver命令后，自动生成了1个和manage.py平级的文件db.sqlite3）

如要指定IP与端口(适合多人开发团队)，启动的方式为：

python manage.py runserver 0.0.0.0:9999

方法2） pycharm中启动

打开manage.py文件》菜单栏中Run选择Edit Configurations > 在弹出的界面Script  parameters输入框中输入runserver,点击确认》 manage.py文件中右键选择Run 'manage' 》在浏览器中访问http://127.0.0.1:8000/，页面展示 it  works，说明

控制台的信息如下

c:\Python\Python37\Scripts\website>python manage.py runserver
Performing system checks...

System check identified no issues (0 silenced).

You have 15 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.
February 19, 2019 - 19:18:15
Django version 2.1.7, using settings 'website.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
[19/Feb/2019 19:18:47] "GET / HTTP/1.1" 200 16348
[19/Feb/2019 19:18:47] "GET /static/admin/css/fonts.css HTTP/1.1" 200 423
[19/Feb/2019 19:18:47] "GET /static/admin/fonts/Roboto-Regular-webfont.woff HTTP/1.1" 200 80304
[19/Feb/2019 19:18:47] "GET /static/admin/fonts/Roboto-Bold-webfont.woff HTTP/1.1" 200 82564
[19/Feb/2019 19:18:47] "GET /static/admin/fonts/Roboto-Light-webfont.woff HTTP/1.1" 200 81348
Not Found: /favicon.ico
[19/Feb/2019 19:18:47] "GET /favicon.ico HTTP/1.1" 404 1973

三、Django项目中新建app

目标：访问http://127.0.0.1:8000/blog/index/，打印出Hello world

Django_中文教程,url的路由，原文说明：

1. 进来的请求转入/hello/.
2. Django通过在ROOT_URLCONF配置来决定根URLconf.
3. Django在URLconf中的所有URL模式中，查找第一个匹配/hello/的条目。
4. 如果找到匹配，将调用相应的视图函数
5. 视图函数返回一个HttpResponse
6. Django转换HttpResponse为一个适合的HTTP response， 以Web page显示出来

新建1个名叫  blog的app:     

用命令新建APP： python manage.py startapp blog

新建一个app，最开始的目录结构    

1、打开blog/views.py，写入如下的代码，见源码：

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

from django.shortcuts import render
from django.http import  HttpResponse
  
# Create your views here.
def index(request):    
    return HttpResponse('<center><h3>Hello World</h3></center>')  #这个是添加的

 

2、拷贝webSite/urls.py文件，复制到blog的目录下(先不要问为什么)，复制成功后，下面按顺序来依次实现修改blog/urls.py文件，把index视图添加到url中，见源码：

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

from django.conf.urls import url
from .views import  *
urlpatterns = [
    url(r'^index/$', index),   #这个是添加的
]

3、webSite/settings.py文件，把blog加入到INSTALLED_APPS中，在INSTALLED_APPS中加入blog,见源码：

INSTALLED_APPS = [  
'django.contrib.admin',    
'django.contrib.auth',  
'django.contrib.contenttypes', 
'django.contrib.sessions', 
'django.contrib.messages', 
'django.contrib.staticfiles',   
'blog', #这个是添加的
]

4、webSite/urls.py，添加blog映射,也就是分发，修改后的文件:

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

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

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^blog/',include('blog.urls',namespace='blog')),  #这个是添加的
]

5、启动本地的开发服务器： python manage.py runserver

6、在浏览器中输入http://127.0.0.1:8000/blog/index,返回Hello World

 

 

四、数据库setting，model

配置数据库链接，创建model并修改

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

python manage.py makemigrations 

python manage.py migrate

操作Django的Model的步骤为：

1、创建数据库

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

 Django的项目创建后，webSite/settings.py，默认数据库是sqlite3，源代码：

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

连接mysql的数据库配置文件为：

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

3、创建Model，继承models.Model

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

     python manage.py check 

     python manage.py makemigrations 

     python manage.py migrate

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

下面就按如上说的步骤来执行该过程，所要求的结果是在blog的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时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()

在执行命令后，就创建了表，在实际的数据库中，我们一般都是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中提示帮助信息

 

修改后的blog/models.py的文件源码：

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,并且是自增性。

五、实现数据库 增/删/改/查

    数据库表的操作部分代码，会写在app的目录 blog/views.py，依次实现表的插入，更新，查询，以及删除。

   1.  首先来实现insert，

这里全部使用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/，如果显示如下截图，说明插入数据成功

还可以去表里用sql查一下insert结果（略）

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

 

2. 实现删除

对插入的数据进行删除。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/，显示如下，表示删除数据成功，见截图

3. 实现update

 下来实现对数据的更新操作，因为之前在实战中，已经把添加的数据删除了，所以为了操作更新的数据，就得先插入一条数据，实现的方式很简单，就是在浏览器访问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/中国西安/，数据就会更新成功，见截图

4、实现查询，

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

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>') 

见控制器的信息：

 

5.实现对数据的排序，

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

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>')

见控制台的输出：

 

事实上，SQL的查询方式很多的，这里就总结这些经常使用的，具体的可以查看下Django的模型部分。