【Python全栈-后端开发】Django入门基础
Django基础知识
1、 什么是web框架？
框架，即framework，特指为解决一个开放性问题而设计的具备必定约束性的支撑结构，使用框架能够帮你快速开发特定的系统，简单地说，就是你用别人搭建好的舞台来作表演。 对于全部的Web应用，本质上其实就是一个socket服务端，用户的浏览器其实就是一个socket客户端。 最简单的Web应用就是先把HTML用文件保存好，用一个现成的HTTP服务器软件，接收用户请求，从文件中读取HTML，返回。 若是要动态生成HTML，就须要把上述步骤本身来实现。不过，接受HTTP请求、解析HTTP请求、发送HTTP响应都是苦力活，若是咱们本身来写这些底层代码，还没开始写动态HTML呢，就得花个把月去读HTTP规范。 正确的作法是底层代码由专门的服务器软件实现，咱们用Python专一于生成HTML文档。由于咱们不但愿接触到TCP链接、HTTP原始请求和响应格式，因此，须要一个统一的接口，让咱们专心用Python编写Web业务。 这个接口就是WSGI：Web Server Gateway Interface。（网络服务网关接口） -----------------------------Do a web framework ourselves--------------------------- step 1: 注意： step 2 step 3 step 4
2、MVC和MTV模式
著名的MVC模式：所谓MVC就是把web应用分为模型(M),控制器(C),视图(V)三层；他们之间以一种插件似的，松耦合的方式链接在一块儿。
模型负责业务对象与数据库的对象(ORM) ， 视图负责与用户的交互(页面)，控制器(C)接受用户的输入调用模型和视图完成用户的请求。
Django的MTV模式本质上与MVC模式没有什么差异，也是各组件之间为了保持松耦合关系，只是定义上有些许不一样，Django的MTV分别表明：
Model(模型)：负责业务对象与数据库的对象(ORM)
Template(模版)：负责如何把页面展现给用户
View(视图)：负责业务逻辑，并在适当的时候调用Model和Template
此外，Django还有一个url分发器，它的做用是将一个个URL的页面请求分发给不一样的view处理，view再调用相应的Model和Template
3、Django的流程和命令行工具
Django实现流程：
Django #安装： pip3 install django 添加环境变量 #1 在cmd命令行中建立project
django-admin startproject [项目名]
django-admin startproject mysite ---mysite ---settings.py ---url.py ---wsgi.py ---- manage.py(启动文件) #2 建立APP
python manage.py startapp [app名字] python manage.py startapp app01 #3 settings配置 TEMPLATES
#配置静态文件路径 STATICFILES_DIRS=( os.path.join(BASE_DIR,"statics"), #必定要加逗号，否则会报错 ) STATIC_URL = '/static/' #别名（因为原名更改致使后续更改麻烦，之后通常使用别名，） # 咱们只能用 STATIC_URL，但STATIC_URL会按着你的STATICFILES_DIRS去找#4 根据需求设计代码 url.py view.py #5 使用模版渲染HTML界面 render(request,"index.html") #6 启动项目（pycharm 的terminal中） python manage.py runserver 【127.0.0.1:8000】 #后面【】部分能够不填，默认是127.0.0.1:8000 #7 链接数据库，操做数据 model.py
django的cmd命令行工具：
django-admin.py 是Django的一个用于管理任务的命令行工具，manage.py是对django－admin.py的简单包装,每个Django Project里都会有一个manage.py。php
<1> 建立一个django工程 : django-admin.py startproject mysitecss
当前目录下会生成mysite的工程，目录结构以下：html
- manage.py ----- Django项目里面的工具，经过它能够调用django shell和数据库等。
- settings.py ---- 包含了项目的默认设置，包括数据库信息，调试标志以及其余一些工做的变量。
- urls.py ----- 负责把URL模式映射到应用程序。
<2>在mysite目录下建立APP应用 blog: python manage.py startapp blog前端
<3>启动django项目：python manage.py runserver 8080java
<4>生成同步数据库的脚本：python manage.py makemigrations python
同步数据库: python manage.py migrate mysql
注意：在开发过程当中，数据库同步误操做以后，不免会遇到后面不能同步成功的状况，解决这个问题的一个简单粗暴方法是把migrations目录下jquery
的脚本（除__init__.py以外）所有删掉，再把数据库删掉以后建立一个新的数据库，数据库同步操做再从新作一遍。 linux
<5>当咱们访问后台管理员：http://127.0.0.1:8080/admin/时，会出现：nginx
因此咱们须要为进入这个项目的后台建立超级管理员：python manage.py createsuperuser，设置好用户名和密码后即可登陆啦！
注意： 修改密码：python manage.py changepassword [用户名]
忘记用户名或密码：
在shell模式下（Python manage.py shell） ---------------------------------------------------找回用户名 from django.contrib.auth.models import User #引入管理员密码存放的数据库 user=User.objects.filter() #查找该数据库里有哪些用户 print(user) #<QuerySet [<User: root>, <User: xiong>]> -----------------------------------------------------修改密码（方法一） user = User.objects.get(username='admin') #获取名称为admin的用户 user.set_password('123456') #设置密码 user.save() # 报错user对象 -----------------------------------------------------修改密码（方法二） 退出shell模式，在Terminal中 Python manage.py changepassword [用户名]
<6>清空数据库（慎用！！！）：python manage.py flush
<7>查询某个命令的详细信息： django-admin.py help startapp
admin 是Django 自带的一个后台数据库管理系统。
<8>启动Django与数据库交互模式：python manage.py shell
这个命令和直接运行 python 进入 shell 的区别是：你能够在这个 shell 里面调用当前项目的 models.py 中的 API，对于操做数据，还有一些小测试很是方便。
<9> 终端上输入python manage.py 能够看到详细的列表，在忘记子名称的时候特别有用。
实例练习1－提交数据并展现
实例练习2－提交数据并展现(数据库)
4、project文件夹下(settings.py)配置
静态文件设置:
1、概述： #静态文件交由Web服务器处理，Django自己不处理静态文件。简单的处理逻辑以下(以nginx为例)： # URI请求-----> 按照Web服务器里面的配置规则先处理，以nginx为例，主要求配置在nginx. #conf里的location |---------->若是是静态文件，则由nginx直接处理 |---------->若是不是则交由Django处理，Django根据urls.py里面的规则进行匹配 # 以上是部署到Web服务器后的处理方式，为了便于开发，Django提供了在开发环境的对静态文件的处理机制，方法是这样： #一、在INSTALLED_APPS里面加入'django.contrib.staticfiles', #二、在urls.py里面加入 if settings.DEBUG: urlpatterns += patterns('', url(r'^media/(?P<path>.*)$', 'django.views.static.serve', {'document_root': settings.MEDIA_ROOT }), url(r'^static/(?P<path>.*)$', 'django.views.static.serve',{'document_root':settings.STATIC_ROOT}), ) # 三、这样就能够在开发阶段直接使用静态文件了。 2、MEDIA_ROOT和MEDIA_URL #而静态文件的处理又包括STATIC和MEDIA两类，这每每容易混淆，在Django里面是这样定义的： #MEDIA:指用户上传的文件，好比在Model里面的FileFIeld，ImageField上传的文件。若是你定义 #MEDIA_ROOT=c:\temp\media，那么File=models.FileField(upload_to="abc/")＃，上传的文件就会被保存到c:\temp\media\abc #eg： class blog(models.Model): Title=models.charField(max_length=64) Photo=models.ImageField(upload_to="photo") # 上传的图片就上传到c:\temp\media\photo，而在模板中要显示该文件，则在这样写 #在settings里面设置的MEDIA_ROOT必须是本地路径的绝对路径，通常是这样写: BASE_DIR= os.path.abspath(os.path.dirname(__file__)) MEDIA_ROOT=os.path.join(BASE_DIR,'media/').replace('\\','/') #MEDIA_URL是指从浏览器访问时的地址前缀，举个例子： MEDIA_ROOT=c:\temp\media\photo MEDIA_URL="/data/" #在开发阶段,media的处理由django处理： # 访问http://localhost/data/abc/a.png就是访问c:\temp\media\photo\abc\a.png # 在模板里面这样写<img src="{{MEDIA_URL}}abc/a.png"> # 在部署阶段最大的不一样在于你必须让web服务器来处理media文件，所以你必须在web服务器中配置， # 以便能让web服务器能访问media文件 # 以nginx为例，能够在nginx.conf里面这样： location ~/media/{ root/temp/ break; } # 具体能够参考如何在nginx部署django的资料。 3、STATIC_ROOT和STATIC_URL、 STATIC主要指的是如css,js,images这样文件，在settings里面能够配置STATIC_ROOT和STATIC_URL, 配置方式与MEDIA_ROOT是同样的，可是要注意 #STATIC文件通常保存在如下位置： #一、STATIC_ROOT：在settings里面设置，通常用来放一些公共的js,css,images等。 #二、app的static文件夹，在每一个app所在文夹都可以创建一个static文件夹，而后当运行collectstatic时， # Django会遍历INSTALL_APPS里面全部app的static文件夹，将里面全部的文件复制到STATIC_ROOT。所以， # 若是你要创建可复用的app，那么你要将该app所须要的静态文件放在static文件夹中。 # 也就是说一个项目引用了不少app，那么这个项目所须要的css,images等静态文件是分散在各个app的static文件的，比 # 较典型的是admin应用。当你要发布时，须要将这些分散的static文件收集到一个地方就是STATIC_ROOT。 #三、STATIC文件还能够配置STATICFILES_DIRS，指定额外的静态文件存储位置。 # STATIC_URL的含义与MEDIA_URL相似。 # ---------------------------------------------------------------------------- #注意1: #为了后端的更改不会影响前端的引入，避免形成前端大量修改 STATIC_URL = '/static/' #引用名 STATICFILES_DIRS = ( os.path.join(BASE_DIR,"statics") #实际名 ,即实际文件夹的名字 ) #django对引用名和实际名进行映射,引用时,只能按照引用名来,不能按实际名去找 #<script src="/statics/jquery-3.1.1.js"></script> #------error－－－－－不能直接用，必须用STATIC_URL = '/static/': #<script src="/static/jquery-3.1.1.js"></script> #注意2(statics文件夹写在不一样的app下,静态文件的调用): STATIC_URL = '/static/' STATICFILES_DIRS=( ('hello',os.path.join(BASE_DIR,"app01","statics")) , ) #<script src="/static/hello/jquery-1.8.2.min.js"></script> #注意3: STATIC_URL = '/static/' {% load staticfiles %} # <script src={% static "jquery-1.8.2.min.js" %}></script>
配置编码：
首先须要配置的是文字编码格式，django默认的编码是英语格式，咱们把它改为中文格式，须要修改下面几个变量的值。
LANGUAGE_CODE = 'zh-hans' # zh-hans为中文编码 TIME_ZONE = 'Asia/Shanghai' # 国际时区改为中国时区 USE_I18N = True USE_L10N = True USE_TZ = False
配置数据库：
而后还须要配置数据库信息，django默认使用的是sqlite数据库，咱们修改成mysql数据库。找到DATABASES节点，修改成以下代码。
其中，NAME为数据库名，USER为mysql的用户名，PASSWORD为密码，HOSY为127.0.0.1，PORT为3306
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'video', 'USER': 'root', 'PASSWORD': '123456', 'HOST':'127.0.0.1', 'PORT':'3306', } }
配置好数据库以后，还须要在 videoproject/videoproject/__init__.py 安装mysql驱动，只须要写入代码：
import pymysql pymysql.install_as_MySQLdb()
views.py操做数据库的日志 --->控制台打印SQL语句
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
5、Django URL (路由系统)
URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL模式以及要为该URL模式调用的视图函数之间的映射表；
你就是以这种方式告诉Django，对于这个URL调用这段代码，对于那个URL调用那段代码。
urlpatterns = [
url(正则表达式, views视图函数，参数，别名),
]
参数说明：
- 一个正则表达式字符串
- 一个可调用对象，一般为一个视图函数或一个指定视图函数路径的字符串
- 可选的要传递给视图函数的默认参数（字典形式）
- 一个可选的name参数
- 能够两个url对应一个views视图函数（注意：逻辑不能乱）
5.1 下面是一些基本的URL配置:
from django.conf.urls import url from django.contrib import admin from blog import views urlpatterns = [ url(r'^articles/2003/$', views.special_case_2003), #url(r'^articles/[0-9]{4}/$', views.year_archive), url(r'^articles/([0-9]{4})/$', views.year_archive), #no_named group url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive), url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail), ]
Note:
#1 There’s no need to add a leading slash, because every URL has that. For # example, it’s ^articles, not ^/articles. #2 A request to /articles/2005/03/ would match the third entry in the list. # Django would call the function views.month_archive(request, '2005', '03'). #3 /articles/2005/3/ would not match any URL patterns #4 /articles/2003/ would match the first pattern in the list, not the second one #5 /articles/2003/03/03/ would match the final pattern. Django would call the # functionviews.article_detail(request, '2003', '03', '03').
注意问题：django---urls中导入url和path问题
初始导入的是path模块： urlpatterns = [ path(r'^hello/$',views.hello), path(r'^admin/$', admin.site.urls), path(r'^time/$', current_datetime), path(r'^time/plus/(\d{1,2})/$',hours_ahead), ] 网站不能正常运行。正则失败。 后来我删掉path，导入url： from django.conf.urls import url urlpatterns = [ url(r'^hello/$',views.hello), url(r'^admin/$', admin.site.urls), url(r'^time/$', current_datetime), url(r'^time/plus/(\d{1,2})/$',hours_ahead), ] 网站运行成功。正则表达式成功
5.2 Named groups（命名组）
上面的示例使用简单的，未命名的正则表达式组（经过括号）来捕获URL的位，并将它们做为位置参数传递给视图。 在更高级的用法中，可使用命名的正则表达式组来捕获URL位并将它们做为关键字参数传递给视图。
在Python正则表达式中，命名正则表达式组的语法是（？P <name> pattern），其中name是组的名称，pattern是要匹配的模式。
下面是用命名组重写了上面的URL配置案例：
这与前一个示例彻底相同，只有一个细微差异：捕获的值做为关键字参数而不是位置参数传递给视图函数。
参考：
Django的路由系统|URL配置、正则表达式、分组命名、命名空间、命名URL反向解析
6、Django Views（视图函数）
http请求中产生两个核心对象：
http请求：HttpRequest对象
http响应：HttpResponse对象
所在位置：django.http
以前咱们用到的参数request就是HttpRequest 检测方法：isinstance(request,HttpRequest)
1 HttpRequest对象的属性和方法：
# path： 请求页面的全路径，不包括域名 # # method： 请求中使用的HTTP方法的字符串表示。全大写表示。例如 # # if req.method=="GET": # # do_something() # # elseif req.method=="POST": # # do_something_else() # # GET: 包含全部HTTP GET参数的类字典对象 # # POST： 包含全部HTTP POST参数的类字典对象 # # 服务器收到空的POST请求的状况也是可能发生的，也就是说，表单form经过 # HTTP POST方法提交请求，可是表单中可能没有数据，所以不能使用 # if req.POST来判断是否使用了HTTP POST 方法；应该使用 if req.method=="POST" # # # # COOKIES: 包含全部cookies的标准Python字典对象；keys和values都是字符串。 # # FILES： 包含全部上传文件的类字典对象；FILES中的每个Key都是<input type="file" name="" />标签中 name属性的值，FILES中的每个value同时也是一个标准的python字典对象，包含下面三个Keys： # # filename： 上传文件名，用字符串表示 # content_type: 上传文件的Content Type # content： 上传文件的原始内容 # # # user： 是一个django.contrib.auth.models.User对象，表明当前登录的用户。若是访问用户当前 # 没有登录，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你 # 能够经过user的is_authenticated()方法来辨别用户是否登录： # if req.user.is_authenticated();只有激活Django中的AuthenticationMiddleware # 时该属性才可用 # # session： 惟一可读写的属性，表明当前会话的字典对象；本身有激活Django中的session支持时该属性才可用。 #方法 get_full_path(), 好比：http://127.0.0.1:8000/index33/?name=123 ,req.get_full_path()获得的结果就是/index33/?name=123 req.path:/index33
注意一个经常使用方法：request.POST.getlist('')
2 HttpResponse对象：
对于HttpRequest对象来讲，是由django自动建立的，可是，HttpResponse对象就必须咱们本身建立。每一个view请求处理方法必须返回一个HttpResponse对象。
HttpResponse类在django.http.HttpResponse
在HttpResponse对象上扩展的经常使用方法：
页面渲染： render()（推荐） render_to_response(),
页面跳转： redirect("路径")
locals()： 能够直接将函数中全部的变量传给模板
补充：
-----------------------------------url.py url(r"login", views.login), url(r"yuan_back", views.yuan_back), -----------------------------------views.py def login(req): if req.method=="POST": if 1: # return redirect("/yuan_back/") name="yuanhao" return render(req,"my backend.html",locals()) return render(req,"login.html",locals()) def yuan_back(req): name="苑昊" return render(req,"my backend.html",locals()) -----------------------------------login.html <form action="/login/" method="post"> <p>姓名<input type="text" name="username"></p> <p>性别<input type="text" name="sex"></p> <p>邮箱<input type="text" name="email"></p> <p><input type="submit" value="submit"></p> </form> -----------------------------------my backend.html <h1>用户{{ name }}你好</h1> #总结: render和redirect的区别: # 1 if render的页面须要模板语言渲染,须要的将数据库的数据加载到html,那么全部的这一部分 # 除了写在yuan_back的视图函数中,必须还要写在login中,代码重复,没有解耦. # 2 the most important: url没有跳转到/yuan_back/,而是还在/login/,因此当刷新后 # 又得从新登陆.
练习：
-----------------------------------------Django/urls url(r'blog/',include('blog.urls')), url('login/', views.login), -----------------------------------------blog/urls #注册界面 url("register",views.register,name="reg") ----------------------------------------views def register(request): # print("部分路径：",request.path) # print("全路径：",request.get_full_path) # if request.method == "POST": # print(request.POST) # print(request.POST.get("userName")) # print(request.POST.get("age")) # return HttpResponse(request) if request.POST.get("userName") == "xiong": return redirect("/login/") #输入userName是 xiong 跳转到login界面 else: redirect("http://www.baidu.com") # 开始进来的时候是get请求 返回html渲染界面，以后form表单是以POST提交 return render(request,"register.html") def login(request): if request.GET.get("username") == "xiong" and request.GET.get("pwd") == "123456": return redirect("https://www.cnblogs.com") ----------------------------------------------------template/.html <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> {% load staticfiles %} {# 使用别名 须要载入静态文件 #} <title>Title</title> </head> <body> <h1>学生注册界面</h1> <hr> {#以post方式提交,action="/register/" 是以当前页面的ip+port放在前面一块儿发过去即：172.0.0.1:8080/register/#} {#<form action="/register/" method="post">#} <form action="{% url 'reg' %}" method="post"> <p>姓名<input type="text" name="userName"></p> <p>年龄<input type="text" name="age"></p> <p>爱好<input type="checkbox" name="hobby">篮球 <input type="checkbox" name="hobby">足球 <input type="checkbox" name="hobby">乒乓球 </p> <p><input type="submit">提交</p> </form> </body> </html> <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>登陆界面</title> </head> <body> <form action=""> <p>用户名: <input type="text" name="username" id=""></p> <p>密码: <input type="text" name="pwd" id=""></p> <p><input type="submit"></p> </form> </body> </html>
7、Template模板基础（重要！！！）
模板系统的介绍
你可能已经注意到咱们在例子视图中返回文本的方式有点特别。 也就是说，HTML被直接硬编码在 Python代码之中。
def current_datetime(request): now = datetime.datetime.now() html = "<html><body>It is now %s.</body></html>" % now return HttpResponse(html)
尽管这种技术便于解释视图是如何工做的，但直接将HTML硬编码到你的视图里却并非一个好主意。 让咱们来看一下为何：
-
对页面设计进行的任何改变都必须对 Python 代码进行相应的修改。 站点设计的修改每每比底层 Python 代码的修改要频繁得多，所以若是能够在不进行 Python 代码修改的状况下变动设计，那将会方便得多。
-
Python 代码编写和 HTML 设计是两项不一样的工做，大多数专业的网站开发环境都将他们分配给不一样的人员（甚至不一样部门）来完成。 设计者和HTML/CSS的编码人员不该该被要求去编辑Python的代码来完成他们的工做。
-
程序员编写 Python代码和设计人员制做模板两项工做同时进行的效率是最高的，远胜于让一我的等待另外一我的完成对某个既包含 Python又包含 HTML 的文件的编辑工做。
基于这些缘由，将页面的设计和Python的代码分离开会更干净简洁更容易维护。 咱们可使用 Django的 模板系统 (Template System)来实现这种模式，这就是本章要具体讨论的问题。
------------------------------------------------------------------模板语法------------------------------------------------------------------
1、模版的组成
组成：HTML代码＋逻辑控制代码
2、 逻辑控制代码的组成
1 变量（使用双大括号来引用变量）：
语法格式： {{var_name}}
－－－－－－Template（模板）和Context（上下文）对象
>>> python manange.py shell (进入该django项目的环境) >>> from django.template import Context, Template >>> t = Template('My name is {{ name }}.') >>> c = Context({'name': 'Stephane'}) >>> t.render(c) 'My name is Stephane.' # 同一模板，多个上下文，一旦有了模板对象，你就能够经过它渲染多个context，不管什么时候咱们均可以 # 像这样使用同一模板源渲染多个context，只进行 一次模板建立而后屡次调用render()方法渲染会 # 更为高效： # Low(建立了3个相同的模板) for name in ('John', 'Julie', 'Pat'): t = Template('Hello, {{ name }}') print t.render(Context({'name': name})) # Good（推荐--建立了1个模板 用了3次） t = Template('Hello, {{ name }}') for name in ('John', 'Julie', 'Pat'): print t.render(Context({'name': name}))
Django 模板解析很是快捷。 大部分的解析工做都是在后台经过对简短正则表达式一次性调用来完成。 这和基于 XML 的模板引擎造成鲜明对比，那些引擎承担了 XML 解析器的开销，且每每比 Django 模板渲染引擎要慢上几个数量级。
from django.shortcuts import render,HttpResponse from django.template.loader import get_template #记得导入 # Create your views here. import datetime from django.template import Template,Context # def current_time(req): #原始的视图函数 # now=datetime.datetime.now() # html="<html><body>如今时刻：<h1>%s.</h1></body></html>" %now # return HttpResponse(html) # def current_time(req): #django模板修改的视图函数 # now=datetime.datetime.now() # t=Template('<html><body>如今时刻是:<h1 style="color:red">{{current_date}}</h1></body></html>') #t=get_template('current_datetime.html') # c=Context({'current_date':now}) # html=t.render(c) # return HttpResponse(html) #另外一种写法(推荐) def current_time(req): now=datetime.datetime.now() return render(req, 'current_datetime.html', {'current_date':now}) 推荐方式
－－－－－－深度变量的查找（万能的句点号）
在到目前为止的例子中，咱们经过 context 传递的简单参数值主要是字符串，然而，模板系统可以很是简洁地处理更加复杂的数据结构，例如list、dictionary和自定义的对象。
在 Django 模板中遍历复杂数据结构（字符串、列表、字典、类等）的关键是句点字符 (.)。
#最好是用几个例子来讲明一下。 # 首先，句点可用于访问列表索引，例如： >>> from django.template import Template, Context >>> t = Template('Item 2 is {{ items.2 }}.') >>> c = Context({'items': ['apples', 'bananas', 'carrots']}) >>> t.render(c) 'Item 2 is carrots.' #假设你要向模板传递一个 Python 字典。 要经过字典键访问该字典的值，可以使用一个句点： >>> from django.template import Template, Context >>> person = {'name': 'Sally', 'age': '43'} >>> t = Template('{{ person.name }} is {{ person.age }} years old.') >>> c = Context({'person': person}) >>> t.render(c) 'Sally is 43 years old.' #一样，也能够经过句点来访问对象的属性。 比方说， Python 的 datetime.date 对象有 #year 、 month 和 day 几个属性，你一样能够在模板中使用句点来访问这些属性： >>> from django.template import Template, Context >>> import datetime >>> d = datetime.date(1993, 5, 2) >>> d.year >>> d.month >>> d.day >>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.') >>> c = Context({'date': d}) >>> t.render(c) 'The month is 5 and the year is 1993.' # 这个例子使用了一个自定义的类，演示了经过实例变量加一点(dots)来访问它的属性，这个方法适 # 用于任意的对象。 >>> from django.template import Template, Context >>> class Person(object): ... def __init__(self, first_name, last_name): ... self.first_name, self.last_name = first_name, last_name >>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.') >>> c = Context({'person': Person('John', 'Smith')}) >>> t.render(c) 'Hello, John Smith.' # 点语法也能够用来引用对象的方法。 例如，每一个 Python 字符串都有 upper() 和 isdigit() # 方法，你在模板中可使用一样的句点语法来调用它们： >>> from django.template import Template, Context >>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}') >>> t.render(Context({'var': 'hello'})) 'hello -- HELLO -- False' >>> t.render(Context({'var': '123'})) '123 -- 123 -- True' # 注意这里调用方法时并* 没有* 使用圆括号 并且也没法给该方法传递参数；你只能调用不需参数的 # 方法。
－－－－－－变量的过滤器(filter)的使用
变量过滤器主要是处理后端视图函数传递给模板HTML的字符串
语法格式： {{obj|filter:param}}
# 1 add ： 给变量加上相应的值 # # 2 addslashes : 给变量中的引号前加上斜线 # # 3 capfirst : 首字母大写 # # 4 cut ： 从字符串中移除指定的字符 # # 5 date ： 格式化日期字符串 # # 6 default ： 若是值是False,就替换成设置的默认值，不然就是用原本的值 # # 7 default_if_none: 若是值是None，就替换成设置的默认值，不然就使用原本的值 #实例: #value1="aBcDe" {{ value1|upper }}<br> #value2=5 {{ value2|add:3 }}<br> #value3='he llo wo r ld' {{ value3|cut:' ' }}<br> #import datetime #value4=datetime.datetime.now() {{ value4|date:'Y-m-d' }}<br> #value5=[] {{ value5|default:'空的' }}<br> #value6='<a href="#">跳转</a>' {{ value6 }} {% autoescape off %} {{ value6 }} {% endautoescape %} {{ value6|safe }}<br> {{ value6|striptags }} #value7='1234' {{ value7|filesizeformat }}<br> {{ value7|first }}<br> {{ value7|length }}<br> {{ value7|slice:":-1" }}<br> #value8='http://www.baidu.com/?a=1&b=3' {{ value8|urlencode }}<br> value9='hello I am yuan'
实例演练：
--------------------------------------------------views from django.shortcuts import render,HttpResponse import datetime,time # Create your views here. class Animal(): def __init__(self,nation,color): self.nation = nation self.color = color def show_time(request): t = datetime.datetime.now() str1 = "hel lo wo r ld !" # 把变量渲染到html中(缺点：前端后端没有分开，python杂糅到HTML中 后续维护困难) # return HttpResponse("<html><body>it is now %s.</body></html>"%(t)) list1 = ['成龙','李小龙','甄子丹'] dict1 = {'name':'李明','sex':'男','age':'25'} myClass = Animal("china",'yellow') list2 = [] alink = "<a href='#'>click!</a>" str2 = "12a3bc4d" myurl = "https://i.cnblogs.com/PostDone.aspx?postid=10488757&actiontip=发布草稿成功" return render(request,"show_time.html",locals()) ------------------------------------------------------template/.html <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h1>time is: {{ t }}</h1> <h1>str1 is: {{ str1 }}</h1> <h1>list's list[0] is: {{ list1.0 }}</h1> <h1>list's list1[1] is: {{ list1.1 }}</h1> <h1>dict's name is: {{ dict1.name }}</h1> <h1>dict's age is: {{ dict1.age }}</h1> <h1>dict's sex is: {{ dict1.sex }}</h1> <h1>从类中取值: {{ myClass.nation }}</h1> <h1>从类中取值: {{ myClass.color }}</h1> {#－－－－－－变量的过滤器(filter)的使用#} <h1>李明的真实年龄：{{ dict1.age|add:10}}</h1> <h1>字符串的首字母大写：{{ myClass.nation|capfirst}}</h1> <h1>字符串中移除指定的字符--移除空格：{{ str1|cut:" "}}</h1> <h1>格式化日期时间：{{ t|date:"Y-m-d H:i:s"}}</h1> {# 2019-03-08 13:35:32 #} <h1>若是值是False,就替换成设置的默认值，不然就是用原本的值：{{ list2|default:"[空列表]" }}</h1> {#后端发给浏览器的HTML格式文本为了安全起见，默认为文本 不是以HTML格式渲染的，若想要HTML渲染---> obj|safe#} <h1>指定浏览器以HTML格式渲染,不加safe默认是文本：{{ alink }}</h1> <h1>指定浏览器以HTML格式渲染：{{ alink|safe }}</h1> {#与上面的效果相同，都是保证浏览器以html格式渲染 #} {% autoescape off %} {{ alink }} {% endautoescape %} {#对字符串进行操做#} <h1>字符串二进制大小：{{ str2|filesizeformat }}</h1> <h1>字符串：{{ str2|first }}</h1> <h1>字符串长度：{{ str2|length }}</h1> <h1>字符串切片：{{ str2|slice:":-1" }}</h1> {# 对url进行urlencode编码 #} <h2>urlencode编码：{{ myurl|urlencode }}</h2> </body> </html>
启用安全机制 --将字符串渲染为html标签
视图函数传递给模板的是字符串，若是要想浏览器将字符串渲染为html标签，须要启用安全机制：
#方法1 {{str1|safe}} #方法2 {% autoescape off %} {{ value6 }} {% endautoescape %}
二、标签(tag)的使用（使用大括号和百分比的组合来表示使用tag）
语法格式： {% tags %}
－－－－－－{% if %} 的使用
{% if %}标签计算一个变量值，若是是“true”，即它存在、不为空而且不是false的boolean值,系统则会显示{% if %}和{% endif %}间的全部内容
{% if num >= 100 and 8 %}
{% if num > 200 %}
<p>num大于200</p>
{% else %}
<p>num大于100小于200</p>
{% endif %}
{% elif num < 100%}
<p>num小于100</p>
{% else %}
<p>num等于100</p>
{% endif %}
{% if %} 标签接受and，or或者not来测试多个变量值或者否认一个给定的变量
{% if %} 标签不容许同一标签里同时出现and和or，不然逻辑容易产生歧义，例以下面的标签是不合法的：
{% if obj1 and obj2 or obj3 %}
－－－－－－{% for %}的使用
{% for %}标签容许你按顺序遍历一个序列中的各个元素,每次循环模板系统都会渲染{% for %}和{% endfor %}之间的全部内容
<ul> {% for obj in list %} <li>{{ obj.name }}</li> {% endfor %} </ul> #在标签里添加reversed来反序循环列表： {% for obj in list reversed %} ... {% endfor %} #{% for %}标签能够嵌套： {% for country in countries %} <h1>{{ country.name }}</h1> <ul> {% for city in country.city_list %} <li>{{ city }}</li> {% endfor %} </ul> {% endfor %} #系统不支持中断循环，系统也不支持continue语句，{% for %}标签内置了一个forloop模板变量， #这个变量含有一些属性能够提供给你一些关于循环的信息 1，forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1: {% for item in todo_list %} <p>{{ forloop.counter }}: {{ item }}</p> {% endfor %} 2，forloop.counter0 相似于forloop.counter，但它是从0开始计数，第一次循环设为0 3，forloop.revcounter 4，forloop.revcounter0 5，forloop.first当第一次循环时值为True，在特别状况下颇有用： {% for object in objects %} {% if forloop.first %}<li class="first">{% else %}<li>{% endif %} {{ object }} </li> {% endfor %} # 富有魔力的forloop变量只能在循环中获得，当模板解析器到达{% endfor %}时forloop就消失了 # 若是你的模板context已经包含一个叫forloop的变量，Django会用{% for %}标签替代它 # Django会在for标签的块中覆盖你定义的forloop变量的值 # 在其余非循环的地方，你的forloop变量仍然可用 #{% empty %} {{li }} {% for i in li %} <li>{{ forloop.counter0 }}----{{ i }}</li> {% empty %} <li>this is empty!</li> {% endfor %} # [11, 22, 33, 44, 55] # 0----11 # 1----22 # 2----33 # 3----44 # 4----55
{% if %}和{% for %}的实例练习：
--------------------------------------------views class Animal(): def __init__(self,nation,color): self.nation = nation self.color = color def show_time(request): t = datetime.datetime.now() str1 = "hel lo wo r ld !" # 把变量渲染到html中(缺点：前端后端没有分开，python杂糅到HTML中 后续维护困难) # return HttpResponse("<html><body>it is now %s.</body></html>"%(t)) list1 = ['成龙','爱因斯坦','李白','刘欢'] dict1 = {'name':'李明','sex':'男','age': 25} myClass = Animal("china",'yellow') list2 = [] list3 = ['actor','scientist','poem','singer'] alink = "<a href='#'>click!</a>" str2 = "12a3bc4d" myurl = "https://i.cnblogs.com/PostDone.aspx?postid=10488757&actiontip=发布草稿成功" return render(request,"show_time.html",locals()) ---------------------------------------------template/.html {#标签(tag)的使用（使用大括号和百分比的组合来表示使用tag）#} {% if dict1.age > 20 %} {% if dict1.age < 40 %} <p>{{ dict1.name }}的年龄为20~40</p> {% elif dict1.age < 60 %} <p>李明的年龄为40~60</p> {% else %} <p>李明的年龄大于60岁</p> {% endif %} {% elif dict1.age > 10 %} <p>李明的年龄为10~20</p> {% else %} <p>李明的年龄为{{ dict1.age }}</p> {% endif %} {#{% for %}的使用#} {% for f1 in list1 %} <table><tr>{{ f1 }} {% for f3 in list3 %} <td>{{ f3 }} <span>|</span></td> {% endfor %} </tr></table> {% endfor %} {# forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1:#} {% for item in list1 %} <p>{{ forloop.counter }}:{{ item }}</p> <p>{{ forloop.revcounter0 }}:{{ item }}</p> <hr/> {% endfor %} {#{% empty %}#} {% for item in list2 %} <h2>{{ forloop.counter0 }}:{{ item }}</h2> {% empty %} <h3>这个列表是空的！</h3> {% endfor %}
－－－－－－{%csrf_token%}：csrf_token标签
用于生成csrf_token的标签，用于防治跨站攻击验证。注意若是你在view的index里用的是render_to_response方法，不会生效
其实，这里是会生成一个input标签，和其余表单标签一块儿提交给后台的。
－－－－－－{% url %}: 引用路由配置的地址 或 别名
<form action="{% url "bieming"%}" > <input type="text"> <input type="submit"value="提交"> {%csrf_token%} </form>
－－－－－－{% with %}:用更简单的变量名替代复杂的变量名
{% with total=fhjsaldfhjsdfhlasdfhljsdal %} {{ total }} {% endwith %}
－－－－－－{% verbatim %}: 禁止render，渲染出来的内容就是 {{ hello }}
{% verbatim %}
{{ hello }}
{% endverbatim %}
－－－－－－{% load %}: 加载标签库
三、自定义filter和simple_tag（重要！！！）
－－－－－－a、在app中建立templatetags模块(必须的)
－－－－－－b、建立任意 .py 文件，如：my_tags.py
from django import template from django.utils.safestring import mark_safe register = template.Library() #register的名字是固定的,不可改变 @register.filter def filter_multi(v1,v2): return v1 * v2 @register.simple_tag def simple_tag_multi(v1,v2): return v1 * v2 @register.simple_tag def my_input(id,arg): result = "<input type='text' id='%s' class='%s' />" %(id,arg,) return mark_safe(result)
－－－－－－c、在使用自定义simple_tag和filter的html文件中导入以前建立的 my_tags.py ：{% load my_tags %}
－－－－－－d、使用simple_tag和filter（如何调用）
from django import template from django.utils.safestring import mark_safe register = template.Library() #register的名字是固定的,不可改变 # 只能传一个参数，注意参数能够是列表 @register.filter def filter_multi(v1,v2): return v1 * v2 # 能够传多个参数，可是不能用在if for等控制语句中 @register.simple_tag def simple_tag_multi(v1,v2,v3): return v1 * v2*v3 @register.simple_tag def my_input(types,id,arg): result = "<input type='%s' id='%s' class='%s' />" %(types,id,arg,) return mark_safe(result)
－－－－－－e、在settings中的INSTALLED_APPS配置当前app，否则django没法找到自定义的simple_tag.
自定义filter和自定义标签各有优缺点：
一、自定义filter 只能传一个参数，而自定义标签 能够传多个参数
二、filter能够用在if 等控制语句后，simple_tag不能够
{% if num|filter_multi:30 > 100 %}
{{ num|filter_multi:30 }}
{% endif %}
四、extend模板继承
－－－－－－include (将多个html中共用的部分提取出来)
主模板 include引入的模板
--->下图是浏览器输入url 后台对应的执行过程:
－－－－－－extend 模板继承
如下是使用模板继承的一些诀窍：
<1>若是在模板中使用 {% extends %} ，必须保证其为模板中的第一个模板标记。 不然，模板继承将不起做用。 <2>通常来讲，基础模板中的 {% block %} 标签越多越好。 记住，子模板没必要定义父模板中全部的代码块，所以 你能够用合理的缺省值对一些代码块进行填充，而后只对子模板所需的代码块进行（重）定义。 俗话说，钩子越 多越好。 <3>若是发觉本身在多个模板之间拷贝代码，你应该考虑将该代码段放置到父模板的某个 {% block %} 中。 若是你须要访问父模板中的块的内容，使用 {{ block.super }}这个标签吧，这一个魔法变量将会表现出父模 板中的内容。 若是只想在上级代码块基础上添加内容，而不是所有重载，该变量就显得很是有用了。 <4>不容许在同一个模板中定义多个同名的 {% block %} 。 存在这样的限制是由于block 标签的工做方式是双向的。 也就是说，block 标签不只挖了一个要填的坑，也定义了在父模板中这个坑所填充的内容。若是模板中出现了两个 相同名称的 {% block %} 标签，父模板将无从得知要使用哪一个块的内容。
实例练习：
代码：
-----------------------------------------------------urls from django.contrib import admin from django.conf.urls import url from app01 import views urlpatterns = [ url('admin/', admin.site.urls), url('base/', views.backend), url('student/', views.student), url('teacher/', views.teacher), url('course/', views.course), url('classes/', views.classes), ] ------------------------------------------------------views from django.shortcuts import render # Create your views here. def backend(request): return render(request,"base.html") def student(request): student_list = ['唐僧','悟空','悟能','悟净'] return render(request,"student.html",locals()) def teacher(request): teachers_list = ['如来','观音','弥勒','菩提'] return render(request,"teacher.html",locals()) def course(request): course_list = ['语文','数学','英语','科学'] return render(request,"course.html",locals()) def classes(request): classes_list = ['三年一班','四年二班','五年三班','六年一班'] return render(request,"classes.html",locals()) --------------------------------------------------------template/.html --------------------------------------base.html <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>首页</title> <style> *{margin: 0; padding: 0; } a{text-decoration: none} .head-box{ width: 100%; height: 80px; background-color: cadetblue; font-size: 26px; font-weight: 700; text-align: center; line-height: 80px; } .left-box{ display: inline-block; float: left; width: 25%; min-height: 800px; background-color: darkgray; } .left-box div{ width: 100%; height: 100px; text-align: center; line-height: 80px; font-size: 30px; font-weight: 500; {#border: 1px solid darkred;#} } .content-box{ display: inline-block; float: right; width: 75%; min-height: 800px; font-size: 50px; font-weight: 700; color: darkred; text-align: center; } .footer-box{ float: left; width: 100%; height: 120px; text-align: center; line-height: 120px; background-color: lightgreen; } </style> </head> <body> <div class="outer"> <div class="head-box">校务信息管理系统</div> <div class="left-box"> <div class="student manage"><a href="/student/">学生信息</a></div> <hr> <div class="teacher manage"><a href="/teacher/">老师信息</a></div> <hr> <div class="course manage"><a href="/course/">课程信息</a></div> <hr> <div class="classes manage"><a href="/classes">班级信息</a></div> </div> <div class="content-box"> {% block content %} {# 块随便取个名字 但必须惟一 #} <h5>欢迎来到校务管理系统首页！</h5> {% endblock %} </div> <div class="footer-box">底部栏</div> </div> </body> </html> ------------------------------------------student.html {% extends "base.html" %} {% block content %} {% for item in student_list %} <h5>学生：{{ item }}</h5> {% endfor %} {% endblock %} -------------------------------------------teacher.html {% extends "base.html" %} {% block content %} {% for item in teachers_list %} <h5>教师：{{ item }}</h5> {% endfor %} {% endblock %} -------------------------------------------course.html {% extends "base.html" %} {% block content %} {% for item in course_list %} <h5>课程：{{ item }}</h5> {% endfor %} {% endblock %} ------------------------------------------classes.html {% extends "base.html" %} {% block content %} {% for item in classes_list %} <h5>班级：{{ item }}</h5> {% endfor %} {% endblock %}
8、Models -- 操做数据库
数据库的配置
1 django默认支持sqlite，mysql, oracle,postgresql数据库。
<1> sqlite
django默认使用sqlite的数据库，默认自带sqlite的数据库驱动 , 引擎名称：django.db.backends.sqlite3
<2> mysql
引擎名称：django.db.backends.mysql
2 mysql驱动程序
- MySQLdb(mysql python)
- mysqlclient
- MySQL
- PyMySQL(纯python的mysql驱动程序)
3 在django的项目中会默认使用sqlite数据库，在settings里有以下设置：
若是咱们想要将数据库更改成mysql，须要修改以下：
在settings.py中修改DATABASE配置
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'books', #你的数据库名称 'USER': 'root', #你的数据库用户名 'PASSWORD': '', #你的数据库密码 'HOST': '', #你的数据库主机，留空默认为localhost 'PORT': '3306', #你的数据库端口 } }
注意：
NAME即数据库的名字，在mysql链接前该数据库必须已经建立，而上面的sqlite数据库下的db.sqlite3则是项目自动建立 USER和PASSWORD分别是数据库的用户名和密码。 设置完后，再启动咱们的Django项目前，咱们须要激活咱们的mysql。 而后，启动项目，会报错：no module named MySQLdb 这是由于django默认你导入的驱动是MySQLdb，但是MySQLdb对于py3有很大问题，因此咱们须要的驱动是PyMySQL 因此，咱们只须要找到项目名文件下的__init__,在里面写入： import pymysql pymysql.install_as_MySQLdb() 问题解决！
Django链接MySQL出错
错误一：No module named 'MySQLdb'
错误二：django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.13 or newer is required; you have 0.9.3.
Django链接MySQL出错 错误一：No module named 'MySQLdb' 缘由：python3链接MySQL不能再使用mysqldb，取而代之的是pymysql。 解决方法：在python的MySQL包中，即路径：C:\Users\adong\AppData\Local\Programs\Python\Python36\Lib\site-packages\Django-2.0.3-py3.6.egg\django\db\backends\mysql 下的__init__.py文件中加入： import pymysql pymysql.install_as_MySQLdb() 错误二：django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.3 or newer is required; you have 0.7.11.None 缘由：在解决了错误一之后出现了此错误。 解决方法：在python的MySQL包中，即路径：C:\Users\Administrator\AppData\Local\Programs\Python\Python36\Lib\site-packages\Django-2.2.4-py3.6.egg\django\db\backends\mysql 下的 base.py 文件中，注释掉一下两行代码： if version < (1, 3, 3): raise ImproperlyConfigured("mysqlclient 1.3.3 or newer is required; you have %s" % Database.__version__)
8、ORM--------------Object Relation Mapping(对象关系映射)
用于实现面向对象编程语言里不一样类型系统的数据之间的转换，换言之，就是用面向对象的方式去操做数据库的建立表以及增删改查等操做。
---对象指的就是python中的类对象
优势： 一、 ORM使得咱们的通用数据库交互变得简单易行，并且彻底不用考虑该死的SQL语句。快速开发，由此而来。
二、 能够避免一些新手程序猿写sql语句带来的性能问题。
3 、便于搬家迁移，换数据库以后 ORM调用的语法类似 换个sql接口就能够了
好比 咱们查询User表中的全部字段:
新手可能会用select ＊ from auth_user,这样会由于多了一个匹配动做而影响效率的。
缺点：一、 性能有所牺牲，不过如今的各类ORM框架都在尝试各类方法，好比缓存，延迟加载登来减轻这个问题。效果很显著。
二、 对于个别复杂查询，ORM仍然力不从心，为了解决这个问题，ORM通常也支持写raw sql。
三、 经过QuerySet的query属性查询对应操做的sql语句
author_obj=models.Author.objects.filter(id=2) print(author_obj.query)
下面要开始学习Django ORM语法了，为了更好的理解，咱们来作一个基本的 书籍/做者/出版商 数据库结构。 咱们这样作是由于 这是一个众所周知的例子，不少SQL有关的书籍也经常使用这个举例。
数据库表 的建立：
实例：咱们来假定下面这些概念，字段和关系
做者模型：一个做者有姓名。
做者详细模型：把做者的详情放到详情表，包含性别，email地址和出生日期，做者详情模型和做者模型之间是一对一的关系（one－to－one）（相似于每一个人和他的身份证之间的关系），在大多数状况下咱们没有必要将他们拆分红两张表，这里只是引出一对一的概念。
出版商模型：出版商有名称，地址，所在城市，省，国家和网站。
书籍模型：书籍有书名和出版日期，一本书可能会有多个做者，一个做者也能够写多本书，因此做者和书籍的关系就是多对多的关联关系（many－to－many），一本书只应该由一个出版商出版，因此出版商和书籍是一对多关联关系（one－to－many），也被称做外键。
from django.db import models<br> class Publisher(models.Model): name = models.CharField(max_length=30, verbose_name="名称") address = models.CharField("地址", max_length=50) city = models.CharField('城市',max_length=60) state_province = models.CharField(max_length=30) country = models.CharField(max_length=50) website = models.URLField() class Meta: verbose_name = '出版商' verbose_name_plural = verbose_name def __str__(self): return self.name class Author(models.Model): name = models.CharField(max_length=30) def __str__(self): return self.name class AuthorDetail(models.Model): sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),)) email = models.EmailField() address = models.CharField(max_length=50) birthday = models.DateField() author = models.OneToOneField(Author) class Book(models.Model): title = models.CharField(max_length=100) authors = models.ManyToManyField(Author) publisher = models.ForeignKey(Publisher) publication_date = models.DateField() price=models.DecimalField(max_digits=5,decimal_places=2,default=10) def __str__(self): return self.title
注意1：记得在settings里的INSTALLED_APPS中加入'app01',而后再同步数据库。
注意2: models.ForeignKey("Publish") & models.ForeignKey(Publish)
注意3：（注意要将外键写在‘多’的一方）。Django支持通用的数据关系：一对一，多对一和多对多。
分析代码：
<1> 每一个数据模型都是django.db.models.Model的子类，它的父类Model包含了全部必要的和数据库交互的方法。并提供了一个简介漂亮的定义数据库字段的语法。
<2> 每一个模型至关于单个数据库表（多对多关系例外，会多生成一张关系表），每一个属性也是这个表中的字段。属性名就是字段名，它的类型（例如CharField）至关于数据库的字段类型（例如varchar）。你们能够留意下其它的类型都和数据库里的什么字段对应。
<3> 模型之间的三种关系：一对一，一对多，多对多。
一对一：实质就是在主外键（author_id就是foreign key）的关系基础上，给外键加了一个UNIQUE＝True的属性；
一对多：就是主外键关系；（foreign key）
多对多：(ManyToManyField) 自动建立第三张表(固然咱们也能够本身建立第三张表：两个foreign key)
<4> 模型经常使用的字段类型参数
<1> CharField #字符串字段, 用于较短的字符串. #CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所容许的最大字符数. <2> IntegerField #用于保存一个整数. <3> FloatField # 一个浮点数. 必须 提供两个参数: # # 参数 描述 # max_digits 总位数(不包括小数点和符号) # decimal_places 小数位数 # 举例来讲, 要保存最大值为 999 (小数点后保存2位),你要这样定义字段: # # models.FloatField(..., max_digits=5, decimal_places=2) # 要保存最大值一百万(小数点后保存10位)的话,你要这样定义: # # models.FloatField(..., max_digits=19, decimal_places=10) # 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参数.
<5> Field重要参数
<1> null ： 数据库中字段是否能够为空 <2> blank： django的 Admin 中添加数据时是否可容许空值 <3> default：设定缺省值 <4> editable：若是为假，admin模式下将不能改写。缺省为真 <5> primary_key：设置主键，若是没有设置django建立表时会自动加上： id = meta.AutoField('ID', primary_key=True) primary_key=True implies blank=False, null=False and unique=True. Only one primary key is allowed on an object. <6> unique：数据惟一 <7> verbose_name Admin中字段的显示名称 <8> validator_list：有效性检查。非有效产生 django.core.validators.ValidationError 错误 <9> db_column，db_index 若是为真将为此字段建立索引 <10>choices：一个用来选择值的2维元组。第一个值是实际存储的值，第二个用来方便进行选择。 如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),) gender = models.CharField(max_length=2,choices = SEX_CHOICES)
注意3：在models.py中添加的类 就至关于操做sql命令中建立的表，添加以后要在terminal控制台中进行下列操做生成表
第一步：
python manage.py makemigrations
class Book(models.Model): name = models.CharField(max_length=30) price = models.IntegerField() pub_date = models.DateField() author = models.CharField(max_length=50,null=False) #默认null=True 便可觉得空
当在models.py 中的类对象里设置 null=False ，会出现下列问题：（须要选择1 再设置一个
author = models.CharField(max_length=50,null=False)
为空时的 默认值便可）
D:\360Downloads\Python编程\老男孩python全栈\day49+50-Django\Django_begin_ORM>>>python manage.py makemigrations (0.001) SELECT @@SQL_AUTO_IS_NULL; args=None (0.001) SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; args=None (0.003) SHOW FULL TABLES; args=None (0.001) SELECT `django_migrations`.`app`, `django_migrations`.`name` FROM `django_migrations`; args=() You are trying to add a non-nullable field 'author' to book without a default; we can't do that (the database need s something to populate existing rows). Please select a fix: 1) Provide a one-off default now (will be set on all existing rows with a null value for this column) 2) Quit, and let me add a default in models.py Select an option: 1 Please enter the default value now, as valid Python The datetime and django.utils.timezone modules are available, so you can do e.g. timezone.now Type 'exit' to exit this prompt >>> "xiong" Migrations for 'app01': app01\migrations\0003_book_author.py - Add field author to book
表的操做(增删改查)：
-------------------------------------增(create , save) -------------------------------
from app01.models import *
#create方式一: Author.objects.create(name='Alvin')
#create方式二: Author.objects.create(**{"name":"alex"})
#save方式一: author=Author(name="alvin")
author.save()
#save方式二: author=Author()
author.name="alvin"
author.save()
如何建立存在一对多或多对多关系的一本书的信息呢？(如何处理外键关系的字段如一对多的publisher和多对多的authors)
#一对多(ForeignKey):
#方式一: 因为绑定一对多的字段,好比publish,存到数据库中的字段名叫publish_id,因此咱们能够直接给这个
# 字段设定对应值:
Book.objects.create(title='php',
publisher_id=2, #这里的2是指为该book对象绑定了Publisher表中id=2的行对象
publication_date='2017-7-7',
price=99)
#方式二:
# <1> 先获取要绑定的Publisher对象:
pub_obj=Publisher(name='河大出版社',address='保定',city='保定',
state_province='河北',country='China',website='http://www.hbu.com')
OR pub_obj=Publisher.objects.get(id=1)
# <2>将 publisher_id=2 改成 publisher=pub_obj
#多对多(ManyToManyField()):
author1=Author.objects.get(id=1)
author2=Author.objects.filter(name='alvin')[0]
book=Book.objects.get(id=1)
book.authors.add(author1,author2)
#等同于:
book.authors.add(*[author1,author2])
book.authors.remove(*[author1,author2])
#-------------------
book=models.Book.objects.filter(id__gt=1)
authors=models.Author.objects.filter(id=1)[0]
authors.book_set.add(*book)
authors.book_set.remove(*book)
#-------------------
book.authors.add(1)
book.authors.remove(1)
authors.book_set.add(1)
authors.book_set.remove(1)
#注意: 若是第三张表是经过models.ManyToManyField()自动建立的,那么绑定关系只有上面一种方式
#本身手动建立的第三张表
class Book2Author(models.Model):
author=models.ForeignKey("Author",on_delete=models.CASCADE)
Book= models.ForeignKey("Book",on_delete=models.CASCADE)
#那么就还有一种方式:
author_obj=models.Author.objects.filter(id=2)[0]
book_obj =models.Book.objects.filter(id=3)[0]
models.Book2Author.objects.create(author_id=1,Book_id=2)
s=models.Book2Author(author=author_obj,Book_id=1)
s.save()
-----------------------------------------删（delete） ---------------------------------------------
def delete(request): Book.objects.filter(author="alex").delete() return HttpResponse("删除书籍成功！")
咱们表面上删除了一条信息，实际却删除了三条，由于咱们删除的这本书在app01_Book_author表中有两条author_id = 1 相关信息，这种删除方式就是django默认的级联删除 models.CASCADE
若是是多对多的关系： remove()和clear()方法：
#正向 book = models.Book.objects.filter(id=1)[0] #删除第三张表中和女孩1关联的全部关联信息 book.author.clear() #清空与book中id=1 关联的全部数据 book.author.remove(2) #能够为id,author_id=2 被删 book.author.remove(*[1,2,3,4]) #能够为列表,前面加* #反向 author = models.Author.objects.filter(id=1)[0] author.book_set.clear() #清空与boy中id=1 关联的全部数据
-----------------------------------------改（update和save） ----------------------------------------
实例：
注意：
<1> 第二种方式修改不能用get的缘由是：update是QuerySet对象的方法，get返回的是一个model对象，它没有update方法，而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合，好比name＝'alvin',可能有两个name＝'alvin'的行数据)。
<2>在“插入和更新数据”小节中，咱们有提到模型的save()方法，这个方法会更新一行里的全部列。 而某些状况下，咱们只须要更新行里的某几列。
#---------------- update方法直接设定对应属性---------------- models.Book.objects.filter(id=3).update(title="PHP") ##sql: ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3) #--------------- save方法会将全部属性从新设定一遍,效率低----------- obj=models.Book.objects.filter(id=3)[0] obj.title="Python" obj.save() # SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", # "app01_book"."color", "app01_book"."page_num", # "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; # # UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556, # "publisher_id" = 1 WHERE "app01_book"."id" = 3;
在这个例子里咱们能够看到Django的save()方法更新了不只仅是title列的值，还有更新了全部的列。 若title之外的列有可能会被其余的进程所改动的状况下，只更改title列显然是更加明智的。更改某一指定的列，咱们能够调用结果集（QuerySet）对象的update()方法,与之等同的SQL语句变得更高效，而且不会引发竞态条件。
此外，update()方法对于任何结果集（QuerySet）均有效，这意味着你能够同时更新多条记录update()方法会返回一个整型数值，表示受影响的记录条数。
注意：这里由于update返回的是一个整形，因此无法用query属性；
注意：若是是多对多的改：
obj=Book.objects.filter(id=1)[0] author=Author.objects.filter(id__gt=2) obj.author.clear() obj.author.add(*author)
---------------------------------------查（filter，values等) -------------------------------------重要！！！
---------->查询API：
# 查询相关API： ## <1>filter(**kwargs): 它包含了与所给筛选条件相匹配的对象（返回一个可迭代对象） ## <2>all(): 查询全部结果（返回一个可迭代对象） ## <3>get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，若是符合筛选条件的对象超过一个或者没有都会抛出错误。 #-----------下面的方法都是对查询的结果再进行处理:好比 objects.filter.values()-------- ## <4>values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后获得的并非一系列 model的实例化对象，而是一个可迭代的字典序列 ## <5>exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象 ## <6>order_by(*field): 对查询结果排序 # <7>reverse(): 对查询结果反向排序 ## <8>distinct(): 从返回结果中剔除重复纪录 ## <9>values_list(*field): 它与values()很是类似，它返回的是一个元组序列，values返回的是一个字典序列 ## <10>count(): 返回数据库中匹配查询(QuerySet)的对象数量。 # <11>first(): 返回第一条记录 # <12>last(): 返回最后一条记录 # <13>exists(): 若是QuerySet包含数据，就返回True，不然返回False。
实例练习：
-------------------------------------models.py # Create your models here. class Book(models.Model): name = models.CharField(max_length=30) price = models.IntegerField(null=True) pub_date = models.DateField(null=True) author = models.CharField(max_length=50,null=False) #默认null=False 即不能够为空 # 加了默认的方法以后，打印出来的是name 而不是对象方法 def __str__(self): return self.name ------------------------------------.html <div class="bookInfo"> {% for book in book_list %} <h4>书名：{{ book.name }} <span>|</span> 做者：{{ book.author }} <span>|</span> 价格：{{ book.price }} <span>|</span> </h4> {% endfor %} </div> ---------------------------------------views def queryBook(request): # <1>filter(**kwargs): 它包含了与所给筛选条件相匹配的对象(返回一个可迭代对象) book_list = Book.objects.filter(author='xiong') # <2>all(): 查询全部结果 book_list = Book.objects.all() ## <3>get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，若是符合筛选条件的对象超过一个或者没有都会抛出错误。 one_book = Book.objects.get(name='PHP') print("get方法返回结果：",one_book) first_book = Book.objects.first() last_book = Book.objects.last() print("first方法返回结果：", first_book) print("last方法返回结果：", last_book) ## <4>values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后获得的并非一系列 model的实例化对象，而是一个可迭代的字典序列 book_list = Book.objects.all()[:3].values("name","author") book_list = Book.objects.all()[::2] #切片：梯度为2 # < 9 > values_list(*field): 它与values() 很是类似，它返回的是一个元组序列，values返回的是一个字典序列 book_list = Book.objects.filter(author='xiong')[:3].values_list("name","author") book_list = Book.objects.exclude(author='xiong')[:3].values_list("name","author") # <8>distinct(): 从返回结果中剔除重复纪录 book_list = Book.objects.all().values("author").distinct() #按照author去重,并显示name price # <10>count(): 返回数据库中匹配查询(QuerySet)的对象数量。 book_count = Book.objects.all().values("author").distinct().count() print("按照做者去重以后书籍数量为：",book_count) return render(request,"index.html",{"book_list":book_list})
补充：
#扩展查询,有时候DJANGO的查询API不能方便的设置查询条件，提供了另外的扩展查询方法extra: #extra(select=None, where=None, params=None, tables=None,order_by=None, select_params=None (1) Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"}) (2) Blog.objects.extra( select=SortedDict([('a', '%s'), ('b', '%s')]), select_params=('one', 'two')) (3) q = Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"}) q = q.extra(order_by = ['-is_recent']) (4) Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
---------->QuerySet对象 惰性机制：
所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会立刻执行sql，而是当调用QuerySet的时候才执行。
<QuerySet [{'name': 'php', 'price': 75.0}, {'name': 'c++', 'price': 36.0}]>
QuerySet 对象特色：
<1> 可迭代的
<2> 可切片
#objs=models.Book.objects.all()#[obj1,obj2,ob3...] #QuerySet: 可迭代 # for obj in objs:#每一obj就是一个行对象 # print("obj:",obj) # QuerySet: 可切片 # print(objs[1]) # print(objs[1:4]) # print(objs[::-1])
---> QuerySet惰性机制的深入理解：
<1>Django的queryset是惰性的 Django的queryset对应于数据库的若干记录（row），经过可选的查询来过滤。例如，下面的代码会得 到数据库中名字为‘Dave’的全部的人:person_set = Person.objects.filter(first_name="Dave") 上面的代码并无运行任何的数据库查询。你可使用person_set，给它加上一些过滤条件，或者将它传给某个函数， 这些操做都不会发送给数据库。这是对的，由于数据库查询是显著影响web应用性能的因素之一。 <2>要真正从数据库得到数据，你能够遍历queryset或者使用if queryset,总之你用到数据时就会执行sql. 为了验证这些,须要在settings里加入 LOGGING(验证方式) obj=models.Book.objects.filter(id=3) # for i in obj: # print(i) # if obj: # print("ok") <3>queryset是具备cache的 当你遍历queryset时，全部匹配的记录会从数据库获取，而后转换成Django的model。这被称为执行 （evaluation）.这些model会保存在queryset内置的cache中，这样若是你再次遍历这个queryset， 你不须要重复运行通用的查询。 obj=models.Book.objects.filter(id=3) # for i in obj: # print(i) ## models.Book.objects.filter(id=3).update(title="GO") ## obj_new=models.Book.objects.filter(id=3) # for i in obj: # print(i) #LOGGING只会打印一次 <4> 简单的使用if语句进行判断也会彻底执行整个queryset而且把数据放入cache，虽然你并不须要这些 数据！为了不这个，能够用exists()方法来检查是否有数据： obj = Book.objects.filter(id=4) # exists()的检查能够避免数据放入queryset的cache。 if obj.exists(): print("hello world!") <5>当queryset很是巨大时，cache会成为问题 处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统 进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可使用iterator()方法 来获取数据，处理完数据就将其丢弃。 objs = Book.objects.all().iterator() # iterator()能够一次只从数据库获取少许数据，这样能够节省内存 for obj in objs: print(obj.name) #BUT,再次遍历没有打印,由于迭代器已经在上一次遍历(next)到最后一次了,没得遍历了 for obj in objs: print(obj.name) #固然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。因此使 #用iterator()的时候要小心，确保你的代码在操做一个大的queryset时没有重复执行查询 总结: queryset的cache是用于减小程序对数据库的查询，在一般的使用下会保证只有在须要的时候才会查询数据库。 使用exists()和iterator()方法能够优化程序对内存的使用。不过，因为它们并不会生成queryset cache，可能 会形成额外的数据库查询。
下面的一些状况，QuerySet才去查询数据库：
1.迭代操做
2.切片操做
3.repr()方法
repr() 函数将对象转化为供解释器读取的形式。
4.len()方法
5.list()方法
6.bool(),or,and,if
如 if Book.objects.filter(id=1):
---------->对象查询，单表条件查询，多表条件关联查询
#--------------------对象形式的查找-------------------------- # 正向查找 ret1=models.Book.objects.first() print(ret1.title) print(ret1.price) print(ret1.publisher) print(ret1.publisher.name) #由于一对多的关系因此ret1.publisher是一个对象,而不是一个queryset集合 # 反向查找 ret2=models.Publish.objects.last() print(ret2.name) print(ret2.city) #如何拿到与它绑定的Book对象呢? print(ret2.book_set.all()) #ret2.book_set是一个queryset集合 #---------------了不得的双下划线(__)之单表条件查询---------------- # models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 # # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于十一、2二、33的数据 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 # # models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and # # startswith，istartswith, endswith, iendswith, #----------------了不得的双下划线(__)之多表条件关联查询--------------- # 正向查找(条件) # ret3=models.Book.objects.filter(title='Python').values('id') # print(ret3)#[{'id': 1}] #正向查找(条件)之一对多 ret4=models.Book.objects.filter(title='Python').values('publisher__city') print(ret4) #[{'publisher__city': '北京'}] #正向查找(条件)之多对多 ret5=models.Book.objects.filter(title='Python').values('author__name') print(ret5) ret6=models.Book.objects.filter(author__name="alex").values('title') print(ret6) #注意 #正向查找的publisher__city或者author__name中的publisher,author是book表中绑定的字段 #一对多和多对多在这里用法没区别 # 反向查找(条件) #反向查找之一对多: ret8=models.Publisher.objects.filter(book__title='Python').values('name') print(ret8)#[{'name': '人大出版社'}] 注意,book__title中的book就是Publisher的关联表名 ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors') print(ret9)#[{'book__authors': 1}, {'book__authors': 2}] #反向查找之多对多: ret10=models.Author.objects.filter(book__title='Python').values('name') print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}] #注意 #正向查找的book__title中的book是表名Book #一对多和多对多在这里用法没区别
单表模糊查询之 双下划线 __ 实例练习：
#---------------了不得的双下划线(__)之单表条件查询---------------- # models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 # # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于十一、2二、33的数据 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 # # models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and # # startswith，istartswith, endswith, iendswith,
【对象查询】多表关联查询--一对多 实例练习：（注意：一对多的状况下 外键通常都建在多的一方。好比 部门-->员工 一个部门对应多个员工 外键建在员工一方）
参考：https://www.cnblogs.com/aaronthon/p/9520832.html https://www.jianshu.com/p/b0895eb45885 ---------------------------------------------------------views.py def addbook(request): # 添加数据库记录 # 方式一 Book.objects.create(name="linux运维",price=89,pub_date='2017-4-5',publish_id=2) # 方式二： publish_obj = Publish.objects.filter(name="图灵出版社")[0] Book.objects.create(name="java开发",price=59,pub_date='2017-4-5',publish=publish_obj) # 多表操做：一对多查询记录 # 正向查询 pub_obj = Publish.objects.get(name='人民出版社') ret = Book.objects.filter(publish=pub_obj).values('name','price') print(ret) #反向查询 pub_obj = Publish.objects.filter(name='人民出版社')[0] # pub_obj.book_set.all() 与 pub_obj关联的book表集合 的左右对象，再取出values('name','price') print(pub_obj.book_set.all().values('name','price')) return HttpResponse("添加书籍成功！")
【双下划线查询】多表关联查询
-------------------------------------------------------views.py # # 【双下划线查询】多表操做：一对多查询记录 # 查：人民出版社出过的全部书 ---找书 ret = Book.objects.filter(publish__name='人民出版社').values('name','price') # print(ret) # 查：出版 php入门 的出版社的信息 ---找出版社 ret = Publish.objects.filter(book__name='php入门').values('name','city') # print(ret) # 查：city是北京的出版社出过的全部书 --->找书 ret = Book.objects.filter(publish__city='香港').values('name') # print(ret) # 总结：找什么就用什么类在前面去过滤 即： ***.objects.filter() # 练习--查：2017年上半年（2017-01-01至2017-07-01）出版的书以及出版社信息 ret = Book.objects.filter(pub_date__gt='2017-01-01',pub_date__lt='2017-07-01').values('name','publish__name') print(ret) return HttpResponse("添加书籍成功！")
多表操做--->多对多查询
-------------------------------------------------------views.py # 多对多查询，方式一：经过manytomany 添加第三张表 # 查：python这本书的做者信息 # 正向查 # ret = Book.objects.filter(name='python').values('authors__age','authors__name') # print(ret) # 给c语言这本书(id=6) 添加Author中的全部做者 # book_obj = Book.objects.get(name='c语言') # author_objs = Author.objects.all() # book_obj.authors.add(*author_objs) # authors 是对象，*author_objs（author_objs是querySet集合对象要在前面加一个*） # 将c语言这本书(id=6) 移除掉Author中的做者 # book_obj.authors.remove(*author_objs) #移除掉全部做者 # book_obj.authors.remove(2) #移除掉author_id=2 的做者 # 方式二：自定义一个第三方表 # 给第三方表添加信息 # book_author_obj = Book_Author.objects.create(book_id=1,author_id=2) # book_obj = Book.objects.get(id=1) # print(book_obj.book_author_set.all()[0]) # 练习 - -查：xiong 出过的书 名称和价格 ret = Book.objects.filter(book_author__author__name='xiong').values('name','price') print(ret)
注意：条件查询即与对象查询对应，是指在filter，values等方法中的经过__来明确查询条件。
---------->聚合查询和分组查询
<1> aggregate(*args,**kwargs):
经过对QuerySet进行计算，返回一个聚合值的字典。aggregate()中每个参数都指定一个包含在字典中的返回值。即在查询集上生成聚合。
from django.db.models import Avg,Min,Sum,Max 从整个查询集生成统计值。好比，你想要计算全部在售书的平均价钱。Django的查询语法提供了一种方式描述全部 图书的集合。 >>> Book.objects.all().aggregate(Avg('price')) {'price__avg': 34.35} aggregate()子句的参数描述了咱们想要计算的聚合值，在这个例子中，是Book模型中price字段的平均值 aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的 标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。若是你想要为聚合值指定 一个名称，能够向聚合子句提供它: >>> Book.objects.aggregate(average_price=Avg('price')) {'average_price': 34.35} 若是你也想知道全部图书价格的最大值和最小值，能够这样查询： >>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price')) {'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
<2> annotate(*args,**kwargs):
能够经过计算查询结果中每个对象所关联的对象集合，从而得出总计值(也能够是平均值或总和)，即为查询集的每一项生成聚合。
查询alex出的书总价格
查询各个做者出的书的总价格,这里就涉及到分组了，分组条件是authors__name
查询各个出版社最便宜的书价是多少
注意：
Django在根据models生成数据库表时报 __init__() missing 1 required positional argument: 'on_delete'
-----------------------------------------------models.py #encoding=utf-8 from django.db import models # Create your models here. class BookInfo(models.Model): #建立书本信息类，继承models.Model booktitle=models.CharField(max_length=20) bookdata=models.DateField() class HeroInfo(models.Model): #建立英雄信息类 heroname=models.CharField(max_length=10) herosex=models.BooleanField() herocontent=models.CharField(max_length=50) herobook=models.ForeignKey('BookInfo') #引用外键，即BookInfo对象 ------------------------------------------------terminal 错误 TypeError: __init__() missing 1 required positional argument: 'on_delete' ------------------------------------------------解决办法 解决办法： 将 引用外键 models.ForeignKey()代码改成： herobook=models.ForeignKey('BookInfo',on_delete=models.CASCADE,) 即在外键值的后面加上 on_delete=models.CASCADE 缘由： 在django2.0后，定义外键和一对一关系的时候须要加on_delete选项，此参数为了不两个表里的数据不一致问题，否则会报错： TypeError: __init__() missing 1 required positional argument: 'on_delete' 举例说明： user=models.OneToOneField(User) owner=models.ForeignKey(UserProfile) 须要改为： user=models.OneToOneField(User,on_delete=models.CASCADE) --在老版本这个参数（models.CASCADE）是默认值 owner=models.ForeignKey(UserProfile,on_delete=models.CASCADE) --在老版本这个参数（models.CASCADE）是默认值 参数说明： on_delete有CASCADE、PROTECT、SET_NULL、SET_DEFAULT、SET()五个可选择的值 CASCADE：此值设置，是级联删除。 PROTECT：此值设置，是会报完整性错误。 SET_NULL：此值设置，会把外键设置为null，前提是容许为null。 SET_DEFAULT：此值设置，会把设置为外键的默认值。 SET()：此值设置，会调用外面的值，能够是一个函数。 通常状况下使用CASCADE就能够了。
---------->F查询和Q查询
在filter() 中实现过滤条件的 与 或 非：
# F 使用查询条件的值,专门取对象中某列值的操做 # from django.db.models import F # models.Tb1.objects.update(num=F('num')+1) # Q 构建搜索条件 from django.db.models import Q #1 Q对象(django.db.models.Q)能够对关键字参数进行封装，从而更好地应用多个查询 q1=models.Book.objects.filter(Q(title__startswith='P')).all() print(q1)#[<Book: Python>, <Book: Perl>] # 二、能够组合使用&,|操做符，当一个操做符是用于两个Q的对象,它产生一个新的Q对象。 Q(title__startswith='P') | Q(title__startswith='J') # 三、Q对象能够用~操做符放在前面表示否认，也可容许否认与不否认形式的组合 Q(title__startswith='P') | ~Q(pub_date__year=2005) # 四、应用范围： # Each lookup function that takes keyword-arguments (e.g. filter(), # exclude(), get()) can also be passed one or more Q objects as # positional (not-named) arguments. If you provide multiple Q object # arguments to a lookup function, the arguments will be “AND”ed # together. For example: Book.objects.get( Q(title__startswith='P'), Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)) ) #sql: # SELECT * from polls WHERE question LIKE 'P%' # AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06') # import datetime # e=datetime.date(2005,5,6) #2005-05-06 # 五、Q对象能够与关键字参数查询一块儿使用，不过必定要把Q对象放在关键字参数查询的前面。 # 正确： Book.objects.get( Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)), title__startswith='P') # 错误： Book.objects.get( question__startswith='P', Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
raw SQL语句
django中models的操做, 是调用了ORM框架来实现的 pymysql 或者mysqldb。因此咱们也可使用原生的SQL语句来操做数据库！
9、admin ---数据库可视化管理
参考：http://www.runoob.com/django/django-admin-manage-tool.html
admin是django强大功能之一，它能共从数据库中读取数据，呈如今页面中，进行管理。默认状况下，它的功能已经很是强大，若是你不须要复杂的功能，它已经够用，可是有时候，一些特殊的功能还须要定制，好比搜索功能，下面这一系列文章就逐步深刻介绍如何定制适合本身的admin应用。
若是你以为英文界面很差用，能够在setting.py 文件中修改如下选项
LANGUAGE_CODE = 'en-us' #默认英文 #LANGUAGE_CODE = 'zh-hans' #修改成中文
1、认识ModelAdmin
管理界面的定制类，如需扩展特定的model界面需从该类继承。
建立超级用户：
能够经过cmd命令行: python manage.py createsuperuser 来建立超级用户，以下所示： # python manage.py createsuperuser Username (leave blank to use 'root'): admin Email address: admin@runoob.com #能够不填 Password: Password (again): Superuser created successfully. [root@solar HelloWorld]#
2、注册medel类到admin的两种方式：
<1> 使用register的方法
admin.site.register(Book,MyAdmin)
<2> 使用register的装饰器
@admin.register(Book)
3、掌握一些经常使用的设置技巧
- list_display: 指定要显示的字段
- search_fields: 指定搜索的字段
- list_filter: 指定列表过滤器
- ordering： 指定排序字段
from django.contrib import admin from app01.models import * # Register your models here. # @admin.register(Book)#----->单给某个表加一个定制 class MyAdmin(admin.ModelAdmin): list_display = ("title","price","publisher") search_fields = ("title","publisher") list_filter = ("publisher",) ordering = ("price",) #按照price 升序排列 #ordering = ("-price","id") #按照price 降序排列,price相同再按照id排序 fieldsets =[ (None, {'fields': ['title']}), ('price information', {'fields': ['price',"publisher"], 'classes': ['collapse']}), ] admin.site.register(Book,MyAdmin) admin.site.register(Publish) admin.site.register(Author)
参考文献：
相关文章
- 1. Python全栈开发【Django基础】
- 2. Python全栈开发之Django基础
- 3. Python全栈开发-Day1-Python基础1
- 4. Python全栈开发【基础三】
- 5. 【python】【Django】云端开发基础
- 6. 全栈开发——javscript基础
- 7. python web 开发 - Django 入门
- 8. Python属于后端开发仍是前端开发?Python入门!
- 9. Python 全栈 入门
- 10. Python开发【Django】：基础
- 更多相关文章...
- • Memcached入门教程 - NoSQL教程
- • Kotlin 基础语法 - Kotlin 教程
- • PHP开发工具
- • YAML 入门教程
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
