封装
1.什么是封装
就是将复杂的丑陋的,隐私的细节隐藏到内部,对外提供简单的使用接口
对外隐藏内部实现细节,并提供访问的接口
2.为什么需要封装
有两个目的：
1.为了保证 关键数据的安全性
2.对外部隐藏实现细节,隔离复杂度
3.什么时候应该封装
当有一些数据不希望外界可以直接修改时
当有一些函数不希望给外界使用时
4.如何使用封装
在需要封装的属性前加双下划线__
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("1111111111111", "jack", 29) p.__id_number = "222" # 无法修改内部的__id_number了，因为被封装了 print(p.__id_number) p.show_id()
也可以封装内部的方法，外部也无法直接访问，内部依然可以使用
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() # 无法使用
5.被封装的内容的特点
1.外界不能直接访问
2.内部依然可以使用
6.权限
学习了封装后就可以控制属性的权限，在python只有两种权限：
1.公开的：默认就是公开的
2.私有的：只能由当前类自己使用
7.如何在外界访问私有的内容
属性虽然被封装了,但是还是需要使用的,在外界如何访问
可以通过定义方法来完成对私有属性的修改和访问,这样一来我们可以在外界修改这个关键数据时,做一些限制
""" 这是一个下载器类,需要提供一个缓存大小这样的属性 缓存大小不能超过内存限制 """ 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()
8.property装饰器（获取）
通过方法来修改或访问属性,本身没什么问题,但是这给对象的使用者带来了麻烦,使用者必须知道哪些是普通属性,哪些是私有属性,需要使用不同的方式来调用他们
property装饰器就是为了使得调用方式一致
class A: def __init__(self,name,key): self.name = name self.__key = key @property # 使用装饰器把方法变成属性来调用 def key(self): return self.__key a = A("jack",123) print(a.name) print(a.key) # 这样就实现了看似不调用方法就可以访问属性
还有setter装饰器和deleter装饰器（修改和删除）
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) a.key = 321 # 可以直接通过属性修改了 print(a.key) # 修改成功 del a.key # 删除 print(a.key) # 报错，已经被删除
注意：key是被property装饰的方法的名称 也就是属性的名称
内部会创建一个对象 变量名称就是函数名称
所以在使用setter和deleter时 必须保证使用对象的名称取调用方法
所以是 key.setter
9.python实现封装的原理
就是在加载类的时候,把 __ 替换成了 _类名__
class A: def __init__(self,key): self.__key = key a = A(100) print(a._A__key) # 封装原理上就是把变量名改了
10.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)
接口
接口是一组功能的集合,但是接口中仅包含功能的名字,不包含具体的实现代码
接口本质是一套协议标准,遵循这个标准的对象就能被调用
接口目的就是为了提高扩展性
1.例如：
电脑提前指定制定一套USB接口协议,只要你遵循该协议,你的设备就可以被电脑使用,不需要关心到底是鼠标还是键盘
# USB接口 class USB: def open(self): pass def close(self): pass def read(self): pass def write(self): pass # 电脑使用USB接口 def pc(usb_device): usb_device.open() usb_device.read() usb_device.write() usb_device.close() # 鼠标 class Mouse: def open(self): print("鼠标开机.....") def close(self): print("鼠标关机了...") def read(self): print("获取了光标位置....") def write(self): print("鼠标不支持写入....") # 鼠标对象 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)
在上述案例中,PC的代码一旦完成,后期无论什么样的设备,只要遵循了USB接口协议,都能够被电脑所调用
接口主要是方便了对象的使用者,降低使用者的学习难度,只要学习一套使用方法,就可以以不变应万变
2.问题：
如果有一个设备没有按照你的协议来设计,也没办法限制他,将导致代码无法运行
# USB接口 class USB: def open(self): pass def close(self): pass def read(self): pass def write(self): pass # 电脑使用USB接口 def pc(usb_device): usb_device.open() usb_device.read() usb_device.write() usb_device.close() # 不遵守协议的U盘 class UDisk: def start(self): print("U盘启动了...") def end(self): print("U盘关闭了...") def read_data(self): print("读出数据") def write_data(self): print("写入数据") u = UDisk() pc(u) # 报错
如何解决？
抽象类
1.定义：
指的是类中包含抽象方法(没有函数体的方法)的类
class AClass: def run(self): pass # 没有函数体代码
2.作用：
可以限制子类必须去定义类中的抽象方法
3.abc模块
abc不是随意取的，而是单词的缩写：abstract class，翻译为抽象类
import abc class AClass(metaclass=abc.ABCMeta): @abc.abstractmethod # 定义抽象方法 def run(self): pass class B(AClass): pass b = B() # 报错，无法实例化 # 子类要想实例化，必须要重写抽象方法run
子类要想实例化，必须要重写抽象方法run
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") def run1(self): # 必须重写父类中的抽象方法 print("run1") b = B() # 实例化成功
这样就可以强制U盘遵守协议，否则无法运行
鸭子类
python一般不会限制你必须怎么写,作为一个优秀的程序员,就应该自觉遵守相关协议
所以有了鸭子类型这么一说：
如果这个对象长得像鸭子,走路像鸭子,那就他是鸭子
就是如果多个类中的对象，它们拥有相同的特征和行为，那么可以把它们们看为是同一类
你只要保证你的类按照相关的协议来编写,也可以达到提高扩展性的目的
总结
接口是一套协议规范,明确子类们应该具备哪些功能
抽象类是用于强制要求子类必须按照协议中规定的来实现
然而,python不推崇限制你的语法,我们可以设计成鸭子类型,即让多个不同类对象具备相同的属性和方法
对于使用者而言,就可以以不变应万变,轻松的使用各种对象