反射

一.反射

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 Bar():
    pass
class Foo(Bar):
    pass
obj=Foo()
print(Foo.__bases__)   #判断是不是继承类
print(issubclass(Foo,Bar))




(<class '__main__.Bar'>,)
True

1.什么是反射

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

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

hasattr(object,name)

　　1.文件直接运行，把一个文件当成脚本运行

　　2.当成模块导入

class People:
    country='China'
    def __init__(self,name):
        self.name=name

p=People('egon')
print(p.__dict__)
People.country    #调的不是字符串
#hasattr
print('name' in p.__dict__)
print(hasattr(p,'name'))
print(hasattr(p,'country'))   #p.country
print(hasattr(People,'country'))  #People.country
print(hasattr(People,'__init__')) #People.__init__


{'name': 'egon'}
True
True
True
True
True

getattr(object,name,default=None)

class People:
    country='China'
    def __init__(self,name):
        self.name=name
    def walk(self):
        print('%s is walking' %self.name)

p=People('egon')


#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)  #函数不会自动传值

China
<bound method People.walk of <__main__.People object at 0x00000000004D1978>>
<function People.walk at 0x00000000004CE2F0>
egon is walking
egon is walking

print(getattr(p,'xxxx','这个属性确实不存在'))  #保证程序不会抛出异常
#或者是用下面这个

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



这个属性确实不存在
egon is walking
=======>
=======>

setattr(x,y,z)

p.sex='male'
print(p.sex)
print(p.__dict__)
setattr(p,'age',18)
print(p.__dict__)
print(p.age)
print(getattr(p,'age'))




male
{'sex': 'male', 'name': 'egon'}
{'sex': 'male', 'name': 'egon', 'age': 18}
18
18

delattr(x,y)

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




{'name': 'egon'}
{}

3.反射当前模块的属性  

this_module=sys.modules[__name__]

import sys

x=11
class Foo:
    pass
def s1():
    print('s1')

def s2():
    print('s2')

this_module = sys.modules[__name__]    #获取当前模块
print(this_module)

print(hasattr(this_module,'s1'))
print(getattr(this_module,'s2'))
print(this_module.s2)
print(this_module.s1)


<module '__main__' from 路径
True
<function s2 at 0x00000000006BE2F0>
<function s2 at 0x00000000006BE2F0>
<function s1 at 0x00000000006BE268>

4.反射的用途：

1.把字符串映射成可执行过程

2.实现可插拔机制

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

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

import ftpclient
#from module import FtpClient
f1=ftpclient.FtpClient('192.168.1.1')
if hasattr(f1,'get'):   #有木有get方法
    func_get=getattr(f1,'get')
    func_get()
else:
    print('---->不存在此方法')
    print('处理其他的逻辑')
# print(ftpclient)
# print(ftpclient.FtpClient)




正在连接服务器[192.168.1.1]
---->不存在此方法
处理其他的逻辑

通过字符串导入模块

m=input('请输入你要导入的模块:')
m1=__import__(m)
print(m1)
print(m1.time())

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



请输入你要导入的模块:time
<module 'time' (built-in)>
1493021033.3454628

手动加上类型限制，弥补python没有类型限制的不足。

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

    def __setattr__(self,key,value):  #都是把属性加到字典里的，递归超过最大限制
        if not isinstance(value,str):
            raise TypeError('must be str')
        # print('---setattr---key:%s,value:%s' %(key,value))
        #setattr(self,key,value)  #self.key=value 递归了，一直再设置属性 #都是把属性加到字典里的，递归超过最大限制
        self.__dict__[key]=value  #使用它

    def __delattr__(self, item):
        print('---> from delattr')
        self.__dict__.pop(item)

f1=Foo('egon')
f1.age='18'
print(f1.name)
print(f1.age)
print(f1.__dict__)  ## 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值

f1.__dict__['a']=3
del f1.age
　　print(f1.__dict__) ##字典里还有age

class Foo:
    def __init__(self,x):
        self.name=x
    #属性不存在的情况下才会触发
    def __getattr__(self, item):
        print('getattr-->%s %s' %(item,type(item)))

f=Foo('egon')
print(f.xxx)



getattr-->xxx <class 'str'>
None     #返回None

5.二次加工标准类型

定制自己的数据类型

定制列表里只加数字

class List(list):    ##继承内置的数据类型
    def append(self, p_object):
        if not isinstance(p_object,int):
            raise TypeError('must be int')
　　　　　　#self.append(p_object)   作为对比，这个不对的
        super().append(p_object)  #完成真正的append
l=List([1,2,3])  
print(l)
l.append(4)
print(l)

l.insert(0,-1)
l.insert(0,'123')
print(l)


[1, 2, 3]
[1, 2, 3, 4]
['123', -1, 1, 2, 3, 4]

规范提示数据类型：

def test(x:int,y:int)->int:
    return x+y
print(test.__annotations__)

print(test(1,2))
# print(test(1,'3'))




{'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}
3

1.使用继承的原理二次加工

class List(list):
    def append(self, 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)
print(l)
l.insert(0,-1)
print(l)
# l.insert(0,'123')
# print(l)


[1, 2, 3]
[1, 2, 3, 4]
[-1, 1, 2, 3, 4]

 2.授权的方式实现定制自己的数据类型

授权：授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。

实现授权的关键点就是覆盖__getattr__方法

#不能用继承，来实现open函数的功能
# f=open('a.txt','w')
# print(f)
# f.write('111')
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))

f=Open('b.txt','w')
print(f)
f.write('1111
')
f.write('11111
')
f.write('11111
')
f.write('11111
')

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('1111
')
# f.write('11111
')
# f.write('11111
')
# f.write('11111
')

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

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


=------> read <class 'str'>
<built-in method read of _io.TextIOWrapper object at 0x00000000008EEA68>
=------> read <class 'str'>
2017-04-24 17:49:50 1111
2017-04-24 17:49:50 11111
2017-04-24 17:49:50 11111
2017-04-24 17:49:50 11111

=------> read <class 'str'>
=-==> 
=------> seek <class 'str'>
=------> read <class 'str'>
2017-04-24 17:49:50 1111
2017-04-24 17:49:50 11111
2017-04-24 17:49:50 11111
2017-04-24 17:49:50 11111

模拟open()打开文件

import time
class Open():
    def __init__(self,filepath):
        self.path=filepath
        self.x=open(filepath,'w+')
    def write(self,value):
        t=time.strftime('%Y-%m-%d')
        self.x.write(t+value)
    def __getattr__(self, item):
        if hasattr(self.x,item):
            return getattr(self.x,item)

f=Open('a.txt')
f.read()
f.seek(0)
f.flush()