Django form 文件上传 cookie session 分页缓存 csrf admin后台配置 admin密码忘记 django文件上传

一、form应用

django中的Form一般有两种功能：

输入html
验证用户输入

创建项目配置setting就不写了

from django.db import models

# Create your models here.

class Author(models.Model):
    '''
    作者
    '''
    name = models.CharField(max_length=100)
    age = models.IntegerField()

class BookType(models.Model):
    '''
    图书
    '''
    caption = models.CharField(max_length=64)

class Book(models.Model):
    name = models.CharField(max_length=64)
    pages = models.IntegerField()
    price = models.DecimalField(max_digits=10,decimal_places=2)
    pubdate = models.DateField(auto_now=True)

    authors = models.ManyToManyField("Author")
    book_type = models.ForeignKey("BookType")

models.py

1 1.1简单应用form

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>from django</title>
</head>
<body>
    <form method="post" action="/form1/">
    <div>
        <input type="text" name="user" placeholder="用户名" style="border-radius: 4px">
    </div>
    <div>
        <input type="password" name="pwd" placeholder="密码" style="border-radius: 4px">
    </div>
    <div>
        <input type="submit" value="提交" style="border-radius: 4px">

    </div>
    </form>
</body>
</html>

form1.html

1.2 app下创建form.py文件注意字段是前端的input name值

#!/usr/bin/env python
#_*_coding:utf-8_*_

from django import forms
from app01 import models

class Form1(forms.Form):
    user = forms.CharField(max_length=6) #前端name值input的
    pwd = forms.CharField(max_length=6,min_length=1)

1.3 view.py的验证

　　需要实例化手动写的form模块的FORM类，要将所有request的post数据传入比如 f1 = form.Form(request.POST) 这样前端的html的所有提交的input就会验证

　　返回两种数据

　　1 cleaned_data 提交的正确数据

　　2 errors错误信息

　　注意，如果将这个表单验证的对象传到前端，我们可以不用些input表单了这样就是user的input，这里的form是view。py返回前端的key {{ form.user }}

from django.shortcuts import render,HttpResponse

# Create your views here.


from app01.form import Form1

def form1(request):
    # 我们可以用form对象创建inut标签
    f = Form1()
    print(Form1.user_type_choice)
    if request.method == "POST":
        user = request.POST.get("user",None)
        pwd = request.POST.get("pwd",None)

        # 验证
        f = Form1(request.POST) #将所有数据验证 
        if f.is_valid():
            print(f.cleaned_data) #  提交争取数据f.cleaned_data
        else:
            print(type(f.errors),f.errors)

        return render(request,"account/form1.html",{"error":f.errors,"right":f.cleaned_data,"form":f}) # form 创建保存input的 的数据

    return render(request,"account/form1.html",{"form":f})

View Code

2 form表单的错误提示

2.1

from django.forms.utils import ErrorDict

@html_safe
@python_2_unicode_compatible
class ErrorDict(dict):
    """
    A collection of errors that knows how to display itself in various formats.

    The dictionary keys are the field names, and the values are the errors.
    """
    def as_data(self):
        return {f: e.as_data() for f, e in self.items()}

    def as_json(self, escape_html=False):
        return json.dumps({f: e.get_json_data(escape_html) for f, e in self.items()})

    def as_ul(self):
        if not self:
            return ''
        return format_html(
            '<ul class="errorlist">{}</ul>',
            format_html_join('', '<li>{}{}</li>', ((k, force_text(v)) for k, v in self.items()))
        )

    def as_text(self):
        output = []
        for field, errors in self.items():
            output.append('* %s' % field)
            output.append('\n'.join('  * %s' % e for e in errors))
        return '\n'.join(output)

    def __str__(self):
        return self.as_ul()

ErrorDict

比如 # 默认f.errors是ul列表而错误信息，但是如果没有索引则报错我们可以用get

    if request.method == "POST":
        user = request.POST.get("user",None)
        pwd = request.POST.get("pwd",None)

        # 验证
        f = Form1(request.POST) #将数据验证
    # 默认f.errors是ul列表  而错误信息，但是如果没有索引则报错我们可以用get
        print(f.errors.get('user',None))
        print(f.errors['user'][0])
        print(f.errors['pwd'][0])

如果前端我返回的是f.error可以用字典取值

　　但是django不支持

　　　　字典 dict[key]这种而是支持这种{{ dict.key }}　

　　而列表索引是{{ dict.key.0 }}

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>from django</title>
</head>
<body>
    {{ error }} {# 错误信息 #}
    {{ right }}
    <form method="post" action="/form1/">
    <div>


           {% if error.user.0 %}
            <span>{{ error.user.0 }}</span>
            {% endif %}
        <input type="text" name="user" placeholder="用户名" style="border-radius: 4px">
    </div>
    <div>

           {% if error.pwd.0 %}
            <span>{{ error.pwd.0 }}</span>
            {% endif %}
        <input type="password" name="pwd" placeholder="密码" style="border-radius: 4px">
    </div>

前端显示错误信息注意字典列表在django的模板语言不是中括号而是点

2.2 利用view.py传给前端html 我们写的form表单对象生成input标签：特点提交数据刷新页面后input仍然保留数据　　

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>from django</title>
</head>
<body>
    {{ error }} {# 错误信息 #}
    {{ right }}
    <form method="post" action="/form1/">
    <div>
          {{ form.user }}

           {% if error.user.0 %}
            <span>{{ error.user.0 }}</span>
            {% endif %}

    </div>
    <div>
        {{ form.pwd }}

           {% if error.pwd.0 %}
            <span>{{ error.pwd.0 }}</span>
            {% endif %}

    </div>

form1.html

#!/usr/bin/env python
#_*_coding:utf-8_*_


from django.shortcuts import render,HttpResponse
from django.forms.utils import ErrorDict

# Create your views here.


from app01.form import Form1

def form1(request):
    # 我们可以用form对象创建inut标签
    f = Form1()
    print(Form1.user_type_choice)
    if request.method == "POST":
        user = request.POST.get("user",None)
        pwd = request.POST.get("pwd",None)

        # 验证
        f = Form1(request.POST) #将数据验证
        if f.is_valid():
            print(f.cleaned_data) #  提交争取数据f.cleaned_data
        else:
            print(type(f.errors),f.errors)

        return render(request,"account/form1.html",{"error":f.errors,"right":f.cleaned_data,"form":f}) # form 创建保存input的 的数据

    return render(request,"account/form1.html",{"form":f})

view.py 返回我们写的form对象

3 定义form文件我们写的Form类的更多参数

from django.db import models

# Create your models here.

class Author(models.Model):
    '''
    作者
    '''
    name = models.CharField(max_length=100)
    age = models.IntegerField()

class BookType(models.Model):
    '''
    图书
    '''
    caption = models.CharField(max_length=64)

class Book(models.Model):
    name = models.CharField(max_length=64)
    pages = models.IntegerField()
    price = models.DecimalField(max_digits=10,decimal_places=2)
    pubdate = models.DateField(auto_now=True)

    authors = models.ManyToManyField("Author")
    book_type = models.ForeignKey("BookType")

models.py

3.1 定义textare select？？

memo = forms.CharField(
        widget=forms.Textarea()
    )

 # select下拉框的 第一种手动定义
    # user_type_choice = (
    #     (0,"普通用户"),
    #     (1,"高级用户"),
    # )

    # select下拉框第二种通过django的value_list在数据获取数据 显示列表
    user_type_choice = models.BookType.objects.values_list("id",'caption')

    user_type = forms.CharField(
        widget=forms.widgets.Select(choices=user_type_choice,attrs={"class":"font_control"}) #第二中定义attr
    )

　3.2 form标签的各种属性类设置

user = forms.CharField(
                           required=False,
                           widget=forms.TextInput(attrs={"class":"c1"}), # 第一种定义attr
                           error_messages={"required":"用户名不能为空"},
                           ) #前端name值input的
user_type = forms.CharField(
        widget=forms.widgets.Select(choices=user_type_choice,attrs={"class":"font_control"}) #第二中定义attr
    )

3.3 针对select下拉框的选项如果是orm获取如何在更新数据库后同步显示呢？？

　　我们知道django程序运行起来后，类是一次性创建的，这个Form内都是静态字段。所以数据也是一次性获取，如果我们新添加的数据后而不用重启程序让数据显示怎么办呢？如下

# select下拉框的 第一种手动定义
    # user_type_choice = (
    #     (0,"普通用户"),
    #     (1,"高级用户"),
    # )

    # select下拉框第二种通过django的value_list在数据获取数据 显示列表
    user_type_choice = models.BookType.objects.values_list("id",'caption')

    user_type = forms.CharField(
        widget=forms.widgets.Select(choices=user_type_choice,attrs={"class":"font_control"}) #第二中定义attr
    )


    # 但是第二种我们在数据库添加了数据后,由于这些都是类静态字段,整个程序一运行起来,类和类的静态字段都创建了,就不会再动了,但是我们想实时在前端看到我们在数据库后来添加的字段。,如下方法
    def __init__(self,*args,**kwargs):

        # 继承基类必须放在前面
        super(Form1,self).__init__(*args,**kwargs)

        # 如果数据库新添加了数据的话如下是更新的 前端显示
        # self.fields = copy.deepcopy(self.base_fields) 源码内

        self.fields["book_type"] = forms.CharField(
            widget=forms.widgets.Select(choices=models.BookType.objects.values_list("id",'caption'),attrs={"class":"font_control"})
        )

3.4 自定义from验证手机号

# 自定义form验证 手机号
from django.core.exceptions import ValidationError

import re
def mobile_validate(value):
    mobile_re = re.compile(r"^(1[3|5|8][0-9]|17[678]|14[57])[0-9]{8}$")
    if not  mobile_re.match(value):
        raise ValidationError("手机号格式错误")

 # 自定义form验证
    phone = forms.CharField(validators=[mobile_validate,],
                            error_messages={"required":"手机号不能为空"},
                            widget=forms.TextInput()
                            )

综合所有

#!/usr/bin/env python
#_*_coding:utf-8_*_

from django import forms
from app01 import models



# 自定义form验证 手机号
from django.core.exceptions import ValidationError

import re
def mobile_validate(value):
    mobile_re = re.compile(r"^(1[3|5|8][0-9]|17[678]|14[57])[0-9]{8}$")
    if not  mobile_re.match(value):
        raise ValidationError("手机号格式错误")

class Form1(forms.Form):
    user = forms.CharField(
                           required=False,
                           widget=forms.TextInput(attrs={"class":"c1"}), # 第一种定义attr
                           error_messages={"required":"用户名不能为空"},
                           ) #前端name值input的

    pwd = forms.CharField(max_length=6,min_length=1)

    email = forms.EmailField(error_messages={'required':"邮箱不能为空","invalid":"邮箱格式错误"})

    memo = forms.CharField(
        widget=forms.Textarea()
    )

    # 自定义form验证
    phone = forms.CharField(validators=[mobile_validate,],
                            error_messages={"required":"手机号不能为空"},
                            widget=forms.TextInput()
                            )

    # select下拉框的 第一种手动定义
    # user_type_choice = (
    #     (0,"普通用户"),
    #     (1,"高级用户"),
    # )

    # select下拉框第二种通过django的value_list在数据获取数据 显示列表
    user_type_choice = models.BookType.objects.values_list("id",'caption')

    user_type = forms.CharField(
        widget=forms.widgets.Select(choices=user_type_choice,attrs={"class":"font_control"}) #第二中定义attr
    )


    # 但是第二种我们在数据库添加了数据后,由于这些都是类静态字段,整个程序一运行起来,类和类的静态字段都创建了,就不会再动了,但是我们想实时在前端看到我们在数据库后来添加的字段。,如下方法
    def __init__(self,*args,**kwargs):

        # 继承基类必须放在前面
        super(Form1,self).__init__(*args,**kwargs)

        # 如果数据库新添加了数据的话如下是更新的 前端显示
        # self.fields = copy.deepcopy(self.base_fields) 源码内

        self.fields["book_type"] = forms.CharField(
            widget=forms.widgets.Select(choices=models.BookType.objects.values_list("id",'caption'),attrs={"class":"font_control"})
        )

app01/form.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re
from django import forms
from django.core.exceptions import ValidationError


def mobile_validate(value):
    mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
    if not mobile_re.match(value):
        raise ValidationError('手机号码格式错误')


class PublishForm(forms.Form):

    user_type_choice = (
        (0, u'普通用户'),
        (1, u'高级用户'),
    )

    user_type = forms.IntegerField(widget=forms.widgets.Select(choices=user_type_choice,
                                                                  attrs={'class': "form-control"}))

    title = forms.CharField(max_length=20,
                            min_length=5,
                            error_messages={'required': u'标题不能为空',
                                            'min_length': u'标题最少为5个字符',
                                            'max_length': u'标题最多为20个字符'},
                            widget=forms.TextInput(attrs={'class': "form-control",
                                                          'placeholder': u'标题5-20个字符'}))

    memo = forms.CharField(required=False,
                           max_length=256,
                           widget=forms.widgets.Textarea(attrs={'class': "form-control no-radius", 'placeholder': u'详细描述', 'rows': 3}))

    phone = forms.CharField(validators=[mobile_validate, ],
                            error_messages={'required': u'手机不能为空'},
                            widget=forms.TextInput(attrs={'class': "form-control",
                                                          'placeholder': u'手机号码'}))

    email = forms.EmailField(required=False,
                            error_messages={'required': u'邮箱不能为空','invalid': u'邮箱格式错误'},
                            widget=forms.TextInput(attrs={'class': "form-control", 'placeholder': u'邮箱'}))

Form

wusir

def publish(request):
    ret = {'status': False, 'data': '', 'error': '', 'summary': ''}
    if request.method == 'POST':
        request_form = PublishForm(request.POST)
        if request_form.is_valid():
            request_dict = request_form.clean()
            print request_dict
            ret['status'] = True
        else:
            error_msg = request_form.errors.as_json()
            ret['error'] = json.loads(error_msg)
    return HttpResponse(json.dumps(ret))

View

扩展：ModelForm

在使用Model和Form时，都需要对字段进行定义并指定类型，通过ModelForm则可以省去From中字段的定义

class AdminModelForm(forms.ModelForm):
      
    class Meta:
        model = models.Admin
        #fields = '__all__'
        fields = ('username', 'email')
          
        widgets = {
            'email' : forms.PasswordInput(attrs={'class':"alex"}),
        }

文件上传

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

    <form method="post" action="/upload_file/" enctype="multipart/form-data">
        {% csrf_token %}
        <input type="file" name="fafafa">
        <input type="submit" value="提交文件">
    </form>

</body>
</html>

def upload_file(request):
    import os
    if request.method == "POST":
        obj = request.FILES.get("fafafa")
        print(obj.name,obj.chunks(),type(obj.chunks()))

        f = open(os.path.join("upload/",obj.name),"wb")
        for chunk in obj.chunks():
            f.write(chunk)




    return render(request,"upload_file.html")

前端选择多个文件　　multiple

<div style="width: 460px;height: auto;background-color:white " class="Picture_Home fileImg" id="fileImg">
         <!--  文件上传        --->
        <input onchange="UploadFile();" style="width: 200px;height: 50px" name="file" class="MyPic" type="file" id="files" multiple /> 
        <output id="list"></output>
        <input type="button" >
    </div>

后端获取getlist 而不是get

def pic_handle(request):

    timestamp = time.time()
    user_id = request.session['userinfo']['data'][0]["user_id__id"]
    pic_path = "statics/uploads/%s/%s" % (user_id, timestamp)

    if request.method == "POST":

        all_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), pic_path)
        if not os.path.exists(all_path):
            os.mkdir(all_path)
        print(request)
        print(request.FILES.getlist("fff"))
        obj = request.FILES.getlist("fff")
        print(obj.name, obj.chunks(), type(obj.chunks()))

        f = open(os.path.join(all_path, obj.name), "wb")
        for chunk in obj.chunks():
            f.write(chunk)

        return HttpResponse(os.path.join("/%s" % pic_path,obj.name))

    return render(request,"test/test.html")

二、cookie 应用

1、获取Cookie：

request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
    参数：
        default: 默认值
           salt: 加密盐
        max_age: 后台控制过期时间

2、设置Cookie：

rep = HttpResponse(...) 或 rep ＝ render(request, ...)
 
rep.set_cookie(key,value,...)
rep.set_signed_cookie(key,value,salt='加密盐',...)
    参数：
        key,              键
        value='',         值
        max_age=None,     超时时间
        expires=None,     超时时间(IE requires expires, so set it if hasn't been already.)
        path='/',         Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问
        domain=None,      Cookie生效的域名
        secure=False,     https传输
        httponly=False    只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）



django 的测试

def cook(request):
    #获取cookie
    print(request.COOKIES)
    # 这里 获取加密cookie 默认为None
    print(request.get_signed_cookie("k2",None,salt="uuu"))
    ret = HttpResponse("ok")
    # 相应时候设置cookie
    ret.set_cookie("k1",999)
    # 设置加密 cookie
    ret.set_signed_cookie("k2",666,salt="uuu")
    return ret

def index(request):
    r = request.COOKIES.get("give_tickets",None)
    obj = SchoolFlower.objects.all()
    print(request.COOKIES)
    print(request.COOKIES.get("give_tickets"))

  

        response = render_to_response("index.html",{"obj":obj})
     
        # response.set_cookie("give_tickets","yes",expires=expire) # set_signed_cookie("give_tickets","yes",salt="salt")
        response.set_cookie("give_tickets",None,expires=expire) # set_signed_cookie("give_tickets","yes",salt="salt")
  
        return response

由于cookie保存在客户端的电脑上，所以，JavaScript和jquery也可以操作cookie。

<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });

三 session　

Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：

数据库（默认）
缓存
文件
缓存+数据库
加密cookie

1、数据库Session

Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。
 
a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）
     
    SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
    SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
    SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
    SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
    SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
    SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
    SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）
 
 
 
b. 使用
 
    def index(request):
        # 获取、设置、删除Session中数据
        request.session['k1']
        request.session.get('k1',None)
        request.session['k1'] = 123
        request.session.setdefault('k1',123) # 存在则不设置
        del request.session['k1']
 
        # 所有 键、值、键值对
        request.session.keys()
        request.session.values()
        request.session.items()
        request.session.iterkeys()
        request.session.itervalues()
        request.session.iteritems()
 
 
        # 用户session的随机字符串
        request.session.session_key
 
        # 将所有Session失效日期小于当前日期的数据删除
        request.session.clear_expired()
 
        # 检查 用户session的随机字符串 在数据库中是否
        request.session.exists("session_key")
 
        # 删除当前用户的所有Session数据
        request.session.delete("session_key")
 
        ...

　　2、缓存Session

a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
    SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置
 
 
    SESSION_COOKIE_NAME ＝ "sessionid"                        # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                              # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                             # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                            # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE = 1209600                              # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                   # 是否关闭浏览器使得Session过期
    SESSION_SAVE_EVERY_REQUEST = False                        # 是否每次请求都保存Session，默认修改之后才保存
 
 
 
b. 使用
 
    同上

　　3、文件Session

a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
    SESSION_FILE_PATH = None                                    # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()                                                            # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T
 
 
    SESSION_COOKIE_NAME ＝ "sessionid"                          # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                  # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                                # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                               # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                              # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE = 1209600                                # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                     # 是否关闭浏览器使得Session过期
    SESSION_SAVE_EVERY_REQUEST = False                          # 是否每次请求都保存Session，默认修改之后才保存
 
b. 使用
 
    同上

4、缓存+数据库Session

数据库用于做持久化，缓存用于提高效率
 
a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎
 
b. 使用
 
    同上

　　5、加密cookie Session

a. 配置 settings.py
     
    SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎
 
b. 使用
 
    同上

更多参考：猛击这里和猛击这里

扩展：Session用户验证

def login(func):
    def wrap(request, *args, **kwargs):
        # 如果未登陆，跳转到指定页面
        if request.path == '/test/':
            return redirect('http://www.baidu.com')
        return func(request, *args, **kwargs)
    return wrap

分页

一、Django内置分页

#!/usr/bin/env python
# _*_coding:utf-8_*_
from django.shortcuts import render
from django.shortcuts import redirect
from django.shortcuts import HttpResponse
from django.shortcuts import render_to_response

import json, time, os
# Create your views here.

from django.core.paginator import Paginator, InvalidPage, EmptyPage, PageNotAnInteger
from decimal import Decimal


def listye(request):
    after_range_num = 5
    before_range_num = 4
    page = int(request.GET.get('page', '1'))  # 获取页码
    if page < 1:
        page = 1
    book_list = [{'price': Decimal('55.00'), 'name': 'python'}, {'price': Decimal('66.00'), 'name': 'django'},
                 {'price': Decimal('77.00'), 'name': 'tornado'}, {'price': Decimal('88.00'), 'name': 'flask'},
                 {'price': Decimal('33.00'), 'name': 'java'}, {'price': Decimal('55.00'), 'name': 'ss'},
                 {'price': Decimal('55.00'), 'name': 'd'}, {'price': Decimal('966.00'), 'name': 'ddsa'},
                 {'price': Decimal('99.00'), 'name': 'mmm'}, {'price': Decimal('666.00'), 'name': 'xxx'},
                 {'price': Decimal('555.00'), 'name': 'dasd'}, {'price': Decimal('666.00'), 'name': 'das'},
                 {'price': Decimal('22.00'), 'name': 'das'}, {'price': Decimal('333.00'), 'name': 'aaa'},
                 {'price': Decimal('111.00'), 'name': 'bbb'}, {'price': Decimal('555.00'), 'name': 'ccc'},
                 {'price': Decimal('777.00'), 'name': 'ddd'}, {'price': Decimal('222.00'), 'name': 'eee'},
                 {'price': Decimal('666.00'), 'name': 'fff'}, {'price': Decimal('5.00'), 'name': '3'},
                 {'price': Decimal('1.00'), 'name': 'ggg'}, {'price': Decimal('333.00'), 'name': 'qqq'},
                 {'price': Decimal('444.00'), 'name': 'sss'}, {'price': Decimal('666.00'), 'name': 'rrr'},
                 {'price': Decimal('111.00'), 'name': 'hhh'}, {'price': Decimal('888.00'), 'name': 'mmm'},
                 {'price': Decimal('999.00'), 'name': 'nnn'}, {'price': Decimal('200.00'), 'name': 'ttt'},
                 {'price': Decimal('66.00'), 'name': 'uuu'}, {'price': Decimal('789.00'), 'name': 'kkk'}]

    paginator = Paginator(book_list, 2)  # 把数据和每页显示多少条 传入
    try:
        p = paginator.page(page)  # 获取当前页的对象
    except (EmptyPage, InvalidPage, PageNotAnInteger):  # 空页  页面无效多取超出范围  不是整数时 取第一页
        p = paginator.page(1)
    if page >= after_range_num:  # 页面最少显示5页
        # 如果page超出5页  就应该取 page的前4页到后4页 加上page 一共是9页
        page_range = paginator.page_range[page - 5:page + 4]

    else:
        # 如果没超过第5页，就取第一页 到 当前页加4   因为索引从0开始，而页码是从1开始的
        page_range = paginator.page_range[0:int(page) + before_range_num]
    return render_to_response('222.html', locals())

app01/util/fenye.py

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        a{
                border: 1px solid #9aafe5;
    color: #2e6ab1;
    margin: 0 2px;
    padding: 2px 3px;
    text-decoration: none;
        }
        .zong{
            width: 160px;
            padding: 10px;
            margin: 0 auto;
        }
    </style>
</head>
<body>
{#  p 为当前页 对象#}
<div style="margin: 100px auto;width: 450px">
<div style="margin: 50px auto;width: 200px">
    {% for book in p.object_list %}
      书名:{{ book.name }}|价格：{{ book.price }} <br />
    {#  显示书名和价格  #}
    {% endfor %}
</div>
<div>
    {% if p.has_previous %}
        {#   是否有上一页 #}
    <a href="?page={{ p.previous_page_number }}" title="上一页">上一页</a>
    {#  p.previous_page_number 上一页的页码  #}
    {% endif %}
    {% for page in page_range %}
        {#  循环 要显示的页码  #}
    {% ifequal  page p.number %}
    {#  判断是否是当前页  #}
    <span>{{page}}</span>
    {% else %}
    <a href="?page={{page}}" title="第{{page}}页">{{page}}</a>
    {% endifequal %}
    {% endfor %}
    {% if p.has_next %}
        {#   是否有下一页 #}
    <a href="?page={{ p.next_page_number }}" title="下一页" >下一页</a>
    {% endif %}
</div>
<input  type="text" > <input type="button" onclick="SUBMIT();" value="跳转">
<div class="zong">第 {{ p.number }} 页 共 {{ p.paginator.num_pages }} 页</div>
{#            当前页                  总页数                #}
</div>
<script src="/static/js/jquery-1.9.1.min.js"></script>
<script>
    function SUBMIT() {
        var aa=$(':text').val()
        window.location.href='/fenye/?page='+aa
    }
</script>
</body>
</html>

222.html

"""s58 URL Configuration

The `urlpatterns` list routes URLs to views. For more information please see:
    https://docs.djangoproject.com/en/1.10/topics/http/urls/
Examples:
Function views
    1. Add an import:  from my_app import views
    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
Class-based views
    1. Add an import:  from other_app.views import Home
    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
Including another URLconf
    1. Import the include() function: from django.conf.urls import url, include
    2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin

from app01 import views
from  app01.util import fenye

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^index/', views.index),
    url(r'^index1/', views.index1),
    url(r'^login/', views.login),
    url(r'^register/', views.register),
    url(r'^logout/', views.logout),
    url(r'^pub/', views.pub),
    url(r'^sub/', views.sub),
    url(r'^sub1/', views.sub_session),
    url(r'^clear_session/', views.clear_session),
    url(r'^fenye/', fenye.listye),
]

url.py

二、自定义分页

分页功能在每个网站都是必要的，对于分页来说，其实就是根据用户的输入计算出应该在数据库表中的起始位置。

1、设定每页显示数据条数

2、用户输入页码（第一页、第二页...）

3、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置

4、在数据表中根据起始位置取值，页面上输出数据

需求又来了，需要在页面上显示分页的页面。如：［上一页］［1］［2］［3］［4］［5］［下一页］

1、设定每页显示数据条数

2、用户输入页码（第一页、第二页...）

3、设定显示多少页号

4、获取当前数据总条数

5、根据设定显示多少页号和数据总条数计算出，总页数

6、根据设定的每页显示条数和当前页码，计算出需要取数据表的起始位置

7、在数据表中根据起始位置取值，页面上输出数据

8、输出分页html，如：［上一页］［1］［2］［3］［4］［5］［下一页］

#!/usr/bin/env python
# _*_coding:utf-8_*_
from django.utils.safestring import mark_safe
 
class PageInfo(object):
    def __init__(self,current,totalItem,peritems=5):
        self.__current=current
        self.__peritems=peritems
        self.__totalItem=totalItem
    def From(self):
        return (self.__current-1)*self.__peritems
    def To(self):
        return self.__current*self.__peritems
    def TotalPage(self):  #总页数
        result=divmod(self.__totalItem,self.__peritems)
        if result[1]==0:
            return result[0]
        else:
            return result[0]+1
 
def Custompager(baseurl,currentPage,totalpage):  #基础页，当前页，总页数
    perPager=11
    #总页数<11
    #0 -- totalpage
    #总页数>11
        #当前页大于5 currentPage-5 -- currentPage+5
            #currentPage+5是否超过总页数,超过总页数，end就是总页数
        #当前页小于5 0 -- 11
    begin=0
    end=0
    if totalpage <= 11:
        begin=0
        end=totalpage
    else:
        if currentPage>5:
            begin=currentPage-5
            end=currentPage+5
            if end > totalpage:
                end=totalpage
        else:
            begin=0
            end=11
    pager_list=[]
    if currentPage<=1:
        first="<a href=''>首页</a>"
    else:
        first="<a href='%s%d'>首页</a>" % (baseurl,1)
    pager_list.append(first)
 
    if currentPage<=1:
        prev="<a href=''>上一页</a>"
    else:
        prev="<a href='%s%d'>上一页</a>" % (baseurl,currentPage-1)
    pager_list.append(prev)
 
    for i in range(begin+1,end+1):
        if i == currentPage:
            temp="<a href='%s%d' class='selected'>%d</a>" % (baseurl,i,i)
        else:
            temp="<a href='%s%d'>%d</a>" % (baseurl,i,i)
        pager_list.append(temp)
    if currentPage>=totalpage:
        next="<a href='#'>下一页</a>"
    else:
        next="<a href='%s%d'>下一页</a>" % (baseurl,currentPage+1)
    pager_list.append(next)
    if currentPage>=totalpage:
        last="<a href=''>末页</a>"
    else:
        last="<a href='%s%d'>末页</a>" % (baseurl,totalpage)
    pager_list.append(last)
    result=''.join(pager_list)
    return mark_safe(result)   #把字符串转成html语言

分页实例

分页示例

总结，分页时需要做三件事：

创建处理分页数据的类
根据分页数据获取数据
输出分页HTML，即：［上一页］［1］［2］［3］［4］［5］［下一页］

缓存

由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。

Django中提供了6种缓存方式：

开发调试
内存
文件
数据库
Memcache缓存（python-memcached模块）
Memcache缓存（pylibmc模块）

1、配置

a、开发调试

# 此为开始调试用，实际内部不做任何操作
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
                'TIMEOUT': 300,                                               # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
                'OPTIONS':{
                    'MAX_ENTRIES': 300,                                       # 最大缓存个数（默认300）
                    'CULL_FREQUENCY': 3,                                      # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
                },
                'KEY_PREFIX': '',                                             # 缓存key的前缀（默认空）
                'VERSION': 1,                                                 # 缓存key的版本（默认1）
                'KEY_FUNCTION' 函数名                                          # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
            }
        }


    # 自定义key
    def default_key_func(key, key_prefix, version):
        """
        Default function to generate keys.

        Constructs the key used by all other methods. By default it prepends
        the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
        function with custom key making behavior.
        """
        return '%s:%s:%s' % (key_prefix, version, key)

    def get_key_func(key_func):
        """
        Function to decide which key function to use.

        Defaults to ``default_key_func``.
        """
        if key_func is not None:
            if callable(key_func):
                return key_func
            else:
                return import_string(key_func)
        return default_key_func

开发调试

b、内存

# 此缓存将内容保存至内存的变量中
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                'LOCATION': 'unique-snowflake',
            }
        }

    # 注：其他配置同开发调试版本

　　c、文件

# 此缓存将内容保存至文件
    # 配置：

        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                'LOCATION': '/var/tmp/django_cache',
            }
        }
    # 注：其他配置同开发调试版本

　　d、数据库

# 此缓存将内容保存至数据库

    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                'LOCATION': 'my_cache_table', # 数据库表
            }
        }

    # 注：执行创建表命令 python manage.py createcachetable

　　e、Memcache缓存（python-memcached模块）

# 此缓存使用python-memcached模块连接memcache

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': '127.0.0.1:11211',
        }
    }

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': 'unix:/tmp/memcached.sock',
        }
    }   

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': [
                '172.19.26.240:11211',
                '172.19.26.242:11211',
            ]
        }
    }

View Code

f、Memcache缓存（pylibmc模块）

# 此缓存使用pylibmc模块连接memcache
    
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': '127.0.0.1:11211',
        }
    }

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': '/tmp/memcached.sock',
        }
    }   

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': [
                '172.19.26.240:11211',
                '172.19.26.242:11211',
            ]
        }
    }

View Code

2、应用

a. 全站使用

使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

    MIDDLEWARE = [
        'django.middleware.cache.UpdateCacheMiddleware',
        # 其他中间件...
        'django.middleware.cache.FetchFromCacheMiddleware',
    ]

    CACHE_MIDDLEWARE_ALIAS = ""
    CACHE_MIDDLEWARE_SECONDS = ""
    CACHE_MIDDLEWARE_KEY_PREFIX = ""

全站使用

b. 单独视图缓存

方式一：
        from django.views.decorators.cache import cache_page

        @cache_page(60 * 15)
        def my_view(request):
            ...

    方式二：
        from django.views.decorators.cache import cache_page

        urlpatterns = [
            url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
        ]

单独视图应用设置时间缓存

c、局部视图使用

a. 引入TemplateTag

        {% load cache %}

    b. 使用缓存

        {% cache 5000 缓存key %}
            缓存内容
        {% endcache %}

局部使用

更多：猛击这里

序列化

应用案例

　　http://www.cnblogs.com/liujianzuo888/articles/5807434.html

关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的Ajax请求一般返回的为Json格式。

1、serializers

from django.core import serializers
 
ret = models.BookType.objects.all()
 
data = serializers.serialize("json", ret)

2、json.dumps

import json
 
#ret = models.BookType.objects.all().values('caption')
ret = models.BookType.objects.all().values_list('caption')
 
ret=list(ret)
 
result = json.dumps(ret)

由于json.dumps时无法处理datetime日期，所以可以通过自定义处理器来做扩展，如：

import json 
from datetime import date 
from datetime import datetime 
   
class JsonCustomEncoder(json.JSONEncoder): 
    
    def default(self, field): 
     
        if isinstance(field, datetime): 
            return o.strftime('%Y-%m-%d %H:%M:%S') 
        elif isinstance(field, date): 
            return o.strftime('%Y-%m-%d') 
        else: 
            return json.JSONEncoder.default(self, field) 
   
   
# ds = json.dumps(d, cls=JsonCustomEncoder)

扩展其他类型字段

信号

Django中提供了“信号调度”，用于在框架执行操作时解耦。通俗来讲，就是一些动作发生的时候，信号允许特定的发送者去提醒一些接受者。

1、Django内置信号

Model signals
    pre_init                    # django的modal执行其构造方法前，自动触发
    post_init                   # django的modal执行其构造方法后，自动触发
    pre_save                    # django的modal对象保存前，自动触发
    post_save                   # django的modal对象保存后，自动触发
    pre_delete                  # django的modal对象删除前，自动触发
    post_delete                 # django的modal对象删除后，自动触发
    m2m_changed                 # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
    class_prepared              # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
Management signals
    pre_migrate                 # 执行migrate命令前，自动触发
    post_migrate                # 执行migrate命令后，自动触发
Request/response signals
    request_started             # 请求到来前，自动触发
    request_finished            # 请求结束后，自动触发
    got_request_exception       # 请求异常后，自动触发
Test signals
    setting_changed             # 使用test测试修改配置文件时，自动触发
    template_rendered           # 使用test测试渲染模板时，自动触发
Database Wrappers
    connection_created          # 创建数据库连接时，自动触发

对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：

from django.core.signals import request_finished
    from django.core.signals import request_started
    from django.core.signals import got_request_exception

    from django.db.models.signals import class_prepared
    from django.db.models.signals import pre_init, post_init
    from django.db.models.signals import pre_save, post_save
    from django.db.models.signals import pre_delete, post_delete
    from django.db.models.signals import m2m_changed
    from django.db.models.signals import pre_migrate, post_migrate

    from django.test.signals import setting_changed
    from django.test.signals import template_rendered

    from django.db.backends.signals import connection_created


    def callback(sender, **kwargs):
        print("xxoo_callback")
        print(sender,kwargs)

    xxoo.connect(callback)
    # xxoo指上述导入的内容

项目/__init__.py

from django.core.signals import request_finished
from django.dispatch import receiver

@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")

调用

2、自定义信号

a. 定义信号

import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])

　　b. 注册信号

def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)
 
pizza_done.connect(callback)

　　c. 触发信号

from 路径 import pizza_done
 
pizza_done.send(sender='seven',toppings=123, size=456)

由于内置信号的触发者已经集成到Django中，所以其会自动调用，而对于自定义信号则需要开发者在任意位置触发。

更多：猛击这里

案例

from django.shortcuts import render,HttpResponse

# Create your views here.

from app01 import models

def signal(request): # django的信号
    print("before")
    models.UserInfo.objects.create(name="alex") # init定义信号触发
    print("after")
    return HttpResponse("ok")

def signal_self(request): # 自定义函数
    from s57 import pizza_done# init定义信号触发
    pizza_done.send(sender='signal_self', toppings=123, size=456)# init定义信号触发
    print("# init定义信号触发")
    return HttpResponse("ok")

view.py 两种信号定义

from django.core.signals import request_finished
from django.core.signals import request_started
from django.core.signals import got_request_exception

from django.db.models.signals import class_prepared
from django.db.models.signals import pre_init, post_init
from django.db.models.signals import pre_save, post_save
from django.db.models.signals import pre_delete, post_delete
from django.db.models.signals import m2m_changed
from django.db.models.signals import pre_migrate, post_migrate

from django.test.signals import setting_changed
from django.test.signals import template_rendered

from django.db.backends.signals import connection_created


def callback1(sender, **kwargs):
    print("xxoo_callback111")
    print(sender, kwargs)

def callback2(sender, **kwargs):
    print("xxoo_callback2222")
    print(sender, kwargs)

pre_save.connect(callback1)
post_save.connect(callback2)
# xxoo指上述导入的内容


# 自定义信号
import django.dispatch
pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])


def callback(sender, **kwargs):
    print("自定义callback")
    print(sender, kwargs)


pizza_done.connect(callback)

项目/init.py

from django.db import models

# Create your models here.

class UserInfo(models.Model):

    name = models.CharField(max_length=16)

models.py

"""s57 URL Configuration

The `urlpatterns` list routes URLs to views. For more information please see:
    https://docs.djangoproject.com/en/1.10/topics/http/urls/
Examples:
Function views
    1. Add an import:  from my_app import views
    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
Class-based views
    1. Add an import:  from other_app.views import Home
    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
Including another URLconf
    1. Import the include() function: from django.conf.urls import url, include
    2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin


from app01 import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^signal/', views.signal),
    url(r'^signal1/', views.signal_self),
    url(r'^upload_file/', views.upload_file),
]

url.py

跨站请求伪造csrf

一、简介

django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。

全局：

　　中间件 django.middleware.csrf.CsrfViewMiddleware

局部：

@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
@csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。

注：from django.views.decorators.csrf import csrf_exempt,csrf_protect

二、应用

1、普通表单

veiw中设置返回值：
　　return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))　　
     或者
     return render(request, 'xxx.html', data)
  
html中设置Token:
　　{% csrf_token %}

2、Ajax

对于传统的form，可以通过表单的方式将token再次发送到服务端，而对于ajax的话，使用如下方式。

view.py

from django.template.context import RequestContext
# Create your views here.
  
  
def test(request):
  
    if request.method == 'POST':
        print request.POST
        return HttpResponse('ok')
    return  render_to_response('app01/test.html',context_instance=RequestContext(request))

View Code

text.html

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    {% csrf_token %}
  
    <input type="button" onclick="Do();"  value="Do it"/>
  
    <script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
    <script src="/static/plugin/jquery/jquery.cookie.js"></script>
    <script type="text/javascript">
        var csrftoken = $.cookie('csrftoken');
  
        function csrfSafeMethod(method) {
            // these HTTP methods do not require CSRF protection
            return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
        }
        $.ajaxSetup({
            beforeSend: function(xhr, settings) {
                if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
        function Do(){
  
            $.ajax({
                url:"/app01/test/",
                data:{id:1},
                type:'POST',
                success:function(data){
                    console.log(data);
                }
            });
  
        }
    </script>
</body>
</html>

更多：https://docs.djangoproject.com/en/dev/ref/csrf/#ajax

admin

django amdin是django提供的一个后台管理页面，改管理页面提供完善的html和css，使得你在通过Model创建完数据库表之后，就可以对数据进行增删改查，而使用django admin 则需要以下步骤：

创建后台管理员
配置url
注册和配置django admin后台管理页面

1、创建后台管理员

python manage.py createsuperuser

　　2、配置后台管理url

url(r'^admin/', include(admin.site.urls))

3、注册和配置django admin 后台管理页面

a、在admin中执行如下配置

from django.contrib import admin
  
from app01 import  models
  
admin.site.register(models.UserType)
admin.site.register(models.UserInfo)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

b、设置数据表名称

class UserType(models.Model):
    name = models.CharField(max_length=50)
  
    class Meta:
        verbose_name = '用户类型'
        verbose_name_plural = '用户类型'

c、打开表之后，设定默认显示，需要在model中作如下配置　　

class UserType(models.Model):
    name = models.CharField(max_length=50)
  
    def __unicode__(self):
        return self.name

from django.contrib import admin
  
from app01 import  models
  
class UserInfoAdmin(admin.ModelAdmin):
    list_display = ('username', 'password', 'email')
  
  
admin.site.register(models.UserType)
admin.site.register(models.UserInfo,UserInfoAdmin)
admin.site.register(models.UserGroup)

　d、为数据表添加搜索功能　

from django.contrib import admin
  
from app01 import  models
  
class UserInfoAdmin(admin.ModelAdmin):
    list_display = ('username', 'password', 'email')
    search_fields = ('username', 'email')
  
admin.site.register(models.UserType)
admin.site.register(models.UserInfo,UserInfoAdmin)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

　　e、添加快速过滤

from django.contrib import admin
  
from app01 import  models
  
class UserInfoAdmin(admin.ModelAdmin):
    list_display = ('username', 'password', 'email')
    search_fields = ('username', 'email')
    list_filter = ('username', 'email')
      
  
  
admin.site.register(models.UserType)
admin.site.register(models.UserInfo,UserInfoAdmin)
admin.site.register(models.UserGroup)
admin.site.register(models.Asset)

更多：http://docs.30c.org/djangobook2/chapter06/

admin密码忘记

urlpatterns = [
    url(r'^admin/', admin.site.urls),
  
    url(r'^test/', views.test),
]

def test(request):
    from django.contrib.auth.models import User
    user = User.objects.get(username='root') # 可以先打印看看是哪个用User.objects.all()
    user.set_password('woqunimade')
    user.save()
    return HttpResponse(user)

posted @ 2016-08-25 23:50 众里寻，阑珊处阅读(242) 评论(0) 编辑收藏举报

刷新页面返回顶部

Django form 文件上传 cookie session 分页 缓存 csrf admin后台配置 admin密码忘记 django文件上传

一 、form应用

1

1.1简单应用form

2 form表单的错误提示

3 定义form文件我们写的Form类的更多参数

文件上传

前端选择多个文件 multiple

后端获取getlist 而不是get

二 、cookie 应用

1、获取Cookie：

2、设置Cookie：

三 session

分页

一、Django内置分页

二、自定义分页

缓存

2、应用

序列化

1、serializers

2、json.dumps

信号

跨站请求伪造csrf

一、简介

二、应用

admin

1、创建后台管理员

2、配置后台管理url

3、注册和配置django admin 后台管理页面

admin密码忘记

公告

Django form 文件上传 cookie session 分页缓存 csrf admin后台配置 admin密码忘记 django文件上传

一、form应用

前端选择多个文件　　multiple

二、cookie 应用

三 session　

　　2、配置后台管理url