Django学习笔记

2020-03-12

本文阅读量：

从大三上开始接触Django到现在差不多半年时间，做过一些大大小小的项目，个人认为Django网站框架还是比较容易上手并且功能十分强大！

以下内容是我的学习笔记：

Django项目创建与框架

# 创建Django项目
django-admin startproject project

# 创建Django-App
python manage.py startapp app1

# 新建static文件，用于存放静态文件

# 配置setting.py
1. ALLOWED_HOSTS添加‘*’，即ALLOWED_HOSTS =[‘*’,] 
2. 添加静态文件路径，STATICFILES_DIRS=(os.path.join(BASE_DIR),’static’)
3. 可修改默认语言和时区
LANGUAGE_CODE = 'zh-Hans'
TIME_ZONE = 'Asia/Shanghai'

# 创建超级用户，访问http://127.0.0.1:8000/admin/
python manage.py createsuperuser

# 改动model.py后执行，生成DDL语句
python manger.py makemigrations
# 将该改动作用到数据库文件，执行DDL语句
python manager.py migrate

project

app01
- admin.py Django自带后台管理相关配置
- models.py 写类、根据类创建数据库表
- tests.py 单元测试
- views.py 业务处理
project
- init.py
- setting.py
- urls.py
- views.py
- wsgi.py
templates
- .html
static

Django基础知识结构

Django

一、路由系统

Http请求：path -> 视图（模板+数据）

一对一：path -> 函数

path('login/', views.login)

# /login/ -> def login(request)

正则匹配：re_path -> 函数

# 正则表达式：^xxx$  起始符：^ 终止符：$

re_path(r'^index(\w+)$/', index)

# /index123abcd/ -> def index(request)

# 参数接收
# 1.顺序接收
# /add-user/(\d+)/ -> def add_user(request,a1)
# /add-user/(\d+)/(\d+)/ -> def add_user(request,a1,a2) 
# 2.指定接收
# /add-user/(?P\<a2\>\d+)/(?P\<a1\>\d+)/ -> def add_user(request,a1,a2)

url命名：

# urls.py
path('index/', views.index, name='n1'),
re_path(r'^index/(?P\<a1\>\w+).html$', views.index,name='n2'),

# views.py 反向生成路径：
from django.urls import reverse
def index(request):
    my_path1 = reverse('n1')
    my_path2 = reverse('n2', kwargs={'a1':a1})

# .html
{% url "n1" %}

路由分发：

# 从项目路由urls.py分发至app路由中
path('app01/',include('app01.urls'))

# app01.urls.py
path('index.html',views.index),

伪静态：路由最后为.html后缀；好处：更好的被搜索引擎收录（提高page_rank）

re_path(r'^edit/(\w+).html$',views.edit)

二、视图函数

FBV（function base views） 在视图里使用函数处理请求。

#urls.py

from django.urls import path
from app01 import views

path('index.html', views.index),

# views.py

from django.shortcuts import HttpResponse

def index(request):
    return HttpResponse('hey')

CBV（class base views） 在视图里使用类处理请求。

#urls.py

from django.urls import path
from app01 import views

path('index.html', views.Index.as_view()),

# views.py

from django.shortcuts import HttpResponse
from django.views import View

class Index(View): 
    def get(self, request):         # 约定用于查询操作
        return HttpResponse('get')
    def post(self, request):        # 约定用于创建操作
        return HttpResponse('post')
    def put(self, request):         # 约定用于更新操作
        return HttpResponse('put')
    def delete(self, request):      # 约定用于删除操作
        return HttpResponse('delete')
    
# form表单提交只有get和post方式
# ajax中有其他方法：'get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'

特殊CBV：

from django.views import View
from django.utils.decorators import method_decorator
@method_decorator(csrf_protect, name='post')  # csrf只能类上加
class Foo(View):
    def get(self, request):
        pass

    def post(self, request):
        pass

CBV中添加装饰器：

def wrapper(func):
    def inner(*args, **kwargs):
        return func(*args, **kwargs)
    return inner()

# 指定方法上加装饰器
class Foo(View):
    def get(self, request):
        pass    
    
    @method_decorator(wrapper)
    def post(self, request): 
        pass
    
# 在类上加装饰器
@method_decorator(wrapper, name='dispatch')
class Foo(View):
    def get(self, request):
        pass
    def post(self, request):
        pass

三、数据库操作

（详见上一篇博客）

四、模板引擎

1. 母版：页面继承

<!- base.html ->

<!DOCTYPE html>
<html lang="en-US">
<head>
    <title>{% block title %}{% endblock %}</title>
    {% block css_content %}{% endblock %}
</head>
<body>
    {% block main_content %}{% endblock %}
	{% block js_content %}{% endblock %}
</body>
</html>

<!- index.html ->

{% extends 'base.html' %}

{% block title %}
    首页
{% endblock %}

{% block css_content %}
	css
{% endblock %}

{% block content %}
    content
{% endblock %}

2. include：小组件

# pub.html
<div>
    <h1>好看的组件</h1>
    <p>标题：</p>
    <p>内容：</p>
</div>

# test.html
{% include 'pub.html' %}

3. 函数：自动执行

自定义函数步骤：

a、在app中创建templatetags模块
b、创建任意 .py 文件，如：xx.py
c、在使用自定义simple_tag的html文件中导入之前创建的 xx.py 文件名
d、使用simple_tag
e、在settings中配置当前app，不然django无法找到自定义的simple_tag

simple filter：最多两个参数，可以做条件判断

{{ 第一个参数|函数名："第二个参数" }}

simple_tag：无限制

{% 函数名 参数 参数 参数 %}

五、其他

1. xss攻击

慎用safe和mark_safe

非要用，一定要过滤关键字

2. CSRF跨站请求伪造

POST时，需要用户携带随机字符

基本应用：

form表单中添加：

{% csrf_token %}

全站禁用：# ‘django.middleware.csrf.CsrfViewMiddleware’,

局部禁用：

from django.views.decorators.csrf import csrf_exempt

@csrf_exempt
def csrf1(request):
    ...

局部应用：

from django.views.decorators.csrf import csrf_protect

@csrf_protect
def csrf2(request):
    ...

保存在客户端浏览器上的键值对，设置超时时间

发送http请求时，在请求头中携带当前所有可访问的cookie

可以放很多，但是不用敏感信息

签名：obj.set_signed_cookie(‘ticket’,”123”,salt=’abc’)

@xxxx
def index(request)：
    obj=Httpresponse(‘..’)
    obj.set_cookie(…)
    request.COOKIES.get(…)
    obj.set_signed_cookie(…)
    request.get_signed_cookie(…)

4. Session

保存在服务端的数据（本质是键值对）

{
	"fhdkashf":{'id':1,'name':'syx'}
	"eqwrewrwe":{'id':2,'name':'abc'}
}

应用：依赖cookie

作用：保持会话（Web网站）

好处：敏感信息不会直接给客户端

# Session存放位置

# 数据库
SESSION_ENGINE = 'django.contrib.sessions.backends.db'  # 引擎（默认）

# 缓存
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
SESSION_CACHE_ALIAS = 'default'  # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置

# 文件
SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎
SESSION_FILE_PATH = None  # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()

# 缓存+数据库
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎

# cookie
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎

配置文件中：存储位置、超时时间、每次刷新更新时间

requset.session

增删、获取随机字符串、主动设置超时时间

5. 分页

分批获取数据

models.UserInfo.objects.all()[0:10]

models.UserInfo.objects.all()[10:20]

Django自带（适合仅用上一页和下一页）

from django.core.paginator import Paginator, Page, EmptyPage,PageNotAnInteger
current_page = request.GET.get('page')
# current_page = int(current_page)
user_list = models.UserInfo.objects.all()
paginator = Paginator(user_list, 10)
# per_page: 每页显示条目数量
# count:    数据总个数
# num_pages:总页数
# page_range:总页数的索引范围，如: (1,10),(1,200)
# page:     page对象
try: 
    posts = paginator.page(current_page)
except PageNotAnInteger as e:
    posts = paginator.page(1)
except EmptyPage as e:
    posts = paginator.page(1)
# has_next              是否有下一页
# next_page_number      下一页页码
# has_previous          是否有上一页
# previous_page_number  上一页页码
# object_list           分页之后的数据列表
# number                当前页
# paginator             paginator对象
return render(request, 'index.html', {'posts': posts})

<ul>
    {% for row in posts.object_list %}
    <li>{{ row.name }}</li> 
    {% endfor %}
</ul>
<div>   
    {% if posts.has_previous %}  
        <a href="/index?page={{ posts.previous_page_number }}">上一页</a>  
    {% endif %}   
    {% for num in posts.paginator.page_range %}    
        <a href="/index?page={{ num }}">{{ num }}</a>  
    {% endfor %}   
    {% if posts.has_next %}    
        <a href="/index?page={{ posts.next_page_number }}">下一页</a>  
    {% endif %}
</div>

6. Ajax提交数据时携带csrf的两种方式

① 放置在data中

<form method="post" action="csrf1">
    {% csrf_token %}
    <input id="user" type="text" name="user">
    <input type="submit" value="提交">
    <a onclick="submitForm();">Ajax提交</a>
</form>

<script src="static/jquery-1.10.2.js"></script>
<script>
    function submitForm() {
        var csrf = $('input[name="csrfmiddlewaretoken"]').val();
        var user = $('#user');
        $.ajax({   
            url:'/csrf1', 
            type:'POST',    
            data:{ 
                "user":user, 
                "csrfmiddlewaretoken":csrf,
            },
            success:function (arg) {
                console.log(arg); 
            }
        }) 
    }
</script>

② 放置在请求头中

<script src="static/jquery-1.10.2.js"></script>
<script src="static/jquery.cookie.js"></script>
<script> 
    function submitForm() {  
        var token=$.cookie('csrftoken');
        var user = $('#user').val();   
        $.ajax({        
            url:'/csrf1', 
            type:'POST',   
            headers:{'X-CSRFToken':token},     
            data:{         
                "user":user,    
            },          
            success:function (arg) {   
                console.log(arg); 
            }      
        })   
    }
</script>

7. 中间件

Django请求生命周期：中间件 -> url -> 视图

Web框架本质：socket

wsgiref+Django //性能低

uwsgi+Django //一定并发

WSGI协议：
    'cgi': CGIServer,
    'flup': FlupFCGIServer,
    'wsgiref': WSGIRefServer,       # Django默认
    'waitress': WaitressServer,
    'cherrypy': CherryPyServer,
    'paste': PasteServer,
    'fapws3': FapwsServer,
    'tornado': TornadoServer,
    'gae': AppEngineServer,
    'twisted': TwistedServer,
    'diesel': DieselServer,
    'meinheld': MeinheldServer,
    'gunicorn': GunicornServer,
    'eventlet': EventletServer,
    'gevent': GeventServer,
    'geventSocketIO':GeventSocketIOServer,
    'rocket': RocketServer,
    'bjoern' : BjoernServer,
    'auto': AutoServer,

Web框架本质

import socket

def main():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('localhost',8000))
    sock.listen(5)
    
    while True:
        client, address = sock.accept()
        v = client.recv(1024)
        # 自己解析：各种split('\r\n...')
        
        # 请求相关
        Django
        # 产出字符串
        
        clinet.send(产出字符串)
        client.close()
        
if __name__ == '__main__':
    main()

python标准库提供的独立WSGI服务器称为wsgiref

# WSGI+Django
from wsgiref.simple_server import make_server

def RunServer(environ, start_response):
    
    '''
    Django框架开始
    中间件
    路由系统
    视图函数
    。。。
    '''
    
    start_response('200 OK', [('Content-Type', 'text/html')])
    return [bytes('<h1>Hello, web!</h1>', encoding='utf-8'), ]

if __name__ == '__main__':
    httpd = make_server('127.0.0.1', 8000, RunServer)
    print("Serving HTTP on port 8000...")
    httpd.serve_forever()

Django_request

中间件

类：

process_request

process_response(…response)：必须有返回值 return response

process_view(self, request, callback, callback_args, callback_kwargs)

process_exception(self, request, exception)

process_template_response(self,request,response)

注册中间件

middleware

应用：适用于对所有请求或一部分请求做批量处理

8. MVC&MTV

MVC：models(数据库、模型) + views(html模板) + controllers(业务逻辑处理)

MTV：models(数据库、模型) + templates(html模板) + views(业务逻辑处理)

Django -> MTV

from wsgiref.simple_server import make_server

def index():
    return 'index'

def login():
    return 'login'

def routers():
urlpatterns = (
    ('/index/',index),
    ('/login/',login),
)
    return urlpatterns

def RunServer(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    url = environ['PATH_INFO']
    urlpatterns = routers()
    func = None
    for item in urlpatterns:
        if item[0] == url:
            func = item[1]
            break
    if func:
        return func()
    else:
        return '404 not found'

if __name__ == '__main__':
    httpd = make_server('', 8000, RunServer)
    print "Serving HTTP on port 8000..."
    httpd.serve_forever()

9. 自定义出错页面

自带的报错页面比较简洁与单调，可以通过配置达到自定义报错页面的展示。

① 修改settings.py

DEBUG=False
ALLOWED_HOSTS = [‘*’]
TEMPLATES中：‘DIRS’: [os.path.join(BASE_DIR, ‘templates’)]

注：Django设置DEBUG为False时，’django.contrib.staticfiles’会关闭，即Django不会自动搜索静态文件。

② 修改url.py

from app import views

urlpatterns = [
    ...
]

handler404 = views.page_not_found
handler500 = views.server_error

③ 修改views.py

def page_not_found(request, exception):
    return render(request, 'error.html')

def server_error(request):
    return render(request, 'error.html')

④ 添加自定义的报错页面即可