组合+封装+property+多态+鸭子类型(day21)

目录

• 昨日回顾
  • 继承
    • 什么是继承
    • 继承的目的
    • 什么是抽象
    • 继承背景下，对象属性的查找顺序
  • 派生
    • 什么是派生
    • 子类派生出新的属性，重用父类的属性
  • 新式类和经典类
  • 钻石继承的继承顺序
• 今日内容
  • 一、组合
    • 1. 什么是组合
    • 2. 组合的作用
    • 3. 如何使用组合
  • 二、封装
    • 1. 什么是封装
    • 2. 为什么要封装
    • 3. 如何封装
    • 4. 访问限制机制
  • 三、property特性
    • 1. 什么是property
    • 2. 为什么用property
    • 3. 如何使用property
  • 四、多态
    • 1. 什么是多态
    • 2. 多态的目的
    • 3. 如何实现
  • 五、鸭子类型
  • 六、多态之炫技

昨日回顾

继承

什么是继承

新建类的方式，新建的类叫子类/派生类，被继承的类叫做父类/基类/超类

继承是一系列相同的属性的类的结合体

继承的目的

让代码不冗余

什么是抽象

抽取相似部分

继承背景下，对象属性的查找顺序

1. 对象
2. 子类
3. 父类

派生

什么是派生

派生是指子类继承父类的属性，并且派生出自己的属性

若子类的属性和父类的属性相同时，以子类的为准

子类派生出新的属性，重用父类的属性

1. 直接调用父类的init函数，当作普通函数传入对象和继承的属性
2. super（）指向父类名

新式类和经典类

1. 继承object的类以及子类都叫新式类
2. 没有继承object的类以及子类都叫经典类
3. python3中默认继承object，即python3中都是新式类，只有python2中才有经典类

钻石继承的继承顺序

1. 新式类

   广度优先

2. 经典类

   深度优先

今日内容

一、组合

1. 什么是组合

组合指的是一种对象的中属性，是另一个对象

组合是指对象和对象的关系

2. 组合的作用

和继承一样，为了减少代码冗余

3. 如何使用组合

class People:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.course_list = []

    def add_course(self,course):
        self.course_list.append(course)

    def tell_all_course(self):
        for course in self.course_list:
            course.tell_course()

class Teacher(People):
    def __init__(self,name, age,sex):
        super().__init__(name,age,sex)

class Course:
    def __init__(self,course_name,course_period,course_price):
        self.course_name = course_name
        self.course_period = course_period
        self.course_price = course_price

    def tell_course(self):
        print(f'''
        课程名称:{self.course_name}
        课程周期:{self.course_period}
        课程价格:{self.course_price}''')

tea = Teacher('wick',24,'man')

python = Course('python',6,20000)
tea.add_course(python)
tea.tell_all_course()  

# 课程名称:python
# 课程周期:6
# 课程价格:20000

二、封装

1. 什么是封装

封装指的是把一堆属性封装到一个对象中，对象可以通过"."的方式获取属性

2. 为什么要封装

方便存取，通过对象“.”属性的方式获取属性

3. 如何封装

1. 在类内部，定义一堆属性
2. 通过对象的赋值操作封装

4. 访问限制机制

在类内部定义的，凡是以__开头的属性都会被隐藏，外部不能直接访问该属性

访问限制机制的目的

• 把一堆隐私的属性与不能被外部轻易访问的属性，可以隐藏起来，不被外部直接调用

• 好处：对数据获取的逻辑更加严谨，进而保护了数据的安全

• 隐私属性可以通过封装一个接口，在接口内做业务逻辑，再把数据返回给调用者

  class Teacher:
      def __init__(self, name, age, sex):
          self.__name = name
          self.__age = age
          self.__sex = sex
  
      # 接口: 打印用户信息接口
      def get_info(self):
          # 用户认证
          user = input('user: ').strip()
          pwd = input('pwd: ').strip()
          if user == 'tank' and pwd == '123':
              print(f'''
              姓名: {self.__name}
              年龄: {self.__age}
              性别: {self.__sex}
              ''')
  
      # 接口: 修改用户信息接口
      def set_info(self, name, age, sex):
          # str1 = 'string'  # str('string')
          if not isinstance(name, str):
              raise TypeError('名字必须要使用字符串')
  
          if not isinstance(age, int):
              raise TypeError('年龄必须是数字')
  
          if not isinstance(sex, str):
              raise TypeError('性别必须要使用字符串')
  
          self.__name = name
          self.__age = age
          self.__sex = sex
  
  tea1 = Teacher('tank', 17, 'male')
  tea1.set_info('jason_sb', 101, 'female')
  tea1.get_info()
  
  # demo3: ATM
  class ATM:
      # 1.插卡
      def __insert_card(self):
          print('插卡')
          pass
  
      # 2.输入密码
      def __input_pwd(self):
          print('密码验证')
          pass
  
      # 3.输入取款金额
      def __input_money(self):
          print('输入金额')
          pass
  
      # 4.开始吐钱
      def __get_money(self):
          print('执行吐钱')
          pass
  
      # 5.打印账单
      def __print_flow(self):
          print('打印账单')
          pass
  
      # 取钱直接接口
      def withdraw(self):
          self.__insert_card()
          self.__input_pwd()
          self.__input_money()
          self.__get_money()
          self.__print_flow()
          print('取款程序执行完毕!')
  
  atm = ATM()
  atm.withdraw()
  

注意：python中不会强制限制属性的访问，类内部__开头的属性只是做了一个变形，通过访问变形后的名字就可以访问该属性 __属性名 变形名 __类名__属性

三、property特性

1. 什么是property

python内置装饰器，主要是给类内部的方法使用

2. 为什么用property

使用它的目的，是将类内部的函数变成数据属性，从而在调用的时候不用加括号

3. 如何使用property

装饰器放在被装饰函数上一行

注意：被装饰过的属性不能被修改,如果非要修改可以用装饰器中的setter和deleter进行删改

class People:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    @property
    def bmi(self):
        return self.weight / (self.height * self.height)

    # 了解
    @property
    def get_name(self):
        return self.name

    # 改
    @get_name.setter
    def set_name(self, val):
        self.name = val

    # 删除
    @get_name.deleter
    def del_name(self):
        del self.name

p = People('jason', 200, 1.6)
print(p.bmi)  

# 了解：若真要通过此方法修改属性,可以通过另一种方式修改.
print(p.get_name)
p.set_name = 'tank' # 固定格式
del p.del_name # 固定格式

四、多态

1. 什么是多态

多态是指同一种事物的多种形态

2. 多态的目的

1. 多态也称之为多态性，程序中继承就是多态的表现形式

2. 让多种不同类型的对象，在使用在相同功能的情况下，调用同一个名字的方法名

3. 父类：定义一套统一的标准

4. 子类：定义父类统一的标准

5. 多态最终目的，统一子类编写的规范，为了让使用者更方便去调用相同功能的方法

3. 如何实现

1. 继承

注意：在python不会强制要求子类必须遵循父类的标准，所以出现了抽象类

2. 抽象类（了解）

abc模块（abstract_class）强制子类必须遵循父类的标准

import abc
class Animal(metaclass=abc.ABCMeta):
    # 吃
    @abc.abstractmethod
    def eat(self):
        pass

    # 喝
    @abc.abstractmethod
    def drink(self):
        pass

    # 叫
    @abc.abstractmethod
    def speak(self):
        pass

# 猪
class Pig(Animal):
    # 吃
    def eat(self):
        print('猪在吃饭')
        pass

    # 喝
    def drink(self):
        pass

    def speak(self):
        print('哼哼哼~~~')

    # 派生
    def run(self):
        pass

pig = Pig()

五、鸭子类型

1. 在不知道当前对象是何物是，它如果像鸭子，那就是鸭子类型

2. 在python中，不推荐使用抽象类强制限制子类的的定义，但是推荐类都遵循鸭子类型

继承

​ 耦合性太高，扩展性差

鸭子类型：

​ 耦合度低，程序可扩展性强

六、多态之炫技

比如len函数的实现

#  数据类型中含有__len__的属性，定义了LEN的函数返回出每个对象的__len__,从而达到多态性
str1 = '1234'
list1 = [1, 2, 3]

def LEN(d):
    return d.__len__()

print(LEN(str1))
print(LEN(list1))