Django进修笔记（13）:模板进阶

添加时间:2013-5-17 点击量:

一、关于Django模板

之前洋洋洒洒写了一篇Django模板，然则“手?”不警惕给删除了。。。。今天重写一篇，就相当于总结。

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

重视：始终要知道模板template是Django供给的机制，里面有模板变量和模板标签，仅此罢了！它解决在视图中HTML硬编码的题目，模板是一个纯文本文件，或是一个用Django模板说话标识表记标帜过的通俗的Python字符串。

二、template模块

1 >>>  django import template ＃导入模板

1、创建模板对象
Template 类就在 django.template 模块中，机关函数接管一个参数。如：

1 t = template.Template（My name is {{ name }}.）

创建一个 Template 对象，模板体系在内部编译这个模板到内部格局，并做优化，做好衬着的筹办。
重视：若是模板语法有错误，那么在调用 Template（） 时就会抛出 TemplateSyntaxError 异常

2、模板衬着
衬着就是是经由过程从context获取值来调换模板中变量并履行所有的模板标签。
一旦创建一个 Template 对象，你可以用 context 来传递数据给它。一个context是一系列变量和它们值的凑集，类似字典Context 类在 django.template 模块里，她的机关函数带有一个可选的参数：一个字典映射变量和它们的值。
调用 Template 对象的 render（） 办法并传递context来填充模板：

重视：t.render（c）返回的值是一个Unicode对象，不是通俗的Python字符串。可以经由过程字符串前的u来区分。在框架中，Django会一向应用Unicode对象而不是通俗的字符串。

当然，同一模板，还可以有多个高低文（即context）

3.句点查找规矩：

1）：字典类型查找（比如 foo[bar] ）
2）：属性查找（比如 foo.bar ）
3）：办法调用（比如 foo.bar（） ）
4）：列表类型索引查找（比如 foo[bar] ）
如：

1 ＃用于接见列表索引

2 >>>  django.template import Template， Context

3 >>> t = Template（Item 2 is {{ items.2 }}.）

4 >>> c = Context（{items: [apples， bananas， carrots]}）

5 >>> t.render（c）

6 uItem 2 is carrots.

三、在视图中应用

拜见：
Django进修笔记（4）:Django模板体系（上）
Django进修笔记（5）:Django模板体系（下）

四、RequestContext和Context处理惩罚器

 django.template import Context，RequestContext

RequestContext 默认地在模板context中参加了一些变量，如 HttpRequest 对象或当前登录用户的相干信息。

demo：

URL：

urlpatterns = patterns（，

    （r^test1/￥，demo.views.t1）， 

    （r^test2/￥，demo.views.t2），        

）

应用Context和RequestContext差别，重视注释掉的项目组是属于Context的，这里视图冗余，故应用RequestContext

＃coding=utf-8

 django.http import HttpRequest，HttpResponse，HttpResponseRedirect

 django.template import TemplateDoesNotExist，RequestContext，loader，Context，Template



def custom_pro（request）:

    app、user、IP

    return{

       app:My app，

       user:request.user，

       ip:request.META[REMOTE_ADDR]

    }

    

def custom_other_pro（request）:

    name，age，job

    return{

       name:BeginMan，

       age:22，

       job:Pythoner       

    }

    

def t1（request）:

    t=loader.get_template（test/t1.html）

＃    c=Context（{app:My app，

＃               user:request.user，

＃               ip:request.META[REMOTE_ADDR]，

＃               message:i am t1}）

    c=RequestContext（request，{message:i am t1}，processors=[custom_pro]）

    return HttpResponse（t.render（c））



def t2（request）:

    t=loader.get_template（test/t2.html）

＃    c=Context（{app:My app，

＃               user:request.user，

＃               ip:request.META[REMOTE_ADDR]，

＃               message:i am t2}）

    c=RequestContext（request，{message:i am t2}，processors=（custom_pro，custom_other_pro））＃元祖情势也行

    return HttpResponse（t.render（c））

当然。也可以进行数据处理惩罚：

def custom_Msg（request）:

    return Msg data

    msg=Msg.objects.all（）

    return{msg:msg}

解析：

1）:定义custom_pro、custom_other_pro、 custom_Msg这些函数，其实都是context处理惩罚器，它接管一个 HttpRequest 对象，然后返回一个字典，这个字典中包含了可以在模板context中应用的变量。它就做了这么多。

2）:我们在这两个视图函数顶用 RequestContext 庖代了 Context 。在context对象的构建上有两个不合点。一， RequestContext 的第一个参数须要传递一个 HttpRequest 对象，就是传递给视图函数的第一个参数（ request ）。二， RequestContext 有一个可选的参数 processors（处理惩罚器的意思） ，这是一个包含context处理惩罚器函数的列表或者元组。在这里，我们传递了我们之前定义的处理惩罚器函数 custom_pro、custom_other_pro、 custom_Msg

3）:若是还不熟悉打听，可以看看RequestContext的源码：

源码：

class RequestContext（Context）:

    

    This subclass of template.Context automatically populates itself using

    the processors defined in TEMPLATE_CONTEXT_PROCESSORS.

    Additional processors can be specified as a list of callables

    using the processors keyword argument.

    

    def __init__（self， request， dict=None， processors=None， current_app=None）:

        Context.__init__（self， dict， current_app=current_app）

        if processors is None:

            processors = （）

        else:

            processors = tuple（processors）

        for processor in get_standard_processors（） + processors:

            self.（processor（request））

接下来就开端处理惩罚模板了，这里列出了t2.html：

-------custom_pro<br>

<div style=color:Red>

{{app}}<br>

{{user}}<br>

{{ip}}<br>

{{message}}<br>

</div>



-------custom_other_pro<br>

<div style=color:Blue>

{{name}}<br>

{{age}}<br>

{{job}}

</div>



<div style=color:＃CCC>

{％ for obj in msg ％}

<li>{{obj.title}}</li>

{％ endfor ％}

</div>

结果如下：

扩大：

render_to_response（） 这个快捷体式格式，它可以简化调用 loader.get_template（），然则上方为了申明两者之间的差别，没有应用，这里我们还是要应用render_to_response（），此时要参加context_instance参数才干正常应用：

def t2（request）:

    return render_to_response（

        test/t2.html，

        {message:t2}，

        context_instance=RequestContext（request，processors=（custom_pro，custom_other_pro，custom_Msg）））

＃    t=loader.get_template（test/t2.html）

＃    c=RequestContext（request，{message:i am t2}，processors=（custom_pro，custom_other_pro，custom_Msg））

＃    return HttpResponse（t.render（c））

五、全局 context处理惩罚器

Django供给对全局 context处理惩罚器的支撑。 TEMPLATE_CONTEXT_PROCESSORS 指定了哪些context processors老是默认被应用。如许就省去了每次应用 RequestContext 都指定 processors 的麻烦。

默认景象下， TEMPLATE_CONTEXT_PROCESSORS 设置如下：

TEMPLATE_CONTEXT_PROCESSORS = （

    django.core.context_processors.auth，

    django.core.context_processors.debug，

    django.core.context_processors.i18n，

    django.core.context_processors.media，

）

在默认景象下被启用
这个设置项是一个可调用函数的元组，此中的每个函数应用了和上文中我们的 custom_proc 雷同的接口，它们以request对象作为参数，返回一个会被归并传给context的字典：接管一个request对象作为参数，返回一个包含了将被归并到context中的项的字典。

具体解析见下节

无论对感情还是对生活，“只要甜不要苦”都是任性而孩子气的，因为我们也不完美，我们也会伤害人。正因为我们都不完美，也因为生活从不是事事如意，所以对这些“瑕疵”的收纳才让我们对生活、对他人的爱变得日益真实而具体。—— 汪冰《世界再亏欠你，也要敢于拥抱幸福》

分享到：

相关文章

按版本划分

按功能划分

企业管理软件

Django进修笔记（13）:模板进阶