python面向对象

1.python中的对象

python中的对象：一切可以赋值给变量或者作为参数传递给函数(Dive into Python)

2.python类定义

class MyClass():
　　pass #do nothing here.

3.python实例

mc = MyClass()

4.对象变量和实例变量

class MyClass():

    classNum = 0  #类属性    

    def __init__(self,num):
        self.instantNum = num  #实例属性

mc = MyClass(20)

print MyClass.classNum  #0
print mc.instantNum  #20
print MyClass.instantNum  #wrong
print mc.classNum  #wrong

类属性通过类名.属性名访问，实例属性通过实例名.属性名访问

5.实例方法和类方法、静态方法

class MyClass():

    classNum = 0  #类属性

    def __init__(self,num):
        self.instantNum = num  #实例属性   

    def method(self):  #普通方法
        print "I'm a general method."

    def classMethod(cls):  #类方法
        print "This is class method."
        classMethod = classmethod(classMethod)        

    def staticMethod():  #静态方法
        print "This is static method."
        staticMethod = staticmethod(staticMethod)

mc = MyClass(20)

#call method.
MyClass.classMethod()
MyClass.classMethod()
MyClass.method(mc)

mc.classMethod()
mc.staticMethod()
mc.method()

类方法和静态方法的第二种定义方式，访问方式相同

class MyClass():

    classNum = 0  #类属性

    def __init__(self,num):
        self.instantNum = num  #实例属性

    @classmethod    
    def classMethod(cls):
        print "This is class method."

    @staticmethod
    def staticMethod():
        print "This is static method."

区别： 

实例方法，类方法，静态方法都可以通过实例或者类调用，只不过实例方法通过类调用时需要传递实例的引用（python 3可以传递任意对象，其他版本会报错）。

类方法的隐含调用参数是类，而类实例方法的隐含调用参数是类的实例，静态方法没有隐含调用参数

三种方法从不同层次上来对方法进行了描述：实例方法针对的是实例，类方法针对的是类，他们都可以继承和重新定义，静态方法也能继承(NND)，可以认为是全局函数。

6.OOP-继承

class Parent():

    version = "1.0"

    def __init__(self, name):
        self.name = name

    def sayHi(self):
        print "Hi, " + self.name

class Child(Parent):
    #do something here.
    pass

继承时成员特性：

a.对于类的成员，在子类中可以通过父类.变量名或者子类.变量名来访问，是相同的。
b.对于对象的成员，在子类中通过self.变量名来访问。但是无法访问以__开头的的私有变量。

继承时方法的特性：

a.生成子类的构造函数的时候，不会自动调用父类的构造函数，你必须手动调用它。同时，在对象释放的时候，同样要手动调用析构函数。
b.子类的构造函数和析构函数可以不定义，如果不定义的话，这会调用基类的构造和析构函数。
c.Python不存在动态绑定和静态绑定。这一点和c++不同。
d.如果基类有一个public函数，子类中重新定义一个和他名称相同，但是多一个参数的函数，多的这个参数使用默认参数。这样来调用的话，调用的子类的函数，而不是父类的函数。应该是这样。

子类和派生：

创建子类： 括号里面是父类，如果没有从任何祖先类派生，可以使用object作为父类的名字。

class SubClassName(ParentClass1[,ParentClass2,...]):
      'optional class documentation string'
      class_suite

__bases__类属性：对于任何子类，它是以个包含其父类的集合的元组。没有父类的类，他们的__bases__属性为空。

在子类方法中调用父类同名方法：

class P(object):    #父类

    def foo(self):
        print 'Hi, I am P-foo()'

class C(P):         #子类，继承父类P

    def foo(self):
        P.foo(self)     #调用父类同名方法

        print 'Hi, I am C-foo()' 

super()内建方法:super()不但能找到基类方法，而且还为我们传进self，如下：

class C(p):

    def foo(self):
        super(C,self).foo()   #调用C基类方法，自动查找C的基类
        print 'Hi,I am C-foo()'

7.OOP-封装

对于C++和JAVA等静态语言，封装完就定了。而python作为动态语言，可以随时往对象里加东西，当然我们不推荐这样做。

例如上面的mc对象，只要mc.new_item = 100,就给ma添加了一个新成员变量

8.OOP-多态

由于python是动态语言，每个对象都知道自己类型，本身就能实现多态，好像也没法不多态。

ma = MyClassA()  
mb = MyClassB()  
mc = ma #mc是MyClassA  
mc = mb #mc是MyClassB  

看上去，动态比多态更变态吧

参考链接：

http://blog.csdn.net/caz28/article/details/7461117
http://blog.csdn.net/lovingprince/article/details/6595466
http://www.cnblogs.com/NNUF/archive/2013/01/28/2880451.html
http://www.cnblogs.com/chgaowei/archive/2011/05/29/2062418.html
http://blog.163.com/yang_jianli/blog/static/161990006201122411586729/