Django
介绍
Django 是一个由 Python 写成的开放源代码的 Web 应用框架。其内部组件非常全面,包括 模板,admin,认证,ORM,form组件等.
Django开发环境用的是wsgiref这个模块来做服务器,一个wsgiref的初级服务器
from wsgiref.simple_server import make_server
def index():
return "这是home界面"
def home():
return "这是home界面"
# 存储url与其对应的函数
URL_FUNC = [
("/index/",index),
("/home/",home)
]
def run_server(environ,start_response): # 处理函数
# environ：一个包含所有HTTP请求信息的dict对象；
# start_response：一个发送HTTP响应的函数。
start_response("200 OK",[('Content-Type', 'text/html;charset=utf8')]) # 发送HTTP响应的状态码和头信息,每一对键值都用元组表示
url = environ["PATH_INFO"] # 取到用户输入的url,然后根据url返回对应的内容
func_name = None
for i in URL_FUNC:
if url == i[0]:
func_name = i[1] # 如果找到对应关系,就把函数名拿到
break
if func_name: # 拿到可执行的函数,获取执行结果
body = func_name()
else:
body = "404找不到这个页面"
return [bytes("<h1>{}</h1>".format(body),encoding="utf8"),] # 发送给客户端的信息,注意数据类型
if __name__ == "__main__":
httpd = make_server('',8000,run_server) # 启动服务端,指定IP,端口,处理函数
print("Serving HTTP on port 8000...") # 开始监听HTTP请求
安装
pip3 install django==1.11.9 #==后是版本
2.0版本的model设置时外键关系必须指定on_delete参数
使用
创建Django项目
# 命令行 切换到存放Django项目的文件下 django-admin startproject 项目名
生成新的项目的项目目录
mysite/
├── manage.py # 管理文件
└── mysite # 项目目录
├── __init__.py
├── settings.py # 配置
├── urls.py # 路由 --> URL和函数的对应关系
└── wsgi.py # runserver命令就使用wsgiref模块做简单的web server
└── static # 动态文件目录(自己创建的,名字是自己起的,要与配置文件对应)
└── template # HTML文件目录(自己创建的,名字是自己起的,要与配置文件对应)
创建应用
# 切换到Django目录下 python manage.py startapp 项目名 # 还要把应用注册到配置文件中
项目目录下会多出一个同名文件夹,内部目录
app01/ ├── admin.py # admin组件用的 ├── apps.py # 注册app用 ├── __init__.py ├── migrations # orm的记录 │ └── __init__.py ├── models.py # 一般存放orm类 ├── tests.py └── views.py # 一般存放视图函数
视图
Django视图是负责业务逻辑业务的处理,其方式可以分为FBV(类的方式)和CBV(函数的方式).其本质上没有区别,CBV中利用了反射来根据请求类型决定执行那个方法
路由注册
from django.conf.urls import url
urlpatterns = [
url(正则表达式, views视图函数，参数，别名),
url(正则表达式, views视图类.as_view()，参数，别名),
]
CBV
from django.views import View # 要创建CBV就要先导入View作为CBV的基类
class Login(View):
def get(self,request): #处理get请求的方法
return render(request,"ceshi.html") #方法名是写死的
def post(self,request): # 处理post请求的方法
print(request.POST)
return render(request, "ceshi.html")
FBV
def XXX(request): # 处理post请求的方法
print(request.POST)
return render(request, "ceshi.html")
CBV的装饰器
CBV时的注意事项？
- 装饰器
from django.views import View
from django.utils.decorators import method_decorator
def auth(func):
def inner(*args,**kwargs):
return func(*args,**kwargs)
return inner
class UserView(View):
@method_decorator(auth)
def get(self,request,*args,**kwargs):
return HttpResponse('...')
- csrf的装饰器要加到dispath
from django.views import View
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt,csrf_protect
class UserView(View):
@method_decorator(csrf_exempt)
def dispatch(self, request, *args, **kwargs):
return HttpResponse('...')
或
from django.views import View
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt,csrf_protect
@method_decorator(csrf_exempt,name='dispatch')
class UserView(View):
def dispatch(self, request, *args, **kwargs):
return HttpResponse('...')
路由
上面简单介绍了路由,下面来深入了解一下
注意：
Django 2.0版本中的路由系统已经替换成下面的写法（官方文档）：
from django.urls import path
urlpatterns = [
path('articles/2003/', views.special_case_2003),
path('articles/<int:year>/', views.year_archive),
path('articles/<int:year>/<int:month>/', views.month_archive),
path('articles/<int:year>/<int:month>/<slug:slug>/', views.article_detail),
]
基本格式
from django.conf.urls import url
urlpatterns = [
url(正则表达式, views视图函数，参数，别名),
]
参数说明
- 正则表达式：一个正则表达式字符串
- views视图函数：一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
- 参数：可选的要传递给视图函数的默认参数（字典形式）
- 别名：一个可选的name参数
正则表达式的注意事项
- urlpatterns中的元素按照书写顺序从上往下逐一匹配正则表达式，一旦匹配成功则不再继续。
- 若要从URL中捕获一个值，只需要在它周围放置一对圆括号（分组匹配）。
- 不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。
- 每个正则表达式前面的'r' 是可选的但是建议加上。
补充
# 是否开启URL访问地址后面不为/跳转至带有/的路径的配置项 APPEND_SLASH=True
分组命名匹配
用简单的正则表达式分组匹配（通过圆括号）来捕获URL中的值并以位置参数形式传递给视图。
在更高级的用法中，可以使用分组命名匹配的正则表达式组来捕获URL中的值并以关键字参数形式传递给视图。
在Python的正则表达式中，分组命名正则表达式组的语法是(?P<name>pattern)，其中name是组的名称，pattern是要匹配的模式。
传递到视图函数中的参数永远是一个字符串类型。
# 捕获参数,位置传参
url(r'^data/([0-9]{4})/([0-2][0-9])/',function)
# 关键字传参
url(r'^data/(?P<year>[0-9]{4})/(?P<day>[0-2][0-9])/',function)
请求及响应
请求对象
django.core.handlers.wsgi.WSGIRequest
django将请求报文中的请求行、头部信息、内容主体封装成 HttpRequest 类中的属性。所有的属性应该被认为是只读的，除非另有说明
常用属性
HttpRequest.method # 一个字符串，表示请求使用的HTTP 方法。必须使用大写。 # 例如："GET"、"POST" HttpRequest.GET # 一个类似于字典的对象，包含 HTTP GET 的所有参数。详情请参考 QueryDict 对象。 HttpRequest.POST # 一个类似于字典的对象，如果请求中包含表单数据，则将这些数据封装成 QueryDict 对象。 # POST 请求可以带有空的 POST 字典 —— 如果通过 HTTP POST 方法发送一个表单，但是表单中没有任何的 # 数据，QueryDict 对象依然会被创建。 # 因此，不应该使用 if request.POST 来检查使用的是否是POST 方法；应该使用 if request.method == # "POST" 另外：如果使用 POST 上传文件的话，文件信息将包含在 FILES 属性中。 HttpRequest.FILES # 一个类似于字典的对象，包含所有的上传文件信息。 FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据。 注意，FILES 只有在请求的方法为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况下才会 包含数据。否则，FILES 将为一个空的类似于字典的对象。 request.FILES["input框的name"].name # 获得文件名 request.FILES["input框的name"].chunks() # chunks()是一个生成器函数,yield self.read(),
注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：
request.POST.getlist("hobby")
QueryDict对象
from django.http import QueryDict
# reuqest.GET和POST的数据类型,该数据类型继承了字典,默认不可以被修改.如果我们想要修改其中数据,建议
# 是将其进行深拷贝,然后将其_mutable 属性设置为True,就可以对新的QueryDict进行修改
# 其设置属性同字典
def get_tag(request):
params = request.GET
print(type(params))
import copy
params = copy.deepcopy(params)
params._mutable = True
params['name] = ''
return HttpResponse('OK')
# 由QueryDict生成URL后的条件
QueryDictObj.urlencode()
文件上传的示例
def upload(request):
if request.method == "POST":
# 从请求的FILES中获取上传文件的文件名，file为页面上type=files类型input的name属性值
filename = request.FILES["file"].name
# 在使用该文件名项目目录下新建一个文件
with open(filename, "wb") as f:
# 从上传的文件对象中一点一点读
for chunk in request.FILES["file"].chunks():
# 写入本地文件
f.write(chunk)
return HttpResponse("上传OK")
更多的属性
0.HttpRequest.scheme
表示请求方案的字符串（通常为http或https）
1.HttpRequest.body
一个字节码，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML,Json等。
但是，如果要处理表单数据的时候，推荐还是使用 HttpRequest.POST 。
另外，我们还可以用 python 的类文件方法去操作它，详情参考 HttpRequest.read() 。
2.HttpRequest.path
一个字符串，表示请求的路径组件（不含域名）。
例如："/music/bands/the_beatles/"
3.HttpRequest.method
一个字符串，表示请求使用的HTTP 方法。必须使用大写。
例如："GET"、"POST"
4.HttpRequest.encoding
一个字符串，表示提交的数据的编码方式（如果为 None 则表示使用 DEFAULT_CHARSET 的设置，默认为 'utf-8'）。
这个属性是可写的，你可以修改它来修改访问表单数据使用的编码。
接下来对属性的任何访问（例如从 GET 或 POST 中读取数据）将使用新的 encoding 值。
如果你知道表单数据的编码不是 DEFAULT_CHARSET ，则使用它。
5.HttpRequest.COOKIES
一个标准的Python 字典，包含所有的cookie。键和值都为字符串。
6.HttpRequest.META
一个标准的Python 字典，包含所有的HTTP 首部。具体的头部信息取决于客户端和服务器，下面是一些示例：
CONTENT_LENGTH —— 请求的正文的长度（是一个字符串）。
CONTENT_TYPE —— 请求的正文的MIME 类型。
HTTP_ACCEPT —— 响应可接收的Content-Type。
HTTP_ACCEPT_ENCODING —— 响应可接收的编码。
HTTP_ACCEPT_LANGUAGE —— 响应可接收的语言。
HTTP_HOST —— 客服端发送的HTTP Host 头部。
HTTP_REFERER —— Referring 页面。
HTTP_USER_AGENT —— 客户端的user-agent 字符串。
QUERY_STRING —— 单个字符串形式的查询字符串（未解析过的形式）。
REMOTE_ADDR —— 客户端的IP 地址。
REMOTE_HOST —— 客户端的主机名。
REMOTE_USER —— 服务器认证后的用户。
REQUEST_METHOD —— 一个字符串，例如"GET" 或"POST"。
SERVER_NAME —— 服务器的主机名。
SERVER_PORT —— 服务器的端口（是一个字符串）。
从上面可以看到，除 CONTENT_LENGTH 和 CONTENT_TYPE 之外，请求中的任何 HTTP 首部转换为 META 的键时，
都会将所有字母大写并将连接符替换为下划线最后加上 HTTP_ 前缀。
所以，一个叫做 X-Bender 的头部将转换成 META 中的 HTTP_X_BENDER 键。
7.HttpRequest.user
一个 AUTH_USER_MODEL 类型的对象，表示当前登录的用户。
如果用户当前没有登录，user 将设置为 django.contrib.auth.models.AnonymousUser 的一个实例。你可以通过 is_authenticated() 区分它们。
例如：
if request.user.is_authenticated():
# Do something for logged-in users.
else:
# Do something for anonymous users.
user 只有当Django 启用 AuthenticationMiddleware 中间件时才可用。
-------------------------------------------------------------------------------------
匿名用户
class models.AnonymousUser
django.contrib.auth.models.AnonymousUser 类实现了django.contrib.auth.models.User 接口，但具有下面几个不同点：
id 永远为None。
username 永远为空字符串。
get_username() 永远返回空字符串。
is_staff 和 is_superuser 永远为False。
is_active 永远为 False。
groups 和 user_permissions 永远为空。
is_anonymous() 返回True 而不是False。
is_authenticated() 返回False 而不是True。
set_password()、check_password()、save() 和delete() 引发 NotImplementedError。
New in Django 1.8:
新增 AnonymousUser.get_username() 以更好地模拟 django.contrib.auth.models.User。
8.HttpRequest.session
一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django 启用会话的支持时才可用。
完整的细节参见会话的文档。
一些方法
1.HttpRequest.get_host()
根据从HTTP_X_FORWARDED_HOST（如果打开 USE_X_FORWARDED_HOST，默认为False）和
HTTP_HOST 头部信息返回请求的原始主机。
如果这两个头部没有提供相应的值，则使用SERVER_NAME 和SERVER_PORT，在PEP 3333 中有详细描
述。
USE_X_FORWARDED_HOST：一个布尔值，用于指定是否优先使用 X-Forwarded-Host 首部，仅在
代理设置了该首部的情况下，才可以被使用。
例如："127.0.0.1:8000"
注意：当主机位于多个代理后面时，get_host() 方法将会失败。除非使用中间件重写代理的首部。
2.HttpRequest.get_full_path()
返回 path，带参数
例如："/music/bands/the_beatles/?print=true"
3.HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
返回签名过的Cookie 对应的值，如果签名不再合法则返回django.core.signing.BadSignature。
如果提供 default 参数，将不会引发异常并返回 default 的值。
可选参数salt 可以用来对安全密钥强力攻击提供额外的保护。max_age 参数用于检查Cookie 对应的时
间戳以确保Cookie 的时间不会超过max_age 秒。
>>> request.get_signed_cookie('name')
'Tony'
>>> request.get_signed_cookie('name', salt='name-salt')
'Tony' # 假设在设置cookie的时候使用的是相同的salt
>>> request.get_signed_cookie('non-existing-cookie')
...
KeyError: 'non-existing-cookie' # 没有相应的键时触发异常
>>> request.get_signed_cookie('non-existing-cookie', False)
False
>>> request.get_signed_cookie('cookie-that-was-tampered-with')
...
BadSignature: ...
>>> request.get_signed_cookie('name', max_age=60)
...
SignatureExpired: Signature age 1677.3839159 > 60 seconds
>>> request.get_signed_cookie('name', False, max_age=60)
False
4.HttpRequest.is_secure()
如果请求时是安全的，则返回True；即请求通是过 HTTPS 发起的。
5.HttpRequest.is_ajax()
如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH
相应的首部是否是字符串'XMLHttpRequest'。
大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器
端），你必须手工设置这个值来让 is_ajax() 可以工作。
如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的
cache middleware，
你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓
存。
响应对象
与由Django自动创建的HttpRequest对象相比，HttpResponse对象是我们的职责范围了。我们写的每个视图都需要实例化，填充和返回一个HttpResponse。
HttpResponse类位于django.http模块中。该文件中设置了有三种响应对象,HttpResponse(文本),render(模板渲染),redirect(重定向)
from django.http import HttpResponse
response = HttpResponse("Here's the text of the Web page.")
响应对象的属性
HttpResponse.content：响应内容 HttpResponse.charset：响应内容的编码 HttpResponse.status_code：响应的状态码
设置响应头
response['key']=vel
HttpResponse(文本),render(模板渲染),redirect(重定向)
render()
# render(request, template_name[, context]）
# 结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。
# 其默认的Content-Type标头设置为application/json
参数：
request： 用于生成响应的请求对象。
template_name：要使用的模板的完整名称，可选的参数
context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲
染模板之前调用它。
content_type：生成的文档要使用的MIME类型。默认为 DEFAULT_CONTENT_TYPE 设置的值。
status：响应的状态码。默认为200。
redirect()
# 传递一个视图的名称
def my_view(request):
return redirect('视图名', foo='bar') # foo="bar" 是参数的键值对
# 传递要重定向到的一个具体的网址
def my_view(request):
return redirect('/some/url/') # 一个url
# 当然也可以是一个完整的网址
def my_view(request):
return redirect('http://example.com/')
# 默认情况下，redirect() 返回一个临时重定向。以上所有的形式都接收一个permanent 参数；如果设置为True，将返回一个永久的重定向：
JsonResponse
为了向不同的客户端发送数据(其他类型的客户端是指非浏览器)
JsonResponse是HttpResponse的子类，专门用来生成JSON编码的响应。
from django.http import JsonResponse
def userinfo(request):
data = [{"name": "皮皮虾", "dream": "不被人骑"}]
return JsonResponse(data, safe=False)
默认只能传递字典类型，如果要传递非字典类型需要设置一下safe关键字参数。
模板
模板语法跳过,下面来说一下模板的继承,组件与自定义方法
继承:母板中定义块,子板中导入模板来填充块
# 母板
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Title</title>
{% block page-css %}
<!-- 这就是待填充的块 page-css 是这个块的名字,这是准备填充css的块-->
{% endblock %}
</head>
<body>
<h1>这是母板的标题</h1>
{% block page-main %}
<!--一个准备填充HTML的块-->
{% endblock %}
<h1>母板底部内容</h1>
{% block page-js %}
<!--一个准备填充js的块-->
{% endblock %}
</body>
</html>
# 子板
{% extends "母板文件名" %}
{% block page-main %}
<p>赵客缦胡缨，吴钩霜雪明。</p>
<p>银鞍照白马，飒沓如流星。</p>
{% endblock %}
组件:将一个html文件拉到固定位置
{% include "文件名" %}
自定义方法
- 文件所在的文件夹名为templatetags
- 且文件夹需要与urls.py等文件同级(APP文件中)
- 任意创建一个py文件
- 创建名字交 register 的Library类的对象
- 定义函数
管道处理
from django import template
register = template.Library()
# 必须有上面两句
# name就是管道符后面的filter名
@register.filter(name="cut")
def cut(value, arg): # value是管道符前value,arg是filter参数
return value.replace(arg, "") # return值为模板中实际值
# 可以不指定name,使用函数名
@register.filterarg
def add_sb(value):
return value+SB
# 模板中调用
{{ somevariable|cut:"0" }} # 将"0"替换为空字符串
{{ d.name|addSB }} # 在后面添加一个SB(帅逼)
函数处理
@register.simple_tag
def func(a1,a2,a3,a4):
result = a1+a2+a3+a4
return result
# 模板中调用
{% func 1 2 3 4 %}
插件(将参数传递给函数生成html)
from django import template
register = template.Library() # register的名字是固定的,不可改变
@register.inclusion_tag("blog/archive.html") # 传递一个HTML页面
def get_archive_style(username):
...
return {kwargs} # 将返回值传递给html文件
# 模板中调用
{% load py文件名 %}
{% get_archive_style username %} # 渲染好的html会插入到此位置
ORM
Django自带了ORM,配置数据库这里就不说了,直接介绍ORM的使用
创建无外键关系的模型类
from django.db import models
class Class(models.Model):
id = models.AutoField(primary_key=True)
cname = models.CharField(max_length=20)
更多字段
AutoField # int自增列，必须填入参数 primary_key=True
BigAutoField # bigint自增列，必须填入参数 primary_key=True
# 注：当model中如果没有自增列，则自动会创建一个列名为id的列
SmallIntegerField # 小整数 -32768 ～ 32767
PositiveSmallIntegerField # 正小整数 0 ～ 32767
IntegerField # 整数列(有符号的) -2147483648 ～ 2147483647
PositiveIntegerField # 正整数 0 ～ 2147483647
BigIntegerField # 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807
FloatField # 浮点型
DecimalField # 10进制小数
- 参数：
max_digits，小数总长度
decimal_places，小数位长度
BinaryField # 二进制类型
DurationField # 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型
DateTimeField # 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
DateField # 日期格式 YYYY-MM-DD
TimeField # HH:MM[:ss[.uuuuuu]]
BooleanField # 布尔值类型
NullBooleanField # 可以为空的布尔值
CharField # 字符类型,必须提供max_length参数， max_length表示字符长度
TextField # 文本类型
EmailField # 字符串类型，Django Admin以及ModelForm中提供验证机制
IPAddressField # 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制
GenericIPAddressField # 字符串类型，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 # 字符串类型，Django Admin以及ModelForm中提供验证 URL
SlugField # 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）
CommaSeparatedIntegerField # 字符串类型，格式必须为逗号分割的数字
UUIDField # 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证
FilePathField # 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
- 参数：
path, 文件夹路径
match=None, 正则匹配
recursive=False, 递归下面的文件夹
allow_files=True, 允许文件
allow_folders=False, 允许文件夹
FileField # 字符串，路径保存在数据库，文件上传到指定目录
- 参数：
upload_to = "" 上传文件的保存路径
storage = None 存储组件，默认django.core.files.storage.FileSystemStorage
ImageField # 路径保存在数据库，文件上传到指定目录
- 参数：
upload_to = "" 上传文件的保存路径
storage = None 存储组件，默认django.core.files.storage.FileSystemStorage
width_field=None, 上传图片的高度保存的数据库字段名（字符串）
height_field=None 上传图片的宽度保存的数据库字段名（字符串）
更多参数
null #数据库中字段是否可以为空
db_column #数据库中字段的列名
default #数据库中字段的默认值
primary_key #数据库中字段是否为主键
db_index #数据库中字段是否可以建立索引
unique #数据库中字段是否可以建立唯一索引
unique_for_date #数据库中字段【日期】部分是否可以建立唯一索引
unique_for_month #数据库中字段【月】部分是否可以建立唯一索引
unique_for_year #数据库中字段【年】部分是否可以建立唯一索引
auto_now_add #时间字段值为生成记录的时间,转化成modelform不会展示
verbose_name #Admin中显示的字段名称
blank #Admin中是否允许用户输入为空
editable #Admin中是否可以编辑
help_text #Admin中该字段的提示信息
choices #Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作,数据库中实际存的是第0个元素
如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
limit_choices_to # 翻译为modelform时过滤展示的字段，值是一个字典{"depart_id__in":[1002,1003]}
error_messages #自定义错误信息（字典类型），从而定制想要显示的错误信息；
字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
如：{'null': "不能为空.", 'invalid': '格式错误'}
validators #自定义错误验证（列表类型），从而定制想要的验证规则
from django.core.validators import RegexValidator
from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
如：
test = models.CharField(
max_length=32,
error_messages={
'c1': '优先错信息1',
'c2': '优先错信息2',
'c3': '优先错信息3',
},
validators=[
RegexValidator(regex='root_\d+', message='错误了', code='c1'),
RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
EmailValidator(message='又错误了', code='c3'), ]
)
元信息
class UserInfo(models.Model):
nid = models.AutoField(primary_key=True)
username = models.CharField(max_length=32)
class Meta:
# 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
db_table = "table_name"
# 联合索引
index_together = [
("pub_date", "deadline"),
]
# 联合唯一索引
unique_together = (("driver", "restaurant"),)
# 默认排序
ordering = ['属性名']
# admin中显示的表名称
verbose_name
# verbose_name加s
verbose_name_plural
普通查询
首先要知道三个类
# QuerySet对象是一个类似列表的集合 models.Book.objects.filter(title="新年快乐") <QuerySet [<Book: 新年快乐>]> # 模型类对象对应数据库的一行数据 models.Book.objects.get(title="新年快乐") <Book: 新年快乐> # 管理器对象 models.Book.objects <django.db.models.manager.Manager object at 0x0000020FAD57B358>
QuerySet和管理器对象可以使用方法来进行查询
# 返回QuerySet对象的方法,调用者可以是QuerySet或objects
Class.objects.all() # 返回全部数据对象的QuerySet
Class.objects.filter(条件) # 返回符合条件全部对象的QuerySet
Class.objects.exclude(条件) # 返回不符合条件的全部对象的QuerySet
Class.objects.values(字段名,字段名) # 返回指定字段名字与值组成的字典的QuerySet
QuerySet.values_list(字段名,字段名) # 返回指定字段值的元组的QuerySet
Class.objects.order_by("字段名") # 返回排好序的QuerySet
Class.objects.reverse() # 返回反转的QuerySet
Class.objects.distinct() # 去重
Class.objects.only() # 指定字段,如果在返回的模型类对象中再去查找其他属性会再次进行查询
Class.objects.defer() # 排除指定字段,如果在返回的模型类对象中再去查找指定属性会再次进行查询
# 返回模型类实例的方法
Class.objects.first() # 返回第一条记录
Class.objects.last() # 返回最后一条记录
Class.objects.get(条件) # 返回一个满足条件的数据对象,有多条满足条件的报错
# 返回其他类型
Class.objects.count() # 返回模型类实例的数量
Class.objects.exists() # 判断是否为空
get , filter , exclude查询条件
属性名__lt=10 # 属性值小于10 属性名__gt=10 # 属性值大于10 属性名__in=[1,2,3]# 属性值存在列表中的 属性名__contains="xx" # 属性包含"xx"的,相当于limit "%xx%" 属性名__icontains="xx" # 不区分大小写的包含 属性名__isnull = bool # 是否有值,之是一个布尔值 属性名__range=[x,y] # 属性值范围大于等于x,小于等于y,相当于sql中的bettwen x and y 类似的还有startswith，istartswith, endswith, iendswith data字段还可以 models.Class.objects.filter(data字段名__year=2017) # 2017年的
查询中多条件的关系是并列,Q类型可以实现复杂的关系
from django.db.models import Q
s = Q() # 实例Q对象
s.connector = "or" # 对象内部条件关系为or,默认为and
s.children.append(("name", "wei"))
s.children.append(("age", "18"))
model.objects.filter(s)
# 相当于
model.objects.filter(Q(name="wei")|Q(age=18))
# 并且Q对象的属性也能够使用双下方法 &=and ~=not |=or
models.Book.objects.filter(Q(author__name="陈粒")&~Q(title="小半"))
<QuerySet [<Book: 新年快乐>]>
# 合并条件进行查询
con = Q()
q1 = Q()
q1.connector = 'OR'
q1.children.append(('id', 1))
q1.children.append(('id', 2))
q1.children.append(('id', 3))
q2 = Q()
q2.connector = 'OR'
q2.children.append(('status', '在线'))
con.add(q1, 'AND')
con.add(q2, 'AND')
models.Book.objects.filter(con)
除了Q类之外,Django还提供了F类,查询条件的值,来计算或比较
from django.db.models import F,Q
# 增加价格都加一块
>>>models.Book.objects.update(price=F("price")+1)
# 查询歌曲价格小于作者年龄一半的
>>>models.Book.objects.filter(price__lt=F("author__age")/2)
<QuerySet [<Book: 新年快乐>, <Book: 新年快乐>, <Book: 济南济南>, <Book: 绿茶>, <Book: 冷血动物>]>
增删改
# 增 # 第一种方式 -- 生成数据并且提交到数据库 Class.objects.create(属性=值,属性=值) # 可以将一个字典打散传入,**解包 # 第二种方式 -- 需要提交 new_info = Class(属性=值) new_info.save() # 批量添加 model.objects.bulk_create([models_obj_list]) # 删 models.Student.objects.filter( sname="狗哥").delete() models.Student.objects.get( sname="狗娃").delete() # 可以删除一个对象,也可以删除一个列表中的全部对象,为了防止不小心把表中的数据都删除，想删除表中的一切数据时，Django 要求必须显式调用 all() 方法。 Class.objects.delete() 无效 Class.objects.all().delete() 生效删除部分数据，无需调用 all() 方法 如上面的例子 # 改 # 查到 QuerySet 对象 update(属性=新的值),可以批量操作,update() 方法有返回值，是一个整数，表示修改的记录数量。 # 或者查到对象,使用赋值的方法修改,然后提交.只能对一个对象操作,不能对QuerySet 对象操作 # 方案一 models.Student.objects.filter(sname="大驴").update(sname="二驴") # 方案二 new_s = models.Student.objects.filter(cid=28).first() # 可以修改 new_s.sname="大驴" new_s.save() # 方案二的错误方式 new_s = models.Student.objects.filter(cid=28) # 可以修改 new_s.sname="大驴" new_s.save()
外键关系
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, # 默认创建第三张表时，数据库中表的名称
需要注意的是db_constraint这个参数
外键属性的值
# 该属性对应一个关联的对象
多对多的三种方式
多对多的三种方式
# 一 ,创建第三张表,第三张表中的两个字段关联两个有关系的表
# 二 ,使用models.ManyToManyField()作为字段的值,并且由Django创建第三张表(默认,表名为APP名_小写类名_属性名,表中字段名为小写类名_id)
# 三 ,使用models.ManyToManyField()作为字段的值,自己创建第三张表(传入thrugh="表名"through_fields=("关联字段名", "关联字段名"))
# 方式二的一些操作create() 创建一个新的对象,保存对象,并将它添加到关联对象集中,返回新创建的对象(可以进行链式操作)模型类对象.多对多属性.create(属性=值,属性=值)
# 为关联的类添加一行数据
add() # 把指定的model对象添加到关联对象集中,需要将集合打散
# 模型类对象.多对多属性值.add(关联模型对象)
b = Blog.objects.get(id=1)
>>> e = Entry.objects.get(id=234)
>>> b.entry_set.add(e)
#模型类对象.多对多属性值.add(*关联模型对象的集合) # QuerySet对象就是模型对象的集合,在第三张表中添加对应记录
>>> book_obj = Book.objects.get(id=1)
>>> author_list = Author.objects.filter(id__gt=2)
>>> book_obj.authors.add(*author_list)
#模型类对象.多对多属性值.add(*数据库值主键集合) # 通过Django自建第三张表还可以使用数据库值添加对应记录
book_obj.authors.add(*[1,3])
set() # 更新模型类对象的关联对象
# 模型类对象.多对多属性值.set(关联模型对象的集合)
# 模型类对象.多对多属性值.set(数据库值集合)
remove() # 从关联对象集中移除关联对象
# 模型类对象.多对多属性值.remove(关联模型对象)
# 模型类对象.多对多属性值.remove(数据库值)
clear() # 从关联对象中移除一切对象
模型类对象.多对多属性值.clear()
- remove()或clear()方法操作后如果关联对象集为空的话，必须满足null=True。
- 对于所有类型的关联字段，add()、create()、remove()和clear(),set()都会马上更新数据库。换句话说，在关联的任何一端，都不需要再调用save()方法。
跨表查询,查询另一张表的数据
>>>models.Book.objects.get(title="新年快乐").author # author 是多对多属性 <django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager object at 0x0000020FAD5FE6A0> >>>models.Book.objects.get(title="新年快乐").author.all() <QuerySet [<Author: 好妹妹乐队>, <Author: 陈粒>]> # 反向 >>>models.Author.objects.get(name="陈粒").book_set.all() # 反向查找小写表名_set <QuerySet [<Book: 新年快乐>]>
作为条件进行查询
使用__来进行跨表,可以用在filter,values,values_list或者Q对象的属性
>>>models.Author.objects.filter(book__title="新年快乐") # 反向查
<QuerySet [<Author: 好妹妹乐队>, <Author: 陈粒>]>
>>>models.Book.objects.filter(author__name="好妹妹乐队") # 正向查
<QuerySet [<Book: 新年快乐>]>
>>>models.Author.objects.filter(name="陈粒").values("name","book__title") # QuerySet.values
<QuerySet [{'name': '陈粒', 'book__title': '新年快乐'}]>
>>>models.Book.objects.filter(title="新年快乐").values("title","author__name")
<QuerySet [{'title': '新年快乐', 'author__name': '好妹妹乐队'}, {'title': '新年快乐', 'author__name': '陈粒'}]>
查询优化
iterator
objs = Book.objects.all().iterator()
# iterator()可以一次只从数据库获取少量数据，这样可以节省内存
for obj in objs:
print(obj.title)
#BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
for obj in objs:
print(obj.title)
# 使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使用iterator()的
# 时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询
select_related
对于一对一字段（OneToOneField）和外键字段（ForeignKey），可以使用select_related 来对QuerySet进行优化。
models.XXX.objects.select_related("外键字段名").all()
# 会与指定的表进行连表查询,不会再去跨表
# 多外键查询
models.XXX.objects.select_related("外键字段名","外键字段名")
# 多层外键可以使用双下划线的方法,会将多张表连表
prefetch_related
对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。
prefetch_related()和select_related()的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。后者是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。若有n个对象，每个对象的多对多字段对应Mi条，就会生成Σ(n)Mi 行的结果表。
prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。
models.XXX.objects.prefetch_related("对多字段名").all()
# select * from userinfo where id <= 8
# 计算：[1,2]
# select * from usertype where id in [1,2]
objs = UserInfo.obejcts.filter(id__lte=8).prefetch_related('ut')
for obj in objs:
print(obj.name,obj.ut.title) # 外键信息已经存在obj中,不会产生额外查询
分组与聚合
聚合
aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的
# 用于计算的函数
from django.db.models import Avg,Min,Sum,Max
>>>models.Book.objects.filter(author__name="陈粒").aggregate(Sum("price"))
{'price__sum': Decimal('14.00')}
#如果你想要为聚合值指定一个名称，可以向聚合子句提供它。
>>> models.Book.objects.filter(author__name="陈粒").aggregate(price=Sum("price"))
{'price': Decimal('14.00')}
#如果你希望生成不止一个聚合，你可以向aggregate()子句中添加另一个参数。
>>> models.Book.objects.all().aggregate(Sum("price"),Max("price"),Avg("price"))
{'price__sum': Decimal('45.66'), 'price__max': Decimal('10.00'), 'price__avg': 7.61}
分组
为调用的QuerySet中每一个对象都生成一个独立的统计值属性,
查询每个人歌曲的总价格
# 从人表查,以每个人为一组,为每个人的歌曲价格求和
a = models.Author.objects.annotate(arg=Sum("book__price"))
for i in a:
print(i,i.arg)
好妹妹乐队 5.00
陈粒 14.00
谢安琪 10.00
陈小熊 8.00
杨亚茹 6.66
谢天笑 7.00
成龙 None
# 从歌曲表查,指定以人分组
b = models.Book.objects.values("author__name").annotate(arg = Sum("price"))
for i in b:
print(i["author__name"],i["arg"])
好妹妹乐队 5.00
陈粒 14.00
谢安琪 10.00
陈小熊 8.00
杨亚茹 6.66
谢天笑 7.00
执行原生SQL
添加额外查询
# extra
# 在QuerySet的基础上继续执行子语句
# extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
# select和select_params是一组，where和params是一组，tables用来设置from哪个表
# 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'])
执行SQL语句
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)
获取连接,执行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(..)
选择数据库
指定数据库生成表
python manage.py makemigraions python manage.py migrate app名称 --databse=配置文件数据名称的别名 # 告诉Django将迁移标记为已应用或未应用，但实际上并未运行SQL来更改数据库模式。 python manage.py migrate app名称 --databse=配置文件数据名称的别名 --fake # manage.py文档 https://docs.djangoproject.com/en/1.11/ref/django-admin/
数据库查询
models.UserType.objects.using('db1').create(title='普通用户')
result = models.UserType.objects.all().using('default')
# 注意,只有queryset才能使用using指定数据库
使用配置文件
class Router1:
def allow_migrate(self, db, app_label, model_name=None, **hints):
"""
migrate时执行此方法,db数据库名,app_labelapp名
返回True允许生成,False禁止生成,None交给下个类处理
"""
if db=='db1' and app_label == 'app02':
return True
elif db == 'default' and app_label == 'app01':
return True
else:
return False
def db_for_read(self, model, **hints):
"""
读操作时执行此方法,需要返回表名,model是操作的模型类
"""
if model._meta.app_label == 'app01':
return 'default'
else:
return 'db1'
def db_for_write(self, model, **hints):
"""
写操作时执行此方法,需要返回表名,model是操作的模型类
"""
if model._meta.app_label == 'app01':
return 'default'
else:
return 'db1'
# 另外还有一个跨表是执行的方法,不过那个方法还有bug
# 配置文件
DATABASE_ROUTERS = ['路径.路由类名',]
根据数据库生成表
python manage .py inspectdb # 给default数据库生成 inspectdb --database yian # 指定库名生成
anaconda
