准备工作：熟悉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支持时该属性才可用。
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'
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----55
4.特殊标签
(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（如何调用）
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_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里有如下设置
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'])
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）聚合查询
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）分组查询
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 使用查询条件的值,专门取对象中某列值的操作 # 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张表
>>>>>>>待续