python面向对象-封装-property-接口-抽象-鸭子类型-03
封装
什么是封装：
# 将复杂的丑陋的隐私的细节隐藏到内部，对外提供简单的使用接口 或 # 对外隐藏内部实现细节，并提供访问的接口
为什么需要封装
- 1.为了保证关键数据的安全性
- 2.对外部隐藏内部的实现细节，隔离复杂度
什么时候需要封装：
# 当有一些数据不希望外界可以直接修改时，# 当有一些函数不希望给外界使用时
如何使用封装
语法：(给属性或者方法前面加上 __ 双下划线，外界就访问不到了)
用户的身份证号等信息属于用户的隐私，肯定不能直接暴露给外界可以直接访问或修改，那么就不能把它作为普通属性了，应该是私有属性
class Person:
def __init__(self, id_number, name, age):
# 身份证号码肯定不能随便改！那就需要给他隐藏起来(__属性，隐藏起来)
self.__id_number = id_number # ************ 把属性隐藏起来
# self.id_number = id_number
self.name = name
self.age = age
def show_id(self):
print(self.__id_number)
def __say_hi(self):
print(f"hi, 我是{self.name}")
p = Person('111111111111111111', 'jack', 29)
p.id_number = '222' # 这里其实是给对象加了个属性 id_number（对象属性的增删改查）
print(p.id_number)
# 222
p.show_id()
# 111111111111111111 # 并没有受到影响
# p.__id_number # 报错，pycharm没有提示也找不到，AttributeError: 'Person' object has no attribute '__id_number'
# p.__say_hi # 报错，AttributeError: 'Person' object has no attribute '__say_hi'封装方法案例
用户使用电脑只需要按下开机键即可，具体开机要涉及检查硬件啊、载入内核、初始化内核等操作，用户根本不需要去操作，也不需要去了解（不然还得学，那用个电脑这么麻烦，估计是不用了），况且没有接通电源是无法载入内核的（有先后顺序），此时就可以把载入内核等方法封装起来，作为私有方法，在暴露出来的接口中调用，这样用户只需要按下开机即可完成了。
class PC:
def __init__(self, price, kind, color):
self.price = price
self.kind = kind
self.color = color
# 外部只需要调用这个open 就可以启动电脑了，其他的歩鄹都不需要外界操作
def open(self):
# 复杂的开机流程
print("接通电源")
self.__check_device()
print("载入内核")
print("初始化内核")
self.__start_services()
print("启动GUI")
self.__login()
# 必须先接通电源
@staticmethod
# def check_device():
def __check_device():
print("硬件检测1")
print("硬件检测2")
print("硬件检测3")
print("硬件检测4")
# 必须先接通电源
@staticmethod
# def start_services():
def __start_services():
print("启动服务1")
print("启动服务2")
print("启动服务3")
print("启动服务4")
# 必须先启动了才能登录 --> 不能让外界直接调用登录
@staticmethod
# def login():
def __login():
print("login流程1.......")
print("login流程2.......")
print("login流程3.......")
print("login流程4.......")
pc = PC(5688, 'ASUS', 'black')
pc.open() # 一键启动
# 接通电源
# 硬件检测1
# 硬件检测2
# 硬件检测3
# 硬件检测4
# 载入内核
# 初始化内核
# 启动服务1
# 启动服务2
# 启动服务3
# 启动服务4
# 启动GUI
# login流程1.......
# login流程2.......
# login流程3.......
# login流程4.......被封装内容的特点
- 外界不能直接访问
- 类内部依然可以使用
权限
利用好封装的特性就可以控制属性的权限（接着往下看）
python中只有两种权限
- 公开的（默认就是公开的）
- 私有的，只能由当前类自己使用
在外界访问私有内容
可以通过封装非私有方法来实现（类内部还是可以访问自身的私有属性的）
'''
这是一个下载器类，需要提供一个缓存大小这样的属性
缓存大小不能超过内存限制
'''
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 装饰器
由来：通过方法来修改或访问私有属性，本身没什么问题，但他还是不怎么好，这给对象的使用者带来了麻烦，使用者必须知道哪些是普通属性，哪些是私有属性，需要使用不同的方式来调他们（获取设置）。
而贴心的python提供了 property装饰器
property 好处
# property 装饰器可以解决上面的问题，把方法伪装成属性，让私有属性与普通属性的调用方式一致
property 有三种装饰器
'''
@property（@property.setter）： 用在获取属性的方法上（调用的时候名字应该和属性一致）
@key.setter：用在修改属性的方法上(必须保持属性名和property装饰的函数的名字一致)
@key.deleter：用在删除属性的方法上(必须保持属性名和property装饰的函数的名字一致)
注意：key是被property装饰方法的名称，也是属性的名称
其内部会创建一个对象，名称就是函数名称，所以在使用setter和deleter时，必须使用对象的名称 . 去调用方法，即 对象.setter
（这三个需要哪个就写哪个）
'''案例
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)
# 987python 实现封装的原理
# 就是在加载类的时候，把 __ 替换成了 _类名__属性（替换属性名称）
python一般不会强制要求程序员怎么怎么样，比较灵活
通过property 实现计算属性
计算属性：属性的值不能直接获得，必须通过计算才能获取
例如：正方形的面积属性，是由边长相乘得到的
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小练习：计算BMI
# 练习: 定义一个类叫做person
# 包含三个属性 身高 体重 BMI
# BMI的值需要通过计算得来 公式 体重 / 身高的平方接口
接口：# 一组功能的集合，但是接口中仅包含功能的名字，不包含具体实现代码。
生活中的案例：USB接口、HDMI、VGA、WLAN网线接口
接口本质：一套协议标准，遵循了这个标准的对象就能够被调用（调谁都可以）
接口的目的：提高扩展性
例如：电脑提前制定一套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接口协议，就都能够被pc识别并调用。
接口主要是为了方便对象的使用者，降低使用者的学习难度，只需要学习一套使用方法就可以以不变应万变了。
如果不按标准来：如果子类没有按照你的协议来设计，你也没办法限制他，这将导致代码无法运行
那么下面的abc模块了解一下。
抽象类
abc模块
abc模块的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 一般不会限制你必须怎么写，作为一个优秀的程序员，就应该自觉遵守相关协议，所以就有了鸭子类型这一说
如果这个对象长得像鸭子（属性），走路像鸭子（方法），那么他就是鸭子（没有说必须方方面面都像）
鸭子类型：拥有相同属性和方法，那么就可以把它看成同样的类，也可以提高扩展性
代码案例（去掉接口，自觉遵守，不改pc代码）
接口与抽象类小结：
'''
接口是一套协议规范，明确子类们应该具备哪些功能
抽象类是用于强制要求子类必须按照协议中的规定来（接口中定义的）实现
然而python 不推崇限制你的语法，我们可以设计成鸭子类型，既让多个不同类对象具备相同的属性和方法，对于使用者而言，就可以以不变应万变，轻松地使用各种符合协议的对象
'''
版权声明：本文为suwanbin原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。