Python-面向对象 (二 继承)

一 继承

 

基类定义例如以下：

class people:

    #define attribute

    name = ''

    age  = 0

    #define private attribute

    __weight = 0

    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从左至右搜索,即方法在子类中未找到时，从左到右查找父类中是否包括方法。

注意：

1. 在Python中，假设父类和子类都又一次定义了构造方法__init( )__，在进行子类实例化的时候，子类的构造方法不会自己主动调用父类的构造方法，必须在子类中显示调用。

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

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

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

　　class SubClass(SuperClass1,SuperClass2)

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

二 多态

         多态即多种形态，在执行时确定其状态，在编译阶段无法确定其类型，这就是多态。Python中的多态和Java以及C++中的多态有点不同，Python中的变量在定义时不用指明其类型，它会依据须要在执行时确定变量的类型（个人认为这也是多态的一种体现），而且Python本身是一种解释性语言，不进行预编译，因此它就仅仅在执行时确定其状态，故也有人说Python是一种多态语言。

        在Python中非常多地方都能够体现多态的特性，比方内置函数len(object)，len函数不仅能够计算字符串的长度，还能够计算列表、元组等对象中的数据个数，这里在执行时通过參数类型确定其详细的计算过程，正是多态的一种体现。这有点类似于函数重载（一个编译单元中有多个同名函数，但參数不同），相当于为每种类型都定义了一个len函数。这是典型的多态表现。有些朋友提出Python不支持多态，我是全然不赞同的。

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

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

　　1、方法多态

[python] view
plaincopy

1. # -*- coding: UTF-8 -*-
2. _metaclass_=type # 确定使用新式类
3. class calculator:
4. def count(self,args):
5. return 1
6. calc=calculator() #自己定义类型
7. from random import choice
8. obj=choice(['hello,world',[1,2,3],calc]) #obj是随机返回的 类型不确定
9. print type(obj)
10. print obj.count('a') #方法多态

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

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

[python] view
plaincopy

1. _metaclass_=type # 确定使用新式类
2. class Duck:
3. def quack(self):
4. print "Quaaaaaack!"
5. def feathers(self):
6. print "The duck has white and gray feathers."
7. class Person:
8. def quack(self):
9. print "The person imitates a duck."
10. def feathers(self):
11. print "The person takes a feather from the ground and shows it."
12. def in_the_forest(duck):
13. duck.quack()
14. duck.feathers()
15. def game():
16. donald = Duck()
17. john = Person()
18. in_the_forest(donald)
19. in_the_forest(john)
20. game()

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

　　2、运算符多态

[python] view
plaincopy

1. def add(x,y):
2. return x+y
3. print add(1,2) #输出3
4. print add("hello,","world") #输出hello,world
5. print add(1,"abc") #抛出异常 TypeError: unsupported operand type(s) for +: 'int' and 'str'

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

　　 Python相同支持运算符重载，实比例如以下：

[python] view
plaincopy

1. class Vector:
2. def __init__(self, a, b):
3. self.a = a
4. self.b = b
5. def __str__(self):
6. return 'Vector (%d, %d)' % (self.a, self.b)
7. def __add__(self,other):
8. return Vector(self.a + other.a, self.b + other.b)
9. v1 = Vector(2,10)
10. v2 = Vector(5,-2)
11. print v1 + v2

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