面向对象进阶---反射

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

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

class Foo:
    pass
obj=Foo()
print(isinstance(obj,Foo))

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

class Foo:
    pass
class Bar(Foo):
    pass

print(Bar.__dict__)
print(issubclass(Bar,Foo))

二 反射
1.概念：主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。
2.python面向对象中的反射：通过字符串的形式操作对象相关的属性。
　python中的一切事物都是对象（都可以使用反射）
3.四个可以实现自省的函数
下列方法适用于类和对象（一切皆对象，类本身也是一个对象）　

class People:
    country="China"
    def __init__(self,name):
        self.name=name
    def walk(self):
        print("-------------")

p=People("fei")
#-----------hasattr用法-->检测是否含有某属性
# print(People.__dict__)
# print(p.__dict__)
# print("name"in p.__dict__)
# print("country"in People.__dict__)
print(hasattr(People,"country"))
print(hasattr(p,"country"))
print(hasattr(People,"walk"))
print(hasattr(p,"walk"))
print(hasattr(People,"name"))

#------------getattr的用法-->获取属性
res=getattr(People,"country")
res=People.country
print(res)
print(p.xxx)  #报错
print(getattr(p,"xxx","该参数不存在"))#自己添加报错信息，不填系统报错
if hasattr(p,"walk"):
    func=getattr(p,"walk")
    func()

print("==============") #利用这种反射方法可以扩展新的程序

#-------------setattr用法-->设置及修改属性
# p.sex="male" #给对象添加新的属性
# print(p.sex)
# print(p.__dict__)

# setattr(p,"sex","famale")
# print(p.sex)
# print(p.__dict__)   #修改增加
# setattr(p,"age",18)
# print(p.__dict__)
# print(getattr(p,"age"))

#-----------delattr的用法-->删除属性
print(p.__dict__)
delattr(p,"name")
print(p.__dict__)

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

 import sys #导入一个模块名
 def s1():
     print 's1'
 def s2():
     print 's2'

#一个完整的py文件就是一个模块
import test

print(test)#显示这个模块的名字，模块路径
 #调用模块的属性就在模块名加点就可以，一切皆文件，模块也是文件，so~
print(test.x) 
print(test.s1)
print(test.s2)

test1中导入test这个模块

　　反射自己当前模块成员(不要疑问，先记住)

import sys #先导入一个sys模块

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)#类似方法

**补充：通过字符串导入其他模块

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

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

三 为什么用反射？反射的好处是什么？

　　好处一：实现可插拔机制

class Ftp_Client:
    def __init__(self,addr):
        print("正在连接服务器%s"%(addr))
        self.addr=addr
    def test(self):
        print("----test----")

import ftp客户端
f1=ftp客户端.Ftp_Client("192.168.3.3")
print(hasattr(f1,"test"))
print(hasattr(f1,"get"))
if hasattr(f1,"get"):
    func_get=getattr(f1,"get")
    func_get()
else:
    print("对方还没写完进了看守所，先写自己的程序吧。")
    #此处可以先写自己的程序，无需等待客服端的代码

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

四 attr系列 （__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

五 二次加工标准类型（包装）-->定制自己的数据类型

包装：python为大家提供了标准数据类型，以及丰富的内置方法，其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型，新增/改写方法，这就用到了我们刚学的继承/派生知识（其他的标准类型均可以通过下面的方式进行二次加工）

#基于继承的原理，来定制自己的数据类型（继承标准类型）
class List(list):
    def append(self, p_object):
        if not isinstance(p_object,int):
            raise TypeError("必须输入一个字整数类型")
        else:
            super().append(p_object)
    def insert(self, index, p_object):
        if not isinstance(p_object,int):
            raise TypeError("必须整数类型")
        else:
            super().insert(index,p_object)

l=List([1,2,3])
print(l)
l.append(5555)
print(l)
l.append("dsa")
print(l)
l.insert(1,333)
print(l)
l.insert(1,"asd")
print(l)

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

　　*附加一个python中查看当前时间的方法

import time
res=time.strftime("%Y-%m-%d %X")
print(res)     #输出为----->  2017-04-24 20:17:21

#不能用继承，来实现open函数的功能(因为类继承不了函数)
#授权的方式实现定制自己的数据类型
import time
class Open:
    def __init__(self,file_path,m="r",encode="utf8"):
        self.file_path=file_path
        self.mode=m
        self.encoding=encode
        self.x=open(file_path,mode=m,encoding=encode)
    def write(self,line):
        t=time.strftime("%Y-%m-%d %X")
        self.x.write("%s---->%s"%(t,line))

    def __getattr__(self, item):
        # print("--------",item)
        return getattr(self.x,item)
# f=Open("a.txt","a")
# # print(f)
# f.write("open函数说你侵权...
")
# f.write("open函数说你山寨...
")
f=Open("a.txt","r")
# print(f.read)
res=f.read()
print(res)
f.seek(0)
print("seek调整后可以重新读",f.read())