[计算机网络] 网络协议流量统计(二) —— 流量分析近日工作情况

由于客户需求的变化,近日的工作重点不得不发生比较大的改变。

刚刚得知这次的监控目标是IDC机房, 那以往的分析模型就不再适用于这次的项目了。 因为普通的网络分析中,我们首先要猜测用户流量有哪些业务构成,然后根据猜测的结果去测试分析,根据长尾理论,我们的分析重点只需要集中在大约20%的重点业务上就能分辨出绝大部分的流量,尤其是在P2P横行的今天。 但是针对IDC机房就不一样了,p2p流量就完全不存在了,而我们平时仅占千分之一不到的业务很可能有大量服务器放在这个机房里面而导致其是主要业务流量,而这种业务我们是不可能去靠猜测来完成的,于是目前就很被动。

客户迟迟不给业务构成,流量分析也就一直停滞着,不得已只好准备再用一次长尾理论,准备统计占主业务80%的IP地址,向客户要这些IP的租用厂商,然后再分析了,希望能赶紧做完,过个好年。

笔记:
wap的content-type很固定,可通过此来识别wap网站(90%),剩下10%可通过正文前面的标识来识别。

笔记2:
现在web和wap真是越来越没有区别了。

[原创] python编码问题整理

这两天折腾spider, 被编码问题搞了半天。

首先是decode和encode,decode是将其他类型的编码转换到unicode,而encode则是将unicode的编码转换到其他类型编码。例如uhtml = html.decode('gb2312') 将gb2312的编码转换成了unicode, html=uhtml.encode('gb2312')则相反。

在python中,一般的做法是文本进入的时候先转换成unicode, 输出的时候在转换成其他编码, 以保证内部编码统一。

在spider中,抓取的网页经常是gb2312编码,但是实际操作中用gb2312却很经常出错, 在这里推荐用gb18030进行解码。

另注: StringIO支持unicode 但cStringIO却不支持unicode

[django] 博客需要改进的地方

小记一下:
1、添加目录删除功能
2、修改删除放到文章标题下面
3、分页功能改进
4、wordpress博客导入功能
5、待补充

[备忘] [转载]C++ Under the Hood译文

Vbptr是做什么用的呢?看下面
 该变量指向一个全类共享的偏移量表 
附:转一篇文章

——谈VC++对象模型
(美)简  格雷
程化    译

译者前言

一 个C++程序员,想要进一步提升技术水平的话,应该多了解一些语言的语意细节。对于使用VC++的程序员来说,还应该了解一些VC++对于C++的诠释。 Inside the C++ Object Model虽然是一本好书,然而,书的篇幅多一些,又和具体的VC++关系小一些。因此,从篇幅和内容来看,译者认为本文是深入理解C++对象模型比较好 的一个出发点。
这篇文章以前看到时就觉得很好,旧文重读,感觉理解得更多一些了,于是产生了翻译出来,与大家共享的想法。虽然文章不长,但时间有限,又若干次在翻译时打盹睡着,拖拖拉拉用了小一个月。
一方面因本人水平所限,另一方面因翻译时经常打盹,错误之处恐怕不少,欢迎大家批评指正。

本文原文出处为MSDN。如果你安装了MSDN,可以搜索到C++ Under the Hood。否则也可在网站上找到 http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/dnarvc/html/jangrayhood.asp

1 前言

了 解你所使用的编程语言究竟是如何实现的,对于C++程序员可能特别有意义。首先,它可以去除我们对于所使用语言的神秘感,使我们不至于对于编译器干的活感 到完全不可思议;尤其重要的是,它使我们在Debug和使用语言高级特性的时候,有更多的把握。当需要提高代码效率的时候,这些知识也能够很好地帮助我 们。

本文着重回答这样一些问题:
 * 类如何布局?
 * 成员变量如何访问?
 * 成员函数如何访问?
 * 所谓的“调整块”(adjuster thunk)是怎么回事?
 * 使用如下机制时,开销如何:
 * 单继承、多重继承、虚继承
 * 虚函数调用
 * 强制转换到基类,或者强制转换到虚基类
 * 异常处理
首先,我们顺次考察C兼容的结构(struct)的布局,单继承,多重继承,以及虚继承;
接着,我们讲成员变量和成员函数的访问,当然,这里面包含虚函数的情况;
再接下来,我们考察构造函数,析构函数,以及特殊的赋值操作符成员函数是如何工作的,数组是如何动态构造和销毁的;
最后,简单地介绍对异常处理的支持。

对 每个语言特性,我们将简要介绍该特性背后的动机,该特性自身的语意(当然,本文决不是“C++入门”,大家对此要有充分认识),以及该特性在微软的 VC++中是如何实现的。这里要注意区分抽象的C++语言语意与其特定实现。微软之外的其他C++厂商可能提供一个完全不同的实现,我们偶尔也会将 VC++的实现与其他实现进行比较。

2 类布局

本节讨论不同的继承方式造成的不同内存布局。

2.1 C结构(struct)

由 于C++基于C,所以C++也“基本上”兼容C。特别地,C++规范在“结构”上使用了和C相同的,简单的内存布局原则:成员变量按其被声明的顺序排列, 按具体实现所规定的对齐原则在内存地址上对齐。所有的C/C++厂商都保证他们的C/C++编译器对于有效的C结构采用完全相同的布局。这里,A是一个简 单的C结构,其成员布局和对齐方式都一目了然

struct A {
   char c;
   int i;
};

译者注:从上图可见,A在内存中占有8个字节,按照声明成员的顺序,前4个字节包含一个字符(实际占用1个字节,3个字节空着,补对齐),后4个字节包含一个整数。A的指针就指向字符开始字节处。

2.2 有C++特征的C结构

当 然了,C++不是复杂的C,C++本质上是面向对象的语言:包含继承、封装,以及多态。原始的C结构经过改造,成了面向对象世界的基石——类。除了成员变 量外,C++类还可以封装成员函数和其他东西。然而,有趣的是,除非为了实现虚函数和虚继承引入的隐藏成员变量外,C++类实例的大小完全取决于一个类及 其基类的成员变量!成员函数基本上不影响类实例的大小。

这里提供的B是一个C结构,然而,该结构有一些C++特 征:控制成员可见性的“public/protected/private”关键字、成员函数、静态成员,以及嵌套的类型声明。虽然看着琳琅满目,实际上 只有成员变量才占用类实例的空间。要注意的是,C++标准委员会不限制由“public/protected/private”关键字分开的各段在实现时 的先后顺序,因此,不同的编译器实现的内存布局可能并不相同。(在VC++中,成员变量总是按照声明时的顺序排列)。

struct B {
public:
   int bm1;
protected:
   int bm2;
private:
   int bm3;
   static int bsm;
   void bf();
   static void bsf();
   typedef void* bpv;
   struct N { };
};

译者注:B中,为何static int bsm不占用内存空间?因为它是静态成员,该数据存放在程序的数据段中,不在类实例中。

2.3 单继承

C++ 提供继承的目的是在不同的类型之间提取共性。比如,科学家对物种进行分类,从而有种、属、纲等说法。有了这种层次结构,我们才可能将某些具备特定性质的东 西归入到最合适的分类层次上,如“怀孩子的是哺乳动物”。由于这些属性可以被子类继承,所以,我们只要知道“鲸鱼、人”是哺乳动物,就可以方便地指出“鲸 鱼、人都可以怀孩子”。那些特例,如鸭嘴兽(生蛋的哺乳动物),则要求我们对缺省的属性或行为进行覆盖。
C++中的继承语法很简单,在子类后加上“:base”就可以了。下面的D继承自基类C。

struct C {
   int c1;
   void cf();
};

struct D : C {
   int d1;
   void df();
};

既然派生类要保留基类的所有属性和行为,自然地,每个派生类的实例都包含了一份完整的基类实例数据。在D中,并不是说基类C的数据一定要放在D的数据之前,只不过这样放的话,能够保证D中的C对象地址,恰好是D对象地址的第一个字节。这种安排之下,有了派生类D的指针,要获得基类C的指针,就不必要计算偏移量了。几乎所有知名的C++厂商都采用这种内存安排(基类成员在前)。在单继承类层次下,每一个新的派生类都简单地把自己的成员变量添加到基类的成员变量之后。看看上图,C对象指针和D对象指针指向同一地址。

2.4 多重继承

大多数情况下,其实单继承就足够了。但是,C++为了我们的方便,还提供了多重继承。

比 如,我们有一个组织模型,其中有经理类(分任务),工人类(干活)。那么,对于一线经理类,即既要从上级经理那里领取任务干活,又要向下级工人分任务的角 色来说,如何在类层次中表达呢?单继承在此就有点力不胜任。我们可以安排经理类先继承工人类,一线经理类再继承经理类,但这种层次结构错误地让经理类继承 了工人类的属性和行为。反之亦然。当然,一线经理类也可以仅仅从一个类(经理类或工人类)继承,或者一个都不继承,重新声明一个或两个接口,但这样的实现 弊处太多:多态不可能了;未能重用现有的接口;最严重的是,当接口变化时,必须多处维护。最合理的情况似乎是一线经理从两个地方继承属性和行为——经理 类、工人类。

C++就允许用多重继承来解决这样的问题:

struct Manager ... { ... };
struct Worker ... { ... };
struct MiddleManager : Manager, Worker { ... };

这样的继承将造成怎样的类布局呢?下面我们还是用“字母类”来举例:

struct E {
   int e1;
   void ef();
};


struct F : C, E {
   int f1;
   void ff();
};
结构F从C和E多重继承得来。与单继承相同的是,F实例拷贝了每个基类的所有数据。与单继承不同的是,在多重继承下,内嵌的两个基类的对象指针不可能全都与派生类对象指针相同:
F f;
// (void*)&f == (void*)(C*)&f;
// (void*)&f < (void*)(E*)&f;
译者注:上面那行说明C对象指针与F对象指针相同,下面那行说明E对象指针与F对象指针不同。

观察类布局,可以看到F中内嵌的E对象,其指针与F指针并不相同。正如后文讨论强制转化和成员函数时指出的,这个偏移量会造成少量的调用开销。

具体的编译器实现可以自由地选择内嵌基类和派生类的布局。VC++按照基类的声明顺序先排列基类实例数据,最后才排列派生类数据。当然,派生类数据本身也是按照声明顺序布局的(本规则并非一成不变,我们会看到,当一些基类有虚函数而另一些基类没有时,内存布局并非如此)。

2.5 虚继承

回到我们讨论的一线经理类例子。让我们考虑这种情况:如果经理类和工人类都继承自“雇员类”,将会发生什么?
struct Employee { ... };
struct Manager : Employee { ... };
struct Worker : Employee { ... };
struct MiddleManager : Manager, Worker { ... };
如果经理类和工人类都继承自雇员类,很自然地,它们每个类都会从雇员类获得一份数据拷贝。如果不作特殊处理,一线经理类的实例将含有两个雇员类实例,它们 分别来自两个雇员基类。如果雇员类成员变量不多,问题不严重;如果成员变量众多,则那份多余的拷贝将造成实例生成时的严重开销。更糟的是,这两份不同的雇 员实例可能分别被修改,造成数据的不一致。因此,我们需要让经理类和工人类进行特殊的声明,说明它们愿意共享一份雇员基类实例数据。

很不幸,在C++中,这种“共享继承”被称为“虚继承”,把问题搞得似乎很抽象。虚继承的语法很简单,在指定基类时加上virtual关键字即可。
struct Employee { ... };
struct Manager : virtual Employee { ... };
struct Worker : virtual Employee { ... };
struct MiddleManager : Manager, Worker { ... };
使用虚继承,比起单继承和多重继承有更大的实现开销、调用开销。回忆一下,在单继承和多重继承的情况下,内嵌的基类实例地址比起派生类实例地址来,要么地 址相同(单继承,以及多重继承的最靠左基类),要么地址相差一个固定偏移量(多重继承的非最靠左基类)。然而,当虚继承时,一般说来,派生类地址和其虚基 类地址之间的偏移量是不固定的,因为如果这个派生类又被进一步继承的话,最终派生类会把共享的虚基类实例数据放到一个与上一层派生类不同的偏移量处。请看 下例:

struct G : virtual C {
   int g1;
   void gf();
};
译者注:GdGvbptrG(In G, the displacement of G’s virtual base pointer to G)意思是:在G中,G对象的指针与G的虚基类表指针之间的偏移量,在此可见为0,因为G对象内存布局第一项就是虚基类表指针; GdGvbptrC(In G, the displacement of G’s virtual base pointer to C)意思是:在G中,C对象的指针与G的虚基类表指针之间的偏移量,在此可见为8。

struct H : virtual C {
   int h1;
   void hf();
};

struct I : G, H {
   int i1;
   void _if();
};
暂时不追究vbptr成员变量从何而来。从上面这些图可以直观地看到,在G对象中,内嵌的C基类对象的数据紧跟在G的数据之后,在H对象中,内嵌的C基类 对象的数据也紧跟在H的数据之后。但是,在I对象中,内存布局就并非如此了。VC++实现的内存布局中,G对象实例中G对象和C对象之间的偏移,不同于I 对象实例中G对象和C对象之间的偏移。当使用指针访问虚基类成员变量时,由于指针可以是指向派生类实例的基类指针,所以,编译器不能根据声明的指针类型计 算偏移,而必须找到另一种间接的方法,从派生类指针计算虚基类的位置。

在VC++中,对每个继承自虚基类的类实例,将增加一个隐藏的“虚基类表指针”(vbptr)成员变量,从而达到间接计算虚基类位置的目的。该变量指向一个全类共享的偏移量表,表中项目记录了对于该类而言,“虚基类表指针”与虚基类之间的偏移量。

其 它的实现方式中,有一种是在派生类中使用指针成员变量。这些指针成员变量指向派生类的虚基类,每个虚基类一个指针。这种方式的优点是:获取虚基类地址时, 所用代码比较少。然而,编译器优化代码时通常都可以采取措施避免重复计算虚基类地址。况且,这种实现方式还有一个大弊端:从多个虚基类派生时,类实例将占 用更多的内存空间;获取虚基类的虚基类的地址时,需要多次使用指针,从而效率较低等等。

在VC++中,G拥有一 个隐藏的“虚基类表指针”成员,指向一个虚基类表,该表的第二项是GdGvbptrC。(在G中,虚基类对象C的地址与G的“虚基类表指针”之间的偏移量 (当对于所有的派生类来说偏移量不变时,省略“d”前的前缀))。比如,在32位平台上,GdGvptrC是8个字节。同样,在I实例中的G对象实例也有 “虚基类表指针”,不过该指针指向一个适用于“G处于I之中”的虚基类表,表中一项为IdGvbptrC,值为20。

观察前面的G、H和I,我们可以得到如下关于VC++虚继承下内存布局的结论:
 首先排列非虚继承的基类实例;
 有虚基类时,为每个基类增加一个隐藏的vbptr,除非已经从非虚继承的类那里继承了一个vbptr;
 排列派生类的新数据成员;
 在实例最后,排列每个虚基类的一个实例。

该布局安排使得虚基类的位置随着派生类的不同而“浮动不定”,但是,非虚基类因此也就凑在一起,彼此的偏移量固定不变。

3 成员变量

介绍了类布局之后,我们接着考虑对不同的继承方式,访问成员变量的开销究竟如何。

没有继承。没有任何继承关系时,访问成员变量和C语言的情况完全一样:从指向对象的指针,考虑一定的偏移量即可。
C* pc;
pc->c1; // *(pc + dCc1);
译者注:pc是指向C的指针。
 访问C的成员变量c1,只需要在pc上加上固定的偏移量dCc1(在C中,C指针地址与其c1成员变量之间的偏移量值),再获取该指针的内容即可。

单继承。由于派生类实例与其基类实例之间的偏移量是常数0,所以,可以直接利用基类指针和基类成员之间的偏移量关系,如此计算得以简化。
D* pd;
pd->c1; // *(pd + dDC + dCc1); // *(pd + dDc1);
pd->d1; // *(pd + dDd1);
译者注:D从C单继承,pd为指向D的指针。
 当访问基类成员c1时,计算步骤本来应该为“pd+dDC+dCc1”,即为先计算D对象和C对象之间的偏移,再在此基础上加上C对象指针与成员变量c1 之间的偏移量。然而,由于dDC恒定为0,所以直接计算C对象地址与c1之间的偏移就可以了。
 当访问派生类成员d1时,直接计算偏移量。

多重继承。虽然派生类与某个基类之间的偏移量可能不为0,然而,该偏移量总是一个常数。只要是个常数,访问成员变量,计算成员变量偏移时的计算就可以被简化。可见即使对于多重继承来说,访问成员变量开销仍然不大。
F* pf;
pf->c1; // *(pf + dFC + dCc1); // *(pf + dFc1);
pf->e1; // *(pf + dFE + dEe1); // *(pf + dFe1);
pf->f1; // *(pf + dFf1);
译者注:F继承自C和E,pf是指向F对象的指针。
 访问C类成员c1时,F对象与内嵌C对象的相对偏移为0,可以直接计算F和c1的偏移;
 访问E类成员e1时,F对象与内嵌E对象的相对偏移是一个常数,F和e1之间的偏移计算也可以被简化;
 访问F自己的成员f1时,直接计算偏移量。

虚继承。当类有虚基类时,访问非虚基类的成员仍然是计算固定偏移量的问题。然而,访问虚基类的成员变量,开销就增大了, 因为必须经过如下步骤才能获得成员变量的地址:获取“虚基类表指针”;获取虚基类表中某一表项的内容;把内容中指出的偏移量加到“虚基类表指针”的地址 上。然而,事情并非永远如此。正如下面访问I对象的c1成员那样,如果不是通过指针访问,而是直接通过对象实例,则派生类的布局可以在编译期间静态获得, 偏移量也可以在编译时计算,因此也就不必要根据虚基类表的表项来间接计算了。

I* pi;
pi->c1; // *(pi + dIGvbptr + (*(pi+dIGvbptr))[1] + dCc1);
pi->g1; // *(pi + dIG + dGg1); // *(pi + dIg1);
pi->h1; // *(pi + dIH + dHh1); // *(pi + dIh1);
pi->i1; // *(pi + dIi1);
I i;
i.c1; // *(&i + IdIC + dCc1); // *(&i + IdIc1);
译者注:I继承自G和H,G和H的虚基类是C,pi是指向I对象的指针。
 访问虚基类C的成员c1时,dIGvbptr是“在I中,I对象指针与G的“虚基类表指针”之间的偏移”,*(pi + dIGvbptr)是虚基类表的开始地址,*(pi + dIGvbptr)[1]是虚基类表的第二项的内容(在I对象中,G对象的“虚基类表指针”与虚基类之间的偏移),dCc1是C对象指针与成员变量c1之 间的偏移;
 访问非虚基类G的成员g1时,直接计算偏移量;
 访问非虚基类H的成员h1时,直接计算偏移量;
 访问自身成员i1时,直接使用偏移量;
当声明了一个对象实例,用点“.”操作符访问虚基类成员c1时,由于编译时就完全知道对象的布局情况,所以可以直接计算偏移量。

当 访问类继承层次中,多层虚基类的成员变量时,情况又如何呢?比如,访问虚基类的虚基类的成员变量时?一些实现方式为:保存一个指向直接虚基类的指针,然后 就可以从直接虚基类找到它的虚基类,逐级上推。VC++优化了这个过程。VC++在虚基类表中增加了一些额外的项,这些项保存了从派生类到其各层虚基类的 偏移量。

4 强制转化

如果没有虚基类的问题,将一个指针强制转化为另一个类型的指针代价并不高昂。如果在要求转化的两个指针之间有“基类-派生类”关系,编译器只需要简单地在两者之间加上或者减去一个偏移量即可(并且该量还往往为0)。

F* pf;
(C*)pf; // (C*)(pf ? pf + dFC : 0); // (C*)pf;
(E*)pf; // (E*)(pf ? pf + dFE : 0);

C 和E是F的基类,将F的指针pf转化为C*或E*,只需要将pf加上一个相应的偏移量。转化为C类型指针C*时,不需要计算,因为F和C之间的偏移量为 0。转化为E类型指针E*时,必须在指针上加一个非0的偏移常量dFE。C++规范要求NULL指针在强制转化后依然为NULL,因此在做强制转化需要的 运算之前,VC++会检查指针是否为NULL。当然,这个检查只有当指针被显示或者隐式转化为相关类型指针时才进行;当在派生类对象中调用基类的方法,从 而派生类指针被在后台转化为一个基类的Const “this” 指针时,这个检查就不需要进行了,因为在此时,该指针一定不为NULL。

正如你猜想的,当继承关系中存在虚基类时,强制转化的开销会比较大。具体说来,和访问虚基类成员变量的开销相当。

I* pi;
(G*)pi; // (G*)pi;
(H*)pi; // (H*)(pi ? pi + dIH : 0);
(C*)pi; // (C*)(pi ? (pi+dIGvbptr + (*(pi+dIGvbptr))[1]) : 0);
译者注:pi是指向I对象的指针,G,H是I的基类,C是G,H的虚基类。
 强制转化pi为G*时,由于G*和I*的地址相同,不需要计算;
 强制转化pi为H*时,只需要考虑一个常量偏移;
 强制转化pi为C*时,所作的计算和访问虚基类成员变量的开销相同,首先得到G的虚基类表指针,再从虚基类表的第二项中取出G到虚基类C的偏移量,最后根据pi、虚基类表偏移和虚基类C与虚基类表指针之间的偏移计算出C*。

一般说来,当从派生类中访问虚基类成员时,应该先强制转化派生类指针为虚基类指针,然后一直使用虚基类指针来访问虚基类成员变量。这样做,可以避免每次都要计算虚基类地址的开销。见下例。

/* before: */             ... pi->c1 ... pi->c1 ...
/* faster: */ C* pc = pi; ... pc->c1 ... pc->c1 ...
译者注:前者一直使用派生类指针pi,故每次访问c1都有计算虚基类地址的较大开销;后者先将pi转化为虚基类指针pc,故后续调用可以省去计算虚基类地址的开销。

5 成员函数

一 个C++成员函数只是类范围内的又一个成员。X类每一个非静态的成员函数都会接受一个特殊的隐藏参数——this指针,类型为X* const。该指针在后台初始化为指向成员函数工作于其上的对象。同样,在成员函数体内,成员变量的访问是通过在后台计算与this指针的偏移来进行。

struct P {
   int p1;
   void pf(); // new
   virtual void pvf(); // new
};

P 有一个非虚成员函数pf(),以及一个虚成员函数pvf()。很明显,虚成员函数造成对象实例占用更多内存空间,因为虚成员函数需要虚函数表指针。这一点 以后还会谈到。这里要特别指出的是,声明非虚成员函数不会造成任何对象实例的内存开销。现在,考虑P::pf()的定义。
void P::pf() { // void P::pf([P *const this])
   ++p1;   // ++(this->p1);
}

这 里P:pf()接受了一个隐藏的this指针参数,对于每个成员函数调用,编译器都会自动加上这个参数。同时,注意成员变量访问也许比看起来要代价高昂一 些,因为成员变量访问通过this指针进行,在有的继承层次下,this指针需要调整,所以访问的开销可能会比较大。然而,从另一方面来说,编译器通常会 把this指针缓存到寄存器中,所以,成员变量访问的代价不会比访问局部变量的效率更差。
译者注:访问局部变量,需要到SP寄存器中得到栈指针,再加上局部变量与栈顶的偏移。在没有虚基类的情况下,如果编译器把this指针缓存到了寄存器中,访问成员变量的过程将与访问局部变量的开销相似。

5.1 覆盖成员函数

和 成员变量一样,成员函数也会被继承。与成员变量不同的是,通过在派生类中重新定义基类函数,一个派生类可以覆盖,或者说替换掉基类的函数定义。覆盖是静态 (根据成员函数的静态类型在编译时决定)还是动态(通过对象指针在运行时动态决定),依赖于成员函数是否被声明为“虚函数”。

Q从P继承了成员变量和成员函数。Q声明了pf(),覆盖了P::pf()。Q还声明了pvf(),覆盖了P::pvf()虚函数。Q还声明了新的非虚成员函数qf(),以及新的虚成员函数qvf()。

struct Q : P {
   int q1;
   void pf(); // overrides P::pf
   void qf(); // new
   void pvf(); // overrides P::pvf
   virtual void qvf(); // new
};
对于非虚的成员函数来说,调用哪个成员函数是在编译时,根据“->”操作符左边指针表达式的类型静态决定的。特别地,即使ppq指向Q的实 例,ppq->pf()仍然调用的是P::pf(),因为ppq被声明为“P*”。(注意,“->”操作符左边的指针类型决定隐藏的this 参数的类型。)
P p; P* pp = &p; Q q; P* ppq = &q; Q* pq = &q;
pp->pf(); // pp->P::pf(); // P::pf(pp);
ppq->pf(); // ppq->P::pf(); // P::pf(ppq);
pq->pf(); // pq->Q::pf(); // Q::pf((P*)pq); (错误!)
pq->qf(); // pq->Q::qf(); // Q::qf(pq);
译者注:标记“错误”处,P*似应为Q*。因为pf非虚函数,而pq的类型为Q*,故应该调用到Q的pf函数上,从而该函数应该要求一个Q* const类型的this指针。

对于虚函数调用来说,调用哪个成员函数在运行时决定。不管“->”操作符左边的指针表达式的类型如何,调用的虚函数都是由指针实际指向的实例类型所决定。比如,尽管ppq的类型是P*,当ppq指向Q的实例时,调用的仍然是Q::pvf()。
pp->pvf(); // pp->P::pvf(); // P::pvf(pp);
ppq->pvf(); // ppq->Q::pvf(); // Q::pvf((Q*)ppq);
pq->pvf(); // pq->Q::pvf(); // Q::pvf((P*)pq); (错误!)
译者注:标记“错误”处,P*似应为Q*。因为pvf是虚函数,pq本来就是Q*,又指向Q的实例,从哪个方面来看都不应该是P*。

为了实现这种机制,引入了隐藏的vfptr成员变量。一个vfptr被加入到类中(如果类中没有的话),该vfptr指向类的虚函数表(vftable)。类中每个虚函数在该类的虚函数表中都占据一项。每项保存一个对于该类适用的虚函数的地址。因此,调用虚函数的过程如下:取得实例的vfptr;通过vfptr得到虚函数表的一项;通过虚函数表该项的函数地址间接调用虚函数。也就是说,在普通函数调用的参数传递、调用、返回指令开销外,虚函数调用还需要额外的开销。

回头再看看P和Q的内存布局,可以发现,VC++编译器把隐藏的vfptr成员变量放在P和Q实例的开始处。这就使虚函数的调用能够尽量快一些。实际上,VC++的实现方式是,保证任何有虚函数的类的第一项永远是vfptr。这就可能要求在实例布局时,在基类前插入新的vfptr,或者要求在多重继承时,虽然在右边,然而有vfptr的基类放到左边没有vfptr的基类的前面(如下)。

class CA

{   int a;};

class CB

{   int b;};

class CL : public CBpublic CA

{   int c;};

以上的类继承, 对CL类说, 他的内存布局是

int b;

int a;

int c;

但是, 改造CA如下:

class CA

{

   int a;

   virtual void setaint _a ) { a = _a; }

};

同样继承顺序的CL, 内存中布局是 

vfptr

int a;

int b;

int c;

CA被提到CB前面, 这样的布局是因为 class 的布局就是 vfptr肯定要放在最前面.

 

许多C++的实现会共享或者重用从基类继承来的vfptr。比如,Q并不会有一个额外的vfptr,指向一个专门存放新的虚函数qvf()的虚函数表。 Qvf项只是简单地追加到P的虚函数表的末尾。如此一来,单继承的代价就不算高昂。一旦一个实例有vfptr了,它就不需要更多的vfptr。新的派生类 可以引入更多的虚函数,这些新的虚函数只是简单地在已存在的,“每类一个”的虚函数表的末尾追加新项。

5.2 多重继承下的虚函数

如果从多个有虚函数的基类继承,一个实例就有可能包含多个vfptr。考虑如下的R和S类:

struct R {
   int r1;
   virtual void pvf(); // new
   virtual void rvf(); // new
};

struct S : P, R {
   int s1;
   void pvf(); // overrides P::pvf and R::pvf
   void rvf(); // overrides R::rvf
   void svf(); // new
};

这 里R是另一个包含虚函数的类。因为S从P和R多重继承,S的实例内嵌P和R的实例,以及S自身的数据成员S::s1。注意,在多重继承下,靠右的基类R, 其实例的地址和P与S不同。S::pvf覆盖了P::pvf()和R::pvf(),S::rvf()覆盖了R::rvf()。
S s; S* ps = &s;
((P*)ps)->pvf(); // (*(P*)ps)->P::vfptr[0])((S*)(P*)ps)
((R*)ps)->pvf(); // (*(R*)ps)->R::vfptr[0])((S*)(R*)ps)
ps->pvf();       // one of the above; calls S::pvf()
译者注:
 调用((P*)ps)->pvf()时,先到P的虚函数表中取出第一项,然后把ps转化为S*作为this指针传递进去;
 调用((R*)ps)->pvf()时,先到R的虚函数表中取出第一项,然后把ps转化为S*作为this指针传递进去;

因 为S::pvf()覆盖了P::pvf()和R::pvf(),在S的虚函数表中,相应的项也应该被覆盖。然而,我们很快注意到,不光可以用P*,还可以 用R*来调用pvf()。问题出现了:R的地址与P和S的地址不同。表达式(R*)ps与表达式(P*)ps指向类布局中不同的位置。因为函数 S::pvf希望获得一个S*作为隐藏的this指针参数,虚函数必须把R*转化为S*。因此,在S对R虚函数表的拷贝中,pvf函数对应的项,指向的是 一个“调整块”的地址,该调整块使用必要的计算,把R*转换为需要的S*。
译者注:这就是“thunk1: this-= sdPR; goto S::pvf”干的事。先根据P和R在S中的偏移,调整this为P*,也就是S*,然后跳转到相应的虚函数处执行。

在微软VC++实现中,对于有虚函数的多重继承,只有当派生类虚函数覆盖了多个基类的虚函数时,才使用调整块。

5.3 地址点与“逻辑this调整”

考虑下一个虚函数S::rvf(),该函数覆盖了R::rvf()。我们都知道S::rvf()必须有一个隐藏的S*类型的this参数。但是,因为也可以用R*来调用rvf(),也就是说,R的rvf虚函数槽可能以如下方式被用到:
((R*)ps)->rvf(); // (*((R*)ps)->R::vfptr[1])((R*)ps)
所以,大多数实现用另一个调整块将传递给rvf的R*转换为S*。还有一些实现在S的虚函数表末尾添加一个特别的虚函数项,该虚函数项提供方法,从而可以 直接调用ps->rvf(),而不用先转换R*。MSC++的实现不是这样,MSC++有意将S::rvf编译为接受一个指向S中嵌套的R实例,而 非指向S实例的指针(我们称这种行为是“给派生类的指针类型与该虚函数第一次被引入时接受的指针类型相同”)。所有这些在后台透明发生,对成员变量的存 取,成员函数的this指针,都进行“逻辑this调整”。

当然,在debugger中,必须对这种this调整进行补偿。
ps->rvf(); // ((R*)ps)->rvf(); // S::rvf((R*)ps)
译者注:调用rvf虚函数时,直接给入R*作为this指针。

所以,当覆盖非最左边的基类的虚函数时,MSC++一般不创建调整块,也不增加额外的虚函数项。

5.4 调整块

正 如已经描述的,有时需要调整块来调整this指针的值(this指针通常位于栈上返回地址之下,或者在寄存器中),在this指针上加或减去一个常量偏 移,再调用虚函数。某些实现(尤其是基于cfront的)并不使用调整块机制。它们在每个虚函数表项中增加额外的偏移数据。每当虚函数被调用时,该偏移数 据(通常为0),被加到对象的地址上,然后对象的地址再作为this指针传入。

ps->rvf();
// struct { void (*pfn)(void*); size_t disp; };
// (*ps->vfptr[i].pfn)(ps + ps->vfptr[i].disp);
译者注:当调用rvf虚函数时,前一句表示虚函数表每一项是一个结构,结构中包含偏移量;后一句表示调用第i个虚函数时,this指针使用保存在虚函数表中第i项的偏移量来进行调整。

这种方法的缺点是虚函数表增大了,虚函数的调用也更加复杂。

现代基于PC的实现一般采用“调整—跳转”技术:
S::pvf-adjust: // MSC++
this -= SdPR;
goto S::pvf()
当然,下面的代码序列更好(然而,当前没有任何实现采用该方法):
S::pvf-adjust:
this -= SdPR; // fall into S::pvf()
S::pvf() { ... }
译者注:IBM的C++编译器使用该方法。


5.5 虚继承下的虚函数

T 虚继承P,覆盖P的虚成员函数,声明了新的虚函数。如果采用在基类虚函数表末尾添加新项的方式,则访问虚函数总要求访问虚基类。在VC++中,为了避免获 取虚函数表时,转换到虚基类P的高昂代价,T中的新虚函数通过一个新的虚函数表获取,从而带来了一个新的虚函数表指针。该指针放在T实例的顶端。

struct T : virtual P {
   int t1;
   void pvf();         // overrides P::pvf
   virtual void tvf(); // new
};
void T::pvf() {
   ++p1; // ((P*)this)->p1++; // vbtable lookup!
   ++t1; // this->t1++;
}
如上所示,即使是在虚函数中,访问虚基类的成员变量也要通过获取虚基类表的偏移,实行计算来进行。这样做之所以必要,是因为虚函数可能被进一步继承的类所覆盖,而进一步继承的类的布局中,虚基类的位置变化了。下面就是这样的一个类:

struct U : T {
   int u1;
};

在此U增加了一个成员变量,从而改变了P的偏移。因为VC++实现中,T::pvf()接受的是嵌套在T中的P的指针,所以,需要提供一个调整块,把this指针调整到T::t1之后(该处即是P在T中的位置)。

5.6 特殊成员函数

本节讨论编译器合成到特殊成员函数中的隐藏代码。

5.6.1 构造函数和析构函数

正如我们所见,在构造和析构过程中,有时需要初始化一些隐藏的成员变量。最坏的情况下,一个构造函数要执行如下操作:

 * 如果是“最终派生类”,初始化vbptr成员变量,调用虚基类的构造函数;
 * 调用非虚基类的构造函数
 * 调用成员变量的构造函数
 * 初始化虚函数表成员变量
 * 执行构造函数体中,程序所定义的其他初始化代码

(注意:一个“最终派生类”的实例,一定不是嵌套在其他派生类实例中的基类实例)

所以,如果你有一个包含虚函数的很深的继承层次,即使该继承层次由单继承构成,对象的构造可能也需要很多针对虚函数表的初始化。
反之,析构函数必须按照与构造时严格相反的顺序来“肢解”一个对象。

 * 合成并初始化虚函数表成员变量
 * 执行析构函数体中,程序定义的其他析构代码
 * 调用成员变量的析构函数(按照相反的顺序)
 * 调用直接非虚基类的析构函数(按照相反的顺序)
 * 如果是“最终派生类”,调用虚基类的析构函数(按照相反顺序)

在 VC++中,有虚基类的类的构造函数接受一个隐藏的“最终派生类标志”,标示虚基类是否需要初始化。对于析构函数,VC++采用“分层析构模型”,代码中 加入一个隐藏的析构函数,该函数被用于析构包含虚基类的类(对于“最终派生类”实例而言);代码中再加入另一个析构函数,析构不包含虚基类的类。前一个析 构函数调用后一个。

5.6.2 虚析构函数与delete操作符

假如A是B的父类,
A* p = new B();
如果析构函数不是虚拟的,那么,你后面就必须这样才能安全的删除这个指针:
delete (B*)p;
但如果构造函数是虚拟的,就可以在运行时动态绑定到B类的析构函数,直接:
delete p;
就可以了。这就是虚析构函数的作用。

实际上,很多人这样总结:当且仅当类里包含至少一个虚函数的时候才去声明虚析构函数

考虑结构V和W。

struct V {
   virtual ~V();
};

struct W : V {
   operator delete();
};
析构函数可以为虚。一个类如果有虚析构函数的话,将会象有其他虚函数一样,拥有一个虚函数表指针,虚函数表中包含一项,其内容为指向对该类适用的虚析构函 数的地址。这些机制和普通虚函数相同。虚析构函数的特别之处在于:当类实例被销毁时,虚析构函数被隐含地调用。调用地(delete发生的地方)虽然不知 道销毁的动态类型,然而,要保证调用对该类型合适的delete操作符。例如,当pv指向W的实例时,当W::~W被调用之后,W实例将由W类的 delete操作符来销毁。
V* pv = new V;
delete pv;   // pv->~V::V(); // use ::operator delete()
pv = new W;
delete pv;   // pv->~W::W(); // use W::operator delete() 动态绑定到 W的析构函数,W默认的析构函数调用{delete this;}
pv = new W;
::delete pv; // pv->~W::W(); // use ::operator delete()
译者注:
 V没有定义delete操作符,delete时使用函数库的delete操作符;
 W定义了delete操作符,delete时使用自己的delete操作符;
 可以用全局范围标示符显示地调用函数库的delete操作符。

为 了实现上述语意,VC++扩展了其“分层析构模型”,从而自动创建另一个隐藏的析构帮助函数——“deleting析构函数”,然后,用该函数的地址来替 换虚函数表中“实际”虚析构函数的地址。析构帮助函数调用对该类合适的析构函数,然后为该类有选择性地调用合适的delete操作符。

6 数组

堆上分配空间的数组使虚析构函数进一步复杂化。问题变复杂的原因有两个:
1、 堆上分配空间的数组,由于数组可大可小,所以,数组大小值应该和数组一起保存。因此,堆上分配空间的数组会分配额外的空间来存储数组元素的个数;
2、 当数组被删除时,数组中每个元素都要被正确地释放,即使当数组大小不确定时也必须成功完成该操作。然而,派生类可能比基类占用更多的内存空间,从而使正确释放比较困难。
struct WW : W { int w1; };
pv = new W[m];
delete [] pv; // delete m W's (sizeof(W) == sizeof(V))
pv = new WW[n];
delete [] pv; // delete n WW's (sizeof(WW) > sizeof(V))
译者注:WW从W继承,增加了一个成员变量,因此,WW占用的内存空间比W大。然而,不管指针pv指向W的数组还是WW的数组,delete[]都必须正确地释放WW或W对象占用的内存空间。

虽 然从严格意义上来说,数组delete的多态行为C++标准并未定义,然而,微软有一些客户要求实现该行为。因此,在MSC++中,该行为是用另一个编译 器生成的虚析构帮助函数来完成。该函数被称为“向量delete析构函数”(因其针对特定的类定制,比如WW,所以,它能够遍历数组的每个元素,调用对每 个元素适用的析构函数)。

7 异常处理

简单说来,异常处理是C++标准委员会工作文件提供的一种机制,通过该机制,一个函数可以通知其调用者“异常”情况的发生,调用者则能据此选择合适的代码来处理异常。该机制在传统的“函数调用返回,检查错误状态代码”方法之外,给程序提供了另一种处理错误的手段。

因 为C++是面向对象的语言,很自然地,C++中用对象来表达异常状态。并且,使用何种异常处理也是基于“抛出的”异常对象的静态或动态类型来决定的。不光 如此,既然C++总是保证超出范围的对象能够被正确地销毁,异常实现也必须保证当控制从异常抛出点转换到异常“捕获”点时(栈展开),超出范围的对象能够 被自动、正确地销毁。
考虑如下例子:
struct X { X(); }; // exception object class
struct Z { Z(); ~Z(); }; // class with a destructor
extern void recover(const X&);
void f(int), g(int);

int main() {
   try {
      f(0);
   } catch (const X& rx) {
      recover(rx);
   }
   return 0;
}

void f(int i) {
   Z z1;
   g(i);
   Z z2;
   g(i-1);
}

void g(int j) {
   if (j < 0)
      throw X();
}
译者注:X是异常类,Z是带析构函数的工作类,recover是错误处理函数,f和g一起产生异常条件,g实际抛出异常。

这 段程序会抛出异常。在main中,加入了处理异常的try & catch框架,当调用f(0)时,f构造z1,调用g(0)后,再构造z2,再调用g(-1),此时g发现参数为负,抛出X异常对象。我们希望在某个调 用层次上,该异常能够得到处理。既然g和f都没有建立处理异常的框架,我们就只能希望main函数建立的异常处理框架能够处理X异常对象。实际上,确实如 此。当控制被转移到main中异常捕获点时,从g中的异常抛出点到main中的异常捕获点之间,该范围内的对象都必须被销毁。在本例中,z2和z1应该被 销毁。

谈到异常处理的具体实现方式,一般情况下,在抛出点和捕获点都使用“表”来表述能够捕获异常对象的类型; 并且,实现要保证能够在特定的捕获点真正捕获特定的异常对象;一般地,还要运用抛出的对象来初始化捕获语句的“实参”。通过合理地选择编码方案,可以保证 这些表格不会占用过多的内存空间。

异常处理的开销到底如何?让我们再考虑一下函数f。看起来f没有做异常处理。 f确实没有包含try,catch,或者是throw关键字,因此,我们会猜异常处理应该对f没有什么影响。错!编译器必须保证一旦z1被构造,而后续调 用的任何函数向f抛回了异常,异常又出了f的范围时,z1对象能被正确地销毁。同样,一旦z2被构造,编译器也必须保证后续抛出异常时,能够正确地销毁 z2和z1。

要实现这些“展开”语意,编译器必须在后台提供一种机制,该机制在调用者函数中,针对调用的函数抛 出的异常动态决定异常环境(处理点)。这可能包括在每个函数的准备工作和善后工作中增加额外的代码,在最糟糕的情况下,要针对每一套对象初始化的情况更新 状态变量。例如,上述例子中,z1应被销毁的异常环境当然与z2和z1都应该被销毁的异常环境不同,因此,不管是在构造z1后,还是继而在构造z2 后,VC++都要分别在状态变量中更新(存储)新的值。

所有这些表,函数调用的准备和善后工作,状态变量的更新,都会使异常处理功能造成可观的内存空间和运行速度开销。正如我们所见,即使在没有使用异常处理的函数中,该开销也会发生。

幸运的是,一些编译器可以提供编译选项,关闭异常处理机制。那些不需要异常处理机制的代码,就可以避免这些额外的开销了。

8 小结

好了,现在你可以写C++编译器了(开个玩笑)。
在本文中,我们讨论了许多重要的C++运行实现问题。我们发现,很多美妙的C++语言特性的开销很低,同时,其他一些美妙的特性(译者注:主要是和“虚” 字相关的东西)将造成较大的开销。C++很多实现机制都是在后台默默地为你工作。一般说来,单独看一段代码时,很难衡量这段代码造成的运行时开销,必须把 这段代码放到一个更大的环境中来考察,运行时开销问题才能得到比较明确的答案。

[计算机网络] 网络各层的协议和应用

[原创] 网络协议流量统计(一)

[概述]
网络协议流量统计要做的内容就是要把在网络上跑的数据分别是什么协议或者什么业务的统计出来,粗看之下类似于协议识别,不过实际做起来跟协议识别差距还是蛮大的, 跟协议封堵差距就更大了。

网络协议流量统计首先要猜测所要检测的网络里大概有些什么协议流量,然后针对这些协议逐个分析,讲分析出的协议挂到网络里先识别出一部分,然后再对剩下的未知流量进行进一步猜测。

这次要监控的是某市的网络,峰值大约有2G的流量。 由于是普通用户网络,占大部分流量的应当是P2P软件,然后是HTTP, FTP, 各个游戏等等, 其他客户比较关心的还有IM(MSN 和 QQ)。

于是就先从以上几个协议和业务着手。

[识别前提]
在本项目中我们假设任意两个IP之间是单一业务流量,也就是说这两个IP最先识别为什么协议,那就认为他以后的流量都是这个协议,断开时间设置为120S。 以后有时间会改为四元组识别,即通过IP和port四个信息来判断是否是同一业务。

[整个识别系统分为几个部分]
第一部分是端口识别,比如ftp的21 20端口,http的80端口,这里需要注意的一点是很多业务可能会走80隧道,这些流量是否算到http里面去,得考虑一下。

第二部分是净荷特征识别,目前QQ和MSN都是用的净荷特征,MSN的入口特征是UUM或者是MSG,报文特征是含有关键字MIME-VERSION, QQ的入口特征是0x02XXXX(XX是版本号,2008 2009不同,2008以前的没有分析),结尾特征0x03,这里还未解决的一点是QQ文件传输,需要花点时间。

第三部分是IP地址识别,这主要应用在游戏业务之上,因为游戏的数据其实都是跟服务器进行交互的,那么只要有服务器IP就肯定是游戏数据了,优势在于识别速度快,准确率极高,难点在于服务器IP的获取和维护,可能各地还不一样。

第四部分也是本系统最核心的部分,P2P业务的识别,P2P业务还分为p2p文件共享和p2p流媒体,分析方法还不一样。edonkey BT PPS等少数几个P2P存特征码,可以通过其来识别数据链路,从而获得流量数据,但大多数的P2P是不存在特征码的,尤其是占很大部分比例的迅雷、pplive等,他们甚至经常更改协议内容以是的别人难以寻找到固定特征。对于这类P2P我们采用的办法是建立用户行为模型,抓住这些P2P都是采用P2SP的模式,抓住其中的这个S,认为连接到S的P就是P2P用户,然后针对其连接特征具体分析。

[结语]
好了,整体框架就是如此,今天先整理到这里, 等下周用户行为模型搭建起来以后再做更进一步描述。

[原创] django学习整理

觉得还是需要整理一下思路, 最近这个状态不太好, 每天晚上回来磨蹭磨蹭时间就过去了, 感觉很难集中时间来一下吧django啃掉,那就每次记录一点的,或许会好一些。

简单地从onlypython项目开始,GAE的django其实不算是纯正的django, form、admin、db都是重新在django helper项目中重新实现过的,而GAE支持django则是因为django是符合WSGI标准的,简单地说就是GAE支持所有符合WSGI标准的python web框架,在GAE中使用django很好的一点在于GAE的运行环境中自带了django的库,最新的google appengine sdk貌似只支持django 1.0以上版本(未完全证实)。

WSGI,web组件的借口规范,http://wiki.woodpecker.org.cn/moin/WSGI 可以找到其官方文档描述的翻译版, 前面列举的几个资源也很值得一看, 只是一个规范,类似于JAVA中的servlet, 不过是用python做web必须要看的东西。

用符合WSGI标准的组件来搭建一个framwork也是一件非常简单的事情, http://bitworking.org/news/Why_so_many_Python_web_frameworks 只用了区区60行代码就用各种组件构建了一个简单的可运行python web框架, 而所谓的django,其实也就是这些组件的一个集合,所不同的是这些组件是django开发团队自己写的。

目前需要关心的:
django的内部实现暂时先不考虑, django 和 django helper确实是非常值得学习的代码, 略微看了点, 好好的复习了一下我日渐生疏的python语法。
那作为onlypython这个blog,我们所要关心的是什么呢? 从功能上来说,能发布日志和对日志有一个简单有效的管理是最切合实际的, 好,第一个要关心的 日志发布,日志管理。
那再从django使用角度来看, 每个目录下的init, urls, mode, view模块则是我们需要完成的。那第二个关心的内容就是这些模块如何来完成。

PS:事实上在使用过程中发现目前BLOG还是有挺多地方不进入人意的,例如这个文本编辑框,例如忘记添加删除文章和目录,例如界面还不是很人性化。。。等等等等。 这些都会在以后慢慢的改正并在这里记录下来。

[django] [转]Django 模板语言: 写给模板作者

作者:Django 团队
译者:weizhong2004@gmail.com
翻译开始日期:2006-04-06
翻译完成日期:2006-04-07
更新日期:2006-07-03
原文版本:3185

Django 的模板语言的设计原则在动力和易用性之间取得均衡.(功能要足够强大,还要容易使用), 如果你以前使用过 HTML,你会觉得很容易上手.如果有其它基于文本的模板语言的经验, 比如 SmartyCheetahTemplate, 你会觉得..使用django模板..就象在自己家里一样.

Templates

一个模板就是一个文本文件. 通过模板可以生成任意的基于文本的格式文件(HTML, XML, CSV, etc.).

一个模板包含 变量, 当模板被求值时,这些变量就被它们的值代替.而 标签 则控制着模板的逻辑.

下面是一个最小化的模板,它演示了某些基本概念. 其中的每个元素都会在本文档的后面部分被详细解释.:

{% extends "base_generic.html" %}

{% block title %}{{ section.title }}{% endblock %}

{% block content %}
<h1>{{ section.title }}</h1>

{% for story in story_list %}
<h2>
<a href="{{ story.get_absolute_url }}">
{{ story.headline|upper }}
</a>
</h2>
<p>{{ story.tease|truncatewords:"100" }}</p>
{% endfor %}
{% endblock %}

哲学

为什么使用基于文本的模板系统而不是基于 XML (类似 Zope 的 TAL)? 我们希望 Django 的模板语言能比那些 XML/HTML 模板更可用.在 World Online, 我们使用它处理 e-mails, JavaScript 和 CSV. 你能使用这种模板语言生成任何基于文本的格式. 哦,还有一个理由,那就是我们认为除非一个人有受虐趋向,否则谁也不愿意手工编辑 xml。

Variables

变量的形式: {{ variable }}. 当模板引擎遇到一个变量时,就会对变量求值,并在变量所在的位置用变量的值取代变量名,然后输出.

使用句点 (.) 可以访问变量的属性.

幕后

技术上,当模板系统遇到 句点, 它会按顺序尝试进依次查询:

  • Dictionary lookup
  • Attribute lookup
  • Method call
  • List-index lookup

在上面的例子中, {{ section.title }} 会被 section 对象的 title 属性替换.

如果你用到的一个变量不存在,模板系统会插入一个值:TEMPLATE_STRING_IF_INVALID ,这个值在 settings 中定义, 默认设置是一个空的字符串.

参见下面的 使用内建参考 , 这会帮助你发现给定模板中有哪些变量可用.

你可以使用 过滤器 来修改变量的显示.

过滤器

通过使用 过滤器 ,可以定制变量的显示格式。

过滤器的形式: {{ name|lower }}. 这将显示 {{ name }} 变量通过 lower 过滤后的值. 它将文本转换为小写. 使用管道符号 (|) 应用一个过滤器.

过滤器可以 "链接". 一个过滤器的输入作为下一个过滤器的输入: {{ text|escape|linebreaks }} 是一个常用过滤器组合,用于将文本内容转义然后将换行转换成 <p> 标签.

有些过滤器能接受参数. 一个带有参数的过滤器看起来这样: {{ bio|truncatewords:"30" }}. 它用来显示 bio 变量的前 30 个. 过滤器参数总是带有比引号. 下文中的 内建过滤器参考 描述了所有的内建过滤器.

标签

标签看起来这样: {% 标签 %}. 标签比起变量来复杂的多: 它负责在输出中创建一些文本,执行循环或逻辑分支, 装入额外信息以供后面的模板变量使用等等.

有些标签要求有开始标记和结束标记 (也就是 {% tag %} ... 标签内容 ... {% endtag %}). 下文中的 内建标签参考 描述了所有的内建标签.你也可以创建你自己的标签, 如果你会写 Python 代码的话.

模板继承

Django 模板引擎最强大的 -- 也是最复杂的 -- 部分是模板继承. 模板继承允许你建立一个基本的 "骨架" 模板, 它包含你所有最常用的站点元素并定义了一些可以被子模板覆盖的 .

通过下面的例子你很容易理解模板继承:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<link rel="stylesheet" href="style.css" />
<title>{% block title %}My amazing site{% endblock %}</title>
</head>

<body>
<div id="sidebar">
{% block sidebar %}
<ul>
<li><a href="/">Home</a></li>
<li><a href="/blog/">Blog</a></li>
</ul>
{% endblock %}
</div>

<div id="content">
{% block content %}{% endblock %}
</div>
</body>

我们称它为 base.html, 定义了一些简单的 HTML 骨架文档, 你可以把它用到一些简单两列的网页上. "子" 模板的任务就是用内容填写这些空白的内容块.

在这个例子里, {% block %} 标签定义了三个子模板要填写的 block . 所有的 block 标签告诉模板引擎,模板的这些部分可以被子模板覆盖.

一个子模板类似下面这样:

{% extends "base.html" %}

{% block title %}My amazing blog{% endblock %}

{% block content %}
{% for entry in blog_entries %}
<h2>{{ entry.title }}</h2>
<p>{{ entry.body }}</p>
{% endfor %}
{% endblock %}

这里的 {% extends %} 标签是最关键的. 它告诉模板引擎这个模板 "扩展" 了另一个模板. 当模板系统要应用该模板时,首先它会去寻找父模板--在这里是 "base.html" .

模板引擎会注意到在 base.html 里有三个 block 并用子模板的相关内容替换这些 block. 用 blog_entries 里的值填写父模板之后, 最后的输出可能看起来象这样:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<link rel="stylesheet" href="style.css" />
<title>My amazing blog</title>
</head>

<body>
<div id="sidebar">
<ul>
<li><a href="/">Home</a></li>
<li><a href="/blog/">Blog</a></li>
</ul>
</div>

<div id="content">
<h2>Entry one</h2>
<p>This is my first entry.</p>

<h2>Entry two</h2>
<p>This is my second entry.</p>
</div>
</body>

注意由于子模板并未定义 sidebar block, 父模板中的值就被保留.

对模板的继承层数,Django未做任何限制. 常用的一种模板继承方法是如下的三层:

* 创建一个 ``base.html`` 模板,用它表现站点主要的外观。

* 为站点的每个 section 创建一个 ``base_SECTIONNAME.html`` 模板。比如
``base_news.html``,``base_sport.html``等等, 这些模板扩充了 ``base.html``
并包括 section 特有的样式和设计。

* 为每种类型的页面创建一个独立的模板,比如一篇新闻稿或者一个博客,这些模板扩展了相应的
section 模板。

这种方式能够最大程度的重用代码并能很容易的扩充内容及共享内容区块,比如 section-范围的
导航。

下面是使用模板继承的一些小技巧:

* 如果你在模板中使用了 ``{% extends %}`` ,那么它必须是这个模板中的第一个模板 tag,
否则它就不工作。

* 在父模板中 ``{% block %}`` 标签虽然不是越多越好,总得来说多比少好. 记住,子模板不
需要定义所有的 parent block, 因此你可以先定义一系列 blocks 并填入合理的默认值, 然
后定义那些你以后才需要的 block. It's better to have more hooks than fewer hooks.

* 如果发现在一堆模板文件中重复定义相同的内容, 就意味着需要将这些内容放到父模板的一个
``{% block %}`` 中去.

* 如果你需要在子模板中引用父模板中的 block 的内容,使用 ``{{ block.super }}``
变量. 这在你希望在父模板的内容之后添加一些内容时会很有用.(你不必完全覆盖父模板的内容.)

最后, 提醒你不能在一个模板文件中定义多个相同名字的 {% block %} 标签.

使用内建参考

Django 自带的 admin site 内建一个当前站点的所有模板标签及过滤器的参考. 要查阅这个参考, 进入 admin 站点,然后点击页面右上角的 "Documentation" 链接(如果你的语言选择的是中文,你会看到一个 "文档" 链接)..

这个参考分为四大部分:tags, filters, models, 和 views.

tagsfilters 部分描述了所有的内建标签(事实上, 下文中的标签和过滤器 参考直接来自那些页面)和所有自定义标签或过滤器 库(如果有的话).

views 页是最有价值的.你站点中的每个 URL 都有一个入口在这儿, 点击这个 URL 你会看到:

  • 生成该页面的 view 函数的名字
  • 该 view 功能的一个简短的描述.
  • 该 view 的 context, 或者该 view 对应模板中的可用变量列表
  • 模板的名字,或该模板使用到的模板名字

每个 view 文档页还有一个 bookmarklet , 使用它你可以任意页跳回到这个 view 页.

由于 Django 站点通常会用到数据库对象, 文档页的 models 小节描述了系统中每个对象的类型及那个对象的所有可用字段.

总得来说, 文档页会告诉你给定模板的每个标签, 每个过滤器,每个变量和对象的细节信息.

自定义标签及过滤器库

某些应用提供自定义标签和过滤器库. 要在一个模板中访问它们, 使用 {% load %} 标签:

{% load comments %}

{% comment_form for blogs.entries entry.id with is_public yes %}

在上面这个例子里, load 标签载入 comments 标签库, 之后 comment_form 标签才能使用. 参考你的 admin 界面的文档部分你会发现一个自定义库的列表. {% load %} 标签可接受空隔分隔的多个库的名字作为参数. 比如:

{% load comments i18n %}

自定义库及模板继承

当你载入一个自定义标签或过滤器库, 只有当前模板可以使用这些标签/过滤器 -- 继承链中不论是父模板还是子模板都不能使用使用这些标签和过滤器.

举例来说, 如果一个模板 foo.html 内有 {% load comments %} 指令, 一个子模板(也就是一个模板内有 {% extends "foo.html" %} 指令将 不能 访问 comments 模板标签和过滤器. 子模板必须自己负责 {% load comments %} 才可以使用这个库.

这是为了模板逻辑的清晰性和可维护性有意而为的一个特性.

内建标签和过滤器参考

下面的标签和过滤器参考就是为那些没有 admin 站点的可用的人准备的.由于 Django 是高度可定制的,你的 admin 里的关于标签和过滤器的参考可以认为是最可信的.

内建标签参考

block

定义一个能被子模板覆盖的 块. 参阅 模板继承 了解更多信息

comment

注释.模板引擎会忽略掉 {% comment %}{% endcomment %} 之间的所有内容.

cycle

在循环时轮流使用给定的字符串列表中的值.

在一个循环中, 在循环过程中的每次循环里轮流使用给定的字符串列表元素:

{% for o in some_list %}
<tr class="{% cycle row1,row2 %}">
...
</tr>
{% endfor %}

在循环之外, 在你第一次调用它时给这些字符串值定义一个不重复的名字,然后在循环中使用这个名字:

<tr class="{% cycle row1,row2,row3 as rowcolors %}">...</tr>
<tr class="{% cycle rowcolors %}">...</tr>
<tr class="{% cycle rowcolors %}">...</tr>

你可以使用任意数量的逗号分隔的值.只有一点请你注意,不要在值与值之间放任何空隔--仅仅只有一个逗号即可.

debug

输出完整的调试信息,包括当前的上下文及导入的模块信息.

extends

当前模板 扩展 父模板的一个信号(标记).

这个标签有两种使用方式: {% extends "base.html" %} (带双引号) 使用 "base" 作为要扩展的父模板的名字.或者 {% extends variable %} 使用 variable 的值作为要扩展的父模板的名字.

参阅 模板继承 以了解更多信息.

filter

用来过滤变量的值.

允许多级过滤, 并且他们可以带有参数运行 -- just like in variable syntax.

示例:

{% filter escape|lower %}
文本将被 HTML-转义, 并且全部转化为小写
{% end过滤器 %}

firstof

输出传递给它的第一个不是 False 的变量值. 如果所有的变量都是 False 那就不输出任何东西.

示例:

{% firstof var1 var2 var3 %}

它等价于:

{% if var1 %}
{{ var1 }}
{% else %}{% if var2 %}
{{ var2 }}
{% else %}{% if var3 %}
{{ var3 }}
{% endif %}{% endif %}{% endif %}

for

循环. 比如要显示一个 athlete_list 中的全部运动员:

<ul>
{% for athlete in athlete_list %}
<li>{{ athlete.name }}</li>
{% endfor %}
</ul>

通过使用 {% for obj in list reversed %} 你也可以实现反序循环.

在循环过程中 for 循环会设置以下的一系列变量:

Variable Description
forloop.counter 当前循环次数 (1-indexed)
forloop.counter0 当前循环次数 (0-indexed)
forloop.revcounter 倒序循环时当前循环次数(1-indexed)
forloop.revcounter0 倒序循环时当前循环次数(0-indexed)
forloop.first 如果当前循环是循环过程的第一次则为True
forloop.last 如果当前循环是循环过程的最后一次则为True
forloop.parentloop 对嵌套循环, 当前循环之上的循环

if

{% if %} 标签对一个变量求值, 若这个变量为 "true" , 就输出 if 内容块:

{% if athlete_list %}
Number of athletes: {{ athlete_list|length }}
{% else %}
No athletes.
{% endif %}

在上例中, 如果 athlete_list 非空, 运动员人数就会通过 {{ athlete_list|length }}
变量显示出来.

就象你刚刚看到的, if 标签可以带一个 {% else %} 子句,用来当 if 测试失败后输出相应的内
容块.

if``标签可以使用 ``and,``or`` 或 not 来测试一系列变量或否定一个给定的变量:

{% if athlete_list and coach_list %}
Both athletes and coaches are available.
{% endif %}

{% if not athlete_list %}
There are no athletes.
{% endif %}

{% if athlete_list or coach_list %}
There are some athletes or some coaches.
{% endif %}

{% if not athlete_list or coach_list %}
There are no athletes or there are some coaches (OK, so
writing English translations of boolean logic sounds
stupid; it's not our fault).
{% endif %}

{% if athlete_list and not coach_list %}
There are some athletes and absolutely no coaches.
{% endif %}

为避免造成歧义, if``标签不允许在一个 tag 中同时有 ``andor 逻辑; 举个例子,下面这个语句不能工作:

{% if athlete_list and coach_list or other_list %}

如果确实需要组合条件,可以使用嵌套的 if 实现相同的功能:

{% if athlete_list %}
{% if coach_list or other_list %}
We have athletes and , either coaches or others.
{% endif %}
{% endif %}

ifchanged

检查一个变量自上次循环之后是否发生了改变.(我的理解:主要用于过滤掉重复的值)

'ifchanged' block标签用于循环中. 它根据自身上次的状态检查自己值, 只有值发生变化时才显示这个值:

<h1>Archive for {{ year }}</h1>

{% for day in days %}
{% ifchanged %}<h3>{{ day|date:"F" }}</h3>{% endifchanged %}
<a href="{{ day|date:"M/d"|lower }}/">{{ day|date:"j" }}</a>
{% endfor %}

ifequal

若两个参数相等,输出一个内容块.

例子:

{% ifequal user.id comment.user_id %}
...
{% endifequal %}

如同 {% if %} tag, 它也支持一个可选的 {% else %} 子句.

参数可以是变量,也可以是字符串字面值, 也就是说下面这样也是合法的:

{% ifequal user.username "adrian" %}
...
{% endifequal %}

ifnotequal

类似 ifequal, 只是它用来测试两个参数是否不等.

include

载入一个模板并根据当前上下文渲染它.用于在一个模板中包含其它模板.

模板名字可以是一个变量,也可以是一个字符串(带引号的字符串,无所谓单引号还是双引号).

下面这个例子包含了 "foo/bar.html" 模板的内容:

{% include "foo/bar.html" %}

下面这个例子包含了另一个模板(该模板的名字为变量 template_name 的值)的内容:

{% include template_name %}

被包含的模板使用包含它的模板的上下文(也就是环境)进行渲染(求值),下面这个例子输出 "Hello, John":

  • Context: variable person is set to "john".

  • Template:

    {% include "name_snippet.html" %}
  • The name_snippet.html template:

    Hello, {{ person }}

参阅: {% ssi %}.

load

装入一个自定义模板标签集.

参阅 自定义标签及过滤器库 以了解更多信息.

now

显示当前日期, 根据给定的字符串决定输出格式.

使用和 PHP 的 date() 函数一样的格式码 (http://php.net/date) 并做了一些扩展

可用的格式字符串:

格式字符 描述 输出示例
a 'a.m.''p.m.' (注意,它与PHP 的输出略有不同.它包括了句点(django扩展). 'a.m.'
A 'AM''PM'. 'AM'
B 未实现.  
d 每月第几天, 带前导零 '01' to '31'
D 每周第几天,3字母的字符串. 'Fri'
f 时间, 12-小时制的小时和分钟数, 如果分钟数为零,则不显示.(django 扩展). '1', '1:30'
F 月份, 长文本格式. 'January'
g 小时, 12-小时制,没有前导零 '1' to '12'
G 小时, 24-小时制,没有前导零 '0' to '23'
h 小时, 12-小时制,有前导零 '01' to '12'
H 小时, 24-小时制,有前导零 '00' to '23'
i 分钟. '00' to '59'
I 未实现  
j 每月第几天, 无前导零 '1' to '31'
l 每周第几天,长文本格式. 'Friday'
L 是否闰年. True or False
m 数字表示的月份,有前导零. '01' to '12'
M 月份,3字母短文本格式. 'Jan'
n 数字表示的月份,无前导零 '1' to '12'
N 出版风格的月份缩写(django 扩展) 'Jan.', 'Feb.', 'March', 'May'
O 与格林威治的时间差(以小时计) '+0200'
P 12小时制的小时分钟及'a.m.'/'p.m.' 分钟数若为零则不显示. 用字符串表示特殊 的时间点, 如 'midnight' 和 'noon' (django扩展) '1 a.m.', '1:30 p.m.', 'midnight', 'noon', '12:30 p.m.'
r RFC 822 格式的日期 . 'Thu, 21 Dec 2000 16:01:07 +0200'
s 秒数, 带有前导零的数字表示 '00' to '59'
S 英语序数后缀,用于一个月的第几天,2个字符 'st', 'nd', 'rd' or 'th'
t 给定月共有多少天. 28 to 31
T 本机时区. 'EST', 'MDT'
U 未实现  
w 一周中的第几天,没有前导零的数字 '0' (Sunday) to '6' (Saturday)
W ISO-8601 一年的第多少星期数, 一周从 星期一开始 1, 23
y Year, 2 位数字表示 '99'
Y Year, 4 位数字表示 '1999'
z 一年中的第几天 . 0 to 365
Z 以秒计的时区偏移量. 这个偏移量对UTC西部 时区总是负数,而对UTC东部时区则总是正数 -43200 to 43200

例子:

It is {% now "jS F Y H:i" %}

注意你可以使用反斜线转义一个格式字符串中的敏感字符.(如果你想使用其原始值的话).在下面这个例子里, "f" 被用反斜线转义, 因为 "f" 本身是一个用于显示时间的格式字符. "o" 不需要被转义,因为它不是一个格式字符.:

It is the {% now "jS o\f F" %}

(显示 "It is the 4th of September" %}

regroup

Regroup a list of alike objects by a common attribute.

要搞懂这个复杂的标签, 最好还是用一个例子来说明(一幅图胜过千句话): 有一个 people 对象,它是一个 Person 对象(拥有 first_name, last_namegender 属性)的列表. 你想显示一个象下面这样的列表:

  • Male:
    • George Bush
    • Bill Clinton
  • Female:
    • Margaret Thatcher
    • Condoleezza Rice
  • Unknown:
    • Pat Smith

下面的模板代码片断可以完成这个看上去复杂的任务:

{% regroup people by gender as grouped %}
<ul>
{% for group in grouped %}
<li>{{ group.grouper }}
<ul>
{% for item in group.list %}
<li>{{ item }}</li>
{% endfor %}
</ul>
{% endfor %}
</ul>

如同你看到的, {% regroup %} 生成一个变量包含一个对象的列表. 列表中的每个对象都拥有 grouperlist 属性. grouper 装有分组的条目; list 包含一系列拥有共同 grouper 属性的对象. 在这个例子里, grouper 可能是 Male, FemaleUnknown, 而 list 则是属于这几种性别的人的列表.

注意当这个被分组的列表没有按你要分组的键排序时, {% regroup %} 将不能工作! 这就是说你的 people 列表如果没有按 gender 排序, 你就必须得保证在使用它之前先将它排好序,也就是:

{% regroup people|dictsort:"gender" by gender as grouped %}

spaceless

将HTML标签之间的空白格式化为一个空格. 空白包括空格,换行,制表符.

示例:

{% spaceless %}
<p>
<a href="foo/">Foo</a>
</p>
{% endspaceless %}

这个例子将返回这样的HTML:

<p> <a href="foo/">Foo</a> </p>

只有 标签 之间的空白被处理 -- 标签与文本之间的空白不会被处理.在下面这个例子里, Hello 周围的空白不会被缩小:

{% spaceless %}
<strong>
Hello
</strong>
{% endspaceless %}

ssi

在页面中输出给定文件的内容.

类似一个简单的 "include" 标签, {% ssi %} 包含另一个文件的内容 -- 不过必须在当前页面指定一个绝对路径

{% ssi /home/html/ljworld.com/includes/right_generic.html %}

如果提供了可选的 "parsed" 参数, 被包含文件的内容会使用当前的上下文作为模板代码进行求值处理.:

{% ssi /home/html/ljworld.com/includes/right_generic.html parsed %}

注意如何你使用 {% ssi %}, 出于安全考虑, 你需要在你的 Django settings 文件中定义 ALLOWED_INCLUDE_ROOTS .

参阅: {% include %}.

templatetag

输出一个组成模板标签的字符.

由于模板系统没有 "转义" 的概念, 要显示一个组成模板标签的字符, 你必须使用 {% templatetag %} 标签.

用参数告诉标签输出哪些内容:

参数 输出
openblock {%
closeblock %}
openvariable {{
closevariable }}
openbrace {
closebrace }

widthratio

要创建柱形图的话, 这个标签计算给定值与最大值的比率再乘以100,四舍五入为整数,最后输出这个整数.

例子:

<img src="bar.gif" height="10" width="{% widthratio this_value max_value 100 %}" />

上例中, 如果 this_value 是 175 而 max_value 是 200, 则上例中的图片应该是 88 像素宽 (因为 175/200 = .875; .875 * 100 = 87.5 四舍五入为 88).

内建过滤器参考

add

返回参数与被处理数据相加的结果.

addslashes

给敏感字符添加斜线(转义). 举例,要将一个字符串传递给 JavaScript 时..

capfirst

大写被处理数据的第一个字母.

center

按给定宽度将待处理数据居中.

cut

将待处理数据中的所有子串删除(该子串等于 cut 的参数)

date

根据给定的格式(与 now 标签相同)格式化一个日期.

default

如果值不可用,使用提供的默认值.

default_if_none

如果值为 None, 使用这个给定的默认值.

dictsort

接受一个字典列表,返回按给定参数的属性排序后的列表.

dictsortreversed

接受一个字典列表,返回按给定参数的属性逆序排序后的列表.

divisibleby

如果值可以被参数除尽,则返回 True.

escape

对一个字符串的敏感字符进入转义(以用于HTML). 特别是它会做如下替换:

  • "&" to "&amp;"
  • < to "&lt;"
  • > to "&gt;"
  • '"' (double quote) to '&quot;'
  • "'" (single quote) to '&#39;'

filesizeformat

将值格式化为 '可读性好的' 文件大小(比如 '13 KB', '4.1 MB', '102bytes' 等等).

first

返回列表中的第一个元素.

fix_ampersands

& 符号替换为 &amp; 实体.

floatformat

将一个浮点数四舍五入到小数点后1位 -- 如果根本没有小数,小数部分不会显示.例如:

  • 36.123 被转换成 36.1
  • 36.15 被转换成 36.2
  • 36 被转换成 36

get_digit

提供一个完整的数, 返回该数中被请求的数字,其中 1 是最右边的数, 2 是从右边数第二个数字等等. 若输入值非法(若输入或参数不是整数, 或者参数小于1)则返回其原始值. 否则输出就总是整数.

join

用一个字符串将一个列表连接起来, 类似 Python 的 str.join(list).

length

返回值的长度. 对列表特别有用.

length_is

若值的长度与参数相等,返回 True, 否则返回 False.

linebreaks

将换行符转化为 <p> 和 <br />.

linebreaksbr

将换行符转化为 <br />.

linenumbers

带行号显示文本.

ljust

在给定宽度的域内将文本左对齐.

参数: 域宽度

lower

将字符串转化为小写.

make_list

将值转化为一个列表.对一个整数,它是一个数字的列表.对一个字符串,这是一个字符的列表.

phone2numeric

将一个电话号码(可能包含字母)转化等价的数字值.比如: '800-COLLECT' 将被转化为 '800-2655328'.

输入不一定非是一个合法号码. 它可以转化任意字符串.

pluralize

如果值不是 1 的话返回 's' 用于 '1 vote' vs. '2 votes' 这种场合. 例如:

you have {{number_messages}} mail{{number_messages|pluralize}}.
(对中国人用处不大,嘿嘿)

pprint

pprint.pprint 和一个封装器-- 仅用于调试.

random

返回随机的从列表中返回一个元素

removetags

从输出中删除单空格分隔的 [X]HTML标签 列表

rjust

在给定宽度的域内将文本右对齐.

参数: 域大小

slice

返回一个列表的片段.

使用与 Python 的 list 相同的语法, 参阅 http://diveintopython.org/native_data_types/lists.html#odbchelper.list.slice 以了解更详细的信息.

示例: {{ some_list|slice:":2" }}

slugify

转化为小写, 移去非单词字符(字母数字和下划线),将空白转化为连字符,去除前后空白.

stringformat

根据给定参数(一个格式字符串)格式化一个变量, 这个格式字符串使用 Python 字符串格式化语法, 例外之处是 "%" 运算符被省略.

参阅 http://docs.python.org/lib/typesseq-strings.html 以了解 Python 格式字符串

striptags

过滤掉[X]HTML标签.

time

根据给定的格式, 格式化一个时间(与 now 标签使用的格式相同).

timesince

格式化一个日期,这个日期是从给定日期到现在的天数和小时数(比如: "4 days, 6 hours").

接受一个可选的参数,该参数是一个包含比较日期的变量(该参数默认值是 now). 举例来说, 如果 blog_date 是一个日期实例表示 2006-06-01 午夜, 而 comment_date 是一个日期实例表示 2006-06-01 早上8点,那么 {{ comment_date|timesince:blog_date }} 将返回 "8 hours".

timeuntil

类似 timesince, 只是它比较当前时间直到给定日期时间。举例来说,如果今天是 2006-06-01 而 conference_date 是 2006-06-29, 那么 {{ conference_date|timeuntil }} 将返回 "28 days".

接受一个可选的参数,该参数是一个包含比较日期的变量(该参数默认值是 now). 举例来说, 如果 from_date 是一个日期实例表示 2006-06-22, 那么 {{ conference_date|timeuntil:from_date }} 会返回 "7 days".

title

按标题格式转化一个字符串

truncatewords

将一个字符串截短为指定数目的单词.

参数: 要保留的单词数

unordered_list

递归的接受一个自嵌套的列表并返回一个HTML无序列表(此列表可不是pythob语义中的列表) -- 只是没有开始和结束的<ul>标签.

假定该列表是合适的格式. 举例来说, 如果 var 的值为 ['States', [['Kansas', [['Lawrence', []], ['Topeka', []]]], ['Illinois', []]]], 那么 {{ var|unordered_list }} 就会返回:

<li>States
<ul>
<li>Kansas
<ul>
<li>Lawrence</li>
<li>Topeka</li>
</ul>
</li>
<li>Illinois</li>
</ul>
</li>

upper

将一个字符串全部转为大写.

urlencode

转义该值以用于 URL.

urlize

将普通文本的 URL 转化为可点击的链接.

urlizetrunc

将 URL 转化为一个可点击的链接, 根据给定的字符数截短 URL.

参数: URL长度

wordcount

返回单词数

wordwrap

在指定行长将文字折行.

参数: 行长(以字符计)

yesno

提供一个字符串参数对应着 true, false 和 (可选的) None, 根据被处理的值返回相应的字符串:

Value Argument Outputs
True "yeah,no,maybe" yeah
False "yeah,no,maybe" no
None "yeah,no,maybe" maybe
None "yeah,no" "no" (如果没有对应 None 的字符 串,就将 None 转化为 False 处理

其它 tags 和 filter 库

Django 自带了几个其它的模板 tag 库,要使用这些 tag 库,必须显式的在 INSTALLED_APPS 设置中启用他们,然后在模板中使用 {% load %} tag 载入他们.

django.contrib.humanize

一堆 Django 模板过滤器,用于生成易读的数据,参阅 humanize documentation.

django.contrib.markup

一堆模板过滤器,支持以下常见标记语言::

  • Textile
  • Markdown
  • ReST (ReStructured Text)
1
feedsky
抓虾
pageflakes
google reader
bloglines
鲜果
哪吒
有道