1. 我们在模板中引用外部的js文件，由于没有模板引擎的解析，trans标签就不起作用了。

2. 而django提供了在js文件中调用gettext等函数的方法，前提是需要做配置。

3. 在urls(全局)中加入：

1 js_info_dict = {
2     'packages': ('report.jscripti18n',),
3 }
4 
5 urlpatterns += patterns('',
6     url(r'^jsi18n/$', 'django.views.i18n.javascript_catalog', js_info_dict),
7 )

说明：

(1). 此处report.jscripti18n表示在report目录下新建jscripti18n目录，其中report和jscripti18n目录下都要有个__init__.py文件，保证可以被import到。

(2). report/jscripti18n目录可以留空，不用任何文件？

(3). 将report.jscripti18n安装到INSTALLED_APPS中。

(4). 而^jsi18n/$表示：如果在需要引用外部js文件的网页中引用<script src="/jsi18n"></script>，表示加载由django提供的“JS文件解析函数”，即gettext等函数。

4. 而原先从其他目录引入的js文件位置，不用做任何更改，注意：<script src="/jsi18n"></script>只是引入由django提供的js解析库，而且这句话应该放到所有需要翻译的JS文件之前。

表现为一些JS函数：

 1 /* gettext library */
 2 
 3 var catalog = new Array();
 4 
 5 function pluralidx(count) { return (count == 1) ? 0 : 1; }
 6 
 7 
 8 function gettext(msgid) {
 9   var value = catalog[msgid];
10   if (typeof(value) == 'undefined') {
11     return msgid;
12   } else {
13     return (typeof(value) == 'string') ? value : value[0];
14   }
15 }
16 
17 function ngettext(singular, plural, count) {
18   value = catalog[singular];
19   if (typeof(value) == 'undefined') {
20     return (count == 1) ? singular : plural;
21   } else {
22     return value[pluralidx(count)];
23   }
24 }
25 
26 function gettext_noop(msgid) { return msgid; }
27 
28 function pgettext(context, msgid) {
29   var value = gettext(context + '' + msgid);
30   if (value.indexOf('') != -1) {
31     value = msgid;
32   }
33   return value;
34 }
35 
36 function npgettext(context, singular, plural, count) {
37   var value = ngettext(context + '' + singular, context + '' + plural, count);
38   if (value.indexOf('') != -1) {
39     value = ngettext(singular, plural, count);
40   }
41   return value;
42 }
43 
44 function interpolate(fmt, obj, named) {
45   if (named) {
46     return fmt.replace(/%\(\w+\)s/g, function(match){return String(obj[match.slice(2,-2)])});
47   } else {
48     return fmt.replace(/%s/g, function(match){return String(obj.shift())});
49   }
50 }
51 
52 /* formatting library */
53 
54 var formats = new Array();
55 
56 formats['DATETIME_FORMAT'] = 'Y-m-d H:i:s';
57 formats['DATE_FORMAT'] = 'N j, Y';
58 formats['DECIMAL_SEPARATOR'] = '.';
59 formats['MONTH_DAY_FORMAT'] = 'F j';
60 formats['NUMBER_GROUPING'] = '0';
61 formats['TIME_FORMAT'] = 'P';
62 formats['FIRST_DAY_OF_WEEK'] = '0';
63 formats['TIME_INPUT_FORMATS'] = ['%H:%M:%S', '%H:%M'];
64 formats['THOUSAND_SEPARATOR'] = ',';
65 formats['DATE_INPUT_FORMATS'] = ['%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', '%b %d %Y', '%b %d, %Y', '%d %b %Y', '%d %b, %Y', '%B %d %Y', '%B %d, %Y', '%d %B %Y', '%d %B, %Y'];
66 formats['YEAR_MONTH_FORMAT'] = 'F Y';
67 formats['SHORT_DATE_FORMAT'] = 'm/d/Y';
68 formats['SHORT_DATETIME_FORMAT'] = 'm/d/Y P';
69 formats['DATETIME_INPUT_FORMATS'] = ['%Y-%m-%d %H:%M:%S', '%Y-%m-%d %H:%M:%S.%f', '%Y-%m-%d %H:%M', '%Y-%m-%d', '%m/%d/%Y %H:%M:%S', '%m/%d/%Y %H:%M:%S.%f', '%m/%d/%Y %H:%M', '%m/%d/%Y', '%m/%d/%y %H:%M:%S', '%m/%d/%y %H:%M:%S.%f', '%m/%d/%y %H:%M', '%m/%d/%y'];
70 
71 function get_format(format_type) {
72     var value = formats[format_type];
73     if (typeof(value) == 'undefined') {
74       return msgid;
75     } else {
76       return value;
77     }
78 }

5. 在js中使用的方法是：

1 $("#tbody").append(gettext('No Item Selected!'));

6. 创建翻译文件

(1). 首先需要在report.jscripti18n目录下创建locale目录，复制需要翻译的js文件到report/jscripti18n目录下（此步不可缺少），以为django不会到project主目录寻找js文件。

(2). 在report/jscripti18n目录下使用命令：django-admin makemessages -l zh_CN -d djangojs；

(3). 在report/jscripti18n/locale/zh_CN/LC_MESSAGES/目录下生成了djangojs.po文件，然后翻译它，可以使用工具或手工翻译；

(4). 编译po文件：django-admin compilemessages

7. 使用firebug可以看到浏览器的请求 GET /jsi18n/ 返回的内容中包含了翻译好的内容：

1 catalog['No Item Selected!'] = '\u672a\u9009\u62e9\u9879\u76ee!';

1. 引子
嗯，为什么要谈Mixin啊？
因为出现了Mixin这样一个东西呀，就像C++社区很多人谈论template一样啊，Python社区也很多会谈论Mixin的（以后会的，嘻嘻），所以我就来凑凑热闹了。

嗯，为什么要Mixin呀？
这个，基本上已经是我这篇文章里要讲的东西了，所以，我会用本文的大部分篇幅来回答你这个超有深度的问题。现在，就开始吧～

小时候，我家开百货店，当然，也兼营水果蔬菜啊。

小时候的事，总是特别有趣，也特别的有意义，所以今天我们就以水果店开始吧～

记得，以前很多人买水果的时候，都会问我妈一个问题，就是价格了啦～但还有两个问题也经常问到哦，就是送人应该买什么水果和什么水果可以用来送人？

嗯，年青人大多都不懂这些礼节。送水果也是很讲兆头的，比如梨和香蕉一般不用来送人，因为它们意味着离别和焦躁哦；而苹果和桔子就很受欢迎，因为它们意味着平安和吉利哦～


1.1. 以此为开始
那，这跟Python有什么关系吗？
当然有啦，不然我扯那么多皮干嘛咧？现在，国产凌凌漆接到一个任务，要求他为一个水果连锁店开发一套软件；显然这个不关心国计民生这些鸡毛蒜皮的小事的武夫是搞不定这项艰巨任务的了，他就找到了你。

通过调研，客户发现两件事实：一是现在的年青人还是不懂送人应该买什么水果和什么水果可以用来送人这两个问题；二是水果连锁店的营业员100％都是年青人，他们中大部分人也不懂。

所以，客户要求在软件中必须提供一个这样的功能－－可以查询一种水果是否适宜送人。


1.1.1. 最初
最初，你可能这样设计：

class Fruit(object):
pass
把fruit类作为一切水果的基类，嗯，这相当明智。代码中去除了一些无需关注的代码，如价格、产地等。
现在你打算实现最受顾客欢迎的苹果：

切换行号显示
   1 class Apple(Fruit):
   2  def is_gift_fruit(self):
   3   return True
同样的，我又去除了一些无需关注的代码，并且打算在接下来的行文中不再提醒这一点。
Apple是一种Fruit。所以上面的实现挺符合OO的原则。
接下来让我们实现梨子吧：

切换行号显示
   1 class Pear(Fruit):
   2  def is_gift_fruit(self):
   3   return False
解决问题了。如果水果连锁店只卖苹果和梨子两种水果的话。
可惜，需求很多，你还要实现桔子和香蕉呢。你写下了这几行代码：

切换行号显示
   1 class Orange(Fruit):
   2  def is_gift_fruit(self):
   3   return True
   4 class Banana(Fruit):
   5  def is_gift_fruit(self):
   6   return False
好臭啊，代码的坏味道！

类Apple和类Orange除了类名不同，几乎是完全重复的代码；类Pear和类Banana也是一样。 更进一层的说，这四个类都差不多啊，所以我们有必要重构一下已有代码，改善它们的设计。


1.1.2. 改善已有代码
阅读代码，你可以发现水果只分两类：一类是可以作为礼品的，一类是不可以的。所以希望可以这样设计：

  Fruit
  / \
GiftFruit NotGiftFruit
/ \ / \
Apple    Orange Pear Banana
嗯，加了两个中间类，看起来不错：

切换行号显示
   1 class GiftFruit(Fruit):
   2  def is_gift_fruit(self):
   3   return True
   4 class NotGiftFruit(Fruit):
   5  def is_gift_fruit(self):
   6   return False
   7 class Apple(GiftFruit):pass
   8 class Orange(GiftFruit):pass
   9 class Pear(NotGiftFruit):pass
  10 class Banana(NotGiftFruit):pass
好啦，看上去很不错哦，代码精简了不少，任务完成～


1.1.3. 新的烦恼
接下来我们来完成另一项功能：提供水果食用方法咨询。 表笑这个需求，这是真实的市场需求。比如相当部分一辈子生活在北方的朋友就没有吃过龙眼荔枝香蕉；而南方虽然水果丰富，但不知道山竹榴莲等洋水果的也大有 人在。我们这个水果连锁店业务简单，水果的食用方法也只分两种：一种是剥皮的，如桔子和香蕉；另一种是削皮的，如苹果和梨子。让我们修改原有的设计：

   Fruit
   / \
  GiftFruit NotGiftFruit
  / \ /  \
PareG...   HuskG... PareNot... HuskNot...
/  / /  /
Apple     Orange  Pear  Banana
不得已，我们添加了四个类：

切换行号显示
   1 class PareGiftFruit(GiftFruit):
   2  def eat_method(self):
   3   return 'Pare'
   4 class HustGiftFruit(GiftFruit):
   5  def eat_method(self):
   6   return 'Husk'
   7 class PareNotGiftFruit(NotGiftFruit):
   8  def eat_method(self):
   9   return 'Pare'
  10 class HuskNotGiftFruit(NotGiftFruit):
  11  def eat_method(self):
  12   return 'Husk'
怎么这四个类这么像啊？汗。。。。
先忍忍，把AOPB四种水果的实现改改：

切换行号显示
   1 class Apple(PareGiftFruit):pass
   2 class Orange(HuskGiftFruit):pass
   3 class Pear(PareNotGiftFruit):Pass
   4 class Banana(HuskNotGiftFruit):pass
我已经忍无可忍了。这个设计不仅仅又引入了好不容易消除的重复代码，而且还修改了AOPB这四个类的实现。这种设计的扩展性也不好，如果以后要提 供水果的其它特点，比如是进口水果还是国产水果。天啊，这还了得！加上这个特性，我要实现NativePareGiftFruit、 NativeHuskGiftFruit等类共8个（2的三次方）啊。水果的特征多得很，随便算算可能超过16种啊，65536个类？叫我去死吧～单是长 达16个单词的类名我就崩溃了！

现在，你们都应该意识到这种实现方法实在是一种龌龊的设计了。那，我们应该怎么样设计呢？

1.1.4. Pythonic的方案
该是Mixin出场的时候了！ 先来看看Mixin的实现吧：

切换行号显示
   1 class Fruit(object):
   2  pass
   3 class GiftMixin(object):
   4  def is_gift_fruit(self):
   5   return True
   6 class NotGiftMixin(object):
   7  def is_gift_fruit(self):
   8   return False
   9 class PareMixin(object):
  10  def eat_method(self):
  11   return 'Pare'
  12 class HuskMixin(object):
  13  def eat_method(self):
  14   return 'Husk'
  15 class Apple(GiftMixin, PareMixin, Fruit):pass
  16 class Orange(GiftMixin, HuskMixin, Fruit):pass
  17 class Pear(NotGiftMixin, PareMixin, Fruit):pass
  18 class Banana(NotGiftMixin, HuskMixin, Fruit):pass
编码完成！这就是Mixin，就是这么简单，以致我无法再说出任何言语，因为我觉得上面的代码已经完整地表达了我想要表达的思想。

注意, 因为 Python 里面多重继承时如果被调用的成员函数只存在于父类中，则按类声明的父类从左到右查找调用的, 所以主类被放在右边, MixIn 被放在左边，才能正确地调用到Mixin的成员函数。


1.1.5. Mixin的好处
Mixin的好处是可以为主类（如Fruit）添加任意多的Mixin来实现多态，比如刚才说的水果有进口和国产两个特征，现在相当容易实现：

切换行号显示
   1 class NativeMixin(object):
   2  def Locality(self):
   3   return 'Native'
   4 class ForeignMixin(object):
   5  def Locality(self):
   6   return 'Foreign'
   7 class Apple(ForeignMixin, GiftMixin, PareMixin, Fruit):pass #进口红富士
   8 class Orange(NativeMixin, GiftMixin, HuskMixin, Fruit):pass
   9 class Pear(NativeMixin, NotGiftMixin, PareMixin, Fruit):pass
  10 class Banana(NativeMixin, NotGiftMixin, HuskMixin, Fruit):pass
简单多了，只加了两个类，对AOPB的实现也只是增加了一个基类（增加总是胜过修改）。
利用Mixin我们还可以增加无数总特征，而无需对已有代码作太大改动。
另外，我们还获得了可重用性。比如NativeMixin和ForeignMixin跟主类Human结合，可以做出国人和老外两个类哦～也许水果连锁店软件以后会考虑记录关于客户是否外国人的信息呢。


1.1.6. 除此之外
这时候，你可能会说：水果连锁店软件只是你杜撰的一个项目，Mixin有什么实际用处吗？
当然有啦！其实Mixin并不是什么高阶的Python技巧，早有就很多开源项目使用这个技巧了，典型的，比如Python项目啊！在 Python自带的SocketServer.py里就应用了Mixin来实现基于进程和基于线程的两种TCP/UDP服务模型，在Tkinter和 Python的其它模块也可以见到它的踪迹，如果你留意的话。


# SocketServer.py 里的Mixin
class ForkingUDPServer(ForkingMixIn, UDPServer): pass
class ForkingTCPServer(ForkingMixIn, TCPServer): pass
class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
确切来说，我对Mixin来实现的水果连锁店的实现仍然相当不满意，但如果我们想要足够面向对象，也就基本上只能接受如此解决方案了。
如果有一天你不能忍受每增加一种特征你就必须编写N（N>=2）个Mixin，然后都必须给已经存在的AOPB代码增加一个基类（想想，水果店卖的可不止四种水果，你会更头大），那，就考虑把OO抛弃吧！


鸣谢
在本文成文过程中，
沈崴(http://eishn.blog.163.com)给我很大帮助，特此鸣谢。

2. 反馈

2.1. 原稿泄漏版本

切换行号显示
   1 #!/usr/bin/env python
   2 # 仿黄毅大师的版本
   3
   4 class Instance:
   5        def __init__(self, *args, **kw):
   6                self.__dict__.update(kw)
   7                for m in args:
   8                        m(self)
   9
  10        def config(self, *args, **kw):
  11                self.__dict__.update(kw)
  12                for m in args:
  13                        m(self)
  14
  15                return self
  16
  17 def i_am_gift(self):
  18        # self.is_gift = True # Why not
  19
  20        self.is_gift = lambda: True
  21
  22 def i_am_not_gift(self):
  23        self.is_gift = lambda: False
  24
  25 def eatable(eat_method = ''):
  26        def config_eat_method(self):
  27                self.eat_method = lambda: eat_method
  28
  29        return config_eat_method
  30
  31 def Apple():
  32        return Instance(i_am_gift, eatable('Bare'))
  33
  34 def Banana():
  35        return Instance(i_am_not_gift, eatable('Hust'))
  36
  37 if __name__ == '__main__':
  38        apple = Apple()
  39        print apple.is_gift()
  40
  41        apple.config(i_am_not_gift)
  42        print apple.is_gift()
  43
  44        banana = Banana()
  45        print apple.eat_method()
  46        print banana.eat_method()

1. Mix-in技术介绍
Mixin可以译为混入，就是在不改变原对象的情况下对其进行扩展。本文介绍了在 Python 语言中，如何实现Mixin技术，及安装的相应技巧。

1.1. 什么是Mix-in技术
Mix- in技术，中文不知道应该如何称呼，但意思好象是混入。它的作用是，在运行期间,动态改变类的基类或类的方法，从而使得类的表现可以发生变化。可以用在一 个通用类接口中，根据不同的选择使用不同的低层类实现，而高层类不用发生变化。而且这一实现可以在运行过程中动态进行改变。由于我也是刚看到，大家有问题 可以与我进行交流。这就是我看到的文章的链接。


1.2. 基类的增加
有一个类，


class foo:
    pass
我可以定义另外一个类，


class foobase:
    def hello(self):
        print "hello"
如果我直接调用：


>>> obj=foo()
>>> obj.hello()
这时你会看到出错。那么我可以这样：


>>> foo.__bases__ +=(foobase,)
>>> obj.hello()
hello
成功了。原理是，每个类都有一个bases属性，它是一个tuple，用来存放所有的基类。而且在运行中，可以动态改变。所以当我们向其中增加新的基类时，再次调用原来不存在的函数，由于基类中的函数已经存在了，所以这次成功了。

这是一个最简单的应用，可以看到我们可以动态改变类的基类。有几个注意事项要说一下：

__bases__是一个tuple，所以增加一个值要使用tuple类型，而单个元素tuple的写法为(foobase,)

类必须先存在。所以，如果想使用这一技术，先要将相关的类的模块导入(import)。
由于Mix-in是一种动态技术，以多继承，对象为基础，而python正好是这样的语言，使得在python中实现这一技术非常容易。


1.3. 函数替换
在前面，简单地向大家介绍了一下Mix-in技术，它实现了基类的动态增加。这样我们就可以在运行时，根据选择可以动态地增加基类，从而实现不同的目的。现在还有一个问题，就是，在基类与派生类中都有同名的函数，要如何处理呢？

在Python中，如果派生类中有与基类同名的函数，那么调用函数时，会调用派生类的函数，而不是基类的函数，可以测试一下：


>>> class foobase:
        def a(self):
                print "hello"

>>> class foo(foobase):
        def a(self):
                print "foo"

>>> c=foo()
>>> c.a()
foo
可以看出，执行的是foo类的函数。这样在使用Mix-in技术时，如果原来的类中存在与Mix类中同名的函数，那么Mix类中的函数不会运行，如果想对其进行替换怎么办呢？方法就是使用getattr()和setattr()函数。当然还是最简单的。

定义两个类：


>>> class foobase:
        def a(self):
                print "hello"

>>> class foo:
        def a(self):
                print "foo"

>>> f=getattr(foobase, "a")
>>> setattr(foo, "a", f.im_func)     #f.im_func会得到真正的函数对象
>>> c=foo()
>>> c.a()
hello
可以看到，函数被替换了。

注意，使用dir(f)还会看到其它的属性im_class,它表示这个函数属于哪个类，im_self表示属于哪个实例。


1.4. Mix-in安装函数
前面讲了基本的实现技术，下面给大家介绍一个Mix-in安装函数，这个函数是从前面所说的文章copy下来的。


import types

def MixIn(pyClass, mixInClass, makeAncestor=0):
   if makeAncestor:
     if mixInClass not in pyClass.__bases__:
        pyClass.__bases__ = (mixInClass,) + pyClass.__bases__
   else:
     # Recursively traverse the mix-in ancestor
     # classes in order to support inheritance
     baseClasses = list(mixInClass.__bases__)
     baseClasses.reverse()
     for baseClass in baseClasses:
        MixIn(pyClass, baseClass)

     # Install the mix-in methods into the class
     for name in dir(mixInClass):
        if not name.startswith('__'):
        # skip private members
           member = getattr(mixInClass, name)
           if type(member) is types.MethodType:
               member = member.im_func
           setattr(pyClass, name, member)
这 个函数可以将某个mix-in类安装为指定类的基类，同时可以通过关键字参数指定在基类中的顺序，是最前还是最后。因为Python在处理基类时，是安顺 序进行的，所以安装在最前则优先级最高。同时对于指定类的方法如果在mix-in类中存在，则将指定类中的方法替换成mix-in类中的方法。


   if makeAncestor:
     if mixInClass not in pyClass.__bases__:
        pyClass.__bases__ = (mixInClass,) + pyClass.__bases__
如果makeAncestor为1，表示是安装在最前，则首先判断在pyClass的基类中是否存在mixInClass类，如果不存在，再进行安装。


   else:
     # Recursively traverse the mix-in ancestor
     # classes in order to support inheritance
     baseClasses = list(mixInClass.__bases__)
     baseClasses.reverse()
     for baseClass in baseClasses:
        MixIn(pyClass, baseClass)
如 果makeAncestor为0，并不将mixInClass安装在最后，原作者说他在实际中没有这样用的。那么它完成什么任务呢？它实际完成了一个递 归，即从mixInClass的最底层的基类开始(因为mixInClass也可能是多重继承而来的)，对pyClass中也存在的函数进行替换。这样执 行完毕后，mixInClass类中，包含所有基类中的函数，如果有与pyClass类中的函数重名的，都将pyClass中的函数替换成 mixInClass相应的函数。（有些复杂！）


     # Install the mix-in methods into the class
     for name in dir(mixInClass):
        if not name.startswith('__'):
        # skip private members
           member = getattr(mixInClass, name)
           if type(member) is types.MethodType:
               member = member.im_func
           setattr(pyClass, name, member)
这 步完成重名函数的替换。首先去掉私有方法（私有方法名前有'__'）.得到mixInClass类中的指定名字的方法对象，判断是否为方法类型。因为还有 可能取到属性。在types模块中包含了一些类型，可以用它来判断是否为方法类型。对于方法对象，如果是类方法，实际的函数应使用它的属性 im_func。然后将pyClass相应的方法替换成mixInClass中的方法。

这样就将mixInClass安装为pyClass的基类了。

使用例子如：


from classa import classa
from classb import classb
MixIn(classa, classb) #将classb安装为classa的基类

1：在Python中所有的都是对象，class 是一个对象，class的实例也是一个对象。在java或者c++中，class 是不用来存放数据的，只有class的实例才存放
    数据

1 class class1(object):
2     pass

1 if __name__=='__main__':
2     test = class1()
3     print class1
4     print test

  class1是一个对象，print 出来的结果：<class '__main__.class1'>
 那么 test也是一个对象，test.__class__也是一个对象
 

2：在python中所有的对象允许动态的添加属性或者方法，当类添加属性之后，类的实例同样能够访问该对象，
    如果修改了类的__class__的属性或者方法，那么该类对性的实例同样也具有该类的方法或者属性

 1 class class1(object):
 2     pass
 3 
 4 if __name__=='__main__':
 5     test = class1()
 6     #print class1
 7     #print test
 8    
 9 test.__class__.newAttr=10
10     test1 = class1()
11     print test1.newAttr

   
    当我们通过test.__class__修改了class1类的属性之后，给class1添加了个新的属性newAttr=10
    则重新test = class1()新的实例后，新的实例拥有newAttr这个属性，
    对于添加新的方法同样如此
   

  3：每个实例都有__dict__来存放动态的属性，查看一下代码：

 1 class class1(object):
 2     pass
 3 
 4 if __name__=='__main__':
 5     test = class1()
 6     #print class1
 7     #print test
 8        
 9     test.__class__.newAttr=10
10     test1 = class1()
11     print test.__dict__
12     print test.__class__.__dict__
13     print test1.__dict__
14     print test1.__class__.__dict__
15     test1.newAttr2=20
16     print test.__dict__
17     print test.__class__.__dict__
18     print test1.__dict__
19     print test1.__class__.__dict__

4:继承：当继承后，python不会像java，c++那样在子类的实例中包含父类的实例，子类的实例是个全新的对象，与父类一点关系都没有，
        不会包含有父类的任何东西，继承只是在子类的__base__指向了父类，在查找函数，属性的过程中会查找父类，
        仅此而已，而这个父类也是class对象

5:类里的变量不是以self,开头定义的都是类变量，相当于java,c++里的static，所有实例共享他们

6:python为每一个对象定义了一些属性和方法
        __doc__
        __module__
        __class__
        __bases__
        __dict__

7:python的继承
基类 __init__ / __del__ 需显示调用
继承方法的调用和基类声明顺序有关
在成员名称前添加 "__" 使其成为私有成员。
除了静态(类型)字段，我们还可以定义静态方法。

1 class Class1:
2     @staticmethod
3     def test():
4     print "static method"
5    
6 Class1.test()
7 static method

           
从设计的角度，或许更希望用属性(property)来代替字段(field)。

 1 class Class1:
 2     def __init__(self):
 3         self.__i = 1234
 4     def getI(self): return self.__i
 5     def setI(self, value): self.__i = value
 6     def delI(self): del self.__i
 7     I = property(getI, setI, delI, "Property I")
 8                  
 9 a = Class1()
10 a.I
11 1234
12 a.I = 123456
13 a.I
14 123456
15                 

如果只是 readonly property，还可以用另外一种方式。
 

 1 class Class1:
 2     def __init__(self):
 3         self.__i = 1234 
 4     @property
 5     def I(self):
 6         return self.__i
 7                  
 8 a = Class1()
 9 a.I
10 1234
11                 

               
用 __getitem__ 和 __setitem__ 可以实现 C# 索引器的功能。

class Class1:
    def __init__(self):
        self.__x = ["a", "b", "c"]
    def __getitem__(self, key):
        return self.__x[key]
    def __setitem__(self, key, value):
        self.__x[key] = value
                            
a = Class1()
a[1]
'b'
a[1] = "xxxx"
a[1]
'xxxx'

8:python的多重继承
由于python的继承主要是将几个对象建立关系，因此多重继承最重要的就是怎样在多个父类中寻找某个attribute
python寻找attribute的顺序：  

1. If attrname is a Python-provided attribute for objectname, return it.

2. Check objectname.__class__.__dict__ for attrname. If it exists and is a data-descriptor, return the descriptor result. Search all bases of objectname.__class__ for the same case.

3. Check objectname.__dict__ for attrname, and return if found. Unless objectname is a type object, in which case search its bases too. If it is a type object and a descriptor is found in the object or its bases, return the descriptor result.

4. Check objectname.__class__.__dict__ for attrname. If it exists and is a non-data descriptor, return the descriptor result. If it exists, and is not a descriptor, just return it. If it exists and is a data descriptor, we shouldn't be here because we would have returned at point 2. Search all bases of objectname.__class__ for same case.

5. Raise AttributeError



9：python重载
我们还可以通过重载 __getattr__ 和 __setattr__ 来拦截对成员的访问，需要注意的是 __getattr__ 只有在访问不存在的成员时才会被调用。

 1 class Class1:
 2     def __getattr__(self, name):
 3         print "__getattr__"
 4         return None
 5     def __setattr__(self, name, value):
 6         print "__setattr__"
 7         self.__dict__[name] = value
 8        
 9 
10            
11 >>> a = Class1()
12 >>> a.x
13 __getattr__
14 >>> a.x = 123
15 __setattr__
16 >>> a.x
17 123
18         

如果类型继承自 object，我们可以使用 __getattribute__ 来拦截所有(包括不存在的成员)的获取操作。
注意在 __getattribute__ 中不要使用 "return self.__dict__[name]" 来返回结果，因为在访问 "self.__dict__" 时同样会被 __getattribute__ 拦截，从而造成无限递归形成死循环。

 1 class Class1(object):
 2     def __getattribute__(self, name):
 3          print "__getattribute__"
 4          return object.__getattribute__(self, name)
 5        
 6 >>> a = Class1()
 7 >>> a.x
 8 __getattribute__
 9        
10 Traceback (most recent call last):
11 File "<pyshell#3>", line 1, in <module>
12 a.x
13 File "<pyshell#1>", line 4, in __getattribute__
14 return object.__getattribute__(self, name)
15 AttributeError: 'Class1' object has no attribute 'x'
16 >>> a.x = 123
17 >>> a.x
18 __getattribute__
19 123

生成器总结：

最普通的例子：

 1 >>> def h():
 2 ... yield 1
 3 ... yield 2
 4 ... yield 3
 5 ... 
 6 >>> c = h()
 7 >>> c.next()
 8 1
 9 >>> c.next()
10 2
11 >>> c.next()
12 3
13 >>> c.next()
14 Traceback (most recent call last):
15 File "<stdin>", line 1, in <module>
16 StopIteration

每次调用next都会返回yield后面表达式的值，直到遇到下一个yield语句为止。

复杂一点的例子：

 1 >>> def h():
 2 ... print '111'
 3 ... yield '+111'
 4 ... print '222'
 5 ... yield '+222'
 6 ... print '333'
 7 ... yield '+333'
 8 ... 
 9 # c是生成器
10 >>> c = h()
11 
12 # 111是print出来的，而+111是yield返回的，这时yield执行完了第一个yield并暂停。
13 # 直到接受到下一个next()
14 >>> c.next()
15 111
16 '+111'
17 
18 >>> c.next()
19 222
20 '+222'
21 >>> c.next()
22 333
23 '+333'
24 # 因为h()已经是一个生成器函数，当所有yield都执行完毕之后，再调用next()就会引发StopIteration错误。
25 >>> c.next()
26 Traceback (most recent call last):
27 File "<stdin>", line 1, in <module>
28 StopIteration
29 
30 >>> 
31 >>> c = h()
32 # 111是print的返回值，而x是yield的返回值
33 >>> x = c.next()
34 111
35 >>> x
36 '+111'
37 >>> y = c.next()
38 222
39 >>> y
40 '+222'
41 >>> z = c.next()
42 333
43 >>> z
44 '+333'

更复杂的例子：

 1 >>> def h():
 2 ... print 'enter yield!'     #1
 3 ... m = yield 123     　　　  #2
 4 ... print m     　　　　　　　 #3
 5 ... d = yield 456     　　   #4
 6 ... print d     　　　　　　  #5
 7 ... print 'leave yield!'    #6
 8 ... 
 9 >>> c = h()     　　 # c是一个生成器，因为python认为h()则是一个生成器函数，不是一个普通函数。
10 >>> a = c.next()    # 往下执行代码，直到遇到yield为止，会返回yield的值
11 enter yield!    　　 # 这里的'enter yield!'是执行#1打印的，因为要运行到#2，所以必须要打印这一行
12 >>> a     　　　　　　# 而#3返回了yield后面表达式的值
13 123
14 >>> b = c.next()    # 再次调用next()执行到了#4，返回了yield的值。 但是yield的总的返回值总是None,所以返回了None.
15 None
16 >>> b     # 但是b的值是yield返回的，是456
17 456

1 def require_login(func):                    # 传入func这个参数，是需要被装饰的函数
2     def proxy_func(self,*args,**kw):        # 这个函数对象，就是原始的函数：some_func被装饰后返回的函数对象。当然是在它被调用时才会执行。
3         print _web.input()               　 # 做一些操作
4         return func(self,*args,**kw)      　# 返回原始的函数，并加上参数
5     return proxy_func                       # 返回内层的函数对象

而真实的顺序是这样的：

1 1> def require_login(func):
2 3>    def proxy_func(self,*args,**kw):
3 4>        print _web.input()
4 5>        return func(self,*args,**kw)
5 2>    return proxy_func

1 @require_login
2 def some_func():
3     pass

上面的意思与下面的样子一样：

1 some_func_decoratored = require_login(some_func)

当执行some_func_decoratored()的时候，就相当于执行了上面的内层的函数。

整个过程大致如下：
1. 外层的require_login函数将some_func函数作为参数传入
2. 内层的proxy_func在执行时会将它捕捉到的环境参数带入，这里包括了外层函数require_login传入的func参数
3. 执行完了require_login(some_func)之后，会返回一个函数对象：proxy_func
4. proxy_func其实就是被装饰完成的函数对象，在调用some_func_decoratored()时，proxy_func执行！


而带有参数的装饰器，如下：

1 @eventhandler('BUTTON')
2 def some_func(args):
3     pass

执行语义如下：

1 def some_func(args):
2     pass
3 temp = eventhandler('BUTTON')    # 使用提供的参数调用装饰器
4 some_func = temp(some_func)        # 调用装饰器返回的函数

# 因为wrap函数的参数只能是一个函数
# 而wrapper的参数又只能是传递给函数的参数列表
# 如果想要再次处理被装饰函数的返回结果，只能在最外层的函数参数中指定
# 这里就是在deco函数的参数中
# 如果只用两层嵌套就无法做到
def deco(render=None):
    def wrap(func):
        def wrapper(*args,**kwargs):
            result = func(*args,**kwargs) ###
            return render(result)  ###
        return wrapper
    return wrap


my_render = lambda x: str(x) + ' --my_render'

@deco(render=my_render)
def test():
    return "this is test!"

print test()

这里正是因为想让result被再次处理，所以要在最外层函数的参数中制定调用的处理函数，就是my_render。

如何成为一名黑客

Copyright © 2001 by Eric S. Raymond

翻译：Barret

翻译水平有限，欢迎来信指教，我的Email是barret（a）ynmail.com， 但请勿问电脑技术问题（反正也不懂）。

允许未经作者及译者的同意进行非商业目的的转载，但必须保持原文的完整性。

FAQ（常问问题解答）

问：你能教我做黑客吗？

问：那么，我要如何开始？

问：我得什么时候开始学？现在会不会太迟了？

问：要学多久才能学会黑客道？

问：Visual Basic及Delphi是好的入门语言吗？

问：你能帮我“黑”掉一个站点吗？或者教我怎么黑它？

问：我怎么样才能得到别人帐号的密码？

问：我如何入侵/查看/监视别人的Email？

问：我如何才能在IRC聊天室里偷到频道op的特权？

问：我被黑了。你能帮我避免以后再被攻击吗？

问：我的Windows软件出现问题了。你能帮我吗？

问：我在哪里能找到可以与之交流的真正的黑客？

问：你能推荐一些有关黑客的好书吗？

问：成为一名黑客我需要擅长数学吗？

问：我该从那种语言学起？

问：我需要什么样的机器配置？

问：我得因此憎恨和反对Microsoft吗？

问：但开放源代码软件不会使程序员丢饭碗吗？

问：我要如何开始？哪里有免费的Unix？

答：在本份文档的某个地方我已经提到过何处可以得到最常用的免费Unix。 要做一名黑客，你需要自立自强，以及自学能力。现在开始吧…

WSGI是什么？

WSGI的官方定义是，the Python Web Server Gateway Interface。从名字就可以看出来，这东西是一个Gateway，也就是网关。网关的作用就是在协议之间进行转换。

也就是说，WSGI就像是一座桥梁，一边连着web服务器，另一边连着用户的应用。但是呢，这个桥的功能很弱，有时候还需要别的桥来帮忙才能进行处理。

Django 是什么？

Django(发音：/ˈdʒæŋɡoʊ/ JANG-goh) 是用python语 言写的开源web开发框架(open source web framework)，它鼓励快速开发,并遵循MVC设计。Django遵守 BSD版权，初次发布于2005年7月, 并于2008年9月发布了第一个正式版本1.0 。最新发行版本是Django 1.3.1，于2011年09月10日发布.

　　Django 根据比利时的爵士音乐家Django Reinhardt命名，他是一个吉普赛人，主要以演奏吉它为主，还演奏过小提琴等。

设计哲学

　　Django的主要目的是简便、快速的开发数据库驱动的网站。它强调代码复用,多个组件可以很方便的以“插件”形式服务于整个框架，Django有许多功能强大的第三方插件，你甚至可以很方便的开发出自己的工具包。这使得Django具有很强的可扩展性。它还强调快速开发和DRY(Do Not Repeat Yourself)原则。

　　Django基于MVC的设计十分优美：

　　对象关系映射 (ORM,object-relational mapping)

　　以Python类形式定义你的数据模型，ORM将模型与关系数据库连接起来，你将得到一个非常容易使用的数据库API，同时你也可以在Django中使用原始的SQL语句。

　　URL 分派

　　使用正则表达式匹配URL，你可以任意设计的URL，没有框架的特定限定。象你喜欢的一样灵活。

　　模版系统

　　使用Django强大而可扩展的模板语言，可以分隔设计、内容和Python代码。并且具有可继承性。

　　表单处理

　　你可以方便的生成各种表单模型，实现表单的有效性检验。可以方便的从你定义的模型实例生成相应的表单。

　　Cache系统

　　可以挂在内存缓冲或其它的框架实现超级缓冲 －－ 实现你所需要的粒度。

　　会话(session)，用户登录与权限检查

　　快速开发用户会话功能。

　　国际化

　　内置国际化系统，方便开发出多种语言的网站。

　　自动化的管理界面

　　不需要你花大量的工作来创建人员管理和更新内容。Django自带一个ADMIN site,类似于内容管理系统。

软件版本：

操作系统：Archlinux Kernel 3.1.0-4-ARCH x86_64
WEB服务器: Apache/2.2.21
Python： Python/2.7.2
Django: 1.3.1
wsgi： mod_wsgi/3.3

1. 安装apache和python
在Archlinux上我已经用pacman安装好了apahce和python，接下来安装mod_wsgi

2. 安装WSGI
pacman -S mod_wsgi
这里是Archlinux，如果是其他操作系统，请google。
安装好之后，会生成mod_wsgi的apache模块，位置在 /usr/lib/httpd/modules/mod_wsgi.so。
在apache的配置文件里载入模块：
LoadModule wsgi_module modules/mod_wsgi.so

3. 配置apache虚拟主机

NameVirtualHost *:80
<VirtualHost>
    ServerName webpy.test.com
    WSGIScriptAlias / /home/max/mysite/django.wsgi
 
   <Directory "/home/max/mysite">
        Options FollowSymLinks Indexes
        AllowOverride all
        Order Deny,Allow
        Allow from all
    </Directory>
 
    ErrorLog "/var/log/httpd/webpy-error.log"
    CustomLog "/var/log/httpd/webpy-access.log" combined
</VirtualHost>

上面红色的一行是让加载django的wsgi配置文件（django本身就支持WSGI协议）

4. 安装django
shell> pacman -S django
也可以选择下载源码安装，因为django本身全部用python编程，所以下载django的安装包之后，进入到
django源码目录，执行以下命令即可安装django：
shell> python setup.py install

5. 配置django
我们现在建立一个django的项目，建立好项目文件夹之后，django会自动生成一些项目文件：
shell> django-admin.py startproject mysite
django-admin.py是django本身的一个管理程序，除了用于新建项目之外，还有很多用途。
mysite是新建的项目名称，这样就会在当前目录下生成一个mysite的文件夹。
__init__.py __init__.pyc manage.py settings.py urls.py
上面就是mysite目录下的文件，这是django项目的初始文件。

6. 配置django的wsgi文件
在mystei目录下新建一个django.wsgi文件，内容如下：

os.environ['DJANGO_SETTINGS_MODULE'] = 'mysite.settings'
 
import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()
 
path = '/home/max'
 
if path not in sys.path:
    sys.path.append(path)

mysite.settings是mysite项目的配置文件，django项目的配置文件就是python代码；在mysite目录下可以看到settings.py文件。
由于当前目录没有在系统的PATH变量里，所以mod_wsgi无法寻找到settings.py文件，为了帮它找到，
我们把mysite目录的上一级目录，追加到PATH变量里。
sys.path.append(path)

7. 启动django项目
重启apache服务器
shell> apachectl restart
在浏览器打开 http://webpy.test.com，即可看到django的欢迎页面。

启动django的项目其实还有一种更快的方式，就是在mysite项目的目录下，执行：
shell> python manage.py runserver 8000
会出现以下信息：

Django version 1.3.1, using settings 'mysite.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

这是浏览器打开http://127.0.0.1:8000，即可看到django的淡蓝色页面。
这其实启动开发服务器，它每次只能服务器一个用户，所以不能在生产环境使用它。

8. 相关资料
推荐django book : http://djangobook.py3k.cn/2.0/ 针对django 1.3