python16_day16【Django_ORM、模板】

一、ORM

  1.MySQL配置

 1 DATABASES = {
 2 
 3     'default': {
 4 
 5         'ENGINE': 'django.db.backends.mysql', 
 6 
 7         'NAME': 'books',    #你的数据库名称
 8 
 9         'USER': 'root',   #你的数据库用户名
10 
11         'PASSWORD': '', #你的数据库密码
12 
13         'HOST': '', #你的数据库主机,留空默认为localhost
14 
15         'PORT': '3306', #你的数据库端口
16 
17     }

  2.MySQL报错

 1 NAME即数据库的名字,在mysql连接前该数据库必须已经创建,而上面的sqlite数据库下的db.sqlite3则是项目自动创建
 2 
 3 USER和PASSWORD分别是数据库的用户名和密码。
 4 
 5 设置完后,再启动我们的Django项目前,我们需要激活我们的mysql。
 6 
 7 然后,启动项目,会报错:no module named MySQLdb
 8 
 9 这是因为django默认你导入的驱动是MySQLdb,可是MySQLdb对于py3有很大问题,所以我们需要的驱动是PyMySQL
10 
11 所以,我们只需要找到项目名文件下的__init__,在里面写入:
12 
13 import pymysql
14 pymysql.install_as_MySQLdb()
15 
16 问题解决!

  3.ORM模型

 1 from django.db import models<br>
 2 class Publisher(models.Model):
 3     name = models.CharField(max_length=30, verbose_name="名称")
 4     address = models.CharField("地址", max_length=50)
 5     city = models.CharField('城市',max_length=60)
 6     state_province = models.CharField(max_length=30)
 7     country = models.CharField(max_length=50)
 8     website = models.URLField()
 9  
10     class Meta:
11         verbose_name = '出版商'
12         verbose_name_plural = verbose_name
13  
14     def __str__(self):
15         return self.name
16  
17 class Author(models.Model):
18     name = models.CharField(max_length=30)
19     def __str__(self):
20         return self.name
21  
22 class AuthorDetail(models.Model):
23     sex = models.BooleanField(max_length=1, choices=((0, ''),(1, ''),))
24     email = models.EmailField()
25     address = models.CharField(max_length=50)
26     birthday = models.DateField()
27     author = models.OneToOneField(Author)
28  
29 class Book(models.Model):
30     title = models.CharField(max_length=100)
31     authors = models.ManyToManyField(Author)
32     publisher = models.ForeignKey(Publisher)
33     publication_date = models.DateField()
34     price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
35     def __str__(self):
36         return self.title

 

分析代码:

       <1>  每个数据模型都是django.db.models.Model的子类,它的父类Model包含了所有必要的和数据库交互的方法。并提供了一个简介漂亮的定义数据库字段的语法。

       <2>  每个模型相当于单个数据库表(多对多关系例外,会多生成一张关系表),每个属性也是这个表中的字段。属性名就是字段名,它的类型(例如CharField)相当于数据库的字段类型(例如varchar)。大家可以留意下其它的类型都和数据库里的什么字段对应。

       <3>  模型之间的三种关系:一对一,一对多,多对多。

             一对一:实质就是在主外键(author_id就是foreign key)的关系基础上,给外键加了一个UNIQUE=True的属性;

             一对多:就是主外键关系;(foreign key)

             多对多:(ManyToManyField) 自动创建第三张表(当然我们也可以自己创建第三张表:两个foreign key)

  4.ORM增加

 1 from app01.models import *
 2 
 3     #create方式一:   Author.objects.create(name='Alvin')
 4 
 5     #create方式二:   Author.objects.create(**{"name":"alex"})
 6 
 7     #save方式一:     author=Author(name="alvin")
 8                             author.save()
 9 
10     #save方式二:     author=Author()
11                             author.name="alvin"
12                             author.save()

  注意:1对多,多对多增加

 1 #一对多(ForeignKey):
 2 
 3     #方式一: 由于绑定一对多的字段,比如publish,存到数据库中的字段名叫publish_id,所以我们可以直接给这个
 4     #       字段设定对应值:
 5            Book.objects.create(title='php',
 6                                publisher_id=2,   #这里的2是指为该book对象绑定了Publisher表中id=2的行对象
 7                                publication_date='2017-7-7',
 8                                price=99)
 9 
10 
11     #方式二:
12     #       <1> 先获取要绑定的Publisher对象:
13         pub_obj=Publisher(name='河大出版社',address='保定',city='保定',
14                 state_province='河北',country='China',website='http://www.hbu.com')
15     OR  pub_obj=Publisher.objects.get(id=1)
16 
17     #       <2>将 publisher_id=2 改为  publisher=pub_obj
18 
19 #多对多(ManyToManyField()):
20 
21     author1=Author.objects.get(id=1)
22     author2=Author.objects.filter(name='alvin')[0]
23     book=Book.objects.get(id=1)
24     book.authors.add(author1,author2)
25     #等同于:
26     book.authors.add(*[author1,author2])
27     book.authors.remove(*[author1,author2])
28     #-------------------
29     book=models.Book.objects.filter(id__gt=1)
30     authors=models.Author.objects.filter(id=1)[0]
31     authors.book_set.add(*book)
32     authors.book_set.remove(*book)
33     #-------------------
34     book.authors.add(1)
35     book.authors.remove(1)
36     authors.book_set.add(1)
37     authors.book_set.remove(1)
38 
39 #注意: 如果第三张表是通过models.ManyToManyField()自动创建的,那么绑定关系只有上面一种方式
40 #     如果第三张表是自己创建的:
41      class Book2Author(models.Model):
42             author=models.ForeignKey("Author")
43             Book=  models.ForeignKey("Book")
44 #     那么就还有一种方式:
45             author_obj=models.Author.objects.filter(id=2)[0]
46             book_obj  =models.Book.objects.filter(id=3)[0]
47 
48             s=models.Book2Author.objects.create(author_id=1,Book_id=2)
49             s.save()
50             s=models.Book2Author(author=author_obj,Book_id=1)
51             s.save()
View Code

  5.ORM删除

1 >>> Book.objects.filter(id=1).delete()
2 (3, {'app01.Book_authors': 2, 'app01.Book': 1})

  我们表面上删除了一条信息,实际却删除了三条,因为我们删除的这本书在Book_authors表中有两条相关信息,这种删除方式就是django默认的级联删除。

  6.ORM修改

  实例:

  

  注意

  <1> 第二种方式修改不能用get的原因是:update是QuerySet对象的方法,get返回的是一个model对象,它没有update方法,

    而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合,比如name='alvin',可能有两个name='alvin'的行数据)。

  <2>在“插入和更新数据”小节中,我们有提到模型的save()方法,这个方法会更新一行里的所有列。 而某些情况下,我们只需要更新行里的某几列。

 1 #---------------- update方法直接设定对应属性----------------
 2     models.Book.objects.filter(id=3).update(title="PHP")
 3     ##sql:
 4     ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)
 5 
 6 
 7 #--------------- save方法会将所有属性重新设定一遍,效率低-----------
 8     obj=models.Book.objects.filter(id=3)[0]
 9     obj.title="Python"
10     obj.save()
11 # SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", 
12 # "app01_book"."color", "app01_book"."page_num", 
13 # "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; 
14 # 
15 # UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556,
16 # "publisher_id" = 1 WHERE "app01_book"."id" = 3; 
17 复制代码
View Code

  7.ORM查询

  打开日志部分  

 1 LOGGING = {
 2     'version': 1,
 3     'disable_existing_loggers': False,
 4     'handlers': {
 5         'console':{
 6             'level':'DEBUG',
 7             'class':'logging.StreamHandler',
 8         },
 9     },
10     'loggers': {
11         'django.db.backends': {
12             'handlers': ['console'],
13             'propagate': True,
14             'level':'DEBUG',
15         },
16     }
17 }
日志

  8.ORM查询

 1 # 查询相关API:
 2 
 3 #  <1>filter(**kwargs):      它包含了与所给筛选条件相匹配的对象
 4 
 5 #  <2>all():                 查询所有结果
 6 
 7 #  <3>get(**kwargs):         返回与所给筛选条件相匹配的对象,返回结果有且只有一个,如果符合筛选条件的对象超过一个或者没有都会抛出错误。
 8 
 9 #-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------
10 
11 #  <4>values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列 model的实例化对象,而是一个可迭代的字典序列
12                                      
13 #  <5>exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象
14 
15 #  <6>order_by(*field):      对查询结果排序
16 
17 #  <7>reverse():             对查询结果反向排序
18 
19 #  <8>distinct():            从返回结果中剔除重复纪录
20 
21 #  <9>values_list(*field):   它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列
22 
23 #  <10>count():              返回数据库中匹配查询(QuerySet)的对象数量。
24 
25 #  <11>first():               返回第一条记录
26 
27 #  <12>last():                返回最后一条记录
28 
29 #  <13>exists():             如果QuerySet包含数据,就返回True,否则返回False

  

 1 ---------------了不起的双下划线(__)之单表条件查询----------------
 2 
 3 #    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
 4 #
 5 #    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
 6 #    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
 7 #
 8 #    models.Tb1.objects.filter(name__contains="ven")
 9 #    models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
10 #
11 #    models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
12 #
13 #    startswith,istartswith, endswith, iendswith,
14 复制代码

  9.QuerySet与惰性机制

    所谓惰性机制:Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet(查询结果集对象),它并不会马上执行sql,

    而是当调用QuerySet的时候才执行。

  QuerySet特点

       <1>  可迭代的

       <2>  可切片

 1  #objs=models.Book.objects.all()#[obj1,obj2,ob3...]
 2 
 3     #QuerySet:   可迭代
 4 
 5     # for obj in objs:#每一obj就是一个行对象
 6     #     print("obj:",obj)
 7     # QuerySet:  可切片
 8 
 9     # print(objs[1])
10     # print(objs[1:4])
11     # print(objs[::-1])

  10.QuerySet高效使用

 1 <1>Django的queryset是惰性的
 2 
 3      Django的queryset对应于数据库的若干记录(row),通过可选的查询来过滤。例如,下面的代码会得
 4      到数据库中名字为‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave")
 5      上面的代码并没有运行任何的数据库查询。你可以使用person_set,给它加上一些过滤条件,或者将它传给某个函数,
 6      这些操作都不会发送给数据库。这是对的,因为数据库查询是显著影响web应用性能的因素之一。
 7 
 8 <2>要真正从数据库获得数据,你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql.
 9    为了验证这些,需要在settings里加入 LOGGING(验证方式)
10         obj=models.Book.objects.filter(id=3)
11         # for i in obj:
12         #     print(i)
13 
14         # if obj:
15         #     print("ok")
16 
17 <3>queryset是具有cache的
18      当你遍历queryset时,所有匹配的记录会从数据库获取,然后转换成Django的model。这被称为执行
19     (evaluation).这些model会保存在queryset内置的cache中,这样如果你再次遍历这个queryset,
20      你不需要重复运行通用的查询。
21         obj=models.Book.objects.filter(id=3)
22 
23         # for i in obj:
24         #     print(i)
25                           ## models.Book.objects.filter(id=3).update(title="GO")
26                           ## obj_new=models.Book.objects.filter(id=3)
27         # for i in obj:
28         #     print(i)   #LOGGING只会打印一次
29 
30 <4>
31      简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache,虽然你并不需要这些
32      数据!为了避免这个,可以用exists()方法来检查是否有数据:
33 
34             obj = Book.objects.filter(id=4)
35             #  exists()的检查可以避免数据放入queryset的cache。
36             if obj.exists():
37                 print("hello world!")
38 
39 <5>当queryset非常巨大时,cache会成为问题
40 
41      处理成千上万的记录时,将它们一次装入内存是很浪费的。更糟糕的是,巨大的queryset可能会锁住系统
42      进程,让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache,可以使用iterator()方法
43      来获取数据,处理完数据就将其丢弃。
44         objs = Book.objects.all().iterator()
45         # iterator()可以一次只从数据库获取少量数据,这样可以节省内存
46         for obj in objs:
47             print(obj.name)
48         #BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
49         for obj in objs:
50             print(obj.name)
51 
52      #当然,使用iterator()方法来防止生成cache,意味着遍历同一个queryset时会重复执行查询。所以使
53      #用iterator()的时候要当心,确保你的代码在操作一个大的queryset时没有重复执行查询
54 
55 总结:
56     queryset的cache是用于减少程序对数据库的查询,在通常的使用下会保证只有在需要的时候才会查询数据库。
57 使用exists()和iterator()方法可以优化程序对内存的使用。不过,由于它们并不会生成queryset cache,可能
58 会造成额外的数据库查询。
View Code

  11.对象查询,单表条件查询,多表条件关联查询

 1 #--------------------对象形式的查找--------------------------
 2     # 正向查找
 3     ret1=models.Book.objects.first()
 4     print(ret1.title)
 5     print(ret1.price)
 6     print(ret1.publisher)
 7     print(ret1.publisher.name)  #因为一对多的关系所以ret1.publisher是一个对象,而不是一个queryset集合
 8 
 9     # 反向查找
10     ret2=models.Publish.objects.last()
11     print(ret2.name)
12     print(ret2.city)
13     #如何拿到与它绑定的Book对象呢?
14     print(ret2.book_set.all()) #ret2.book_set是一个queryset集合
15 
16 #---------------了不起的双下划线(__)之单表条件查询----------------
17 
18 #    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
19 #
20 #    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
21 #    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
22 #
23 #    models.Tb1.objects.filter(name__contains="ven")
24 #    models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
25 #
26 #    models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
27 #
28 #    startswith,istartswith, endswith, iendswith,
29 
30 #----------------了不起的双下划线(__)之多表条件关联查询---------------
31 
32 # 正向查找(条件)
33 
34 #     ret3=models.Book.objects.filter(title='Python').values('id')
35 #     print(ret3)#[{'id': 1}]
36 
37       #正向查找(条件)之一对多
38 
39       ret4=models.Book.objects.filter(title='Python').values('publisher__city')
40       print(ret4)  #[{'publisher__city': '北京'}]
41 
42       #正向查找(条件)之多对多
43       ret5=models.Book.objects.filter(title='Python').values('author__name')
44       print(ret5)
45       ret6=models.Book.objects.filter(author__name="alex").values('title')
46       print(ret6)
47 
48       #注意
49       #正向查找的publisher__city或者author__name中的publisher,author是book表中绑定的字段
50       #一对多和多对多在这里用法没区别
51 
52 # 反向查找(条件)
53 
54     #反向查找之一对多:
55     ret8=models.Publisher.objects.filter(book__title='Python').values('name')
56     print(ret8)#[{'name': '人大出版社'}]  注意,book__title中的book就是Publisher的关联表名
57 
58     ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors')
59     print(ret9)#[{'book__authors': 1}, {'book__authors': 2}]
60 
61     #反向查找之多对多:
62     ret10=models.Author.objects.filter(book__title='Python').values('name')
63     print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}]
64 
65     #注意
66     #正向查找的book__title中的book是表名Book
67     #一对多和多对多在这里用法没区别

 

二、模板

  1.介绍

1 def current_datetime(request):
2     now = datetime.datetime.now()
3     html = "<html><body>It is now %s.</body></html>" % now
4     return HttpResponse(html)

  2.大括号变量

 1 ----------------------------------Template和Context对象 
 2 >>> python manange.py shell  (进入该django项目的环境)
 3 >>> from django.template import Context, Template
 4 >>> t = Template('My name is {{ name }}.')
 5 >>> c = Context({'name': 'Stephane'})
 6 >>> t.render(c)
 7 'My name is Stephane.'
 8 
 9 
10 # 同一模板,多个上下文,一旦有了模板对象,你就可以通过它渲染多个context,无论何时我们都可以
11 # 像这样使用同一模板源渲染多个context,只进行 一次模板创建然后多次调用render()方法渲染会
12 # 更为高效:
13 # Low
14 for name in ('John', 'Julie', 'Pat'):
15     t = Template('Hello, {{ name }}')
16     print t.render(Context({'name': name}))
17 
18 # Good
19 t = Template('Hello, {{ name }}')
20 for name in ('John', 'Julie', 'Pat'):
21     print t.render(Context({'name': name}))

  3.演变

 1 from django.shortcuts import render,HttpResponse
 2 from django.template.loader import get_template #记得导入
 3 # Create your views here.
 4 
 5 
 6 import datetime
 7 from django.template import Template,Context
 8 
 9 # def current_time(req):
10     #原始的视图函数
11     # now=datetime.datetime.now()
12     # html="<html><body>现在时刻:<h1>%s.</h1></body></html>" %now
13     # return HttpResponse(html)
14 
15 
16 
17 # def current_time(req):
18 
19       #django模板修改的视图函数
20 #     now=datetime.datetime.now()
21 #     t=Template('<html><body>现在时刻是:<h1 style="color:red">{{current_date}}</h1></body></html>')
22       #t=get_template('current_datetime.html')
23 #     c=Context({'current_date':now})
24 #     html=t.render(c)
25 #     return HttpResponse(html)
26 
27 #另一种写法(推荐)
28 
29 def current_time(req):
30 
31     now=datetime.datetime.now()
32 
33     return render(req, 'current_datetime.html', {'current_date':now})

  4.深度查找(万能的句号)

 1 #最好是用几个例子来说明一下。
 2 # 首先,句点可用于访问列表索引,例如:
 3 
 4 >>> from django.template import Template, Context
 5 >>> t = Template('Item 2 is {{ items.2 }}.')
 6 >>> c = Context({'items': ['apples', 'bananas', 'carrots']})
 7 >>> t.render(c)
 8 'Item 2 is carrots.'
 9 
10 #假设你要向模板传递一个 Python 字典。 要通过字典键访问该字典的值,可使用一个句点:
11 >>> from django.template import Template, Context
12 >>> person = {'name': 'Sally', 'age': '43'}
13 >>> t = Template('{{ person.name }} is {{ person.age }} years old.')
14 >>> c = Context({'person': person})
15 >>> t.render(c)
16 'Sally is 43 years old.'
17 
18 #同样,也可以通过句点来访问对象的属性。 比方说, Python 的 datetime.date 对象有
19 #year 、 month 和 day 几个属性,你同样可以在模板中使用句点来访问这些属性:
20 
21 >>> from django.template import Template, Context
22 >>> import datetime
23 >>> d = datetime.date(1993, 5, 2)
24 >>> d.year
25 >>> d.month
26 >>> d.day
27 >>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.')
28 >>> c = Context({'date': d})
29 >>> t.render(c)
30 'The month is 5 and the year is 1993.'
31 
32 # 这个例子使用了一个自定义的类,演示了通过实例变量加一点(dots)来访问它的属性,这个方法适
33 # 用于任意的对象。
34 >>> from django.template import Template, Context
35 >>> class Person(object):
36 ...     def __init__(self, first_name, last_name):
37 ...         self.first_name, self.last_name = first_name, last_name
38 >>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.')
39 >>> c = Context({'person': Person('John', 'Smith')})
40 >>> t.render(c)
41 'Hello, John Smith.'
42 
43 # 点语法也可以用来引用对象的方法。 例如,每个 Python 字符串都有 upper() 和 isdigit()
44 # 方法,你在模板中可以使用同样的句点语法来调用它们:
45 >>> from django.template import Template, Context
46 >>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}')
47 >>> t.render(Context({'var': 'hello'}))
48 'hello -- HELLO -- False'
49 >>> t.render(Context({'var': '123'}))
50 '123 -- 123 -- True'
51 
52 # 注意这里调用方法时并* 没有* 使用圆括号 而且也无法给该方法传递参数;你只能调用不需参数的
53 # 方法。

  5.过滤器

语法:{{obj|filter:param}}
 1 # 1  add          :   给变量加上相应的值
 2    #
 3    # 2  addslashes   :    给变量中的引号前加上斜线
 4    #
 5    # 3  capfirst     :    首字母大写
 6    #
 7    # 4  cut          :   从字符串中移除指定的字符
 8    #
 9    # 5  date         :   格式化日期字符串
10    #
11    # 6  default      :   如果值是False,就替换成设置的默认值,否则就是用本来的值
12    #
13    # 7  default_if_none:  如果值是None,就替换成设置的默认值,否则就使用本来的值
14 
15 
16 #实例:
17 
18 #value1="aBcDe"
19 {{ value1|upper }}<br>
20 
21 #value2=5
22 {{ value2|add:3 }}<br>
23 
24 #value3='he  llo wo r ld'
25 {{ value3|cut:' ' }}<br>
26 
27 #import datetime
28 #value4=datetime.datetime.now()
29 {{ value4|date:'Y-m-d' }}<br>
30 
31 #value5=[]
32 {{ value5|default:'空的' }}<br>
33 
34 #value6='<a href="#">跳转</a>'
35 
36 {{ value6 }}
37 
38 {% autoescape off %}
39   {{ value6 }}
40 {% endautoescape %}
41 
42 {{ value6|safe }}<br>
43 
44 {{ value6|striptags }}
45 
46 #value7='1234'
47 {{ value7|filesizeformat }}<br>
48 {{ value7|first }}<br>
49 {{ value7|length }}<br>
50 {{ value7|slice:":-1" }}<br>
51 
52 #value8='http://www.baidu.com/?a=1&b=3'
53 {{ value8|urlencode }}<br>
54     value9='hello I am yuan'
View Code
1.text|truncatechars:200
2.text|truncatewords:200

  6.IF判断

 1 {% if num >= 100 and 8 %}
 2 
 3     {% if num > 200 %}
 4         <p>num大于200</p>
 5     {% else %}
 6         <p>num大于100小于200</p>
 7     {% endif %}
 8 
 9 {% elif num < 100%}
10     <p>num小于100</p>
11 
12 {% else %}
13     <p>num等于100</p>
14 
15 {% endif %}
16 
17 
18 
19 {% if %} 标签接受and,or或者not来测试多个变量值或者否定一个给定的变量
20 {% if %} 标签不允许同一标签里同时出现and和or,否则逻辑容易产生歧义,例如下面的标签是不合法的:
21 
22 {% if obj1 and obj2 or obj3 %} 

  7.FOR循环

 1 <ul>
 2 {% for obj in list %}
 3     <li>{{ obj.name }}</li>
 4 {% endfor %}
 5 </ul>
 6 
 7 
 8 #在标签里添加reversed来反序循环列表:
 9 
10     {% for obj in list reversed %}
11     ...
12     {% endfor %}
13 
14 #{% for %}标签可以嵌套:
15 
16     {% for country in countries %}
17         <h1>{{ country.name }}</h1>
18         <ul>
19          {% for city in country.city_list %}
20             <li>{{ city }}</li>
21          {% endfor %}
22         </ul>
23     {% endfor %}
24 
25 
26 #系统不支持中断循环,系统也不支持continue语句,{% for %}标签内置了一个forloop模板变量,
27 #这个变量含有一些属性可以提供给你一些关于循环的信息
28 
29 1,forloop.counter表示循环的次数,它从1开始计数,第一次循环设为1:
30 
31     {% for item in todo_list %}
32         <p>{{ forloop.counter }}: {{ item }}</p>
33     {% endfor %}
34 2,forloop.counter0 类似于forloop.counter,但它是从0开始计数,第一次循环设为0
35 3,forloop.revcounter
36 4,forloop.revcounter0
37 5,forloop.first当第一次循环时值为True,在特别情况下很有用:
38 
39     
40     {% for object in objects %}   
41          {% if forloop.first %}<li class="first">{% else %}<li>{% endif %}   
42          {{ object }}   
43         </li>  
44     {% endfor %}  
45     
46 # 富有魔力的forloop变量只能在循环中得到,当模板解析器到达{% endfor %}时forloop就消失了
47 # 如果你的模板context已经包含一个叫forloop的变量,Django会用{% for %}标签替代它
48 # Django会在for标签的块中覆盖你定义的forloop变量的值
49 # 在其他非循环的地方,你的forloop变量仍然可用
50 
51 
52 #{% empty %}
53 
54 {{li }}
55       {%  for i in li %}
56           <li>{{ forloop.counter0 }}----{{ i }}</li>
57       {% empty %}
58           <li>this is empty!</li>
59       {% endfor %}
60 
61 #         [11, 22, 33, 44, 55]
62 #            0----11
63 #            1----22
64 #            2----33
65 #            3----44
66 #            4----55

  8.引用别名

1 <form action="{% url "bieming"%}" >
2           <input type="text">
3           <input type="submit"value="提交">
4           {%csrf_token%}
5 </form>

  9.WITH(用更简单的变量名替代复杂的变量名)

{% with total=fhjsaldfhjsdfhlasdfhljsdal %} {{ total }} {% endwith %}

  10.禁止render

1 {% verbatim %}
2          {{ hello }}
3 {% endverbatim %}

  11.自定义filter和simple_tag

  a.在app中创建templatetags模块(必须的)

  b.创建任意 .py 文件,如:my_tags.py

 1 from django import template
 2 from django.utils.safestring import mark_safe
 3 
 4 register = template.Library()   #register的名字是固定的,不可改变
 5 
 6 
 7 @register.filter
 8 def filter_multi(v1,v2):
 9     return  v1 * v2
10 
11 
12 @register.simple_tag
13 def simple_tag_multi(v1,v2):
14     return  v1 * v2
15 
16 
17 @register.simple_tag
18 def my_input(id,arg):
19     result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
20     return mark_safe(result)
View Code

  c.在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py :{% load my_tags %}

  d.使用simple_tag和filter(如何调用)

 1 -------------------------------.html
 2 {% load xxx %}   #首行
 3     
 4     
 5     
 6     
 7  # num=12
 8 {{ num|filter_multi:2 }} #24
 9 
10 {{ num|filter_multi:"[22,333,4444]" }}
11 
12 
13 {% simple_tag_multi 2 5 %}  参数不限,但不能放在if for语句中
14 {% simple_tag_multi num 5 %}
View Code

  注意:filter可以用在if等语句后,simple_tag不可以

1 {% if num|filter_multi:30 > 100 %}
2     {{ num|filter_multi:30 }}
3 {% endif %}
View Code

  12.继承

 1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
 2 <html lang="en">
 3 <head>
 4     <title>{% block title %}{% endblock %}</title>
 5 </head>
 6 <body>
 7     <h1>My helpful timestamp site</h1>
 8     {% block content %}{% endblock %}
 9     {% block footer %}
10     <hr>
11     <p>Thanks for visiting my site.</p>
12     {% endblock %}
13 </body>
14 </html>
base.html
1 {% extends "base.html" %}
2  
3 {% block title %}The current time{% endblock %}
4  
5 {% block content %}
6 <p>It is now {{ current_date }}.</p>
7 {% endblock %}
index.html

 

posted @ 2017-05-17 14:16  willianflasky  阅读(137)  评论(0编辑  收藏  举报