python面向对象1–类、对象、属性、魔法方法
python面向对象2–综合案例:烤地瓜、搬家具、单继承、多继承
python面向对象3-多层继承、super()、私有权限、多态、类属性实例属性、类方法和静态方法
mro
print(对象名.mro) 输出其父类和继承关系
五、 子类调用父类的同名方法和属性
故事:daqiu学到了师傅的古法,学校的,还有自己独创的。这时有顾客想要吃到独创,也想吃到师傅的古法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
def __init__(self):
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self): # 两个父类的属性和方法一样
print(f'运用{self.kongfu}制作煎饼果子')
# 子类
class Prentice(Master, School):
def __init__(self):
self.kongfu = '[独制煎饼果子配方]'
def make_cake(self):
self.__init__()
#加自己的初始化原因:如果不加自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
print(f'运用{self.kongfu}制作煎饼果子')
# 调用父类方法,为保证调用的是父类的属性,必须在调用方法
def make_master_cake(self):
Master.__init__(self) # 要初始化之后再调用
# 再次调用初始化的原因:想要调用父类的同名方法和属性,属性在init初始化位置,需要再次调用init
Master.make_cake(self) # 加上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() #运用[独制煎饼果子配方]制作煎饼果子
六、 多层继承
故事:N年后,daqiu老了,想把所有技术传给其徒弟xiaoqiu
是运行多层继承。
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class School(object):
def __init__(self):
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self): # 两个父类的属性和方法一样
print(f'运用{self.kongfu}制作煎饼果子')
# 子类
class Prentice(Master, School):
def __init__(self):
self.kongfu = '[独制煎饼果子配方]'
def make_cake(self):
self.__init__()
#加自己的初始化原因:如果不加自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
print(f'运用{self.kongfu}制作煎饼果子')
# 调用父类方法,为保证调用的是父类的属性,必须在调用方法
def make_master_cake(self):
Master.__init__(self) # 要初始化之后再调用
# 再次调用初始化的原因:想要调用父类的同名方法和属性,属性在init初始化位置,需要再次调用init
Master.make_cake(self) # 加上self对象
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
class Tusun():
pass
xiaoqiu = Tusun()
xiaoqiu.make_cake() #运用[独制煎饼果子配方]制作煎饼果子
xiaoqiu.make_master_cake() #运用[古法煎饼果子配方]制作煎饼果子
xiaoqiu.make_school_cake() #运用[学校煎饼果子配方]制作煎饼果子
七、super()调用父类方法
需求:一次性调用父类School和Master
两种方法:法一:原方法 法二:super()
方法一:父类名.函数名(self)
class Prentice(Master, School):
def __init__(self):
self.kongfu = '[独制煎饼果子配方]'
def make_cake(self):
self.__init__()
#加自己的初始化原因:如果不加自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
print(f'运用{self.kongfu}制作煎饼果子')
# 调用父类方法,为保证调用的是父类的属性,必须在调用方法
def make_master_cake(self):
Master.__init__(self) # 要初始化之后再调用
# 再次调用初始化的原因:想要调用父类的同名方法和属性,属性在init初始化位置,需要再次调用init
Master.make_cake(self) # 加上self对象
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
#需求:一次性调用父类School和Master
def make_old_cake(self):
#方法一:如果定义的类名修改,这里也需要修改,麻烦,且代码庞大冗余
School.__init__(self)
School.make_cake(self)
Master.__init__(self)
Master.make_cake(self)
方法2:2.1 super(当前类名,self).函数()
super()能找回到它的父类
这样Prentice中super找到 School,再School中super找到Master
Prentice----》School----》Master
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class School(Master):
def __init__(self):
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self): # 两个父类的属性和方法一样
print(f'运用{self.kongfu}制作煎饼果子')
# 2.1 super(当前类名,self).函数()
super(School, self).__init__()
super(School, self).make_cake()
class Prentice( School):
def __init__(self):
self.kongfu = '[独制煎饼果子配方]'
def make_cake(self):
self.__init__()
#加自己的初始化原因:如果不加自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
print(f'运用{self.kongfu}制作煎饼果子')
# 调用父类方法,为保证调用的是父类的属性,必须在调用方法
def make_master_cake(self):
Master.__init__(self) # 要初始化之后再调用
# 再次调用初始化的原因:想要调用父类的同名方法和属性,属性在init初始化位置,需要再次调用init
Master.make_cake(self) # 加上self对象
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
#需求:一次性调用父类School和Master
def make_old_cake(self):
#方法二:super()
#2.1 super(当前类名,self).函数()
super(Prentice,self).__init__()
super(Prentice, self).make_cake()
daqiu = Prentice()
daqiu.make_old_cake()
#输出:
#运用[学校煎饼果子配方]制作煎饼果子
#运用[古法煎饼果子配方]制作煎饼果子
方法2:2.2 无参数super
相比于2.1 ,省略了参数,其余没变。更简洁,super能自动查找父类,以防父类名称改变
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
class School(Master):
def __init__(self):
self.kongfu = '[学校煎饼果子配方]'
def make_cake(self): # 两个父类的属性和方法一样
print(f'运用{self.kongfu}制作煎饼果子')
# # 2.1 super(当前类名,self).函数()
# super(School, self).__init__()
# super(School, self).make_cake()
# 方法二:2.2super
super().__init__()
super().make_cake()
class Prentice( School):
def __init__(self):
self.kongfu = '[独制煎饼果子配方]'
def make_cake(self):
self.__init__()
#加自己的初始化原因:如果不加自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
print(f'运用{self.kongfu}制作煎饼果子')
# 调用父类方法,为保证调用的是父类的属性,必须在调用方法
def make_master_cake(self):
Master.__init__(self) # 要初始化之后再调用
# 再次调用初始化的原因:想要调用父类的同名方法和属性,属性在init初始化位置,需要再次调用init
Master.make_cake(self) # 加上self对象
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
#需求:一次性调用父类School和Master
def make_old_cake(self):
# #方法一:如果定义的类名修改,这里也需要修改,麻烦,且代码庞大冗余
# School.__init__(self)
# School.make_cake(self)
# Master.__init__(self)
# Master.make_cake(self)
# #方法二:super()
# #2.1 super(当前类名,self).函数()
# super(Prentice,self).__init__()
# super(Prentice, self).make_cake()
#方法二:2.2super
super().__init__()
super().make_cake()
daqiu = Prentice()
daqiu.make_old_cake()
#输出:
#运用[学校煎饼果子配方]制作煎饼果子
#运用[古法煎饼果子配方]制作煎饼果子
八、私有权限
某些属性和方法,不想继承给子类,即对其添加私有权限
故事:daqiu把技术传承给徒弟的同时,不想把自己的钱继承给徒弟
设置私有权限的方法:在属性名和方法名前面加上__
class Prentice(Master, School):
def __init__(self):
self.kongfu = '[独制煎饼果子配方]'
self.__money = 2000000 #设置私有属性
#定义私有方法
def __info_print(self):
print('这是私有方法')
class Tusun(Prentice):
pass
xiaoqiu = Tusun()
print(xiaoqiu.__money) #报错
xiaoqiu.__info_print() #报错
获取和修改私有属性值
私有属性和私有方法只能在类的里面进行访问和修改
由于没有限定为私有类,所以在类里面可以相互传,
一般定义函数名get_xx来获取私有属性,定义set_xx用来修改私有属性值。
class Prentice(object):
def __init__(self):
self.kongfu = '[独制煎饼果子配方]'
self.__money = 2000000 #设置私有属性
#定义函数:获取私有属性值
def get_money(self):
return self.__money
#定义函数:修改私有属性值
def set_money(self):
self.__money = 500
class Tusun(Prentice):
pass
xiaoqiu = Tusun()
#print(xiaoqiu.__money) #报错
#xiaoqiu.__info_print() #报错
print(xiaoqiu.get_money()) #输出:2000000
xiaoqiu.set_money()
print(xiaoqiu.get_money()) #输出:500
九、多态
多态:传入不同的对象,产生不同的结果
定义:多态是一种使用对象的方式,子类重写父类方法,调用不同子类对象的相同父类方法,可以产生不同的执行结果
步骤
- 定义父类:并提供公共方法
- 定义子类:并重写父类方法
- 传递子类对象给调用者,可以看到不同子类执行效果不同
案例
需求:警务人员和警犬一起工作,携带不同警犬执行不同功能
两个类:工作人员、警犬
两种警犬:追击敌人,追查毒品
#需求:警务人员和警犬一起工作,携带不同警犬执行不同功能
#1,定义父类 提供公共方法 :警犬和人
class Dog(object):
def work(self):
pass
#2,定义子类:并重写父类方法 :两种警犬
class ArmyDog(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 = ArmyDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad) #追击敌人。。
daqiu.work_with_dog(dd) #追击毒品。。
十、类属性和实例属性
类属性
设置类属性
访问类属性
修改类属性
类属性是类对象所拥有的属性,它被该类的所有实例对象所共有
类属性可以使用类对象或实例对象访问
class Dog(object):
tooth = 10
wangcai = Dog()
xiaohei = Dog()
print(Dog.tooth) #10
print(wangcai.tooth) #10
print(xiaohei.tooth) #10
如果想记录某项数据始终保持一致时,则定义类属性
实例属性:要求每个对象为其单独开辟一个内存空间来记录数据,而类属性为全类共享,仅占一份内存,节省空间
修改类属性
修改类属性,只能对类对象修改,不能通过实例对象修改
通过类修改:
class Dog(object):
tooth = 10
wangcai = Dog()
xiaohei = Dog()
Dog.tooth = 20
print(Dog.tooth) #20
print(wangcai.tooth) #20
print(xiaohei.tooth) #20
通过对象修改:
class Dog(object):
tooth = 10
wangcai = Dog()
xiaohei = Dog()
wangcai.tooth = 20
print(Dog.tooth) #10
print(wangcai.tooth) #20
print(xiaohei.tooth) #10
通过对象修改:并不是修改了类属性,而是给对象创建了一个同名属性
十一、类方法和静态方法
类方法
装饰器@classmethod 标识其为类方法,第一个参数必须是类对象,cls作为第一个参数
class Dog(object):
__tooth = 10
#定义类方法
@classmethod
def get_tooth(cls):
return cls.__tooth
wangcai = Dog()
print(wangcai.get_tooth()) #10
静态方法
静态方法特点:装饰器@staticmethod
静态方法中不需要参数传递,有利于减少不必要的内存占用和性能消耗
class Dog(object):
__tooth = 10
#定义静态方法
@staticmethod
def info_print():
print('这是一个静态方法')
wangcai = Dog()
wangcai.info_print() #这是一个静态方法
Dog.info_print() #这是一个静态方法
#即可以对象调用,也可以类调用