Python之面向对象反射

Python之面向对象反射

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

1 class Foo(object):
2     pass
3
4 obj = Foo()
5
6 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字符串对应的方法或属性

 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

getattr(object, name, default=None)

 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

setattr(x, y, v)

 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

delattr(x, y)

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

反射当前模块成员

导入其他模块，利用反射查找该模块是否存在某个方法

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-

 def test():
     print('from the test')

module_test.py

 #!/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 People:
     country='China'
     def __init__(self,name):
         self.name=name
     # def walk(self):
     #     print('%s is walking' %self.name)
 p=People('egon')
 #
 # People.country
 # print(People.__dict__)

 # print(p.name)
 # print(p.__dict__)

 # p.name

 #hasattr
 # print('name' in p.__dict__)
 # print(hasattr(p,'name'))
 # print(hasattr(p,'name1213'))

 # print(hasattr(p,'country')) #p.country
 # print(hasattr(People,'country')) #People.country
 # print(hasattr(People,'__init__')) #People.__init__

 #getattr
 # res=getattr(p,'country') #res=p.country
 # print(res)
 #
 # f=getattr(p,'walk') #t=p.walk
 # print(f)
 #
 # f1=getattr(People,'walk')
 # print(f1)
 #
 # f()
 # f1(p)

 # print(p.xxxxxxx)
 # print(getattr(p,'xxxxxxxx','这个属性确实不存在'))

 #
 # if hasattr(p,'walk'):
 #     func=getattr(p,'walk')
 #     func()
 #
 # print('================>')
 # print('================>')

 #setattr

 # p.sex='male'
 # print(p.sex)
 # print(p.__dict__)

 # setattr(p,'age',18)
 # print(p.__dict__)
 # print(p.age)
 # print(getattr(p,'age'))

 #delattr
 # print(p.__dict__)
 # del p.name
 # print(p.__dict__)

 print(p.__dict__)
 delattr(p,'name')
 print(p.__dict__)

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

好处一：实现可插拔机制

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

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

 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('处理其他的逻辑')

不影响lili的代码编写

好处二：动态导入模块（基于反射当前模块成员）

　　反射的用途：

　　　　

import sys
def add():
    print('add')

def change():
    print('change')

def search():
    print('search')

def delete():
    print('delete')

this_module=sys.modules[__name__]
while True:
    cmd=input('>>：').strip()
    if not cmd:continue
    if hasattr(this_module,cmd):
        func=getattr(this_module,cmd)
        func()
    # if cmd in func_dic: #hasattr()
    #     func=func_dic.get(cmd) #func=getattr()
    #     func()

# func_dic={
#     'add':add,
#     'change':change,
#     'search':search,
#     'delete':delete
# }

# while True:
#     cmd=input('>>：').strip()
#     if not cmd:continue
#     if cmd in func_dic: #hasattr()
#         func=func_dic.get(cmd) #func=getattr()
#         func()

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

#     def walk(self):
#         print('walking......')
# f=Foo('egon')

# Foo.__dict__={'x':1,'walk':....}
# 'x' in Foo.__dict__ #hasattr(Foo,'x')
# Foo.__dict__['x'] #getattr(Foo,'x')
# print(Foo.x) #'x' in Foo.__dict__

　　反射实现可插拔机制：

　　　　FTP Server：

 import ftpclient
 #
 # print(ftpclient)
 # print(ftpclient.FtpClient)
 # obj=ftpclient.FtpClient('192.168.1.3')
 #
 # print(obj)
 # obj.test()

 #
 f1=ftpclient.FtpClient('192.168.1.1')
 if hasattr(f1,'get'):
     func=getattr(f1,'get')
     func()
 else:
     print('其他逻辑')

　　　　FTP Client：

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

     def get(self):
         print('get------->')

　　通过字符串导入模块：

# m=input("请输入你要导入的模块：")

# m1=__import__(m)  #官方不推荐
# print(m1)　　　　　　#官方不推荐
# print(m1.time())　　#官方不推荐

#官方推荐使用方法
import importlib
t=importlib.import_module('time')
print(t.time())

　　attr系列：

　　__getattr__、__setattr__、__delattr__

　　setattr：为对象设置属性的时候回触发setattr的运行。

　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

三者的用法演示

　　定制自己的数据类型：　　　　

# l=list([1,2,3])
#
# l.append(4)
# l.append('5')
# print(l)

# class List(list):
#     pass
#
# l1=List([1,2,3])
# print(l1)
# l1.append(4)
# print(l1)
# l1.append('5')
# print(l1)

#基于继承的原理，来定制自己的数据类型（继承标准类型）

# class List(list):
#     def append(self, p_object):
#         # print('--->',p_object)
#         if not isinstance(p_object,int):
#             raise TypeError('must be int')
#         # self.append(p_object)
#         super().append(p_object)
#     def insert(self, index, p_object):
#         if not isinstance(p_object,int):
#             raise TypeError('must be int')
#         # self.append(p_object)
#         super().insert(index,p_object)
#
# l=List([1,2,3])
# # print(l)
# # l.append(4)
# # print(l)
#
# # l.append('5')
# print(l)
# # l.insert(0,-1)
# l.insert(0,'-1123123213')
# print(l)

# def test(x:int,y:int)->int:
#     return x+y
# print(test.__annotations__)
#
# print(test(1,2))
# print(test(1,'3'))
#
# def test(x,y):
#     return x+y

#不能用继承,来实现open函数的功能
# f=open('a.txt','w')
# print(f)
# f.write('1111111')

#授权的方式实现定制自己的数据类型
import time

class Open:
    def __init__(self,filepath,m='r',encode='utf-8'):
        self.x=open(filepath,mode=m,encoding=encode)

        self.filepath=filepath
        self.mode=m
        self.encoding=encode

    def write(self,line):
        print('f自己的write',line)
        t=time.strftime('%Y-%m-%d %X')
        self.x.write('%s %s' %(t,line))

    def __getattr__(self, item):
        # print('=------>',item,type(item))
        return getattr(self.x,item)
#
# f=Open('b.txt','w')
# # print(f)
# f.write('111111\n')
# f.write('111111\n')
# f.write('111111\n')

f=Open('b.txt','r+')
# print(f.write)
print(f.read)

res=f.read() #self.x.read()
print(res)

print('=-=====>',f.read())
f.seek(0)
print(f.read())
# f.flush()
# f.close() 

　　作业：

 #基于继承来定制自己的数据类型
 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])

 # print(l.mid)

 #基于授权来定制自己的数据类型：

 # class Open:
 #     def __init__(self,filepath,mode,encode='utf-8'):
 #         self.f=open(filepath,mode=mode,encoding=encode)
 #         self.filepath=filepath
 #         self.mode=mode
 #         self.encoding=encode

 #     def write(self,line):
 #         print('write')
 #         self.f.write(line)

 #     def __getattr__(self, item):
 #         return getattr(self.f,item)

 # # f=Open('a.txt','w')
 # # f.write('123123123123123\n')
 # # print(f.seek)
 # # f.close()
 # #
 # # f.write('111111\n')

 # f=open('b.txt','w')
 # f.write('bbbbbb\n')
 # f.close()
 # print(f)

 # class Foo:
 #     def test(self):
 #         pass
 #
 # print(getattr(Foo,'test'))
 #
 # obj=Foo()
 # print(getattr(obj,'test'))

 class List:
     def __init__(self,x):
         self.seq=list(x)

     def append(self,value):
         if not isinstance(value,str):
             raise TypeError('must be str')
         self.seq.append(value)
     @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])

 l.append('')

 print(l.mid)
 l.insert(0,123123123123123123123123123)
 # print(l.seq)

 print(l)

 obj.name='egon'
 del obj.name

链接：详细