djaogo知识点 python_python Django知识点总结

最新推荐文章于 2022-01-07 01:10:56 发布

weixin_39873191

最新推荐文章于 2022-01-07 01:10:56 发布

阅读量373

点赞数

文章标签： djaogo知识点 python

本文链接：https://blog.csdn.net/weixin_39873191/article/details/111759651

版权

一、Django创建项目：

其他常用命令：

二、创建数据库(ORM)

a.数据库表的增

1 这是原来的表

2 classUserINfo(models.Model):

3 nickname = models.CharField(max_length=32)

4 username = models.CharField(max_length=32)

5 password = models.CharField(max_length=32)

6 gender_list=(

7 (1,'男'),

8 (2,'女'),

9 )

10 gender = models.IntegerField(choices=gender_list)

11 m = models.ManyToManyField('UserINfo')

12 -------------------------------------------------------------------------

13 这是新增的表

14 classUser(models.Model):

15 new_id=models.IntegerField(null=True)

16 new_tabe= models.CharField(max_length=32)

17 new_content =models.CharField(max_length=64)

18 new_root = models.CharField(max_length=32)

19 content = models.ForeignKey('User',null=True,blank=True,related_name='xxx')

b.数据库表的删

1 这是数据库的表

2 classGTB(models.Model):

3 g = models.ForeignKey('Boy',null=True)

4 b = models.ForeignKey('Grily',null=True)

6 -------------------------------------------------------------

7 这是删除数据库表

8 #class UserInfo(models.Model):

9 #nickname = models.CharField(max_length=32)

10 #username = models.CharField(max_length=32)

11 #password = models.CharField(max_length=32)

12 #gender_list=(

13 #(1,'男'),

14 #(2,'女'),

15 #)

16 #gender = models.IntegerField(choices=gender_list)

c.数据库表的改

1 这是数据库未进行修改的表

2 classBoy(models.Model):

3 username = models.CharField(max_length=32)

4 nickname = models.CharField(max_length=32)

5 password = models.CharField(max_length=32)

8 ------------------------------------------------------------

9 这是要进行更改数据的表

10 classBoy(models.Model):

11 username = models.CharField(max_length=32)

12 name = models.CharField(max_length=32)

13 password = models.CharField(max_length=32)

d.数据库表行的增

1 defindex(request):

2 models.Body.objects.create(username='波多爱军',password=123,sex=1)

3 models.Body.objects.create(username='苍爱军',password=123,sex=1)

4 models.Body.objects.create(username='吉泽爱军',password=123,sex=1)

5 models.Body.objects.create(username='田原爱军',password=123,sex=1)

e.数据库表行的删

1 defindex(request):

2 models.Body.objects.delete(username='波多爱军',password=123,sex=1)

f.数据库表行的改

1 defindex(request)：

2 models.Body.objects.filter(username='波多爱军',password=123,sex=1).update(username='波多爱军',password=233,sex=2)

g.数据库表行的查

1 defgets(request):

2 #models.UserInfo.objects.all()

3 ## 查看全部行的数据

5 #models.UserInfo.objects.filter(id=2)

6 ##查看id等于2的哪行数据

8 #models.UserInfo.objects.first()

9 ##查看第一个数据

11 #models.UserInfo.objects.last()

12 ##查看最后一个数据

14 #models.UserInfo.objects.exclude(id=4)

15 ##查看id不等于4的所有内容

17 #models.UserInfo.objects.filter(name='seven').count()

18 ##获取名字等于seven的总数

20 #models.UserInfo.objects.get(name='seven')

21 ##获取名字等于seven的单个对象

23 #models.UserInfo.objects.filter(id_gt=1)

24 ##查看id大于1的行内容

26 #models.UserInfo.objects.filter(id_lt=2)

27 ##查看id小于2的行内容

29 #models.UserInfo.objects.filter(id_gte=1)

30 ##查看id大于等于1的行内容

32 #models.UserInfo.objects.filter(id_let=5)

33 ##查看id小于等于5的行内容

35 #models.UserInfo.objects.filter(id_lt=10,id_gt=1)

36 ##查看id大于1且id小于10的行内容

38 #models.UserInfo.objects.filter(id__in=[11,33,44])

39 ##查看id在不在列表中

41 #models.UserInfo.objects.exclude(id_in=[11,33,44])

42 ##查看id不在列表中的的数据内容

44 #models.UserInfo.objects.filter(pud_date__isnull=True)

45 ##查看pud_date不是为空

47 #models.UserInfo.objects.filter(name__contains='alex')

48 ##查看名字中列中包含alex的数据内容

50 #models.UserInfo.objects.exclude(name__icontains='alex')

51 ##查看名字中列中包含alex(大小写不敏感)的数据内容

53 #models.UserInfo.objects.filter(ut_id__range=[1,5])

54 ##范围(bettwen end)

56 #models.UserInfo.objects.filter(name__startswith='alex')

57 ##查看名字以alex开头的数据行

59 #models.UserInfo.objects.filter(name__istartswith='alex')

60 ##查看名字以alex开头(大小写不敏感)的数据行

62 #models.UserInfo.objects.filter(name__endswith='egon')

63 ##查看名字以egon结尾的数据行

65 #models.UserInfo.objects.filter(name__iendswith='egon')

66 ##查看名字以egon(大小写不敏感)的数据行

68 #models.UserInfo.objects.all().order_by('-id')

69 ##以降序进行排列查看

71 #models.UserInfo.objects.all().order_by('id')

72 ##以升序进行排列查看(默认使用升序)

74 #models.UserInfo.objects.all()[1:4]

75 ##分页limit offset 起始位置和结束位置

三、路由系统

1、单一路由对应

2、基于正则的路由

3、添加额外的参数

4、为路由映射设置名称

设置名称之后，可以在不同的地方调用，如：

模板中使用生成URL {% url 'h2' 2012 %}

函数中使用生成URL reverse('h2', args=(2012,)) 路径:django.urls.reverse

Model中使用获取URL 自定义get_absolute_url() 方法

1 classNewType(models.Model):

2 caption = models.CharField(max_length=16)

5 defget_absolute_url(self):

6 """

7 为每个对象生成一个URL

8 应用：在对象列表中生成查看详细的URL，使用此方法即可！！！

9 :return:

10 """

11 #return '/%s/%s' % (self._meta.db_table, self.id)

12 #或

13 from django.urls importreverse

14 return reverse('NewType.Detail', kwargs={'nid': self.id})

获取请求匹配成功的URL信息：request.resolver_match

5、根据app对路由规则进行分类

6、命名空间

a. project.urls.py

b. app01.urls.py

c. app01.views.py

以上定义带命名空间的url之后，使用name生成URL时候，应该如下：

v = reverse('app01:detail', kwargs={'pk':11})

{% url 'app01:detail' pk=12 pp=99 %}

django中的路由系统和其他语言的框架有所不同，在django中每一个请求的url都要有一条路由映射，这样才能将请求交给对一个的view中的函数去处理。其他大部分的Web框架则是对一类的url请求做一条路由映射，从而是路由系统变得简洁。

通过反射机制，为django开发一套动态的路由系统Demo：

四、模板

1、模版的执行

模版的创建过程，对于模版，其实就是读取模版(其中嵌套着模版标签)，然后将 Model 中获取的数据插入到模版中，最后将信息返回给用户。

1 defcurrent_datetime(request):

2 now =datetime.datetime.now()

3 html = "

It is now %s." %now

4 return HttpResponse(html)

1 from django importtemplate

2 t = template.Template('My name is {{ name }}.')

3 c = template.Context({'name': 'Adrian'})

4 print t.render(c)

1 importdatetime

2 from django importtemplate

3 importDjangoDemo.settings

5 now =datetime.datetime.now()

6 fp = open(settings.BASE_DIR+'/templates/Home/Index.html')

7 t =template.Template(fp.read())

8 fp.close()

9 html = t.render(template.Context({'current_date': now}))

10 return HttpResponse(html

1 from django.template.loader importget_template

2 from django.template importContext

3 from django.http importHttpResponse

4 importdatetime

6 defcurrent_datetime(request):

7 now =datetime.datetime.now()

8 t = get_template('current_datetime.html')

9 html = t.render(Context({'current_date': now}))

10 return HttpResponse(html)

1 return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))

2、模版语言

模板中也有自己的语言，该语言可以实现数据展示

{% for item in item_list %} {{ item }} {% endfor %}

forloop.counter

forloop.first

forloop.last

{% if ordered_warranty %} {% else %} {% endif %}

母板：{% block title %}{% endblock %}

子板：{% extends "base.html" %}

{% block title %}{% endblock %}

帮助方法：

3、自定义simple_tag

a、在app中创建templatetags模块

b、创建任意 .py 文件，如：xx.py

c、在使用自定义simple_tag的html文件中导入之前创建的 xx.py 文件名

d、使用simple_tag

e、在settings中配置当前app，不然django无法找到自定义的simple_tag

五、F

1 # from django.db.models import F

2 # models.UserInfo.objects.all().update(age=F('age')+1)

六、Q

1 #方法一：

2 # Q(nid__gt=10)

3 # #创建一个Q

4 # Q(nid=8) | Q(nid__gt=10)

5 # #俩个Q是或的关系

6 # Q(nid=8) & Q(nid__gt=10)

7 # #俩个Q是与的关系

8 # Q(nid=8) | Q(nid__gt=10) & Q(nid=7)

9 # #Q8 和 Q7 或 Q10 和 Q7的关系

11 #方法二：

12 # from django.db.models import Q

13 # q1=Q()

14 # q1.connector='OR'

15 # q1.children.append(('id_gt',1))

16 # q1.children.append(('id',10))

17 # q1.children.append(('id',9))

18 #

19 # q2=Q()

20 # q2.connector='OR'

21 # q2.children.append(('c1',2))

22 # q2.children.append(('c1',10))

23 # q2.children.append(('c1',9))

24 #

25 # q3=Q()

26 # q3.connector='AND'

27 # q3.children.append(('id',1))

28 # q3.children.append(('id',2))

29 # q2.add(q3,'OR')

30 #

31 # con=Q()

32 # con.add(q1,'AND')

33 # con.add(q2,'AND')

34 #

35 # models.UserInfo.objects.filter(con)

七、extra

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

where ---------params

select ----------select_params

1 1 # def gets(request):

2 2 # models.UserInfo.objects.extra(where=['headline=%s'],params=[1,])

3 3 # #where 和 params 配合使用

4 4 # models.UserInfo.objects.extra(where=["foo='a' OR bar='a',baz='a"])

5 5 # #查询条件是foo和baz等于a 或者bar和baz等a

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

7 7 # #查询id大于1并以降序排列

八、连表

a.对象连表

b.字典连表

c.元组连表

七、正反向查找

a.对象正向查找

1 result = models.UserInfo.objects.all()

2 for obj in result:

3 print(obj.name,obj.age,obj.ut_id,obj.ut.title)

4 #打印obj对象的名字，对象的年龄，对象的外键，ut设置外键的列就是相当于ut表对应的主键(现在拿到就是ut那个表可以拿ut对应的一行所有内容)

5 result = models.UserInfo.objects.all().first()

6 ##获取表中所有的行但只是拿第一个对象，也就是第一行

7 print(result.name,result.age,result.ut)

b.对象反向查找

1 # obj = models.UserType.objects.all().last()

2 # print('用户类型',obj)

3 # for row in obj.userinfo_set.all():

4 # print(row.name,row.age)

c.字典正向查找

1 # models.UserInfo.objects.filter(id__gt=7).delete()

2 #v=models.UserInfo.objects.all().values('name','age','ut__title')

3 # print(v)

d.字典反向查找

1 1 # vv = models.UserType.objects.values('title','userinfo__name')

2 2 # print(vv)

e.元组正向查找

1 1 # v3 = models.UserInfo.objects.all().values_list('name','age','ut__title')

2 2 # print(v3)

f.元组反向查找

1 1 # v4 = models.UserType.objects.all().values_list('title','userinfo__name')

2 2 # print(v4)

九、排序

1 ss =models.UserInfo.objects.all().order_by('-id','age').reverse()

2 print(ss.query)

3 '''

4 SELECT "appo1_userinfo"."id", "appo1_userinfo"."name", "appo1_userinfo"."age", "appo1_userinfo"."ut_id" FROM "appo1_userinfo" ORDER BY "appo1_userinfo"."id" ASC, "appo1_userinfo"."age" DESC

6 '''

8 将设置的排序方式进行反转，本来id是降序，age是升序，反转后id 是升序，age是降序

十、annotate(组合)

十一、转化成sql语句

十二、去重

十三、排除某列数据

十四、仅获取某列数据

十五、指定使用某数据库

十六、其他相关操作

1 models.UserInfo.objects.dates('ctime','day','DESC')

2 根据时间进行某一部分进行去查找并截取指定内容 (参数表行时间格式排方式)

3 kind 只能是 year(年) month(年-月)day(年-月-日)

4 order 只能是 ASC DESC (排序方式)

5 并获取转换后的时间

6 year 年 01 01

7 month 年月 01

8 day 年月日

9 models.UserInfo.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)

10 128 #根据时间进行某一部分查找并截取指定内容，将时间转换为指定时区时间

11 kind只能是 year month day hour minute second

12 order只能是 ASC DESC 排序方式

13 tzinfo 时区对象

14 models.UserInfo.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

15 ’''

16 安装 pythz pip3 install pytz

17 import pytz

18 pytz.all_timezones

19 pytz.timezone('Asia/Shanghai')

20 '''

21 def none(self):

22 #空QuesySet

23 pass

24 ss=models.UserInfo.objects.aggregate(k=Count('ut_id',distinct=True),n=Count('id'))

25 {'k': 3, 'n': 7}

26 print(ss)

27 ogj=[

28 models.UserInfo(name='alex'),

29 models.UserInfo(name='egon')

31 ]

32 models.UserInfo.objects.bulk_create(ogj,10)

33 批量插入数据 10代表没次插入数量

34 obj,creted = models.UserInfo.objects.get_or_create(username='roo1',defaults={'email':'11111','u_id':2,'tid':3})

35 先查看如果存在就不执行创建的操作，如果不存在就会创建后边的数据

36 obj,creted = models.UserInfo.objects.update_or_create(username='roo1',defaults={'email':'11111','u_id':2,'tid':3})

37 先查如果存在就不执行更新，如果不存在就会创建后边的数据

38 id=[11,222,333]

39 models.UserInfo.objects.in_bulk(id)

40 根据主键ID进行查找

41 ss = models.UserInfo.objects.exists()

42 #查看是否有结果

43 print(ss)

44 return HttpResponse('....')

十七、cookie

1、获取Cookie：

2、设置Cookie：

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

十八、xss(跨站脚本攻击)

十九、crsf 跨站伪装请求

一、简介

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

全局：

中间件 django.middleware.csrf.CsrfViewMiddleware

局部：

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

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

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

二、应用

1、普通表单

2、Ajax

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

view.py

text.html

二十、session

Session个人理解

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

配置文件中可以指定存储位置

数据库 Session

缓存Session

文件Session

缓存+数据库Session

Cookie 中存放Session

Session 用户验证

1 1 def login(func):

2 2 def wrap(request, *args, **kwargs):

3 3 # 如果未登陆，跳转到指定页面

4 4 if request.path == '/test/':

5 5 return redirect('http://www.baidu.com')

6 6 return func(request, *args, **kwargs)

7 7 return wrap

二十一、分页

一、Django内置分页

1 from django.shortcuts import render

2 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

4 L = []

5 for i in range(999):

6 L.append(i)

8 def index(request):

9 current_page = request.GET.get('p')

11 paginator = Paginator(L, 10)

12 # per_page: 每页显示条目数量

13 # count: 数据总个数

14 # num_pages:总页数

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

16 # page: page对象

17 try:

18 posts = paginator.page(current_page)

19 # has_next 是否有下一页

20 # next_page_number 下一页页码

21 # has_previous 是否有上一页

22 # previous_page_number 上一页页码

23 # object_list 分页之后的数据列表

24 # number 当前页

25 # paginator paginator对象

26 except PageNotAnInteger:

27 posts = paginator.page(1)

28 except EmptyPage:

29 posts = paginator.page(paginator.num_pages)

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

9 {% for item in posts %}

11 {% endfor %}

16 {% if posts.has_previous %}

17 Previous

18 {% endif %}

20 Page {{ posts.number }} of {{ posts.paginator.num_pages }}.

22 {% if posts.has_next %}

23 Next

24 {% endif %}

1 from django.shortcuts import render

2 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

5 class CustomPaginator(Paginator):

6 def __init__(self, current_page, max_pager_num, *args, **kwargs):

7 """

8 :param current_page: 当前页

9 :param max_pager_num:最多显示的页码个数

10 :param args:

11 :param kwargs:

12 :return:

13 """

14 self.current_page = int(current_page)

15 self.max_pager_num = max_pager_num

16 super(CustomPaginator, self).__init__(*args, **kwargs)

18 def page_num_range(self):

19 # 当前页面

20 # self.current_page

21 # 总页数

22 # self.num_pages

23 # 最多显示的页码个数

24 # self.max_pager_num

25 print(1)

26 if self.num_pages < self.max_pager_num:

27 return range(1, self.num_pages + 1)

28 print(2)

29 part = int(self.max_pager_num / 2)

30 if self.current_page - part < 1:

31 return range(1, self.max_pager_num + 1)

32 print(3)

33 if self.current_page + part > self.num_pages:

34 return range(self.num_pages + 1 - self.max_pager_num, self.num_pages + 1)

35 print(4)

36 return range(self.current_page - part, self.current_page + part + 1)

39 L = []

40 for i in range(999):

41 L.append(i)

43 def index(request):

44 current_page = request.GET.get('p')

45 paginator = CustomPaginator(current_page, 11, L, 10)

46 # per_page: 每页显示条目数量

47 # count: 数据总个数

48 # num_pages:总页数

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

50 # page: page对象

51 try:

52 posts = paginator.page(current_page)

53 # has_next 是否有下一页

54 # next_page_number 下一页页码

55 # has_previous 是否有上一页

56 # previous_page_number 上一页页码

57 # object_list 分页之后的数据列表

58 # number 当前页

59 # paginator paginator对象

60 except PageNotAnInteger:

61 posts = paginator.page(1)

62 except EmptyPage:

63 posts = paginator.page(paginator.num_pages)

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

10 {% for item in posts %}

12 {% endfor %}

17 {% if posts.has_previous %}

18 Previous

19 {% endif %}

21 {% for i in posts.paginator.page_num_range %}

22 {{ i }}

23 {% endfor %}

25 {% if posts.has_next %}

26 Next

27 {% endif %}

31 Page {{ posts.number }} of {{ posts.paginator.num_pages }}.

二、自定义分页

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

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

2、用户输入页码(第一页、第二页...)

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

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

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

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

2、用户输入页码(第一页、第二页...)

3、设定显示多少页号

4、获取当前数据总条数

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

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

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

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

1 ##============================================django自定义分页不能对页数进行限定============================

3 # class PageInfo(object):

4 #

5 # def __init__(self,current_page,per_page,all_count,show_page=11):

6 # try:

7 # self.current_page = int(current_page)

8 # except Exception as e:

9 # self.current_page=1

10 # self.per_page=per_page

11 # self.all_count=all_count

12 # a,b =divmod(all_count,per_page)

13 # if b:

14 # a = a+1

15 # self.all_pager = a

16 # self.show_page=show_page

17 #

18 # def start(self):

19 # return (self.current_page -1)* self.per_page

20 #

21 # def end(self):

22 # return self.current_page * self.per_page

23 #

24 # def pager(self):

25 # # v='1'

26 # # return v

27 # page_list=[]

28 # half=(self.show_page-1)/2

29 # begin=self.current_page - half

30 # stop=self.current_page +half +1

31 # for i in range(int(begin),int(stop)):

32 # if self.current_page == i:

33 # temp="%s" % (

36 # i, i,)

37 # page_list.append(temp)

38 #

39 # return ''.join(page_list)

40 # def custom(request):

41 # #表示用户当前想要访问的页码

42 # all_count = models.UserInfo.objects.all().count()

43 # #每页显示的个数

44 # page_info=PageInfo(request.GET.get('page'),10,all_count)

45 # user_list = models.UserInfo.objects.all()[page_info.start():page_info.end()]

46 # return render(request,'custom.html',{'user_list':user_list,'page_info':page_info})

1 from django.core.paginator import Paginator,Page

2 class PageInfo(object):

4 def __init__(self,current_page,per_page,all_count,show_page=11):

5 ##类的变量参数

6 try:

7 #捕捉异常

8 self.current_page = int(current_page)

9 #如果能正常转换成整型就赋值给self.current_page

10 except Exception as e:

11 #不能正常转换成整型就赋值成数字1

12 self.current_page=1

13 #设置多少条数据分为一个一页

14 self.per_page=per_page

15 #获取数据库中所有的数据能分为多少页

16 self.all_count=all_count

17 #进行分页计算(数据库总数/多少天数据进行分页)能除开等到结果就像是(12,0)把12赋值给a，把0赋值给b

18 a,b =divmod(all_count,per_page)

19 #如果b为真

20 if b:

21 #a 等于a+1

22 a = a+1

23 #求出总共要分的页数赋值给self.all_pager

24 self.all_pager = a

25 #把传入的show_page值赋值给self.show_page

26 self.show_page=show_page

28 def start(self):

29 #定义函数设定起始位

30 return (self.current_page -1)* self.per_page

31 #返回当前页数减1 乘每页多少数据

32 def end(self):

33 # 定义函数设定停止位

34 return self.current_page * self.per_page

35 # 返回当前页数减乘每页多少数据

36 def pager(self):

37 #定义函数

38 # v='1'

39 # return v

40 page_list=[]

41 #创建列表

42 half=(self.show_page-1)/2

43 #获取页码的中间值

44 if self.all_pager < self.show_page:

45 #如果数据库的数小于设定的页码数

46 begin=1

47 #起始位设定为1

48 stop=self.all_pager+1

49 #停止为设定为数据库的数加上1(因为切片是顾头不顾尾)

50 else:

51 #否则

52 if self.current_page <= half:

53 #如果当前页码小于等于页码中间值

54 begin=1

55 #起始位设定为1

56 stop=self.show_page+1

57 #停止位设定为页码数加1(因为切片是顾头不顾尾)

58 else:

59 #否则

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

61 #如果当前页码加上中间的页码大于数据库的总页码数

62 begin=self.all_pager-10

63 #起始值设定为数据库总数减10

64 stop=self.all_pager+1

65 #停止值设定为数据库总数加1(因为切片是顾头不顾尾)

66 else:

67 #否则

68 begin=self.current_page-half

69 #起始位设定为当前页码减中间页码

70 stop=self.current_page+half+1

71 #停止位设定为当前页码加中间页码加1(因为切片是顾头不顾尾)

72 if self.current_page==self.all_pager:

73 up = "

下一页"

74 else:

75 up = "

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

76 page_list.append(up)

77 for i in range(int(begin),int(stop)):

78 #进行循环范围是(起始位，停止位)

79 if self.current_page == i:

80 #如果当前页码等于循环的i时

81 temp="

%s"%(i,i,)

82 #自定义一个a标签设置简单样式并添加背景颜色作为当前页码标识

83 else:

84 #否则

85 temp = "

%s" % (

86 i, i,)

87 #自定义一个a标签设置简单样式

88 page_list.append(temp)

89 #把每循环的a标签都添加到page_list列表中

90 if self.current_page==1:

91 nex = "

上一页"

92 else:

93 nex = "

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

94 page_list.append(nex)

95 return ''.join(page_list)

96 #把列摆中的内容进行拼接(因为返回的是字符串)

97 # def custom(request):

98 # #从数据库中获取所有数据

99 # all_count = models.UserInfo.objects.all().count()

100 # #实例化一个对象并进行传值

101 # page_info=PageInfo(request.GET.get('page'),10,all_count)

102 # #从数据库中获取数据设置起始和结束位置

103 # user_list = models.UserInfo.objects.all()[page_info.start():page_info.end()]

104 # #返回到HTML标签中并传入参数

105 # return render(request,'custom.html',{'user_list':user_list,'page_info':page_info})

106

107 ##==================================================总结=================================================================

108 '''

109 1.获取到数据中最大的页码数

110 2.设定一页显示多少数据

111 3.在用数据库总数除以要显示的内容数量(如果余数不等于零需要多添加一页)

112 4.设定一页中显示多少页码按钮

113 5.获取一页页码中中间的页码数

114 6.判断数据库的页码是不是小于设定一页中显示页码按钮的数(如果小于就重写停止值，不小于就往下判断)

115 7.判断当前页码数小于等于设定页码的中间值(重写起始值为1)

116 8.当前页码值不小于等于页码的中间值(重写起始值为中间值-5，结束值+6，因为切片是顾头不顾尾)

117 9.判断当前页码加上中间页码数是不是大于数据库总数(大于重写起始值为数据库总数-10，结束值为数据库总数+1，因为切片是顾头不顾尾)

118 10.通过python向HTML页面中传一个函数名，在HTML中函数名.方法执行(不能加括号执行)

119 11.|safe 表明是安全参数可以正常渲染

120 12.判断当前页码数是不是等于1(如果等于1不执行上一步按钮)

121 13.判断当前页码数是不是等于数据库总数(如果等于不执行下一步按钮)

122 '''

二十二、自关联

1、自关联，通过名字大概就知道是一张表要关联它自己本身，如果按照以前学的知识创表时肯定不能成功，这就要运用到今天新学的知识点。

2、想想，咱们以前关联表时都是在创建一个关系表里边设置外键，自关联也一样。

3、重点来了，表已经创好了，数据也存在怎么查看相关联的信息啊？

1 def indexs(request):

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

3 print(tt)

4 # 获取Boy表中id等于2的obj对象(Boy的obj对象)

5 xx =tt.grily.all()

6 # 获取UTU表中的所有和Boy对象相关的所有对象

7 print(xx)

8 for i in xx:

9 print(i.g.nickname)

10 # 循环获取UTU对象g外键对应的名称

11 return HttpResponse('ok')

1 def indexss(request):

2 tt=models.UserINfo.objects.filter(id=2).first()

3 xx = tt.userinfo_set.all()

4 ## 反向查看关系自关联的表

5 for i in xx:

6 print(i.nickname)

7 return HttpResponse('ok')

4、我们在通过ManyToManyField自动创建一个自关联的关系表。

1 def indexsz(request):

2 tt = models.UserINfo.objects.filter(id=2).first()

3 # 正向查看自关联表的内容

4 xx =tt.m.all()

5 # 获取到和UserINfo相关的UserINfo对象

6 for i in xx:

7 print(i.nickname)

8 return HttpResponse('ok')

1 def indexs(request):

2 tt =models.UserINfo.objects.filter(id=2).first()

3 ss=tt.userinfo_set.all()

4 print(ss)

5 for i in ss:

6 print(i.nickname)

Fk(外键关联)

外键关联就是表(本身)设置一个外键，这个外键要关联的列是这个表(本身)的自增id

1 def indexss(request):

2 xx =models.User.objects.filter(id=1).first()

3 xs =models.User.objects.filter(id=2).first()

4 tt =xx.xxx.all()

5 ts =xs.xxx.all()

6 for i in tt:

7 print(i.new_content)

8 for i in ts:

9 print(i.new_content)

10 return HttpResponse('ok')

weixin_39873191

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
djaogo知识点 python_python Django知识点总结

一、Django创建项目：其他常用命令：二、创建数据库(ORM)a.数据库表的增1 这是原来的表2 classUserINfo(models.Model):3 nickname = models.CharField(max_length=32)4 username = models.CharField(max_length=32)5 password = models.Ch...
复制链接

扫一扫