面向对象三大特性之封装

1.初识封装

什么是封装

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

为什么需要封装

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

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

什么时候应该封装

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

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

封装的语法:需要封装的属性和方法前加__

# 封装的小例子
class Person:
    def __init__(self,name,age,id):
        self.name = name
        self.age = age
        self.__id = id  # 把id封装了

    def say_id(self):
        print('我的id是:%s'%self.__id)

p1 = Person('sxc',18,11111)
# print(p1.id)  # 外界无法访问
# print(p1.__id)  # 外界无法访问
p1.id = 555
print(p1.id)
p1.say_id()  # 外界无法修改

2.封装方法

封装的方法:需要封装的属性和方法前加__

被封装的内容的特点

　　1.外界不能直接访问

　　2.内部依然可以使用

模拟电脑开机的例子

# 模拟电脑的开机
class PC:
    def __init__(self,brand,price,color):
        self.brand = brand
        self.price = price
        self.color = color

    # def check_device(self):  # 封装前可以直接调用
    def __check_device(self):  # 封装后不可以在外部调用,可以在内部调用
        print("硬件检测1")
        print("硬件检测2")
        print("硬件检测3")
        print("硬件检测4")

    # def start_services(self):  # 封装前可以直接调用
    def __start_services(self):  # 封装后不可以在外部调用,可以在内部调用
        print("启动服务1")
        print("启动服务2")
        print("启动服务3")
        print("启动服务4")

    # def login(self):  # 封装前可以直接调用
    def __login(self):  # 封装后不可以在外部调用,可以在内部调用
        print("login....")
        print("login....")
        print("login....")

    # 定义一个打开电脑的方法,类比电源键
    def open(self):
        print('接通电源')
        self.__check_device()
        print("载入内核")
        print("初始化内核")
        self.__start_services()
        print("启动GUI")
        self.__login()

p1 = PC('apple',10000,'red')

# 比如未封装前要经历三步才能打开电脑
# p1.check_device()
# p1.start_services()
# p1.login()

# 封装之后只需经历一步就能打开电脑,就像按电源键一样
p1.open()

封装可以控制属性的权限

在python中只要两种权限

　　1.公开的,默认就是公开的

　　2.私有的,只能由当前类自己使用

3.在外界访问被封装的属性

类中的属性虽然被封装起来了,但是还是需要使用的,如果不使用就失去了意义

在外界是通过定义方法类完成对私有属性的修改和访问

对人的id的封装与修改

# 通过类中的方法即函数访问/修改/删除被封装的属性
class Person:
    def __init__(self,name,age,id):
        self.name = name
        self.age = age
        self.__id = id  # 把id封装起来

    def get_id(self):  # 获取id的方法
        return self.__id


    def set_id(self,new_id):  # 修改id的方法
        if type(new_id) == int:
            str_id = str(new_id)
            if len(str_id) == 7:
                self.__id = new_id
                print('新的id是%s'%self.__id)
                return
        print('请输入正确的id')

    def del_id(self):  # 删除id的方法
        del self.__id
        print('删除成功')

p1 = Person('sxc',18,1818299)
# print(p1.self.__id)  # id已被封装,外界不能直接访问

print(p1.get_id())  # 访问被封装的属性
p1.set_id('1818211')  # 可以判断修改的属性的对错
p1.set_id(1818211)  # 修改被封装的属性
p1.del_id()   # 删除被封装的属性
# print(p1.get_id())  # 已经删除,报错
print(p1.__dict__)  # 结果中没有id属性

在通过函数访问或者修改类内部封装的属性时可以做一些逻辑判断

4.property装饰器的使用和封装的原理

通过方法来访问或者修改属性时,我们必须使用调用方法的格式,但这却给使用者带来了麻烦

使用者必须知道哪些属性是普通属性,哪些是私有属性,然后再使用不同的方法调用他们,这对使用者不友好

这时候我们可以使用property装饰器来装饰,可以解决这个问题

装饰器的语法,有三个相关的装饰器

@property  # 用在获取被封装的属性的方法前

@属性名.setter  # 用在修改被封装的属性的方法前

@属性名.deleter  # 用在删除被封装的属性的方法前

注意:属性名是被property装饰的方法的名称,可以是任意的,但为了让使用者能方便的使用,默认使用原来的被封装的属性名,会在类的名称空间的内部创建一个对象,变量名就是函数名称,在使用.setter和.deleter方法时,必须保证使用对象的名称调用方法,所以是属性名.setter

刚才的例子的修改

# property装饰器的使用
class Person:
    def __init__(self,name,age,id):
        self.name = name
        self.age = age
        self.__id = id  # 把id封装起来

    @property
    def id(self):  # 获取id的方法
        return self.__id

    @id.setter
    def id(self,new_id):  # 修改id的方法
        if type(new_id) == int:
            str_id = str(new_id)
            if len(str_id) == 7:
                self.__id = new_id
                print('新的id是%s'%self.__id)
                return
        print('请输入正确的id')

    @id.deleter
    def id(self):  # 删除id的方法
        del self.__id
        print('删除成功')

p1 = Person('sxc',18,1818299)

print(p1.id)  # 访问被封装的属性
p1.id = 1111  # 可以判断修改的属性的对错
p1.id = 1818211  # 修改被封装的属性
del p1.id   # 删除被封装的属性
print(p1.__dict__)  # 结果中没有id属性

 

python实现封装的原理

在加载类的时候,将被封装的属性__双下划替换成了_类名__

# 封装的实现原理
class Person:
    def __init__(self,name,age,id):
        self.name = name
        self.age = age
        self.__id = id

p1 = Person('sxc',18,1818299)
print(p1.__dict__)
'''
输出结果是{'name': 'sxc', 'age': 18, '_Person__id': 1818299}
封装的__id本质是_Person__id,即内部帮我们做了'__id'.replace('__','_Person__')
'''
print(p1._Person__id)  # 这样就算封装了也能输出

5.计算属性

property可以用来实现计算属性

计算属性指的是:属性的值,不能直接获得,需要进行计算才能获得

例如通过正方形的边长求周长和面积

# 计算属性
# 计算一个正方形的周长和面积
class Square:
    def __init__(self,side):
        self.side = side

    @property
    def perimeter(self):
        square_perimeter = self.side *4
        return square_perimeter

    @property
    def area(self):
        area = self.side **2
        return area

s1 = Square(5)
print(s1.side)  # 调用属性
print(s1.perimeter)  # 可以像属性一样调用他的方法
print(s1.area)  # 可以像属性一样调用他的方法

6.接口类、抽象类和鸭子类型(了解)

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

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

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

# 生成一个接口类
class USB:
    def open(self):
        pass

    def read(self):
        pass

    def write(self):
        pass

    def close(self):
        pass

# 鼠标这个硬件要继承这个接口类
class Mouse(USB):
    def open(self):
        print('打开鼠标')

    def read(self):
        print('获取光标位置')

    def write(self):
        print('不支持该操作')

    def close(self):
        print('关闭鼠标')

# pc操作
def pc(usb_device):
    usb_device.open()
    usb_device.read()
    usb_device.write()
    usb_device.close()

m = Mouse()
pc(m)

抽象类

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

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

# 抽象类
import abc
class A(metaclass=abc.ABCMeta):
    @abc.abstractmethod  # 生成一个限制条件,他的子类必须要有run这个方法
    def run(self):
        pass


class B(A):
    def run(self):  # 子类拥有父类这个方法
        print('gogogogo!')

b = B()
b.run()

鸭子类型

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

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

然而,python不推崇限制程序员的语法,我们可以设计成鸭子类型,即让多个不同类和对象具备相同的属性和方法,对于使用者可以轻松的使用各种对象.

 22