继承
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__)
![](https://i-blog.csdnimg.cn/blog_migrate/c698ac92f0dd9fd13d500a28d131587e.png)
显示了子类的继承关系
子类调用父类的同名方法
#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)
#用徒弟类创建对象,调用实例属性和方法
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):
pass
xiaoqiu = 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初始化位置,所以需要再次调用init
Master.__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) #10
print(wangcai.tooth) #10
print(xiaohei.tooth) #10
类属性优点:
记录的某项数据始终保持一致时,则定义类属性。
实例属性 要求 每个对象为其
单独开辟一份内存空间来记录数据。
类属性 为全类共有,仅占一份内存,更加节省内存空间。
修改类属性
class Dog(object):
tooth = 10
wangcai = 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
#定义类方法
@classmethod
def get_tooth(cls):
return cls.__tooth
#2.创建对象,调用类方法
wangcai = Dog()
result = wangcai.get_tooth()
print(result) #10
静态方法特点
需要通过装饰器@staticmethod来进行装饰,静态方法既不需要传递类对象也不需要传递实例对象(形参没有self/cls)。
静态方法 也能够通过 实例对象和类对象访问。
使用场景
当方法中既不需要使用实例对象(如实例对象,实例属性),也不需要使用类对象(如类属性、类方法、创建实例时等)时,就定义类方法。取消不需要的参数传递,有利于减少不必要的内存占用和性能消耗。
#1.定义类,定义静态方法
class Dog(object):
@staticmethod
def info_print():
print("这是一个静态方法")
#创建对象
wangcai = Dog()
#3. 调用静态方法:类 和 对象
wangcai.info_print()
Dog.info_print()
总结:
类方法语法:
@classmethod
def类名():
代码
静态方法语法:
@staticmethod
def类名():
代码