[python]type和isinstance的比较

共同点

type和instanceof都可以判断变量是否属于某个内建类型

#-*- coding:utf8 -*-
from timeit import timeit
from dis import dis

#用type和isinstance分别判断{'s'}是否属于set类型
def a():return type({'s'})is set
def b():return isinstance({'s'},set)
def c():return type({'s'})==set 

time = [timeit(a),timeit(b),timeit(c)]

#打印结果
print 'result:\n%s %s %s\n'%(a(),b(),c())

#打印时间
print 'time:\n%s\n'%( ''.join([str(_)+'\n' for _ in time]) )

#打印指令
print 'orders:\n'
dis(a)
print '\n'
dis(b)
print '\n'
dis(c)

运行3次 结果：

result:
True True True

time:
0.229784965515
0.217791080475 #最小
0.239007949829

time:
0.232392072678
0.21791100502  #最小
0.229682922363

time:
0.233175992966
0.220207929611 #最小
0.234972953796

orders:

  5           0 LOAD_GLOBAL              0 (type)
              3 LOAD_CONST               1 ('s')
              6 BUILD_SET                1
              9 CALL_FUNCTION            1
             12 LOAD_GLOBAL              1 (set)
             15 COMPARE_OP               8 (is)
             18 RETURN_VALUE        


  6           0 LOAD_GLOBAL              0 (isinstance)
              3 LOAD_CONST               1 ('s')
              6 BUILD_SET                1
              9 LOAD_GLOBAL              1 (set)
             12 CALL_FUNCTION            2
             15 RETURN_VALUE        


  7           0 LOAD_GLOBAL              0 (type)
              3 LOAD_CONST               1 ('s')
              6 BUILD_SET                1
              9 CALL_FUNCTION            1
             12 LOAD_GLOBAL              1 (set)
             15 COMPARE_OP               2 (==)

由此可见,isinstance效率更高一些

不同点

1. 1.type可以只接收一个参数，打印其未知的所属的类型；而isinstance只能判断是否属于某个已知类型。

print type({'s'})

1. 2.isinstance可以判断子类对象是否继承于父类；而type不可以。

class father(object):
    pass
class son(father):
    pass
if __name__ == '__main__':
    print type(son())==father
    print isinstance(son(),father)
    print type(son())
    print type(son)

结果：

False
True
<class '__main__.son'>
<type 'type'>

由不同点不难发现这俩函数的应用场景是不同的：

    type主要用于获取未知变量的类型
    isinstance主要用于判断A类是否继承于B类