继承

python面向对象的继承指的是多个类之间的所属关系，及子类默认继承父类的所有属性和方法

#父类A
class A(object):def __init__(self):self.num = 1#定义成员函数：方法def info_print(self):print(self.num)#子类，继承父类
class B(A):pass

# 3.创建对象验证结论

result = B()
result.info_print() #1

在python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

单继承

单个子类继承单个父类所有属性和方法
#1.师傅类，属性和方法
class Master(object):def __init__(self):self.kongfu = '【古法煎饼果子配方】'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')#2.定义徒弟类
class Prentice(Master):pass#创建对象daqiu
daqiu = Prentice()#4.对象访问实例属性
print(daqiu.kongfu)daqiu.make_cake()

多继承

所谓多继承意思就是一个类同时继承了多个父类

#1.师傅类，属性和方法
class Master(object):def __init__(self):self.kongfu = '【古法煎饼果子配方】'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')#添加school类
class School(object):def __init__(self):self.kongfu = '[黑马煎饼果子配方]'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')

#2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性

#继承多个父类
class Prentice(Master,School):pass#用徒弟类，继承师傅类
daqiu = Prentice()print(daqiu.kongfu)daqiu.make_cake()

注意：当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法（不是按定义顺序排序，而是调用顺序） 子类重写父类同名方法和属性 以上代码修改子类，重写属性和函数即可 #2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性

#继承多个父类  添加和父类同名的属性和方法
class Prentice(Master,School):def __init__(self):self.kongfu = '[独创煎饼果子技术]'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')

注意：如果子类和父类拥有同名属性，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法 通过_mro_显示继承层级顺序 print(子类.__mro__) 显示了子类的继承关系 子类调用父类的同名方法

#1.师傅类，属性和方法
class Master(object):def __init__(self):self.kongfu = '【古法煎饼果子配方】'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')#添加school类
class School(object):def __init__(self):self.kongfu = '[黑马煎饼果子配方]'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')

#2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性

#继承多个父类  添加和父类同名的属性和方法
class Prentice(Master,School):def __init__(self):self.kongfu = '[独创煎饼果子技术]'def make_cake(self):self.__init__()print(f'运用{self.kongfu}制作煎饼果子')#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装def make_master_cake(self):#父类类名.函数（）#再次调用初始化的原因：这里想要调用父类的同名方法和属性，# 属性在init初始化位置，所以需要再次调用initMaster.__init__(self)Master.make_cake(self)def make_school_cake(self):School.__init__(self)School.make_cake(self)#用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
daqiu.make_cake()daqiu.make_master_cake()daqiu.make_school_cake()daqiu.make_cake()

多层继承

#1.师傅类，属性和方法
class Master(object):
def __init__(self):
self.kongfu = '【古法煎饼果子配方】'def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')#添加school类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')#2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性
#继承多个父类 添加和父类同名的属性和方法
class Prentice(Master,School):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'def make_cake(self):
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数（）
#再次调用初始化的原因：这里想要调用父类的同名方法和属性，
# 属性在init初始化位置，所以需要再次调用init
Master.__init__(self)
Master.make_cake(self)def make_school_cake(self):
School.__init__(self)
School.make_cake(self)#1.创建Tusun，用这个类创建对象；2.用这个对象调用父类的属性或方法看是否能成功。
class Tusun(Prentice):
passxiaoqiu = Tusun()xiaoqiu.make_cake()xiaoqiu.make_master_cake()xiaoqiu.make_school_cake()

使用super()调用父类方法 当需要一次性调用父类：类一、类二的时候可以使用super()函数 作用：减少代码冗余，提高扩展性 带参与不带参数super()写法

#1.师傅类，属性和方法
class Master(object):def __init__(self):self.kongfu = '【古法煎饼果子配方】'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')#添加school类
class School(Master):def __init__(self):self.kongfu = '[黑马煎饼果子配方]'def make_cake(self):print(f'运用{self.kongfu}制作煎饼果子')#2.1 super()带参数写法# super(School, self).__init__()# super(School, self).make_cake()#2.2 无参数的super()super().__init__()super().make_cake()#2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性
#继承多个父类  添加和父类同名的属性和方法
class Prentice(School):def __init__(self):self.kongfu = '[独创煎饼果子技术]'def make_cake(self):self.__init__()print(f'运用{self.kongfu}制作煎饼果子')#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装def make_master_cake(self):#父类类名.函数（）#再次调用初始化的原因：这里想要调用父类的同名方法和属性，# 属性在init初始化位置，所以需要再次调用initMaster.__init__(self)Master.make_cake(self)def make_school_cake(self):School.__init__(self)School.make_cake(self)

#需求：一次性调用父类Shool Master的方法

#先定义一个类def make_old_cake(self):#方法一#2.1 super(当前类明，self).函数()# super(Prentice, self).__init__()# super(Prentice, self).make_cake()#2.2 无参数super()super().__init__()super().make_cake()xiaoqiu = Prentice()xiaoqiu.make_old_cake()

私有属性 当想保留自己的密码不继承给别人时，就可以设置私有属性。 定义私有属性和方法 在属性名和方法名前加两条下划线__即可 如：

#定义私有属性：在属性名前加两条下划线__即可self.__money = 2000000#定义私有方法: 在方法名前加两条下划线__即可
def __info_print(self):print("这是私有方法")

获取和修改私有属性值 在python中一般定义函数名get_xx用来获取私有属性，定义set_xx用来修改私有属性值。

#定义函数，获取私有属性值get_xx
def get_money(self):return self.__money#定义函数：修改私有属性值 set_xx
def set_money(self):self.__money = 5000#调用验证
xiaoqiu = Tusun()print(xiaoqiu.get_money())xiaoqiu.set_money()print(xiaoqiu.get_money())

继承总结： 特点：     子类默认拥有父类的所有属性和方法     子类重写父类同名方法和属性     子类调用父类同名方法和属性 super()方法快速调用父类方法 私有权限     不能继承给子类的属性和方法需要添加私有权限 私有权限语法

class 类名():#私有属性__属性名 = 值#私有方法def __函数名(self):代码

---

面向对象—多态

多态：

指的是一类事物有多种形态。（一个抽象类有多个子类，因而多态的概念依赖于继承）。

定义：

多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果

好处：

调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！

实现步骤：

定义父类，并提供公共方法 定义子类，并重写父类方法 传递子类对象给调用者，可以看到不同子类执行效果不同

案例

#警务人员和警犬一起工作，警犬2分钟：
# 追击敌人和毒品追查，携带不同的警犬，执行不同的工作#1.定义狗的父类，子类重写父类方法：
class Dog(object):def work(self):pass#2.定义2个狗类表示不同的警犬，子类重写父类方法：
class ArmDog(Dog):def work(self):print("追击敌人...")class DrugDog(Dog):def work(self):print("追查毒品...")#定义人类
class Person(object):def work_with_dog(self,dog):dog.work()#3.创建对象·调用不同的功能传入不同的对象，观察执行的结果
ad = ArmDog()
dd = DrugDog()daqiu = Person()
daqiu.work_with_dog(ad) #追击敌人...
daqiu.work_with_dog(dd) #追查毒品...

类属性和实例属性 类属性 设置和访问类属性

类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。 类属性可以使用类对象或实例对象访问。

案例：

#1.定义类，定义类属性
class Dog(object):tooth = 10#2.创建对象
wangcai = Dog()
xiaohei = Dog()#3.使用类和对象访问类属性
print(Dog.tooth)    #10print(wangcai.tooth) #10
print(xiaohei.tooth) #10

类属性优点： 记录的某项数据始终保持一致时，则定义类属性。 实例属性 要求 每个对象为其 单独开辟一份内存空间来记录数据。 类属性 为全类共有，仅占一份内存，更加节省内存空间。 修改类属性

class Dog(object):tooth = 10wangcai = Dog()
xiaohei = Dog()#1. 类  类.类属性 = 值
# Dog.tooth = 20
# print(Dog.tooth)
#
# #使用对象获取属性值
# print(wangcai.tooth)
# print(xiaohei.tooth)#2.测试通过对象修改类属性
wangcai.tooth = 200     #实际是为wangcai添加了实例属性print(Dog.tooth) #10
print(wangcai.tooth) #200
print(xiaohei.tooth) #10

注意：     类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。

---

类方法和静态方法

类方法特点

需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数。

类方法使用场景

当方法中需要使用类对象（如访问私有类属性等）时，定义类放方法 类方法一般和类属性配合使用

#1.定义类：私有类属性，类方法获取这个私有类属性
class Dog(object):__tooth = 10#定义类方法@classmethoddef get_tooth(cls):return cls.__tooth#2.创建对象，调用类方法
wangcai = Dog()
result = wangcai.get_tooth()
print(result)   #10

静态方法特点

需要通过装饰器@staticmethod来进行装饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。

 静态方法 也能够通过 实例对象和类对象访问。 使用场景

当方法中既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性、类方法、创建实例时等）时，就定义类方法。 取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗。

#1.定义类，定义静态方法
class Dog(object):@staticmethoddef info_print():print("这是一个静态方法")#创建对象
wangcai = Dog()#3. 调用静态方法：类 和 对象
wangcai.info_print()Dog.info_print()总结：
类方法语法：
@classmethod
def类名():代码静态方法语法：
@staticmethod
def类名():代码