Django:URL，Views，Template，Models
准备工作：熟悉Django命令行工具
django-admin.py 是Django的一个用于管理任务的命令行工具，常用的命令整理如下：
<1> 创建一个django工程 : django-admin.py startproject mysite
当前目录下会生成mysite的工程，目录结构如下：
- manage.py ----- Django项目管理工具，通过它可以调用django shell和数据库等。
- settings.py ---- 包含了项目的默认设置，包括数据库信息，调试标志以及其他一些工作的变量。
- urls.py ----- 负责把URL模式映射到应用程序。
<2>在mysite目录下创建blog应用: python manage.py startapp blog
目录结构如下：
<3>启动django项目：python manage.py runserver 8080
这样我们的django就启动起来了！
<4>生成同步数据库的脚本：python manage.py makemigrations
同步数据库: python manage.py migrate
注意：在开发过程中，数据库同步误操作之后，难免会遇到后面不能同步成功的情况，解决这个问题的一个简单粗暴方法是把migrations目录下
的脚本（除__init__.py之外）全部删掉，再把数据库删掉之后创建一个新的数据库，数据库同步操作再重新做一遍。
<5>当我们访问http://127.0.0.1:8080/admin/时，会出现：
所以我们需要为进入这个项目的后台创建超级管理员：python manage.py createsuperuser，设置好用户名和密码后便可登录啦！
<6>清空数据库：python manage.py flush
<7>查询某个命令的详细信息： django-admin.py help startapp
admin 是Django 自带的一个后台数据库管理系统。
<8>启动交互界面 ：python manage.py shell
这个命令和直接运行 python 进入 shell 的区别是：你可以在这个 shell 里面调用当前项目的 models.py 中的 API，对于操作数据，还有一些小测试非常方便。
<9> 终端上输入python manage.py 可以看到详细的列表，在忘记子名称的时候特别有用。
一、URL(路由系统)
浏览器会自动给url后加一个“/”
django会自动给路由的正则表达式前面加一个“/”
django会给任何不带“/”结尾的url语句添加“/”（可设置）
短路路由规则：匹配到第一条就忽略后面所有！
所以路由顺序很重要！1.普通路由
url(r'^index/',views.index),
2.正则路由
url(r'^page/\d+', views.page),
3.正则加括号
提供参数传递,按顺序接收，接收到的都是字符串
# urls.py
url(r'^page/(\d+)', views.page),
# views.py
def page(request, index):
page = index
return HttpResponse("page: 第%s页" % page)
4.正则加括号加指定参数名
提供指定参数传递,按参数名字进行接收，顺序可变，但参数名必须相同，接收到的都是字符串。
urls.py
url(r'^page/(?P<page>\d+)/(?P<number>\d+)', views.page),
views.py
def page(request, page, number):
p = page
n = number
return HttpResponse("page: 第%s页 第%s条" %(p, n))
5.分级路由include
在app01中新建urls文件
from django.conf.urls import include
url(r'index/', include(app01.urls)),
二、Views(视图函数）
http请求中产生两个核心对象：
http请求：HttpRequest对象
http响应：HttpResponse对象
1. HttpRequest对象的属性和方法
from django.shortcuts import render,HttpResponse # Create your views here.
def index(request):
#request.POST
#request.GET
#return HttpResponse("hello world!")
#1.path:请求页面的全路径,不包括域名
print(request.path) #2.get_full_path:请求页面的全路径,包括域名
print(request.get_full_path()) #3.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" #4.COOKIES:包含所有cookies的标准Python字典对象；keys和values都是字串。 #5.FILES:包含所有上传文件的类字典对象；
# FILES中的每一个Key都是<input type = "file" name = "" / > 标签中name属性的值，
# FILES中的每一个value同时也是一个标准的python字典对象，包含下面三个Keys：
# filename:上传文件名，用字符串表示
# content_type:上传文件的Content Type
# content:上传文件的原始内容 #6.user:是一个django.contrib.auth.models.User对象，代表当前登陆的用户。如果访问用户当前
# 没有登陆，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你可以通
# 过user的is_authenticated()方法来辨别用户是否登陆：
# if req.user.is_authenticated();
# 只有激活Django中的AuthenticationMiddleware时该属性才可用 # 7.session:唯一可读写的属性，代表当前会话的字典对象；自己有激活Django中的session支持时该属性才可用。
Http Request对象的属性和方法
2. HttpResponse对象的属性和方法
HttpRequest对象是由django自动创建的，HttpResponse对象需要我们自己创建，每个view请求处理方法必须返回一个HttpResponse对象。
HttpResponse类在django.http.HttpResponse
在HttpResponse对象上扩展的常用方法：
页面渲染:render()(推荐), render_to_response()
页面跳转:redirect("路径")
locals():可以直接将函数中所有的变量传给模板
/*--------------------register.html-------------------*/
<body>
<form action="{% url 'register' %}" method="post">
<p>用户名<input type="text" name="username"></p>
<p>密码<input type="password" name="password"></p>
<p><input type="submit" value="提交注册"></p> </form>
<script src="/static/jquery-3.1.1.js"></script>
</body>
/*--------------------login.html---------------------*/
<body>
<form action="{% url '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>
/*--------------------user_page.html--------------*/
<body>
<h1>用户{{ name }}你好</h1>
</body>
/*---------------------blog\urls.py------------------*/
from django.contrib import admin
from django.urls import path
from django.conf.urls import url from blog import views urlpatterns = [
# path('admin/', admin.site.urls), url(r'register/',views.register,name="register"),
url(r'^login',views.login,name="login"),
url(r'^user_page',views.user_page,name="user_page")
]
/*----------------------views.py-----------------------*/
from django.shortcuts import render,HttpResponse,render_to_response,redirect # Create your views here.
user_list=[]
def register(request):
if request.method == "POST":
username=request.POST.get("username",None)
password=request.POST.get("password",None)
print("username:",username)
if username:
user_list.append(username)
return redirect("/blog/login/")
#redirect方法进行页面跳转时，地址栏URL会跟改为跳转页面的，此处为http://127.0.0.1/blog/login
#return render(request,"login.html")
#在此处用render方法进入页面，地址栏URL不会改变，仍然为http;//127.0.0.1/blog/index return HttpResponse("username is None")
return render(request,"register.html")
#或者render_to_response("register.html")
def login(request):
if request.method=="POST":
user=request.POST.get("username",None)
if user in user_list:
name=user
return redirect("/blog/user_page/")
return HttpResponse("username does not exist") return render(request, "login.html") def user_page(request): return render(request,"user_page.html",locals())
注册-登录-用户首页流程模拟
三、Template(模板系统)
在html文件中使用模板语言
1. 普通变量
{{var}}
调用数组元素：(圆点加下标)
list1 = [1,2,3]
{{list.0}}
{{list.1}}
{{list.2}}
调用字典元素： (圆点加键值)
dict1 = {"k1":"v1","k2":"v2"}
{{dict1.k1}}
{{dict1.k2}}
# 1.句点用于访问列表索引: >>> 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.' # 2.句点用于访问字典索引: >>> from django.template import Template, Context
>>> person = {'name': 'Sally', 'age': ''}
>>> t = Template('{{ person.name }} is {{ person.age }} years old.')
>>> c = Context({'person': person})
>>> t.render(c)
'Sally is 43 years old.' #3.句点访问对象属性,如 Python 的 datetime.date 对象有year,month 和 day 几个属性,可#以在模板中使用句点来访问这些属性： >>> from django.template import Template, Context
>>> import datetime
>>> d = datetime.date(1993, 5, 2)
>>> d.year
1993
>>> d.month
5
>>> d.day
2
>>> 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.' # 4.句点通过实例变量访问自定义类属性，这个方法适用于任意的对象。 >>> 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.' #5. 句点也可以用来引用对象的方法。例如，每个 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 -- True'
0# 语法格式:{{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'
模板变量的filter使用
2. if语句
{% if %}标签判断一个条件表达式，如果是“true”，即它存在、不为空并且不是false的boolean值,系统则会显示{% if %}和{% endif %}间的所有内容
{% if 判断 %}
......
{% else %}
......
{% endif %}
3. for循环
{% for %}标签按顺序遍历一个序列中的各个元素,每次循环模板系统都会渲染{% for %}和{% endfor %}之间的所有内容
{% for i in data %}
......
{% endfor %}
django内置特殊的用于for循环的变量：
forloop.counter
forloop.counter0
forloop.first
forloop.last
forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1
{% for item in todo_list %}
<p>{{ forloop.counter }}: {{ item }}</p>
{% endfor %}
forloop.counter0 类似于forloop.counter，但它是从0开始计数，第一次循环设为0
forloop.revcounter
forloop.revcounter0
forloop.first当第一次循环时值为True，在特别情况下很有用：
#{% 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
4.特殊标签
(1) {%csrf_token%}：csrf_token标签，用于防治跨站攻击验证。注意如果你在view的index里用的是render_to_response方法，该标签不会生效
其实，{%csrf_token%}是会生成一个input标签，和其他表单标签一起提交给后台。
(2) {% url '路由别名' %}: 引用路由配置的地址
<form action="{% url "bieming"%}" >
<input type="text">
<input type="submit"value="提交">
{%csrf_token%}
</form>
(3) {% with %}:用更简单的变量名替代复杂的变量名
{% with total=fhjsaldfhjsdfhlasdfhljsdal %} {{ total }} {% endwith %}
(4) {% verbatim %}: 禁止render
{% verbatim %}
{{ hello }}
{% endverbatim %}
(5) {% load %}: 加载标签库
5. 内置函数
lower first last divisibleby 等等。例如：
{{ “AAA”|lower}}
使用管道符引用函数名，左边的‘AAA’自动当作参数传递给lower函数
又或：判断当前循环的次数是否能被2整除
{% if forloop.counter0|divisibleby:"2" %}
<tr class="success">
{% else %}
<tr>
{% endif %}
6. 自定义filter和simple_tag
1.在settings中的INSTALLED_APPS配置当前app,不然django无法找到自定义的simple_tag.
2.在app中创建templatetags模块(必须的)
3.创建任意 .py 文件，如：my_tags.py
4.在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py ：{% load my_tags %}
5.使用simple_tag和filter（如何调用）
/*-------------------my_tag.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 /*---------------使用my_tag的html------------*/
{% load my_tag %}
# num=12
{{ num|filter_multi:2 }} #调用自定义filter24
{% simple_tag_multi 2 5 %}#调用自定义simple_tag
自定义filter和simple_tag函数
7. 继承模板
{% extends "xxxx.html" %}
8. 重写模板
在母版和子版式中使用同样的：
{% block 取个名字 %}
（每个子版专属的代码）
{% endbloack %}
9.导入html代码
{% include "xxx.html" %}
与继承模板不同的是，导入的是xxx.html的完全代码，因此xxx.html中最好没有头部，title等代码，只有实际的功能代码。
四、models
1.数据库配置
django默认支持sqlite，mysql, oracle,postgresql数据库。
1.sqlite： django默认使用sqlite数据库，默认自带sqlite的数据库驱动 , 引擎名称：django.db.backends.sqlite3
2.mysql：引擎名称：django.db.backends.mysql
3.常用的mysql驱动：MySQLdb(又名mysql_python,不支持python3.+,由pymysql替代)，mysqlclient，mysql_connector_python(纯python的mysql驱动程序,由oracle官方维护)
4.在django的项目中会默认使用sqlite数据库，在settings里有如下设置
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
如果我们想要更改数据库，需要修改如下：
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'mydatabase',
'USER': 'mydatabaseuser',
'PASSWORD': 'mypassword',
'HOST': '127.0.0.1',
'PORT': '',
}
}
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() 问题解决！
如果使用的驱动是mysql官网驱动：mysql_connector_python，则database settings中需要将engine设置为
'ENGINE': 'mysql.connector.django'，然后改驱动会自动适配Django
5.通过Django两条命令创建数据库和表
python3 manage.py makemigrations
python3 manage.py migrate
2. Django ORM语法
（1）基础类型
from django.db import models class userinfo(models.Model):
name = models.CharField(max_length=30)
email = models.EmailField()
memo = models.TextField()
（2）连表类型
一对多：models.ForeignKey("其他表")
多对多：models.ManyToManyField("其他表")
一对一：models.OneToOneField("其他表")
（3） 字段类型
<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参数.
字段类型
AutoField(Field)
- int自增列，必须填入参数 primary_key=True BigAutoField(AutoField)
- bigint自增列，必须填入参数 primary_key=True 注：当model中如果没有自增列，则自动会创建一个列名为id的列
from django.db import models class UserInfo(models.Model):
# 自动创建一个列名为id的且为自增的整数列
username = models.CharField(max_length=32) class Group(models.Model):
# 自定义自增列
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32) SmallIntegerField(IntegerField):
- 小整数 -32768 ～ 32767 PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正小整数 0 ～ 32767
IntegerField(Field)
- 整数列(有符号的) -2147483648 ～ 2147483647 PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
- 正整数 0 ～ 2147483647 BigIntegerField(IntegerField):
- 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807 BooleanField(Field)
- 布尔值类型 NullBooleanField(Field):
- 可以为空的布尔值 CharField(Field)
- 字符类型
- 必须提供max_length参数， max_length表示字符长度 TextField(Field)
- 文本类型 EmailField(CharField)：
- 字符串类型，Django Admin以及ModelForm中提供验证机制 IPAddressField(Field)
- 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制 GenericIPAddressField(Field)
- 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
- 参数：
protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol="both" URLField(CharField)
- 字符串类型，Django Admin以及ModelForm中提供验证 URL SlugField(CharField)
- 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号） CommaSeparatedIntegerField(CharField)
- 字符串类型，格式必须为逗号分割的数字 UUIDField(Field)
- 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证 FilePathField(Field)
- 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
- 参数：
path, 文件夹路径
match=None, 正则匹配
recursive=False, 递归下面的文件夹
allow_files=True, 允许文件
allow_folders=False, 允许文件夹 FileField(Field)
- 字符串，路径保存在数据库，文件上传到指定目录
- 参数：
upload_to = "" 上传文件的保存路径
storage = None 存储组件，默认django.core.files.storage.FileSystemStorage ImageField(FileField)
- 字符串，路径保存在数据库，文件上传到指定目录
- 参数：
upload_to = "" 上传文件的保存路径
storage = None 存储组件，默认django.core.files.storage.FileSystemStorage
width_field=None, 上传图片的高度保存的数据库字段名（字符串）
height_field=None 上传图片的宽度保存的数据库字段名（字符串） DateTimeField(DateField)
- 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] DateField(DateTimeCheckMixin, Field)
- 日期格式 YYYY-MM-DD TimeField(DateTimeCheckMixin, Field)
- 时间格式 HH:MM[:ss[.uuuuuu]] DurationField(Field)
- 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型 FloatField(Field)
- 浮点型 DecimalField(Field)
- 10进制小数
- 参数：
max_digits，小数总长度
decimal_places，小数位长度 BinaryField(Field)
- 二进制类型
字段类型
（4）参数类型
<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> help_text: Admin中该字段的提示信息
<9> validator_list： 有效性检查。非有效产生 django.core.validators.ValidationError 错误
<10> db_column: 数据库中字段的列名
<11>db_index : 数据库中字段是否可以建立索引,如果为真将为此字段创建索引
<12>choices：一个用来选择值的2维元组。第一个值是实际存储的值，第二个用来方便进行选择。
如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),)
gender = models.CharField(max_length=2,choices = SEX_CHOICES)
<13>error_messages: 自定义错误信息（字典类型），从而定制想要显示的错误信息；
字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
如：{'null': "不能为空.", 'invalid': '格式错误'}
参数类型
（5）多表关系及参数
ForeignKey(ForeignObject) # ForeignObject(RelatedField)
to, # 要进行关联的表名
to_field=None, # 要关联的表中的字段名称
on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为
- models.CASCADE，删除关联数据，与之关联也删除
- models.DO_NOTHING，删除关联数据，引发错误IntegrityError
- models.PROTECT，删除关联数据，引发错误ProtectedError
- models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
- models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
- models.SET，删除关联数据，
a. 与之关联的值设置为指定值，设置：models.SET(值)
b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象) def func():
return 10 class MyModel(models.Model):
user = models.ForeignKey(
to="User",
to_field="id"
on_delete=models.SET(func),)
related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件：
# 如：
- limit_choices_to={'nid__gt': 5}
- limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q
- limit_choices_to=Q(nid__gt=10)
- limit_choices_to=Q(nid=8) | Q(nid__gt=10)
- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
db_constraint=True # 是否在数据库中创建外键约束
parent_link=False # 在Admin中是否显示关联数据 OneToOneField(ForeignKey)
to, # 要进行关联的表名
to_field=None # 要关联的表中的字段名称
on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为 ###### 对于一对一 ######
# 1. 一对一其实就是 一对多 + 唯一索引
# 2.当两个类之间有继承关系时，默认会创建一个一对一字段
# 如下会在A表中额外增加一个c_ptr_id列且唯一：
class C(models.Model):
nid = models.AutoField(primary_key=True)
part = models.CharField(max_length=12) class A(C):
id = models.AutoField(primary_key=True)
code = models.CharField(max_length=1) ManyToManyField(RelatedField)
to, # 要进行关联的表名
related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件：
# 如：
- limit_choices_to={'nid__gt': 5}
- limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q
- limit_choices_to=Q(nid__gt=10)
- limit_choices_to=Q(nid=8) | Q(nid__gt=10)
- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
symmetrical=None, # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段
# 做如下操作时，不同的symmetrical会有不同的可选字段
models.BB.objects.filter(...) # 可选字段有：code, id, m1
class BB(models.Model): code = models.CharField(max_length=12)
m1 = models.ManyToManyField('self',symmetrical=True) # 可选字段有: bb, code, id, m1
class BB(models.Model): code = models.CharField(max_length=12)
m1 = models.ManyToManyField('self',symmetrical=False) through=None, # 自定义第三张表时，使用字段用于指定关系表
through_fields=None, # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表
from django.db import models class Person(models.Model):
name = models.CharField(max_length=50) class Group(models.Model):
name = models.CharField(max_length=128)
members = models.ManyToManyField(
Person,
through='Membership',
through_fields=('group', 'person'),
) class Membership(models.Model):
group = models.ForeignKey(Group, on_delete=models.CASCADE)
person = models.ForeignKey(Person, on_delete=models.CASCADE)
inviter = models.ForeignKey(
Person,
on_delete=models.CASCADE,
related_name="membership_invites",
)
invite_reason = models.CharField(max_length=64)
db_constraint=True, # 是否在数据库中创建外键约束
db_table=None, # 默认创建第三张表时，数据库中表的名称 unique_together #联合唯一，自己创建多对多第三章表时，加上此约束后，创建的表与默认创建的表相同
#class UserToTag(models.Model):
# # nid = models.AutoField(primary_key=True)
# u = models.ForeignKey(to='User')
# t = models.ForeignKey(to='Tag')
# ctime = models.DateField()
# class Meta:
# unique_together=[
# ('u','t'),
# ]
3. Django ORM表操作
（1）单表的增，删，改，查
/*--------------------------index.html-------------------------*/ <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
* {
margin: 0;
padding: 0
}
.head{
line-height: 40px;
background-color: green;
color: white;
text-align: center; } </style>
</head>
<body>
<div class="outer">
<div class="head">标题</div>
<div class="content">
<a href="/addbook/">添加书籍</a>
<a href="/update/">修改书籍</a>
<a href="/delete/">删除书籍</a>
<a href="/select/">查询书籍</a>
</div>
<hr>
<div class="queryResult">
{% for book in book_list %}
<div>
<p>{{ book.title }} {{ book.author }} {{ book.price }}</p>
</div>
{% endfor %}
</div>
</div> <script src="/static/jquery-3.1.1.js"></script>
</body>
</html> /*-----------------------models.py---------------------------*/ from django.db import models # Create your models here.
class UserInfo(models.Model):
user=models.CharField(max_length=32)
pwd=models.CharField(max_length=32)
class book(models.Model):
author=models.CharField(max_length=32)
price=models.IntegerField()
date=models.DateField()
title=models.CharField(max_length=100)
def __str__(self):
return self.title /*-----------------------view.py------------------------------*/ from django.shortcuts import render,HttpResponse
from blog.models import * # Create your views here.
def index(request):
return render(request,"index.html")
#-----------------增-------------------
def addbook(request):
#法一
book.objects.create(author="马尔克斯",price=88,date="2014-3-3",title="百年孤独")
#法二
b=book(author="狄更斯",price=66,date="2011-2-4",title="艰难时世")
b.save()
return HttpResponse("书籍信息添加成功")
#-----------------删-------------------
def delete(request):
book.objects.filter(id=9).delete()
return HttpResponse("书籍信息删除成功")
#-----------------改---------------------
def update(request):
#法一
book.objects.filter(author="高尔基").update(price=99)
#法二
b=book.objects.get(author="狄更斯")
b.price=77
b.save()
return HttpResponse("书籍信息修改成功")
#------------------------------------------
#<1> 法一修改不能用get的原因是：update是QuerySet对象的方法，
# get返回的是一个model对象，它没有update方法，而filter返回的是一个
# QuerySet对象(filter里面的条件可能有多个条件符合，比如name＝'alvin',
# 可能有两个name＝'alvin'的行数据)。
#<2>update方法直接设定对应字段属性，save方法会将所有属性重新设定一遍,效率低,
# 故推荐使用update方法
#--------------------------------------------
练习所用book表单
每次对表的操作想看见对应的sql实现语句，可在settings.py里加入日志记录配置
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
查询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。 #扩展查询,有时候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'])
查询API
def select(request):
# book_list=book.objects.all()
# book.objects.all()支持切片操作
# book_list = book.objects.all()[::2]#切片
# book_list = book.objects.all()[::-1]#切片
# book_list = book.objects.first()
# book_list = book.objects.last()
# book_list = book.objects.get(id=2) # 只能取出一条记录时才不报错,取出的是单个元素，不能进行循环
# ret1=book.objects.filter(author="高尔基").values("title","price")
# ret2=book.objects.filter(author="yuan").values_list("name","price")
# book_list=book.objects.exclude(author="yuan").values("name","price")
# book_list= book.objects.all().values("name").distinct()
# book_count= book.objects.all().values("name").distinct().count()
# print("ret1:",ret1)
# 万能的 __
book_list=book.objects.filter(price__gt=50).values("name","price")#price__gt=50代表价格大于50
# book_list = book.objects.filter(name__contains="P").values_list("name", "price")
return render(request,"index.html",{"book_list":book_list})
查询API的使用
（2）一对多表的增、删、改、查
练习所用表单
book表
author表
publish表
book_author表
/*---------------------------models.py---------------------*/
from django.db import models # Create your models here.
class book(models.Model):
author=models.CharField(max_length=32)
price=models.IntegerField()
date=models.DateField()
title=models.CharField(max_length=100)
publish=models.ForeignKey("Publish",on_delete=models.CASCADE)
def __str__(self):
return self.title
class Publish(models.Model):
name=models.CharField(max_length=100)
city=models.CharField(max_length=100) /*--------------------------views.py---------------------------*/ def addbook(request):
#一对多
#法一由于绑定一对多的字段,比如publish,存到数据库中的字段名叫publish_id,所以我们可以直接给这个
#字段设定对应值
#book.objects.create(author="马尔克斯",price=88,date="2014-3-3",title="百年孤独",publish_id=2)
#法二
#<1>先获取要绑定的Publisher对象:
#pub_obj = Publish.objects.get(id=2)
#print("-------pub_obj:",pub_obj)
#<2>将 publish_id=2 改为 publish=pub_obj
#book.objects.create(author="马尔克斯",price=88,date="2014-1-3",title="霍乱时期的爱情",publish=pub_obj) return HttpResponse("书籍信息添加成功") def select(request):
#法一 通过对象
book_obj=book.objects.get(title="童年")
#book_obj.publish是一个书籍对象对应的一个publish object ,数据类型是models下publish类的一条与name="童年"的publish_id相同的实例对象，
#可以通过调用对象属性查看相应信息
# print(book_obj.publish.name)
# print(book_obj.publish.city)
#需求查询吉林出版社出版的所有书籍
# pub_obj=Publish.objects.filter(name="吉林出版社")[0]
# print("pub_obj:",pub_obj)
# print(pub_obj.book_set.all().values("title","price"))
# 法二通过filter和values的双下滑线语法查询
# 需求:查询所有安徽人民出版社出版的书籍
# ret = book.objects.filter(publish__name="安徽人民出版社").values("title", "price")
# print("ret:", ret)
#需求：查询童年这本书出版社的名字
#ret=Publish.objects.filter(book__title="童年").values('name')
#ret=book.objects.filter(title="童年").values("publish__name")
#需求：查询出版社在北京的出版社出版的书籍名字
#ret=book.objects.filter(publish__city="北京").values("title")
#需求：查询在2014年上半年出版的书对应的出版社名字
ret=book.objects.filter(date__gt="2014-01-01",date__lt="2014-07-01").values("publish__name")
print("ret:", ret)
return render(request,"书籍修改成功")
一对多增，删，改，查
（3）多对多表的增、删、改、查
/*-----------------------models.py---------------------------------*/
from django.db import models # Create your models here.
class book(models.Model):
#author=models.CharField(max_length=32)
price=models.IntegerField()
date=models.DateField()
title=models.CharField(max_length=100)
publish=models.ForeignKey("Publish",on_delete=models.CASCADE)
#author= models.ManyToManyField("Author")#自己创建中间表，不用ManyToManyField字段参数类型
def __str__(self):
return self.title
class Publish(models.Model):
name=models.CharField(max_length=100)
city=models.CharField(max_length=100)
def __str__(self):
return self.name
class Author(models.Model):
name=models.CharField(max_length=32)
age=models.IntegerField(default=20)
def __str__(self):
return self.name
class Book_Author(models.Model):
book=models.ForeignKey("book",on_delete=models.CASCADE)
author=models.ForeignKey("Author",on_delete=models.CASCADE) /*---------------------------views.py---------------------------*/
#创建多对多关系author= models.ManyToManyField("Author")（推荐） /*-----------------------------增--------------------------------*/
#多对多(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 Book_Author(models.Model):
author=models.ForeignKey("Author")
book= models.ForeignKey("book")
# 那么就还有一种方式:
author_obj=models.Author.objects.filter(id=2)[0]
book_obj =models.book.objects.filter(id=3)[0] s=models.Book_Author.objects.create(author_id=1,book_id=2)
s.save()
s=models.book_Author(author=author_obj,book_id=1)
s.save() /*--------------------------------删--------------------------------*/
#多对多：remove()和clear()方法
#正向
book_obj = models.book.objects.filter(id=1) #删除第三张表中和id=1关联的所有关联信息
book_obj.author.clear() #清空与book中id=1 关联的所有数据
book.author.remove(2) #可以为id
book.author.remove(*[1,2,3,4]) #可以为列表,前面加* #反向
author = models.Author.objects.filter(id=1)
author.book_set.clear() #清空id=1 关联的所有数据 /*-------------------------------查--------------------------------*/ #多对多查询(ManyToManyField()):
#ret=models.Book.objects.filter(title='Python').values('author__name')
#print(ret)
#ret=models.Book.objects.filter(author__name="alex").values('title')
#print(ret)
#ret=models.Author.objects.filter(book__title='Python').values('name','price')
（4）表操作总结
0.一对多，外键一定是建在'多'的那张表
1. 类代表数据库表
2. 类的对象代指数据库的一行记录
3. FK字段代指关联表中的一行数据（类的对象）
4. 自动生成的第三章表中命名为FK_id的字段代表的是对应关联表的id
5. ManyToMany字段，自动生成第三张表：依赖关联表对第三张表进行操作
6.一对多: 正向查询用"FK字段"，反向查询用"小写类名_set",跨表用双下划线
7.多对多：正向查询用"M2M字段"，其他同一对多，如果未自己创建第三章多对多关系表，无法直接用对象
8.数据库获取数据
.all .filter 输出为[obj,obj],即一个个对象组成的列表
.values 输出为[{},{}]，即一个个字典组成的列表，字典中为所选字段的键值对
.values_list 输出为[(),()],即一个个元组组成的列表，元组中为所选字段和对应的值
"""book包含字段： id price date title publish_id(ForeignKey) authors（ManyToManyField）"""
#1. 类代表数据库表
#2. 类的对象代指数据库的一行记录
#3. FK字段代指关联表中的一行数据（类的对象）
#4. 自动生成的第三章表中命名为FK_id的字段代表的是对应关联表的id
#5. ManyToMany字段，自动生成第三张表：依赖关联表对第三张表进行操作
#6. 正向查询用"FK字段"，反向查询用"小写类名_set"
#<1> ret = book.objects.all()
#返回为QuerySet对象，对象由一个个book类的对象（即一条条记录）组成QuerySet列表
#< QuerySet[ < book: bookobject(1) >, < book: bookobject(2) >, < book: bookobject(3) >, < book: book object(4) >, < book: bookobject(5) >,
#< book: bookobject(6) >, < book: bookobject(7) >, < book: bookobject(8) >, < book: bookobject(9) >, < book: bookobject(10) >, < book: bookobject(11) >] >
#在models book 加入下面两句，返回为：
#def __str__(self):
# return self.title
#<QuerySet [<book: 战争与和平>, <book: 百年孤独>, <book: 巴黎圣母院>, <book: 童年>, <book: 霍乱时期的爱情>,
# <book: 我们家的猫>, <book: 在人间>, <book: 我的大学>, <book: 艰难时世>, <book: 红与黑>, <book: python程序设计教程>]>
#<2> 对通过ret = book.objects.all()拿到的QuerySet进行循环遍历
# ret=book.objects.all()
# for item in ret:
# print(item.id,item.price,item.date,item.title,item.publish_id,item.publish.id)
# #跨表
# print(item.publish.id,item.publish.name,item.publish.city)
#<3> 删除
#pid=input("请输入出版社ID")
#book.objects.filter(publish_id=pid).delete()#删除publish_id为对应输入id的book记录
#pname=input("请输入出版社名字")
#book.objects.filter(publish__name=pname).delete()#删除出版社为输入出版社名发布的所有book记录
#<4> ret=book.objects.all().values("id","title")
#返回QuerySet对象，对象由一个个所选字段组成的字典构成QuerySet列表
#ret: < QuerySet[{'id': 1, 'title': '战争与和平'}, {'id': 2, 'title': '百年孤独'}, {'id': 3, 'title': '巴黎圣母院'},
# {'id': 4,'title': '童年'}, {'id': 5, 'title': '霍乱时期的爱情'}, {'id': 6, 'title': '我们家的猫'}, {'id': 7, 'title': '在人间'},
# {'id': 8,'title': '我的大学'}, {'id': 9, 'title': '艰难时世'}, {'id': 10, 'title': '红与黑'}, {'id': 11, 'title': 'python程序设计教程'}] >
#<5> ret=book.objects.all().values_list("id","title")
#返回QuerySet对象，对象由一个个所选字段值组成的元祖构成QuerySet列表
#ret: <QuerySet [(1, '战争与和平'), (2, '百年孤独'), (3, '巴黎圣母院'), (4, '童年'), (5, '霍乱时期的爱情'),
# (6, '我们家的猫'), (7, '在人间'), (8, '我的大学'), (9, '艰难时世'), (10, '红与黑'), (11, 'python程序设计教程')]>
（5）聚合查询
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')}
aggregate(*args,**kwargs)
（6）分组查询
from django.db.models import Avg,Min,Sum,Max
#必须导入上面聚类函数，否则会报错
ret=book.objects.values("publish__name").annotate(Min('price'))
#<QuerySet [{'publish__name': '北京出版社', 'price__min': 44},
# {'publish__name': '安徽人民出版社', 'price__min': 36},
# {'publish__name': '长春出版社', 'price__min': 33},
# {'publish__name': '重庆出版社', 'price__min': 99},
# {'publish__name': '吉林出版社', 'price__min': 46},
# {'publish__name': '江苏人民出版社', 'price__min': 77},
# {'publish__name': '清华大学出版社', 'price__min': 48}]>
annotate
（7）F查询和Q查询
# F 使用查询条件的值,专门取对象中某列值的操作
# from django.db.models import F
#让所有书的价格加10
# book.objects.values(price=F(price)+10)
# 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>]
# 2、可以组合使用&,|操作符，当一个操作符是用于两个Q的对象,它产生一个新的Q对象。
Q(title__startswith='P') | Q(title__startswith='J')
# 3、Q对象可以用~操作符放在前面表示否定，也可允许否定与不否定形式的组合
Q(title__startswith='P') | ~Q(pub_date__year=2005)
# 4、应用范围：
# 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
# 5、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)))
F查询和Q查询
（8）QuerySet
#惰性机制：
#所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结#果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。
#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，可能
会造成额外的数据库查询。
（9）QuerySet对象的源码里的方法总结
def all(self)
# 获取所有的数据对象 def filter(self, *args, **kwargs)
# 条件查询
# 条件可以是：参数，字典，Q def exclude(self, *args, **kwargs)
# 条件查询
# 条件可以是：参数，字典，Q def select_related(self, *fields)
性能相关：表之间进行join连表操作，一次性获取关联的数据。
model.tb.objects.all().select_related()
model.tb.objects.all().select_related('外键字段')
model.tb.objects.all().select_related('外键字段__外键字段') def prefetch_related(self, *lookups)
性能相关：多表连表操作时速度会慢，使用其执行多次SQL查询在Python代码中实现连表操作。
# 获取所有用户表
# 获取用户类型表where id in (用户表中的查到的所有用户ID)
models.UserInfo.objects.prefetch_related('外键字段') from django.db.models import Count, Case, When, IntegerField
Article.objects.annotate(
numviews=Count(Case(
When(readership__what_time__lt=treshold, then=1),
output_field=CharField(),
))
) students = Student.objects.all().annotate(num_excused_absences=models.Sum(
models.Case(
models.When(absence__type='Excused', then=1),
default=0,
output_field=models.IntegerField()
))) def annotate(self, *args, **kwargs)
# 用于实现聚合group by查询 from django.db.models import Count, Avg, Max, Min, Sum v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
# SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
# SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1 v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
# SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1 def distinct(self, *field_names)
# 用于distinct去重
models.UserInfo.objects.values('nid').distinct()
# select distinct nid from userinfo 注：只有在PostgreSQL中才能使用distinct进行去重 def order_by(self, *field_names)
# 用于排序
models.UserInfo.objects.all().order_by('-id','age') def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
# 构造额外的查询条件或者映射，如：子查询 Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) def reverse(self):
# 倒序
models.UserInfo.objects.all().order_by('-nid').reverse()
# 注：如果存在order_by，reverse则是倒序，如果多个排序则一一倒序 def defer(self, *fields):
models.UserInfo.objects.defer('username','id')
或
models.UserInfo.objects.filter(...).defer('username','id')
#映射中排除某列数据 def only(self, *fields):
#仅取某个表中的数据
models.UserInfo.objects.only('username','id')
或
models.UserInfo.objects.filter(...).only('username','id') def using(self, alias):
指定使用的数据库，参数为别名（setting中的设置） ##################################################
# PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
################################################## def raw(self, raw_query, params=None, translations=None, using=None):
# 执行原生SQL
models.UserInfo.objects.raw('select * from userinfo') # 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名
models.UserInfo.objects.raw('select id as nid from 其他表') # 为原生SQL设置参数
models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,]) # 将获取的到列名转换为指定列名
name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
Person.objects.raw('SELECT * FROM some_other_table', translations=name_map) # 指定数据库
models.UserInfo.objects.raw('select * from userinfo', using="default") ################### 原生SQL ###################
from django.db import connection, connections
cursor = connection.cursor() # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1])
row = cursor.fetchone() # fetchall()/fetchmany(..) def values(self, *fields):
# 获取每行数据为字典格式 def values_list(self, *fields, **kwargs):
# 获取每行数据为元祖 def dates(self, field_name, kind, order='ASC'):
# 根据时间进行某一部分进行去重查找并截取指定内容
# kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
# order只能是："ASC" "DESC"
# 并获取转换后的时间
- year : 年-01-01
- month: 年-月-01
- day : 年-月-日 models.DatePlus.objects.dates('ctime','day','DESC') def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
# 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
# kind只能是 "year", "month", "day", "hour", "minute", "second"
# order只能是："ASC" "DESC"
# tzinfo时区对象
models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai')) """
pip3 install pytz
import pytz
pytz.all_timezones
pytz.timezone(‘Asia/Shanghai’)
""" def none(self):
# 空QuerySet对象 ####################################
# METHODS THAT DO DATABASE QUERIES #
#################################### def aggregate(self, *args, **kwargs):
# 聚合函数，获取字典类型聚合结果
from django.db.models import Count, Avg, Max, Min, Sum
result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
===> {'k': 3, 'n': 4} def count(self):
# 获取个数 def get(self, *args, **kwargs):
# 获取单个对象 def create(self, **kwargs):
# 创建对象 def bulk_create(self, objs, batch_size=None):
# 批量插入
# batch_size表示一次插入的个数
objs = [
models.DDD(name='r11'),
models.DDD(name='r22')
]
models.DDD.objects.bulk_create(objs, 10) def get_or_create(self, defaults=None, **kwargs):
# 如果存在，则获取，否则，创建
# defaults 指定创建时，其他字段的值
obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '','u_id': 2, 't_id': 2}) def update_or_create(self, defaults=None, **kwargs):
# 如果存在，则更新，否则，创建
# defaults 指定创建时或更新时的其他字段
obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '','u_id': 2, 't_id': 1}) def first(self):
# 获取第一个 def last(self):
# 获取最后一个 def in_bulk(self, id_list=None):
# 根据主键ID进行查找
id_list = [11,21,31]
models.DDD.objects.in_bulk(id_list) def delete(self):
# 删除 def update(self, **kwargs):
# 更新 def exists(self):
# 是否有结果
（10）常用双下划线
models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、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
（11）表的正反向查询
1.一对多跨表查询:
(1)正向跨表查询
例1:查询书名为《巴黎圣母院》的出版社名
<法1:>通过对象进行正向跨表查询(obj.FK.跨表要查询的字段),注意book_obj.publish是指书籍对象对应的关联表中的publish对象，是Publish表中的一条记录
book_obj= book.objects.filter(title="巴黎圣母院").first()
ret=book_obj.publish.name
注意.filter输出为[obj,obj...],即一个个对象组成的列表，后面不加.first()，直接取值会出错，可以遍历里面的对象取值
book_obj = book.objects.filter(title="巴黎圣母院")
for item in book_obj:
print(item.publish.name,item.publish.city)
<法2:>通过PK加双下滑线进行正向跨表查询
ret=book.objects.filter(title="巴黎圣母院").values('publish__name','publish__city')#values里面用双下划线
补充ret=Publish.objects.filter(book__title='巴黎圣母院').values('name','city')#filter里面用双下滑线,这个是反向查询,及类名加双下滑线实现例子中的需求
print(ret) print(ret)
(2)反向跨表查询
例1：查询北京出版社出版的所有书籍书名和价格
<法1:>通过对象进行反向跨表查询
publish_obj=Publish.objects.filter(name='北京出版社')[0]#先拿到一个publish对象
ret=book.objects.filter(publish=publish_obj).values('title','price')#通过FK=publish对象进行筛选
print(ret)
<法2:>：通过 小写表名_set进行反向查询
publish_obj = Publish.objects.filter(name='北京出版社')[0]#先拿到一个publish对象
print(publish_obj.book_set.all().values('title','price'))#通过book_set反向关联要查询的表
<法3:>通过类名加双下滑线进行反向查询
ret=Publish.objects.filter(name='北京出版社').values('book__title','book__price')
ret=book.objects.filter(publish__name='北京出版社').values('title','price')#补充，这个是通过正向查询，及PK加双下划线实现的例子中的需求
print(ret) 2.一对多查询练习
例1：查询在北京的所有出版社出过的书籍名称和价格
ret=Publish.objects.filter(city='北京').values('book__title','book__price')
print(ret)
3.多对多跨表查询
类型1，通过many_to_many字段自动创建第3张表
(1)正向多对多跨表查询
例1:查询书籍《python程序设计教程》的所有作者姓名和年龄
<法1:>通过对象进行正向跨表查询
book_obj = book.objects.filter(title='python程序设计教程')[0]
print(book_obj.author.all())#通过book_obj.MTM字段.all()拿到的是book对应的author对象组成的QuerySet集合<QuerySet[obj,obj]>
author_set=book_obj.author.all()
for item in author_set:
print(item.name,item.age)
<法2:> 通过MTM字段加双下滑线进行正向跨表查询
author_ret_set=book.objects.filter(title='python程序设计教程').values('author__name','author__age')
print(author_ret_set)
(2)反向多对多跨表查询
例1：查询高尔基出过的所有书籍名称和价格
<法1:> 通过对象进行反向跨表查询
author_obj=Author.objects.filter(name='高尔基')[0]
book_ret_set=book.objects.filter(author=author_obj).values('title','price')
print(book_ret_set)
<法2:> 通过小写表名_set进行反向查询
author_obj = Author.objects.filter(name='高尔基')[0]
book_set=author_obj.book_set.all()
for item in book_set:
print(item.title,item.price)
<法3:>通过类名加双下滑线进行反向查询
book_ret_set=Author.objects.filter(name='高尔基').values('book__price','book__title')
print(book_ret_set)
类型2，自己手动创建第3张表
>>>>>>>待续
Django:URL，Views，Template，Models的更多相关文章
- 第三百零四节，Django框架，urls.py模块，views.py模块，路由映射与路由分发以及逻辑处理——url控制器
Django框架,urls.py模块,views.py模块,路由映射与路由分发以及逻辑处理——url控制器 这一节主讲url控制器 一.urls.py模块 这个模块是配置路由映射的模块,当用户访问一个 ...
- 二 Django框架，urls.py模块，views.py模块，路由映射与路由分发以及逻辑处理——url控制器
Django框架,urls.py模块,views.py模块,路由映射与路由分发以及逻辑处理——url控制器 这一节主讲url控制器 一.urls.py模块 这个模块是配置路由映射的模块,当用户访问一个 ...
- python :Django url /views /Template 文件介绍
1,Django URL 路由系统 URL配置(URLconf)就像Django 所支撑网站的目录.它的本质是URL模式以及要为该URL模式调用的视图函数之间的映射表:你就是以这种方式告诉Django ...
- Django框架_URLconf、Views、template、ORM
目录: 一.Django-MTV MTV模型 Django基本命令 视图层之路由配置系统(views) 视图层之视图函数(views) 模板层(template) 二.Django-model基础 O ...
- Django基础(一)_URLconf、Views、template、ORM
一 什么是web框架? 框架,即framework,特指为解决一个开放性问题而设计的具有一定约束性的支撑结构,使用框架可以帮你快速开发特定的系统,简单地说,就是你用别人搭建好的舞台来做表演. 对于所有 ...
- Django 路由系统URL 视图views
一.Django URL (路由系统) URL配置(URLconf)就像Django 所支撑网站的目录.它的本质是URL模式以及要为该URL模式调用的视图函数之间的映射表:你就是以这种方式告诉Djan ...
- Django url配置 正则表达式详解 分组命名匹配 命名URL 别名 和URL反向解析 命名空间模式
Django基础二之URL路由系统 本节目录 一 URL配置 二 正则表达式详解 三 分组命名匹配 四 命名URL(别名)和URL反向解析 五 命名空间模式 一 URL配置 Django 1.11版本 ...
- Django URL (路由系统)
URL配置(URLconf)就像Django 所支撑网站的目录.它的本质是URL模式以及要为该URL模式调用的视图函数之间的映射表:你就是以这种方式告诉Django,对于这个URL调用这段代码,对于那 ...
- Django url
urlpatterns = [ url(正则表达式, views视图函数,参数,别名),] 参数说明: 一个正则表达式字符串 一个可调用对象,通常为一个视图函数或一个指定视图函数路径的字符 ...
- Django URL（路由系统）
Django URL Django 1.11版本 URLconf官方文档 URL配置(URLconf)就像 Django 所支撑网站的目录.它的本质是URL模式以及要为该URL模式调用的视图函数之间的 ...
随机推荐
- 网上有一种错误的做法是:因为每一个双连通分量内的点low[]值都是相同的，则dfs()时，对于一条边(u,v),只需low[u]=min(low[u],low[v])，这样就不用缩点，最后求度数的时候
- Timus - 1213 - Cockroaches!
先上题目: 1213. Cockroaches! Time limit: 1.0 secondMemory limit: 64 MB It's well-known that the most ten ...
- [bzoj3062][Usaco13Feb]Taxi_贪心
Taxi bzoj-3062 Usaco13Feb 题目大意:有n个奶牛想坐出租车.第i头奶牛在起点a[i]等候,想坐出租车到b[i].Bessie从0出车,车上只能坐一头奶牛.她必须完成所有奶牛的要 ...
- linux中O(1)调度算法与全然公平(CFS)调度算法
一.O(1)调度算法 1.1:优先级数组 O(1)算法的:一个核心数据结构即为prio_array结构体. 该结构体中有一个用来表示进程动态优先级的数组queue,它包括了每一种优先级进程所形成的链表 ...
- spring学习笔记(22)声明式事务配置，readOnly无效写无异常
在上一节内容中.我们使用了编程式方法来配置事务,这种优点是我们对每一个方法的控制性非常强.比方我须要用到什么事务,在什么位置假设出现异常须要回滚等.能够进行非常细粒度的配置.但在实际开发中.我们可能并 ...
- ZOJ 1649 Rescue(有敌人迷宫BFS)
题意 求迷宫中从a的位置到r的位置须要的最少时间 经过'.'方格须要1s 经过'x'方格须要两秒 '#'表示墙 因为有1s和2s两种情况 须要在基础迷宫bfs上加些推断 令到达每一个点的时间初 ...
- 简单总结static、final、this关键字的使用
在最近看书的过程中,常常遇到static.final.this这三个关键字,不是很明白它们的使用,查阅资料结合实例做了如下总结: 一.static——无需创建对象就可以调用(方法.属性). 1.静态变 ...
- luogu3865 【模板】 ST表
题目大意:给出一段序列,每次查询一段区间,求区间最大值. ST表:设原序列为A,定义F[i][k]为A[i][2k-1]的最大值.有递归式:F[i][k]=max(F[i][k-1], F[i+2k- ...
- HDU3535 AreYouBusy 混合背包
题目大意 给出几组物品的体积和价值,每组分为三种:0.组内物品至少选一个:1.组内物品最多选一个:2.组内物品任意选.给出背包容量,求所能得到的最大价值. 注意 仔细审题,把样例好好看完了再答题,否则 ...
- CodeForces 660A
Description You are given an array of n elements, you must make it a co-prime array in as few moves ...