一 继承

 

基类定义例如以下：

    def __init__(self,n="hello",a=24,w=45.9):
        self.name = n
        self.age  = a
        self.__weight = w

    def __del__(self):
        print("people deconstructor........")

    def __repr__(self):
        print("people class")

    def speak(self):
        print("%s is speaking: I am %d years old" % (self.name,self.age))

    def weight(self):
        print("Weight number:%d" % (self.__weight))

单重继承

class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        people.__init__(self,n,a,w)
        self.grade = g

def speak(self):
        print("%s is speaking: I am %d years old,and I am in grade %d" % (self.name,self.age,self.grade))

def __del__(self):
        print("student deconstructor......")

 s  = student('ken',20,60,3)
 s.speak()

多重继承

class speaker():
    topic = ''
    name  = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("I am %s,I am a speaker!My topic is %s " % (self.name,self.topic))
    def __del__(self):
        print("speaker deconstructor.....")

class sample(speaker,student):
    a = ''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)

def __del__(self):
        print ('sample deconstructor')
       #  speaker.__del__()
       #  student.__del__()

test = sample("Tim",25,80,4,"Python")
test.speak()

须要注意圆括号里父类的顺序，若是父类中有同样的方法名，而在子类使用时未指定，python从左至右搜索,即方法在子类中未找到时，从左到右查找父类中是否包括方法。

注意：

2. 假设须要在子类中调用父类的方法，须要以 父类名.方法 这样的方式调用，以这样的方式调用的时候，注意要传递self參数过去。

　　对于继承关系，子类继承了父类全部的公有属性和方法，能够在子类中通过父类名来调用，而对于私有的属性和方法，子类是不进行继承的，因此在子类中是无法通过父类名来訪问的。

　　Python支持多重继承。对于多重继承，比方

　　class SubClass(SuperClass1,SuperClass2)

　　此时有一个问题就是假设SubClass没有又一次定义构造方法，它会自己主动调用哪个父类的构造方法？这里记住一点：以第一个父类为中心。假设SubClass又一次定义了构造方法，须要显示去调用父类的构造方法，此时调用哪个父类的构造方法由你自己决定；若SubClass没有又一次定义构造方法，则仅仅会运行第一个父类的构造方法。而且若SuperClass1和SuperClass2中有同名的方法，通过子类的实例化对象去调用该方法时调用的是第一个父类中的方法。

二 多态

　　本质上，多态意味着能够对不同的对象使用相同的操作，但它们可能会以多种形态呈现出结果。len(object)函数就体现了这一点。在C++、Java、C#这样的编译型语言中，因为有编译过程，因此就鲜明地分成了执行时多态和编译时多态。执行时多态是指同意父类指针或名称来引用子类对象，或对象方法，而实际调用的方法为对象的类类型方法，这就是所谓的动态绑定。编译时多态有模板或范型、方法重载（overload）、方法重写（override）等。而Python是动态语言，动态地确定类型信息恰恰体现了多态的特征。在Python中，不论什么不知道对象究竟是什么类型，但又须要对象做点什么的时候，都会用到多态。

　　可以直接说明多态的两段演示样例代码例如以下：
　　1、方法多态

　　对于一个暂时对象obj，它通过Python的随机函数取出来，不知道详细类型（是字符串、元组还是自己定义类型），都能够调用count方法进行计算，至于count由谁（哪种类型）去做怎么去实现我们并不关心。

　　有一种称为”鸭子类型（duck typing）“的东西，讲的也是多态：

　　就in_the_forest函数而言，參数对象是一个鸭子类型，它实现了方法多态。可是实际上我们知道，从严格的抽象来讲，Person类型和Duck全然风马牛不相及。
　　2、运算符多态

　　上例中，显而易见，Python的加法运算符是”多态“的，理论上，我们实现的add方法支持随意支持加法的对象，可是我们不用关心两个參数x和y详细是什么类型。
　　 Python相同支持运算符重载，实比例如以下：

　　一两个演示样例代码当然不能从根本上说明多态。普遍觉得面向对象最有价值最被低估的特征事实上是多态。我们所理解的多态的实现和子类的虚函数地址绑定有关系，多态的效果事实上和函数地址执行时动态绑定有关。在C++, Java, C#中实现多态的方式通常有重写和重载两种，从上面两段代码，我们事实上能够分析得出Python中实现多态也能够变相理解为重写和重载。在Python中非常多内置函数和运算符都是多态的。