====== 类的基本概念 ======

----
  * 类是一个对象
    * 类可以有自己的属性，函数
  * 实例是类对象通过__init__函数创建出来的一个对象，
    * 可以调用类对象的属性，函数。
    * 也可以知己覆盖类对象的属性，函数
  * 类对象，实例对象都可以动态生成属性，函数
mod1.py
<code>
class mod1:
    def origin(self):
        print "this is mod1 only"
    def show(self):
        print "mod1"
</code>
mod2.py
<WRAP center round tip 60%>
所有_ _xx_ _的函数都是类的钩子函数，当某些操作被触发的时候调用
</WRAP>

<code>
from mod1 import mod1
class mod2(mod1): #继承mod1类
    def __init__(self):   #初始化函数，这里可以声明类的属性。python中属性是动态建立的，只要被赋值就会被创建
        self.count=10
    def __add__(self,data): # 当类做加法的时候回自动调用这个函数
        print str(self.count)+" + "+str(data)+" = "+str(self.count+data)
    def show(self):
        self.name='fang' #创建一个类的属性，其实只要被赋值就会自动创建
        print "mod2"
    def __str__(self): #当实例被内置函数str调用时触发
        return "str function is called"

def test(self):
    print "test"
mod2.testFun = test   #动态创建函数
</code>

main.py
<code>
#!/usr/bin/python
from mod2 import mod2
m=mod2()
m.origin() #调用mod2的父类
m.show()   #mod2重载了mod1的show函数
m+1        #测试+重载
m.testFun()  #调用动态函数
print str(m) #此时str重载
</code>
<code>
class s:pass  #定义一个临时类
s.name='fang' #给类加了一个属性。这句话合法，因为类也是一个对象
print s.name 
ss=s()     #新建一个实例
s.name='qiang'
print ss.name #结果是"qiang"。实例ss其实并没有name属性，只是从类对象中读取罢了
</code>

----
====== 运算符重载 ======
<code>
方法             重载            触发
__init__        构造函数        	X=Class()
__del__        	析构函数        	对象销毁
__add__        	+                	X+Y,X+=Y
__or__        	|                	X|Y,X|=Y
__repr__        打印转换        	print X，repr(X)
__str__        	打印转换        	print X，str(X)
__call__        调用函数        	X()
__getattr_   	限制            	X.undefine
__setattr__    	取值            	X.any=value
__getitem__    	索引            	X[key]，
                            
__len__        	长度            	len(X)
__cmp__        	比较            	X==Y,X<Y
__lt__        	小于            	X<Y
__eq__        	等于            	X=Y
__radd__        Right-Side +        	+X
__iadd__        +=                	X+=Y
__iter__        迭代            	For In 
</code>
====== 类的特殊属性 ======
<code>
C.__name__
C.__doc__
C.__bases__
C.__dict__
C.__module__
C.__class__
类C的名字(字符串)
类C的文档字符串
类C的所有父类构成的元组
类C的属性
类C定义所在的模块(1.5 版本新增) 实例C对应的类(仅新式类中)
</code>
====== 实例的特殊属性 ======
<code>
I.__class__ 实例化 I 的类 
I.__dict__ I 的所有属性
</code>

====== 类的多继承 ======
<code>
class a(object):pass
class b(a):pass
class c(a):pass
class d(b,c):pass

print d.__mro__


结果：
(<class '__main__.d'>, <class '__main__.b'>, <class '__main__.c'>, <class '__main__.a'>, <type 'object'>)


d -> b -> c -> a (按继承顺序广度搜索)
</code>