封装

1.封装

　　对外隐藏内部实现细节,并提供访问接口

　　封装是为了保证关键数据的安全性.  对外部隐藏实现细节,隔离复杂度

　　什么时候应该封装: 当有一些数据不希望外界直接修改时,当有一些函数不希望给外界使用时

python中只有两种权限

　　公开的,默认公用,   私有的,只能由当前类使用

在外界访问私有的内容

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

# 被封装的内容外界不能直接访问, 内部依旧可以使用
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('1111','jack',20)
print(p._Person__id_number)   # 1111  隐藏到内部的实质是将属性名称前加_类名__
p.__id_number = '22'
print(p.__id_number)   # 22
p.show_id()   #  1111

封装函数属性实例

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('初始化内核')
        self.__start_services()
        print('启动GUI')
        self.__login()
    def __check_device(self):
         print('硬件检测1')
         print('硬件检测2')
         print('硬件检测3')
    def __start_services(self):
        print('启动服务1')
        print('启动服务2')
        print('启动服务3')
    def __login(self):
        print('login')
        print('login')
        print('login')
pc1 = PC(2000,'香蕉','黄色')
pc1.open()   
#  接通电源
硬件检测1
硬件检测2
硬件检测3
载入内核
初始化内核
启动服务1
启动服务2
启动服务3
启动GUI
login
login
login

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('开始下载')
        else:
            print('内存炸了')
    def set_buffer_size(self,size):
        if not type(size) == int:
            print('缓冲区为整形')
        else:
            print('缓冲区大小修改成功')
    def get_buffer_size(self):
        return self.__buffer_size
d = Downloader('葫芦娃','http://www.baidu.com',1024*1024)
d.set_buffer_size(1024*512)   # 缓冲区大小修改成功
print(d.get_buffer_size())     # 524288
print(d.filename)    # 葫芦娃
d.start_download()   # 开始下载

property 装饰器

　　通过方法来修改或访问属性,使用者必须知道哪些是普通属性,哪些是私有属性,需要使用不同方法调用,  property 装饰之后, 使调用方式一致

class A:
    def __init__(self,name,key):
        self.__name = name
        self.__key = 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.key)  # 123
a.key = 321   # key 必须小于等于100
print(a.key)    # 123
del a.key    # 不允许删除该属性

有三个相关的装饰器

　　@property    该装饰器用在获取属性的方法上

　　@key.setter   该装饰器用在修改属性的方法上

　　@key.deleter  该装饰器用在删除属性的方法上

注意: key 是被property装饰方法的名称, 也是属性名称

　　内部创建一个对象,变量名称就是函数名称,  所以在使用setter和deleter时,必须保证使用对象的名称去调用方法

python 实现封装的原理

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

　　封装: 对外部隐藏内部的实现细节. 并提供访问接口

　　好处: 提高安全性    隔离复杂度

　　语法: 将要封装的方法或属性名称前加双下划线

　　访问被隐藏的属性, 提供用于访问或修改的方法, 使用property装饰器可以将一个方法伪装成普通的属性,保证属性之间方法一致

封装的原理:  替换变量名称

property 可以用来实现计算属性

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

接口

　　接口是一种功能的集合,但是接口中仅包含功能的名字,不包含具体的实现代码

　　接口本质是一套协议标准,遵循这个标准的对象就能被调用, 接口目的就是为了提高扩展性

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)
#鼠标开机
获取光标位置
鼠标不支持写入
鼠标关机

　　电脑提供USB接口,可以使用任何遵循USB接口协议的设备

抽象类

　　类中的方法是不具体, 这个类也是抽象的, 抽象类可以实现强制性要求子类必须实现父类声明的方法, 一个类是抽象类的子类,那么他必然实现了抽象类中的方法,对于使用者而言,只要知道抽象类中的方法,就可以无差别的使用这个抽象类的任何子类,大大降低了使用成本!

abc 是abstract class单词的缩写, 翻译为抽象类
抽象类的定义: 类中包含没有函数体的方法

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('run')

鸭子类型

　　Python崇尚鸭子类型

class Tex:
    def read(self):
        pass
    def write(self):
        pass
class Disk:
    def read(self):
        pass
    def write(self):
        pass

　　接口是一套协议规范,明确子类们应该具备哪些功能

　　抽象类是用于强制要求子类必须按照协议中规定的来实现

　　然而,python不推崇限制你的语法, 我们可以设计成鸭子类型,既让多个不同类对象具备相同的属性和方法, 对于使用者而言,就可以以不变应万变,轻松的使用各种对象