Day26 of learning python--多态和封装

1.多态

多态指的是一类事物有多种形态，比如动物的形态有人、狗、猪，还比如文件有多种形态：文本文件，可执行文件

import abc
class File(metaclass=abc.ABCMeta):  # 同一类事物：文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File):  # 文件的形态之一：文本文件
    def click(self):
        print('open file')

class ExeFile(File):  #文件的形态之二：可执行文件
    def click(self):
        print('execute file')

多态性：是指在不考虑实例类型的情况下使用实例，可以理解为：向不同的对象发送同一条消息（obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即是调用同一名称的方法，但是里面实现的方法是不一样的），执行的效果则不一样了。

多态性：

text = Text()
exefile = ExeFile()

#text和exefile都是文件，所有肯定又click的方法
text.click()
exefile.click()

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

 鸭子类型：Python崇尚鸭子类型，就是看起啦像是鸭子，都把它当作鸭子来处理和使用。python程序员通常根据这种行为来编写程序，例如：如果想编写现有对象的自定义版本，可以继承对象，也可以创建一个外观和行为像，但是与它没有任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

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

例2：序列类型有多种形态：字符串，列表，元祖，但他们没有直接的继承关系

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

    def write(self):
        pass

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

2.封装

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：1.将变化隔离；2.便于使用；3.提高复用性；4.提高安全性

封装的原则：1.将不需要对外提供的内容都隐藏起来；2.把属性都隐藏，提供公共方法对其访问；

私有变量和私有方法；通过在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

私有变量

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

class A:
    __N= 0 # 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 # 变形为self._A__X
    def __foo(self): # 变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() # 只有在类内部才可以通过__foo的形式访问到.

print(A._A__N)
print(A.bar())  # missing 1 required positional argument: 'self'
# A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

这种自动变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果，在类内部使用，会自动变行的。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变成了：_子类名__x，而父类中变形成了：_父类名__x，即双下划线开头的属性在继承给子类时，子类是无法覆盖的

注意问题：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，直到了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

2.变行的过程中只在类的内部生效，在定义后的赋值操作，不会变行

a = A()
print(a.__dict__)
a.__Y = 1
print(a.__dict__)
结果：
{'_A__X': 10}
{'_A__X': 10, '__Y': 1}

私有方法

1.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

class A:
    def func(self):
        print('from A')

    def test(self):
        self.func()

class B(A):
    def func(self):
        print('from B')

b = B()
b.test()
结果：from B

class A:
    def __func(self):    # 在定义时就变形为_A__fa
        print('from A')

    def test(self):
        self.__func()   # 只会与自己所在的类为准，即调用_A__fa

class B(A):
    def __func(self):
        print('from B')

b = B()
b.test()
结果：from A

用到私有这个概念的场景：

1.隐藏起一个属性，不想让类的外部调用

2.我想保护这个属性，不想让属性随意被改变

3.我想保护这个属性，不想让子类继承

# 父类的私有属性，不能被子类调用
class Foo:
    __key = '123'   # _Foo__key

class Son(Foo):
    print(Foo.__key)   # _Son__key

例子：

class Room:
    def __init__(self,name,length,width):
        self. __name = name
        self.__length = length
        self.__width = width
    def get_name(self):
        return self.__name
    def set_name(self,newName):
        if type(newName) is str and newName.isdigit() == False:
             self.__name = newName
    def area(self):
        return self.__length * self.__width

jin = Room('金老板',2,1)
jin.set_name('2')
print(jin.get_name())
print(jin.area())

封装与扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用者只直到一个接口（函数），只要接口（函数）名，参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础--或者说，只要接口这个基础约定不变，则代码改变不足为滤

#类的设计者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area


#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
        return self.__width * self.__length * self.__high


#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()

3.三个重要属性

property属性

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

例一：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):
        return self.weight / (self.height**2)

p1=People('egon',75,1.85)
print(p1.bmi)  #调用的时候，对使用者来说，把它当作属性来调用

import math
class Circle:
    def __init__(self,radius): #圆的半径radius
        self.radius=radius

    @property
    def area(self):
        return math.pi * self.radius**2 #计算面积

    @property
    def perimeter(self):
        return 2*math.pi*self.radius #计算周长

c=Circle(10)
print(c.radius)
print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
print(c.perimeter) #同上
'''
输出结果:
314.1592653589793
62.83185307179586
'''
#注意：此时的特性area和perimeter不能被赋值
c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

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

class Foo:
    def __init__(self,val):
        self.__NAME=val #将所有的数据属性都隐藏起来

    @property
    def name(self):
        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在设定值之前进行类型检查
            raise TypeError('%s must be str' %value)
        self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter
    def name(self):
        raise TypeError('Can not delete')

f=Foo('egon')
print(f.name)  # 相当于调用name()
# f.name=10 #抛出异常'TypeError: 10 must be str'   #相当于调用name.setter
del f.name #抛出异常'TypeError: Can not delete'     #相当于调用name.delter

一个静态属性property本质上就是实现了get,set,delete三种方法

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

复制代码
class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

用法：

class Goods:

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price


obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

classmethod

类直接调用类里面的方法

class Classmethod_Demo():
    role = 'dog'

    @classmethod
    def func(cls):
        print(cls.role)


Classmethod_Demo.func()

staticmethod

方法没有引用类里面的属性和调用其他的函数，可以把它当作一个普通的函数，只是定义在了类里面而已

class Staticmethod_Demo():
    role = 'dog'

    @staticmethod
    def func():
        print("当普通方法用")

Staticmethod_Demo.func()