慕课DJANGO配置

重写内置的错误处理视图

在项目urls.py中添加配置

handler500 = "app01.views.page_500"

handler404 = "app01.views.page_404"

handler403 = "app01.views.page_403"

在项目视图中如下填写

from django.core.exceptions import PermissionDenied

def test(request):

    # raise ValueError

    raise PermissionDenied

    return HttpResponse('ok')

def page_500(request):

    return HttpResponse('500')

def page_404(request):

    return HttpResponse('404')

def page_403(request):

    return HttpResponse('403')

切换到生产模式DEBUG=False

STATIC处理静态文件

在项目settings.py中添加配置

STATIC_URL = '/static/'

STATICFILES_DIRS = [

    os.path.join(BASE_DIR, "static"),

]

在项目settings.py中添加配置

MEDIA_URL='/media/'

MEDIA_ROOT=os.path.join(BASE_DIR,'medias')

在项目urls中添加配置

from django.views.static import serve

from django.conf import settings

urlpatterns += [

    url(r'^medias/(?P<path>.*)$',serve,{

        'document_root':settings.MEDIA_ROOT,

    }),

]

请求对象HttpRequest

请求头信息META

REMOTE_ADDR------请求的IP地址

HTTP_USER_AGENT-----用户请求终端信息

常见的Content-Type

text/html——超文本标记语言文本(HTML)

text/plain——普通文本  text/xml——XML文档

image/png、image/jpeg、image/gif——图片或图形

application/json ——json数据类型

响应对象

HttpResponse

HttpResponseRedirect

JsonResponse——响应json

FileResponse——响应文件

HttpResponse

status查看HTTP响应状态码

status_code查看HTTP响应状态码

content_type设置响应的类型

write()写入响应内容

def content(request):

    dic = {

        'username':'jamie',

    }

    # return HttpResponse('ok',content_type='text/plain')

    import json

    ret = json.dumps(dic)

    # return HttpResponse(ret,content_type='application/json')

    return JsonResponse(dic)

def status(request):

    # 改变响应状态码

    ret = HttpResponse('status_code', status=404)

    # 重新设置HTTP的状态码

    ret.status_code = 200

    # 打印HTTPS状态码

    print(ret.status_code)

    # 写入响应内容

    ret.write('多写入响应内容')

    return ret

def image(request):

    # pring image

    import os

    from django.conf import settings

    try:

        file_name = os.path.join(settings.BASE_DIR,'medias/images/1111.png')

        f = open(file_name, 'rb')

    except Exception as e:

        print(e)

    return FileResponse(f,content_type='image/png')

    # application/vnd.ms-excel 这样可以导出EXCEL

使用CLASS重写视图

url(r'^class/',views.classview.as_view(), name='class'),

from django.views.generic import TemplateView

class classview(TemplateView):

    '''class'''

    template_name = 'class.html'

渲染机制

思考:没有模板引擎怎样在浏览器展示HTML

1. 从磁盘读取html字符串

2. 将满足特定规则的内容进行替换 3. 发送给浏览器展示

步骤一:从磁盘读取模板文件(get_template)

步骤二:选择合适的模板引擎(select_template)

步骤三:将制定内容对模板进行渲染(render)

步骤四:发送给浏览器显示

配置选项

APP_DIRS——决定模板引擎是否应该进入每个已安装 的应用中查找模板

每种模板引擎后端都定义了一个惯用的名称作为应用内部存放 模板的子目录名称

DTL——templates目录

Jinja2——jinja2目录

OPTIONS——其他选项配置

同时支持俩种引擎模板

TEMPLATES = [

    {

        'BACKEND': 'django.template.backends.django.DjangoTemplates',

        'DIRS': [os.path.join(BASE_DIR, 'templates')],

        'APP_DIRS': True,

        'OPTIONS': {

            'context_processors': [

                'django.template.context_processors.debug',

                'django.template.context_processors.request',

                'django.contrib.auth.context_processors.auth',

                'django.contrib.messages.context_processors.messages',

                'mine.context_processors.const',

            ],

        },

    },

    {

        'BACKEND': 'django.template.backends.jinja2.Jinja2',

        'DIRS': [os.path.join(BASE_DIR, 'jiaja2')],

        'APP_DIRS': True,

        'OPTIONS': {

            'context_processors': [

                'django.template.context_processors.debug',

                'django.template.context_processors.request',

                'django.contrib.auth.context_processors.auth',

                'django.contrib.messages.context_processors.messages',

            ],

        },

    },

]

渲染静态图片

img_url = "/medias/images/1111.png"

return render(request,'image1.html',{'img_url':img_url})

<img src="{{ img_url }}" alt="403报错图片">

模板标签的使用

循环控制

{% for item in data_list %} <li>内容</li>

{% endfor %}

条件控制

{% if condition_a %} 满足了A条件

{% elif condition_b %} 满足了B条件

{% else %} 都不满足

{% endif %}

注释

添加注释

{# 注释内容 #}

与HTML注释的区别

<!-- 注释内容 -->

重复循环

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

    <style>

        .row1 {

            background-color: pink;

        }

        .row2 {

            background-color: red;

        }

        .row3 {

            background-color: gray;

        }

    </style>

</head>

<body>

<ul>

    {% for foo in tag reversed%}

        <li class="{% cycle 'row1' 'row2' 'row3' %}">{{ forloop.counter }}{{ foo }}</li>

    {% empty %}

        <li>列表要是空就走这里</li>

    {% endfor %}

</ul>

</body>

</html>

过滤器：对变量进行特殊处理后再渲染?

过滤器语法

{{ value|filter_name: params }}

使用过滤器将字母大写

{{ value|upper}}

内置过滤器

def test_tp_filter(request):

    import math

    pi = math.pi

    html = '<h1>lalalalalalalalala</h1>'

    import datetime

    time = datetime.datetime.now()

    user_info = {

        'username': 'jamie',

        'age': None,

        'sex': False,

        'pi': pi,

        'html': html,

        'time': time

    }

    return render(request, 'filter.html', {'userinfo': user_info})

日期对象格式化

{{ value|date:"D d M Y" }}

默认值显示

{{ value|default:"" }} # 为none时候显示我

{{ value|default_if_none:“无" }} # 为空false显示我

数字四舍五入显示

{{ value | floatformat:3 }}

富文本内容转义显示

{{ value|safe }}

字符串截取

{{ value|truncatechars:9 }}

{{ value|truncatechars_html:9 }} # 不算Html字符

{{ value|truncatewords:2 }}

自定义过滤器

步骤一:在app目录下新建包templatetags

polls/

    __init__.py

    models.py

    templatetags/

        __init__.py

        poll_extras.py

    views.py

步骤二:实现过滤器poll_filter.py

from django import template

register = template.Library()

def warning(value):

    """ 将第一个字符变红 """

    return '<span class="red">' + value[0] +'</span>'+ value[1:]

register.filter('warning', warning)

步骤三:在模板中使用过滤器

{% load poll_filter %}

{{ value| warning|safe }}

切记:添加自定义过滤器后记得重启开发服务器

模板抽象和继承

步骤一:将可变的部分圈出来(base.html)

{% block sidebar %}

    <!--菜单栏的内容 -->

{% endblock %}

步骤二:继承父模板

{% extends "base.html" %}

步骤三:填充新的内容(index.html)

{% extends "base.html" %}

{% block sidebar %}

    <!-- 新的菜单栏的内容 -->

{% endblock %}

步骤四:复用父模板的内容(可选)

{% extends "base.html" %} {% block sidebar %}

    {{ supper }}

    <!-- 新的菜单栏的内容 -->

{% endblock %}

在模板中添加公共部分

步骤一:将可变的部分拆出来(footer.html)

<footer>

这是页脚公共的部分

</footer>

步骤二:将拆出来的部分包进来(index.html)

{% extends "base.html" %}

{% block content %}

    <!– 页面主要内容区域-->

    {# 公用的footer #}

    {% include "footer.html" %}

{% endblock %}

Django工具及管理

常用的内置命令(mine是一个app应用)

检查djangoORM模型

python manage.py check

生成同步原语

python manage.py makemigrations

模型同步

python manage.py migrate

收集依赖中的静态文件

python manage.py collectstatic

django控制台

python manage.py shell

清除过期会话

python manage.py clearsessions

自定义Django命令行工具

第一步:创建指定的目录及文件结构

mine/

    __init__.py

    models.py

    management/

        __init__.py

        commands/

            __init__.py

            update.py

    urls.py

        views.py

第二步:实现自定义命令

实现django.core.management.base.BaseCommand的子类

添加命令参数add_arguments

处理命令逻辑handle

显示处理过程(self.stdout.write/self.stderr.write)

"""

update.py

更新订单状态 

订单超过半小时不支付，取消订单，释放库存

"""

from django.core.management.base import BaseCommand

class Command(BaseCommand):

    help = """

        更新订单状态

        回收订单

    """

    def add_arguments(self, parser):

        """

        添加命令的参数

        argparse

        https://docs.python.org/3/library/argparse.html

        1. 回收所有超时未支付的订单

        python manage.py update --all

        2. 指定回收某一个订单

        python manage.py update --one 20001

        :param parser:

        :return:

        """

        # 添加参数 dest匹配参数，交给handel处理，

        parser.add_argument(

            '--all',

            # 不需要加参数的意思，但是还没确定

            action='store_true',

            dest='all',

            default=False,

            help='回收所有超时未支付的订单'

        )

        parser.add_argument(

            '--one',

            action='store',

            dest='one',

            default=False,

            help='指定回收某一个订单'

        )

    def handle(self, *args, **options):

        if options['all']:

            self.stdout.write('开始回收订单')

            # 逻辑处理

            self.stdout.write('-------')

            self.stdout.write('处理完成')

        elif options['one']:

            self.stdout.write('开始回收订单{}'.format(options['one']))

        else:

            self.stderr.write('指令异常')

Django中间件的开发和使用

上下文处理器，为模板添加全局变量，utils是创建在项目里面的公用脚本目录

渲染上下文Context

请求上下文RequestContext

连接views(视图)和templates(模板)

场景举例: 在每个页面都显示IP地址，多个页面展示购物车信息

TEMPLATES = [

    {

        'BACKEND': 'django.template.backends.django.DjangoTemplates',

        'DIRS': [os.path.join(BASE_DIR, 'templates')],

        'APP_DIRS': True,

        'OPTIONS': {

            'context_processors': [

                'django.template.context_processors.debug',

                'django.template.context_processors.request',

                'django.contrib.auth.context_processors.auth',

                'django.contrib.messages.context_processors.messages',

                'mine.context_processors.const', # 这里定义上下文的路径

            ],

        },

    },

]

from utils import constants

def const(request):

    addr = '湖南'

    return {

        'constants': constants.UserList,

        'addr':addr,

    }

# Utils是个创建在项目下的目录

# !/usr/bin/env python

# _*_ coding:utf-8 _*_

# Author: Jamie

UserList = ['吊哥','傻逼']

模板调用

{% for foo in constants %}

    {{ foo }}

{% endfor %}

{{ addr }}

中间件，过滤请求，拦截请求

场景1:用户非法请求拦截

添加IP地址黑名单，在名单内的用户限制访问

场景2:模拟用户登录

实现简单的用户登录中间件

步骤一:实现中间件，处理业务逻辑

    方式1:函数式自定义中间件

    方式2: OOP(面向对象)自定义中间件

步骤二:激活中间件，添加到setting.py配置

'''

保存在Utils目录里面，公共方法，ip_middleware.py

'''

from django.http import HttpResponse

from weibo.models import WeiboUser

def ip_middleware(get_response):

    def middleware(request):

        # 请求到达前的业务逻辑

        print('请求到达前的业务逻辑')

        # 请求不满足业务规则：IP被限制

        ip = request.META.get('REMOTE_ADDR', None)

        ip_disable_list = [

            '127.0.0.1'

        ]

        print(ip)

        # for ip_dis in ip_disable_list:

        #     if ip_dis == ip:

        if ip in ip_disable_list:

                return HttpResponse('not allowed', status=403)

        reponse = get_response(request)

        # 在视图函数调用之后的业务逻辑

        print('在视图函数调用之后的业务逻辑')

        return reponse

    return middleware

class MallAuthMiddleware(object):

    """ 自定义的登录验证中间件 """

    def __init__(self, get_response):

        self.get_response = get_response

    def __call__(self, request, *args, **kwargs):

        print('MallAuthMiddleware请求到达前的业务逻辑')

        # 请求不满足业务规则：IP被限制

        user_id = request.session.get('user_id', None)

        print('middle:%s' %user_id)

        if user_id:

            user = WeiboUser.users.get(pk=user_id)

        else:

            user = None

        request.my_user = user

        print('--------------', user)

        reponse = self.get_response(request)

        # 在视图函数调用之后的业务逻辑

        print('MallAuthMiddleware在视图函数调用之后的业务逻辑')

        return reponse

MIDDLEWARE = [

    # 'debug_toolbar.middleware.DebugToolbarMiddleware',

    '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',

    # 'utils.middleware.ip_middleware',

    'utils.middleware.MallAuthMiddleware'

]

另一篇实例 https://www.cnblogs.com/jokerbj/p/8173820.html

Django扩展

DRF(Django REST Framework)REST接口框架

django-cms 内容管理系统

django-debug-toolbar 调试工具 pypi.org搜索，要对应JDANGO版本

django-channels Websocket通信

表单重复提交

支付时，快速点击，多次提交会有什么问题? csfttoken

BUG邮件通知

1.发送文字邮件

2.发送HTML邮件

3.发送带附件的邮件

4.发送多个邮件

5.打破连接限制，连接复用

第一步:邮件配置

第二步:准备邮件内容

第三步:发送邮件

'''

SETTINGS.PY

'''

# 邮件发送配置

EMAIL_HOST = 'smtp.qq.com'

EMAIL_HOST_USER = 'navcat@foxmail.com'

EMAIL_HOST_PASSWORD = 'vgppwryinupwbfgb'

# 自己发送,from django.core.mail import send_mail  send_mail(邮件主题，邮件内容，发件人，发送给谁，是个列表)

# 触发异常就会给ADMINS发邮件，DEBUG = False

SERVER_EMAIL = 'navcat@foxmail.com'

ADMINS = [('admin', 'navcat@foxmail.com')]

https://docs.djangoproject.com/en/1.11/topics/email/

日志记录配置

logging的四个部分

1.Loggers——日志记录入口

2.Handlers——决定处理logger中消息的方式

3.Filters——对日志进行条件控制

4.Formatters——日志记录的文本顺序(格式）

Logger的级别

DEBUG:用于调试目的的底层系统信息

INFO:普通的系统信息

WARNING:警告，较小的问题，不影响执行顺序

ERROR:错误，较大的问题  CRITICAL:严重，致命的问题

'''

SETTINGS.PY

'''

# 日志的配置

LOGGING = {

    'version': 1,

    'disable_existing_loggers': False,

    'formatters': {

        'verbose': {

            'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'

        },

        'simple': {

            'format': '%(levelname)s %(message)s'

        },

    },

    'handlers': {

        'sql_log_file': {

            'level': 'DEBUG',

            'class': 'logging.FileHandler',

            'filename': os.path.join(BASE_DIR, 'log/sql.log'),

        },

        'log_index_file': {

            'level': 'DEBUG',

            'class': 'logging.FileHandler',

            'formatter': 'verbose',

            'filename': os.path.join(BASE_DIR, 'log/index.log'),

        },

        'console': {

            'level': 'DEBUG',

            'class': 'logging.StreamHandler',

            # 'formatter': 'simple'

        },

        'mail_admins': {

            'level': 'ERROR',

            'class': 'django.utils.log.AdminEmailHandler',

            # 'filters': ['special']

        }

    },

    'loggers': {

        'django.db.backends': {

            'handlers': ['sql_log_file',],

            'level': 'DEBUG',

            'propagate': True,

        },

        'index': {

            'handlers': ['log_index_file', 'console'],

            'level': 'DEBUG',

        }

    },

}

上传图片方式

# !/usr/bin/env python

# _*_ coding:utf-8 _*_

# Author: Jamie

import re

from django import forms

from weibo import models

class UserLoginForm(forms.Form):

    username = forms.CharField(label='用户名',max_length=64)

    password = forms.CharField(label='密码',max_length=64,widget=forms.PasswordInput)

    verify_code = forms.CharField(label='验证码',max_length=64)

    def clean_username(self):

        username = self.cleaned_data['username']

        pattern = r'^0{0,1}1[0-9]{10}$'

        if not re.search(pattern,username):

            raise forms.ValidationError('请输入正确的手机号码')

        return username

    def clean(self):

        cleand_data = super().clean()

        username = cleand_data.get('username',None)

        password = cleand_data.get('password',None)

        if username and password:

            user_list = models.WeiboUser.users.filter(username=username)

            if user_list.count() == 0:

                raise forms.ValidationError('用户名不存在')

            if not user_list.filter(password=password).exists*():

                raise forms.ValidationError('密码错误')

        return cleand_data

class UserForm(forms.ModelForm):

    class Meta:

        model = models.WeiboUser

        fields = ['username','password']

        widgets = {

            'password':forms.PasswordInput(attrs={

                'class':'text-error',

            })

        }

        labels = {

            'username':'手机号码',

        }

        error_messages = {

            'username':{

                'required':'请输入手机号码',

                'max_length':'最长不超过32',

            }

        }

class AvatarUploadForm(forms.Form):

    remark = forms.CharField(label='备注',max_length=32)

    touxiang = forms.FileField(label='头像')

class WeiboImageForm(forms.ModelForm):

    content = forms.CharField(label='微博内容',max_length=256,widget=forms.Textarea(attrs={'placeholder':'请输入微博内容'}))

    class Meta:

        model = models.WeiboImage

        fields = ['image']

    def save(self,user,commit=False):

        obj = super().save(commit)

        data = self.cleaned_data

        content = self.cleaned_data['content']

        #1 创建微博记录

        weibo = models.Weibo.objects.create(user=user,content=content)

        #2 修改微博关联关系

        obj.weibo = weibo

        obj.save()

        return obj

FORMS

def upload_one(request):

    if request.method == 'POST':

        file = request.FILES.get('touxiang',None)

        import os

        from dalaohu import settings

        filename = os.path.join(settings.MEDIA_ROOT,'touxiang')

        with open(filename,'wb+') as f:

            for i in file.chunks():

                f.write(i)

            print('上传陈功了')

    return render(request,'upload_one.html')

def upload_two(request):

    if request.method == 'POST':

        form = forms.AvatarUploadForm(request.POST,request.FILES)

        if form.is_valid():

            file = request.FILES.get('touxiang', None)

            import os

            from dalaohu import settings

            filename = os.path.join(settings.MEDIA_ROOT, 'touxiang1')

            with open(filename, 'wb+') as f:

                for i in file.chunks():

                    f.write(i)

                print('上传陈功了')

    else:

        form = forms.AvatarUploadForm()

    return render(request,'upload_two.html',{'form':form})

def upload_three(request):

    if request.method == 'POST':

        user = WeiboUser.users.get(pk=1)

        form = forms.WeiboImageForm(request.POST,request.FILES)

        if form.is_valid():

            obj = form.save(user,False)

            print('保存陈功了',obj.pk)

    else:

        form = forms.WeiboImageForm()

    return render(request,'upload_three.html',{

        'form':form

    })

VIEWS

自带登录验证

import re

from django import forms

from django.forms import widgets

from django.forms import fields

from django.contrib.auth import authenticate, login

from django.contrib.auth.models import User

from utils.verify import VerifyCode

class UserLoginForm(forms.Form):

    """ 用户登录表单 """

    username = forms.CharField(label='用户名', max_length=64,widget=widgets.TextInput(attrs={'class':'form-control','placeholder':'请输入用户名'}),

                               error_messages={

                                   'required': '请输入用户名',

                               }

                               )

    password = forms.CharField(label='密码', max_length=64,widget=widgets.PasswordInput(attrs={'class':'form-control','placeholder':'请输入密码'}),

                               error_messages={

                                   'required': '请输入密码',

                               })

    verify_code = forms.CharField(label='验证码', max_length=4,widget=widgets.TextInput(attrs={'class':'form-control','placeholder':'验证码'}),

                               error_messages={

                                   'required': '请输入验证码',

                               })

    def __init__(self, request, *args, **kwargs):

        super().__init__(*args, **kwargs)

        self.request = request

    # def clean_username(self):

    #     """ 验证用户名 hook 钩子函数"""

    #     username = self.cleaned_data['username']

    #     print(username)

    #     # 判断用户名是否为手机号码

    #     pattern = r'^0{0,1}1[0-9]{10}$'

    #     if not re.search(pattern, username):

    #         raise forms.ValidationError('请输入正确的手机号码')

    #     return username

    def clean_verify_code(self):

        """ 验证用户输入的验证码是否正确 """

        verify_code = self.cleaned_data['verify_code']

        if not verify_code:

            raise forms.ValidationError('请输入验证码')

        client = VerifyCode(self.request)

        if not client.validate_code(verify_code):

            raise forms.ValidationError('验证码不正确')

        return verify_code

    def clean(self):

        cleaned_data = super().clean()

        print(cleaned_data)

        # 获取用户名和密码 ，不建议使用[]的方式

        # username = cleaned_data['username']

        username = cleaned_data.get('username', None)

        password = cleaned_data.get('password', None)

        if username and password:

            # 查询用户名和密码匹配的用户

            user_list = User.objects.filter(username=username)

            if user_list.count() == 0:

                raise forms.ValidationError('用户名不存在')

            # # 验证密码是否正确

            # if not user_list.filter(password=password).exists():

            #     raise forms.ValidationError('密码错误')

            if not authenticate(username=username, password=password):

                raise forms.ValidationError('密码错误')

        return cleaned_data

class UserRegistForm(forms.Form):

    """ 用户注册表单 """

    username = forms.CharField(label='用户名', max_length=64)

    nickname = forms.CharField(label='昵称', max_length=64)

    password = forms.CharField(label='密码', max_length=64, widget=forms.PasswordInput)

    password_repeat = forms.CharField(label='重复密码', max_length=64, widget=forms.PasswordInput)

    verify_code = forms.CharField(label='验证码', max_length=4)

    def __init__(self, request, *args, **kwargs):

        super().__init__(*args, **kwargs)

        self.request = request

    def clean_username(self):

        """ 验证用户名是否已经被注册 """

        data = self.cleaned_data['username']

        if User.objects.filter(username=data).exists():

            raise forms.ValidationError('用户名已存在')

        return data

    def clean_verify_code(self):

        """ 验证用户输入的验证码是否正确 """

        verify_code = self.cleaned_data['verify_code']

        if not verify_code:

            raise forms.ValidationError('请输入验证码')

        client = VerifyCode(self.request)

        if not client.validate_code(verify_code):

            raise forms.ValidationError('您输入的验证码不正确')

        return verify_code

    def clean(self):

        cleaned_data = super().clean()

        password = cleaned_data.get('password', None)

        password_repeat = cleaned_data.get('password_repeat', None)

        if password and password_repeat:

            if password != password_repeat:

                raise forms.ValidationError('两次密码输入不一致')

        return cleaned_data

    def register(self):

        """ 注册方法 """

        data = self.cleaned_data

        # 1. 创建用户

        User.objects.create_user(username=data['username'],

                                 password=data['password'],

                                 level=0,

                                 nickname='昵称')

        # 2. 自动登录

        user = authenticate(username=data['username'],

                     password=data['password'])

        login(self.request, user)

        return user