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

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 类的派生类

1 class Foo(object):
2     pass
3
4 class Bar(Foo):
5     pass
6
7 issubclass(Bar, Foo)

二 反射

1 什么是反射

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

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

四个可以实现自省的函数

下列方法适用于类和对象（一切皆对象，类本身也是一个对象）

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

hasattr(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

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3
 4 """
 5 程序目录：
 6     module_test.py
 7     index.py
 8
 9 当前文件：
10     index.py
11 """
12
13 import module_test as obj
14
15 #obj.test()
16
17 print(hasattr(obj,‘test‘))
18
19 getattr(obj,‘test‘)()

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

好处一：实现可插拔机制

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

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

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

egon还没有实现全部功能

#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的代码编写

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

三 __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

三者的用法演示

四 __setitem__,__getitem,__delitem__

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print(‘del obj[key]时,我执行‘)
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print(‘del obj.key时,我执行‘)
        self.__dict__.pop(item)

f1=Foo(‘sb‘)
f1[‘age‘]=18
f1[‘age1‘]=19
del f1.age1
del f1[‘age‘]
f1[‘name‘]=‘alex‘
print(f1.__dict__)

五  __del__

　　析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:

    def __del__(self):
        print(‘执行我啦‘)

f1=Foo()
del f1
print(‘------->‘)

#输出结果
执行我啦
------->

简单示范

class Foo:

    def __del__(self):
        print(‘执行我啦‘)

f1=Foo()
# del f1
print(‘------->‘)

#输出结果
------->
执行我啦

#为何啊？？？

挖坑埋了你

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print(‘del obj[key]时,我执行‘)
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print(‘del obj.key时,我执行‘)
        self.__dict__.pop(item)

f1=Foo(‘sb‘)
f1[‘age‘]=18
f1[‘age1‘]=19
del f1.age1
del f1[‘age‘]
f1[‘name‘]=‘alex‘
print(f1.__dict__)