day21总结 | 易学教程

1.组合

1. 什么是组合

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

2.为什么要使用组合

减少代码的冗余

3.如何使用组合

继承:     类与类的关系,一种什么是什么的关系,子类与父类是从属关系.  
组合:    对象与对象的关系,一种什么有什么的关系,一个对象拥有另一个对象.

# 组合实现:
 选课系统: 老师类,学生类,老师与学生都有名字,年龄,性别
class People:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

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

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


# 日期类
class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tell_birth(self):
        print(f'''
        === 出生年月日 ===
        年: {self.year}
        月: {self.month}
        日: {self.day}
        ''')


tea1 = Teacher('tank', 17, 'male')
date_obj = Date(2002, 1, 1)
# date_obj.tell_birth()
# 将date对象赋值到tea1对象的date属性中
tea1.date = date_obj
tea1.date.tell_birth()

2.封装

1.什么是封装？

比喻：
    封：比如把一个袋子封装起来
    装：把一个对东西装到袋子里
封装指的是把一堆属性（特征与技能）封装到一个对象中
存数据的目的是为了取，对象可以使用'.'的方式获取属性。
 
比喻：对象就好比一个袋子，袋子里面装一堆属性。

2.为什么要封装？

封装的属性为了方便存取值，可以通个对象，属性的方式获取属性。

3.如何封装？

特征：变量----》数据属性

技能：函数-----》方法属性

在类的内部，定义一堆属性（特征与技能）

通过对象属性 --- 属性值

3.访问限制机制

1.生么是访问限制机制？

在类内部定义，凡是以__开头的数据属性与方法属性。

都会被python内部隐藏起来，让外部不能直接访问类内部的__开头的属性。比如：

__ name = 'tank'

2.访问限制机制的目的？

一堆隐私的属性与不能被外部轻易访问的属性, 可以隐藏起来,不被外部直接调用.
好处:
对重要数据获取的逻辑更加严谨, 进而保证了数据的安全.

接口: 隐私属性可以通过封装一个接口,在接口内做业务逻辑的处理,再把数据返回给调用者.

注意: 在python中,不会强制限制属性的访问,类内部__开头的属性,只是做了一种变形.
若想直接访问, 调用变形后的名字即可.
class Foo:
    __name = 'tank'  # ---> _类名__属性名
    
    
列：
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()

4.property:

1.什么是property
python内置的装饰器, 主要是给类内部的方法使用.

2.为什么要用property
    使用它的目的,是将类内部的方法 (def 方法名()) 变成了 (def 方法).
    在对象调用某个方法时,将对象.方法()变成对象.方法(看起来想一个普通的数据属性)

3.如何使用property
    @property

5.多态:

1.什么是多态?
多态指的是同一种事物的多种形态.

2.多态的目的:
    多态也称之为多态性, 在程序中继承就是多态的表现形式.
    多态的目的是为了, 让多种不同类型的对象, 在使用相同功能的情况下,调用同一个名字的方法名.
    父类: 定义一套统一的标准.
    子类: 遵循父类统一的标准.
    多态的最终目的: 统一子类编写的规范, 为了让使用者更方便调用相同功能的方法.

3.如何实现:
    - 继承

注意: 在python中,不会强制要求子类必须遵循父类的一套标准,所以出现了抽象类.
class Animal:
    # 吃
    def eat(self):
        pass

    # 喝
    def drink(self):
        pass

    # 叫
    def speak(self):
        pass


# 猪
class Pig(Animal):

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

    # 喝
    def drink(self):
        pass

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


# 猫
class Cat:
    # 吃
    def eat(self):
        print('猫在吃饭')
        pass

    # 喝
    def drink(self):
        pass

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


# 狗
class Dog:
    # 吃
    def eat(self):
        print('狗在吃饭')
        pass

    # 喝
    def drink(self):
        pass

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


# 正确教材
pig = Pig()
cat = Cat()
dog = Dog()

pig.speak()
cat.speak()
dog.speak()

6.抽象类(了解):

1.是什么?
abc模块 abstract_class

2.使用的目的?
    强制子类必须遵循父类的一套标准.

3.如何使用
    import abc

列：
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()

7.鸭子类型:

1.什么是鸭子类型?
在不知道当前对象是何物的情况下,但是你长得像鸭子,那么你就是鸭子类型.

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

- 继承:
    耦合性太高,程序的可扩展性差

- 鸭子类型:
    耦合度低,程序的可扩展性强
    
列：
# 猪
class Pig:
    # 吃
    def eat(self):
        print('猪在吃饭')
        pass
    # 喝
    def drink(self):
        pass
    def speak(self):
        print('哼哼哼~~~')


# 猫
class Cat:
    # 吃
    def eat(self):
        print('猫在吃饭')
        pass
    # 喝
    def drink(self):
        pass
    def speak(self):
        print('喵喵喵~~')

# 狗
class Dog:
    # 吃
    def eat(self):
        print('狗在吃饭')
        pass
    # 喝
    def drink(self):
        pass
    def speak(self):
        print('汪汪汪~~~')

8.多态旋技操作

代码演示

# # 猫
# class Cat:
#     # 吃
#     def eat(self):
#         print('猫在吃饭')
#         pass
#     # 喝
#     def drink(self):
#         pass
#     def speak(self):
#         print('喵喵喵~~')
#
# # 狗
# class Dog:
#     # 吃
#     def eat(self):
#         print('狗在吃饭')
#         pass
#     # 喝
#     def drink(self):
#         pass
#     def speak(self):
#         print('汪汪汪~~~')
#
# dog = Dog()
# cat = Cat()
# pig = Pig()
#
# def BARK(animal):
#     animal.speak()

# BARK(dog)
# BARK(cat)
# BARK(pig)

汪汪汪~~~
喵喵喵~~
哼哼哼~~~

来源：https://www.cnblogs.com/WQ577098649/p/11656019.html

标签

pass