$.ajax({

  url: "/cookie_ajax/",

  type: "POST",

  data: {

    "username": "Q1mi",

    "password": 123456,

    "csrfmiddlewaretoken": $("[name = 'csrfmiddlewaretoken']").val()  // 使用jQuery取出csrfmiddlewaretoken的值，拼接到data中

  },

  success: function (data) {

    console.log(data);

  }

})

// 原生ajax，XMLHttpRequest

    以下两函数功能一样。

         function Ajax1()

            {

                $.ajax({

                    url:'index.html',

                    type:'GET',

                    data:{'p':123},

                    success:function(arg){

                        console.log(arg);

                    }

                })

            }    

        function Ajax2()

            {

                var xhr = new XMLHttpRequest();

                xhr.onreadystatechange=function(){

                    if(xhr.readyState==4){

                        //状态‘4’表示将服务器的返回的数据全部接收完毕

                        console.log(xhr.responseText);  //xhr.responseText表示服务器端返回的数据

                    }

                }

                xhr.open('GET','/index.html?p=123').  //GET请求只能将data数据写在url中

                xhr.send(null)

            }

        而POST请求而只要改动以下

        xhr.open('POST','/index.html')

        xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset-UTF-8');

　　　　　xhr.send('p=123')

//send中字符串参数是post请求，而且必须带请求头，否则django不会解析，即request.POST会无数据，

//但是request.body中可以查看到数据确实发过去了。jquery的ajax已经帮我们封装好请求头了。并且可能有其他框架会指定要特有的请求头。

//注意，若前端使用Formdata封装数据(因为不需要头，jquery的ajax中也要做特殊处理），则不用请求头也可

    content-type ：服务器端给客户端发送的数据类型

    accept ：服务器端告诉客户端要接收数据类型

    User-agent

    COOKIE

        // 默认：（和form表单一样的头）

        $.ajax({

            url:...

            type:POST,

            data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男

        })

         // 情况二：（定制了请求头，Content-Type 不再是 application/x-www-form-urlencoded）

        $.ajax({

                url:...

                type:POST,

                headers:{'Content-Type':"application/json"}

                data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男

            })

            # body有值；POST无

        //  情况三：（序列化，数据格式不满足，而且头也不满足）

            $.ajax({

                url:...

                type:POST,

                headers:{'Content-Type':"application/json"}

                data:JSON.stringfy({name:alex,age=18}) # {name:alex,age:18...}

            })

            // body有值；POST无

            // json.loads(request.body)

        // #avatar是文件上传按钮

          $('#avatar').click(function () {

                    if (!$('#avatar-img').val()) {

                        // $('#avatar-img').val() 是文件路径名

                        // $('#avatar-img')[0].files[0] 是文件对象，后台从request.FILES里取出就是它

                    }

                    var formData = new FormData();

                    formData.append('csrfmiddlewaretoken', $('[name = "csrfmiddlewaretoken"]').val());

                    formData.append('img', $('#avatar-img')[0].files[0]);

                    $.ajax({

                        url: '/account/upload_avatar/',

                        type: 'post',

                        processData: false,

                        contentType: false,

                        data: formData,

                        dataType: 'json',

                        success: function (data) {

                            console.log(typeof(data), data);

                        }

                    })

                });

url(r'^(?P<type>type_[1-3])', views.index),

url(r'^$', views.index),

# 该正则表示按标签或者日期或者种类过滤

url(r'^(?P<site>\w+)/(?P<condition>((tag)|(date)|(category))/(?P<val>\w+).html$',home.filter)

url('^yuan',([],None,None))

from django.utils.http import urlquote

def parse_filter_kwargs(kwargs):

    # kwargs: {'title':1,'price':12000}

    # return: title=1&price=12000

    l = []

    for k, v in kwargs.items():

        l.append('%s=%s' % (k, urlquote(v)))

    return '&'.join(l)

from django.core.urlresolvers import reverse

#kwargs参数接收 一个字典，代表命名正则的名 和 对应的值

    if kwargs:

            base_url = reverse('index', kwargs=kwargs)

        else:

            base_url = '/'

# 默认版

url('all/(\d+).html$',home.index,name='index')

{%url "index" 1%} # 在html中

reverse('index',kwargs=(1,)) # 在view中

# 命名正则版

url('all/(?<my_id>\d+).html$',home.index,name='index')

{%url "index" my_id=1%} # 在html中：

reverse('index',kwargs={"my_id":1}) #在view中

# 命名空间的url反转

{% url 'org:org_list'%}

from django.http import JsonRespone

#注意：默认JsonRespone只能返回字典，若一定要返回列表，则需要加参数

    return JsonRespone([11,22,33],safe=False)

# HttpResponse可以带几个参数：

"""

content: 返回的内容

content_type: 返回内容的类型

status

"""

def index(request):

　　　　return HttpResponse('<p>this is a test</p>', content_type="text/html", status="")

　res = HttpRespone('xxxxx')

　res['Access-Control-Allow-Origin']='*'

　return res

from django.contrib.auth.decorators import login_required

from django.utils.decorators import method_decorator

from django.views import View

class LoginRequiredMixin(object):

    @method_decorator(login_required(login_url='/url/'))

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

        return super(LoginRequiredMixin, self).dispatch(request, *args, **kwargs)

# 注意继承顺序

class CommentView(LoginRequiredMixin, View):

    pass

from django.utils.decorators import method_decorator

class HomeView(View):

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

        return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request):

        return render(request, "home.html")

    @method_decorator(check_login)

    def post(self, request):

        print("Home View POST method...")

        return redirect("/index/")

from django.utils.decorators import method_decorator

class HomeView(View):

    @method_decorator(check_login)

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

        return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request):

        return render(request, "home.html")

    def post(self, request):

        print("Home View POST method...")

        return redirect("/index/")

from django.utils.decorators import method_decorator

@method_decorator(check_login, name="get")

@method_decorator(check_login, name="post")

class HomeView(View):

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

        return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request):

        return render(request, "home.html")

    def post(self, request):

        print("Home View POST method...")

        return redirect("/index/")

# cookie

request.COOKIES.get('username111')

res = render(request,'index.html')

res.set_cookie('key',"value",max_age=10)  # 设置cookie, N秒后失效

#session

x = request.session['xx']

request.session['xx'] = 1

request.session.set_expiry(value)

        # * 如果value是个整数，session会在些秒数后失效。

        # * 如果value是个datatime或timedelta，session就会在这个时间后失效。

        # * 如果value是0,用户关闭浏览器session就会失效。

        # * 如果value是None,session会依赖全局session失效策略。

# 指明函数路径

handler404 = 'users.views.page_not_found'

def page_not_found(request):

    from django.shortcuts import render_to_response

    response = render_to_response('404.html',{})

    response.status_code = 404

    return response

url(r'^static/(?P<path>.*)$,serve,{"document_root":STATIC_ROOT})

    # django setting里面的database的初始化命令

    DATABASES = {

        'default': {

            'ENGINE': 'django.db.backends.mysql',

            'NAME': 'imoocc',

            'USER': 'imoocc',

            'PASSWORD': 'imoocccom',

            'HOST': '127.0.0.1',

            'PORT': '',

            'OPTIONS': {},

            'init_command': 'SET storage_engine=INNODB,'

                            'SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED, autocommit=1, names "utf8";',

        }

}

status = models.IntegerField(choices=[(-1, '未处理'), (0, '待处理'), (1, '已处理')]）

　　# obj.get_status_choice

send_time = models.DateTimeFIeld(default=datetime.now)

# 如果有额外的字段的时候
tags=models.ManyToManyField(

to='Tag',

through = 'Article2Tag',

through_fields = ('article','tag'),

) 

models.Author2Book.objects.get(author_id=1,book_id=1).delete()

# 例如：为每个用户创建一个指定的文件夹

def upload_to(instance, filename):

    import uuid

    filename = '%s-%s' % (str(uuid.uuid4())[:8], filename)

    return '/'.join(['head', instance.username, filename])

    UserInfo.objects.create(img=request.FILES)

    # 或者：

    username = form.cleaned_data['username']

            headImg = form.cleaned_data['headImg']

            #写入数据库

            user = User()

            user.username = username

            user.headImg = headImg

            user.save()
    

image = models.ImageField(upload_to="courses/%Y/%m")

from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation

from django.contrib.contenttypes.models import ContentType

class Course(models.Model):

    """

    普通课程

    """

    title = models.CharField(max_length=32)

    # 不生成表列，仅用于反向查找

    price_policy_list = GenericRelation("PricePolicy")

# 用于反向查找的特殊字段（一个课程可以对应多个价格策略），由于不能用xxx_set。

# 注意：GenericRelation("PricePolicy")要定义在一对多的‘一’处

# course = models.Course.objects.filter(id=1).first()

# price_policys = course.price_policy_list.all() # 反向查找出课程所有的价格策略

class DegreeCourse(models.Model):

    """

    学位课程

    """

    title = models.CharField(max_length=32)

    price_policy_list = GenericRelation("PricePolicy")

class PricePolicy(models.Model):

    """

    价格策略

    """

    price = models.IntegerField()

    period = models.IntegerField()

    # ContentType是django生成一张管理所有表的表，会自动将所有表的名称存进去进行管理

    content_type = models.ForeignKey(ContentType, verbose_name='关联的表')  #

    object_id = models.IntegerField(verbose_name='关联的表中的数据行的ID')

    # 帮助你快速实现带contenttype关联字段的表对象创建工作，不会数据库中生成列

    content_object = GenericForeignKey('content_type', 'object_id')

# 1. 为学位课“Python全栈”添加一个价格策略：一个月 9.9

"""

obj = DegreeCourse.objects.filter(title='Python全栈').first()

# obj.id

cobj = ContentType.objects.filter(model='course').first()

# cobj.id

PricePolicy.objects.create(price='9.9',period='30',content_type_id=cobj.id,object_id=obj.id)

"""

# 增加GenericForeignKey（"conten_type"，"object_id"）之后，会自动识别obj的表的名称，并将表在contenType中的id赋予GenericForeignKey第二个参数

# obj = DegreeCourse.objects.filter(title='Python全栈').first()

# PricePolicy.objects.create(price='9.9',period='30',content_object=obj)

try:

　　aricle = Article.objects.get(pk=id)

except Article.DoesNotExist:

　　return render(request,'failure.html',{'reason':'没有找到对应的文章'})

# 注：两种用法，可以做条件，也可以取值

　BookInfo.object.filter(heroinfo__hgender__exact = False)

#取值

v2 = models.Host.objects.filter(nid__gt=0).values('nid','hostname','b_id','b__caption')

v3 = models.Host.objects.filter(nid__gt=0).values_list('nid','hostname','b_id','b__caption')

a = CategoryInfo.objects.values('articleinfo')

# a = CategoryInfo.objects.filter(articleinfo=1) #可以看作articleinfo__id

ArticleInfo.objects.values('category__title') #即使是manytomany也行

# 附加where条件

Entry.objects.extra(where=['headline=%s'], params=['Lennon'])

# 先filter筛选出指定博客掉文章，再按指定年月过滤

article_list = modles.Article.objects.filter(blog=blog).extra(where=['strftime("%%Y-%%m",create_time)=%s'],params=[val,])

# 自定义一个“子查询”字段

Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])　

# 查询语句对比：

    models.UserInfo.objects.extra(

                        select={'newid':'select count(1) from app01_usertype where id>%s'},

                        select_params=[1,],

                        where = ['age>%s'],

                        params=[18,],

                        order_by=['-age'],

                        tables=['app01_usertype']

                    )

                    """

                    select

                        app01_userinfo.id,

                        (select count(1) from app01_usertype where id>1) as newid

                    from app01_userinfo,app01_usertype

                    where

                        app01_userinfo.age > 18

                    order by

                        app01_userinfo.age desc

                    """
    

TableInfo.objects.aggregate(c=Count('category_id')) 

from django.db.models import Sum, Count

Comment.objects.values(‘article’).annotate(comment_count=Count(‘article’)).order_by(‘-comment_count)。

# select count(article) as c from Evainfo group by aricle ordey by c

# annotate前面的value指定group by后面的字段，默认是以自己的id分组

# 注：comment_count是自定义查询字典的key

# 查询不同种类对应的书籍数目

CategoryInfo.objects.filter(blog_id=1).values(c=Count('articleinfo')).values('title', 'c')

 # 按日期归档

 archive_list = models.Article.objects.filter(user=user).extra(

  select={"archive_ym": "date_format(create_time,'%%Y-%%m')"}).values("archive_ym").annotate(c=Count("nid")).values("archive_ym", "c")

# 标签,种类归档

category_list = models.Category.objects.filter(blog=blog).annotate(c=Count("article")).values("title", "c")

 tag_list = models.Tag.objects.filter(blog=blog).annotate(c=Count("article")).values("title", "c")

# like查询

filter(sname__contains='黄') #也适用于整型等其他类型，并且要配合比较运算符使用 等同于select * from table where sname like "黄%" 

#字段排序

order_by('-price')   #支持多字段排序 order_by('id','-price','title') 

#判断查询集中是否有数据，返回bool值

exists() 

#返回查询集的总条数

count() 

# 去重

distinct()

# 排除指定条件，常用作不等于

exclude()

obj = Permission2Action.objects.filter().exclude(p__menu_isnull =True)

#根据字段排序，支持多字段排序

order_by('id','-price','title') 

# 附：查看执行的sql原生语句

#obj.query 

from django.http import Http404

try:

    product = Product.objects.get(pk=1)

except MyModel.DoesNotExist:

    raise Http404

from django.shortcuts import get_object_or_404

product = get_object_or_404(Product, pk=1) 

# 查询语句对比：

    models.UserInfo.objects.extra(

                        select={'newid':'select count(1) from app01_usertype where id>%s'},

                        select_params=[1,],

                        where = ['age>%s'],

                        params=[18,],

                        order_by=['-age'],

                        tables=['app01_usertype']

                    )

                    """

                    select

                        app01_userinfo.id,

                        (select count(1) from app01_usertype where id>1) as newid

                    from app01_userinfo,app01_usertype

                    where

                        app01_userinfo.age > 18

                    order by

                        app01_userinfo.age desc

                    """

     

Topic.objects.raw('select * form forum_topic')

# 异常，因为返回的结果没有包含主键

blog_article.objects.raw(‘select distinct date_format(r‘blog_article’.’date_publist’,’%Y-%m’) from blog_article’)

from django.db import connection, transaction

        cursor = connection.cursor()

    　　# cursor = connections['default'].cursor()

        # 数据修改操作——提交要求

        cursor.execute("UPDATE bar SET foo = 1 WHERE baz = %s", [self.baz])

        transaction.commit_unless_managed()

        # 数据检索操作,不需要提交

        cursor.execute("SELECT foo FROM bar WHERE baz = %s", [self.baz])

        row = cursor.fetchone()

from django.db.models import Q

Q(Q(account='fuck_man') & Q(status=0) | Q(birthday_lte=ctime))

# 多个Q对象组装复杂条件

q = Q()

q1 = Q()

q1.connector = 'AND'

q1.children.append('account', 'fuck_man')

q1.children.append('status', 0)

q1.children.append('birthday_lte', ctime)

q2 = Q()

q2.connector = 'AND'

q2.children.append('title', 'fuck')

q.add(q1, 'OR')

q.add(q2, 'OR')

from django.db.models.query import Q

queryset = UserInfo.objects.filter(~Q(name=""))

import operator

from django.db.models.query import Q

# 用户要查询的值

q = request.GET.get('q', '').strip()

# 可能的查询键值列表

key_list = ['title__contains', 'content__contains','author__name__contains']

# 实现Q(title__contains=q)|Q(content__contains=q)|Q(author__name__contains=q)

l = [Q(**{key:q}) for key in key_list]

#reduce相当于c++的accumulate，累加函数, operator.or_(x,y)是二进制的'或'操作， 从列表里将所有Q对象一起'或'起来，得到最终的结果

queryset = Entry.objects.filter(reduce(operator.or_, l)) 

models.Book.objects.filter(id__lt=F("price"))

models.Book.objects.filter(id__lt=F("price")/2)

models.Book.objects.all().update(price=F("price")+30) 

from django.core import serializers

ret = models.BookType.objects.all()

data = serializers.serialize("json", ret)

    import json

    #ret = models.BookType.objects.all().values('caption')

    ret = models.BookType.objects.all().values_list('caption')

    ret=list(ret)

    result = json.dumps(ret)

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)

class MyCustomManager(models.Manager):

    # 连接查询时也生效

    use_for_related_fields = True 

    def get_queryset(self):

        return super(MyCustomManager, self).get_queryset().filter(isDelete=False)

# 配置 use_for_related_fields = True，一定要写在外面。不知道是不是bug,一定要再类的外面的实例化

custom_manager = MyCustomManager()

class BaseModel(models.Model):

    create_time = models.DateTimeField(verbose_name='创建时间', auto_now=True)

    isDelete = models.BooleanField(verbose_name='是否已经删除', default=False)

    default_objects = models.Manager()  # objects = BaseManger会被覆盖

    objects = custom_manager

    class Meta:

        abstract = True

    def delete(self, using=None, keep_parents=False):

        """重写数据库删除方法实现逻辑删除"""

        self.isDelete = True

        self.save()

        print('isDelete = false')

row = Trouble.objects.filter(id=nid,status=1).update(**form.cleaned_data)

if not row:

    return HttpResponse('来晚一步，被人抢走了')

　　# 需要考虑多个用户抢同一个资源的问题,update返回的是数字，若返回是0，表示单子被抢走了。

else:

    return redirect('/backend/trouble-list.html')

# 查询,使用using函数，参数就是要查询的数据库

User.objects.using('user1').all()

# 保存或者更新,使用save的using参数，值就是要使用的数据库

my_object.save(using='user1')

#删除,使用delete的using参数

user_obj.delete(using='user1')

# 注意的是，模版的传入的参数都是为字符串，并且传参时都要带‘：’

    {{courses | length}} #集合的长度

    {{ time_obj|date:"Y-m-d H:i:s"}}  # 对传入转为日期时间格式

    {{ str_obj|truncatewords:"" }}  # 截取前三十个字符,无法截取中文

    {{str_obj| slice:""}} #截取中文

    {{ my_list|first|upper }}  # 把第一个字符大写

    {{ article.summary |default:'' }}   #这个可以保障模版不输出None，因为从数据库取出的值若没有则为None

    {{ name|lower }}  # 把传入值小写

   {{ article.date_publish | date:"Y-m-d" }}

　　{{html_str|safe}} #让html_str给浏览器解析，默认出于安全考虑不解析

　　{% autoescape off %} #批量转义

　　{{ course.detail }}

　　{% endautoescape %}

    注：还有另一种方式可以让浏览器解析，

    from django.utils.safestring import mark_safe

　　html_str=mark_safe(html_str)

        {% for row in v1 %}           # 假设3条数据

        {{ forloop.counter}}      # 依次为：1、2、3

        {{ forloop.counter0}}     # 依次为：0、1、2

        {{ forloop.revcounter}}   # 依次为：3、2、1

        {{ forloop.revcounter0}}  # 依次为：2、1、0

        {{ forloop.last }}        # 是否最后一个，是为True，其他False

        {{ forloop.first }}       # 是否第一个

        {{ forloop.parentloop }}  # 嵌套循环，表示上层循环的上面的六个值别是多少。

{% endfor %}    

from django import template

register = template.Library()

# 定义一个将日期中月份转换为大写的过滤器，如8转换为八

@register.filter

def month_to_upper(key):

    return ['一','二','三','四','五','六','七','八','九','十','十一','十二'][key]

# 使用,模版文件要load一下才能使用，filter是filter.py文件的文件名

{%load filter%}

<div class='month'>{{article.date_publish | month_to_upper}}</div> # article.date_publish会被当做month_to_upper的参数

{{ cls_verbose_name |test:app_name }} # 如果过滤器有参数时，一定要确定没有空格，即过滤器test后面一定要紧贴':'

# 配置

注意的是：一定要在指定App目录下建立templatetags目录，并且要在setting.py设置

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

                ],

                'libraries': {

                    'my_tags': 'web.templatetags.filter',  #my_tags为自定义键值, web.templatyetags.filter为路径

                }

            },

        },

# 可以接收多个参数

@register.simple_tag

def create_filter_str(order, q, filter_dict, field, value=''):

    d = copy.copy(filter_dict)

    remove_previous_field(d, field)

    d[field] = value

    order_str = 'order=%s' % order

    q_str = 'q=%s' % q

    filter_str = parse_filter_kwargs(d)

    return '?' + '&'.join([order_str, q_str, filter_str])

#调用

 <a href="{% create_filter_str args.order args.q args.filter data_dict.field %}">全部</a>

#或者{% create_filter_str args.order args.q args.filter data_dict.field as filter_str%}

{{filter_str}}

@register.inclusion_tag('web/sub/common_bar.html')

def get_common_bar(blog):

    tag_statistics = TagInfo.objects.filter(blog=blog). \

        annotate(article_count=Count('articleinfo')).values('id', 'article_count', 'title')

    category_statistics = CategoryInfo.objects.filter(blog=blog). \

        annotate(article_count=Count('articleinfo')).values('id', 'article_count', 'title')

    date_statistics = ArticleInfo.objects.filter(blog_id=1). \

        extra(select={'create_date': 'date_format(time,"%%Y-%%m")'}). \

        values('create_date').annotate(article_count=Count('id')).values('article_count', 'create_date')

    # 粉丝数

    fans_count = Star2Fans.objects.filter(star_user=blog.user).count()

    # 关注数

    star_count = Star2Fans.objects.filter(fans_user=blog.user).count()

    # 模版只会根据这个函数返回的上下文进行渲染

    return locals()

{% get_common_bar blog %}

# 原理就是url拼配成功后，截取剩下的路径去指定目录下查找

STATIC_URL = '/static/'

STATICFILES_DIRS = (

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

)

MEDIA_URL = '/uploads/'

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

# 注意：upload_to 设置的路径是相对于MEDIA_ROOT下创建

# 模板中引用静态文件

<link href ="{% static 'css/base.css' %}" rel="stylesheet"}

#配置能访问upload的文件

from django.views.static import serve

from django.conf import settings

urlpatterns = [

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

    url(r'^uploads/(?P<path>.*)$', serve, {'document_root': settings.MEDIA_ROOT}),

]

#配置在模版中使用{{MEDIA_URL}} 代表 ‘/uploads/'

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

                'django.template.context_processors.media',

            ],

BASE_LOG_DIR = os.path.join(BASE_DIR, "log")

LOGGING = {

    'version': 1,

    'disable_existing_loggers': False,

    'formatters': {

        'standard': {

            'format': '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]'

                      '[%(levelname)s][%(message)s]'

        },

        'simple': {

            'format': '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

        },

        'collect': {

            'format': '%(message)s'

        }

    },

    'filters': {

        'require_debug_true': {

            '()': 'django.utils.log.RequireDebugTrue',

        },

    },

    'handlers': {

        'console': {

            'level': 'DEBUG',

            'filters': ['require_debug_true'],  # 只有在Django debug为True时才在屏幕打印日志

            'class': 'logging.StreamHandler',

            'formatter': 'simple'

        },

        'SF': {

            'level': 'INFO',

            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件，根据文件大小自动切

            'filename': os.path.join(BASE_LOG_DIR, "xxx_info.log"),  # 日志文件

            'maxBytes': 1024 * 1024 * 50,  # 日志大小 50M

            'backupCount': 3,  # 备份数为3  xx.log --> xx.log.1 --> xx.log.2 --> xx.log.3

            'formatter': 'standard',

            'encoding': 'utf-8',

        },

        'TF': {

            'level': 'INFO',

            'class': 'logging.handlers.TimedRotatingFileHandler',  # 保存到文件，根据时间自动切

            'filename': os.path.join(BASE_LOG_DIR, "xxx_info.log"),  # 日志文件

            'backupCount': 3,  # 备份数为3  xx.log --> xx.log.2018-08-23_00-00-00 --> xx.log.2018-08-24_00-00-00 --> ...

            'when': 'D',  # 每天一切， 可选值有S/秒 M/分 H/小时 D/天 W0-W6/周(0=周一) midnight/如果没指定时间就默认在午夜

            'formatter': 'standard',

            'encoding': 'utf-8',

        },

        'error': {

            'level': 'ERROR',

            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件，自动切

            'filename': os.path.join(BASE_LOG_DIR, "xxx_err.log"),  # 日志文件

            'maxBytes': 1024 * 1024 * 5,  # 日志大小 50M

            'backupCount': 5,

            'formatter': 'standard',

            'encoding': 'utf-8',

        },

        'collect': {

            'level': 'INFO',

            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件，自动切

            'filename': os.path.join(BASE_LOG_DIR, "xxx_collect.log"),

            'maxBytes': 1024 * 1024 * 50,  # 日志大小 50M

            'backupCount': 5,

            'formatter': 'collect',

            'encoding': "utf-8"

        }

    },

    'loggers': {

        '': {  # 默认的logger应用如下配置

            'handlers': ['SF', 'console', 'error'],  # 上线之后可以把'console'移除

            'level': 'DEBUG',

            'propagate': True,

        },

        'collect': {  # 名为 'collect'的logger还单独处理

            'handlers': ['console', 'collect'],

            'level': 'INFO',

        }

    },

}

# 用户使用logging.getLogger([name])获取logger实例,如果没有名字，返回logger层级中的根logger（root logger）

# django名字的logger可能是默认终端的输出，未验证

logger = logging.getLogger(‘django’)

logger.info(“This is an error msg”)

LOGGING = {

    'version': 1,

    'disable_existing_loggers': False,

    'handlers': {

        'console':{

            'level':'DEBUG',

            'class':'logging.StreamHandler',

        },

    },

    'loggers': {

        'django.db.backends': {

            'handlers': ['console'],

            'propagate': True,

            'level':'DEBUG',

        },

    }

}

# 常用字段

# CharField

# IntegerField

# DeimalField

# DateField

# DateTimeField

# EmailField

# ChoiceField

# FileField

# RegexField

# GenericIPAddressField

from django import forms

from django.forms import fields

#forms的单选框

     auto = forms.CharField(

            label='一个月内自动登录',

            widget=widgets.CheckboxInput(attrs={'id': "auto", 'name': 'auto'}),

            required=False,

        )

    phone = fields.CharField(

        min_length=11,

        max_length=12,

        error_messages={'required': 'server:手机号码不能为空',

                        'min_length': 'server:号码必须为11位或者12位',

                        'max_length': 'server:号码必须为11位或者12位',

                        },

        validators=[RegexValidator(r'^1[0-9]{10,11}$', '手机号码格式错误'), ],

        label='电话号码',

        widget=widgets.TextInput(attrs={'name': 'phone', 'placeholder': "请输入手机号码", \

                                        'class': 'form-control', 'id': 'phone'}),

    )

    city = forms.ChoiceField(

        choices =models.CityInfo.objects.all().values_list('id','name'),

        # choices = [(1,"东莞"),(2,"广州"),(3,"深圳")],

        label = "城市",

        initial = 1,

        widget = forms.widgets.Select

        )


    #注意：以上的做法，当数据库更新时，不会实时更新。这时候需要自定义form的构造方法

    class MyForm(Form):

    user = fields.ChoiceField(

        # choices=((1, '上海'), (2, '北京'),),

        initial=2,

        widget=widgets.Select

    )

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

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

        # self.fields['user'].choices = ((1, '上海'), (2, '北京'),)

        self.fields['user'].choices = models.Classes.objects.all().values_list('id','caption')
    

#单一字段的验证，clean_xxx()

def clean_verify(self):

        user_verify_code = self.request.POST.get('verify', '').upper()

        verify_code = self.request.session.get('verify_code').upper()

        if user_verify_code != verify_code:

            raise ValidationError(message='验证码错误', code='invalid')

# 整体验证例子

def clean(self):

    value_dict = self.clean_data

    v1 = value_dict.get('username')

    v2 = value_dict.get('user_id')

    if v1!='root' and v2 !=1:

    raise ValidationError('整体错误信息')

return self.cleaned_data

# form.errors['username'] = ['用户名不存在或者密码错误', ]

form.add_error(field, error）

#form.fields['title'].widget.attr['readonly']=True

#form.fields['title'].widget.attr.update(['disabled':'true'})

form.fields['title'].disabled = True

form = UserForm(request.POST,request.FILE)

    if form.is_valid():

        form.cleaned_data #验证过的数据，字典形式，键是name属性

    else:

    # 错误数据，字典形式，键是name属性，不过它的__str__默认返回errors.as_ul()，也就是字符串。html的ul代码

        form.errors 

form = TroubleMaker(initial={'title':'标题1','detail':'XXXX'}) 

{'username:['错误信息1','错误信息2'],'password':['错误信息1,]}

{{ form.errors.username.0}}

{{ form.non_field_errors }}

from django.core.exceptions import ValidationError

def validate_even(value):

    if value % 2 != 0:

        raise ValidationError('%s is not an even number' % value)

from django.db import models

class MyModel(models.Model):

    even_field = models.IntegerField(validators=[validate_even])

from django import forms

class MyForm(forms.Form):

    even_field = forms.IntegerField(validators=[validate_even])

RegexValidator

class RegexValidator([regex=None, message=None, code=None, _inversematch=None, flags=0])[source]

regex

用于搜索提供的value的正则表达式，或者是预编译的正则表达式对象。通常在找不到匹配时抛出带有 message 和code的 ValidationError异常。这一标准行为可以通过设置inverse_match 为True来反转，这种情况下，如果找到匹配则抛出 ValidationError异常。通常它会匹配任何字符串（包括空字符串）。

message

验证失败时ValidationError所使用的错误信息。默认为"Enter a valid value"。

code

验证失败时ValidationError所使用的错误代码。默认为"invalid"。

inverse_match

New in Django 1.7.regex的匹配模式。默认为False。

flags

New in Django 1.7.编译正则表达式字符串regex时所用的标识。如果regex是预编译的正则表达式，并且覆写了flags，会产生TypeError异常。默认为 0

class UserCreationForm(forms.ModelForm):

    """A form for creating new users. Includes all the required

    fields, plus a repeated password."""

    password1 = forms.CharField(label='密码', widget=forms.PasswordInput(attrs={'class': 'form-control'}), \

                                max_length=32, min_length=8)

    password2 = forms.CharField(label='重复密码', widget=forms.PasswordInput(attrs={'class': 'form-control'}))

    class Meta:

        model = UserInfo

        fields = ('email', 'username')

        labels = {

            'username': '用户名',

            'email': '邮箱',

        }

        error_messages = {

            '__all__': {},

            'email': {

                'required': '邮箱不能为空',

                'invalid': '邮箱格式错误',

            },

            'username': {

                'required': '用户名不能为空',

                'invalid': '用户名格式错误..',

            }

        }

        widgets = {

            'username': widgets.TextInput(attrs={'class': 'form-control'}),

            'email': widgets.TextInput(attrs={'class': 'form-control'})

        }

    def clean_password2(self):

        # Check that the two password entries match

        password1 = self.cleaned_data.get("password1")

        password2 = self.cleaned_data.get("password2")

        if password1 and password2 and password1 != password2:

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

        return password2

    def save(self, commit=True):

        # Save the provided password in hashed format

        user = super(UserCreationForm, self).save(commit=False)

        user.set_password(self.cleaned_data["password1"])

        if commit:

            user.save()

        return user

 # instance参数表示和data参数共同融合

form = form_cls(instance=obj, data=request.POST)

if form.is_valid():

　　 obj = form.save() #存储对象，返回model对象

{%for field in form %}

{{ field.label }} # verbose_name

{{ field.name}} # modelinfo原始定义的字段名,例如price

{{ field }} # input组件

{{ field.errors.0 }} #错误信息

{%endfor%}

class FormClassFactory(object):

    @classmethod

    def from_admin(cls, admin):

        class Meta:

            model = admin.cls_info

            fields = '__all__'

            exclude = admin.readonly_fields

        def __new__(cls, *args, **kwargs):

            for field_name in cls.base_fields:

                field_obj = cls.base_fields[field_name]

                field_obj.widget.attrs.update({'class': 'form-control'})   # 传入组件属性

            return ModelForm.__new__(cls)

        form_cls = type('DynamicModelForm', (ModelForm,), {'Meta': Meta, '__new__': __new__})

        return form_cls

from django.core.cache import cache

is_had_read = cache.get(article_id)

if not is_had_read:

     article.read_num += 1

     article.save()

     cache.set(article_id, 1, 60 * 60 * 24 * 30) #一个月过期

import os

import django

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project_name.settings")  # project_name 改成你自己的项目名称

django.setup()

# 第一步在app的apps.py中

class AccountConfig(AppConfig):

    name = 'account'

    verbose_name = u'用户信息'  # 更改app的在admin中的显示 

# 第二步，在该app的__init__.py中

default_app_config = 'account.apps.AccountConfig'

 from django.apps import AppConfig

    class App01Config(AppConfig):

        name = 'app01'

        def ready(self):

            from django.utils.module_loading import autodiscover_modules

            # 在项目所有的目录下查找并调用aaaa.py文件

            autodiscover_modules("aaaa")

    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          # 创建数据库连接时，自动触发

            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)

        from 路径 import pizza_done

        pizza_done.send(sender='seven',toppings=123, size=456)

LANGUAGE_CODE = 'zh-hans'

TIME_ZONE = 'Asia/Shanghai'

USE_TZ = False # 防止django存储数据库时采用utc时间，而use_tz为false则表示使用本地时间

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

    # settings.py文件中配置，指明路径

        AUTHENTICATION_BACKENDS = (

            'users.views.CustomBackend',

        )

    from django.contrib.auth.backends import ModelBackend

    from django.db.models import Q

    class CustomBackend(ModelBackend):

        def authenticate(self, username=None, password=None, **kwargs):

            try:

                user = UserProfile.objects.get(Q(username=username)|Q(email=username))

                if user.check_password(password):

                    return user

            except Exception as e:

                return None

# Email settings smtp/pop3

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'

EMAIL_HOST = "smtp.163.com"  # smtp加上指定的域名

EMAIL_PORT = 25

EMAIL_HOST_USER = "jdecree@163.com"

EMAIL_HOST_PASSWORD = "xxxxx"  # 授权码

# EMAIL_USE_TLS = True

EMAIL_FROM = "jdecree@163.com"

class EmailHelper(object):

    def __init__(self):

        self.email_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

        self.email_from = settings.EMAIL_FROM  # 发送人

    def send_captcha(self, receive_email):

        """

        发送验证码

        """

        captcha_helper = CaptchaHelper()

        captcha = captcha_helper.create_and_save_captcha(email=receive_email)

        # 邮件发送参数

        email_title = '修仔科技'

        email_body = '%s' % (captcha,)

        status = send_mail(email_title, email_body, self.email_from, [self.email_from, receive_email])

        return status

    def set_user_activate_link(self):

        """

        发送注册后的激活邮件

        :return:

        """

        pass

    def send_password_reset_link(self):

        """

        发送密码重置链接

        :return:

        """

    def send_email_reset_link(self):

        """

        发送邮箱重置链接

        :return:

        """

# 附上邮箱model

class EmailVerifyRecord(models.Model):

    code = models.CharField(max_length=20, verbose_name=u"验证码")

    email = models.EmailField(max_length=50, verbose_name=u"邮箱")

    send_type = models.CharField(verbose_name=u"验证码类型",

                                 choices=(("register", u"注册"), ("forget", u"找回密码"), ("update_email", u"修改邮箱")),

                                 max_length=30)

    send_time = models.DateTimeField(verbose_name=u"发送时间", default=datetime.now)

    class Meta:

        verbose_name = u"邮箱验证码"

        verbose_name_plural = verbose_name

# 点击邮箱链接激活

# 通过随机字符串找出邮箱，再通过邮箱找出用户

class AciveUserView(View):

    def get(self, request, active_code):

        all_records = EmailVerifyRecord.objects.filter(code=active_code)

        if all_records:

            for record in all_records:

                email = record.email

                user = UserProfile.objects.get(email=email)

                user.is_active = True

                user.save()

        else:

            return render(request, "active_fail.html")

        return render(request, "login.html")

from django_redis import get_redis_connection

conn = get_redis_connection("default")

视图中链接并操作

# celery

# pip install redis==2.10.6

djcelery.setup_loader()

BROKER_BACKEND = 'redis'

BROKER_URL = 'redis://127.0.0.1:6379/0'

CELERY_RESULT_BACKEND = 'redis://127.0.0.1:6379/1'

# 设置路径让celery能找到tasks文件

CELERY_IMPORTS = ['web_chat.tasks', ]

# 设置时区

CELERY_TIMEZONE = TIME_ZONE

# 防止死锁

CELERYD_FORCE_EXECV = True

# 并发数

CELERYD_CONCURRENCY = 4

# 允许重试

CELERYD_ACKS_LATE = True

# 一个worker最多执行任务数

CELERYD_MAX_TASKS_PER_CHILD = 100

# 单个任务最大运行时间

CELERY_TASK_TIME_LIMIT = 60

class Meta:

    verbose_name = u"邮箱验证码"

    verbose_name_plural = verbose_name  #这个是复数形式的显示，默认会加个s

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

    if 'excel' in request.FILES:

        pass

    return super(CourseAdmin, self).post(request, args, kwargs)