总结二十

封装

什么是封装

隐藏对象的属性和实现细节，仅对外提供公共访问方式

 

为什么需要封装

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

2.对外部隐藏实现细节，隔离复杂度

 

好处

1.将变化隔离

2.便于使用

3.提高复用性

4.提高安全性

 

什么时候应该封装

1.当有一些数据不希望外界可以直接修改时

2.当有一些函数不希望给外界使用时

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

class Person:
    de.__init__(self,id_name,name,ago)
    self.__id_number = id_number
    self.name = name
    self.age = age

p = Person('111111','Apple',18)

p.id_number = '123'

 

被封装的内容的特点：

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

    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*512)

# 通过函数访问内部封装的属性
print(d.get_buffer_size())
print(d.filename)

d.start_download()

 

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
    
    @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('不允许删除该属性')
        def self.__key
    
    # @property
    # def name(self):
    #     return self.__name
    #
    # @name.setter
    # def name(self,new_name):
    #     self.__name = new_name

a = A('jack',123)
print(a.name)
# print(a.get_key())

print(a.key)
a.key = 321
print(a.key)
# def a.key
# print(a.key)

a,name = 'xx'
print(a.name)

 

封装的实现原理，替换变量名称

 

python实现封装的原理

就是在加载类的时候，把\_\_替换成了 \_类名\__变量名称

python 一般不会强制要求程序必须怎样

class A:
    def __init__(self,key):
        self,__key = key

    @property
    def key(self):
        return self.__key
    
    @key.deleter
    def key(self):
        def self.__key

a = A('123')
# print(a.key)
# print(a.__dict__)

print(a._A__key)

a.__name = 1

print(a.__dict__)

# print('__key'.replace('_','_A__'))

 

property可以用来实现计算属性

计算属性指的是：实行的值，不能直接获得，必须通过计算才能获取

class Square:
    def __init__(self,width):
        self.width = width
        # self.area = self.width * self.width
    
    @property
    def area(self):
        return self.width * self.width

s = Square(10)

print(s.area)

s.width = 20

print(s.area)

s.width = 2
print(s.area)

 

接口

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

接口本质是一套协议标准，遵循这个标准的对象就能被调用

 

接口的目的就是为了提高扩展性：

例如，电脑提前指定指定一套USB接口协议，只要你遵循该协议，

你的设备就可以被电脑使用，不需要关系到底是鼠标还是键盘

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 = UDisk
pc(u)

 

在上述案例中，PC的代码一旦完成，后期无论什么样的设备，

只要遵循了USB接口协议，都能够被电脑所调用

接口主要是方便了对象的使用者，降低使用者的学习难度，

只要学习一套使用方法，就可以以不变应万变

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

 

抽象类

指的是包含抽象方法（没有函数体的方法）的类

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

'''
abc == abstract class
翻译为抽象类
抽象类的定义：
类中包含 没有函数体的方法
'''

import abc

class AClass(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def run(self):
        pass
    @abc.abstractmethod
    def runl(self):
        pass
    
class B(AClass):
    def run(self):
        print('runrunrun...')

b = B()

 

python一般不会限制你必须怎么写，一个优秀的程序员，就应该自觉遵守相关协议

所以有了鸭子类型这一说：如果这个对象张的像鸭子，走路像鸭子，那他就是鸭子

你只要保证你的类按照相关的协议类编写，也可以达到提高扩展性的目的

 

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

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

然而，python不推崇限制你的语法，我们可以设计成鸭子类型，

即让多个不同类对象具备相同的属性和方法

对于使用者而言，就可以以不变应万变，轻松的使用各种对象