python面向对象-封装-property-接口-抽象-鸭子类型-03

封装

什么是封装

# 将复杂的丑陋的隐私的细节隐藏到内部，对外提供简单的使用接口 或 # 对外隐藏内部实现细节，并提供访问的接口

为什么需要封装

• 为了保证关键数据的安全性

• 对外部隐藏内部的实现细节，隔离复杂度

什么时候需要封装

# 当有一些数据不希望外界可以直接修改时，# 当有一些函数不希望给外界使用时

如何使用封装

语法：(给属性或者方法前面加上 __ 双下划线，外界就访问不到了)

​ 用户的身份证号等信息属于用户的隐私，肯定不能直接暴露给外界可以直接访问或修改，那么就不能把它作为普通属性了，应该是私有属性

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中只有两种权限

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

由来：通过方法来修改或访问私有属性，本身没什么问题，但他还是不怎么好，这给对象的使用者带来了麻烦，使用者必须知道哪些是普通属性，哪些是私有属性，需要使用不同的方式来调他们（获取设置）。

而贴心的python提供了 property装饰器

property 好处

# property 装饰器可以解决上面的问题，把方法伪装成属性，让私有属性与普通属性的调用方式一致

property 有三种装饰器

'''
	@property（@property.getter）： 用在获取属性的方法上（调用的时候名字应该和属性一致）
	@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)
# 987

python 实现封装的原理

# 就是在加载类的时候，把 __ 替换成了 _类名__属性（替换属性名称）

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的值需要通过计算得来 公式   体重 / 身高的平方

class Person:
    '''
        height: 单位 m
        weight: 单位 kg
    '''
    def __init__(self, height_meter, weight_kg):  # 用变量名来提示调用者数据的单位
        self.height = height_meter
        self.weight = weight_kg

    @property  # 利用property 把方法伪装成属性  --> 计算属性的原理
    def bmi(self):
        return self.weight / pow(self.height, 2)

p1 = Person(1.80, 65)
print(p1.bmi)
# 20.061728395061728

抽象类

抽象类：# 类中没有方法的具体实现代码的类

接口

接口：# 一组功能的集合，但是接口中仅包含功能的名字，不包含具体实现代码。

生活中的案例：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 一般不会限制你必须怎么写，作为一个优秀的程序员，就应该自觉遵守相关协议，所以就有了鸭子类型这一说

如果这个对象长得像鸭子（属性），走路像鸭子（方法），那么他就是鸭子（没有说必须方方面面都像）

鸭子类型：拥有相同属性和方法，那么就可以把它看成同样的类，也可以提高扩展性

代码案例

# 默认按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 不推崇限制你的语法，我们可以设计成鸭子类型，既让多个不同类对象具备相同的属性和方法，对于使用者而言，就可以以不变应万变，轻松地使用各种符合协议的对象

tips: markdown写博客还是挺爽的，真香~

附上使用Typora软件来写博客的快捷键参考博客，一起用起来吧~

markdown文件可以保存在本地，用编辑器打开即可看到效果，简单轻快，很多博客平台都是支持markdown格式的，所以其扩展性会很高（既可以本地化，又可以拥有扩展性，果断学起来，体验两天，比用博客园那个默认的编辑器给力呀，上手了写起来更快~）

在刚开始用的时候可以开个快捷键的网页在旁边要用什么了就看一眼快捷键，直接使用，多用几次就记住了。