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__N是可以访问到的，
#这种，在外部是无法通过__x这个名字访问到。

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

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

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

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

#正常情况
>>> 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()
from B
 

#把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()
from A

二. 封装

2.1 封装静态属性

　　封装静态属性就是把一些属性隐藏起来然后对外提供操作该数据的接口，我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

class Persion:
    def __init__(self,name,age):
        # self.__name=name
        # self.__age=age
        self.info_input(name,age)

    def info_output(self):
        print('姓名：%s;年龄：%s'%(self.__name,self.__age))

    def info_input(self,name,age):
        if not isinstance(name,str):
            raise TypeError('姓名请输入字符串类型')
        if not isinstance(age,int):
            raise TypeError('年龄请输入整形')
        self.__name=name
        self.__age=age

hantao=Persion('hantao',12)
hantao.info_output()

2.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(）

三. property的使用

property的简单的说就是给方法加上一个装饰器，在调用这个方法时不用加上"()",就像是调用一个静态属性一样。这种特性的使用方式遵循了统一访问的原则。

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height

    @property
    def bmi(self):
        '''
        计算bmi指数
        bmi=体重（kg）+身高**2（m）
        :return: 
        '''
        return self.weight/(self.height**2)

hantao=People('hantao',85,1.74)
print(hantao.bmi)

在python中通过property方法实现将所有的数据设置为私有的，然后提供set和get方法（接口）去设置和获取

class People:
    def __init__(self,name):
        self.__Name=name

    @property
    def name(self):
        return self.__Name

    @name.setter
    def name(self,new_name):
        if not isinstance(new_name,str):
            raise TypeError('%s不是是字符串'%new_name)
        self.__Name=new_name

    @name.deleter
    def name(self):
        raise TypeError('不能删！')

hantao=People('hantao')
print(hantao.name)
hantao.name='asdf'
print(hantao.name)
# hantao.name=123
# print(hantao.name)
del hantao.name

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

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

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

    def delname(self):
        raise TypeError('Can not delete')

    name=property(getname,setname,delname) #不如装饰器的方式清晰

了解：一种property的古老用法