类的继承和多态

继承

定义：继承是一种创建类的方法，在python中，一个类可以继承来自一个或多个父类。原始类称为基类（base）或超类（super）。

class <类名>(父类名) :
<语句>

class 类名(父类1,父类2,....,父类n) :
<语句> 注：不用学

class Person:
    def __init__(self, name, age):
        self._name = name  # _name是保护类型
        self._age = age
    
    def print_age(self):
        print("%s's age is %s" % (self._name, self._age))

class Man(Person):  #子类不重写 __init__，实例化子类时，会自动调用父类定义的 __init__ 
    work = "Teacher"
    def print_age(self):
        # super().print_age()  调用基类的方法
        print("Mr. %s's age is %s" %(self._name, self._age))
    
    def print_work(self):
        print("Mr. %s's word is %s" %(self._name, self.work))

bob = Man('Bob', 33) # 类Man外部并没有实例属性_name和_age，但Man内部继承了保护类型_name和_age，可以访问
bob.print_age()  # Mr. Bob's age is 33  
bob.print_work() # Mr. Bob's word is Teacher

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

class Student(Person): # Person类中有name和gender属性所以直接继承即可。另外需要新增score属性。
    def __init__(self, name, gender, score): # 如果子类重写了__init__ ，实例化子类时，就不会自动调用父类的构造函数
        super().__init__(name, gender)       # 必须通过super()强制调用
        self.score = score

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)# 旧式用法，新式super().方式 
        self.score = score

class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course

t = Teacher('Alice', 'Female', 'English')
p = Person('Tim','Male')
print isinstance(t,Person)   # True
print isinstance(t,Student)  # False
print isinstance(t,Teacher)  # True
print (issubclass(Teacher,Person))  # True

多态

多态性依赖于继承。从一个父类派生出多个子类，可以使子类之间有不同的行为，这种行为称之为多态。更直白的说，就是子类重写父类的方法，使子类具有不同的方法实现。

子类与父类拥有同一个方法，子类的方法优先级高于父类，即子类覆盖父类。

#多态特性
#父类Person有whoAmI方法，子类Student也有whoAmI方法
#函数who_am_i参数为具有whoAmI方法的实例对象

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def whoAmI(self):
        print( 'I am a Person, my name is %s' % self.name)

class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    def whoAmI(self):
        print( 'I am a Student, my name is %s' % self.name)

def who_am_i(person):
    person.whoAmI()

p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
who_am_i(p)  # I am a Person, my name is Tim
who_am_i(s)  # I am a Student, my name is Bob

（了解）重载^*

1）、函数（方法重载）

其他编程语言中函数或者类中方法的重载主要是为了解决两个问题。
1.可变参数类型。
2.可变参数个数。

在python中，具有重载的思想却没有重载的概念，或者说python天生就具有重载的功能。python是一门动态语言，不需要声明变量类型，函数中可以接受任何类型的参数也就无法根据参数类型来支持重载，python没有必要去考虑参数的类型问题，这些都可以在函数内部判断处理，并无必要去在写一个函数。python 有多种传参方式，默认参数/可变参数/可变关键字参数可以处理函数参数中参数可变的问题。

可以说python没有任何形式的重载

def add(x,y):
    return x+y

print(add(100,200))     # 变量的动态类型，天生具有其他语言的重载概念
print(add("abc","def"))

def add_other(*arg):    # 可变参数让python具有其他语言的重载概念
    s=0
    for item in arg:
        s=s+item
    return s

print(add_other(1,2,3))  # 
print(add_other(1,2,3,4,5,6))

2）、运算符重载

Python运算符重载的实现是提供特殊命名的方法来拦截运算。Python语言替每种运算和特殊命名的方法之间，定义了固定不变的映射关系。例如：如果实例对象继承了__add__方法，当对象出现在“+”表达式内时，该方法就会调用。该方法的返回值会变成相应表达式的结果。如果没有__add__，类实例的“+”表达式就会引发异常。

class Vector:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __repr__(self):
        return 'Vector(%r, %r)' % (self.x, self.y)

    def __bool__(self):
        return bool(self.x and self.y)

    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Vector(x, y)
    def  __radd__(self, other):
        return self + other #直接委托给 __add__ 

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

a = Vector(1, 2)
b = Vector(3, 4)
v = a + b  # Vector(4, 6)  # 调用__add__方法
print(bool(Vector(0,-2)))     # 调用__bool__方法
repr(v*3)                    # 先调用__mul__方法，再调用__repr__ ，'Vector(12, 18)'

运算符(a+b)，Python提供了特殊的分派机制,如下图：

面向对象编程编程举例