OOP的三大特征之封装(****),类属性装饰器以及封装原理,abc模块的使用,抽象类

今日内容:

 

封装:

---

 

什么是封装?

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

为什么要封装?

• 两个目的:
  • 1.为了保证关键数据的安全性
  • 2.对外隐藏实现细节,隔离复杂度

什么时候应该封装?

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

如何使用(语法):

# 封装的基本使用
class Person:

    def __init__(self,id_number,name,age):
        self.__id_number = id_number
        self.name = name
        self.age = age

    def show_id(self):
        print(self.__id_number)

p = Person('111111','jack',20)
p.id_number = '222222'
print(p.__id_number)  # 222222

被封装的内容的特点:

• 1.外界不能直接访问
• 2.内部依然可以使用

权限:

---

 

定义:

• 学习了封装后就可以控制属性的权限

在python只有两种权限:

• 1.公开的,默认就是公开的
• 2.私有的,只能由当前类自己使用

在外界访问私有的内容:

• 属性虽然被封装了,但是还是需要使用的
• 在外界可以通过定义方法类完成对私有属性的修改和访问

# 封装方法
class PC:
    def __init__(self,price,kind,color):
        self.price = price
        self.kind = kind
        self.color = color
        
    def __open(self):
        print('接通电源')
        self.__check_device()
        print('硬件检测')
        print('载入内核')
        print('初始化内核')
        self.__start_services()
        print('启动服务')
        print('启动GUI')
        self.__login()
        
    def __check_device(self):
        print('硬件检测')
        
    def __start_services(self):
        print('启动服务')
        
    def __login(self):
        print('login...')
        
pc1 = PC(20000,'弟弟牌','red')
pc1.open()      

# 如何访问被封装的属性
# 下面是一个下载器类,需要提供一个缓存大小这样的属性,且缓存大小不能超过内存限制
class Downloader:
    def __init__(self,filename,url,buffer_size):
        self.filename = filename
        self.url = url
        self.__buffer_size = buffer_size
        
    def start_download(self):
        if self.__buffer_size <= 1024*1024:
            print('开始下载...')
            print('当前缓冲器大',self.__buffer_size)
        else:
            print('内存炸了...')
            
    def set_buffer_size(self,size):
        # 可以在方法中添加额外的逻辑
        if not type(size) == int:
            print('缓冲区必须是整型!')
        else:
            print('缓冲区大小修改成功!')
        self.__buffer_size = size
        
    def get_buffer_size(self):
       return self.__buffer_size
            
d = Downloader('葫芦娃','http://www.baidu.com',1024*1024)
​
# 通过函数获取修改内部封装的属性
d.set_buffer_size(1024*1024 / 2)
​
# 通过函数访问内部封装的属性
print(d.get_buffer_size())
​
d.start_download()          

总结:这样一来我们可以在外界修改这个关键数据时,做一些限制

property装饰器:

---

 

定义:

• 通过方法来修改或访问属性,本身没什么问题,但是这给对象的使用者带来了麻烦
• 使用者必须知道哪些是普通属性,哪些是私有属性,需要使用不同的方式来调用他们
• property装饰器就是为了使用调用方式一致

有三个相关的装饰器:

# 1.@property 该装饰器用在获取属性的方法上
# 2.@key.setter 该装饰器用在修改属性的方法上
# 3.@key.deleter 该装饰器用在删除属性的方法上
​
'''
注意:
key是被property装饰的方法的名称,也就是属性的名称
内部会创建一个对象,变量名称就是函数名称
所以在使用setter和deleter方法时,必须保证使用对象的名称获取调用方法
所以是key.setter
'''

# property装饰器
class A:
    def __init__(self,name,key):
        self.name = name
        self.key = key
        
    def get_key(self):
        return self.__key
    
    def set_key(self,new_key):
        self.__key = new_key
    
    @property
    def key(self):
        return self.__key
    
    @key.setter
    def key(self,new_key):
        if new_key <=100:
            self.__key = new_key
        else:
            print('key必须小于等于100')
            
    @key.deleter
    def key(self):
        print('不允许删除该属性!')
        del self.__key
        
a = A('jack',123)
print(a.name)
​
print(a.key) 

python实现封装的原理:

---

 

定义:

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

注意:python一般不会强制要求程序必须怎么样

class A:
    def __init__(self,key):
        self.__key = key
        
    @property
    def key(self):
        return self.__key
    
    @key.deleter
    def key(self):
        del self.__key
​
a = A('123')
print(a.key)  # 报错
print(a.__dict__)  # {'_A__key':'123'}
print(a._A__key)  # 123
​
print('__key'.replace('__','_A__'))  # 原理大概就是这段代码

property可以用来实现计算属性:

---

 

定义:

• 计算属性指的是:属性的值,不能直接获得,必须通过计算才能获取

例如:正方形求面积

class Square:
    def __init__(self,width):
        self.width = width
        # self.area = self.width * self.width 如果area方法上方没有@property,那么就需要增加这段代码,且area方法中不会返回self.width * self.width计算方法,直接为pass
    
    @property
    def area(self):
        return self.width * self.width
        
s = Square(10)
print(s.area)  # 100
s.width = 20
print(s.area)  # 400

练习:

• 定义一个类叫做person
• 包含三个属性:身高,体重,BMI
• BMI的值需要通过计算得到,公式为BMI = 体重/身高的平方（kg/㎡）

接口类:

---

 

定义:

• 接口是一组功能的集合,但是接口中仅包含功能的名字,不包含具体的实现代码
• 接口本质上是 一套协议标准,遵循这个标准的对象就能被调用
• 接口的目的就是为了提高程序的扩展性

例如:电脑提前指定制定一套USB接口协议,只要你遵循该协议,你的设备就可以被电脑使用,不需要关系到底是鼠标还是键盘

# 接口的使用
class USB:
    def open(self):
        pass 
    def close(self):
        pass
    def read(self):
        pass
    def wirte(self):
        pass
    
class Mouse(USB):
    def open(self):
        print('鼠标开机了....')  
    def close(self):
        print('鼠标关机了....')
    def read(self):
        print('获取了光标位置....')
    def wirte(self):
        print('鼠标不支持写入....')
        
class pc(usb_devices):
    usb_devicie.open()
    usb_devicie.close()
    usb_devicie.read()
    usb_devicie.write()
    
m = Mouse()
# 将鼠标传给电脑
pc(m)
​
class KeyBoard(USB):
    def open(self):
        print("键盘开机.....")
    def close(self):
        print("键盘关机了...")
    def read(self):
        print("获取了按键字符....")
    def write(self):
        print("可以写入灯光颜色....")
​
# 来了一个键盘对象
k = KeyBoard()
pc(k)

总结:

• 在上述案例中,PC的代码一旦完成,后期无论什么样的设备,只要遵循USB接口协议,你的设备就都可以被电脑调用
• 接口主要是方便了对象的使用者,降低使用者的学习难度,只要学习一套使用方法,就可以以不变应万变

注意:

• 如果子类没有按照你的协议来设计,也没办法限制他,将导致代码无法运行

拓展知识点:abc模块的使用

---

 

# abc不是随便取得,而是单词的缩写,abstract class抽象类
import abc
​
class AClass(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def run(self):
        pass
    
class B(AClass):
    def run(self):
        print('xxxxxxx...')
​
b = B()
# 一直到最后都没有问题,可以实现用抽象方法run实例化抽象类B

import abc
​
class AClass(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def run(self):
        pass
    @abc.abstractmethod
    def run1(self):
        pass
​
class B(AClass):
    def run(self):
        print("runrunrurn...")
​
b = B()
# 报错,TypeError: Can't instantiate abstract class B with abstract methods run1

抽象类:

---

 

抽象类的定义:

• 指的是包含抽象方法(没有函数体的方法)的类,用于强制要求子类必须按照协议中的规定来实现

作用:

• 可以限制子类必须类中定义的抽象方法

总结:

• python一般不会限制你必须怎么写,作为一名优秀的程序员,就应该自觉遵守相关协议,所有才有了鸭子类型这种说法
• 如果这个对象长得像鸭子,走路也像鸭子,那他就是鸭子
• 你只要保证你的类是按照相关的协议类编写,也可以达到提高扩展性的目的

案例:

class Mouse:
    def open(self):
        print("鼠标开机.....")
    def close(self):
        print("鼠标关机了...")
    def read(self):
        print("获取了光标位置....")
    def write(self):
        print("鼠标不支持写入....")
​
    def pc(usb_device):
        usb_device.open()
        usb_device.read()
        usb_device.write()
        usb_device.close()
​
# 来了一个鼠标对象
m = Mouse()
# 将鼠标传给电脑
pc(m)
​
class KeyBoard:
    def open(self):
        print("键盘开机.....")
    def close(self):
        print("键盘关机了...")     
    def read(self):
        print("获取了按键字符....")  
    def write(self):
        print("可以写入灯光颜色....")
        
# 来了一个键盘对象
k = KeyBoard()
# 将键盘传给电脑
pc(k)
​
class UDisk:
    def open(self):
        print("U盘启动了...")
    def close(self):
        print("U盘关闭了...")
    def read(self):
        print("读出数据...")
    def write(self):
        print("写入数据...")
​
# 来了一个U盘对象
u = UDisk()
# 将U盘传给电脑
pc(u)