11 封装

 1 #其实这仅仅这是一种变形操作
 2 #类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：
 3  
 4 class A:
 5     __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
 6     def __init__(self):
 7         self.__X=10 #变形为self._A__X
 8     def __foo(self): #变形为_A__foo
 9         print(‘from A‘)
10     def bar(self):
11         self.__foo() #只有在类内部才可以通过__foo的形式访问到.
12  
13 #A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

 1 class Teacher:
 2     def __init__(self,name,age):
 3         self.__name=name
 4         self.__age=age
 5  
 6     def tell_info(self):
 7         print(‘姓名:%s,年龄:%s‘ %(self.__name,self.__age))
 8     def set_info(self,name,age):
 9         if not isinstance(name,str):
10             raise TypeError(‘姓名必须是字符串类型‘)
11         if not isinstance(age,int):
12             raise TypeError(‘年龄必须是整型‘)
13         self.__name=name
14         self.__age=age
15  
16 t=Teacher(‘egon‘,18)
17 t.tell_info()
18  
19 t.set_info(‘egon‘,19)
20 t.tell_info()

 1 #取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
 2 #对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
 3 #隔离了复杂度,同时也提升了安全性
 4  
 5 class ATM:
 6     def __card(self):
 7         print(‘插卡‘)
 8     def __auth(self):
 9         print(‘用户认证‘)
10     def __input(self):
11         print(‘输入取款金额‘)
12     def __print_bill(self):
13         print(‘打印账单‘)
14     def __take_money(self):
15         print(‘取款‘)
16  
17     def withdraw(self):
18         self.__card()
19         self.__auth()
20         self.__input()
21         self.__print_bill()
22         self.__take_money()
23  
24 a=ATM()
25 a.withdraw()

 1 class People:
 2     def __init__(self,name,weight,height):
 3         self.name=name
 4         self.weight=weight
 5         self.height=height
 6     @property
 7     def bmi(self):
 8         return self.weight / (self.height**2)
 9  
10 p1=People(‘egon‘,75,1.85)
11 print(p1.bmi)

 1 import math
 2 class Circle:
 3     def __init__(self,radius): #圆的半径radius
 4         self.radius=radius
 5  
 6     @property
 7     def area(self):
 8         return math.pi * self.radius**2 #计算面积
 9  
10     @property
11     def perimeter(self):
12         return 2*math.pi*self.radius #计算周长
13  
14 c=Circle(10)
15 print(c.radius)
16 print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
17 print(c.perimeter) 
18 #同上
19 ‘‘‘
20 输出结果:
21 10
22 314.1592653589793
23 62.83185307179586
24 ‘‘‘

1 c.area=3 #为特性area赋值
2 ‘‘‘
3 抛出异常:
4 AttributeError: can‘t set attribute
5 ‘‘‘

 1 class Foo:
 2     def __init__(self,val):
 3         self.__NAME=val #将所有的数据属性都隐藏起来
 4  
 5     @property
 6     def name(self):
 7         return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)
 8  
 9     @name.setter
10     def name(self,value):
11         if not isinstance(value,str): #在设定值之前进行类型检查
12             raise TypeError(‘%s must be str‘ %value)
13         self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME
14  
15     @name.deleter
16     def name(self):
17         raise TypeError(‘Can not delete‘)
18  
19 f=Foo(‘egon‘)
20 print(f.name)# f.name=10 #抛出异常‘TypeError: 10 must be str‘
21 del f.name #抛出异常‘TypeError: Can not delete‘

 1 #类的设计者
 2 class Room:
 3     def __init__(self,name,owner,width,length,high):
 4         self.name=name
 5         self.owner=owner
 6         self.__width=width
 7         self.__length=length
 8         self.__high=high
 9     def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
10         return self.__width * self.__length

#使用者，一旦实例化r1房间，则r1房间的宽、长、高固定，无法修改
>>> r1=Room(‘卧室‘,‘egon‘,20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area

 1 #类的设计者，轻松的扩展了功能（从计算面积变成计算体积），而类的使用者完全不需要改变自己的代码
 2 class Room:
 3     def __init__(self,name,owner,width,length,high):
 4         self.name=name
 5         self.owner=owner
 6         self.__width=width
 7         self.__length=length
 8         self.__high=high
 9     def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
10         return self.__width * self.__length * self.__high

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