封装 就是隐藏内部实现细节,
将复杂的,丑陋的,隐私的细节隐藏到内部,对外提供简单的访问接口
1.保证关键数据的安全性
2.对外部隐藏实现细节,隔离复杂度
1.当有一些数据不希望外界可以直接修改时
2.当有一些函数不希望给外界使用时
语法:
class Person: def __init__(self,id_number,name,age) self.__id_number = id_number # 比如这里是比较重要的身份证号码，不能随便调用 # 给属性或者方法前面加上 __ def show_id(self): print(self.__id_number) def __say_hi(self): print(f"hi, 我是{self.name}") p = Person('35676549809711', 'bitten', 29) p.id_number = '3756789' # 这里其实是给对象加了个属性 id_number（对象属性的增删改查） print(p.id_number) # 3756789 p.show_id() # 35676549809711 # 并没有受到影响 # p.__id_number # 报错，pycharm没有提示也找不到，AttributeError: 'Person' object has no attribute '__id_number' # p.__say_hi # 报错，AttributeError: 'Person' object has no attribute '__say_hi'双下划线，外界就访问不到了 self.name = name self.age = age p = Person("35676549809711","bitten",29) p.id_number = "222"1.外界不能直接访问
2.内部依然可以使用
利用好封装的特性就可以控制属性的权限
1.公开的属性或方法，默认就是公开的
2.私有的属性或方法，只能由当前类自己使用
属性虽然被封装了，但是还是需要使用的
在外界访问私有属性的方法就是：
通过定义方法类完成对私有属性的修改和访问
''' 这是一个下载器类，需要提供一个缓存大小这样的属性 缓存大小不能超过内存限制 ''' class Downloader: def __init__(self, filename, url, buffer_size): self.filename = filename self.url = url # self.buffer_size = buffer_size self.__buffer_size = buffer_size # 一旦被私有后，外界就无法直接访问了，应该给外界提供一个接口，可以改动 def start_download(self): # if self.buffer_size <= 1024*1024: if self.__buffer_size <= 1024*1024: print("开始下载...") else: print("内存超过限制！") # 可以在方法中添加一些额外的逻辑 def set_buffer_size(self, size): # 这里可以加一些限制操作，限制大小或者登录验证，数据校验 if not isinstance(size, int): print("缓冲区大小必须是整数！") return False self.__buffer_size = size def get_buffer_size(self): return self.__buffer_size d = Downloader("冰火两重天", 'https://www.baidu.com', 1024*1024) # d.buffer_size = 1024*1024*1024 d.start_download() # 开始下载... d.set_buffer_size(1024 * 512) # 外界通过方法改动私有属性 d.set_buffer_size('aa') # 外界通过方法改动私有属性 # 缓冲区大小必须是整数！ d.start_download() # 开始下载... print(d.get_buffer_size()) # 外界通过方法访问私有属性 # 524288 d.set_buffer_size(1024 * 1024 * 1024 / 2) # 这里 / 2 变成了float 浮点型，类型不匹配了 # 缓冲区大小必须是整数！ d.start_download() # 开始下载... # 这里用的是之前的buffer_size，上面没有改成功（不然超出大小了也下不了的） d.set_buffer_size(1024 * 1024 * 1024) # set_buffer_size() 里没有做大小限制，所以其实是改成功了 d.start_download() # 超过大小限制，所以提示内存超过限制 # 内存超过限制！好处：通过封装的方法来修改、读取、删除（私有）属性，可以在对属性进行修改、读取、删除的时候可以做拦截，做一些逻辑操作
缺点：访问的时候，访问方式不统一，非私有变量直接 # 对象.属性名 就可以访问了，而私有变量因为用了方法封装才能访问，所以访问的时候要调用方法才行。
通过方法来修改或访问属性,本身没什么问题,但是这给对象的使用者带来了麻烦.
使用必须知道哪些是普通属性,哪些是私有属性,需要使用不同的方式来调用他们
property装饰就是为了使得调用方式一致
案例：
class A: def __init__(self, name, key): self.name = name self.__key = key def set_key(self, new_key): self.__key = new_key def get_key(self): return self.__key @property # 把一个方法伪装成普通属性，通过 . 来访问调用 def key(self): # 可以改成其他名字，但调的时候也要改，通常情况下也是默认跟属性名一致 # 逻辑处理 return self.__key @key.setter # 把一个私有的属性通过方法伪装成一个普通的属性 def key(self, new_key): # 逻辑处理 self.__key = new_key @key.deleter # 在del 对象.key 的时候会执行这个 def key(self): # 判断权限再删除 if '有权限' == '有权限': del self.key else: print(f"您没有权限删除！") a = A('jack', 123) print(a.name) # jack print(a.get_key()) # 这样需要记哪些属性需要调方法，哪些直接就可以 . 访问, 不太好 # 123 a.set_key(321) # 这样也不太好 print(a.key) # 321 # 访问与修改私有属性 key （别说没用，我这里可以在装饰的方法里写一些逻辑操作，控制私有属性（加权限）） a.key = 987 print(a.key) # 987就是在加载类的时候,把__替换成了 _类名__
属性的值不能直接获得，必须通过计算才能获得
例如：正方形的面积属性，是边长相乘获得的
class Square: # 正方形 def __init__(self, width): self.width = width self.area = self.width * self.width s = Square(10) print(s.area) # 100 s.width = 20 print(s.area) # 后续更改了width，它的值就不对了 # 100 class Square2: # 正方形 def __init__(self, width): self.width = width # self.area = self.width * self.width # 下面定义的时候要把这里去掉 @property # 只要 . 这个属性， 就会自动触发这个函数 def area(self): return self.width * self.width s2 = Square2(10) print(s2.area) # 100 s2.width = 20 print(s2.area) # 400即没有 方法的具体实现 的类
接口定义：一组功能的集合,但是接口中仅包含功能的名字,不包含具体的实现代码
接口本质：一套协议标准,遵循这个标准的对象就能被调用
接口的目的：提高扩展性
例如：电脑提前制定一套USB接口协议，只要你的设备遵循了该协议，那么它就可以被电脑使用，无所谓什么类型（鼠标、键盘...）
# 协议：支持打开关闭，读写数据 class USB: def open(self): pass def close(self): pass def read(self): pass def write(self): pass # 按USB标准制作鼠标 class Mouse(USB): def open(self): # 打开方法 print("鼠标开机了") def close(self): print("鼠标关闭了") def read(self): print("获取了光标位置") def write(self): # 请忽略鼠标配置 print("鼠标可以写入灯光颜色等数据...") # 至此，Mouse就算是一个合格的USB设备了 # 按USB标准制作键盘 class KeyBoard(USB): def open(self): # 打开方法 print("键盘开机了") def close(self): print("键盘关闭了") def read(self): print("获取了按键字符...") def write(self): # 请忽略鼠标配置 print("键盘可以写入灯光颜色等数据...") # 至此，Mouse就算是一个合格的USB设备了 # ..........其他符合USB接口协议的设备........... def pc(usb_device): usb_device.open() usb_device.read() usb_device.write() usb_device.close() mouse = Mouse() # 将鼠标传给pc pc(mouse) # 鼠标开机了 # 获取了光标位置 # 鼠标不支持写入数据 # 鼠标关闭了 key_board = KeyBoard() pc(key_board) # 键盘开机了 # 获取了按键字符... # 键盘可以写入灯光颜色等数据... # 键盘关闭了 # 上述过程，鼠标键盘的使用都没有改变pc 的代码（使用方式），体现了扩展性和复用性 小结
在上述案例中，pc的代码一旦完成后期无论什么样的设备
只要遵循了USB接口协议，都能够被电脑所调用
接口主要是方便了对象的使用者，降低使用者的学习难度
只要学习一套使用方法，就可以以不变应万变
如果不按标准来
如果子类没有按照你的协议来设计，你也无法限制它，这将导致代码无法运行
这就需要了解下面的abc模块了
所谓ABC：即ABstract Class(抽象类)
作用：可以限制子类必须实现类中定义的抽象方法(@abc.abstractmethod) ( 防止一些类不按照规定来写 )
import abc # abc是 abstract class（抽象类） 的缩写，不是随便写的 class AClass(metaclass=abc.ABCMeta): # 抽象类 @abc.abstractmethod # 装饰抽象方法 def run(self): pass @abc.abstractmethod # 装饰抽象方法 def run2(self): pass class B(AClass): pass # b = B() # 直接报错，TypeError: Can't instantiate abstract class B with abstract methods run class C(AClass): def run(self): print("runrunrun....") # c = C() # 少实现了一个方法，直接报错 TypeError: Can't instantiate abstract class C with abstract methods run2 class D(AClass): def run(self): print("runrunrun....") def run2(self): print("runrunrun2....") d = D() # 把抽象类的方法都实现了，不会报错python一般不会限制你必须怎么写，作为一个合格的??，就应该自觉遵守相关协议，所以就有了鸭子类型
如果这个对象长得像鸭子(属性)，走路像鸭子(方法)，那么他就是鸭子(没有必须全方位都得像)
鸭子类型：拥有相同属性和方法，那么就可以把它看成同样的类，也可以提高扩展性
代码案例：
# 默认按USB标准制作鼠标 class Mouse: @staticmethod def open(): # 打开方法 print("鼠标开机了") @staticmethod def close(): print("鼠标关闭了") @staticmethod def read(): print("获取了光标位置") @staticmethod def write(): # 请忽略鼠标配置 print("鼠标可以写入灯光颜色等数据...") # 默认按USB标准制作键盘 class KeyBoard: @staticmethod def open(): # 打开方法 print("键盘开机了") @staticmethod def close(): print("键盘关闭了") @staticmethod def read(): print("获取了按键字符...") @staticmethod def write(): # 请忽略鼠标配置 print("键盘可以写入灯光颜色等数据...") # ..........其他符合USB接口协议的设备........... def pc(usb_device): usb_device.open() usb_device.read() usb_device.write() usb_device.close() mouse = Mouse() # 将鼠标传给pc pc(mouse) # 可以正常使用 # 鼠标开机了 # 获取了光标位置 # 鼠标不支持写入数据 # 鼠标关闭了 key_board = KeyBoard() pc(key_board) # 可以正常使用 # 键盘开机了 # 获取了按键字符... # 键盘可以写入灯光颜色等数据... # 键盘关闭了上面的案例中依然没有改变pc中的代码，而Mouse、KeyBoard这样的类也可以直接交给pc使用，他们看起来用起来都像是前面写的USB接口协议，所以他们就是鸭子类型
接口是一套协议规范，明确子类们应该具备哪些功能
抽象类是用于强制要求子类必须按照协议中的规定来（接口中定义的）实现
然而python 不推崇限制你的语法，我们可以设计成鸭子类型，既让多个不同类对象具备相同的属性和方法，对于使用者而言，就可以以不变应万变，轻松地使用各种符合协议的对象
转载于:https://www.cnblogs.com/PowerTips/p/11255932.html
相关资源：JAVA上百实例源码以及开源项目