day27--多态封装反射
Posted _慕
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了day27--多态封装反射相关的知识，希望对你有一定的参考价值。
一、多态
多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）
import abc class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 @abc.abstractmethod def talk(self): pass class People(Animal): #动物的形态之一:人 def talk(self): print(\'say hello\') class Dog(Animal): #动物的形态之二:狗 def talk(self): print(\'say wangwang\') class Pig(Animal): #动物的形态之三:猪 def talk(self): print(\'say aoao\')
多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。（取决于是哪个具体的对象调用了那个函数名）
在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。
>>> def func(animal): #参数animal就是对态性的体现 ... animal.talk() ... >>> people1=People() #产生一个人的对象 >>> pig1=Pig() #产生一个猪的对象 >>> dog1=Dog() #产生一个狗的对象 >>> func(people1) say hello >>> func(pig1) say aoao >>> func(dog1) say wangwang #综上我们也可以说，多态性是‘一个接口（函数func）
多态性优点：
1.增加了程序的灵活性
以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)
2.增加了程序额可扩展性
通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用
>>> class Cat(Animal): #属于动物的另外一种形态：猫 ... def talk(self): ... print(\'say miao\') ... >>> def func(animal): #对于使用者来说，自己的代码根本无需改动 ... animal.talk() ... >>> cat1=Cat() #实例出一只猫 >>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能 say miao \'\'\' 这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1) \'\'\'
二、封装
从封装本身的意思去理解，封装就好像是拿来一个麻袋，把超市买来的一堆零食起装进麻袋，然后把麻袋封上口子。你不知道里面到底装的是什么好吃的（片面的理解）。
封装其实分为两个层面，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口（接口可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口，并且我们可以在接口的实现上附加更多的处理逻辑，从而严格控制使用者的访问）
第一个层面的封装（什么都不用做）：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装
注意：对于这一层面的封装（隐藏），类名.和实例名.就是访问隐藏属性的接口
第二个层面的封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。
在python中用双下划线的方式实现隐藏属性（设置成私有的）
类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：
class A: __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N def __init__(self): self.__X=10 #变形为self._A__X def __foo(self): #变形为_A__foo print(\'from A\') def bar(self): self.__foo() #只有在类内部才可以通过__foo的形式访问到.
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
注意：对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了。
python并不会真的阻止你访问私有的属性，模块也遵循这种约定，如果模块名以单下划线开头，那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的。
三、反射
自省给与你，程序员，某种能力来进行像\'手工类型检查\'的工作，它也被称为反射。主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）
python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
判断object中有没有一个name字符串对应的方法或属性
有则返回True 没有返回False
def getattr(object, name, default=None): # known special case of getattr """ getattr(object, name[, default]) -> value Get a named attribute from an object; getattr(x, \'y\') is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn\'t exist; without it, an exception is raised in that case. """ pass 得到的是相应的内存地址 default 为指定报错内容（字符串形式）
def setattr(x, y, v): # real signature unknown; restored from __doc__ """ Sets the named attribute on the given object to the specified value. setattr(x, \'y\', v) is equivalent to ``x.y = v\'\' """ pass
def delattr(x, y): # real signature unknown; restored from __doc__ """ Deletes the named attribute from the given object. delattr(x, \'y\') is equivalent to ``del x.y\'\' """ pass
class BlackMedium: feature=\'Ugly\' def __init__(self,name,addr): self.name=name self.addr=addr def sell_house(self): print(\'%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼\' %self.name) def rent_house(self): print(\'%s 黑中介租房子啦,傻逼才租呢\' %self.name) b1=BlackMedium(\'万成置地\',\'回龙观天露园\') #检测是否含有某属性 print(hasattr(b1,\'name\')) print(hasattr(b1,\'sell_house\')) #获取属性 n=getattr(b1,\'name\') print(n) func=getattr(b1,\'rent_house\') func() # getattr(b1,\'aaaaaaaa\') #报错 print(getattr(b1,\'aaaaaaaa\',\'不存在啊\')) #设置属性 setattr(b1,\'sb\',True) setattr(b1,\'show_name\',lambda self:self.name+\'sb\') print(b1.__dict__) print(b1.show_name(b1)) #删除属性 delattr(b1,\'addr\') delattr(b1,\'show_name\') delattr(b1,\'show_name111\')#不存在,则报错 print(b1.__dict__)
class Foo(object): staticField = "old boy" def __init__(self): self.name = \'wupeiqi\' def func(self): return \'func\' @staticmethod def bar(): return \'bar\' print getattr(Foo, \'staticField\') print getattr(Foo, \'func\') print getattr(Foo, \'bar\')
#!/usr/bin/env python # -*- coding:utf-8 -*- import sys def s1(): print \'s1\' def s2(): print \'s2\' this_module = sys.modules[__name__] hasattr(this_module, \'s1\') getattr(this_module, \'s2\')
导入其他模块，利用反射查找该模块是否存在某个方法
def test(): print(\'from the test\')
#!/usr/bin/env python # -*- coding:utf-8 -*- """ 程序目录： module_test.py index.py 当前文件： index.py """ import module_test as obj #obj.test() print(hasattr(obj,\'test\')) getattr(obj,\'test\')()
反射好处一：可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种\'后期绑定\'，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能。
class FtpClient: \'ftp客户端,但是还么有实现具体的功能\' def __init__(self,addr): print(\'正在连接服务器[%s]\' %addr) self.addr=addr
#from module import FtpClient f1=FtpClient(\'192.168.1.1\') if hasattr(f1,\'get\'): func_get=getattr(f1,\'get\') func_get() else: print(\'---->不存在此方法\') print(\'处理其他的逻辑\')
反射好处二：动态导入模块（基于反射当前模块成员）
__import__(\'package.test\') #定位到package（解释器内部的） import importlib m = importlib.import_module(\'package.test\') #定位到package.test #官方建议用第二种方法
四、__setattr__,__delattr__,__getattr__
class Foo: x=1 def __init__(self,y): self.y=y def __getattr__(self, item): print(\'----> from getattr:你找的属性不存在\') def __setattr__(self, key, value): print(\'----> from setattr\') # self.key=value #这就无限递归了,你好好想想 # self.__dict__[key]=value #应该使用它 def __delattr__(self, item): print(\'----> from delattr\') # del self.item #无限递归了 self.__dict__.pop(item) #__setattr__添加/修改属性会触发它的执行 f1=Foo(10) print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值 f1.z=3 print(f1.__dict__) #__delattr__删除属性的时候会触发 f1.__dict__[\'a\']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作 del f1.a print(f1.__dict__) #__getattr__只有在使用点调用属性且属性不存在的时候才会触发 f1.xxxxxx
1. self.key=value（新增属性）会触发__setattr__方法，导致无限递归增加属性
2. del self.item（删除属性）会触发__delattr__方法，导致无限递归删除属性（第一次删掉后，再删，不存在了，所以导致报错）
五、二次加工标准类型（包装）
包装：python为大家提供了标准数据类型，以及丰富的内置方法，其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型，新增/改写方法，这就用到了我们刚学的继承/派生知识（其他的标准类型均可以通过下面的方式进行二次加工）
class List(list): #继承list所有的属性，也可以派生出自己新的，比如append和mid def append(self, p_object): \' 派生自己的append：加上类型检查\' if not isinstance(p_object,int): raise TypeError(\'must be int\') super().append(p_object) @property def mid(self): \'新增自己的属性\' index=len(self)//2 return self[index] l=List([1,2,3,4]) print(l) l.append(5) print(l) # l.append(\'1111111\') #报错，必须为int类型 print(l.mid) #其余的方法都继承list的 l.insert(0,-123) print(l) l.clear() print(l)
1.继承list类所有的属性，派生出自己的方法，例如对append加上类型检查，如果append对象不是int类型，则抛出一个类型错误的提示，结束掉程序。如果是则接着运行super().append(p_object) 调用父类的原有的append方法来进行添加，因为自己派生的功能仅仅只是类型检查。
2. @property 把方法变为静态属性，这样在实例在调用的时候可以不用加括号运行。
3.注意：静态属性只能传入self，不能再加其他参数。
4.继承得来的方法只要没有被派生增加别的功能，用法和父类中的相同。
授权：授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。
实现授权的关键点就是覆盖__getattr__方法
import time class FileHandle: def __init__(self,filename,mode=\'r\',encoding=\'utf-8\'): self.file=open(filename,mode,encoding=encoding) def write(self,line): t=time.strftime(\'%Y-%m-%d %T\') self.file.write(\'%s %s\' %(t,line)) def __getattr__(self, item): return getattr(self.file,item) f1=FileHandle(\'b.txt\',\'w+\') f1.write(\'你好啊\') f1.seek(0) print(f1.read()) f1.close()
1. self.file=open(filename,mode,encoding=encoding)其中self是实例本身，self.file是拿到文件句柄。
2.通过 self.方法名 调用属性，如果属性不存在则触发__getattr__方法 ，然后通过getattr(self,item)拿到方法的内存地址，最后加上括号就可以运行。
3. 其中getattr(self,item) self是实例 item是字符串形式的方法名。
#_*_coding:utf-8_*_ __author__ = \'Linhaifeng\' #我们来加上b模式支持 import time class FileHandle: def __init__(self,filename,mode=\'r\',encoding=\'utf-8\'): if \'b\' in mode: self.file=open(filename,mode) else: self.file=open(filename,mode,encoding=encoding) self.filename=filename self.mode=mode self.encoding=encoding def write(self,line): if \'b\' in self.mode: if not isinstance(line,bytes): raise TypeError(\'must be bytes\') self.file.write(line) def __getattr__(self, item): return getattr(self.file,item) def __str__(self): if \'b\' in self.mode: res="<_io.BufferedReader name=\'%s\'>" %self.filename else: res="<_io.TextIOWrapper name=\'%s\' mode=\'%s\' encoding=\'%s\'>" %(self.filename,self.mode,self.encoding) return res f1=FileHandle(\'b.txt\',\'wb\') # f1.write(\'你好啊啊啊啊啊\') #自定制的write,不用在进行encode转成二进制去写了,简单,大气 f1.write(\'你好啊\'.encode(\'utf-8\')) print(f1) f1.close()
#练习一 class List: def __init__(self,seq): self.seq=seq def append(self, p_object): \' 派生自己的append加上类型检查，覆盖原有的append\' if not isinstance(p_object,int): raise TypeError(\'must be int\') self.seq.append(p_object) @property def mid(self): \'新增自己的方法\' index=len(self.seq)//2 return self.seq[index] def __getattr__(self, item): return getattr(self.seq,item) def __str__(self): return str(self.seq) l=List([1,2,3]) print(l) l.append(4) print(l) # l.append(\'3333333\') #报错，必须为int类型 print(l.mid) #基于授权，获得insert方法 l.insert(0,-123) print(l) #练习二 class List: def __init__(self,seq,permission=False): self.seq=seq self.permission=permission def clear(self): if not self.permission: raise PermissionError(\'not allow the operation\') self.seq.clear() def __getattr__(self, item): return getattr(self.seq,item) def __str__(self): return str(self.seq) l=List([1,2,3]) # l.clear() #此时没有权限，抛出异常 l.permission=True print(l) l.clear() print(l) #基于授权，获得insert方法 l.insert(0,-123) print(l)
资料来源：海峰老师
以上是关于day27--多态封装反射的主要内容，如果未能解决你的问题，请参考以下文章