如何比较Python中的对象的types？

基本上我想这样做：

obj = 'str' type ( obj ) == string 

我试过了：

 type ( obj ) == type ( string ) 

并没有工作。

另外，其他types呢？ 例如，我无法复制NoneType 。

Answer 1

 isinstance() 

在你的情况下， isinstance("this is a string", str)将返回True 。

您也可以阅读： http : //www.canonical.org/~kragen/isinstance/

Answer 2

isinstance作品：

 if isinstance(obj, MyClass): do_foo(obj) 

但是请记住：如果它看起来像一只鸭子，如果它听起来像一只鸭子，那它就是一只鸭子。

编辑：对于Nonetypes，你可以简单地做：

 if obj is None: obj = MyClass() 

Answer 3

首先，避免所有types的比较。 他们是非常非常less的必要的。 有时，他们帮助检查函数中的参数types – 即使这很less见。 错误的types数据会引发exception，这就是您所需要的。

所有的基本转换函数将映射为与types函数相同。

 type(9) is int type(2.5) is float type('x') is str type(u'x') is unicode type(2+3j) is complex 

还有其他一些情况。

 isinstance( 'x', basestring ) isinstance( u'u', basestring ) isinstance( 9, int ) isinstance( 2.5, float ) isinstance( (2+3j), complex ) 

没有，BTW，从来不需要任何这种types的检查。 None是NoneType的唯一实例。 None对象是一个Singleton。 只是检查无

 variable is None 

顺便说一句，不要使用上面的一般。 使用普通的exception和Python自己的自然多态性。

Answer 4

对于其他types，请查看types模块：

 >>> import types >>> x = "mystring" >>> isinstance(x, types.StringType) True >>> x = 5 >>> isinstance(x, types.IntType) True >>> x = None >>> isinstance(x, types.NoneType) True 

PS Typechecking是一个坏主意。

Answer 5

你总是可以使用type(x) == type(y)技巧，其中y是已知types的东西。

 # check if x is a regular string type(x) == type('') # check if x is an integer type(x) == type(1) # check if x is a NoneType type(x) == type(None) 

通常有更好的方法，特别是最近的Python。 但如果你只想记住一件事，你可以记住这一点。

在这种情况下，更好的方法是：

 # check if x is a regular string type(x) == str # check if x is either a regular string or a unicode string type(x) in [str, unicode] # alternatively: isinstance(x, basestring) # check if x is an integer type(x) == int # check if x is a NoneType x is None 

注意最后一种情况：python中只有一个NoneType实例，那就是None 。 你会在exception中看到很多TypeError: 'NoneType' object is unsubscriptable （ TypeError: 'NoneType' object is unsubscriptable – 我一直都在使用它）..但是你几乎不需要在代码中引用它。

最后，正如fengshaun指出的那样，python中的types检查并不总是一个好主意。 仅仅使用该值就好像它是你期望的types，并捕获（或允许传播）由此产生的exception。

Answer 6

这是因为你必须写

 s="hello" type(s) == type("") 

type接受一个实例并返回它的types。 在这种情况下，你必须比较两个实例的types。

如果您需要进行抢先检查，最好是检查支持的接口而不是types。

除了事实上你的代码需要一个特定types的实例之外，types并没有真正地告诉你很多事实，不pipe事实上你可以拥有另一个完全不同types的实例，因为它实现了相同的接口。

例如，假设你有这个代码

 def firstElement(parameter): return parameter[0] 

现在，假设你说：我希望这个代码只接受一个元组。

 import types def firstElement(parameter): if type(parameter) != types.TupleType: raise TypeError("function accepts only a tuple") return parameter[0] 

这降低了这个例程的可重用性。 如果你传递一个列表，一个string或一个numpy.array，它将不起作用。 更好的东西会是

 def firstElement(parameter): if not (hasattr(parameter, "__getitem__") and callable(getattr(parameter,"__getitem__"))): raise TypeError("interface violation") return parameter[0] 

但是这样做没有意义：如果协议不满意，参数[0]将引发exception…当然，除非您想防止副作用或从失败之前调用的调用中恢复。 （愚蠢的）例子，只是为了说明这一点：

 def firstElement(parameter): if not (hasattr(parameter, "__getitem__") and callable(getattr(parameter,"__getitem__"))): raise TypeError("interface violation") os.system("rm file") return parameter[0] 

在这种情况下，在运行system（）调用之前，您的代码将引发exception。 没有接口检查，你会删除文件，然后引发exception。

Answer 7

你非常接近！ string是一个模块，而不是一个types。 您可能想要比较obj的types和string的types对象，即str ：

 type(obj) == str # this works because str is already a type 

或者：

 type(obj) == type('') 

请注意，在Python 2中，如果obj是unicodetypes，那么以上都不会起作用。 也不会isinstance() 。 看到约翰对这篇文章的评论如何解决这个问题…我一直试图记住它现在约10分钟，但有一个内存块！

Answer 8

我使用type(x) == type(y)

例如，如果我想检查一个数组是：

 type( x ) == type( [] ) 

string检查：

 type( x ) == type( '' ) or type( x ) == type( u'' ) 

如果你想检查无，使用是

 x is None 

Answer 9

我认为这应该做到这一点

 if isinstance(obj, str) 

Answer 10

使用str而不是string

 type ( obj ) == str 

说明

 >>> a = "Hello" >>> type(a)==str True >>> type(a) <type 'str'> >>> 

Answer 11

types在某些类上不起作用。 如果您不确定对象的types是否使用__class__方法，那么：

 >>>obj = 'a string' >>>obj.__class__ == str True 

另见本文 – http://www.siafoo.net/article/56

Answer 12

要获取types，请使用__class__成员，如unknown_thing.__class__

说鸭式打字在这里是无用的，因为它不能回答一个完美的问题。 在我的应用程序代码中，我从来不需要知道某个东西的types，但是学习一个对象的types还是很有用的。 有时我需要得到实际的类来validationunit testing。 因为所有可能的对象都具有相同的API，所以鸭式打字会受到阻碍，但只有一个是正确的。 另外，有时候我还在维护别人的代码，我不知道我通过了什么样的对象。 这是dynamictypes语言如Python的最大问题。 版本1非常容易和快速的开发。 版本2是一个包子的痛苦，特别是如果你没有写第一版。所以有时候，当我使用一个我没有写的函数的时候，我需要知道一个参数的types，所以我知道我可以调用什么方法。

这就是__class__参数派上用场的地方。 （据我所知）是获得对象types的最好方法（也许是唯一的方法）。

Answer 13

你可以比较类的检查水平。

 #!/usr/bin/env python #coding:utf8 class A(object): def t(self): print 'A' def r(self): print 'rA', self.t() class B(A): def t(self): print 'B' class C(A): def t(self): print 'C' class D(B, C): def t(self): print 'D', super(D, self).t() class E(C, B): pass d = D() dt() dr() e = E() et() er() print isinstance(e, D) # False print isinstance(e, E) # True print isinstance(e, C) # True print isinstance(e, B) # True print isinstance(e, (A,)) # True print e.__class__ >= A, #False print e.__class__ <= C, #False print e.__class__ < E, #False print e.__class__ <= E #True