封装
property
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
class A:
__x = 1 # 以__开头的变量属性或者函数方法,在类定义以后都会自动变形成_A__.x def __test(self): # _A__test
print("from A") def foo(self):
self.__test() # 在类内部可以通过self.__test()来调用私有的属性或者方法.因为在方法定义阶段,就已经变形成_A__test()
print("from foo") print(A.__dict__)
a = A()
a.foo()
print(a.__test) a._A__test() # 子类无法覆盖父类__开头的属性或方法.
class Foo:
def __test(self): # 定义阶段就变成了_Foo__test()
print("from Foo") class Bar(Foo):
def __test(self): # 定义阶段编程了_Bar__test().所以这2个__test()完全是2个不同的方法.
print("from Bar")
变形的特点：
类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。(代码1-9)
这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。(代码14行)
在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。(代码:20-26行)
变形需要注意的问题是：
1、这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：对象名._类名__属性，然后就可以访问了，如a._A__N
2、变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形
class A:
__y = 5
def __test(self):
print("from A") A.__X = 3
print(A.__dict__)
# '__X': 3 定义的并未发生变形.
3、在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
class A:
def test(self):
print("from A")
self.__foo() def __foo(self): # 定义阶段变成self._B__foo() 当从A中test()方法调用的时候,就是调自己类中的__foo()
print("from A.foo") class B(A):
def __foo(self):
print("from B.foo") a = B()
a.test()
封装的作用:
1. 隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。class Teacher:
def __init__(self, name, age):
self.__name = name
self.__age = age def tell_infco(self):
print("name is %s and age is %s" % (self.__name, self.__age)) def set_info(self, name, age):
if not isinstance(name, str):
print("\033[1;31mError,name must str.\033[0m")
else:
self.__name = name
if not isinstance(age, int):
print("\033[1;31mError,age is must int.\033[0m")
else:
self.__age = age t1 = Teacher("Jack", 18) t1.tell_infco()
t1.set_info(123,"") # 姓名和年龄,有一个不符合我们设定的条件,就打印我们设置的提示.
t1.set_info("mayun", 55) # 符合要求,打印我们修改后的内容.
t1.tell_infco()
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()
取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
隔离了复杂度,同时也提升了安全性
封装与扩展性:
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。
#类的设计者
class Room:
def __init__(self,name,owner,width,length,high):
self.name=name
self.owner=owner
self.__width=width
self.__length=length
self.__high=high
def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
return self.__width * self.__length #使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area #类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
def __init__(self,name,owner,width,length,high):
self.name=name
self.owner=owner
self.__width=width
self.__length=length
self.__high=high
def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
return self.__width * self.__length * self.__high #对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()
property
property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值.
class Peoplo:
def __init__(self, name, height, weight):
self.name = name
self.height = height
self.weight = weight
@property # 加上property这个装饰器,就把这个方法变成了像一个属性.在调用的时候,直接b.bmi就可以了
def bmi(self):
return self.weight / (self.height ** 2) p = Peoplo("Nick", 1.7, 69) # print(p.bmi()) # 正常情况下,我们要调用这个方法来获取我们想要的数据.
p.bmi = 35555 # 会报错.本质上行还是调用bmi()方法.没有修改属性.
print(p.bmi)