Python知识分享第十六天

"""

故事7:

小明把煎饼果子技术传给徒弟的同时, 不想把独创配方传给他, 我们就要加私有.

问: 既然不想让子类用, 为什么要加私有?

答: 私有的目的不是不让子类用, 而是不让子类直接用, 而必须通过特定的途径或者方式才能使用.

大白话: ATM机为啥要设计那么繁琐, 直接搞个大箱子, 里边放钱, 存钱就直接放进去, 取钱就直接拿多少, 何必要锁的那么严实, 留个插卡口, 键盘输入密码.

不能直接拿要按照银行定的规矩拿

"""

python 复制代码

class Prentice():
    def __init__(self):
        self.congfu = '[独创煎饼果子配方]'

    def __make_cake(self):
        print(f'运用{self.congfu} 制作煎饼果子')

    def my_make_cake_method(self):
        self.__make_cake()

class TuSun(Prentice):
    pass

if __name__ == '__main__':
    t1 = TuSun()
   # t1.make_cake()      #报错  方法私有后通过公共的访问方式调用 
   # t1.__make_cake()  #报错
    t1.my_make_cake_method()

"""

多态介绍:

概述:

多态是指通义事物在不同时刻(环境) 表现出的不用状态, 形态

Python: 同一个函数接收不同的对象达到不同的效果

实现条件:

1.要有继承关系

2, 要有方法重写

3.要有父类引用指向子类对象

好处:

提高代码扩展性和可维护性

还记开发中的应用:

父类充当函数的形参类型这样可以接受任意的子类对象实现传入什么子类就调用其对应的功能

"""

python 复制代码

# 定义动物类 充当父类
class Animal():
    def speak(self):
        print('动物会叫')
        # pass    # 如果多个子类的实现都不同 则直接用pass修饰即可

class Dog(Animal):
    def speak(self):
        print('狗会汪汪汪的叫')

class Cat(Animal):
    def speak(self):
        print('猫会喵喵喵')

class Phone:
    def speak(self):
        print('手机会模仿各种声音')

def print_animal(an: Animal):
    an.speak()


if __name__ == '__main__':
    a = Animal()

    d1 = Dog()
    c1 = Cat()
    p = Phone()
    print_animal(d1)
    print_animal(c1)

    print_animal(p)
# 直观的感受父类引用指向子类对象
an : Animal =  Dog()

"""

需求:

构建对象对战平台object_play(英雄机, 敌机)

英雄一代战机（战斗力60）与敌军战机（战斗力70）对抗。英雄1代战机失败！
卧薪尝胆，英雄二代战机（战斗力80）出场！，战胜敌军战机！
对象对战平台object_play, 代码不发生变化的情况下, 完成多次战斗

提示:

抽象战机类 HeroFighter AdvHeroFighter；敌机EnemyFighter;

构建对象战斗平台, 使用多态实现

"""

python 复制代码

class HeroFight():
    def power(self):
        return 60
class AdvHeroFight(HeroFight):
    def power(self):
        return 80
class EnemyFughter():
    def power(self):
        return 70


def object_play(hero:HeroFight, enemy:EnemyFughter):
    if hero.power() >= enemy.power():
        print('凯旋')
    else:
        print('铩羽')

if __name__ == '__main__':
    hero = HeroFight()
    hero2 = AdvHeroFight()
    enemy = EnemyFughter()

    object_play(hero, enemy)
    object_play(hero2, enemy)

"""

抽象类解释:

概述:

有抽象方法的就叫抽象类也叫接口

抽象方法: 没有方法体的方法就叫抽象方法

格式:

class 类名:

def 函数名(self):

pass

作用:

抽象类一般充当父类使用用于指定行业规范

而具体的实现是交由各个子类完成

需求:
    假设国家规定空调必须有 冷风热风左右摆风的功能 现在又格力 美的 两个厂商正产空调 请用所学 模拟此场景

"""

python 复制代码

# 创建抽象类 表示标准\
class AC:
    def cool_wind(self):
        pass
    def hot_wind(self):
        pass
    def swing_l_r(self):
        pass
class Gree(AC):
    def cool_wind(self):
        print('格力空调 制造冷风')
    def hot_wind(self):
        print('格力空调,制造热风')

    def swing_l_r(self):
        print('格力空调 左右摇摆')

class Media(AC):

    def cool_wind(self):
        print('美的空调 制造冷风')

    def hot_wind(self):
        print('美的空调 制造冷风')

    def swing_l_r(self):
        print('美的空调 制造冷风')

if __name__ == '__main__':
    g = Gree()
    m = Media()
    g.cool_wind()
    g.hot_wind()
    g.swing_l_r()

    m.cool_wind()
    m.hot_wind()
    m.swing_l_r()

（1）请写出单继承与多继承的语法格式?

"""

python 复制代码

# 单继承
class 类名(父类名):
    重写方法
# 多继承
class 类名(父类名1,父类名2 ...):
    重写方法
"""
# （2）什么是方法重写，为什么要方法重写?
"""
方法重写是 子类继承父类后 将继承父类的方法逻辑重新编写
重写后的方法子啊父类的功能主题上 具有子类独有的功能
"""

"""
（4）实操练习：
- 1.创建一个Animal（动物）基类，其中有一个run方法，输出`跑起来....`；
- 2.创建一个Horse（马）类继承于动物类，Horse类中不仅有run()方法还有eat()方法；
- 2.1run方法输出 `跑起来....`
- 2.2 eat 方法输出 `吃东西...`
"""

# #创建父类
# class Animal(object):
#     #父类方法
#     def run(self):
#         print('跑起来...')
#
# #创建子类 继承父类
# class Horse(Animal):
#     #子类方法
#     def eat(self):
#         print('吃东西...')
#
#
# if __name__ == '__main__':
#     h1 = Horse()
#     h1.run()
#     h1.eat()


"""
（5）加强练习：
- 1.创建一个动物(Animal)的基类,其中有一个run方法, 输出`跑起来....`
- 2。创建一个Horse（马）类继承于动物类，Horse类中重写run方法，增加打印输出"`迈着矫健的步伐跑起来!!`"，同时实现eat方法, 输出 `吃东西...`
"""

# #创建父类
# class Animal(object):
#     #父类方法
#     def run(self):
#         print('跑起来...')
#
# #创建子类 继承父类
# class Horse(Animal):
#    #重写run方法
#     def run(self):
#         print('`迈着矫健的步伐跑起来!!`')
#    #子类方法
#     def eat(self):
#         print('吃东西...')
#
#
# if __name__ == '__main__':
#     h1 = Horse()
#     h1.run()
#     h1.eat()


"""
（6）综合训练：

- 1.创建一个动物(Animal)的基类，其中有一个run方法, 输出`跑起来....`
- 2.创建一个Horse（马）类继承于动物类，Horse类中不仅有run方法还有eat方法
  - 2.1 run方法输出 `跑起来....`
  - 2.2 eat 方法输出 `吃东西...`
- 3.创建一个 SwiftHorse（千里马）类继承Horse类，初始化init方法name属性为千里马，同时针对吃东西，SwiftHorse类中重写eat方法，增加打印输出"`一天可以吃一担粮食...`"
"""


```python
# 创建父类
class Animal(object):
     # 父类方法
     def run(self):
         print('跑起来...')


 # 创建子类 继承父类
 class Horse(Animal):
     # 重写run方法
     def run(self):
         print('`迈着矫健的步伐跑起来!!`')

     # 子类方法
     def eat(self):
         print('吃东西...')


 class SwiftHorse(Horse):
     # init初始化
     def __init__(self):
         self.name = '千里马'

     # 重写eat方法
     def eat(self):
         print(f'{self.name}`一天可以吃一担粮食...`')


 if __name__ == '__main__':
     h1 = Horse()
     h1.run()
     h1.eat()

     h2 = SwiftHorse()
     print(h2.name)
     h2.eat()

"""

（7）综合训练：

定义一个Person 类,包含初始化 init 方法:

实例属性: 名字, name

年龄, age

"""

python 复制代码

 创建类
class Person():
    # 初始化计数器 count
    count = 0

    # init初始化参数
    def __init__(self, name, age):
        self.name = name
        self.age = age
        Person.count += 1

    def __str__(self):
        return f'此人的姓名为: {self.name} 年龄为: {self.age}'


    def __del__(self):
        Person.count -= 1

记录由该类创建的对象的个数，创建一个对象，计数+1，删除一个对象，计数-1；
count变量记录对象数
定义一个方法，可以打印当前对象的个数；

python 复制代码

	def print_count():
	    print(f'当前对象数: {Person.count}')

定义一个方法show_info, 输出以下信息

python 复制代码

#        这是一个 Person 类,谢谢查看!
    def show_info():
        print(f'这是一个 Person 类,谢谢查看!')

     # 需要传对象
    # def show_info(self):
    #     print(f'这是一个 {self.__class__.__name__} 类,谢谢查看!')

打印对象的时候，可以输出打印自己的名字和年龄

我的名字是 xxx, 年龄是 xxx

用 str 魔法方法
定义一个方法 study, 输出以下信息

python 复制代码

# 我叫 xxx, 我要好好学习
    def study(self):
        print(f'我叫 {self.name} ,我要好好学习')

操作步骤
调用show_info 方法；
创建两个对象, 打印当前对象，并打印当前的对象个数；
分别使用两个对象调用study方法；
删除一个对象，打印输出当前的对象个数。

python 复制代码

if __name__ == '__main__':

    Person.show_info()
    p1 = Person('菲菲', 17)
    p2 = Person('波比', 18)

    print(p1)
    print(p2)
    Person.print_count()
    p1.study()
    p2.study()
    # p.show_info()
    # p.print_count()
    p2.__del__()
    Person.print_count()

"""

构建对象对战平台object_play

1 英雄一代战机（战斗力60）与敌军战机（战斗力70）对抗。英雄1代战机失败！

2 卧薪尝胆，英雄二代战机（战斗力80）出场！，战胜敌军战机！

3 对象对战平台object_play, 代码不发生变化的情况下, 完成多次战斗

"""

python 复制代码

class HeroFly():
     def fight(self):
         return 60

 class HeroFlyPlus(HeroFly):
     def fight(self):
         return 80

 class JapanFly():
     def fight(self):
         return 70

 def object_play(hero : HeroFly, japan : JapanFly):
     if hero.fight() >= japan.fight():
         print('凯旋')
     else:
         print('铩羽')

 if __name__ == '__main__':
     h1 = HeroFly()
     h2 = HeroFlyPlus()
     j1 = JapanFly()
     object_play(h1, j1)
     object_play(h2, j1)

"""

国家部门制定了打印机标准

1、请抽象父类，制定标准：抽象printer，要求支持黑白打印(Black_white_printing)、彩色打印(color_printing)。

2、完成打印机hp、小米、佳能（canon）硬件入围；入围测试平台 make_test_printing(myobj:抽象类))

3、完成多态场景测试

"""

python 复制代码

class Printer():
    def black_white_printing(self):
        pass
    def color_printing(self):
        pass

class HuiPu(Printer):

    def black_white_printing(self):
        print('hp黑白打印')

    def color_printing(self):
        print('hp彩色打印')

class XiaoMi(Printer):

    def black_white_printing(self):
        print('XiaoMi黑白打印')

    def color_printing(self):
        print('XiaoMi彩色打印')

class JiaNeng(Printer):

    def black_white_printing(self):
        print('JiaNeng黑白打印')

    def color_printing(self):
        print('JiaNeng彩色打印')


class Myobj():
    def make_test_printing(pre:Printer):
        pass

class MyobjSon(Myobj):
    def make_test_printing(pre:Printer):
        pre.black_white_printing()
        pre.color_printing()


if __name__ == '__main__':
    h1 = HuiPu()
    x1 = XiaoMi()
    j1 = JiaNeng()
    MyobjSon.make_test_printing(h1)
    MyobjSon.make_test_printing(x1)
    MyobjSon.make_test_printing(j1)

坚持分享 共同进步 如有错误 欢迎指出