Django
- 简介
Django,发音为[`dʒæŋɡəʊ],是用python语言写的开源web开发框架,并遵循MVC设计。为了开发以新闻内容为主的网站,而开发出来了这个框架。Django的主要目的是简便、快速的开发数据库驱动的网站
- 特点
1) 重量级框架
提供项目工程管理的自动化脚本工具
数据库ORM支持(对象关系映射,英语:Object Relational Mapping)
模板
表单
Admin管理站点
文件管理
认证权限
session机制
缓存
2)MVT模式
程序设计模式叫MVC,其核心思想是分工、解耦,让不同的代码块之间降低耦合,增强代码的可扩展性和可移植性,实现向后兼容。
M(Model),主要封装对数据库层的访问,对数据库中的数据进行增、删、改、查操作。
V(View),用于封装结果,生成页面展示的html内容。
C(Controller),用于接收请求,处理业务逻辑,与Model和View交互,返回结果。
M(Model),与MVC中的M功能相同,负责和数据库交互,进行数据处理。
V(View),与MVC中的C功能相同,接收请求,进行业务处理,返回应答。
T(Template),与MVC中的V功能相同,负责封装构造要返回的html。
工程搭建
- 环境安装
mkvirtualenv django_py3_1.11 -p python3(创建虚拟环境)
pip install django==1.11.11(安装Django,使用1.1版本比较稳定)
虚拟环境 mkvirtualenv #
创建虚拟环境 rmvirtualenv
删除虚拟环境 workon #
进入虚拟环境、查看所有虚拟环境
deactivate # 退出虚拟环境
pip install # 安装依赖包
pip uninstall # 卸载依赖包
pip list # 查看已安装的依赖包
pip freeze # 冻结当前环境的依赖包
-
创建工程(django提供的命令帮助我们创建)
先在桌面创建一个文件夹,先切换到这个文件里面执行下面命令 django-admin startproject 工程名称(创建工程的命令)
工程目录说明
与项目同名的目录,此处为demo。
settings.py 是项目的整体配置文件。
urls.py 是项目的URL配置文件。
wsgi.py 是项目与WSGI兼容的Web服务器入口。
manage.py 是项目管理文件,通过它管理项目。
运行开发服务器
django提供了一个纯python编写的轻量级web服务器,仅在开发阶段使用。
运行服务器命令如下:
python manage.py runserver ip:端口
或:
python manage.py runserver
## 标题可以不写IP和端口,默认IP是127.0.0.1,默认端口为8000。
django默认工作在调式Debug模式下,如果增加、修改、删除文件,服务 器会自动重启。
按ctrl+c停止服务器。
3.创建子应用
Django的视图编写是放在子应用中的。
创建子应用模块
python manage.py startapp 子应用名称
子应用目录说明
admin.py 文件跟网站的后台管理站点配置相关。
apps.py 文件用于配置当前子应用的相关信息。
migrations 目录用于存放数据库迁移历史文件。
models.py 文件用户保存数据库模型类。
tests.py文件用于开发测试用例,编写单元测试。
views.py 文件用于编写Web应用视图。
注册安装子应用
将子应用的文件apps.py中的Config类注册到setting.py ,INSTALLED_APPS项中
如:users.apps.UsersConfig'。
4.创建视图
Django的视图是定义在子应用的views.py中的。
创建视图函数,在views.py中编写视图代码
from django.http import HttpResponse
def index(request):
"""
index视图
:param request: 包含了请求信息的请求对象
:return: 响应对象
"""
return HttpResponse("hello the world!")
视图函数的第一个传入参数必须定义,用于接收Django构造的包含了请求数据的HttpReqeust对象,通常名为request。
视图函数的返回值必须为一个响应对象,不能像Flask一样直接返回一个字符串,可以将要返回的字符串数据放到一个HTTPResponse对象中。
1)定义路由URL
在子应用中新建一个urls.py,一般子应用中路由保存到此文件中
-
在users/urls.py文件中定义路由信息。
from django.conf.urls import url from . import views urlpatterns是被django自动识别的路由列表变量 urlpatterns = [ # 每个路由信息都需要使用url函数来构造 **# url(路径, 视图)** url(r'^index/$', views.index), ]
-
在工程总路由demo/urls.py中添加子应用的路由数据。
from django.conf.urls import url, include from django.contrib import admin urlpatterns = [ url(r'^admin/', admin.site.urls), # django默认包含的 # 添加 url(r'^users/', include('users.urls')), ]
使用include来将子应用users里的全部路由包含进工程路由中;
r’^users/’ 决定了users子应用的所有路由都已/users/开头,如我们刚定义的视图index,其最终的完整访问路径为/users/index/。
include函数除了可以传递字符串之外,也可以直接传递应用的urls模块
import users.urls # 先导入应用的urls模块
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^users/', include(users.urls)), # 添加应用的路由,urls模块
]
-
启动运行
python manage.py runserver
配置、静态文件与路由
1.配置文件
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
django默认有的,dirname指的是顶层目录,abspath指的是绝对路径,__file__指的是setting.py文件
2.DEBUG
创建工程后初始值为True,即默认工作在调试模式下
作用:
修改代码文件,程序自动重启
Django程序出现异常时,向前端显示详细的错误追踪信息
注意:部署线上运行的Django不要运行在调式模式下,记得修改DEBUG=False。
本地语言与时区
中国大陆地区使用简体中文,时区使用亚洲/上海时区,注意这里不使用北京时区表示。
初始化的工程默认语言和时区为英语和UTC标准时区
LANGUAGE_CODE = ‘en-us’ # 语言
TIME_ZONE = ‘UTC’ # 时区
将语言和时区修改为中国大陆信息
LANGUAGE_CODE = ‘zh-hans’
TIME_ZONE = ‘Asia/Shanghai’
静态文件
STATICFILES_DIRS 存放查找静态文件的目录
STATIC_URL 访问静态文件的URL前缀
1) 在项目根目录下创建static_files目录来保存静态文件。
2) 在demo/settings.py中修改静态文件的两个参数为
STATIC_URL = '/static/'
STATICFILES_DIRS = [
os.path.join(BASE_DIR, 'static_files'),
]
3)此时在static_files添加的任何静态文件都可以使用网址 /static/文件在static_files中的路径 来访问了。
例如,我们向static_files目录中添加一个index.html文件,在浏览器中就可以使用127.0.0.1:8000/static/index.html来访问。
或者我们在static_files目录中添加了一个子目录和文件goods/detail.html,在浏览器中就可以使用127.0.0.1:8000/static/goods/detail.html来访问。
Django 仅在调试模式下(DEBUG=True)能对外提供静态文件。
当DEBUG=False工作在生产模式时,Django不再对外提供静态文件,需要是用collectstatic命令来收集静态文件并交由其他静态文件服务器来提供
3.路由说明
路由解析顺序
从主路由到子路由
从上至下的顺序
避免出现屏蔽效应,需要在主路由中每一个路由中添加命名空间namespace
如: url(r’^users/’, include(‘users.urls’, namespace=‘users’)),
命名空间的作用:避免不同应用中的路由使用了相同的名字发生冲突,使用命名空间区别开
在子路由中,添加name参数指明路由名,使用reverse函数,可以根据路由名称,返回具体的路径
from django.urls import reverse # 注意导包路径
def index(request):
return HttpResponse("hello the world!")
def say(request):
url = reverse('users:index') # 返回 /users/index/
print(url)
return HttpResponse('say')
对于未指明namespace的,reverse(路由name) reverse(‘index’)
对于指明namespace的,reverse(命名空间namespace:路由name) reverse(‘users:index’)
- 路径结尾斜线/的说明
其好处是用户访问不以斜线/结尾的相同路径时,Django会把用户重定向到以斜线/结尾的路径上,而不会返回404不存在
请求
URL路径参数
正则表达式提取参数的方法从URL中获取请求参数
未命名参数按定义参数顺序传递, 如
url(r'^weather/([a-z]+)/(\d{4})/$', views.weather),
def weather(request, city, year):
print('city=%s' % city)
print('year=%s' % year)
return HttpResponse('OK')
命名参数按名字正则传递,如
url(r'^weather/(?P<city>[a-z]+)/(?P<year>\d{4})/$', views.weather),
def weather(request, year, city):
print('city=%s' % city)
print('year=%s' % year)
return HttpResponse('OK')
Django中的QueryDict对象
HttpRequest对象的属性GET、POST都是QueryDict类型的对象
方法get():根据键获取值
如果一个键同时拥有多个值将获取最后一个值
如果键不存在则返回None值,可以设置默认值进行后续处理
dict.get('键',默认值)
可简写为
dict['键']
方法getlist():根据键获取值,值以列表返回,可以获取指定键的所有值
如果键不存在则返回空列表[],可以设置默认值进行后续处理
dict.getlist('键',默认值)
查询字符串Query String
通过request.GET属性获取,返回QueryDict对象(形如?k1=v1&k2=v2)
#/qs/?a=1&b=2&a=3
def qs(request):
a = request.GET.get('a')
b = request.GET.get('b')
alist = request.GET.getlist('a')
print(a) # 3
print(b) # 2
print(alist) # ['1', '3']
return HttpResponse('OK')
重要:查询字符串不区分请求方式,即假使客户端进行POST方式的请求,依然可以通过request.GET获取请求中的查询字符串数据。
请求体 表单类型 JSON XML
请求方式有POST、PUT、PATCH、DELETE。
请求体
Django默认开启了CSRF防护,会对上述请求方式进行CSRF防护验证,在测试时可以关闭CSRF防护机制,方法为在settings.py文件中注释掉CSRF中间件
表单类型 Form Data
前端发送的表单类型的请求体数据,可以通过request.POST属性获取,返回QueryDict对象。
def get_body(request):
a = request.POST.get('a')
b = request.POST.get('b')
alist = request.POST.getlist('a')
print(a)
print(b)
print(alist)
return HttpResponse('OK')
重要:request.POST只能用来获取POST方式的请求体表单数据。
非表单类型 Non-Form Data
request.body属性获取最原始的请求体数据,自己按照请求体格式(JSON、XML等)进行解析。request.body返回bytes类型。
import json
def get_body_json(request):
json_str = request.body
json_str = json_str.decode() # python3.6 无需执行此步
req_data = json.loads(json_str)
print(req_data['a'])
print(req_data['b'])
return HttpResponse('OK')
请求头
request.META属性获取请求头headers中的数据,request.META为字典类型
常见的请求头如:
CONTENT_LENGTH – The length of the request body (as a string).
CONTENT_TYPE – The MIME type of the request body.
HTTP_ACCEPT – Acceptable content types for the response.
HTTP_ACCEPT_ENCODING – Acceptable encodings for the response.
HTTP_ACCEPT_LANGUAGE – Acceptable languages for the response.
HTTP_HOST – The HTTP Host header sent by the client.
HTTP_REFERER – The referring page, if any.
HTTP_USER_AGENT – The client’s user-agent string.
QUERY_STRING – The query string, as a single (unparsed) string.
REMOTE_ADDR – The IP address of the client.
REMOTE_HOST – The hostname of the client.
REMOTE_USER – The user authenticated by the Web server, if any.
REQUEST_METHOD – A string such as "GET" or "POST".
SERVER_NAME – The hostname of the server.
SERVER_PORT – The port of the server (as a string).
具体使用如:
def get_headers(request):
print(request.META['CONTENT_TYPE'])
return HttpResponse('OK')
6 其他常用HttpRequest对象属性
method:一个字符串,表示请求使用的HTTP方法,常用值包括:‘GET’、‘POST’。
user:请求的用户对象。
path:一个字符串,表示请求的页面的完整路径,不包含域名和参数部分。
encoding:一个字符串,表示提交的数据的编码方式。
如果为None则表示使用浏览器的默认设置,一般为utf-8。
这个属性是可写的,可以通过修改它来修改访问表单数据使用的编码,接下来对属性的任何访问将使用新的encoding值。
FILES:一个类似于字典的对象,包含所有的上传文件。
响应
HttpRequest对象由Django创建,HttpResponse对象由开发人员创建。
HttpResponse(content=响应体, content_type=响应体数据类型, status=状态码)
HttpResponse对象属性来设置响应体、状态码:
content:表示返回的内容。
status_code:返回的HTTP响应状态码。
from django.http import HttpResponse
def demo_view(request):
return HttpResponse('itcast python', status=400)
或者
response = HttpResponse('itcast python')
response.status_code = 400
response['Itcast'] = 'Python'
return response
HttpResponse子类
Django提供了一系列HttpResponse的子类,可以快速设置状态码
HttpResponseRedirect 301
HttpResponsePermanentRedirect 302
HttpResponseNotModified 304
HttpResponseBadRequest 400
HttpResponseNotFound 404
HttpResponseForbidden 403
HttpResponseNotAllowed 405
HttpResponseGone 410
HttpResponseServerError 500
JsonResponse
若要返回json数据,可以使用JsonResponse来构造响应对象,作用:
帮助我们将数据转换为json字符串
设置响应头Content-Type为 application/json
from django.http import JsonResponse
def demo_view(request):
return JsonResponse({'city': 'beijing', 'subject': 'python'})
4 redirect重定向
from django.shortcuts import redirect
def demo_view(request):
return redirect('/index.html')
Cookie
Cookie是存储在浏览器中的一段纯文本信息,建议不要存储敏感信息如密码
Cookie的特点
Cookie以键值对的格式进行信息的存储。
Cookie基于域名安全,不同域名的Cookie是不能互相访问的,如访问itcast.cn时向浏览器中写了Cookie信息,使用同一浏览器访问baidu.com时,无法访问到itcast.cn写的Cookie信息。
当浏览器请求某网站时,会将浏览器存储的跟网站相关的所有Cookie信息提交给网站服务器。
设置Cookie
HttpResponse.set_cookie(cookie名, value=cookie值,
max_age=cookie有效期, 单位为秒,默认为None,临时cookie,可将max_age设置为None。
def demo_view(request):
response = HttpResponse('ok')
response.set_cookie('itcast1', 'python1') # 临时cookie
response.set_cookie('itcast2', 'python2', max_age=3600) # 有效期一小时
return response
读取Cookie
COOKIES属性来读取本次请求携带的cookie值。request.COOKIES为字典类型。
def demo_view(request):
cookie1 = request.COOKIES.get('itcast1')
print(cookie1)
return HttpResponse('OK')
Session
Django项目默认启用Session。在settings.py文件中查看
存储方式
数据库(默认存储方式)
SESSION_ENGINE='django.contrib.sessions.backends.db'
本地缓存
SESSION_ENGINE='django.contrib.sessions.backends.cache'
混合存储
SESSION_ENGINE='django.contrib.sessions.backends.cached_db'
Redis(重要)
1) 安装扩展
pip install django-redis
2)配置
在settings.py文件中做如下设置
CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/1",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
}
}
}
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"
出现Redis连接错误
解决方法:
修改redis的配置文件,添加特定ip地址
打开redis的配置文件,添加需要修改的ip地址
sudo vim /etc/redis/redis.conf
sudo service redis-server restart(重启服务器)
Session操作
request.session['key']=value(键值对格式写session)
request.session.get('key',默认值)(按键取值)
request.session.clear()(清除所有session,删除值)
request.session.flush()(删除整条数据)
del request.session['key'](删除某键及对应的值)
request.session.set_expiry(value)(设置有限期)
value是一个整数,session将在value秒没有活动后过期。
value为0,用户session的Cookie将在用户的浏览器关闭时过期。
value为None,那么session有效期将采用系统默认值,默认为两周,可以通过在settings.py中设置SESSION_COOKIE_AGE来设置全局默认值。
类视图与中间件
类视图引入
from django.views.generic import View
class RegisterView(View):
"""类视图:处理注册"""
def get(self, request):
"""处理GET请求,返回注册页面"""
return render(request, 'register.html')
def post(self, request):
"""处理POST请求,实现注册逻辑"""
return HttpResponse('这里实现注册逻辑')
类视图的好处:
代码可读性好
类视图相对于函数视图有更高的复用性, 如果其他地方需要用到某个类视图的某个特定逻辑,直接继承该类视图即可
类视图使用
定义类视图需要继承自Django提供的父类View,可使用from django.views.generic import View或者from django.views.generic.base import View 导入
配置路由时,使用类视图的as_view()方法来添加。
urlpatterns = [
# 视图函数:注册
# url(r'^register/$', views.register, name='register'),
# 类视图:注册
url(r'^register/$', views.RegisterView.as_view(), name='register'),
]
类视图原理
@classonlymethod
def as_view(cls, **initkwargs):
"""
Main entry point for a request-response process.
"""
...省略代码...
def view(request, *args, **kwargs):
self = cls(**initkwargs)
if hasattr(self, 'get') and not hasattr(self, 'head'):
self.head = self.get
self.request = request
self.args = args
self.kwargs = kwargs
# 调用dispatch方法,按照不同请求方式调用不同请求方法
return self.dispatch(request, *args, **kwargs)
...省略代码...
# 返回真正的函数视图
return view
def dispatch(self, request, *args, **kwargs):
# Try to dispatch to the right method; if a method doesn't exist,
# defer to the error handler. Also defer to the error handler if the
# request method isn't on the approved list.
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
return handler(request, *args, **kwargs)
类视图使用装饰器
method_decorator()作用:把普通装饰器转换成类方法装饰器-----装饰器的参数跟类的参数一一对应
装饰器
def my_decorator(func):
def wrapper(request, *args, **kwargs):
print('自定义装饰器被调用了1')
print('请求路径%s' % request.path)
return func(request, *args, **kwargs)
return wrapper
在路径中添加装饰器*
定义装饰器,在URL中为请求方式添加装饰器
url(r'^demo/$',views.my_decorator(Demoview.as_view()))
class DemoView(View):
def get(self, request):
print('get方法')
return HttpResponse('ok1')
def post(self, request):
print('post方法')
return HttpResponse('ok1')
为全部请求方法添加装饰器
在类上加装饰器,为全部请求方式添加装饰器
@method_decorator(my_decorator,name='dispatch')
class DemoView(View):
def get(self, request):
print('get方法')
return HttpResponse('ok1')
def post(self, request):
print('post方法')
return HttpResponse('ok1')
重写dispatch 方法,给方法进行装饰
class DemoView(View):
@method_decorator(my_decorator)
def dispatch(self,request,*args,**kwargs)
return super().dispatch(request,*args,**kwargs)
def get(self, request):
print('get方法')
return HttpResponse('ok1')
def post(self, request):
print('post方法')
return HttpResponse('ok1')
为特定请求方法添加装饰器
在类上加装饰器给get方法进行装饰
@method_decorator(my_decorator,name='get')
class DemoView(View):
def get(self, request):
print('get方法')
return HttpResponse('ok1')
def post(self, request):
print('post方法')
return HttpResponse('ok1')
在get或者post方式上装饰器,给get或者post方式进行装饰
class DemoView(View):
@method_decorator(my_decorator) # 为get方法添加了装饰器
def get(self, request):
print('get方法')
return HttpResponse('ok')
@method_decorator(my_decorator) # 为post方法添加了装饰器
def post(self, request):
print('post方法')
return HttpResponse('ok')
直接写类方法装饰器
def my_decorator1(func):
def wrapper(self,request,*args,**kwargs):
print('自定义装饰器被调用了')
print('my_decorator1')
return func(self,request,*args,**kwargs)
return wrapper
class DemoView(View):
@my_decorator1
def get(self, request):
print('get方法')
return HttpResponse('ok1')
@my_decorator1
def post(self, request):
print('post方法')
return HttpResponse('ok1')
类视图Mixin扩展类
class BaseViewMixin(object):
@classmethod
def as_view(cls, *args,**kwargs):
view=super().as_view(*args,**kwargs)
view=my_decorator(view)
return view
class BaseViewMixin2(object):
@classmethod
def as_view(cls, *args, **kwargs):
view = super().as_view(*args, **kwargs)
view = my_decorator2(view)
return view
class DemoView(BaseViewMixin,BaseViewMixin2,View):
def get(self,request):
return HttpResponse('get page')
def post(self,request):
return HttpResponse('post page')
执行顺序:BaseViewMixin---->BaseViewMixin2---->View
装饰顺序:BaseViewMixin2---->BaseViewMixin
mro方法解析顺序(多继承),是python中用于处理二义性问题的算法
中间件
Django运行在调试模式下,中间件init部分有可能被调用两次。
中间件说明
中间件---->钩子程序
请求之前---->前置钩子
请求之后—>后置钩子
多个中间件的执行顺序:
初始化运行:从下至上
视图函数请求前:从上至下
视图函数请求后:从下至上
定义两个中间件
def my_middleware(get_response):
print('init 被调用')
def middleware(request):
print('before request 被调用')
response = get_response(request)
print('after response 被调用')
return response
return middleware
def my_middleware2(get_response):
print('init2 被调用')
def middleware(request):
print('before request 2 被调用')
response = get_response(request)
print('after response 2 被调用')
return response
return middleware
注册添加两个中间件
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
# 'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'users.middleware.my_middleware', # 添加
'users.middleware.my_middleware2', # 添加
]