python类封装_Python__类的封装

python不依赖语言特性去封装数据，而是通过遵循一定的数据属性和函数属性的命名约定来达到封装的效果

约定一：任何一单下划线开头的名字都应该是内部的，私有的

#_*_coding:utf-8_*_

__author__ = 'Simon'

classPeople:__star='earth111111111111' #单下划线开头的就代表隐藏起来的

__star1='earth111111111111'

__star2='earth111111111111'

__star3='earth111111111111'

def __init__(self,id,name,age,salary):print('----->',self.__star)

self.id=id

self.name=name

self.age=age

self.salary=salarydefget_id(self):print('我是私有方法啊,我找到的id是[%s]' %self.id)#访问函数

defget_star(self):print(self.__star)

p1=People('123123123123','alex','18',100000000)#print(p1.__star)

print(People.__dict__)#print(p1.__star)

print(p1._People__star)#

#p1.get_star()

p1.get_star()

约定二：双下划线开头的名字

第三个层面的封装：

隐藏方式

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

#其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形#类中所有双下划线开头的名称如__x都会在类定义时自动变形成：_类名__x的形式：

classA:__N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N

def __init__(self):

self.__X=10 #变形为self._A__X

def __foo(self): #变形为_A__foo

print('from A')defbar(self):

self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的，#这种，在外部是无法通过__x这个名字访问到。

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

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

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

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

#正常情况

>>> classA:

...deffa(self):

...print('from A')

...deftest(self):

... self.fa()

...>>> classB(A):

...deffa(self):

...print('from B')

...>>> b=B()>>>b.test()fromB#把fa定义成私有的，即__fa

>>> classA:

...def __fa(self): #在定义时就变形为_A__fa

... print('from A')

...deftest(self):

... self.__fa() #只会与自己所在的类为准,即调用_A__fa

...>>> classB(A):

...def __fa(self):

...print('from B')

...>>> b=B()>>>b.test()from A

封装的意义

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

classTeacher:def __init__(self,name,age):#self.__name=name

#self.__age=age

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

self.__name=name

self.__age=age

t=Teacher('egon',18)

t.tell_info()

t.set_info('egon',19)

t.tell_info()

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

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

classATM:def __card(self):print('插卡')def __auth(self):print('用户认证')def __input(self):print('输入取款金额')def __print_bill(self):print('打印账单')def __take_money(self):print('取款')defwithdraw(self):

self.__card()

self.__auth()

self.__input()

self.__print_bill()

self.__take_money()

a=ATM()

a.withdraw()

隔离复杂度的例子

什么是特性property

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

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：

过轻：低于18.5

正常：18.5-23.9

过重：24-27

肥胖：28-32

非常肥胖, 高于32

体质指数（BMI）=体重（kg）÷身高^2（m）

EX：70kg÷（1.75×1.75）=22.86

classPeople:def __init__(self,name,weight,height):

self.name=name

self.weight=weight

self.height=height

@propertydefbmi(self):return self.weight / (self.height**2)

p1=People('egon',75,1.85)print(p1.bmi)

例二：圆的周长和面积

importmathclassCircle:def __init__(self,radius): #圆的半径radius

self.radius=radius

@propertydefarea(self):return math.pi * self.radius**2 #计算面积

@propertydefperimeter(self):return 2*math.pi*self.radius #计算周长

c=Circle(10)print(c.radius)print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值

print(c.perimeter) #同上

'''输出结果:

314.1592653589793

62.83185307179586'''

为什么要用property

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

除此之外，看下

ps：面向对象的封装有三种方式:

【public】

这种其实就是不封装,是对外公开的

【protected】

这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开

【private】

这种封装对谁都不公开

python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

classFoo:def __init__(self,val):

self.__NAME=val #将所有的数据属性都隐藏起来

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

@name.setterdefname(self,value):if not isinstance(value,str): #在设定值之前进行类型检查

raise TypeError('%s must be str' %value)

self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

@name.deleterdefname(self):raise TypeError('Can not delete')

f=Foo('egon')print(f.name)#f.name=10 #抛出异常'TypeError: 10 must be str'

del f.name #抛出异常'TypeError: Can not delete'

封装性与扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

#类的设计者

classRoom:def __init__(self,name,owner,width,length,high):

self.name=name

self.owner=owner

self.__width=width

self.__length=length

self.__high=highdef tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积

return self.__width * self.__length

#使用者

>>> r1=Room('卧室','egon',20,20,20)>>> r1.tell_area() #使用者调用接口tell_area

#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码

classRoom:def __init__(self,name,owner,width,length,high):

self.name=name

self.owner=owner

self.__width=width

self.__length=length

self.__high=highdef tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了

return self.__width * self.__length * self.__high

#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能

>>> r1.tell_area()