import MySQLdbdef GetList(sql):db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')cursor = db.cursor()cursor.execute(sql)data = cursor.fetchall()db.close()return datadef GetSingle(sql):db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')cursor = db.cursor()cursor.execute(sql)data = cursor.fetchone()db.close()return data

    AutoField(Field)- int自增列，必须填入参数 primary_key=TrueBigAutoField(AutoField)- bigint自增列，必须填入参数 primary_key=True注：当model中如果没有自增列，则自动会创建一个列名为id的列from django.db import modelsclass UserInfo(models.Model):# 自动创建一个列名为id的且为自增的整数列username = models.CharField(max_length=32)class Group(models.Model):# 自定义自增列nid = models.AutoField(primary_key=True)name = models.CharField(max_length=32)SmallIntegerField(IntegerField):- 小整数 -32768 ～ 32767PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)- 正小整数 0 ～ 32767IntegerField(Field)- 整数列(有符号的) -2147483648 ～ 2147483647PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)- 正整数 0 ～ 2147483647BigIntegerField(IntegerField):- 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807自定义无符号整数字段class UnsignedIntegerField(models.IntegerField):def db_type(self, connection):return 'integer UNSIGNED'PS: 返回值为字段在数据库中的属性，Django字段默认的值为：'AutoField': 'integer AUTO_INCREMENT','BigAutoField': 'bigint AUTO_INCREMENT','BinaryField': 'longblob','BooleanField': 'bool','CharField': 'varchar(%(max_length)s)','CommaSeparatedIntegerField': 'varchar(%(max_length)s)','DateField': 'date','DateTimeField': 'datetime','DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)','DurationField': 'bigint','FileField': 'varchar(%(max_length)s)','FilePathField': 'varchar(%(max_length)s)','FloatField': 'double precision','IntegerField': 'integer','BigIntegerField': 'bigint','IPAddressField': 'char(15)','GenericIPAddressField': 'char(39)','NullBooleanField': 'bool','OneToOneField': 'integer','PositiveIntegerField': 'integer UNSIGNED','PositiveSmallIntegerField': 'smallint UNSIGNED','SlugField': 'varchar(%(max_length)s)','SmallIntegerField': 'smallint','TextField': 'longtext','TimeField': 'time','UUIDField': 'char(32)',BooleanField(Field)- 布尔值类型NullBooleanField(Field):- 可以为空的布尔值CharField(Field)- 字符类型- 必须提供max_length参数， max_length表示字符长度TextField(Field)- 文本类型EmailField(CharField)：- 字符串类型，Django Admin以及ModelForm中提供验证机制IPAddressField(Field)- 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制GenericIPAddressField(Field)- 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6- 参数：protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both"URLField(CharField)- 字符串类型，Django Admin以及ModelForm中提供验证 URLSlugField(CharField)- 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）CommaSeparatedIntegerField(CharField)- 字符串类型，格式必须为逗号分割的数字UUIDField(Field)- 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证FilePathField(Field)- 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能- 参数：path,                      文件夹路径match=None,                正则匹配recursive=False,           递归下面的文件夹allow_files=True,          允许文件allow_folders=False,       允许文件夹FileField(Field)- 字符串，路径保存在数据库，文件上传到指定目录- 参数：upload_to = ""      上传文件的保存路径storage = None      存储组件，默认django.core.files.storage.FileSystemStorageImageField(FileField)- 字符串，路径保存在数据库，文件上传到指定目录- 参数：upload_to = ""      上传文件的保存路径storage = None      存储组件，默认django.core.files.storage.FileSystemStoragewidth_field=None,   上传图片的高度保存的数据库字段名（字符串）height_field=None   上传图片的宽度保存的数据库字段名（字符串）DateTimeField(DateField)- 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]DateField(DateTimeCheckMixin, Field)- 日期格式      YYYY-MM-DDTimeField(DateTimeCheckMixin, Field)- 时间格式      HH:MM[:ss[.uuuuuu]]DurationField(Field)- 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型FloatField(Field)- 浮点型DecimalField(Field)- 10进制小数- 参数：max_digits，小数总长度decimal_places，小数位长度BinaryField(Field)- 二进制类型

    null                数据库中字段是否可以为空db_column           数据库中字段的列名db_tablespacedefault             数据库中字段的默认值primary_key         数据库中字段是否为主键db_index            数据库中字段是否可以建立索引unique              数据库中字段是否可以建立唯一索引unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引unique_for_month    数据库中字段【月】部分是否可以建立唯一索引unique_for_year     数据库中字段【年】部分是否可以建立唯一索引verbose_name        Admin中显示的字段名称blank               Admin中是否允许用户输入为空editable            Admin中是否可以编辑help_text           Admin中该字段的提示信息choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date如：{'null': "不能为空.", 'invalid': '格式错误'}validators          自定义错误验证（列表类型），从而定制想要的验证规则from django.core.validators import RegexValidatorfrom django.core.validators import EmailValidator,URLValidator,DecimalValidator,\MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator如：test = models.CharField(max_length=32,error_messages={'c1': '优先错信息1','c2': '优先错信息2','c3': '优先错信息3',},validators=[RegexValidator(regex='root_\d+', message='错误了', code='c1'),RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),EmailValidator(message='又错误了', code='c3'), ])

    class UserInfo(models.Model):nid = models.AutoField(primary_key=True)username = models.CharField(max_length=32)class Meta:# 数据库中生成的表名称 默认 app名称 + 下划线 + 类名db_table = "table_name"# 联合索引index_together = [("pub_date", "deadline"),]# 联合唯一索引unique_together = (("driver", "restaurant"),)# admin中显示的表名称
            verbose_name# verbose_name加s
            verbose_name_plural更多：https://docs.djangoproject.com/en/1.10/ref/models/options/

    1.触发Model中的验证和错误提示有两种方式：a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息b. 调用Model对象的 clean_fields 方法，如：# models.pyclass UserInfo(models.Model):nid = models.AutoField(primary_key=True)username = models.CharField(max_length=32)email = models.EmailField(error_messages={'invalid': '格式错了.'})# views.pydef index(request):obj = models.UserInfo(username='11234', email='uu')try:print(obj.clean_fields())except Exception as e:print(e)return HttpResponse('ok')# Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。2.Admin中修改错误提示# admin.pyfrom django.contrib import adminfrom model_club import modelsfrom django import formsclass UserInfoForm(forms.ModelForm):username = forms.CharField(error_messages={'required': '用户名不能为空.'})email = forms.EmailField(error_messages={'invalid': '邮箱格式错误.'})age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'})class Meta:model = models.UserInfo# fields = ('username',)fields = "__all__"class UserInfoAdmin(admin.ModelAdmin):form = UserInfoFormadmin.site.register(models.UserInfo, UserInfoAdmin)

    ForeignKey(ForeignObject) # ForeignObject(RelatedField)to,                         # 要进行关联的表名to_field=None,              # 要关联的表中的字段名称on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为- models.CASCADE，删除关联数据，与之关联也删除- models.DO_NOTHING，删除关联数据，引发错误IntegrityError- models.PROTECT，删除关联数据，引发错误ProtectedError- models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）- models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）- models.SET，删除关联数据，a. 与之关联的值设置为指定值，设置：models.SET(值)b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)def func():return 10class MyModel(models.Model):user = models.ForeignKey(to="User",to_field="id"on_delete=models.SET(func),)related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：# 如：- limit_choices_to={'nid__gt': 5}- limit_choices_to=lambda : {'nid__gt': 5}from django.db.models import Q- limit_choices_to=Q(nid__gt=10)- limit_choices_to=Q(nid=8) | Q(nid__gt=10)- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')db_constraint=True          # 是否在数据库中创建外键约束parent_link=False           # 在Admin中是否显示关联数据
OneToOneField(ForeignKey)to,                         # 要进行关联的表名to_field=None               # 要关联的表中的字段名称on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为###### 对于一对一 ####### 1. 一对一其实就是 一对多 + 唯一索引# 2.当两个类之间有继承关系时，默认会创建一个一对一字段# 如下会在A表中额外增加一个c_ptr_id列且唯一：class C(models.Model):nid = models.AutoField(primary_key=True)part = models.CharField(max_length=12)class A(C):id = models.AutoField(primary_key=True)code = models.CharField(max_length=1)ManyToManyField(RelatedField)to,                         # 要进行关联的表名related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：# 如：- limit_choices_to={'nid__gt': 5}- limit_choices_to=lambda : {'nid__gt': 5}from django.db.models import Q- limit_choices_to=Q(nid__gt=10)- limit_choices_to=Q(nid=8) | Q(nid__gt=10)- limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')symmetrical=None,           # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段# 做如下操作时，不同的symmetrical会有不同的可选字段
                                        models.BB.objects.filter(...)# 可选字段有：code, id, m1class BB(models.Model):code = models.CharField(max_length=12)m1 = models.ManyToManyField('self',symmetrical=True)# 可选字段有: bb, code, id, m1class BB(models.Model):code = models.CharField(max_length=12)m1 = models.ManyToManyField('self',symmetrical=False)through=None,               # 自定义第三张表时，使用字段用于指定关系表through_fields=None,        # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表from django.db import modelsclass Person(models.Model):name = models.CharField(max_length=50)class Group(models.Model):name = models.CharField(max_length=128)members = models.ManyToManyField(Person,through='Membership',through_fields=('group', 'person'),)class Membership(models.Model):group = models.ForeignKey(Group, on_delete=models.CASCADE)person = models.ForeignKey(Person, on_delete=models.CASCADE)inviter = models.ForeignKey(Person,on_delete=models.CASCADE,related_name="membership_invites",)invite_reason = models.CharField(max_length=64)db_constraint=True,         # 是否在数据库中创建外键约束db_table=None,              # 默认创建第三张表时，数据库中表的名称

    # 增#
    # models.Tb1.objects.create(c1='xx', c2='oo')  增加一条数据，可以接受字典类型数据 **kwargs# obj = models.Tb1(c1='xx', c2='oo')# obj.save()# 查#
    # models.Tb1.objects.get(id=123)         # 获取单条数据，不存在则报错（不建议）# models.Tb1.objects.all()               # 获取全部# models.Tb1.objects.filter(name='seven') # 获取指定条件的数据# 删#
    # models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据# 改# models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新，均支持 **kwargs# obj = models.Tb1.objects.get(id=1)# obj.c1 = '111'# obj.save()                                                 # 修改单条数据

        # 获取个数#
        # models.Tb1.objects.filter(name='seven').count()# 大于，小于#
        # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值# models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值# models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值# models.Tb1.objects.filter(id__lte=10)             # 获取id小于10的值# models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值# in#
        # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据# models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in# isnull# Entry.objects.filter(pub_date__isnull=True)# contains#
        # models.Tb1.objects.filter(name__contains="ven")# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感# models.Tb1.objects.exclude(name__icontains="ven")# range#
        # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and# 其他类似#
        # startswith，istartswith, endswith, iendswith,# order by#
        # models.Tb1.objects.filter(name='seven').order_by('id')    # asc# models.Tb1.objects.filter(name='seven').order_by('-id')   # desc# group by#
        # from django.db.models import Count, Min, Max, Sum# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"# limit 、offset#
        # models.Tb1.objects.all()[10:20]# regex正则匹配，iregex 不区分大小写#
        # Entry.objects.get(title__regex=r'^(An?|The) +')# Entry.objects.get(title__iregex=r'^(an?|the) +')# date#
        # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))# year#
        # Entry.objects.filter(pub_date__year=2005)# Entry.objects.filter(pub_date__year__gte=2005)# month#
        # Entry.objects.filter(pub_date__month=12)# Entry.objects.filter(pub_date__month__gte=6)# day#
        # Entry.objects.filter(pub_date__day=3)# Entry.objects.filter(pub_date__day__gte=3)# week_day#
        # Entry.objects.filter(pub_date__week_day=2)# Entry.objects.filter(pub_date__week_day__gte=2)# hour#
        # Event.objects.filter(timestamp__hour=23)# Event.objects.filter(time__hour=5)# Event.objects.filter(timestamp__hour__gte=12)# minute#
        # Event.objects.filter(timestamp__minute=29)# Event.objects.filter(time__minute=46)# Event.objects.filter(timestamp__minute__gte=29)# second#
        # Event.objects.filter(timestamp__second=31)# Event.objects.filter(time__second=2)# Event.objects.filter(timestamp__second__gte=31)

    # extra#
    # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)#    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))#    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])#    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])#    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])# F#
    # from django.db.models import F# models.Tb1.objects.update(num=F('num')+1)# Q#
    # 方式一：# Q(nid__gt=10)# Q(nid=8) | Q(nid__gt=10)# Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')# 方式二：# con = Q()# q1 = Q()# q1.connector = 'OR'# q1.children.append(('id', 1))# q1.children.append(('id', 10))# q1.children.append(('id', 9))# q2 = Q()# q2.connector = 'OR'# q2.children.append(('c1', 1))# q2.children.append(('c1', 10))# q2.children.append(('c1', 9))# con.add(q1, 'AND')# con.add(q2, 'AND')#
    # models.Tb1.objects.filter(con)# 执行原生SQL#
    # from django.db import connection, connections# cursor = connection.cursor()  # cursor = connections['default'].cursor()# cursor.execute("""SELECT * from auth_user where id = %s""", [1])# row = cursor.fetchone()

class UserProfile(models.Model):user_info = models.OneToOneField('UserInfo')username = models.CharField(max_length=64)password = models.CharField(max_length=64)def __unicode__(self):return self.usernameclass UserInfo(models.Model):user_type_choice = ((0, u'普通用户'),(1, u'高级用户'),)user_type = models.IntegerField(choices=user_type_choice)name = models.CharField(max_length=32)email = models.CharField(max_length=32)address = models.CharField(max_length=128)def __unicode__(self):return self.nameclass UserGroup(models.Model):caption = models.CharField(max_length=64)user_info = models.ManyToManyField('UserInfo')def __unicode__(self):return self.captionclass Host(models.Model):hostname = models.CharField(max_length=64)ip = models.GenericIPAddressField()user_group = models.ForeignKey('UserGroup')def __unicode__(self):return self.hostname

user_info_obj = models.UserInfo.objects.filter(id=1).first()
print user_info_obj.user_type
print user_info_obj.get_user_type_display()
print user_info_obj.userprofile.passworduser_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
print user_info_obj.keys()
print user_info_obj.values()

类似一对一
1、搜索条件使用 __ 连接
2、获取值时使用 .    连接

user_info_obj = models.UserInfo.objects.get(name=u'武沛齐')
user_info_objs = models.UserInfo.objects.all()group_obj = models.UserGroup.objects.get(caption='CEO')
group_objs = models.UserGroup.objects.all()# 添加数据
#group_obj.user_info.add(user_info_obj)
#group_obj.user_info.add(*user_info_objs)# 删除数据
#group_obj.user_info.remove(user_info_obj)
#group_obj.user_info.remove(*user_info_objs)# 添加数据
#user_info_obj.usergroup_set.add(group_obj)
#user_info_obj.usergroup_set.add(*group_objs)# 删除数据
#user_info_obj.usergroup_set.remove(group_obj)
#user_info_obj.usergroup_set.remove(*group_objs)# 获取数据
#print group_obj.user_info.all()
#print group_obj.user_info.all().filter(id=1)# 获取数据
#print user_info_obj.usergroup_set.all()
#print user_info_obj.usergroup_set.all().filter(caption='CEO')
#print user_info_obj.usergroup_set.all().filter(caption='DBA')

def upload_file(request):if request.method == "POST":obj = request.FILES.get('fafafa')f = open(obj.name, 'wb')for chunk in obj.chunks():f.write(chunk)f.close()return render(request, 'file.html')

class FileForm(forms.Form):ExcelFile = forms.FileField()

from django.db import modelsclass UploadFile(models.Model):userid = models.CharField(max_length = 30)file = models.FileField(upload_to = './upload/')date = models.DateTimeField(auto_now_add=True)

def UploadFile(request):uf = AssetForm.FileForm(request.POST,request.FILES)if uf.is_valid():upload = models.UploadFile()upload.userid = 1upload.file = uf.cleaned_data['ExcelFile']upload.save()print upload.file

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re
from django import forms
from django.core.exceptions import ValidationErrordef 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'邮箱'}))

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_dictret['status'] = Trueelse:error_msg = request_form.errors.as_json()ret['error'] = json.loads(error_msg)return HttpResponse(json.dumps(ret))

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

from django.shortcuts import render
from django.core.paginator import Paginator, EmptyPage, PageNotAnIntegerL = []
for i in range(999):L.append(i)def index(request):current_page = request.GET.get('p')paginator = Paginator(L, 10)# per_page: 每页显示条目数量# count:    数据总个数# num_pages:总页数# page_range:总页数的索引范围，如: (1,10),(1,200)# page:     page对象try:posts = paginator.page(current_page)# has_next              是否有下一页# next_page_number      下一页页码# has_previous          是否有上一页# previous_page_number  上一页页码# object_list           分页之后的数据列表# number                当前页# paginator             paginator对象except PageNotAnInteger:posts = paginator.page(1)except EmptyPage:posts = paginator.page(paginator.num_pages)return render(request, 'index.html', {'posts': posts})

<!DOCTYPE html>
<html>
<head lang="en"><meta charset="UTF-8"><title></title>
</head>
<body>
<ul>{% for item in posts %}<li>{{ item }}</li>{% endfor %}
</ul><div class="pagination"><span class="step-links">{% if posts.has_previous %}<a href="?p={{ posts.previous_page_number }}">Previous</a>{% endif %}<span class="current">Page {{ posts.number }} of {{ posts.paginator.num_pages }}.</span>{% if posts.has_next %}<a href="?p={{ posts.next_page_number }}">Next</a>{% endif %}</span></div>
</body>
</html>

from django.shortcuts import render
from django.core.paginator import Paginator, EmptyPage, PageNotAnIntegerclass CustomPaginator(Paginator):def __init__(self, current_page, max_pager_num, *args, **kwargs):""":param current_page: 当前页:param max_pager_num:最多显示的页码个数:param args::param kwargs::return:"""self.current_page = int(current_page)self.max_pager_num = max_pager_numsuper(CustomPaginator, self).__init__(*args, **kwargs)def page_num_range(self):# 当前页面# self.current_page# 总页数# self.num_pages# 最多显示的页码个数# self.max_pager_numprint(1)if self.num_pages < self.max_pager_num:return range(1, self.num_pages + 1)print(2)part = int(self.max_pager_num / 2)if self.current_page - part < 1:return range(1, self.max_pager_num + 1)print(3)if self.current_page + part > self.num_pages:return range(self.num_pages + 1 - self.max_pager_num, self.num_pages + 1)print(4)return range(self.current_page - part, self.current_page + part + 1)L = []
for i in range(999):L.append(i)def index(request):current_page = request.GET.get('p')paginator = CustomPaginator(current_page, 11, L, 10)# per_page: 每页显示条目数量# count:    数据总个数# num_pages:总页数# page_range:总页数的索引范围，如: (1,10),(1,200)# page:     page对象try:posts = paginator.page(current_page)# has_next              是否有下一页# next_page_number      下一页页码# has_previous          是否有上一页# previous_page_number  上一页页码# object_list           分页之后的数据列表# number                当前页# paginator             paginator对象except PageNotAnInteger:posts = paginator.page(1)except EmptyPage:posts = paginator.page(paginator.num_pages)return render(request, 'index.html', {'posts': posts})

<!DOCTYPE html>
<html>
<head lang="en"><meta charset="UTF-8"><title></title>
</head>
<body><ul>{% for item in posts %}<li>{{ item }}</li>{% endfor %}
</ul><div class="pagination">
<span class="step-links">
{% if posts.has_previous %}<a href="?p={{ posts.previous_page_number }}">Previous</a>
{% endif %}{% for i in posts.paginator.page_num_range %}<a href="?p={{ i }}">{{ i }}</a>{% endfor %}{% if posts.has_next %}<a href="?p={{ posts.next_page_number }}">Next</a>{% endif %}
</span><span class="current">
Page {{ posts.number }} of {{ posts.paginator.num_pages }}.
</span></div>
</body>
</html>

#!/usr/bin/env python
# _*_coding:utf-8_*_
from django.utils.safestring import mark_safeclass PageInfo(object):def __init__(self,current,totalItem,peritems=5):self.__current=currentself.__peritems=peritemsself.__totalItem=totalItemdef From(self):return (self.__current-1)*self.__peritemsdef To(self):return self.__current*self.__peritemsdef TotalPage(self):  #总页数result=divmod(self.__totalItem,self.__peritems)if result[1]==0:return result[0]else:return result[0]+1def Custompager(baseurl,currentPage,totalpage):  #基础页，当前页，总页数perPager=11#总页数<11#0 -- totalpage#总页数>11#当前页大于5 currentPage-5 -- currentPage+5#currentPage+5是否超过总页数,超过总页数，end就是总页数#当前页小于5 0 -- 11begin=0end=0if totalpage <= 11:begin=0end=totalpageelse:if currentPage>5:begin=currentPage-5end=currentPage+5if end > totalpage:end=totalpageelse:begin=0end=11pager_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语言

    # 此为开始调试用，实际内部不做任何操作# 配置：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】）
            }}# 自定义keydef default_key_func(key, key_prefix, version):"""Default function to generate keys.Constructs the key used by all other methods. By default it prependsthe `key_prefix'. KEY_FUNCTION can be used to specify an alternatefunction 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_funcelse:return import_string(key_func)return default_key_func

    # 此缓存将内容保存至内存的变量中# 配置：CACHES = {'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache','LOCATION': 'unique-snowflake',}}# 注：其他配置同开发调试版本

    # 此缓存将内容保存至文件# 配置：
CACHES = {'default': {'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache','LOCATION': '/var/tmp/django_cache',}}# 注：其他配置同开发调试版本

    # 此缓存将内容保存至数据库# 配置：CACHES = {'default': {'BACKEND': 'django.core.cache.backends.db.DatabaseCache','LOCATION': 'my_cache_table', # 数据库表
            }}# 注：执行创建表命令 python manage.py createcachetable

# 此缓存使用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',]}}

    # 此缓存使用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',]}}

CACHES = {"default": {"BACKEND": "django_redis.cache.RedisCache","LOCATION": "redis://127.0.0.1:6379","OPTIONS": {"CLIENT_CLASS": "django_redis.client.DefaultClient","CONNECTION_POOL_KWARGS": {"max_connections": 100}# "PASSWORD": "密码",
        }}
}

from django_redis import get_redis_connection
conn = get_redis_connection("default")

   使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存MIDDLEWARE = ['django.middleware.cache.UpdateCacheMiddleware',# 其他中间件...'django.middleware.cache.FetchFromCacheMiddleware',]CACHE_MIDDLEWARE_ALIAS = ""CACHE_MIDDLEWARE_SECONDS = ""CACHE_MIDDLEWARE_KEY_PREFIX = ""

    方式一：from django.views.decorators.cache import cache_page@cache_page(60 * 15)def my_view(request):...方式二：from django.views.decorators.cache import cache_pageurlpatterns = [url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),]

    a. 引入TemplateTag{% load cache %}b. 使用缓存{% cache 5000 缓存key %}缓存内容{% endcache %}

    from django.core.signals import request_finishedfrom django.core.signals import request_startedfrom django.core.signals import got_request_exceptionfrom django.db.models.signals import class_preparedfrom django.db.models.signals import pre_init, post_initfrom django.db.models.signals import pre_save, post_savefrom django.db.models.signals import pre_delete, post_deletefrom django.db.models.signals import m2m_changedfrom django.db.models.signals import pre_migrate, post_migratefrom django.test.signals import setting_changedfrom django.test.signals import template_renderedfrom django.db.backends.signals import connection_createddef callback(sender, **kwargs):print("xxoo_callback")print(sender,kwargs)xxoo.connect(callback)# xxoo指上述导入的内容

from django.core.signals import request_finished
from django.dispatch import receiver@receiver(request_finished)
def my_callback(sender, **kwargs):print("Request finished!")