类的封装
什么是封装，就是将复杂的丑陋的，隐私的细节隐藏到内部，对外提供简单的使用接口.
对外隐藏内部实现细节，并提供访问的接口。
为什么需要封装
两个目的
1.为了保证关键数据的安全性
2.对外部隐藏实现细节，隔离复杂度
什么时候封装
当有一些数据不希望外界可以直接修改时，
当有一些函数不希望给外界使用时。
如何使用：
语法：
class Person: def __init__(self,id_number,name,age) self.__id_number = id_bunber self.name = name self.age = agep = 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__': , 'show': , '__dict__': , '__weakref__': , '__doc__': None}# 类属于哪个类型print(Person.__class__) # # 类的名字print(Person.__name__) # Person# 打印对象的类print(p.__class__) # # 打印对象属于哪个类名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__': , 'open': , '_PC__check_device': , '_PC__start_services': , '_PC__login': , '__dict__': , '__weakref__': , '__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 该装饰器用在获取属性的方法上2.@key.setter 该装饰器用在修改属性的方法上3.@key.deleter 该装饰器用在删除属性的方法上注意：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.__keya = A("nick",123)print(a.key)a.key = 321print(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.__keya = 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.widths = Square(10)print(s.area)s.width = 20print(s.area)s.width = 2print(s.area)
接口 了解
接口时一组功能的集合，但是接口中仅包含功能的名字，不包含具体的实现代码。接口本质就是一套协议标准，遵循这个标准的对象就能被调用
接口目的就是为了提高扩展性
例如电脑提前指定了一套USB接口协议，只要你遵循该协议，你的设备就可以被电脑使用，不需要关系到底时鼠标还是键盘。
案例：
class USB: def open(self): pass def close(self): pass def read(self): pass def write(self): passclass 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 abcclass AClass(metaclass=abc.ABCMeta): @abc.abstractmethod def run(self): pass @abc.abstractmethod def run1(self): passclass 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 # 使用是对象.函数名可以查看到属性 权限
学习了封装后