面向对象之封装/鸭子类型

一.封装

1.1什么是封装

　　封装就是将复杂的丑陋的隐私的东西隐藏到内部,对外部提供简单使用的接口.也可以说成(对外隐藏内部实现细节,并提供访问接口)

1.2为什么要用封装

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

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

1.3什么时候要用到封装

　　1.当有些数据不希望被直接修改的时候(属性)

　　2.有一些函数不希望被外界使用(技能)

2.1如何使用封装

使用方式:在属性名或者技能名前添加双下划线,内部是实现原理为,在你输入后,在类的定义阶段进行改名将其改成_类名__属性名/技能名的形式

lass People:
    def __init__(self,name,id,sex,age):
        self.name=name
        self.age=age
        self.__id=id
        self.sex=sex
    def shou_id(self):  # 查看私有数据
        return self.__id

p1=People('zhang',111111,'man',19)
p1.id
#报错信息为 AttributeError: 'People' object has no attribute 'id'p1.__id
#报错信息为AttributeError: 'People' object has no attribute '__id'
p1.id=2222
print(p1.id)  # 2222
print(p1.shou_id())  # 111111
p1.__id=22222
print(p1.__id)  # 22222
print(p1.shou_id())  # 11111
#上述两种方式就是一种为对象p1重新添加了一个属性,原本的属性还是没有被改变
p1._People__id=333
print(p1.shou_id())  # 333
# 所谓的隐藏就是将属性名重新命名方式为_类名__属性名,可以通过这个去访问修改

ps:

被封装内容的特点:
    1.外界不能直接访问(属性名被更改)
    2.内部依然可以使用(接口)

2.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("开始下载....")
            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.baicu.com",1024*1024)


# 通过函数取修改内部封装的属性
d.set_buffer_size(1024*512)

# 通过函数访问内部封装的属性
print(d.get_buffer_size())

d.start_download()

封装可以明确地区分内外，封装的属性可以直接在内部使用，而不能被外部直接使用，然而定义属性的目的终归是要用，外部要想用类隐藏的属性，需要为其提供接口，让外部能够间接地使用到隐藏起来的属性，那这么做的意义何在?

答:可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

三.property装饰器

3.1什么时property

　　property是一个装饰器,将一个方法伪装成普通属性,其特殊之处在于该方法会在修改值得时候自动执行

3.2为什么要用property

　　当我们将一个属性设置为私有后就无法直接访问他们了,需要为他们创建两个方法,一个用于访问一个用于修改,但是对使用者而言,私有的和普通的都是属性,然而一个可以用点来访问,用等号来修改,另一个却要调用函数来存取,这样就做不到统一,所以就需要property装饰器了

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)
print(a.key)  
a.key = 321
print(a.key)  
a.key=9
print(a.key)  

a = A("jack", 123)
print(a.key)
del a.key
print(a.key)

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

3.3计算属性

计算属性指的是:属性的值,不能直接获得,必须通过计算才能获取如计算

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property
    def bmi(self):
        return self.weight / (self.height**2)

p1=People('zhang',62,1.69)
print(p1.bmi)

四.接口

4.1什么是接口

　　接口是一组功能的结合体,但是接口中仅包含功能的名字,不包含具体的代码,接口的本质是一套协议标准,遵循这个标准的对象就能被调用

4.2为什么要用接口

　　是为了提高扩展性

接口的使用案例:

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.read()
    usb_device.write()
    usb_device.close()

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)
"""
键盘开机.....
获取了按键字符....
可以写入灯光颜色....
键盘关机了...

"""

ps:在上述案例中,PC的代码一旦完成,后期无论什么样的设备 只要遵循了USB接口协议,都能够被电脑所调用 接口主要是方便了对象的使用者,降低使用者的 学习难度,只要学习一套使用方法,就可以以不变应万变 .

4.3抽象类

抽象类指的是包含抽象方法(没有函数体的方法)的类,其作用是可以限制子类必必须定义父类中的抽象方法对于使用者而言,只要知道抽象类中的方法,就可以无差别的使用,这个抽象类的任何子类,大大降低了使用成本!

import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的写入方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的写入方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的写入方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家的使用方法时完全一致的,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

4.4鸭子类型

什么是鸭子类型:即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子.

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass