标签：__ 进阶 python self kofu print make def
三大特征
1. 继承
面向对象中的继承: 指的是多个类之间的所属关系, 即子类默认继承父类的属性和方法
作用: 提高代码的复用率, 减少重复代码的书写
class 父类名(object):
...(省略)
class 子类名(父类名): # 继承语法
...(省略)
继承的相关概念：
继承:一个类从另一个已有的类获得其成员的相关特性，就叫作继承！
派生:从一个已有的类产生一个新的类，称为派生！
很显然，继承和派生其实就是从不同的方向来描述的相同的概念而已，本质上是一样的！
父类:也叫作基类，就是指已有被继承的类！
子类:也叫作派生类或扩展类
"""
# 1.定义父类
class Father(object):
def __init__(self):
self.gender = 'man'
def walk(self):
print('爱好散步行走')
# 2.定义子类
class Son(Father):
pass
# 3.实例化,验证继承结果
son = Son()
print(son.gender)
son.walk()
1.1 单继承
# 1.定义师傅类
class Master(object):
# 1.1 属性
def __init__(self):
self.kofu = '[传统方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 2.定义徒弟类
class Tudi(Master):
pass
# 3.实例化
xiaoming = Tudi()
print(xiaoming.kofu)
xiaoming.make_cake()
1.2 多继承
# 1.定义师傅类
class Master(object):
# 1.1 属性
def __init__(self):
self.kofu = '[传统方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 2.定义AI类
class AI(object):
# 1.1 属性
def __init__(self):
self.kofu = '[AI方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 3.定义徒弟类
class Tudi(AI, Master):
pass
# 3.实例化
xiaoming = Tudi()
print(xiaoming.kofu)
xiaoming.make_cake()
1.3 方法调用顺序
"""
子类调用父类的同名方法顺序问题:
当一个类有多个父类时, 默认使用第一个父类的同名属性和方法,
可以使用 类名.__mro__属性 或 类名.mro()方法查看调用的先后顺序
子类重写父类同名方法和属性:
重写也叫作覆盖，就是当子类属性或方法与父类的属性或方法名字相同的时候,
从父类继承下来的成员可以重新定义
"""
# 1.定义师傅类
class Master(object):
# 1.1 属性
def __init__(self):
self.kofu = '[传统方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 2.定义AI类
class AI(object):
# 1.1 属性
def __init__(self):
self.kofu = '[AI方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 3.定义徒弟类
class Tudi(AI, Master):
# 1.1 属性
def __init__(self):
self.kofu = '[独创技术]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 3.实例化
xiaoming = Tudi()
print(xiaoming.kofu)
xiaoming.make_cake()
1.4 调用父类方法
"""
子类调用父类方法
类中仍想要保留父类的行为，则需要在子类中调用父类方法 可以 直接使用父类名来进行调用，使用的方法
"""
# 1.定义师傅类
class Master(object):
# 1.1 属性
def __init__(self):
self.kofu = '[传统方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 2.定义AI类
class AI(object):
# 1.1 属性
def __init__(self):
self.kofu = '[AI方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 3.定义徒弟类
class Tudi(AI, Master):
# 1.1 属性
def __init__(self):
self.kofu = '[独创技术]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 1.3 使用老师傅的技术
def master_make_cake(self):
Master.__init__(self)
Master.make_cake(self)
# 1.4 使用AI技术
def AI_make_cake(self):
AI.__init__(self)
AI.make_cake(self)
# 3.实例化
xiaoming = Tudi()
print(xiaoming.kofu)
xiaoming.make_cake()
xiaoming.master_make_cake()
xiaoming.AI_make_cake()
1.5 super
"""
super方法调用父类方法
注意：使⽤super() 可以⾃动查找⽗类，适合单继承使⽤，多继承不建议使用
"""
# 1.定义师傅类
class Master(object):
# 1.1 属性
def __init__(self):
self.kofu = '[传统方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 2.定义AI类
class AI(object):
# 1.1 属性
def __init__(self):
self.kofu = '[AI方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 3.定义徒弟类
class Tudi(AI):
# 1.1 属性
def __init__(self):
self.kofu = '[独创技术]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 1.4 使用AI技术
def AI_make_cake(self):
super().__init__()
super().make_cake()
# 3.实例化
xiaoming = Tudi()
print(xiaoming.kofu)
xiaoming.make_cake()
xiaoming.AI_make_cake()
1.6 多层继承
# 1.定义师傅类
class Master(object):
# 1.1 属性
def __init__(self):
self.kofu = '[传统方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 2.定义AI类
class AI(object):
# 1.1 属性
def __init__(self):
self.kofu = '[AI方法]'
# 1.2 方法
def make_cake(self):
print(f'使用{self.kofu}摊煎饼')
# 3.定义徒弟类
class Tudi(AI, Master):
# 1.1 属性
def __init__(self):
self.kofu = '[独创技术]'
# 1.2 方法
def make_cake(self):
self.__init__()
print(f'使用{self.kofu}摊煎饼')
# 1.3 使用老师傅的技术
def master_make_cake(self):
Master.__init__(self)
Master.make_cake(self)
# 1.4 使用AI技术
def AI_make_cake(self):
AI.__init__(self)
AI.make_cake(self)
# 4.创建徒孙类
class Tusun(Tudi):
pass
xiaoxiaoming = Tusun()
print(xiaoxiaoming.kofu)
xiaoxiaoming.make_cake()
xiaoxiaoming.AI_make_cake()
xiaoxiaoming.master_make_cake()
2 封装
"""
封装
在软件编程中，将**属性和方法**书写到类的里面的操作即为封装，封装可以为属性和方法添加私有权限
设置私有权限的方式：在属性名前面加上两个下划线 __，格式：
self.__属性名
在Python中，可以为方法设置私有权限，即设置某个方法不继承给子类。
设置私有权限的方式：在方法名前面加上两个下划线 __，格式：
def __方法名(self):
...
"""
3 多态
3.1 入门
"""
多态，指的是：多种状态。比如：同样一个函数在不同的场景下有不同的状态
"""
# 1 多态: 同样一个函数在不同的场景下有不同的状态
# 2 多态应用场景: make_noise相当于搭建一个舞台, 让对象调用
# 传入子类对象会执行子类的api函数, 传入父类对象会传入父类的api函数
class Animal(object):
def speak(self):
print("animal 嗯嗯 ")
pass
class Dog(Animal):
def speak(self):
print('汪汪汪')
class Cat(Animal):
def speak(self):
print('喵喵喵')
# def make_noise(animal):
def make_noise(animal: Animal):
animal.speak()
if __name__ == '__main__':
mydog = Dog()
mycat = Cat()
animal = Animal()
make_noise(mydog)
make_noise(mycat)
make_noise(animal)
3.2 条件
"""
多态的条件
1、有继承 （定义父类、定义子类，子类继承父类)
2、函数重写 （子类重写父类的函数）
3、父类引用指向子类对象 （子类对象传给父类对象调用者）
根据多态实现的三个条件，构建一下场景
构建对象对战平台object_play
1 英雄一代战机（战斗力60）与敌军战机（战斗力70）对抗。英雄1代战机失败！
2 卧薪尝胆，英雄二代战机（战斗力80）出场！，战胜敌军战机！
3 对象对战平台object_play, 代码不发生变化的情况下, 完成多次战斗
# 构建对象对战平台object_play
# 1 英雄一代战机（战斗力60）与敌军战机（战斗力70）对抗。英雄1代战机失败！
# 2 卧薪尝胆，英雄二代战机（战斗力80）出场！，战胜敌军战机！
# 3 对象对战平台object_play, 代码不发生变化的情况下, 完成多次战斗
# 思路分析: 抽象战机类 HeroFighter AdvHeroFighter；敌机EnemyFighter; 构建对象战斗平台,使用多态实现
"""
class HeroFighter(object):
def power(self):
return 60
class AdvHeroFighter(HeroFighter):
def power(self):
return 80
class EnemyFighter(object):
def attack(self):
return 70
# 搭建一个平台(框架), 让对象调用
def object_play(herofighter: HeroFighter, enemyfighter: EnemyFighter):
# def object_play(herofighter, enemyfighter):
# herofighter.power() 此处发生多态!!!
# 看面向对象代码要时时刻刻注意什么时候会发生多态
if herofighter.power() > enemyfighter.attack():
print('英雄战机胜利, 敌机失败')
else:
print('英雄战机失败, 敌机胜利')
if __name__ == '__main__':
# 实例化1代战机 2代战机
myherofighter = HeroFighter()
myadvherofighter = AdvHeroFighter()
myenemyfighter = EnemyFighter()
# 一代战机出场
object_play(myherofighter, myenemyfighter)
# 二代战机出场
object_play(myadvherofighter, myenemyfighter)
3.3 优势
"""
多态的好处
1、在不改变框架代码的情况下，通过多态语法轻松的实现模块和模块之间的解耦合；实现了软件系统的可拓展
2、对解耦合的大白话解释：搭建的平台函数def object_play(herofighter:HeroFighter, enemyfighter:EnemyFighter) 相当于任务的调用者；子类、孙子类重写父类的函数，相当于子任务；相当于任务的调用者和任务的编写者进行了解耦合
3、对可拓展的大白话解释： 搭建的平台函数def object_play(herofighter:HeroFighter, enemyfighter:EnemyFighter)，在不做任何修改的情况下，可以调用后来人写的代码
4、对“继承和多态对照理解”大白话解释：
继承相当于：孩子可以复用老爹的东西。
多态相当于：老爹框架，不做任何修改的情况下，可以可拓展的使用后来人（孩子）写的东西。
"""
4 抽象
"""
抽象类
父类来确定有哪些方法 --父类制定接口标准
具体的方法实现由子类来实现 --子类实现接口标准
抽象类: 含有抽象方法的类 称之为 抽象类
抽象方法: 方法体是空实现pass 称之为 抽象方法
"""
# 抽象的父类设计标准 AC
# 具体的子类实现标准 XiaoMi_AC GREE_AC Midea_AC
class AC(object):
def cool_wind(self):
"""制冷"""
pass
def hot_wind(self):
"""制热"""
pass
def swing_l_r(self):
"""左右摆风"""
pass
class XiaoMi_AC(AC):
def cool_wind(self):
print("小米空调制冷")
def hot_wind(self):
print("小米空调制热")
def swing_l_r(self):
print("小米空调左右摆风")
class GREE_AC(AC):
def cool_wind(self):
print("格力空调制冷")
def hot_wind(self):
print("格力空调制热")
def swing_l_r(self):
print("格力空调左右摆风")
def make_cook(ac: AC):
ac.cool_wind()
if __name__ == '__main__':
gree_ac = GREE_AC()
xiaomi_ac = XiaoMi_AC()
make_cook(gree_ac)
make_cook(xiaomi_ac)
5 类 属性与方法
5.1 类 属性
"""
类属性
所谓类属性，指的就是类所拥有的属性，它被共享于整个类中(即都可以直接调用)，格式如下：
1. 类名.类属性名 # 推荐使用
2. 对象名.类属性名
"""
# 1.定义类
class Person(object):
count = 1
__height = 165
# 2.获取属性值:类名.类属性
print(Person.count)
# p = Person()
# print(p.count)
5.2 类 方法
"""
类方法
所谓类方法，指的是类所拥有的方法，并需要使用[装饰器]@classmethod来标识其为类方法
同时一定要注意的是对于类方法的第一个参数必须是类对象，通常以cls作为第一个参数名，格式如下：
@classmethod
def 类方法名(cls):
...
调用时，格式如下：
1. 类名.类方法名() # 推荐使用
2. 对象名.类方法名()
"""
# 1.定义类
class Dog(object):
__num = 6
# 类方法
@classmethod
def eat(cls):
print(cls.__num)
print('小狗喜欢吃骨头')
# 2.调用类方法
Dog.eat()
# dog = Dog()
# dog.eat()
5.3 静态方法
"""
静态方法
静态方法需要通过装饰器@staticmethod来来标识其为静态方法，且静态方法不需要多定义参数，格式如下：
@staticmethod
def 静态方法名():
...
调用时，格式如下：
1. 类名.静态方法名 # 推荐使用
2. 对象名.静态方法名
"""
# 1.定义类
class Dog(object):
__num = 6
# 类方法
@classmethod
def eat(cls):
print(cls.__num)
print('小狗喜欢吃骨头')
@staticmethod
def speak():
print('小狗会叫')
# 2.调用类方法
Dog.speak()
# dog = Dog()
# dog.speak()
标签：__,
进阶,
python,
self,
kofu,
print,
make,
def
From： https://blog.csdn.net/leeaon/article/details/140152038