Python面向对象--封装

一.什么是封装？

就是帮一些数据和方法装起来，不让外界看到，保护好数据和方法。

二.如何封装？

在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的形式访问到.

a=A()
print(a._A__foo())
print(a._A__N)
print(a._A__X)
#A._A__N是可以访问到的，
#这种，在外部是无法通过__x这个名字访问到。

设置私有属性需要注意的问题：

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

如a._A__N，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问。

 

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

class A:
    __B=30  #定义阶段才能被设置私有属性
    def fuuc(self):
        print('from A')
a=A()
A.__N=20  #这个在外部的不是设置私有属性，是普通的属性
print(A.__dict__)



#运行结果

# {'__module__': '__main__', '_A__B': 30,
#  'fuuc': <function A.fuuc at 0x000000000292E9D8>,
#  '__dict__': <attribute '__dict__' of 'A' objects>,
#  '__weakref__': <attribute '__weakref__' of 'A' objects>,
# '__doc__': None, '__N': 20}

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

# 正常情况下：
class A:

    def bar(self):
        print('from A')
        self.func()

    def func(self):
        print('from func1')

class B(A):

    def func(self):
        print('from func2')

b1=B()
b1.bar()


# 运行结果
# from A
# from func2




# 把func设置为私有属性的情况下：
class A:

    def bar(self):
        print('from A')
        self.__func()

    def __func(self):
        print('from func1')

class B(A):

    def __func(self):
        print('from func2')

b1=B()
b1.bar()

# 运行结果
# from A
# from func1

 

三.需要封装什么？

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

class Teacher:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
        self.set_info(name,age)

    def tell_info(self):
        print('姓名:%s,年龄:%s' %(self.__name,self.__age))
    def set_info(self,name,age):
        if not isinstance(name,str):
            raise TypeError('姓名必须是字符串类型')
        if not isinstance(age,int):
            raise TypeError('年龄必须是整型')

        # self.__name=name
        # self.__age=age


t=Teacher(11,18)
t.tell_info()

t.set_info('egon',19)
t.tell_info()

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

#取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
#对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
#隔离了复杂度,同时也提升了安全性

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

3.补充部分

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

其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的，原则上是供内部调用的，作为外部的你，一意孤行也是可以用的，只不过显得稍微傻逼一点点

python要想与其他编程语言一样，严格控制属性的访问权限，只能借助内置方法如__getattr__

 

四.特性（property）

property是Python中的一个内置函数，它的主要功能有以下几个方面：

• 将类方法转换为只读属性（就是当一个类方法转换成一个类属性）
• 重新实现一个属性的setter和getter方法（如果要对这个属性进行修改，必须设置setter的方法）

实例如下：

class Person(object):

    def __init__(self,age):
        self._age = age

    @property
    def age(self):
        return self._age

    @age.setter        #修改属性必须要加上这个方法
    def age(self,age):
        if isinstance(age,str):
            self._age = int(age)
        elif isinstance(age,int):
            self._age = age

    @age.deleter    #删除属性必须加上这个方法
    def age(self):
        del self._age

P1=Person(20)
print(P1.age)
#20

P1.age=30
print(P1.age)
# 30

del P1.age
print(P1.age)
# 已经删除
# AttributeError: 'Person' object has no attribute '_age'


# 上面使用property装饰器模式的时候注意几个小点： 
# 1.三个函数的名字与字段名是一样的。 
# 2.使用proterty可以比较简单实现字段的读写控制。例如想要字段为只读属性，那么只需要提供getter方法，上面的setter方法可以去掉。