Comment comparer le type d'un objet en Python?

isinstance Travaux:

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

Mais, gardez à l'esprit: si elle ressemble à un canard, et si cela ressemble à un canard, c'est un canard.

EDIT: pour le type None, Vous pouvez simplement faire:

if obj is None: obj = MyClass()

Tout d'abord, évitez toutes les comparaisons de types. Ils sont très, très rarement nécessaires. Parfois, ils aident à vérifier les types de paramètres dans une fonction-même si c'est rare. Les données de type incorrect déclencheront une exception, et c'est tout ce dont vous aurez besoin.

Toutes les fonctions de conversion de base seront mappées comme égales à la fonction type.

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

Il y a quelques autres cas.

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

Aucun, BTW, n'a jamais besoin de ce type de vérification de type. None est la seule instance de NoneType. Aucune l'objet est un Singleton. Il suffit de vérifier pour aucun

variable is None

BTW, ne pas utiliser ce qui précède en général. Utilisez des exceptions ordinaires et le polymorphisme naturel de Python.

Pour les autres types, consultez le moduletypes :

>>> 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 est une mauvaise idée.

Vous pouvez toujours utiliser l'Astuce type(x) == type(y), où y est quelque chose avec un type connu.

# 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)

Il existe souvent de meilleures façons de le faire, en particulier avec tout Python récent. Mais si vous voulez seulement vous souvenir d'une chose, vous pouvez vous en souvenir.

Dans ce cas, les meilleurs moyens seraient:

# 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

Notez le dernier cas: il n'y a qu'une seule instance de NoneType en python, et c'est None. Vous verrez beaucoup NoneType dans les exceptions (TypeError: 'NoneType' object is unsubscriptable - m'arrive tout le temps..) mais vous aurez presque jamais besoin de s'y référer dans le code.

Enfin, comme le souligne fengshaun, la vérification de type en python n'est pas toujours une bonne idée. Il est plus pythonique d'utiliser simplement la valeur comme si c'était le type que vous attendez, et d'attraper (ou permettre de propager) les exceptions qui en résultent.

Vous êtes très proche! string est un module, pas un type. Vous voulez probablement comparer le type de obj avec l'objet type pour les chaînes, à savoir str:

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

Alternativement:

type(obj) == type('')

Notez, en Python 2, Si obj est un type unicode, alors aucun des éléments ci-dessus ne fonctionnera. Pas plus que isinstance(). Voir les commentaires de John à cet article pour savoir comment contourner ce problème... J'ai essayé de m'en souvenir pendant environ 10 minutes maintenant, mais j'avais un bloc de mémoire!

C'est parce que vous devez écrire

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

Type accepte une instance et renvoie son type. Dans ce cas, vous devez comparer les types de deux instances.

Si vous devez effectuer une vérification préventive, il est préférable de vérifier une interface prise en charge que le type.

Le type ne vous en dit pas vraiment beaucoup, mis à part le fait que votre code veut une instance d'un type spécifique, indépendamment du fait que vous pourriez avoir une autre instance d'un type complètement différent qui serait parfaitement bien car il implémente la même interface.

Par exemple, supposons que vous ayez ce code

def firstElement(parameter):
    return parameter[0]

Maintenant, supposons que vous disiez: Je veux que ce code n'accepte qu'un tuple.

import types

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

Cela réduit la réutilisabilité de cette routine. Cela ne fonctionnera pas si vous passez une liste, une chaîne ou un numpy.tableau. Quelque chose de mieux serait

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

Mais cela ne sert à rien: le paramètre [0] déclenchera une exception si le protocole n'est pas satisfait de toute façon... ce de bien sûr, sauf si vous voulez éviter les effets secondaires ou avoir à récupérer des appels que vous pourriez invoquer avant d'échouer. (Stupide) exemple, juste pour faire le point:

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

Dans ce cas, votre code déclenchera une exception avant d'exécuter l'appel system (). Sans vérification de l'interface, vous auriez supprimé le fichier, puis déclenché l'exception.

J'utilise type(x) == type(y)

Par exemple, si je veux vérifier quelque chose est un tableau:

type( x ) == type( [] )

Vérification de chaîne:

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

Si vous voulez vérifier avec None, Utilisez

x is None

Utilisez str au lieu de string

type ( obj ) == str

Explication

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

Je pense que cela devrait le faire

if isinstance(obj, str)

Le Type ne fonctionne pas sur certaines classes. Si vous n'êtes pas sûr du type de l'objet, utilisez la méthode __class__, comme suit:

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

Voir Aussi cet article - http://www.siafoo.net/article/56

Pour obtenir le type, l'utilisation de la __class__ membre, comme dans unknown_thing.__class__

Parler de typage de canard est inutile ici car il ne répond pas à une très bonne question. Dans mon code d'application, je n'ai jamais besoin de connaître le type de quelque chose, mais il est toujours utile d'avoir un moyen d'apprendre le type d'un objet. Parfois, j'ai besoin d'obtenir la classe réelle pour valider un test unitaire. Le typage de canard s'y met car tous les objets possibles ont la même API, mais un seul est correct. Aussi, parfois, je suis le maintien de le code de quelqu'un d'autre, et je n'ai aucune idée du type d'objet qui m'a été transmis. C'est mon plus gros problème avec les langages typés dynamiquement comme Python. La Version 1 est très facile et rapide à développer. La Version 2 est une douleur dans les petits pains, surtout si vous n'avez pas écrit la version 1. Donc, parfois, quand je travaille avec une fonction que je n'ai pas écrite, j'ai besoin de connaître le type d'un paramètre, juste pour savoir quelles méthodes je peux appeler.

C'est là que le paramètre __class__ est utile. Qui (autant que Je peux dire) est le meilleur moyen (peut-être le seul moyen) d'obtenir le type d'un objet.

Vous pouvez comparer les classes pour le niveau de contrôle.

#!/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()
d.t()
d.r()

e = E()
e.t()
e.r()

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

Utilisez isinstance(object, type). Comme ci-dessus, c'est facile à utiliser si vous connaissez les bonnes type, par exemple,

isinstance('dog', str) ## gives bool True

Mais pour les objets plus ésotériques, cela peut être difficile à utiliser. Par exemple:

import numpy as np 
a = np.array([1,2,3]) 
isinstance(a,np.array) ## breaks

Mais vous pouvez faire cette astuce:

y = type(np.array([1]))
isinstance(a,y) ## gives bool True 

Je recommande donc d'instancier une variable (y dans ce cas) avec un type de l'objet que vous voulez vérifier (par exemple, type(np.array())), puis en utilisant isinstance.