封装

封装

一、封装的概念

​ 将复杂丑陋的，隐私的细节隐藏到内部，对外提供简单的使用接口

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

二、为什么需要封装

​ 1、为了保证，关键数据的安全性

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

三、什么时候应该封装

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

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

四、如何使用

class Person:
    def __init__(self, id_number, name, age)
    	self.__id_number = number
        self.name = name
        self.age = age
p = Person("321084199502150624","marry",23)

p.id_number = "222"

五、被封装的内容的特点

​ 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

d = Downloader("葫芦娃","http://....",1024*1024)
# 通过函数修改内部封装的属性    
d.set_buffer_size(1024*512)
# 通过函数访问内部封装的属性
print(d.get_buffer_size())

d.start_download()
# 这样一来我们可以在外界修改这个关键数据时，做一些修改

八、property装饰器

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

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

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

有三个相关的装饰器

1.property  用在获取属性的方法上
2.@key.setter 用在修改属性的方法上
3.@key.deleter 用在删除属性的方法上

注意：key是被property装饰的方法的名称 也就是属性的名称
内部会创建一个对象，变量名就是函数名称
所以在使用setter和deleter时，必须保证使用对象的名称去调用方法
所以是key.setter

案例：

class A:
    def __init__(self, naem, key)：
		self.__name = naem
        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)
a.key = 321
print(a.key)

九、封装

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

好处：

​ 1、提高安全性

​ 2、隔离复杂度

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

访问被隐藏的属性：

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

使用property装饰器可以将一个方法伪装成普通顺属性,报纸属性之间调用方法一致

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

十、python实现封装的原理

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

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

十一、property可以用来实现计算属性

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

例如:正方形求面积

十二、接口（了解）

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

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

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

例如电脑提前指定一套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.read()
    usb_device.write()
    usb_device.close()

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接口协议,都能够被电脑所调用

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

问题:

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

十三、抽象类

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

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

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

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

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

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

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