java web框架 django_Web框架Django（二）

最新推荐文章于 2023-02-10 14:46:28 发布

weixin_39647734

最新推荐文章于 2023-02-10 14:46:28 发布

阅读量352

点赞数

文章标签： java web框架 django

本文链接：https://blog.csdn.net/weixin_39647734/article/details/114509467

版权

一、Model

到目前为止，当我们的程序涉及到数据库相关操作时，我们一般都会这么搞：

创建数据库，设计表结构和字段

使用 MySQLdb 来连接数据库，并编写数据访问层代码

业务逻辑层去调用数据访问层执行数据库操作

importMySQLdbdefGetList(sql):

db= MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')

cursor=db.cursor()

cursor.execute(sql)

data=cursor.fetchall()

db.close()returndatadefGetSingle(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

View Code

django为使用一种新的方式，即：关系对象映射(Object Relational Mapping，简称ORM)。

PHP：activerecord

Java：Hibernate

C#：Entity Framework

django中遵循 Code Frist 的原则，即：根据代码中定义的类来自动生成数据库表。

1、创建表

1.1 基本结构

from django.db import models

class userinfo(models.Model):

name = models.CharField(max_length=30)

email = models.EmailField()

memo = models.TextField()

1.1.1 字段

AutoField(Field)- int自增列，必须填入参数 primary_key=True

BigAutoField(AutoField)- bigint自增列，必须填入参数 primary_key=True

注：当model中如果没有自增列，则自动会创建一个列名为id的列from django.db importmodelsclassUserInfo(models.Model):#自动创建一个列名为id的且为自增的整数列

username = models.CharField(max_length=32)classGroup(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自定义无符号整数字段classUnsignedIntegerField(models.IntegerField):defdb_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中提供验证 URL

SlugField(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.FileSystemStorage

ImageField(FileField)-字符串，路径保存在数据库，文件上传到指定目录-参数：

upload_to= ""上传文件的保存路径

storage=None 存储组件，默认django.core.files.storage.FileSystemStorage

width_field=None, 上传图片的高度保存的数据库字段名(字符串)

height_field=None 上传图片的宽度保存的数据库字段名(字符串)

DateTimeField(DateField)- 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

DateField(DateTimeCheckMixin, Field)- 日期格式 YYYY-MM-DD

TimeField(DateTimeCheckMixin, Field)-时间格式 HH:MM[:ss[.uuuuuu]]

DurationField(Field)-长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

FloatField(Field)-浮点型

DecimalField(Field)-10进制小数-参数：

max_digits，小数总长度

decimal_places，小数位长度

BinaryField(Field)- 二进制类型

View Code

1.1.2参数

null 数据库中字段是否可以为空

db_column 数据库中字段的列名

db_tablespace

default 数据库中字段的默认值

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

如：{'null': "不能为空.", 'invalid': '格式错误'}

validators 自定义错误验证(列表类型)，从而定制想要的验证规则from django.core.validators importRegexValidatorfrom django.core.validators importEmailValidator,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'), ]

)

View Code

1.1.3元信息

classUserInfo(models.Model):

nid= models.AutoField(primary_key=True)

username= models.CharField(max_length=32)classMeta:#数据库中生成的表名称默认 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/

View Code

1.1.4拓展知识

1.触发Model中的验证和错误提示有两种方式：

a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息

b. 调用Model对象的 clean_fields 方法，如：#models.py

classUserInfo(models.Model):

nid= models.AutoField(primary_key=True)

username= models.CharField(max_length=32)

email= models.EmailField(error_messages={'invalid': '格式错了.'})#views.py

defindex(request):

obj= models.UserInfo(username='11234', email='uu')try:print(obj.clean_fields())exceptException as e:print(e)return HttpResponse('ok')#Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。

2.Admin中修改错误提示#admin.py

from django.contrib importadminfrom model_club importmodelsfrom django importformsclassUserInfoForm(forms.ModelForm):

username= forms.CharField(error_messages={'required': '用户名不能为空.'})

email= forms.EmailField(error_messages={'invalid': '邮箱格式错误.'})

age= forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'})classMeta:

model=models.UserInfo#fields = ('username',)

fields = "__all__"

classUserInfoAdmin(admin.ModelAdmin):

form=UserInfoForm

admin.site.register(models.UserInfo, UserInfoAdmin)

View Code

1.2、连表结构

一对多：models.ForeignKey(其他表)

多对多：models.ManyToManyField(其他表)

一对一：models.OneToOneField(其他表)

应用场景：

一对多：当一张表中创建一行数据时，有一个单选的下拉框(可以被重复选择)

例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。

多对多：在某表中创建一行数据是，有一个可以多选的下拉框

例如：创建用户信息，需要为用户指定多个爱好

一对一：在某表中创建一行数据时，有一个单选的下拉框(下拉框中的内容被用过一次就消失了

例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据

字段以及参数

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(可执行对象)deffunc():return 10

classMyModel(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 importQ- 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列且唯一：

classC(models.Model):

nid= models.AutoField(primary_key=True)

part= models.CharField(max_length=12)classA(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中显示关联数据时，提供的条件：

#如：

symmetrical=None, #仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段

#做如下操作时，不同的symmetrical会有不同的可选字段

models.BB.objects.filter(...)#可选字段有：code, id, m1

classBB(models.Model):

code= models.CharField(max_length=12)

m1= models.ManyToManyField('self',symmetrical=True)#可选字段有: bb, code, id, m1

classBB(models.Model):

code= models.CharField(max_length=12)

m1= models.ManyToManyField('self',symmetrical=False)

through=None, #自定义第三张表时，使用字段用于指定关系表

through_fields=None, #自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表

from django.db importmodelsclassPerson(models.Model):

name= models.CharField(max_length=50)classGroup(models.Model):

name= models.CharField(max_length=128)

members=models.ManyToManyField(

Person,

through='Membership',

through_fields=('group', 'person'),

)classMembership(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, #默认创建第三张表时，数据库中表的名称

View Code

2、操作表

2.1、基本操作

基本操作

#增

#models.User_type.objects.create(title="黑金用户")#方法二，比较少用

#obj = models.User_type(title="小白用户")

#obj.save()

#删#models.User_type.objects.filter(title="小白用户").delete() # 删除指定条件的数据

#改

#models.User_type.objects.filter(title="黑金用户").update(title="黑卡用户") # 修改指定条件的数据#方法二，比较少用

#obj = models.Tb1.objects.get(id=1) # obj.c1 = '111'

#obj.save() # 修改单条数据

#查#models.User_type.objects.get(title="大白用户") # 获取单条数据，不存在则报错(不建议)#models.User_type.objects.all() # 获取全部#models.User_type.objects.filter(title="小白用户") # 获取指定条件的数据#models.User_type.objects.exclude(title="黄金用户") # 排除指定条件的数据

基本增删改查

2.2、进阶操作(了不起的双下划线)

利用双下划线将字段和对应的操作连接起来

进阶操作

#获取个数#

#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 #后面出现filter代表having

from django.db.models importCount#models.User_info.objects.values("name","age").annotate() #没有起作用#SELECT "app01_user_info"."name", "app01_user_info"."age" FROM "app01_user_info"

#models.User_info.objects.values("age").annotate(xxx=Count("age"))#SELECT "app01_user_info"."age", COUNT("app01_user_info"."age") AS "xxx" FROM "app01_user_info" GROUP BY "app01_user_info"."age"

#models.User_info.objects.values("age").annotate(xxx=Count("age")).filter(xxx__gt=2) #年龄相同次数大于2的查出来#SELECT "app01_user_info"."age", COUNT("app01_user_info"."age") AS "xxx" FROM "app01_user_info" GROUP BY "app01_user_info"."age" HAVING COUNT("app01_user_info"."age") > 2

#注意两次filter 第一次代表where 第二次代表having#models.User_info.objects.filter(id__gt=2).values("age").annotate(xxx=Count("age")).filter(xxx__gt=2)#SELECT "app01_user_info"."age", COUNT("app01_user_info"."age") AS "xxx" FROM "app01_user_info" WHERE "app01_user_info"."id" > 2 GROUP BY "app01_user_info"."age" HAVING COUNT("app01_user_info"."age") > 2

#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)

View Code

2.3、其他操作

F、Q

#from django.db.models import F#models.User_info.objects.all().update(age=F("age")+5) # age列加5

#方式一：#Q(nid__gt=10)#Q(nid=8) | Q(nid__gt=10)#Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')

#-------------------------------以下三种查找方式相同效果

#obj = models.User_info.objects.filter(id=307,name="egon")

#condition ={#'id':307,#'name':'egon',#}#obj = models.User_info.objects.filter(**condition)

#obj = models.User_info.objects.filter(Q(id=307) & Q(name="egon"))

---------------------------------

#方式二：

#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))

#q3 = Q()#q3.connector = 'AND'#q3.children.append(('id', 1))#q3.children.append(('id', 2))#q1.add(q3, 'OR')

#con = Q()#con.add(q1, 'AND')#con.add(q2, 'AND')

#(id=1 or id=10 or id=9 or (id=1 and id=2)) and (c1=1 or c1=10 or c1=9) #等于上面

#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()

#Q演示

condition_dict ={'k1':[1,2,3,4],'k2':[1,],'k3':[11,]

}

con=Q()for k,v incondition_dict.items():

q=Q()

q.connector= 'OR'

for i inv:

q.children.append(('id',1))

con.add(q,'AND')

models.User_info.objects.filter(con)

View Code

extra

#extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)

#a. 映射

select

select_params=None

select 此处from表#b. 条件

where=None

params=None

select* from表 where 此处#c. 表

table

select* from表,此处#d. 排序

prder_by=None

select* from表 order by 此处

result=models.User_info.objects.extra(

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

select_params=[1,],

where= ["age>%s"],

params=[18,],

order_by=["-age"],

tables=["app01_usertype"]

)

SELECT

(selet count(1) from app01_usertype where id>1) AS "newid","app01_user_info"."id","app01_user_info"."name","app01_user_info"."age","app01_user_info"."ut_id"FROM"app01_user_info" , "app01_usertype"WHERE (age>18)

ORDER BY"app01_user_info"."age"DESC#-------------------------------------

v=models.User_info.objects.all().extra(

select={'n':"select count(1) from app01_user_type where uid >2"}

)

SELECT

(select count(1) from app01_user_type where uid >2) AS "n","app01_user_info"."id","app01_user_info"."name","app01_user_info"."age","app01_user_info"."ut_id"FROM"app01_user_info"

#-------------------------------------

v=models.User_info.objects.all().extra(

select={'n':"select count(1) from app01_user_type where uid=%s or uid=%s"},

select_params=[1,3]

)

SELECT

(select count(1) from app01_user_type where uid=1 or uid=3) AS "n","app01_user_info"."id","app01_user_info"."name","app01_user_info"."age","app01_user_info"."ut_id"FROM"app01_user_info"

#------------- select_params ------------------------

v=models.User_info.objects.all().extra(

select={'m':"select count(1) from app01_user_type where uid=%s or uid=%s",'n':"select count(1) from app01_user_type where uid=%s or uid=%s",

},select_params=[1,2,3,4])

SELECT

(select count(1) from app01_user_type where uid=1 or uid=2) AS "m",

(select count(1) from app01_user_type where uid=3 or uid=4) AS "n","app01_user_info"."id","app01_user_info"."name","app01_user_info"."age","app01_user_info"."ut_id"FROM"app01_user_info"

#-------------- where -----------------------

v=models.User_info.objects.extra(

where=["id=%s or id=%s","name=%s"],

params=[1,307,"egon"]

)

SELECT"app01_user_info"."id","app01_user_info"."name","app01_user_info"."age","app01_user_info"."ut_id"FROM"app01_user_info" WHERE (id=1 or id=307) AND (name=egon)#-------------- table -----------------------

#笛卡尔积

#示例一：

result =models.User_info.objects.extra(

tables=["app01_user_type"],

)

SELECT"app01_user_info"."id","app01_user_info"."name","app01_user_info"."age","app01_user_info"."ut_id"FROM"app01_user_info" , "app01_user_type"

#示例二:

result=models.User_info.objects.extra(

tables=["app01_user_type"],

where=["app01_usertype.id = app01_userinfo.ut_id"]

)

SELECT"app01_user_info"."id","app01_user_info"."name","app01_user_info"."age","app01_user_info"."ut_id"FROM"app01_user_info" , "app01_user_type"WHERE (app01_usertype.id= app01_userinfo.ut_id)

View Code

示例：

a、一对多ForeignKey联表操作

from django.db importmodelsclassUserType(models.Model):

title= models.CharField(max_length=32)classUserInfo(models.Model):

name= models.CharField(max_length=16)

age=models.IntegerField()

ut= models.ForeignKey('UserType')

models.py

models.UserType.objects.create(title='普通用户')

models.UserType.objects.create(title='二逼用户')

models.UserType.objects.create(title='牛逼用户')

models.UserInfo.objects.create(name='方少伟',age=18,ut_id=1)

models.UserInfo.objects.create(name='由秦兵',age=18,ut_id=2)

models.UserInfo.objects.create(name='刘庚',age=18,ut_id=2)

models.UserInfo.objects.create(name='陈涛',age=18,ut_id=3)

models.UserInfo.objects.create(name='王者',age=18,ut_id=3)

models.UserInfo.objects.create(name='杨涵',age=18,ut_id=1)#正向操作

obj =models.UserInfo.objects.all().first()print(obj.name, obj.age, obj.ut.title)#反向操作 obj.表名小写_set.all()

obj =models.UserType.objects.all().first()for row inobj.user_info_set.all():print(row.name, row.age)#obj.表名小写_set.filter()

result =models.UserType.objects.all()for item inresult:print(item.title, item.user_info_set.all())print(item.user_info_set.filter(name="方少伟"))#字典格式values

result = models.UserInfo.objects.all().values("id", "name")for row inresult:print(row)#字典格式正向跨表

result = models.UserInfo.objects.all().values("id", "name", "ut__title")for row inresult:print(row["id"], row["name"], row["ut__title"])#字典格式反向跨表

result = models.UserType.objects.values('id', 'title', 'userinfo__name','userinfo__age')for row inresult:print(row["id"], row["name"], row["userinfo__name"],row["userinfo__age"])#元组格式values_list

result = models.UserInfo.objects.all().values_list("id","name")for row inresult:print(row)#元组格式正向跨表

result = models.UserInfo.objects.all().values_list("id", "name","ut__title")for row inresult:print(row)#元组格式反向跨表

result = models.UserType.objects.all().values_list('id', 'title', 'userinfo__name','userinfo__age')for row inresult:print(row)#查询时过滤正向跨表

models.UserInfo.objects.filter(ut__title='超级用户').values('id', 'name', 'ut__title')#查询时过滤正向跨表？？？？？？？？？？？？？？？？？？？？？？？？？？

######models.UserType.objects.filter(userinfo__title='超级用户').values('id', 'name', 'userinfo__title')

views.py

b、多对多操作

方式一：通过外键创建第三张表

classBoy(models.Model):

name= models.CharField(max_length=32)classGirl(models.Model):

nick= models.CharField(max_length=32)classLove(models.Model):

b= models.ForeignKey("Boy")

g= models.ForeignKey("Girl")classMeta:

unique_together=[

("b","g"),

]

View Code

SQL演示

#表里插入数据

objs=[

models.Boy(name='方少伟'),

models.Boy(name='游勤斌'),

models.Boy(name='于浩'),

models.Boy(name='陈涛'),

]

models.Boy.objects.bulk_create(objs,4)

result=[

models.Girl(nick='于浩姐姐'),

models.Girl(nick='景甜'),

models.Girl(nick='刘亦非'),

models.Girl(nick='苍老师'),

]

models.Girl.objects.bulk_create(result,4)

models.Love.objects.create(b_id=1,g_id=1)

models.Love.objects.create(b_id=1,g_id=2)

models.Love.objects.create(b_id=1,g_id=3)

models.Love.objects.create(b_id=2,g_id=4)################### 查找和我有关系的女孩四种方式 ################

obj= models.Boy.objects.filter(name="方少伟").first()

love_list=obj.love_set.all()for row inlove_list:print(row.g.nick)

love_list= models.Love.objects.filter(b__name="方少伟")for row inlove_list:print(row.g.nick)#下面两个效果好

love_list= models.Love.objects.filter(b__name="方少伟").values("g__nick")for item inlove_list:print(item["g__nick"])

love_list= models.Love.objects.filter(b__name="方少伟").select_related("g")for obj inlove_list:print(obj.g.nick)

View Code

方式二：通过 ManyToManyField 创建第三张表

classBoy(models.Model):

name= models.CharField(max_length=32)

m= models.ManyToManyField("Girl")classGirl(models.Model):

nick= models.CharField(max_length=32)

View Code

SQL 演示

obj = models.Boy.objects.filter(name="方少伟").first()#print(obj.id,obj.name)

#obj.m.add(2)

#obj.m.add(1,3)

#obj.m.add(*[4,])

#obj.m.remove(2)

#obj.m.remove(1,3)

#obj.m.remove(*[4,])

#obj.m.set([1,4,])

#girl_list = obj.m.all()

#girl_list = obj.m.filter(nick="苍老师")

#obj.m.clear()

obj= models.Girl.objects.filter(nick="苍老师").first()

v= obj.boy_set.all()

View Code

方式三：通过外键和 ManyToManyField 创建

classBoy(models.Model):

name= models.CharField(max_length=32)

m= models.ManyToManyField("Girl",through="Love",through_fields=("b","g",))classGirl(models.Model):

nick= models.CharField(max_length=32)classLove(models.Model):

b= models.ForeignKey("Boy")

g= models.ForeignKey("Girl")classMeta:

unique_together=[

("b","g"),

]

View Code

SQL 操作

obj = models.Boy.objects.filter(name="方少伟").first()#只可以查或清空

obj.m.clear()

obj.m.all()

View Code

c. 关联

1. 方式一：

ForeignKey 关联两个表

classUserInfo(models.Model):

nickname= models.CharField(max_length=32)

username= models.CharField(max_length=32)

password= models.CharField(max_length=64)

gender_choices=(

(1,'男'),

(2,'女'),

)

gender= models.IntegerField(choices=gender_choices)#obj对象男.a.all() 反向查找#obj对象女.b.all() 反向查找

classU2U(models.Model):

b= models.ForeignKey("UserInfo",related_name="a")

g= models.ForeignKey("UserInfo",related_name="b")#obj对象男.a_set.all() 反向查找#obj对象女.b_set.all() 反向查找#class U2U(models.Model):#b = models.ForeignKey("UserInfo",related_query_name="a")#g = models.ForeignKey("UserInfo",related_query_name="b")

View Code

插入性别两种方式

#models.U2U.objects.create(b_id=2,g_id=5)#models.U2U.objects.create(b_id=2,g_id=4)#models.U2U.objects.create(b_id=2,g_id=6)

#这种方式也是插入的ID#boy = models.UserInfo.objects.filter(gender=1,id=2).first()#girl = models.UserInfo.objects.filter(gender=2,id=5).first()#models.U2U.objects.create(b_id=boy,g_id=girl)

View Code

查找数据

two = models.UserInfo.objects.filter(id=2).first()

result=two.girls.all()for u inresult:print(u.g.nickname)

View Code

方式二：

classUserInfo(models.Model):

nickname= models.CharField(max_length=32)

username= models.CharField(max_length=32)

password= models.CharField(max_length=64)

gender_choices=(

(1,'男'),

(2,'女'),

)

gender= models.IntegerField(choices=gender_choices)

m= models.ManyToManyField("UserInfo")#--------------------------------------------

#男生查女生

#xz.m 用的第二张表的第一列

xz = models.UserInfo.objects.filter(id=1).first()

u=xz.m.all()for row inu:print(row.nickname)#女生查男生

#xz.userinfo_set 用的第二张表的第二列

xz = models.UserInfo.objects.filter(id=4).first()

v=xz.userinfo_set.all()for row inv:print(row.nickname)

View Code

2.4、连表操作(了不起的双下划线)

利用双下划线和 _set 将表之间的操作连接起来

表结构实例

classUserProfile(models.Model):

user_info= models.OneToOneField('UserInfo')

username= models.CharField(max_length=64)

password= models.CharField(max_length=64)def __unicode__(self):returnself.usernameclassUserInfo(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):returnself.nameclassUserGroup(models.Model):

caption= models.CharField(max_length=64)

user_info= models.ManyToManyField('UserInfo')def __unicode__(self):returnself.captionclassHost(models.Model):

hostname= models.CharField(max_length=64)

ip=models.GenericIPAddressField()

user_group= models.ForeignKey('UserGroup')def __unicode__(self):return self.hostname

View Code

一对一操作

user_info_obj = models.UserInfo.objects.filter(id=1).first()printuser_info_obj.user_typeprintuser_info_obj.get_user_type_display()printuser_info_obj.userprofile.password

user_info_obj= models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()printuser_info_obj.keys()print user_info_obj.values()

View Code

一对多操作

类似一对一

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

View Code

扩展：

a、自定义上传

defupload_file(request):if request.method == "POST":

obj= request.FILES.get('fafafa')

f= open(obj.name, 'wb')for chunk inobj.chunks():

f.write(chunk)

f.close()return render(request, 'file.html')

View Code

b、Form上传文件实例

Form

class FileForm(forms.Form):

ExcelFile = forms.FileField()

Model

from django.db import models

class UploadFile(models.Model):

userid = models.CharField(max_length = 30)

file = models.FileField(upload_to = './upload/')

date = models.DateTimeField(auto_now_add=True)

View

def UploadFile(request):

uf = AssetForm.FileForm(request.POST,request.FILES)

if uf.is_valid():

upload = models.UploadFile()

upload.userid = 1

upload.file = uf.cleaned_data['ExcelFile']

upload.save()

print upload.file

二、Form

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

输入html

验证用户输入

Form

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

importrefrom django importformsfrom django.core.exceptions importValidationErrordefmobile_validate(value):

mobile_re= re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')if notmobile_re.match(value):raise ValidationError('手机号码格式错误')classPublishForm(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'邮箱'}))

View Code

View

defpublish(request):

ret= {'status': False, 'data': '', 'error': '', 'summary': ''}if request.method == 'POST':

request_form=PublishForm(request.POST)ifrequest_form.is_valid():

request_dict=request_form.clean()printrequest_dict

ret['status'] =Trueelse:

error_msg=request_form.errors.as_json()

ret['error'] =json.loads(error_msg)return HttpResponse(json.dumps(ret))

View Code

扩展：ModelForm

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

classAdminModelForm(forms.ModelForm):classMeta:

model=models.Admin#fields = '__all__'

fields = ('username', 'email')

widgets={'email' : forms.PasswordInput(attrs={'class':"alex"}),

}

View Code

三、XSS和CSRF跨站请求伪造

XSS: 对用户提交的数据验证

1.后端设置

def test(request):

from django.utils.safestring import mark_safe

temp = "百度"

newtemp = mark_safe(temp)

return render(request,'test.html',{'temp':temp})

2.前端设置

CSRF: CSRF(Cross-site request forgery)跨站请求伪造，通常缩写为CSRF或者XSRF，是一种对网站的恶意利用。

尽管听起来像跨站脚本(XSS)，但它与XSS非常不同,XSS利用站点内的信任用户，而CSRF则通过伪装来自受信任用户的请求来利用受信任的网站。

csrf_token防止从别的网站向自己网站发post请求, 客户来访问网站，网站会向客户发送随机字符串，然后客户带随机字符串发送post请求。

只有带随机字符串来，网站才认,一般是post请求才要求带随机字符串，其它网站第一次来不会带随机字符串。

Title

Ajax提交

var user= $("#user").val();

$.ajax({

url:'/index/',

type:'POST',

data:{"user":user,"csrfmiddlewaretoken":"{{ csrf_token }}"},

success:function (arg) {

console.log(arg);

}

})

}

csrf1.html

四、Cookie

a. 简单应用

deflogin(request):if request.method=="GET":return render(request,"login.html")else:

name= request.POST.get("name")

password= request.POST.get("password")if name == "alex" and password == "123":

obj= redirect("/classes/")

obj.set_cookie("ticket","123456",max_age=10)returnobjelse:return redirect("/login/")defclasses(request):

sk=request.COOKIESprint(sk)if notsk:return redirect("/login/")

View Code

b. 设置cookie的过期时间

方式一：

obj.set_cookie("ticket","123456",max_age=10)

方式二：

import datetime

from datetime import timedelta #时间的加减

ct = datetime.datetime.utcnow() #获取当前日期

v= timedelta(seconds=10) #10秒

value = ct + v

obj.set_cookie("ticket","123456",expires=value)

c. 限制路径

obj.set_cookie("ticket","123456",max_age=10,path="/") #所有路径都可以访问

obj.set_cookie("ticket","123456",max_age=10,path="/class") #只有class访问

d. cookie签名

#加

obj.set_signed_cookie("ticket","123456",salt="abc")

#解

sk = request.get_signed_cookie("ticket",salt="abc")

五、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. 使用defindex(request):#获取、设置、删除Session中数据

request.session['k1']

request.session.get('k1',None)

request.session['k1'] = 123request.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")

request.session.set_expiry(value)*如果value是个整数，session会在些秒数后失效。*如果value是个datatime或timedelta，session就会在这个时间后失效。*如果value是0,用户关闭浏览器session就会失效。* 如果value是None,session会依赖全局session失效策略。

View Code

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. 使用

同上

View Code

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. 使用

同上

View Code

4、缓存+数据库Session

数据库用于做持久化，缓存用于提高效率

a. 配置 settings.py

SESSION_ENGINE= 'django.contrib.sessions.backends.cached_db' #引擎

b. 使用

同上

View Code

5、加密cookie Session

a. 配置 settings.py

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

b. 使用

同上

View Code

6、扩展：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

7、简单应用

流程：客户登录网址，验证成功后,服务端生成一个随机字符串和随机字符串对应的键值,然后把随机字符串通过cookie发送给客户端。客户端拿着随机字符串通过cookie再次登陆，服务端拿着随机字符串和保存在本地的数据对应，以确定用户的登录状态。

Cookie是什么？

保存在客户端浏览器上的键值对

Session是什么？

保存在服务端的数据(本质是键值对)

{

“aaaaa":{'id':1,'name':'alex',email='xxxx'}

"bbbbb":{'id':2,'name':'egon',email='0000'}

}

应用：依赖cookie

作用：保持会话(Web网站)

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

梳理：

1. 保存在服务端的数据(本质是键值对)

2. 配置文件中：

- 存储位置

- 超时时间、每次刷新更新时间

用户访问http://127.0.0.1:8000/login/

urlpatterns =[

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

url(r'^login/', views.login),

]

urls.py

deflogin(request):if request.method == 'GET':return render(request,'login.html')else:

u= request.POST.get('user')

p= request.POST.get('pwd')

obj= models.UserAdmin.objects.filter(username=u,password=p).first()ifobj:#1. 生成随机字符串

#2. 通过cookie发送给客户端

#3. 服务端保存

#随机字符串1: {'username':'alex','email':x''...}

request.session['username'] =obj.usernamereturn redirect('/index/')else:return render(request,'login.html',{'msg':'用户名或密码错误'})defindex(request):#1. 获取客户端端cookie中的随机字符串

#2. 去session中查找有没有随机字符

#3. 去session对应key的value中查看是否有 username

v = request.session.get('username')ifv:return HttpResponse('登录成功:%s' %v)else:return redirect('/login/')

views.py

Title

index page

index.html

六、cbv、fbv

cbv(class-base-view) 基于类的视图

fbv(func-base-view) 基于函数的视图

cbv基本演示

根据源码执行get post 方法前会先执行dispatch操作url请求前可以自定义dispatch方法，当作装饰器使用。

urlpatterns =[

url(r'^login.html$', views.Login.as_view()),

]

urls.py

from django.views importViewclassLogin(View):def dispatch(self, request, *args, **kwargs):print('before')

obj= super(Login,self).dispatch(request,*args,**kwargs)print("after")returnobjdefget(self,request):return render(request,"login.html")defpost(self,request):print(request.POST)return HttpResponse("Login.post")

views.py

七、分页

1、Django内置分页

#浏览器访问

http://127.0.0.1:8000/index.html/?page=9

defindex(request):"""分页

:param request:

:return:"""current_page= request.GET.get('page')

user_list=models.UserInfo.objects.all()

paginator= Paginator(user_list,10)#per_page: 每页显示条目数量

#count: 数据总个数

#num_pages:总页数

#page_range:总页数的索引范围，如: (1,10),(1,200)

#page: page对象

try:

posts=paginator.page(current_page)exceptPageNotAnInteger as e:

posts= paginator.page(1)exceptEmptyPage as e:

posts= paginator.page(1)#has_next 是否有下一页

#next_page_number 下一页页码

#has_previous 是否有上一页

#previous_page_number 上一页页码

#object_list 分页之后的数据列表

#number 当前页

#paginator paginator对象

return render(request,'index.html',{'posts':posts})

views.py

用户列表

{% for row in posts.object_list %}
{{ row.name }}{% endfor %}

{% if posts.has_previous %} 上一页{% endif %}

{% if posts.has_next %}下一页{% endif %}

index.py

2、自定义分页

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

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 importmark_safeclassPageInfo(object):def __init__(self,current,totalItem,peritems=5):

self.__current=current

self.__peritems=peritems

self.__totalItem=totalItemdefFrom(self):return (self.__current-1)*self.__peritems

defTo(self):return self.__current*self.__peritems

def TotalPage(self): #总页数

result=divmod(self.__totalItem,self.__peritems)if result[1]==0:returnresult[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=0if totalpage <= 11:

begin=0

end=totalpageelse:if currentPage>5:

begin=currentPage-5end=currentPage+5

if end >totalpage:

end=totalpageelse:

begin=0

end=11pager_list=[]if currentPage<=1:

first="首页"

else:

first="首页" % (baseurl,1)

pager_list.append(first)if currentPage<=1:

prev="上一页"

else:

prev="上一页" % (baseurl,currentPage-1)

pager_list.append(prev)for i in range(begin+1,end+1):if i ==currentPage:

temp="%d" %(baseurl,i,i)else:

temp="%d" %(baseurl,i,i)

pager_list.append(temp)if currentPage>=totalpage:

next="下一页"

else:

next="下一页" % (baseurl,currentPage+1)

pager_list.append(next)if currentPage>=totalpage:

last="末页"

else:

last="末页" %(baseurl,totalpage)

pager_list.append(last)

result=''.join(pager_list)return mark_safe(result) #把字符串转成html语言

View Code

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

创建处理分页数据的类

根据分页数据获取数据

输出分页HTML，即：［上一页］［1］［2］［3］［4］［5］［下一页］

分页模板应用：

classPageInfo(object):def __init__(self,current_page,all_count,per_page,base_url,show_page=11):""":param current_page:

:param all_count: 数据库总行数

:param per_page: 每页显示行数

:return:"""

try:

self.current_page=int(current_page)exceptException as e:

self.current_page= 1self.per_page=per_page

a,b=divmod(all_count,per_page)ifb:

a= a +1self.all_pager=a

self.show_page=show_page

self.base_url=base_urldefstart(self):return (self.current_page-1) *self.per_pagedefend(self):return self.current_page *self.per_pagedefpager(self):#v = "1 2"

#return v

page_list =[]

half= int((self.show_page-1)/2)#如果数据总页数 < 11

if self.all_pager

begin= 1stop= self.all_pager + 1

#如果数据总页数 > 11

else:#如果当前页 <=5,永远显示1,11

if self.current_page <=half:

begin= 1stop= self.show_page + 1

else:if self.current_page + half >self.all_pager:

stop= self.all_pager + 1begin= self.all_pager - self.show_page + 1

else:

begin= self.current_page -half

stop= self.current_page + half + 1

if self.current_page <= 1:

prev= "

上一页"

else:

prev= "

上一页" %(self.base_url,self.current_page-1,)

page_list.append(prev)for i inrange(begin,stop):if i ==self.current_page:

temp= "

%s" %(self.base_url,i,i,)else:

temp= "

%s" %(self.base_url,i,i,)

page_list.append(temp)if self.current_page >=self.all_pager:

nex= "

下一页"

else:

nex= "

下一页" %(self.base_url,self.current_page+1,)

page_list.append(nex)return ''.join(page_list)

utils/pager.py

用户列表

{% for row in user_list %}
{{ row.name }}{% endfor %}

{{ page_info.pager|safe }}

weixin_39647734

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java web框架 django_Web框架Django（二）

一、Model到目前为止，当我们的程序涉及到数据库相关操作时，我们一般都会这么搞：创建数据库，设计表结构和字段使用 MySQLdb 来连接数据库，并编写数据访问层代码业务逻辑层去调用数据访问层执行数据库操作importMySQLdbdefGetList(sql):db= MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host...
复制链接

扫一扫