python中的oop

1. 要分清楚“类”和“实例”，类和实例都是一种类型

class MyClass:    //定义一个类
    'define a class' 
    foo=0		//定义一个static变量
    def func(self):	//定义一个static 的方法
        print self.foo

classinstance=MyClass() //创建一个实例
print type(myclass)
print type(MyClass)
打印：

<type 'instance'>
<type 'classobj'>



2.方法（python中不能重载）
myclass=MyClass() //创建一个实例
myclass.func() //调用类中的一个方法
MyClass.func(myclass) //另一种调用类中的方法



3.类中的变量

class MyClass:
    'define a class'
    foo=0
    var=0
    def func(self):
        print self.foo,'---',self.var
        
myclass=MyClass()
myclass.func()
myclass.foo=10
MyClass.func(myclass)
MyClass.var=1000
MyClass.func(myclass)


myclass1=MyClass()
myclass1.func()
myclass1.foo=100
MyClass.func(myclass1)
打印：
0 --- 0
10 --- 0
10 --- 1000
0 --- 1000
100 --- 1000


4.类的构造函数和析构函数

    def __init__(self,foo,var='1111'):
        self.foo=foo
        self.var=var
其中析构函数一般不用：__del__




5.继承（可以多继承）

class OtherClass(MyClass):
    var2=0
    def __init__(self,foo,var):
        MyClass.__init__(self, foo, var)
        self.var2='111111111111'
    def otherfunc(self):
        self.func()
        print self.var2


总结：在class定义中的都是静态变量，如果用MyClass.var=10这样的方式可以修改类中的静态变量。
需要要在实例添加实例的成员变量，可以用myclass.foo=1000 这样就会添加一个foo的成员变量，修改myclass实例中的成员变量foo不会影响这个类的其他实例，如果这个类中原来就有foo
 的静态变量，也不会影响。
用某一个实例.一个成员变量，如果这个成员变量没有在这个实例中，这个动作将会添加一个成员变量到这个实例中，同时在class类中的函数中也可以通过self.一个成员变量  添加一个成员到某个实例中。

class MyClass:
    'define a class'
    foo=0
    var=0
    def __init__(self,foo,var='1111'):
        self.foo=foo
        self.var=var

    def func(self):
        var4=90000000
        print self.foo,'---',self.var,'----',var4
        
myclass=MyClass('sun',190)
myclass.func()
print myclass.var4 #这句话不对，因为没有var4变量，如果在fuc函数中将var4前面添加self. 就可以了，因为self.一个变量，会将这个变量添加到该实例中，但是上面程序中的var4就是一个普通的临时变量


类中的特殊属性比较后面都实例的特殊属性：
__name__ : 类的字符串名字
__doc__：  类的文档字符串
__bases__： 类的父亲表列
__dict__： 
类的属性  这个重要
__module__：对类进行定义的模块




print '__name__: '+str(MyClass.__name__)
print '__doc__: '+str(MyClass.__doc__)
print '__bases__: '+str(MyClass.__bases__)
print '__dict__: '+str(MyClass.__dict__)
print '__module__: '+str(MyClass.__module__)
print dir(MyClass)  打印类属性
myclass.func()
print dir(myclass)  打印实例属性


打印：
__name__: MyClass__doc__: define a class__bases__: ()__dict__: {'__module__': '__main__', 'func': <function func at 0x00BA0570>, 'var': 0, 'foo': 0, '__doc__': 'define a class', '__init__': <function __init__ at 0x00BA05B0>}__module__: __main__(<class __main__.MyClass
 at 0x00ACA510>,)
['__doc__', '__init__', '__module__', 'foo', 'func', 'var']sun --- 190 ---- 90000000['__doc__', '__init__', '__module__', 'foo', 'func', 'var', 'var4']
//这里为什么多多一个var4，因为在func中添加了一个成员变量
实例的特殊属性：
__class__: 实例化出这个实例的类
__dict__: 
实例的属性

print myclass.__class__
print myclass.__dict__




打印：
__main__.MyClass  类的名称

{'var': 190, 'foo': 'sun'} 实例中的属性





内建类型的属性：
内建类型不想类和实例一样有属性字典__dict__，python中内建类型有两个特殊的属性__methods__和__members__,查看方法或者数据属性