• 类是一个对象
  • 类可以有自己的属性，函数
• 实例是类对象通过init函数创建出来的一个对象，
  • 可以调用类对象的属性，函数。
  • 也可以知己覆盖类对象的属性，函数
• 类对象，实例对象都可以动态生成属性，函数

mod1.py

class mod1:
    def origin(self):
        print "this is mod1 only"
    def show(self):
        print "mod1"

mod2.py

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   #动态创建函数

main.py

#!/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重载

class s:pass  #定义一个临时类
s.name='fang' #给类加了一个属性。这句话合法，因为类也是一个对象
print s.name 
ss=s()     #新建一个实例
s.name='qiang'
print ss.name #结果是"qiang"。实例ss其实并没有name属性，只是从类对象中读取罢了

方法             重载            触发
__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 

C.__name__
C.__doc__
C.__bases__
C.__dict__
C.__module__
C.__class__
类C的名字(字符串)
类C的文档字符串
类C的所有父类构成的元组
类C的属性
类C定义所在的模块(1.5 版本新增) 实例C对应的类(仅新式类中)

I.__class__ 实例化 I 的类 
I.__dict__ I 的所有属性

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 (按继承顺序广度搜索)