Python面向对象--继承

1.继承

在现实生活中，继承一般指的是子女继承父辈的财产，父辈有的财产，子女能够直接使用。

程序里的继承
继承是面向对象软件设计中的一个概念，与多态、封装共为面向对象的三个基本特征。继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。

在程序中，继承描述的是多个类之间的所属关系。
如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里。
那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类。

 

格式：

继承：
 Student，Employee，Doctor都属于人类
 具有相同的属性，相同的代码存在冗余，可读性不高

 提取相同的代码，子类继承父类--->Person
 Student，Employee，Doctor===》继承Person
 class 子类名（父类名）:
    pass

 

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

    def eat(self):
        print(self.name + '正在吃饭...')

    def run(self):
        print(self.name + '正在跑步...')


class Student(Person):
    pass


class Employee(Person):
    pass


class Doctor(Person):
    pass


stu = Student('tom', 18)
stu.run()
stu.eat()

e = Employee('jack', 20)
e.run()
e.eat()

d = Doctor('smith', 21)
d.run()
e.eat()

'''
tom正在跑步...
tom正在吃饭...
jack正在跑步...
jack正在吃饭...
smith正在跑步...
jack正在吃饭...
'''

 

2.super

 1、如果类中不定义__init__,调用父类 super class 的__init__
 2、如果类继承父类也需要定义自己的__init___,就需要在当前类的__init__调用父类的__init__
 3、如何调用父类的__init__:
    (1).super().__init__(参数)
    (2).super（类名，对象）.__init__(参数)
 4、如果父类有某个方法，子类也定义一个同样的方法，则只读取子类的方法。默认搜索原则：先找当前子类，再找父类。
    如父类的Person也有eat(),但子类的Student类也有eat()，则先调用子类Student类的eat(),再调用父类的eat()

 5、当父类提供的方法不满足子类的需求时，就需要在子类中定义一个同名的方法，这种行为就叫做重写
 6、子类的方法中也可以调用父类的方法，调用方法：super().方法名
 例如Student类的eat，：super.eat()

 

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

    def eat(self):
        print(self.name + '正在吃饭...')

    def run(self):
        print(self.name + '正在跑步...')


class Student(Person):
    def __init__(self, name, age, clazz):
        super().__init__(name, age)
16         self.clazz = clazz
        print('---------->student的init')

    def study(self, course):
        print('{}正在学{}'.format(self.name, course))

    def eat(self, food):
        super().eat()
        print('{}正在吃饭...喜欢吃：{}'.format(self.name, food))


class Employee(Person):
    def __init__(self, name, age, salary, manager):
        super().__init__(name, age)
        self.salary = salary
        self.manager = manager


class Doctor(Person):
    def __init__(self, name, age, patients):
        super(Doctor, self).__init__(name, age)
        self.patients = patients


stu = Student('tom', 18, 'python1906')
stu.run()
stu.eat('万州烤鱼')
stu.study('python基础')
e = Employee('jack', 20, 10000, 'king')
# e.run()

list1 = ['张三', '李四', '王五']
d = Doctor('smith', 21, list)
# e.run()

'''
tom正在跑步...
tom正在吃饭...
tom正在吃饭...喜欢吃：万州烤鱼
tom正在学python基础
'''

 

小练习

编写一个简单的工资管理程序,系统可以管理以下四类人，工人(rorker)、销售员(salesman)
所有的员工都具有员工号，姓名，工资等属性，
有设置姓名，获取姓名，获取员工号，计算工资等方法。
1）工人:工人具有工作小时数和时薪的属性，工资计算法方法为工作小时数*时薪。
2)销售员:具有销售额和提成比例的属性，工资计算方法为销售额*提成比例。
请根据以上要求设计合理的类,完成以下功能:
    1）添加所有类型的人员
    2）计算月薪
    3）显示所有人工资情况

 

class Person:
    def __init__(self, no, name, salary):
        self.no = no
        self.name = name
        self.salary = salary

    def __str__(self):
        msg = '工号：{}，姓名：{}，本月工资：{}'.format(self.no, self.name, self.salary)
        return msg

    def getSalary(self):
        return self.salary


class Worker(Person):

    def __init__(self, no, name, salary, hours, per_hour):
        super(Worker, self).__init__(no, name, salary)
        self.hours = hours
        self.per_hours = per_hour

    def getSalary(self):
        money = self.hours * self.per_hours
        self.salary += money
        return self.salary


class Salesman(Person):
    def __init__(self, no, name, salary, salemoney, percent):
        super(Salesman, self).__init__(no, name, salary)
        self.salemoney = salemoney
        self.percent = percent

    def getSalary(self):
        money = self.salemoney * self.percent
        self.salary += money
        return self.salary


#  创建子类对象

worker = Worker('007', 'tom', 2000, 180, 18)
salary = worker.getSalary()
print('007号月薪是:', salary)
print(worker)

saler = Salesman('008', 'jack', 5000, 5000000, 0.003)
salary = saler.getSalary()
print('008号月薪是:', salary)
print(saler)

'''
007号月薪是: 5240
工号：007，姓名：tom，本月工资：5240
008号月薪是: 20000.0
工号：008，姓名：jack，本月工资：20000.0
'''

 

 

3.多继承

Python中针对类提供了一个内置属性__mro__可以用来查看方法的搜索顺序。
MRO 是method resolution order的简称，主要用于在多继承时判断方法属性的调用顺序。
print(C.__mro__)
输出结果:

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
在调用方法时，按照__mro__的输出结果从左至右的顺序查找。
如果再当前类中找到方法，就直接执行，不再向下搜索。
如果没有找到，就顺序查找下一个类中是否有对应的方法，如果找到，就直接执行，不再继续向下搜索。
如果找到了最后一个类，依然没有找到方法，程序就会报错。

 

新式类和旧式（经典）类
object是Python中所有对象的基类，提供了一些内置的属性和方法，可以时候用dir函数查看。

新式类：以object为基类的类，推荐使用
经典类：不以object为基类的类，不推荐使用
在 Python3.x 以后定义类时，如果没有指定父类，这个类会默认继承自 object,所以，python3.x版本定义的类都是新式类。
在Python2.x中定义类时，如果没有指定父类，则不会继承自object.
为了保证代码在Python2.x和Python3.x中都能够运行，在定义类时，如果一个类没有父类，建议统一继承自'object'

class 类名(object):
    pass

 

 

class P2:
    def foo(self):
        print('p2--->foo')


class C1(P1, P2):
    pass


class C2(P1, P2):
    def bar(self):
        print('C2--->bar')


class D(C1, C2):
    pass

d = D()

20 print(D.__mro__)

'''
(<class '__main__.D'>, <class '__main__.C1'>, <class '__main__.C2'>,
 <class '__main__.P1'>, <class '__main__.P2'>, <class 'object'>)
'''

 

继承搜索顺序

class A:
    def foo(self):
        print('p1--->foo')

    def bar(self):
        print('p1--->bar')


class B:
    def foo(self):
        print('p2--->foo')


class C(A):
    pass


class D(A):
    def bar(self):
        print('C2--->bar')


class E(C, B):
    pass


class F(C, B, D):
    pass


class G(D, B):
    pass


g = G()

print(F.__mro__)

'''
(<class '__main__.F'>, <class '__main__.C'>, <class '__main__.B'>, 
<class '__main__.D'>, <class '__main__.A'>, <class 'object'>)
'''

F的查找顺序，先C-->B-->D-->A-->object

 

 先按继承的顺序寻找，到最后一个再按往上一层级的寻找