封装和@property

封装和@property

一、复习

1、接口类和抽象类

　　python中没有接口类，有抽象类，abc模块中的metaclass=abcmeta,@abstructmethod，本质是做代码规范用的，希望在子类中实现和父类方法名完全一样的方法

　　在java的角度上是有区别的：

　　　　java本来支持单继承，所以就有了抽象类

　　　　java没有多继承，所以为了接口隔离原则，设计了接口这个概念，支持多继承了

　　python既支持单继承也支持多继承，所以对于接口类和抽象类的区别就不那么明显了

甚至在python中没有内置接口类

 

2、多态和鸭子类型

　　多态----python天生支持多态

　　鸭子类型----不依赖父类的情况下实现两个相似的类中的同名方法

 

3、封装----私有的

　　在python中只要__名字，就把这个名字私有化了，私有化了之后，就不能从类的外部直接调用了

　　静态属性，方法，对象属性都可以私有化；这种私有化只是代码级别做了变形，并没有真的约束

　　变形机制：_类名__名字，在类用这个调用，在类的内部直接__名字调用

 

二、封装和@property

1、其他语言，比如c语言里面的属性的编写习惯统

习惯将类里面的属性设置成私有属性，为了防止外部随便调用和修改，在内部的私有属性都会有一个get和set的方法，这也是这类语言编程习惯，一般c语言的私有属性的使用方法如下代码：

class room:
    def __init__(self,name,length,width):
        self.__name = name  # 私有属性
        self.__length = length  # 私有属性
        self.__width = width  # 私有属性

    def get_name(self):  # get方法返回获取名字
        return self.__name

    def set_name(self,newname):  # set方法判断是否需要改名
        if type(newname) is str and newname.isdigit()== false:
            self.__name = newname
        else:
            print('不合法的姓名')

    def area(self):
        return self.__length * self.__width

w = room('wm',3,4)  # 实例化
print(w.area())
w.set_name('6')  # 传入新的名字
print(w.get_name())  # 打印最后的名字

运行结果：

12
不合法的姓名
wm

 

2、父类的私有属性能被子类调用吗？

假设可以被调用，如下代码：

class foo:
    __key = '123'
class son(foo):
    print(foo.__key)

运行结果：

traceback (most recent call last):
  file "<encoding error>", line 26, in <module>
  file "<encoding error>", line 27, in son
attributeerror: type object 'foo' has no attribute '_son__key'

从结果中可以看出假设是不成立的，为什么会这样呢，要想到私有化的那个变形机制，在父类中当key私有化之后，它本质上是以_foo__key存储下来的，而当子类继承父类之后，实质上是以_son__key存储的，所以当直接继承打印foo.__key才会报错，并且不存

 

3、会用到私有的这个概念的场景

（1）隐藏起一个属性。不想要类的外部调用

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

（3）我想保护这个属性不被子类继承

 

4、property----内置装饰器函数 只在面向对象中使用，使用类下的公有函数方法修改删除类里面的私有属性

from math import pi
class circle:
    def __init__(self,r):
        self.r = r
    @property
    def perimeter(self):  # @property后面的self都不能传参数
        return 2*pi*self.r
    @property
    def area(self):  # @property后面的self都不能传参数
        return self.r**2*pi
c1 = circle(5)
print(c1.area)  # 圆的面积 area后面没有括号了，直接拿对象.方法来获取
print(c1.perimeter)  # 圆的周长

运行结果：

78.53981633974483
31.41592653589793

 @property是将函数或者方法伪装成属性，可以直接在外部 类名.函数名/方法发 进行调用，不用在函数或方法名后面加上括号，并且在加上之后，不能再通过 类名.函数名/方法名=‘xxx’ 赋值的方法进行修改了，所以一般用到@property的装饰器都是一些固定的，不经常变动的方法函数

 

5、利用@property和@xxx.setter修改私有属性　　

可以通过下面的例子知道如何在加上@property装饰器后，还能对通过类名.函数方法=‘xxx’的方法进行修改相关的私有属性

class person:
    def __init__(self,name):
        self.__name = name
    @property  # 将name函数伪装成属性，后面直接调用函数名字不用加上括号，并且限制了类名.函数方法='xxx'的改变
    def name(self):
        return self.__name + '是sb'
    @name.setter  # 改变机制，可以解除前面 类名.函数方法='xxx'的改变的限制
    def name(self,new_name):
        self.__name = new_name
cc = person('ww')
print(cc.name)
cc.name = 'dd'  # 加上@name.setter以及后面的操作后，这里就可以改变名字属性了
print(cc.name)

运行结果：

ww是sb
dd是sb

要特别注意的是：@property里面的函数名字name和 @name.setter里面的name以及里面的函数方法名字这三个是同一个名字，
只要是其中一个不一样，都不能进行修改
再来一个购物打折的例子：

class goods:
    discount = 0.8  # 折扣数，当不想要这个折扣的时候，就可以在这里直接改变就可以了，其他都不需要要
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property  # 将price伪装成为属性，并且不用传参数
    def price(self):
        return self.__price * goods.discount  # 苹果的价格等于实际价格剩余打折数
apple = goods('苹果',5)
print(apple.price)  

# 直接就可以调用函数price，但是也可以说是私有属性price，加上@property后可以等同，但是本质还是name函数

运行结果：

4.0

 

6、利用@property和xxx.deleter删除私有属性

没有执行del self.__name

class person:
    def __init__(self,name):
        self.__name = name
    @property  # 将函数伪装成属性，实例化后可以直接调用私有属性，本质上还是函数
    def name(self):
        return self.__name
    @name.deleter  # 启动删除机制，没有实际执行删除操作，而是通过@name里面的函数方法执行相应的删除操作
    def name(self):
        print('执行了这个方法')
        # del self.__name  # 实际的删除操作
brother2 = person('二哥')
print(brother2.name)
del brother2.name  # 一出现del就要回到@xxx.deleter的地方并且在其下面函数方法中执行对应的删除操作
print(brother2.name)

运行结果：

二哥
执行了这个方法
二哥

执行del self.__name

class person:
    def __init__(self,name):
        self.__name = name
    @property  # 将函数伪装成属性，实例化后可以直接调用私有属性，本质上还是函数
    def name(self):
        return self.__name
    @name.deleter  # 启动删除机制，没有实际执行删除操作，而是通过@name里面的函数方法执行相应的删除操作
    def name(self):  # 不能传参数
        print('执行了这个方法')
        del self.__name  # 实际的删除操作
brother2 = person('二哥')
print(brother2.name)
del brother2.name  # 一出现del触发删除机制，就要回到@xxx.deleter的地方并且在其下面函数方法中执行对应的删除操作
print(brother2.name)
print(brother2.name)

运行结果：

二哥
traceback (most recent call last):
执行了这个方法
  file "<encoding error>", line 89, in <module>
  file "<encoding error>", line 81, in name
attributeerror: 'person' object has no attribute '_person__name'

从上面这两个程序以及运行结果可以验证：

（1）当 del brother2.name  的时候就会马上触发删除机制 @name.deleter，而触发删除机制后，只有做出对应的删除操作 del self.__name ，最后才会删除成功

（2）在存在@property的前提下，（1）中的三个name和@name deleter下面的函数名name所在的地方的名字以及@property下面的函数方法名字必须是相同的，否则就不能做到删除私有属性的操作