类的封装

封装

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

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

为什么需要封装

两个目的

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

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

 

什么时候应该封装

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

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

class Person:
    def __init__(self,id_num,name,age):
        self.__id_num = id_num
        self.name = name
        self.age = age
    def func(self):
        print(self.__id_num)


p = Person(1231313,"egon",12)
# 对象不能直接访问，
# print(p.id_num)  # 'Person' object has no attribute 'id_num'
p.func() # 内部还是可以访问

被封装的内容的特点:

1.外界不能直接访问

2.内部依然可以使用

权限

学习了封装后就可以控制属性的权限

在python只要两种权限,

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

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

在外界访问私有的内容

属性虽然被封装了,但是还是需要使用的,在外界如何访问

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

class Downloader:
    def __init__(self,name,age,id_card):
        self.name = name
        self.age = age
        self.__id_card = id_card  # 定义私有属性

    def chock_id_card(self): # 定义方法来访问私有属性
        print(self.__id_card)

    def set_id_card(self,new_id_card):  # 定义方法，来修改私有属性
        if type(new_id_card) == int:
            self.__id_card = new_id_card
        else:
            print("你输入的不是整形")


d = Downloader("egon",12,12312312313)
d.chock_id_card()
d.set_id_card(11111111111111111111)
d.chock_id_card()
d.set_id_card("asdasd")
d.chock_id_card()

property装饰器

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

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

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

有三个相关的装饰器

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


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

class A:
    def __init__(self,name,age,hobby):
        self.name = name
        self.age = age
        self.__hobby = hobby
        self.__func()

    def __func(self):
        print("----func-----")

    @property  # 有了这个装饰器，就相当于把这个函数，变为了一个属相
    def check(self):  # 注意，每个装饰器装饰的函数，函数名必须相同
        return self.__hobby

    @check.setter
    def check(self,new_hobby):  # 注意，每个装饰器装饰的函数，函数名必须相同
        self.__hobby = new_hobby
        print(self.__hobby)
    @check.deleter  # 注意，每个装饰器装饰的函数，函数名必须相同
    def check(self):
        del self.__hobby
        # print(self.__hobby)


a = A("egon",12,"play")

print(a.check)  # 我们在调用的时候就把他当做一个属性来就好了，它支持属性的。删除修改查询
a.check = "read"
print(a.check)

python实现封装的原理

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

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

所以我们每次访问的属性名是不存在的

都会报错，属性名不存在的错误

 

封装:

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

好处:

1.提高安全性

2.隔离复杂度

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

访问被隐藏的属性:

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

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

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

property 计数属性

 

# 练习: 定义一个类叫做person
# 包含三个属性 身高 体重   BMI
# BMI的值需要通过计算得来 公式   体重 / 身高的平方

class Person:
    def __init__(self,sg,tz):
        self.sg = sg
        self.tz = tz
    @property
    def bmi(self):
        return self.sg/(self.tz*self.tz)


p = Person(175,140)
print(p.bmi)
p.sg = 120
print(p.bmi)
p.tz = 120
print(p.bmi)

接口 了解

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

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

 

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

例如电脑提前指定制定一套USB接口协议,只要你遵循该协议,你的设备就可以被电脑使用,不需要关心到底是鼠标还是键盘

# 定义一个类的流程
class Mouse:
    def open(self):
        print("开机")

    def close(self):
        print("关机")

    def read(self):
        print("读取")

    def write(self):
        print("写入")

# 创建一个实例对象
m = Mouse()

# 定义一个pc端的接口
# 也就是顶一个函数，将上面类的是咧对象传入函数中
# 我们定义的类只要是按照我们函数定义的协议来写，就可以成功调用
# 如果，没有就无法调用
def pc(n):
    n.open() # 函数内的方法，必须要一一对应类中的方法
    n.close()
    n.read()
    n.write()

pc(m)  # 将类的实例对象传入pc函数接口

 

最后: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不推崇限制你的语法, 我们可以设计成鸭子类型,既让多个不同类对象具备相同的属性和方法

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

 

抽象类

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

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

import abc  #导入包abc 

class AClass(metaclass=abc.ABCMeta):  # 参数metaclass=abc.ABCMeta

    @abc.abstractmethod
    def run(self):
        pass
    @abc.abstractmethod
    def run1(self):
        pass


class B(AClass):

    def run(self):
        print("runrunrurn...")

    def run1(self):
        print("asdadasd")

b = B()
# 当父类中定义了抽象类，子类就必须定义抽象类，否者就会报错

　　

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

转载于:https://www.cnblogs.com/cherish937426/p/11251063.html