python 3 封装

python 3 封装

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

先看如何隐藏

在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__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形。

这种自动变形的特点：

1. 类种定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2. 这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3. 在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下划线开头的属性在继承给子类时，子类是无法覆盖的。

• 对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了

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

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

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

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

python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的，原则上是供内部调用的。作为外部也可以用，只过写出代码比较傻了，python要想与其他编程语言一样，严格控制属性的访问权限，只能借助内置方法如__getattr__

#先看如何隐藏
 
class Foo:
 
    __N=111111 #_Foo__N
 
    def __init__(self,name):
 
        self.__Name=name #self._Foo__Name=name
 
    def __f1(self): #_Foo__f1
 
        print('f1')
 
    def f2(self):
 
        self.__f1() #self._Foo__f1()
 
f=Foo('egon')
 
# print(f.__N)
 
# f.__f1()
 
# f.__Name
 
f.f2() #通f
 
#这种隐藏需要注意的问题：
 
#1：这种隐藏只是一种语法上变形操作，并不会将属性真正隐藏起来
 
print(Foo.__dict__)
 
print(f.__dict__)
 
print(f._Foo__Name)
 
print(f._Foo__N)
 
#2:这种语法级别的变形，是在类定义阶段发生的，并且只在类定义阶段发生
 
Foo.__x=123123123123123123123123123123123123123123
 
print(Foo.__dict__)
 
print(Foo.__x)
 
f.__x=123123123
 
print(f.__dict__)
 
print(f.__x)
 
#3:在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
 
class Foo:
 
    def __f1(self): #_Foo__f1
 
        print('Foo.f1')
 
    def f2(self):
 
        self.__f1() #self._Foo_f1
 
class Bar(Foo):
 
    def __f1(self): #_Bar__f1
 
        print('Bar.f1')
 
b=Bar()
 
b.f2()
 
#封装不是单纯意义的隐藏
 
#1：封装数据属性：将属性隐藏起来，然后对外提供访问属性的接口，关键是我们在接口内定制一些控制逻辑从而严格控制使用对数据属性的使用
 
class People:
 
    def __init__(self,name,age):
 
        if not isinstance(name,str):
 
            raise TypeError('%s must be str' %name)
 
        if not isinstance(age,int):
 
            raise TypeError('%s must be int' %age)
 
        self.__Name=name
 
        self.__Age=age
 
    def tell_info(self):
 
        print('<名字：%s 年龄：%s>' %(self.__Name,self.__Age))
 
    def set_info(self,x,y):
 
        if not isinstance(x,str):
 
            raise TypeError('%s must be str' %x)
 
        if not isinstance(y,int):
 
            raise TypeError('%s must be int' %y)
 
        self.__Name=x
 
        self.__Age=y
 
p=People('egon',18)
 
p.tell_info()
 
# p.set_info('Egon','19')
 
p.set_info('Egon',19)
 
p.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()
# _x=123

示例代码