'''
1什么是继承？
继承一种新建类的方式，在python中支持一个儿子继承多个爹
新建的类称为子类的或者派生类
父类有可以称为基类或者超类
子类会‘遗传’父类的属性
2 为什么要用继承
减少代码冗余
3 怎么用继承
'''
# class ParentClass1:
# pass
#
# class ParentClass2:
# pass
#
# class Subclass1(ParentClass1):
# pass
# class Subclass2(ParentClass1,ParentClass2):
# pass
# print(Subclass2.__bases__)
# (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
# 在python2中有经典类与新式类之分
# 在python3中全部为新式类
'''
1 继承是类与类之间的关系，寻找这种关系需要先抽象再继承
'''
# class OldboyPeople:
# school='oldboy'
#
# def __init__(self,name,age,sex):
# self.name=name
# self.age=age
# self.sex=sex
#
# class OldboyTeacher(OldboyPeople):
# def change_score(self):
# print('teacher %s is changing score'%self.name)
#
#
# class Oldboystudent(OldboyPeople):
# def choose(self):
# print('student %s choose course'%self.name)
# tea1=OldboyPeople('egon',18,'male') ##OldboyPeople.__init__()
# stu1=OldboyPeople('alex',73,'female')
# print(tea1.name,tea1.age,tea1.sex)
# egon 18 male
# print(stu1.name)
# alex
#
# class OldboyPeople:
# school = 'oldboy'
#
# def __init__(self, name, age, sex):
# self.name = name
# self.age = age
# self.sex = sex
#
# def f1(self):
# print('爹的f1')
# class OldboyTeacher(OldboyPeople):
# def change_score(self):
# print('teacher %s is changing score' %self.name)
# tea1 = OldboyTeacher('egon', 18, 'male')
# print(tea1.__dict__) #{'name': 'egon', 'age': 18, 'sex': 'male'}
#
# print(tea1.name) #egon
#
# print(tea1.school) #oldboy
#
# tea1.change_score() #teacher egon is changing score
# tea1.f1() #爹的f1
# class Foo:
# def f1(self):
# print('Foo.f1')
#
# def f2(self): #self=obj
# print(self) #<__main__.Bar object at 0x0000000002173898>
#
# print('Foo.f2')
# self.f1() #obj.f1()
#
# class Bar(Foo):
# def f1(self):
# print('Bar.f1')
#
# obj =Bar()
# print(obj.__dict__) #{}
#
# obj.f2()
# Foo.f2
# Bar.f1
'''
派生：子类定义自己新的属性，如果与父类同名，以子类自己的为准
'''
# class OldboyPeople:
# school = 'oldboy'
#
# def __init__(self, name, age, sex):
# self.name = name
# self.age = age
# self.sex = sex
#
# def f1(self):
# print('爹的f1')
# class OldboyTeacher(OldboyPeople):
# def change_score(self):
# print('teacher %s is changing score' %self.name)
#
# def f1(self):
# print('儿子的f1')
#
# tea1 = OldboyTeacher('egon', 18, 'male')
#
# tea1.f1() #儿子的f1 子类有的用子类的 没有网上查
#
#
# class OldboyPeople:
# school = 'oldboy'
#
# def __init__(self, name, age, sex):
# self.name = name
# self.age = age
# self.sex = sex
#
# def f1(self):
# print('爹的f1')
#
# class OldboyTeacher(OldboyPeople):
# def __init__(self,name,age,sex,level,salary):
# self.name=name
# self.age=age
# self.sex=sex
#
# self.level=level
# self.salary=salary
#
# def change_score(self):
# print('teacher %s is changing score' %self.name)
#
# def f1(self):
# print('儿子的f1')
#
# tea1 = OldboyTeacher('egon', 18, 'male',9,3.1)
# print(tea1.name,tea1.age,tea1.sex,tea1.level,tea1.salary)
'''
在子类派生出的新方法中重用父类的功能
方式一：指名道姓地调用（其实与继承没有什么关系的）
OldboyPeople.__init__(self,name, age, sex)
'''
#
# class OldboyPeople:
# school = 'oldboy'
#
# def __init__(self, name, age, sex):
# self.name = name
# self.age = age
# self.sex = sex
#
# def tell_info(self):
# print("""
# ===========个人信息==========
# 姓名：%s
# 年龄：%s
# 性别：%s
# """ %(self.name,self.age,self.sex))
# class OldboyTeacher(OldboyPeople):
# # tea1,'egon', 18, 'male', 9, 3.1
# def __init__(self, name, age, sex, level, salary):
# # self.name = name
# # self.age = age
# # self.sex = sex tea1 先调用OldboyTeacher __init__ self 已经把自己传入了
# OldboyPeople.__init__(self,name, age, sex) #在类中调用类自己的方法(不是嵌套) 类自己调方法就是当做普通的函数调用 需要几个值
# #就传入几个
#
# self.level = level
# self.salary = salary
#
# def tell_info(self):
# OldboyPeople.tell_info(self) #指名道姓的调用类里面的方法
# print("""
# 等级：%s
# 薪资：%s
# """ %(self.level,self.salary))
#
# tea1 = OldboyTeacher('egon', 18, 'male', 9, 3.1)
# # print(tea1.name, tea1.age, tea1.sex, tea1.level, tea1.salary)
#
#
# # tea1.tell_info()
'''
方法二：super()调用（严格以来依赖于继承）
super()的返回值是一个特殊的对象，该对象专门用来调用父类中的属性
在python2中 需要super(当前 自己的类名，self）
python3中super()可以不用传参数
'''
# class OldboyPeople:
# school = 'oldboy'
#
# def __init__(self, name, age, sex):
# self.name = name
# self.age = age
# self.sex = sex
#
# def tell_info(self):
# print("""
# ===========个人信息==========
# 姓名：%s
# 年龄：%s
# 性别：%s
# """ %(self.name,self.age,self.sex))
#
# class OldboyTeacher(OldboyPeople):
# # tea1,'egon', 18, 'male', 9, 3.1
# def __init__(self, name, age, sex, level, salary):
# # OldboyPeople.__init__(self,name, age, sex)
# super(OldboyTeacher,self).__init__(name,age,sex)
#
# self.level = level
# self.salary = salary
#
# def tell_info(self):
# # OldboyPeople.tell_info(self)
# super().tell_info()
# print("""
# 等级：%s
# 薪资：%s
# """ %(self.level,self.salary))
#
# tea1 = OldboyTeacher('egon', 18, 'male', 9, 3.1)
# # print(tea1.name, tea1.age, tea1.sex, tea1.level, tea1.salary)
# tea1.tell_info()
'''
1 新式类：
继承object 的类，以及该类的子类，都是新式类
在python3中，如果一个类没有指定继承的父类，默认就继承object
所以说python3中所有的类都是新式类
2 经典类（只有在python2才区分经典类与新式类）：
没有继承object的类，以及该类的子类，都是经典类
'''
# class Foo(object):
# pass
#
# class Bar(Foo):
# pass
#
# print(Foo.__bases__)
# print(Bar.__bases__)
'''
1. 什么是继承
继承是一种新建类的方式,新建的类称之为子类/派生类,被继承的类称之为父类/基类/超类
继承有3个特点:
1. 子类可以遗传/重用父类的属性(解决类与类之间代码冗余的问题)
2. 在python中一个子类可以同时继承多个父类
3. 在继承的背景下,类分为两种:新式类,经典类
新式类:但凡继承object类的子类,以及该子类的子子孙孙都是新式类
在python3中一个类即便是没有显式地继承任何类,默认就继承object类,
即在python3中所有类都是新式类
经典类:没有继承object类的子类,以及该子类的子子孙孙都是经典类
强调:只有在python2中才有经典类
在python2中如果一个类没有显式地继承任何类,并不会自动继承object类
2. 为何要用继承:减少类与类之间的代码冗余
3. 如何继承
class Foo:
pass
class Bar(Foo):
pass
#obj=Bar()
#obj.x
Bar.x
4. 属性查找
在没有出现菱形继承的情况下,属性的查找是按照从左往右的顺序一个分支一个分支的找下去
在出现菱形继承(一个子类继承的多个分支最终汇聚到一个非object类)的情况下,
新式类:广度优先查找,按照从左往右的顺序一个分支一个分支的找下去,在最后一个分支才去查找*类
经典类:深度优先查找,按照从左往右的顺序一个分支一个分支的找下去,在第一个分支就查找*类
5. 派生
在子类中定义自己的属性,如果与父类的属性重名,那以自己的为准.
在子类派生的新方法中重用父类的功能:
方式一:指名道姓地调用某一个类的函数
特点:
1. 与继承无关
2. 没有自动传值的效果
方式二:super()得到一个特殊的对象,该对象专门用来引用父类的属性
特点:
1. 严格依赖继承,完全参照mro
2. 有自动传值的效果
'''
继承与抽象（先抽象在继承）
继承描述的是子类与父类之间的关系，要找出这种关系，必须先抽象在继承
继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构
抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类
什么是抽象类 ：抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
为什么要有抽象类：如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的
内容包括数据属性和方法属性。
从设计角度来看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被
实例化，只能被继承，且子类必须实现抽象方法。
抽象类的本质还是类，指的是一组类的相似性，包括数据属性和方法属性，而接口只强调函数属性的相似性。
抽象类是一个介于类和接口之间的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计