http://www.cnblogs.com/yuanchenqi/articles/6083427.html
本节内容：
1：MVC和MTV是什么
2：django命令
3：Django的配置文件(settings)
4：Django URL (路由系统)
5：Django Views（视图函数） ~V
6：Django Template基础 ~T
7：Django Model基础 ~M
8：Django Admin
1：MVC和MTV是什么
著名的MVC模式：所谓MVC就是把web应用分为模型(M),控制器(C),视图(V)三层；他们之间以一种插件似的，松耦合的方式连接在一起。
模型负责业务对象与数据库的对象(ORM); 视图负责与用户的交互(页面); 控制器(C)接受用户的输入调用模型和视图完成用户的请求。
Django的MTV模式本质上与MVC模式没有什么差别，也是各组件之间为了保持松耦合关系，只是定义上有些许不同，Django的MTV分别代表：
Model(模型)：负责业务对象与数据库的对象(ORM) Template(模版)：负责如何把页面展示用户 View(视图)：负责业务逻辑，并在适当的时候调用Model和Template 此外，Django还有一个url分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template
注意的是：
在MVC中的V视图是代表着--->html文件。而在MTV中的V是一个个的函数视图。
def index(request): return render(request,"base.html")
2：django常用命令
安装： pip3 install django django-admin startproject sitename ##创建project python manage.py runserver 0.0.0.0 ##启动服务 python manage.py startapp appname ##创建app python manage.py syncdb python manage.py makemigrations ##数据库 python manage.py migrate python manage.py createsuperuser
import django
django.VERSION ##查看django的版本是多少
pip3 install django --upgrade # #升级django
pip3 uninstall django ##卸载django
3：Django的静态文件(settings)
a：setting配置文件要有django.contrib.staticfiles'
INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', "app01", ]
b：setting文件的STATIC_URL
STATIC_URL = '/static/' ##使用的时候只能是采用别名的方式去引用静态文件： STATICFILES_DIRS = ( os.path.join(BASE_DIR,"statics"), # os.path.join(BASE_DIR,"blog","statics"), ##一个app对应一个静态文件 )
c：在template目录的html文件中 使用
##第一种 <script src="/static/jquery-3.3.1.min.js"></script> #第二种 {% load staticfiles %} ##首行 <script src="{% static "jquery-3.3.1.min.js" %}"></script>
4：Django URL (路由系统)
URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL模式以及要为该URL模式调用的视图函数之间的映射表；你就是以这种方式告诉Django，对于这个URL调用这段代码，对于那个URL调用那段代码。
urlpatterns = [
url(正则表达式, views视图函数，参数，别名),
]
参数说明：
- 一个正则表达式字符串
- 一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
- 可选的要传递给视图函数的默认参数（字典形式）
- 一个可选的name参数
传递的参数始终是字符串
from django.conf.urls import url from app01 import views urlpatterns = [ # 一般 url(r'^articles/2003/$', views.special_case_2003), url(r'^articles/([0-9]{4})/$', views.year_archive), url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive), # 路由分发 url(r'^contact/', include('django_website.contact.urls')), # 传给视图的默认参数，对应的视图函数也必须加上同名的参数 url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}), #name参数 别名 url(r'^index',views.index,name='bieming'), ##<a href="{% url "bieming" %}">click me</a> ]
5:Django Views（视图函数）
当一个请求来了，会对应的去匹配app 里面view视图函数。而一个view视图即一个请求的过程。
http请求中产生两个核心对象：
http请求：HttpRequest对象
http响应：HttpResponse对象
1 HttpRequest对象的属性和方法：
path： 请求页面的全路径，不包括域名 # # method： 请求中使用的HTTP方法的字符串表示。全大写表示。例如 # # if req.method=="GET": # # do_something() # # elseif req.method=="POST": # # do_something_else() # # GET: 包含所有HTTP GET参数的类字典对象 # # POST： 包含所有HTTP POST参数的类字典对象 # # 服务器收到空的POST请求的情况也是可能发生的，也就是说，表单form通过 # HTTP POST方法提交请求，但是表单中可能没有数据，因此不能使用 # if req.POST来判断是否使用了HTTP POST 方法；应该使用 if req.method=="POST" # # # # COOKIES: 包含所有cookies的标准Python字典对象；keys和values都是字符串。 # # FILES： 包含所有上传文件的类字典对象；FILES中的每一个Key都是<input type="file" name="" />标签中 name属性的值，FILES中的每一个value同时也是一个标准的python字典对象，包含下面三个Keys： # # filename： 上传文件名，用字符串表示 # content_type: 上传文件的Content Type # content： 上传文件的原始内容 # # # user： 是一个django.contrib.auth.models.User对象，代表当前登陆的用户。如果访问用户当前 # 没有登陆，user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你 # 可以通过user的is_authenticated()方法来辨别用户是否登陆： # if req.user.is_authenticated();只有激活Django中的AuthenticationMiddleware # 时该属性才可用 # # session： 唯一可读写的属性，代表当前会话的字典对象；自己有激活Django中的session支持时该属性才可用。 #方法 get_full_path(), 比如：http://127.0.0.1:8000/index33/?name=123 ,req.get_full_path()得到的结果就是/index33/?name=123 req.path:/index33
2 HttpResponse对象：
对于HttpRequest对象来说，是由django自动创建的，但是，HttpResponse对象就必须我们自己创建。每个view请求处理方法必须返回一个HttpResponse对象。
HttpResponse类在django.http.HttpResponse
在HttpResponse对象上扩展的常用方法：
页面渲染：render，render_to_response（不需要加request） 其本质就是调用的:HttpResponse 页面跳转：redirect locals： 可以直接将函数中所有的变量传给模板
from django.shortcuts import render,render_to_response,redirect from django.shortcuts import HttpResponse def index(request): # return render(request,"base.html") # return render_to_response("base.html") return redirect("/register/") # return HttpResponse("SUCCESS")
6：Django Template基础
Django的template目录中的html文件是包括了html标签和template语言的。
在发送response响应给客户端，要先将template模版语言与html标签进行渲染之后才发送给客户端。
模板语法
1：变量（使用双大括号来引用变量）：
语法格式： {{var_name}}
a：Template和Context对象（了解）
>>> python manange.py shell (进入该django项目的环境) >>> from django.template import Context, Template >>> t = Template('My name is {{ name }}.') >>> c = Context({'name': 'Stephane'}) >>> t.render(c) 'My name is Stephane.' # 同一模板，多个上下文，一旦有了模板对象，你就可以通过它渲染多个context，无论何时我们都可以 # 像这样使用同一模板源渲染多个context，只进行 一次模板创建然后多次调用render()方法渲染会 # 更为高效： # Low for name in ('John', 'Julie', 'Pat'): t = Template('Hello, {{ name }}') print t.render(Context({'name': name})) # Good t = Template('Hello, {{ name }}') for name in ('John', 'Julie', 'Pat'): print t.render(Context({'name': name}))
我们对Template和Context对象的了解之后，基本是不用这个的：而是直接用render
def current_time(req): now=datetime.datetime.now() return render(req, 'current_datetime.html', {'current_date':now})
b：万能的点(.)
view可以template中传递的数据类型：
列表、字典、元组、字符串、数字....
而要使用如字典还有列表等数据格式。采用点(.)
######view########### class foo: def __init__(self,a): self.a = a def register(request,FOO): person = {"name":'cfp',"age":22,"hobby":"gril"} l = [1,2,3] str1 = "hello" num = 10 c = foo('xx') return render(request,"register.html",locals()) #########register.html########## <body> {{ person.age }} #22 {{ c.a }} ##xx {{ str1 }} ##hello </body>
c：变量的过滤器(filter)的使用
语法格式： {{obj|filter:param}}
# 1 add ： 给变量加上相应的值 # # 2 addslashes : 给变量中的引号前加上斜线 # # 3 capfirst : 首字母大写 # # 4 cut ： 从字符串中移除指定的字符 # # 5 date ： 格式化日期字符串 # # 6 default ： 如果值是False,就替换成设置的默认值，否则就是用本来的值 # # 7 default_if_none: 如果值是None，就替换成设置的默认值，否则就使用本来的值 #实例: #value1="aBcDe" {{ value1|upper }}<br> #value2=5 {{ value2|add:3 }}<br> #value3='he llo wo r ld' {{ value3|cut:' ' }}<br> #import datetime #value4=datetime.datetime.now() {{ value4|date:'Y-m-d' }}<br> #value5=[] {{ value5|default:'空的' }}<br> #value6='<a href="#">跳转</a>' {{ value6 }} {% autoescape off %} {{ value6 }} {% endautoescape %} {{ value6|safe }}<br> {{ value6|striptags }} #value7='1234' {{ value7|filesizeformat }}<br> {{ value7|first }}<br> {{ value7|length }}<br> {{ value7|slice:":-1" }}<br> #value8='http://www.baidu.com/?a=1&b=3' {{ value8|urlencode }}<br> value9='hello I am yuan'
2：标签(tag)的使用（使用大括号和百分比的组合来表示使用tag）
{% tags %}
a：{% if %} 的使用
{% if num >= 100 and 8 %}
{% if num > 200 %}
<p>num大于200</p>
{% else %}
<p>num大于100小于200</p>
{% endif %}
{% elif num < 100%}
<p>num小于100</p>
{% else %}
<p>num等于100</p>
{% endif %}
{% if %} 标签接受and，or或者not来测试多个变量值或者否定一个给定的变量
{% if %} 标签不允许同一标签里同时出现and和or，否则逻辑容易产生歧义，例如下面的标签是不合法的：
{% if obj1 and obj2 or obj3 %}
b：{% for %}的使用
<ul> {% for obj in list %} <li>{{ obj.name }}</li> {% endfor %} </ul> #在标签里添加reversed来反序循环列表： {% for obj in list reversed %} ... {% endfor %} #{% for %}标签可以嵌套： {% for country in countries %} <h1>{{ country.name }}</h1> <ul> {% for city in country.city_list %} <li>{{ city }}</li> {% endfor %} </ul> {% endfor %} #系统不支持中断循环，系统也不支持continue语句，{% for %}标签内置了一个forloop模板变量， #这个变量含有一些属性可以提供给你一些关于循环的信息 1:forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1: {% for item in todo_list %} <p>{{ forloop.counter }}: {{ item }}</p> {% endfor %} 2，forloop.counter0 类似于forloop.counter，但它是从0开始计数，第一次循环设为0 3，forloop.revcounter 4，forloop.revcounter0 5，forloop.first当第一次循环时值为True，在特别情况下很有用： {% for object in objects %} {% if forloop.first %}<li class="first">{% else %}<li>{% endif %} {{ object }} </li> {% endfor %} # 富有魔力的forloop变量只能在循环中得到，当模板解析器到达{% endfor %}时forloop就消失了 # 如果你的模板context已经包含一个叫forloop的变量，Django会用{% for %}标签替代它 # Django会在for标签的块中覆盖你定义的forloop变量的值 # 在其他非循环的地方，你的forloop变量仍然可用 #{% empty %} {{li }} {% for i in li %} <li>{{ forloop.counter0 }}----{{ i }}</li> {% empty %} <li>this is empty!</li> {% endfor %} # [11, 22, 33, 44, 55] # 0----11 # 1----22 # 2----33 # 3----44 # 4----55
c：{%csrf_token%}：csrf_token标签
用于生成csrf_token的标签，用于防治跨站攻击验证。注意如果你在view的index里用的是render_to_response方法，不会生效
其实，这里是会生成一个input标签，和其他表单标签一起提交给后台的。
<form action="/register/" method="post"> <input type="text" name="user"> <input type="password" name="pwd"> <input type="submit"> {% csrf_token %} </form>
d：{% url %}: 引用路由配置的地址
<form action="{% url "bieming"%}" > <input type="text"> <input type="submit"value="提交"> {%csrf_token%} </form>
e：{% with %}:用更简单的变量名替代复杂的变量名
{% with total=fhjsaldfhjsdfhlasdfhljsdal %} {{ total }} {% endwith %}
f：{% verbatim %}: 禁止render
{% verbatim %}
{{ hello }}
{% endverbatim %}
###不将 hello进行渲染，本文内容就是 {{hello}}
g：{% load %}: 加载标签库
3：自定义变量过滤(filter)和标签（simple_tag）
a、在app中创建templatetags模块(必须的)
b、创建任意 .py 文件，如：my_tags.py
from django import template from django.utils.safestring import mark_safe register = template.Library() #register的名字是固定的,不可改变 @register.filter def filter_multi(x,y,): return x*y @register.simple_tag def simple_multi(x,y,z): return x**y*z
c、在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py ：{% load my_tags %}
d、使用simple_tag和filter（如何调用）
-------------------------------.html {% load xxx %} #首行 # num=12 {{ num|filter_multi:2 }} #24 ##只能有一个参数 {{ num|filter_multi:"[22,333,4444]" }} {% simple_tag_multi 2 5 %} #参数不限,但不能放在if for语句中 {% simple_tag_multi num 5 %}
e、在settings中的INSTALLED_APPS配置当前app，不然django无法找到自定义的simple_tag.
4： extend模板继承
母html：{% block content %} {% endblock %} ##block越多越好，block也可以叫做钩子
子html：
{% extends "base.html" %} ##必须在html页面的首行
{% block content %} ##要修改的内容都在block包含，其他都是一样的
{{ block.super }} ##执行母版中的block中的内容
内容。。。
{% endblock %}
我觉的一个html文件内容写的很好。想直接内嵌到自己的html文件中：
1：{% load staticfiles %}
2：{% include "test.html" %}
{% load staticfiles %}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<style>
*{
margin: 0;
padding: 0;
}
.nav {
line-height: 40px;
100%;
height: 40px;
background-color: #2459a2;
color: white;
font-size: 20px;
text-align: center;
}
.left {
20%;
background-color: lightblue;
min-height: 694px;
overflow: hidden;
float: left;
}
.manage {
text-align: center;
padding: 15px 0;
margin: 20px 0;
font-size: 20px;
color: white;
}
a {
text-decoration: none;
}
.content {
80%;
min-height: 694px;
display: inline-block;
float: left;
}
h1 {
text-align: center;
}
</style>
{% block css %}
{% endblock %}
<body>
<div class="outer">
<div class="nav">标题</div>
<div class="left">
<div class="student manage"><a href="/student/">学生管理</a></div>
<div class="teacher manage"><a href="">老师管理</a></div>
<div class="class manage"><a href="">班级管理</a></div>
<div class="course manage"><a href="">课程管理</a></div>
</div>
<div class="content">
{% block content %}
<h1>WELCOME TO MANAGE </h1>{% block manage %} {% endblock %}
{% endblock %}
</div>
</div>
<script src="/static/jquery-3.3.1.min.js"></script>
<script src="{% static "jquery-3.3.1.min.js" %}"></script>
<script>
$("h3").css("color","red")
</script>
</body>
</html>
{% extends "base.html" %}
{% load staticfiles %}
{% block css %}
<style>
H1,h2 {
text-align: center;
}
</style>
{% endblock %}
{% block content %}
{{ block.super }}{% block manage %}FOR STUDENT MANAGE{% endblock %}
{% for item in student_list %}
<h2>学生：{{ item }}</h2>
{% endfor %}
{% include "test.html" %}
{% endblock %}
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h1>hello world</h1> </body> </html>
7：Django Model基础 ~M
一、表与表之间的关系
一对一 一个外键加字段的unique 一对多 一个外键 多对多 两个外键
二、django的ORM
ORM（Object relation mapping）对象关系映射，把用python的一个类去对应数据库里面的一个表，用于实现面向对象编程语言里不同类型系统的数据之间的转换，换言之，就是用面向对象的方式去操作数据库的创建表以及增删改查等操作。
优点：
1 ：ORM使得我们的通用数据库交互变得简单易行，而且完全不用考虑该死的SQL语句。快速开发，由此而来。
2 ：可以避免一些新手程序猿写sql语句带来的性能问题。
注意：没有ORM我们一样是可以对数据库进行操作的：无非就是在view里面导入模块，创建游标
import pymysql def index(request): conn = pymysql.connect(host="127.0.0.1",port=3306,user="root",password='',database='') cursor = conn.cursor() cursor.execute("select * from t1;") data = cursor.fetchall() print(data) conn.commit() cursor.close() conn.close() return render(request,"base.html")
三、Model数据库的配置
1 django默认支持sqlite，mysql, oracle,postgresql数据库。
<1> sqlite
django默认使用sqlite的数据库，默认自带sqlite的数据库驱动 , 引擎名称：django.db.backends.sqlite3
<2> mysql
引擎名称：django.db.backends.mysql
2 mysql驱动程序
- MySQLdb(mysql python)
- mysqlclient
- MySQL
- PyMySQL(纯python的mysql驱动程序)
3 在django的项目中会默认使用sqlite数据库，在settings里有如下设置：
如果我们想要更改数据库，需要修改如下：
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'books', #你的数据库名称 'USER': 'root', #你的数据库用户名 'PASSWORD': '', #你的数据库密码 'HOST': '', #你的数据库主机，留空默认为localhost 'PORT': '3306', #你的数据库端口 } }
注意：
NAME即数据库的名字，在mysql连接前该数据库必须已经创建，而上面的sqlite数据库下的db.sqlite3则是项目自动创建
USER和PASSWORD分别是数据库的用户名和密码。
设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。
然后，启动项目，会报错：no module named MySQLdb
这是因为django默认你导入的驱动是MySQLdb，可是MySQLdb对于py3有很大问题，所以我们需要的驱动是PyMySQL
所以，我们只需要找到项目名文件下的__init__,在里面写入：
import pymysql
pymysql.install_as_MySQLdb()
问题解决！
四、在model文件创建一个表
1： ###app01下的model创建一个类
from django.db import models # Create your models here. class Book(models.Model): name = models.CharField(max_length=30) price = models.IntegerField() pub_date = models.DateField()
2：执行命令：python manage.py makemigrations
3：执行命令：python manage.py migrate 才会真正的在数据库中生成表
4：对数据库的快捷操作
步骤一：
步骤二：
步骤三：
步骤四：
五、表的操作(增删改查)：
增加:
第一种：通过类的对象去增加 b = Book(name='python1',price=67,pub_date="2018-4-12",author='yhy') b.save() 第二种：这种方式不需要再save一次 Book.objects.create(name='python4',price=124,pub_date="2018-4-12",author='cfp') 在学函数的时候：要是一个个的key = value的时候，我们可以采用 **dic的方式去传入值： dic = { "name":"python4","price":124,"pub_date":"2018-4-12","author":"cfp"} Book.objects.create(**dic)
修改：
查找数据的时候： filter 和 get 两种方式 filter方式：是获取到一个QuerySet的集合。 get的方式：是获取到一个model对象 ，而只要是model对象就必须才用save方法。 注意:save的效率太低，你要是只是修改一个字段，会将其他的字段都一起重新赋值，虽然没改别的字段。 ##filter Book.objects.filter(author='cfp').update(price='999') ##get b = Book.objects.get(author='cfp') b.price=123 b.save()
查看每个的sql的语句是怎么执行的：
需要在settings加上日志记录部分
LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console':{ 'level':'DEBUG', 'class':'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'propagate': True, 'level':'DEBUG', }, } } LOGGING
删除：
Book.objects.get(author='cfp').delete()
b = Book.objects.filter(author='yhy').delete()
print(b) ##(2, {'app01.Book': 2})Book表删除了两条数据
查找：
# 查询相关API： # <1>filter(**kwargs): 它包含了与所给筛选条件相匹配的对象 # <2>all(): 查询所有结果 # <3>get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
对查询到的进行操作：
select_list = Book.objects.all()[:2] ###切片操作 select_list = Book.objects.all()[2:2] select_list = Book.objects.all()[::2] b =Book.objects.filter(author='cfp').values("name","price") ##<QuerySet [{'name': 'python4', 'price': 124}]> ##字典列表的方式 c = Book.objects.filter(author='cfp').values_list("name","price") ##<QuerySet [('python4', 124)]> ##元组列表 # <5>exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象 # <6>order_by(*field): 对查询结果排序 # <7>reverse(): 对查询结果反向排序 # <8>distinct(): 从返回结果中剔除重复纪录 ###b =Book.objects.filter(author='cfp').values("name").distinct().count() # <9>values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列 # <10>count(): 返回数据库中匹配查询(QuerySet)的对象数量。 # <11>first(): 返回第一条记录 # <12>last(): 返回最后一条记录 # <13>exists(): 如果QuerySet包含数据，就返回True，否则返回False。
万能双下划线“__”
# 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") ##就是模糊查询 包含ven的书籍名字 # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 # # models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and # # startswith，istartswith, endswith, iendswith,
六、多表查询
查询记录（基于对象）
##正向查询 ##go这本书的出版社名字和地址 # cc = Book.objects.get(name="go") # cc = Book.objects.filter(name="go")[0] # print(cc.publist_id.name,cc.publist_id.addr) ##反向查询 ###通过"人民出版社"找到它出版的书名和价格 cc = Publish.objects.filter(name="人民出版社")[0] print(cc.book_set.all().values("name","price")) ##<QuerySet [{'name': 'go', 'price': 34}, {'name': 'java', 'price': 45}]>
查询记录（基于"__"）filter或value的双下划线
####通过"人民出版社"找到它出版的书名和价格 ret = Book.objects.filter(publist_id__name="人民出版社").values("name","price") print(ret) ##<QuerySet [{'name': 'go', 'price': 34}, {'name': 'java', 'price': 45}]> ####go这本书的出版社名字 ##book可以理解成反向查找 ret = Publish.objects.filter(book__name="go").values("name") print(ret) ##<QuerySet [{'name': '人民出版社'}]>
ret = Book.objects.filter(name="go").values("publist_id__name","publist_id__addr")
print(ret) ##<QuerySet [{'publist_id__name': '人民出版社', 'publist_id__addr': '北京'}]>
七、多对多表操作
多对多表的创建：
第一种： 让models自动帮你创建第三张表 class Book(models.Model): name = models.CharField(max_length=30) authors = models.ManyToManyField("Author") def __str__(self): return self.name 第二种： 自己建第三张表： class Book_Author(models.Model): book = models.ForeignKey("Book") author = models.ForeignKey("Author")
ManyToManyField操作
##添加数据 # book_obj = Book.objects.get(id=1) # authors = Author.objects.all() # # book_obj.authors.add(*authors) ##*是分解列表 #book_obj.authors.add(1) #book_obj.authors.add([2,3]) #给id为1的book加上，id为1,2,3的作者 ##删除数据 # # book_obj.authors.remove(*authors) ##解除全部 # book_obj.authors.remove(2) ##将id=2的作者移除 #book_obj.authors.clear() ##将id为1的book都清空 #book_obj.authors.set([2,3,5]) ##将id为1的book 作者重置为2,3,5的id ##查操作和多表查询是一样的都有基于对象和基于"__" # book= Book.objects.get(id=1) # ret=book.authors.all() # print(ret.values("name")) # # ret=Author.objects.filter(name='alex').values("book__name","book__price") # print(ret)
表： class User(models.Model): name = models.CharField(max_length=32) m = models.ManyToManyField(to="Tag",related_name="mm") def __str__(self): return self.name class Tag(models.Model): caption = models.CharField(max_length=32) def __str__(self): return self.caption tages = models.User.objects.filter(name="yhy").values("m__caption") ##m是在User表中，m直接关联了对应tags里面的多条字段 tages1 = models.Tag.objects.filter(user__m__user__name="yhy").values() # tag 和user 没有直接关联，而是通过user里面的m 第三张表 # user__m 找到第三张表，再反向__user找到user表 然后__name = "yhy"
手动创建第三张表操作：
操作 ： ##添加 # book_obj = Book.objects.get(id=2) # authors = Author.objects.all()[0] # Book_Author.objects.create(author=authors,book=book_obj) ##删除 Book_Author.objects.filter(author=1).delete() ##查询 表： class User(models.Model): name = models.CharField(max_length=32) def __str__(self): return self.name class Tag(models.Model): caption = models.CharField(max_length=32) def __str__(self): return self.caption class UserToTag(models.Model): nid = models.AutoField(primary_key = True) uid = models.ForeignKey(to="User") tid = models.ForeignKey(to="Tag") class Meta: unique_together = [("uid","tid"),] #反向查询 查询yhy对应的标签 找到对应的反向查询的表： usertotag 再根据里面表的，tid 或 uid找到对应的表 #tages= models.User.objects.filter(name="yhy").values("usertotag__tid__caption") #tages = models.Tag.objects.filter(usertotag__uid__name="yhy").values()
八、聚合和分组查询
要想使用聚合：aggregate先导入
from django.db.models import Min,Max,Count,Sum
聚合操作：
##查询alex出书的最少的价格是多少 # ret = Book.objects.filter(book_author__author__name="alex").aggregate(Sum("price")) # print(ret) ##查询出了多少本书 ret = Book.objects.filter(book_author__author__name="alex").aggregate(Count("price")) print(ret)
分组操作：
annotate: 分组，先分组再操作
filter: 就是筛选
##查询每个出版社出了几本书 # ret= Publish.objects.values("name").annotate(Count("book__name")) # print(ret) ##<QuerySet [{'name': '人民出版社', 'book__name__count': 2}, {'name': '河南出版社', 'book__name__count': 2}]> ##查询每个作者出了几本书 # ret = Book.objects.values("book_author__author__name").annotate(count=Count("name")) # print(ret) # < QuerySet[{'book_author__author__name': None, 'count': 2}, {'book_author__author__name': 'alex', 'count': 2}] >
九、F查询和Q查询
仅仅靠单一的关键字参数查询已经很难满足查询要求。此时Django为我们提供了F和Q查询：
什么是单关键字？
obj = Book.objects.get(name='go',price=45) ##get返回的结果有且只有一个，不然报错 ##name = "go" 就叫做单个关键字，一组键值对
要求1：给每个书卖价加10块钱
Book.objects.all().update(price=price+10) ？ 不对！这写法是错误是，虽然在mysql的sql语句中可以写
a、导入F、Q
from django.db.models import F,Q
b、实现要求：
Book.objects.all().update(price=F("price")+10) ##用F给他包起来
要求2：找出书籍价格为67 或 书籍名字为go的
obj = Book.objects.get(name='go',price=45) 你可以通过逗号实现与的操作。 而要想使用或就必须用到Q操作
obj = Book.objects.filter(Q(name="go")|Q(price=47)) print(obj) ##<QuerySet [<Book: go>, <Book: linux>]>
具体操作：
# F 使用查询条件的值,专门取对象中某列值的操作 # from django.db.models import F # models.Tb1.objects.update(num=F('num')+1) # Q 构建搜索条件 from django.db.models import Q #1 Q对象(django.db.models.Q)可以对关键字参数进行封装，从而更好地应用多个查询 q1=models.Book.objects.filter(Q(title__startswith='P')).all() print(q1)#[<Book: Python>, <Book: Perl>] # 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)))
十、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，可能 会造成额外的数据库查询。
8：Django Admin
Django Admin: 关于数据库的一个后台管理工具 和naicat 差不多。
a、创建超级用户
python manage.py createsuperuser ##创建超级用户
b、admin文件中的自定制：
from django.contrib import admin # Register your models here. from app01 import models class BookAdmin(admin.ModelAdmin): list_display = ("id","name","pub_date","price") ##显示 list_editable = ("name",) ##可以直接编辑的 filter_horizontal = ("authors",) ##在增加author的时候可以水平查找 list_per_page = 21 ##21条记录为1页 search_fields = ("name","authors__name") ##可以用name继续搜索记录,也可以用author_name list_filter = ("pub_date","publist_id") ##相当于分组了，根据日期、根据出版社查询 # ordering = ("-price",) ##admin里面的字段按降序排序 ordering = ("price","id") ##按升序,如果价格一样再按id去排 admin.site.register(models.Book,BookAdmin) admin.site.register(models.Publish) admin.site.register(models.Author)
c、admin页面都是英文 看中文setting配置文件
# LANGUAGE_CODE = 'en-us' LANGUAGE_CODE = 'zh-hans'
d、让admin页面的字段出现中文 models字段加verbose_name
class Book(models.Model): name = models.CharField(max_length=30,verbose_name="姓名") price = models.IntegerField("价格") ##不写verbose_name直接放在第一个也是可以的 pub_date = models.DateField(verbose_name="出版日期")
model的补充：
Field的重要参数
<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参数.
字段修饰符：
related_name #s2c = models.ForeignKey("Classes") s2c = models.ForeignKey("Classes",related_name="ssss") ##被关联的查询 ##反向 #Classes.objects.all().values("cname","student__sname") Classes.objects.all().values("cname","ssss__sname")