python封装与property

Posted on | In

封装

封装可以理解为一个多功能的自助饮料机器，且机器是不透明密封的，只在下方开了不同的龙头，当顾客需要不同的饮料时，只需要去打开不同的龙头开关即可得到自己想要的饮料，但顾客不知道机器内部是产生不同的饮料的。
在python中，封装可以是类，可以是函数。封装是将数据或属性隐藏在内部，不让外部看到。

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形
#类中所有双下划线开头的名称如__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的形式访问到.
 
#A._A__N是可以访问到的，
#这种，在外部是无法通过__x这个名字访问到

这种变形需要注意的问题是：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问。

2.变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形

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

例：

1
2
3
4
5
6
7
8
9
10
11
12
class A:
    def fa(self):
        print('from A')
    def test(self):
        self.fa()
 
class B(A):
    def fa(self):
        print('from B')
 
b=B()
b.test()

输出：form B

1
2
3
4
5
6
7
8
9
10
11
12
13
#把fa定义成私有的，即__fa
class A:
    def __fa(self): #在定义时就变形为_A__fa
        print('from A')
    def test(self):
        self.__fa() #只会与自己所在的类为准,即调用_A__fa
 
class B(A):
    def __fa(self):
        print('from B')
 
b=B()
b.test()

输出：form A

封装的真谛在于明确地区分内外，封装的属性可以直接在内部使用，而不能被外部直接使用，然而定义属性的目的终归是要用，外部要想用类隐藏的属性，需要我们为其开辟接口，让外部能够间接地用到我们隐藏起来的属性，那这么做的意义何在？？？

1：封装数据：将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

2：封装方法：目的是隔离复杂度

3: 了解

python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的

特性(property)

什么是特性property

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

1
2
3
4
5
6
7
8
9
10
11
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)

为什么要用property

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

被property装饰的属性会 优先于对象的属性被使用

而被property装饰的属性，如sex，分成三种：

1.property

2.sex.setter

3.sex.deleter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class People:
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
 
    @property
    def sex(self):
        return self.__sex
 
    @sex.setter
    def sex(self, sex1):        
        if not isinstance(sex1, int):
            raise TypeError('必须是数字')
        self.__sex = sex1
 
    @sex.deleter
    def sex(self):
        del self.__sex
 
 
p = People('ezc', 20)
print(p.sex)
p.sex = 15
print(p.sex)
del p.sex
print(p.sex)

在创建对象时self.sex会先去找有没有property，如果有会先去调用其下面的，所以self.__sex = sex1，实际上真正的值存在了__sex中，可以通过p._dict_查看，查询时也是，会先去寻找被property装饰的属性，修改和删除也同理