类的封装
什么是封装，就是将复杂的丑陋的，隐私的细节隐藏到内部，对外提供简单的使用接口.
对外隐藏内部实现细节，并提供访问的接口。
为什么需要封装
两个目的
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 该装饰器用在获取属性的方法上
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.__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 # 使用是对象.函数名可以查看到属性
权限
学习了封装后