• 封装


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

    dayehui
  • 相关阅读:
    c 概念详解
    c 目录
    win文件操作
    使用panads处理数据
    冒泡排序
    notepad++搭建python环境
    继承方法-->一级一级继承
    原型问题2—原型对象的替换
    原型问题1—原型对象的替换
    js继承——扩展Object方式实现继承
  • 原文地址:https://www.cnblogs.com/zrh-960906/p/11251656.html
Copyright © 2020-2023  润新知