标签：__ .__ 封装 Person python self 面向对象 age def
- 一：面向对象编程有三大特性：
- 二：其中最重要的一个特性就是封装。
- 三：什么是封装？
- 1.数据角度讲，将一些基础数据类型复合成一个自定义类型
- 2.行为角度讲，向类外提供必要的功能，隐藏实现的细节
- 3.设计角度
- 分而治之
- 将一个大的需求分解成许多类，每个类处理一个独立的功能
- 拆分的好处，便于分工，便于复合，可扩展性强
- 变则疏之
- 高内聚
- 低耦合
- 四：隐藏属性
- 1.Python的Class机制采用双下划线开头的方式将属性隐藏起来（设置成私有的）
- 2.但其实这仅仅只是一种变形操作，类中所有双下滑线开头的属性都会在类定义阶段、检测语法时自动变成_类名__属性名的形式：
class Person:
# 变形为_Person__NAME
__NAME = "ZHANG"
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def __init__(self):
# 变形为self._Person__age
self.__age = 18
# 变形为_Foo__run
def __run(self):
print('__f1 run')
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def walk(self):
self.__run()
# print(Person.__NAME) #object 'Person' has no attribute '__NAME'
obj = Person()
# print(obj.__NAME) #'Person' object has no attribute '__NAME'
print(obj.__dict__) #{'_Person__age': 18}
print(Person.__dict__)
"""
{'__module__': '__main__', '_Person__NAME': 'ZHANG', '__init__': <function Person.__init__ at 0x0000017F3CE3C5E0>,
'_Person__run': <function Person.__run at 0x0000017F3CE3C790>, 'walk': <function Person.walk at 0x0000017F3D0B2C10>,
'__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>,
'__doc__': None}
"""
- 3.问题：在类外部无法直接访问双下滑线开头的属性，但知道了类名和属性名就可以拼出名字：__类名__属性，然后就可以访问了，
如Person._Person__NAME，所以说这种操作并没有严格意义上地限制外部访问，仅仅只是一种语法意义上的变形
- 4.在类内部是可以直接访问双下滑线开头的属性的，比如self.__f1()，因为在类定义阶段类内部双下滑线开头的属性统一发生了变形。
class Person:
# 变形为_Person__NAME
__NAME = "Dream"
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def __init__(self):
# 变形为self._Person__age
self.__age = 18
# 变形为_Person__run
def __run(self):
print('__f1 run')
# 定义函数时，会检测函数语法，所以__开头的属性也会变形
def walk(self):
# 变形为self._Person__run()
self.__run() # 等同于 self._Person__run()
print(self.__NAME) # 等同于 print(self._Person__age)
- 五：开发接口
- 1.定义属性就是为了使用，所以隐藏并不是目的
- 2.将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
- 3.目的的是为了隔离复杂度
- 例如ATM程序的取款功能,该功能有很多其他功能组成，
- 比如插卡、身份认证、输入金额、打印小票、取钱等
- 而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来
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()
obj = ATM()
obj.withdraw()
# 插卡
# 用户认证
# 输入取款金额
# 打印账单
# 取款
- 4.总结隐藏属性与开放接口，本质就是为了明确地区分内外，类内部可以修改封装内的东西而不影响外部调用者的代码；
- 而类外部只需拿到一个接口，只要接口名、参数不变，则无论设计者如何改变内部实现代码，使用者均无需改变代码。
- 这就提供一个良好的合作基础，只要接口这个基础约定不变，则代码的修改不足为虑。
- 六：装饰器property
- 1.将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
- 2.初版
class Wife:
def __init__(self,name,age,weight):
self.name = name
# 本质：障眼法(实际将变量名改为：_类名__age)
# self.__age = age
# self.set_age(age) # 缺点：看着不方便，不像数据
self.age = age
self.weight = weight
# 提供公开的读写方法
def get_age(self):
return self.__age
def set_age(self,value):
if 21 <= value <= 31:
self.__age = value
else:
raise ValueError("不行")
# 实例变量使用 self.age = age, 配合property
age = property(get_age, set_age)
"""
w01 = Wife("白雪公主",22,90)
# 重新创建了实例变量，没有改变类中定义的__age
# w01.__age = 88
# 修改了类中定义的私有变量
w01._Wife__age = 88
print(w01.__dict__) # __dict__内置变量，存储对象的实例变量
"""
w01 = Wife("白雪公主",21,90)
print(w01.get_age())
print(w01.__dict__)
class Wife:
def __init__(self,name,age,weight):
self.name = name
# 本质：障眼法(实际将变量名改为：_类名__age)
# self.__age = age
# self.set_age(age) # 缺点：看着不方便，不像数据
self.age = age
self.weight = weight
# 提供公开的读写方法
@property # 创建property对象，只负责读取操作
def age(self):
return self.__age
@age.setter # 只负责拦截写入操作
def age(self,value):
if 21 <= value <= 31:
self.__age = value
else:
raise ValueError("不行")
# 实例变量使用 self.age = age, 配合property
# age = property(get_age, set_age)
w01 = Wife("白雪公主",23,90)
w01.age = 11
print(w01.__dict__)
- 七：封装与扩展性
- 1.封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；
- 2.而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变
- 3.这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑
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
# 使用者
room = Room('卧室', 'dream', 20, 20, 20)
# 使用者调用接口tell_area
result = room.tell_area()
print(result)
# 400
#更好的扩展性
# 类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
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接口的人来说，根本无需改动自己的代码，就可以用上新功能
room = Room('卧室', 'dream', 20, 20, 20)
# 使用者调用接口tell_area
result = room.tell_area()
print(result)
# 8000
标签：__,
.__,
封装,
Person,
python,
self,
面向对象,
age,
def
From： https://www.cnblogs.com/xwltest/p/18372554