13 内置方法（上）——含反射、包装与授权等内容

面向对象学习目录

1 面向对象介绍

2 类、实例、属性、方法详解

3 面向过程与面向对象进一步比较

4 类与对象

5 属性查找与绑定方法

6 小结

7 继承与派生

8 组合

9 抽象类

10 多态

11 封装

12 绑定方法与非绑定方法

13 内置方法（上）

14 内置方法（中）之描述符

15 内置方法（下）

16 元类

---

一、isinstance(obj,cls)和issubclass(sub,super)

　　isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo(object):
　　pass

obj = Foo()
isinstance(obj, Foo)

 

　　issubclass(sub, super)检查sub类是否是 super 类的派生类

class Foo(object):
　　pass

class Bar(Foo):
　　pass

issubclass(Bar, Foo)

 

二、反射

1 什么是反射

　　反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

2 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

　　四个可以实现自省的函数——下列方法适用于类和对象（一切皆对象，类本身也是一个对象）：

hasattr(object,name)

　　判断object中有没有一个name字符串对应的方法或属性

getattr(object, name, default=None)

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

setattr(x, y, v)

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

delattr(x, y)

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')

 

反射查找当前模块成员

import sys
 
def s1():
　　print 's1'
 
def s2():
　　print 's2'
 
this_module = sys.modules[__name__] # 利用sys模块的modules方法将当前模块形成一个对象
 
hasattr(this_module, 's1')
getattr(this_module, 's2')

 

导入其他模块，利用反射查找该模块是否存在某个方法（即传入方法名的字符串查找）

"""
程序目录内容：
　　module_test.py
　　index.py
 
当前文件：
　　index.py
"""
 
import module_test as obj # 这里将导入的模块赋值给obj(作为一个对象)

#obj.test()
 
print(hasattr(obj,'test'))
 
getattr(obj,'test')()

 

3 为什么用反射——反射的好处

好处一：实现可插拔机制

　　有俩程序员，一个lili，一个是egon，lili在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，lili想到了反射，使用了反射机制lili可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

　　总之反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能

 

　　egon还没有实现全部功能

class FtpClient:
　　'ftp客户端,但是还么有实现具体的功能'
　　def __init__(self,addr):
　　　　print('正在连接服务器[%s]' %addr)
　　　　self.addr=addr

　　不影响lili的代码编写

#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__方法（解释器自己内部的）

　　这里用__import__导入的import_lib目录下的metaclass，确实会把要导入的模块metaclass执行一遍，但是返回的是import_lib这个目录的名称空间（如果赋值m1 = __import__('import_lib.metaclass')，则m1为import_lib目录的名称空间）

　　因为__import__只会返回同级文件的内存地址(若为同级文件夹则返回名称空间)

②importlib模块下的importlib.import_module方法

　　如果用importlib.import_module方法导入，会把要导入的模块metaclass执行一遍，并且返回的是想导入的模块metaclass的内存地址

 

三、__setattr__,__delattr__,__getattr__

　　都是给类的实例用的方法：

　　__setattr__是添加/修改实例的属性会触发它的执行（不去定义修改的话，默认就是在对象的__dict__里添加/修改属性的操作）

　　__delattr__是删除实例的属性会触发它的执行（不去定义修改的话，默认就是在对象的__dict__里删除属性）

　　__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

 

四、二次加工标准类型(包装)

　　包装：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) # 检查通过后这里直接用的父类list的append方法添加

    @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)

　　练习（clear加权限限制）

class List(list):
    def __init__(self,item,tag=False):
        super().__init__(item)
        self.tag=tag
    def append(self, p_object):
        if not isinstance(p_object,str):
            raise TypeError
        super().append(p_object)
    def clear(self):
        if not self.tag:
            raise PermissionError
        super().clear()

l=List([1,2,3],False)
print(l)
print(l.tag)

l.append('saf')
print(l)

# l.clear() #异常

l.tag=True
l.clear()

　　授权与包装的关系：

　　授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制，这种做法可以新建，修改或删除原有产品的功能，其它的则保持原样。

　　授权的过程，即是所有更新的功能都是由新类的某部分来包装定制处理，但已存在的不打算更新的功能就授权给对象的默认属性保留使用。

　　

　　实现授权的关键点就是重设__getattr__方法

 

授权示范一（1.重设write方法  2.其他未重设的方法都随句柄自带内建方法）

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)) # 这里没继承关系，就直接调用生成的句柄本身的内建方法write

    def __getattr__(self, item): # 其他未重设的属性/方法就授权用句柄自带内建方法
        return getattr(self.file,item) # 这里如果item调用的是方法，则返回的是内存地址

f1=FileHandle('b.txt','w+')
f1.write('你好啊')
f1.seek(0)
print(f1.read())
f1.close()

授权示范二

#我们来加上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): # 授权list的其他方法给List
        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)

 

五、__getattribute__

　　调用类的实例的属性时，无论是否找的到该属性，都会触发__getattribute__

　　若__getattribute__与__getattr__同时存在，当找不到属性时，也只会执行__getattrbute__，除非__getattribute__在执行过程中指定抛出异常AttributeError(必须指定为AttributeError，其他异常会直接中止程序运行)，那么该异常就会被屏蔽，且继续运行__getattr__

 

❉注：实际上，系统默认的__getattribute__方法就是在找到实例的属性时，返回这个属性的值，找不到则raise出AttributeError异常，如果我们写了__getattr__方法，则会屏蔽掉该异常，继续运行__getattr__

 

　　回顾__getattr__

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattr__(self, item):
        print('执行的是我')
        # return self.__dict__[item]

f1=Foo(10)
print(f1.x)
f1.xxxxxx #不存在的属性访问，触发__getattr__

　　getattribute

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattribute__(self, item):
        print('不管是否存在,我都会执行')

f1=Foo(10)
f1.x
f1.xxxxxx

　　二者同时出现

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattr__(self, item):
        print('执行的是我')
        # return self.__dict__[item]

    def __getattribute__(self, item):
        print('不管是否存在,我都会执行')
        raise AttributeError('哈哈')

f1=Foo(10)
f1.x
f1.xxxxxx

#当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError