类的封装

什么是封装，就是将复杂的丑陋的，隐私的细节隐藏到内部，对外提供简单的使用接口.

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

为什么需要封装

两个目的

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

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

什么时候封装

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

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

如何使用：

语法：

class Person:
    def __init__(self,id_number,name,age)
        self.__id_number = id_bunber
        self.name = name
        self.age = age
p = Person('11111111','nick',29)

p.id_number = '222'

class Person:
    def __init__(self,id_number,name,age):
        # 将隐私的属性隐藏起来
        self.__id_number = id_number
        self.name = name
        self.age = age

    def show(self):
        print(self.__id_number)
# 查看类中所有的方法        
print(Person.__dict__)  # {'__module__': '__main__', '__init__': <function Person.__init__ at 0x02785B70>, 'show': <function Person.show at 0x02785930>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
# 类属于哪个类型
print(Person.__class__)  # <class 'type'>

# 类的名字
print(Person.__name__)  # Person
# 打印对象的类
print(p.__class__)  # <class '__main__.Person'>
# 打印对象属于哪个类名
print(p.__class__.__name__)  # Person
        
# 实例化对象p        
p = Person('1111111','jack',39)

# 对象在python中是一快内存地址，通过.方法进行调用
print(p)  # <__main__.Person object at 0x02E4ED90>

# 对象的属性字典
print(p.__dict__)  # {'_Person__id_number': '1111111', 'name': 'jack', 'age': 39}
# 注意： '_Person__id_number': '1111111'，说明属性名已经改变


# 外部无法使用对象.属性查看属性
print(p.__id_number)  # 会报错

# 调用类内部查看属性的方法查看隐藏的属性
p.show()  # 1111111
# 但是：对象是具有属性和方法的结合体，通过方法查看属性不太好。会给使用者带来使用上的不便。

类的封装时将__属性名，变成了_类名__属性名，

# 外部无法直接通过.属性查看属性是因为在初始化属性名时，将__属性名变成了_类名__属性名，所以外部无法通过._属性名来查看属性。但是可以通过._类名__属性名来查看属性，所以类封装的本质就是将类的属性名变成一个另外属性名。
print(p._Person__id_number)  # 1111111

# 这是给类中的添加属性，而不是修改类中隐藏属性的值。
p.__id_number = 14598474 
print(p.__id_number)  # 14598474

# 封装类中的方法
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")
        print("硬件检测4")

    def __start_services(self):
        print('启动服务1')
        print('启动服务2')
        print('启动服务3')
        print('启动服务4')

    def __login(self):
        print("login....")
        print('login....')
        print('login...')


pc1 = PC(20000,'苹果','白色')
# 对象调用类中的方法
pc1.open()  # 可以打印出所有结果

# 封装类中的方法之后，无法直接进行调用
pc1.login()  # 报错 AttributeError: 'PC' object has no attribute 'login'

print(PC.__dict__)  # {'__module__': '__main__', '__init__': <function PC.__init__ at 0x02185B70>, 'open': <function PC.open at 0x02185930>, '_PC__check_device': <function PC.__check_device at 0x060D0C48>, '_PC__start_services': <function PC.__start_services at 0x060D0C90>, '_PC__login': <function PC.__login at 0x060D0CD8>, '__dict__': <attribute '__dict__' of 'PC' objects>, '__weakref__': <attribute '__weakref__' of 'PC' objects>, '__doc__': None}

# 在对类中的方法进行封装后，类中被封装的函数名发生了改变，由__函数名变成了_类名__函数名，但是可以在类内部进行调用，无法在类外部直接调用。

"""
这是一个下载器类，需要提供一个缓存大小这样的属性
缓冲大小不能超过内存限制
"""
# 如何访问被封装的属性
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)
d1 = Downloader('葫芦娃',"http://www.baidu.com",1024*1024*5)

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

# print(d1.get_buffer_size())
# print(d1.filename)
# d1.start_download()

# 修改的是对象的属性
d1.set_buffer_size(1024*1024*10)

d1.start_download()

print(d1.get_buffer_size())

被封装的内容的特点：

? 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('开始下载....')
        else:
            print('内部炸了')
    
    def set_buffer_size(self,size):
        # 可以在方法中添加额外的逻辑
        if not type(size) == int:
            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())

d.start_download()

这样一来，我们可以在外界修改这个关键数据时，做一些限制。

property装饰器

通过方法来修改或访问属性，本身没什么问题，但是这给对象的使用者带来了麻烦。

使用必须知道哪些是普通属性，哪些是私有属性，需要使用不同的方式来调用他们。

property装饰就是为了使得调用方式一致。

有三个装饰器

1.property   该装饰器用在获取属性的方法上
[email protected]  该装饰器用在修改属性的方法上
[email protected] 该装饰器用在删除属性的方法上


注意：key是被proper装饰的方法的名称  也就是属性的名称
内部会创建一个对象  变量名称就是函数名称
所以使用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('不允许删除该属性')
        del slef.__key
a = A("nick",123)
print(a.key)
a.key = 321
print(a.key)

python实现封装的原理

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

python一般不会强制要求程序必须怎么怎么怎么的。

封装：

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

好处是：

? 1.提供安全性

? 2.隔离复杂度

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

访问被隐藏的属性

? 提供用于访问和修改的方法

使用proper装饰器可以将一个方法围伪装成普通的属性，属性之间调用方法一致。

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

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._A__key)
# 为对象添加属性
a.__name = 1
# 打印对象的所有属性
print(a.__dict__)  # {'_A__key': '123', '__name': 1}

property可以用来实现计算属性

计算属性值的是：属性的值，不能直接获得，必须通过计算才能获取。例如：正方形的面积

class Square:
    def __init__(self,width):
        self.width = 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 USB:
    def open(self):
        pass
    def close(self):
        pass
    def read(self):
        pass
    def write(self):
        pass

class Mouse(USB):
    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.open()
    usb_device.open()
    usb_device.open()
    
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接口协议，都能被电脑所调用

接口主要是为了方便对象的使用者，降低使用者的学习难度，只要学习了一套使用方法，就可以以不变应万变。

问题：

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

抽象类

指的是包含抽象方法(没有函数体的方法)的类。

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

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("runrunrun....")

b = B()  # TypeError: Can't instantiate abstract class B with abstract methods run1

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

所以有了鸭子类型这么一说

如果这个对象长的像鸭子,走路像鸭子，那他就是鸭子

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

案例：

clss 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)

clss 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)

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

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

然而，python不推崇限制你的语法，我们可以设计成鸭子类型，既能让多个不同类对象具备相同的属性和方法，

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

封装：隐藏属性或方法，外部无法使用，内部可以使用，在类定义阶段就执行了，真的想引用，就使__类名或__属性名。

被封装的内容特点：

1.外界无法直接使用

2.内部依然可以使用

子类无法调用父类中的隐藏属性。

class Person():

    def __init__(self,id_num,name,age):
        # 隐藏隐私属性，无法更改
        self.__id_num = id_num
        self.name = name
        self.age = age

    def show(self):
        print(self.__id_num)

p = Person('11111111','nick',17)

# 增加属性
# p.__id_num = 222222  # 增加属性会直接访问增加的属性，没有会报错。
# 查看增加的属性
print(p.__id_num)  # 运行会报错，无法直接查看隐藏的属性
# 查看隐藏的属性
p.show()  # 打开隐藏的是属性

隐藏模块内部的函数/变量_x:from module import *(无法导入)，from module import _x(不合理)。

@property：被@property装饰的函数会将函数方法变成属性，也就是说直接.函数名，不需要加括号调用。

class Person():

    def __init__(self,id_num,name,age):
        # 隐藏隐私属性，无法更改
        self.__id_num = id_num
        self.name = name
        self.age = age
    @property  # 将函数变成属性
    def show(self):
        print(self.__id_num)

p = Person('11111111','nick',17)

# 增加属性
# p.__id_num = 222222
# 查看增加的属性
# print(p.__id_num)
# 查看隐藏的属性
# p.show()
p.show  # 使用是对象.函数名可以查看到属性

权限

学习了封装后