PYTHON-组合 封装 多态 property装饰器

# 组合
'''
软件重用的重要方式除了继承之外还有另外一种方式，即：组合
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合

1. 什么是组合
    一个对象的属性是来自于另外一个类的对象,称之为组合

2. 为何用组合
    组合也是用来解决类与类代码冗余的问题

3. 如何用组合
# obj1.xxx=obj2
'''
'''
    >>> class Equip: #武器装备类
    ...     def fire(self):
    ...         print('release Fire skill')
    ...
    >>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
    ...     camp='Noxus'
    ...     def __init__(self,nickname):
    ...         self.nickname=nickname
    ...         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
    ...
    >>> r1=Riven('锐雯雯')
    >>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
    release Fire skill

# class Foo:
#     aaa=1111
#     def __init__(self,x,y):
#         self.x=x
#         self.y=y
#     def func1(self):
#         print('foo中的功能')
#
# class Bar:
#     bbb=2222
#     def __init__(self, m, n):
#         self.m = m
#         self.n = n
#     def func2(self):
#         print('bar中的功能')
#
# obj1=Foo(10,20)
# obj2=Bar(30,40)
#
# obj1.xxx=obj2  #组合
# print(obj1.x,obj1.y,obj1.aaa,obj1.func1)
# print(obj1.xxx.m,obj1.xxx.n,obj1.xxx.bbb,obj1.xxx.func2)


# class OldboyPeople:
#     school = 'Oldboy'
#     def __init__(self, name, age, gender):
#         self.name = name
#         self.age = age
#         self.gender = gender
#
# class OldboyStudent(OldboyPeople):
#     def choose_course(self):
#         print('%s is choosing course' %self.name)
#
# class OldboyTeacher(OldboyPeople):
#     def __init__(self, name, age, gender,level,salary):
#         super(OldboyTeacher, self).__init__(name, age, gender)
#         # OldboyPeople.__init__(self, name, age, gender)
#         self.level=level
#         self.salary=salary
#     def score(self,stu,num):
#         stu.num=num
#         print('老师%s给学生%s打分%s' %(self.name,stu.name,num))
#
# class Course:
#     def __init__(self,course_name,course_price,course_period):
#         self.course_name=course_name
#         self.course_price=course_price
#         self.course_period=course_period
#     def tell_course(self):
#         print('课程名:<%s> 价钱:[%s] 周期:[%s]' % (self.course_name, self.course_price, self.course_period))
#
# python_obj=Course('python开发',3000,'5mons')
# linux_obj=Course('linux运维',5000,'3mons')
#
#
# stu1=OldboyStudent('egon练习',18,'male')
# stu1.choose_course()
#
# stu1.courses=[]
# stu1.courses.append(python_obj)
# stu1.courses.append(linux_obj)
# stu1.courses[0].tell_course()
#
#
# tea2=OldboyTeacher('kevin',38,'male',5,3000)
# tea2.score(stu1,60)
'''

# 封装
#  引子
# 从封装本身的意思去理解，封装就好像是拿来一个麻袋，
# 把小猫，小狗，小王八，还有alex一起装进麻袋，然后把麻袋封上口子。
# 照这种逻辑看，封装=‘隐藏’，这种理解是相当片面的

'''
1. 什么是封装
    装指的是把属性装进一个容器
    封指的是将容器内的属性隐藏起来
    封装本质上就是影藏一部分内容  使外界无法直接访问  只能通过提供的接口来访问
        对于开发者 作用对数据的访问加以限制 提高安全性
        对于使用者而言   简化了操作

2. 为何要封装（*****）
    封装不是单纯意义的隐藏
    封装数据属性的目的:让外部使用者间接地操作数据，在接口上附加额外的逻辑,从而严格
        控制使用者对属性的操作
    封装函数(功能)属性的目的:隔离复杂度(很多功能是给内部用,给外部封装起来隔离复杂度)

3. 如何封装（*****）
    只需要在属性前加上__(两个下划线),该属性就会被隐藏起来,该隐藏具备的特点:
        1. 只是一种语法意义上的变形,即__开头的属性会在检测语法时发生变形 _类名__属性名
        2. 这种隐藏式对外不对内的(因为在类内部检测语法时所有的代码统一都发生的变形)
        3. 这种变形只在检测语法时发生一次,在类定义之后新增的__开头的属性并不会发生变形
        4. 如果父类不想让子类覆盖自己的属性,可以在属性前加__开头

        本质是 语法级别上变形(在语法检测期间)  _类名__属性名
            这么一来 我么完全可以绕过语法限制
'''
'''
# class Foo:
#     __x=111 #_Foo__x
#     def __init__(self,m,n):
#         self.__m=m # self._Foo__m=m
#         self.n=n
#
#     def __func(self): #_Foo__func
#         print('Foo.func')
#
#     def func1(self):
#         print(self.__m) #self._Foo__m
#         print(self.__x) #self._Foo__x

# print(Foo.__dict__)
# Foo.__x
# Foo.__func
# print(Foo._Foo__x)
# print(Foo._Foo__func)


obj=Foo(10,20)
# print(obj.__dict__)
# print(obj.n)
# print(obj.__m)
# print(obj._Foo__m)

# obj.func1()
# obj._Foo__func()

# obj.__yyy=3333   #特点三,
# print(obj.__dict__)
# print(obj.__yyy)

# Foo.__zzz=444
# Foo.zzz=333
# print(Foo.__dict__)
# print(Foo.__zzz)



# class Foo:
#     def __f1(self): #_Foo__f1
#         print('Foo.f1')
#
#     def f2(self):
#         print('Foo.f2')
#         self.__f1() #self._Foo__f1
#
# class Bar(Foo):
#     def __f1(self): #_Bar__f1
#         print('Bar.f1')
#
# obj=Bar()
# obj.f2()


# 封装数据属性的真实意图
# class People:
#     def __init__(self,name,age):
#         self.__name=name
#         self.__age=age
#     def tell_info(self):
#         print('<name:%s age:%s>' %(self.__name,self.__age))
#     def set_info(self,new_name,new_age):
#         if type(new_name) is not str:
#             print('name error')
#             return
#         self.__name=new_name
#         if type(new_age) is not int:
#             print('age error')
#             return
#         self.__age=new_age
#     def clear_info(self):
#         del self.__name
#         del self.__age
#
# obj1=People('aaa',10)
# obj1.tell_info()
# obj1.set_info('aaa',111)
# print(obj1.__dict__)
# obj1.clear_info()
# print(obj1.__dict__)


# 封装函数属性的真实意图
# class ATM:
#     def __card(self):
#         print('插卡')
#     def __auth(self):
#         print('用户认证')
#     def __input(self):
#         print('输入取款金额')
#     def __print_bill(self):
#         print('打印账单')
#     def __take_money(self):
#         print('取款')
#
#     def withdraw(self):
#         self.__card()
#         self.__auth()
#         self.__input()
#         self.__print_bill()
#         self.__take_money()
#
# a=ATM()
# a.withdraw()
'''

# 特性(property)
# 什么是特性property
# property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

# 为什么要用property
# 将一个类的函数定义成特性以后，对象再去使用的时候obj.name,
# 根本无法察觉自己的name是执行了一个函数然后计算出来的，
# 这种特性的使用方式遵循了统一访问的原则

# property装饰器:将类中定义的函数(功能)伪装成属性
# @property  #查看属性的功能
# @xxx.setter  #修改属性的功能
# @xxx.deleter #删除属性的功能
# name=property(xxx_name,yyy_name,zzz_name)  #古老的做法非装饰下使用这种,(按照括号里的参数名顺序)
'''
例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86

# class People:
#     def __init__(self,name,weight,height):
#         self.name=name
#         self.weight=weight
#         self.height=height
#     @property
#     def bmi(self):
#         print(self.weight/(self.height**2))
#
# obj1=People('aaa',65,1.78)
# obj1.bmi
# obj1.height=1.70
# # obj1.bmi()
# obj1.bmi


# 需要了解的property的用法 setter,deleter
# class People:
#     def __init__(self,name):
#         self.__name=name
#     @property
#     def name(self):
#         return '<name:%s>' %self.__name
#     @name.setter
#     def name(self,new_name):
#         if type(new_name) is not str:
#             print('name error')
#             return
#         self.__name=new_name
#     @name.deleter
#     def name(self):
#         del self.__name
#
# obj=People('egon练习')
# print(obj.name)
#
# obj.name=123
# print(obj.name)
#
# del obj.name
# print(obj.__dict__)

# 常规工作常使用套路
# class People:
#     def __init__(self,name):
#         self.__name=name
#     def xxx_name(self):
#         return '<name:%s>' %self.__name
#
#     def yyy_name(self,new_name):
#         if type(new_name) is not str:
#             print('名字必须是str类型')
#             return
#         self.__name=new_name
#     def zzz_name(self):
#         del self.__name
#
#     name=property(xxx_name,yyy_name,zzz_name)
#
# obj=People('egon练习')
# print(obj.name)
#
# obj.name=123
# print(obj.name)
#
# del obj.name
# print(obj.__dict__)
'''

# 多态
'''
1. 什么是多态
    同一种事物的多种形态
    在程序中用继承可以表现出多态

    指的是可以在不考虑对象具体类型的前提下直接使用对象
    (比如动物有多种形态：人，狗，猪)
2. 为何要用多态
    多态性:可以在不用考虑对象具体类型(类)的前提下而直接使用对象下的方法
    多态的精髓:统一标准

3. 如何用多态

多态性
一 什么是多态动态绑定（在继承的背景下使用时，有时也称为多态性）
多态性是指在不考虑实例类型的情况下使用实例

在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息
    （！！！obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），
    不同的对象在接收时会产生不同的行为（即方法）。也就是说，
    每个对象可以用自己的方式去响应共同的消息。
    所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，
    学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同


多态性分为静态多态性和动态多态性
　　静态多态性：如任何类型都可以用运算符+进行运算
　　动态多态性：如下

    peo=People()
    dog=Dog()
    pig=Pig()

    #peo、dog、pig都是动物,只要是动物肯定有talk方法
    #于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
    peo.talk()
    dog.talk()
    pig.talk()

    #更进一步,我们可以定义一个统一的接口来使用
    def func(obj):
        obj.talk()

二 为什么要用多态性（多态性的好处）
    其实大家从上面多态性的例子可以看出，我们并没有增加什么新的知识，
    也就是说python本身就是支持多态性的，这么做的好处是什么呢？

    1.增加了程序的灵活性
    　　以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
    2.增加了程序额可扩展性
    　　通过继承animal类创建了一个新的类，使用者无需更改自己的代码，
        还是用func(animal)去调用 　　　　


    >>> class Cat(Animal): #属于动物的另外一种形态：猫
    ...     def talk(self):
    ...         print('say miao')
    ...
    >>> def func(animal): #对于使用者来说，自己的代码根本无需改动
    ...     animal.talk()
    ...
    >>> cat1=Cat() #实例出一只猫
    >>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
    say miao

    这样我们新增了一个形态Cat，由Cat类产生的实例cat1，
    使用者可以在完全不需要修改自己代码的情况下。
    使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)

'''


# 强制子类遵循父类的方法:(python并不推崇)
# class xxx(metaclass=abc.ABCMeta):
# @abc.abstractmethod
'''
鸭子类型

逗比时刻：

　　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’
        python程序员通常根据这种行为来编写程序。
        例如，如果想编写现有对象的自定义版本，可以继承该对象
        也可以创建一个外观和行为像，但与它无任何关系的全新对象，
        后者通常用于保存程序组件的松耦合度。

例1：利用标准库中定义的各种‘与文件类似’的对象，
    尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法

    # 二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
    class TxtFile:
        def read(self):
            pass
        def write(self):
            pass

    class DiskFile:
        def read(self):
            pass
        def write(self):
            pass

例2：其实大家一直在享受着多态性带来的好处，
    比如Python的序列类型有多种形态：字符串，列表，元组，多态性体现如下
    # str,list,tuple都是序列类型
    s = str('hello')
    l = list([1, 2, 3])
    t = tuple((4, 5, 6))

    # 我们可以在不考虑三者类型的前提下使用s,l,t
    s.__len__()
    l.__len__()
    t.__len__()

    len(s)
    len(l)
    len(t)
'''