python的对象和类

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

class class1(object):
    pass

if __name__=='__main__':
    test = class1()
    print class1
    print test

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

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

class class1(object):
    pass

if __name__=='__main__':
    test = class1()
    #print class1
    #print test
   
test.__class__.newAttr=10
    test1 = class1()
    print test1.newAttr

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

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

class class1(object):
    pass

if __name__=='__main__':
    test = class1()
    #print class1
    #print test
       
    test.__class__.newAttr=10
    test1 = class1()
    print test.__dict__
    print test.__class__.__dict__
    print test1.__dict__
    print test1.__class__.__dict__
    test1.newAttr2=20
    print test.__dict__
    print test.__class__.__dict__
    print test1.__dict__
    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__ 需显示调用
继承方法的调用和基类声明顺序有关
在成员名称前添加 "__" 使其成为私有成员。
除了静态(类型)字段，我们还可以定义静态方法。

class Class1:
    @staticmethod
    def test():
    print "static method"
   
Class1.test()
static method

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

class Class1:
    def __init__(self):
        self.__i = 1234
    def getI(self): return self.__i
    def setI(self, value): self.__i = value
    def delI(self): del self.__i
    I = property(getI, setI, delI, "Property I")
                 
a = Class1()
a.I
1234
a.I = 123456
a.I
123456
                

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

class Class1:
    def __init__(self):
        self.__i = 1234 
    @property
    def I(self):
        return self.__i
                 
a = Class1()
a.I
1234
                

               
用 __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__ 只有在访问不存在的成员时才会被调用。

class Class1:
    def __getattr__(self, name):
        print "__getattr__"
        return None
    def __setattr__(self, name, value):
        print "__setattr__"
        self.__dict__[name] = value
       

           
>>> a = Class1()
>>> a.x
__getattr__
>>> a.x = 123
__setattr__
>>> a.x
123
        

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

class Class1(object):
    def __getattribute__(self, name):
         print "__getattribute__"
         return object.__getattribute__(self, name)
       
>>> a = Class1()
>>> a.x
__getattribute__
       
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
a.x
File "<pyshell#1>", line 4, in __getattribute__
return object.__getattribute__(self, name)
AttributeError: 'Class1' object has no attribute 'x'
>>> a.x = 123
>>> a.x
__getattribute__
123