python学习（10）继承、多态、实战

继承

一、Java与Python的继承区别：

1、Python是一个类可以继承N个类

2、Java只能继承一个类

 

二、概念：

1、基类（父类）：被继承的类

2、派生类（子类）：继承其他类的类

 

• 如果一个类没有继承任何类，则默认继承object

• Python支持多继承

• 定义子类时，必须在其构造函数中调用父类的构造函数

三、格式：

class    子类类名（父类）:
    （构造方法中调用父类的构造方法）

 

四、子类继承父类，继承了什么？

继承了父类的：（数据属性、实例属性、方法）

1、数据属性

2、实例属性

方法1：  super().__init__(name,age)       
方法2：  父类名.__init__(self,name,age)

 

3、方法

在子类中调用父类的方法，因为要用到这个方法里的内容，子类调用后对这个方法要进行重写（或者说要对这个方法进行运用），所以这个父类方法要有return返回值。

 

五、方法重写：

当父类的方法没有办法满足子类的需求的时候，那么子类就会重写了父类的方法。

 

六、继承的原则：

（简单来说，从左到右、从上到下的实践方法其实也是遵循的MRO原理，是从mro中总结出来的，根本上的顺序就是mro的输出结果。说白了就是先找自己、再从左到右找（因为是线性查找，自己重写了父类的方法就从自己这儿找到了，自己没重写的话，就是从左到右找）。

原理：

在Python中，基于MRO的解析顺序规则，就会从左到右开始查找基类，如果找到第一个匹配的属性类，就会停止查找，如果没有，那么就继续查找，直到查找到如何要求的为止。MRO其实就是通过一个C3线性化算法来实现的，它的核心思想为：

1、子类会优先于父类检查

2、多个父类会根据它们在列表中的顺序被依次检查（如下图mro输出的列表，也就是从左到右）

3、如果对下一个类存在两个合法的选择，只能选择第一个

 

 

实践：

1、从左到右

（父类中写在左边的，优先于写在右边的，如下图的Father优先于Mother）

前提条件：子类没重写父类的方法

原则：线性查找的顺序规则，也就是说调用方法，如果找到第一个满足的方法，后面继承的类即使有这个方法，也不会调用。

class Father(object):
    def __init__(self,salary):
        self.salary=salary

    @property
    def getSalary(self):
        return self.salary

    def show(self):
        print("男人赚钱")

class Mother(object):
    def __init__(self,hobby):
        self.hobby=hobby
    def show(self):
        print("女人花钱")

class Son(Father,Mother):
    def __init__(self,salary,hobby):
        Father.__init__(self,salary)
        Mother.__init__(self,hobby)

obj=Son(salary=10,hobby="读书")
# obj.show()
print(Son.mro())

 

2、从下到上

前提条件：子类重写了父类的方法。

原则：线性查找的顺序规则，调用父类以及子类共同拥有的方法的时候，优先调用子类自己写的方法。

 

class Animal(object):
    address="地球"

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

    def show(self):
        return "name is {0},age is {1}".format(self.name,self.age)

class Person(Animal):
    def __init__(self,name,age,work):
        super().__init__(name,age)        #子类继承父类的实例属性 方式1
        Animal.__init__(self,name,age)    #子类继承父类的实例属性 方式2
        self.work=work

    def info(self):
        print("来自{0}，信息：{1}".format(self.address,self.show()))

    def show(self):
        print("我我我我")

obj=Person(name="j",age=18,work="测试")
obj.show()

 

 报错：

 

 

多态

多态的优势具体可以总结为如下几点，具体为：

• 增加了持续的灵活性

• 增加了持续的额外扩展的功能

一、主函数：

主函数（统一执行程序）下可以执行函数或方法，敲main就会出来：

使用：

二、多态：万物皆可对象

func函数定义了这个方法，给函数赋值，值属于哪一类中，就调用哪个方法

 

oop实战：

oop：面向对象

 

import json
import sys

class Stack(object):
    def out(self):
        username=input("请输入你的账户：\n")
        password=input("请输入你的密码：\n")
        return username,password                 #类似封装，在下面调用就行，下面的代码会更简洁

    def register(self):
        username,password=self.out()
        temp=username+","+password
        json.dump(temp,open("data.txt","w"))           #文件序列化:相当于下面两行代码（把内容写入文件）
        # with open("data.txt","w") as f:
        #     f.write(temp)

    def login(self):
        username, password=self.out()
        lists=str(json.load(open("data.txt"))).split(",")   #文件反序列化:相当于下面两行代码
        # with open("data.txt","r") as f:
        #     lists=f.read().split(",")
        if username==lists[0] and password==lists[1]:
            print( "恭喜你，登录成功！")
        else:
            print( "请输入正确的用户名和密码")

    def profile(self):
        with open("data.txt","r") as f:
            lists=f.read().split(",")
            print("欢迎{0}访问主页".format(lists[0]))

    def exit(self):
        sys.exit(1)

    def main(self):
        while True:
            try:
                f=int(input("1、注册 2、登录 3、主页 4、退出\n"))
                if f==1:
                    self.register()
                elif f==2:
                    self.login()
                elif f==3:
                    self.profile()
                elif f==4:
                    self.exit()
                else:continue
            except Exception as e:continue

if __name__ == '__main__':
    obj=Stack()
    obj.main()