7.26 面向对象_封装_property_接口

封装

---

封装 就是隐藏内部实现细节,

将复杂的,丑陋的,隐私的细节隐藏到内部,对外提供简单的访问接口

为什么要封装

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.内部依然可以使用

权限

---

利用好封装的特性就可以控制属性的权限

python中只有两种权限

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装饰器

通过方法来修改或访问属性,本身没什么问题,但是这给对象的使用者带来了麻烦.

使用必须知道哪些是普通属性,哪些是私有属性,需要使用不同的方式来调用他们

property装饰就是为了使得调用方式一致

property有三个相关的装饰器

1.@property   该装饰器用在获取属性的方法上
2.@key.setter  该装饰器用在修改属性的方法上
3.@key.deleter 该装饰器用在删除属性的方法上 

注意:key是被property装饰的方法的名称 也就是属性的名称
内部会创建一个对象 变量名称就是函数名称
所以在使用setter和deleter时 必须保证使用对象的名称取调用方法
所以是 key.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)
# 987

python实现封装的原理

就是在加载类的时候,把__替换成了 _类名__

python实现计算属性的方式

属性的值不能直接获得，必须通过计算才能获得

例如：正方形的面积属性，是边长相乘获得的

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模块

所谓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一般不会限制你必须怎么写，作为一个合格的