准备工作：熟悉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对象的属性和方法
1 from django.shortcuts import render,HttpResponse
2
3 # Create your views here.
4 def index(request):
5 #request.POST
6 #request.GET
7 #return HttpResponse("hello world!")
8 #1.path:请求页面的全路径,不包括域名
9 print(request.path)
10
11 #2.get_full_path:请求页面的全路径,包括域名
12 print(request.get_full_path())
13
14 #3.method:请求中使用的HTTP方法
15 #if req.method == "GET":
16 # do_something()
17 #elseif req.method=="POST":
18 # do_something_else()
19 #GET: 包含所有HTTP GET参数的类字典对象
20 # POST:包含所有HTTP POST参数的类字典对象
21 # 服务器收到空的POST请求的情况也是可能发生的，也就是说，表单form通过
22 # HTTP POST方法提交请求，但是表单中可能没有数据，因此不能使用
23 #if req.POST来判断是否使用了HTTP POST方法；应该使用 if req.method=="POST"
24
25 #4.COOKIES:包含所有cookies的标准Python字典对象；keys和values都是字串。
26
27 #5.FILES:包含所有上传文件的类字典对象；
28 # FILES中的每一个Key都是<input type = "file" name = "" / > 标签中name属性的值，
29 # FILES中的每一个value同时也是一个标准的python字典对象，包含下面三个Keys：
30 # filename:上传文件名，用字符串表示
31 # content_type:上传文件的Content Type
32 # content:上传文件的原始内容
33
34 #6.user:是一个django.contrib.auth.models.User对象，代表当前登陆的用户。如果访问用户当前
35 # 没有登陆，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你可以通
36 # 过user的is_authenticated()方法来辨别用户是否登陆：
37 # if req.user.is_authenticated();
38 # 只有激活Django中的AuthenticationMiddleware时该属性才可用
39
40 # 7.session:唯一可读写的属性，代表当前会话的字典对象；自己有激活Django中的session支持时该属性才可用。
Http Request对象的属性和方法Http Request对象的属性和方法
2. HttpResponse对象的属性和方法
HttpRequest对象是由django自动创建的，HttpResponse对象需要我们自己创建，每个view请求处理方法必须返回一个HttpResponse对象。
HttpResponse类在django.http.HttpResponse
在HttpResponse对象上扩展的常用方法：
页面渲染:render()(推荐), render_to_response()
页面跳转:redirect("路径")
locals():可以直接将函数中所有的变量传给模板
注册-登录-用户首页流程模拟
1 /*--------------------register.html-------------------*/
2 <body>
3 <form action="{% url 'register' %}" method="post">
4 <p>用户名<input type="text" name="username"></p>
5 <p>密码<input type="password" name="password"></p>
6 <p><input type="submit" value="提交注册"></p>
7
8 </form>
9 <script src="/static/jquery-3.1.1.js"></script>
10 </body>
11 /*--------------------login.html---------------------*/
12 <body>
13 <form action="{% url 'login' %}" method="post">
14 <p>姓名<input type="text" name="username"></p>
15 <p>性别<input type="text" name="sex"></p>
16 <p>邮箱<input type="text" name="email"></p>
17 <p><input type="submit" value="submit"></p>
18 </form>
19 /*--------------------user_page.html--------------*/
20 <body>
21 <h1>用户{{ name }}你好</h1>
22 </body>
23 /*---------------------blog\urls.py------------------*/
24 from django.contrib import admin
25 from django.urls import path
26 from django.conf.urls import url
27
28 from blog import views
29
30 urlpatterns = [
31 # path('admin/', admin.site.urls),
32
33 url(r'register/',views.register,name="register"),
34 url(r'^login',views.login,name="login"),
35 url(r'^user_page',views.user_page,name="user_page")
36 ]
37 /*----------------------views.py-----------------------*/
38 from django.shortcuts import render,HttpResponse,render_to_response,redirect
39
40 # Create your views here.
41 user_list=[]
42 def register(request):
43 if request.method == "POST":
44 username=request.POST.get("username",None)
45 password=request.POST.get("password",None)
46 print("username:",username)
47 if username:
48 user_list.append(username)
49 return redirect("/blog/login/")
50 #redirect方法进行页面跳转时，地址栏URL会跟改为跳转页面的，此处为http://127.0.0.1/blog/login
51 #return render(request,"login.html")
52 #在此处用render方法进入页面，地址栏URL不会改变，仍然为http;//127.0.0.1/blog/index
53
54 return HttpResponse("username is None")
55 return render(request,"register.html")
56 #或者render_to_response("register.html")
57 def login(request):
58 if request.method=="POST":
59 user=request.POST.get("username",None)
60 if user in user_list:
61 name=user
62 return redirect("/blog/user_page/")
63 return HttpResponse("username does not exist")
64
65 return render(request, "login.html")
66
67 def user_page(request):
68
69 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 # 1.句点用于访问列表索引:
2
3 >>> from django.template import Template, Context
4 >>> t = Template('Item 2 is {{ items.2 }}.')
5 >>> c = Context({'items': ['apples', 'bananas', 'carrots']})
6 >>> t.render(c)
7 'Item 2 is carrots.'
8
9 # 2.句点用于访问字典索引:
10
11 >>> from django.template import Template, Context
12 >>> person = {'name': 'Sally', 'age': '43'}
13 >>> t = Template('{{ person.name }} is {{ person.age }} years old.')
14 >>> c = Context({'person': person})
15 >>> t.render(c)
16 'Sally is 43 years old.'
17
18 #3.句点访问对象属性,如 Python 的 datetime.date 对象有year,month 和 day 几个属性,可#以在模板中使用句点来访问这些属性：
19
20 >>> from django.template import Template, Context
21 >>> import datetime
22 >>> d = datetime.date(1993, 5, 2)
23 >>> d.year
24 1993
25 >>> d.month
26 5
27 >>> d.day
28 2
29 >>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.')
30 >>> c = Context({'date': d})
31 >>> t.render(c)
32 'The month is 5 and the year is 1993.'
33
34 # 4.句点通过实例变量访问自定义类属性，这个方法适用于任意的对象。
35
36 >>> from django.template import Template, Context
37 >>> class Person(object):
38 ... def __init__(self, first_name, last_name):
39 ... self.first_name, self.last_name = first_name, last_name
40 >>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.')
41 >>> c = Context({'person': Person('John', 'Smith')})
42 >>> t.render(c)
43 'Hello, John Smith.'
44
45 #5. 句点也可以用来引用对象的方法。例如，每个 Python 字符串都有 upper() 和 isdigit()方法，你在模板中可以使用同样的句点语法来调用它们：
46 >>> from django.template import Template, Context
47 >>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}')
48 >>> t.render(Context({'var': 'hello'}))
49 'hello -- HELLO -- False'
50 >>> t.render(Context({'var': '123'}))
51 '123 -- 123 -- True'模板变量的filter使用
1 0# 语法格式:{{obj|filter:param}}
1 #1. add :给变量加上相应的值
2 #2. addslashes :给变量中的引号前加上斜线
3 #3. capfirst:首字母大写
4 #4. cut:从字符串中移除指定的字符
5 #5. date:格式化日期字符串
6 #6. default :如果值是False,就替换成设置的默认值，否则就是用本来的值
7 #7. default_if_none: 如果值是None，就替换成设置的默认值，否则就使用本来的值
8 #实例:
9
10 #value1="aBcDe"
11 {{ value1|upper }}<br>
12
13 #value2=5
14 {{ value2|add:3 }}<br>
15
16 #value3='he llo wo r ld'
17 {{ value3|cut:' ' }}<br>
18
19 #import datetime
20 #value4=datetime.datetime.now()
21 {{ value4|date:'Y-m-d' }}<br>
22
23 #value5=[]
24 {{ value5|default:'空的' }}<br>
25
26 #value6='<a href="#">跳转</a>'
27
28 {{ value6 }}
29
30 {% autoescape off %}
31 {{ value6 }}
32 {% endautoescape %}
33
34 {{ value6|safe }}<br>
35
36 {{ value6|striptags }}
37
38 #value7='1234'
39 {{ value7|filesizeformat }}<br>
40 {{ value7|first }}<br>
41 {{ value7|length }}<br>
42 {{ value7|slice:":-1" }}<br>
43
44 #value8='http://www.baidu.com/?a=1&b=3'
45 {{ value8|urlencode }}<br>
46 value9='hello I am yuan'
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
1 forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1
2
3 {% for item in todo_list %}
4 <p>{{ forloop.counter }}: {{ item }}</p>
5 {% endfor %}
6 forloop.counter0 类似于forloop.counter，但它是从0开始计数，第一次循环设为0
7 forloop.revcounter
8 forloop.revcounter0
9 forloop.first当第一次循环时值为True，在特别情况下很有用：
10 #{% empty %}判断列表是否为空
11
12 {{li }}
13 {% for i in li %}
14 <li>{{ forloop.counter0 }}----{{ i }}</li>
15 {% empty %}
16 <li>this is empty!</li>
17 {% endfor %}
18
19 # [11, 22, 33, 44, 55]
20 # 0----11
21 # 1----22
22 # 2----33
23 # 3----44
24 # 4----554.特殊标签
(1) {%csrf_token%}：csrf_token标签，用于防治跨站攻击验证。注意如果你在view的index里用的是render_to_response方法，该标签不会生效
其实，{%csrf_token%}是会生成一个input标签，和其他表单标签一起提交给后台。
(2) {% url '路由别名' %}: 引用路由配置的地址
1 <form action="{% url "bieming"%}" >
2 <input type="text">
3 <input type="submit"value="提交">
4 {%csrf_token%}
5 </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（如何调用）
自定义filter和simple_tag函数
1 /*-------------------my_tag.py-----------------*/
2 from django import template
3 from django.utils.safestring import mark_safe
4 register = template.Library() #register的名字是固定的,不可改变
5 @register.filter #只能传递一个参数，能用在逻辑控制语句中
6 def filter_multi(v1,v2):
7 return v1 * v2
8
9 @register.simple_tag #参数不限，但不能用在逻辑控制语句中
10 def simple_tag_multi(v1,v2):
11 return v1 * v2
12
13 /*---------------使用my_tag的html------------*/
14 {% load my_tag %}
15 # num=12
16 {{ num|filter_multi:2 }} #调用自定义filter24
17 {% simple_tag_multi 2 5 %}#调用自定义simple_tag7. 继承模板
{% 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里有如下设置
1 DATABASES = {
2 'default': {
3 'ENGINE': 'django.db.backends.sqlite3',
4 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
5 }
6 }如果我们想要更改数据库，需要修改如下：
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'mydatabase',
'USER': 'mydatabaseuser',
'PASSWORD': 'mypassword',
'HOST': '127.0.0.1',
'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() 问题解决！
如果使用的驱动是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})（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）聚合查询
aggregate(*args,**kwargs)
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')}（6）分组查询
annotate
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}]>（7）F查询和Q查询
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)))（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': '1111111','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': '1111111','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张表>>>>>>>待续
扫一扫
2891
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
