Comment comparer le type d'un objet en Python?


163

En gros, je veux faire ceci:

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

J'ai essayé:

type ( obj ) == type ( string )

et cela n'a pas fonctionné.

Et qu'en est-il des autres types? Par exemple, je ne pouvais pas répliquer NoneType.


Cela fonctionnetype(obj) == str
Joshua Varghese

Réponses:


241
isinstance()

Dans votre cas, isinstance("this is a string", str)je reviendrai True.

Vous pouvez également lire ceci: http://www.canonical.org/~kragen/isinstance/


4
Je dirais que vous (l'OP) devriez certainement lire le lien référencé, qui donne beaucoup de détails sur les raisons pour lesquelles vérifier le type d'un objet est généralement une mauvaise idée, et ce que vous devriez probablement faire à la place.
Jeff Shannon le

2
vous devez utiliser basestr, pas str. sinon, vous ne choisirez pas unicode. (bien que pour 3.x je pense que str est le plus bas)
hasen

36

isinstance travaux:

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

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

EDIT: Pour le type Aucun, vous pouvez simplement faire:

if obj is None: obj = MyClass()

def distance_from_zero(n): if isinstance(n,int) or isinstance(n,float): return abs(n) else: return "Nope" print distance_from_zero(True) Cela renvoie un "1" au lieu de "Nope". Comment contourner cela?
dig_123

Si vous souhaitez utiliser , isinstancemais aussi pour vérifier Noneensuite les isinstance(obj, (MyClass, type(None)))travaux. types.NoneTypea été supprimé de Python 3, il n'est donc pas aussi portable que type(None)pour obtenir une référence NoneType.
Santeri Paavolainen

33

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 c'est rare. Un type de données incorrect soulèvera 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 de 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 existe 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. L'objet None est un Singleton. Vérifiez simplement Aucun

variable is None

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


3
Si vous validez les entrées d'un DSL, vous avez besoin de tout cela, même NoneType. Que faire si un paramètre peut être str, unicodeou None? isinstance(x, (str, unicode, types.NoneType))est beaucoup plus propre que de vérifier None. Si vous créez des outils pour le calcul différé, ou si vous êtes sur le point de lancer un processus long ou gourmand en ressources, il est utile de typedétecter les erreurs à l'avance, lors d'une étape de validation personnalisée. Cela a été un élément essentiel de presque tous les projets informatiques scientifiques sur lesquels j'ai travaillé. Parmi tous les projets de développement que j'ai vus, il y en a plus qui en ont eu besoin.
ely

23

Pour les autres types, consultez le module 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 est une mauvaise idée.


15

Vous pouvez toujours utiliser l' type(x) == type(y)astuce, où yest 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 n'importe quel python récent. Mais si vous ne voulez vous rappeler qu'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 NoneTypeen python, et c'est None. Vous verrez beaucoup NoneType dans les exceptions ( TypeError: 'NoneType' object is unsubscriptable- cela m'arrive tout le temps ..) mais vous n'aurez presque jamais besoin de vous 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.


1
Pour ce que ça vaut, isinstance () est le moyen préféré de vérifier les types en Python (lorsque vous devez le faire).
David Z

6

Vous êtes très proche! stringest un module, pas un type. Vous souhaitez probablement comparer le type de objà 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 que dans Python 2, si objest un type unicode, aucun des éléments ci-dessus ne fonctionnera. Ni sera isinstance(). Voir les commentaires de John sur ce post pour savoir comment contourner cela ... J'essaie de m'en souvenir depuis environ 10 minutes maintenant, mais j'avais un bloc de mémoire!


2
Utilisez basestring avec isinstance () pour obtenir à la fois str et unicode.
John Fouhy

5

C'est parce que tu dois é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 rechercher une interface prise en charge plutôt que le type.

Le type ne vous dit pas vraiment grand-chose, 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 conviendrait parfaitement car elle 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.array. 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 ça ne sert à rien de le faire: le paramètre [0] lèvera une exception si le protocole n'est pas satisfait de toute façon ... ceci bien sûr à moins que vous ne vouliez éviter les effets secondaires ou devoir récupérer des appels que vous pourriez appeler 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 lèvera une exception avant d'exécuter l'appel system (). Sans vérifications d'interface, vous auriez supprimé le fichier, puis déclenché l'exception.


Merci d'avoir indiqué la méthode préférée pour vérifier les interfaces. Beaucoup de réponses ici le mentionnent, mais peu donnent des exemples de ce qui est bon à la place. Il ne répond toujours pas directement à ma question personnelle (j'essaie de séparer une liste de chaînes, contenant de nombreux éléments significatifs, d'une chaîne, qui contient de nombreux éléments non significatifs. Merci!
Nick

5

Utilisez str au lieu de string

type ( obj ) == str

Explication

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

4

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

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

type( x ) == type( [] )

vérification de la chaîne:

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

Si vous voulez cocher Aucun, utilisez est

x is None

hein? pourquoi est-ce une mauvaise idée en général? Ce n'est qu'une mauvaise idée pour les chaînes (pour les versions antérieures à la version 3.0) car il existe deux types de chaînes, str et unicode. Pour les tableaux, c'est une bonne idée à mon humble avis.
hasen le

@hasen: c'est une mauvaise idée dans l'ensemble. Que faire si je définis mon propre type qui se comporte comme un tableau mais, par exemple, récupère les valeurs d'une base de données? Votre code échouera avec mon type sans raison.
nosklo

@hasen: lisez le lien canonical.org/~kragen/isinstance de la réponse la plus votée (+7), par voltronw
nosklo

1
Eh bien, toute la raison (pour moi au moins) de vérifier le type est exactement parce que je veux traiter les tableaux différemment des autres types (y compris les types qui imitent les tableaux).
hasen le

2
Vous vous trompez. Je vais vous donner un exemple concret: django a un raccourci de rendu de modèle qui peut accepter soit une chaîne, soit un tableau de chaînes. Maintenant, les chaînes et les tableaux (listes) sont itérables, mais dans ce cas, les fonctions doivent les différencier.
hasen

2

je pense que ça devrait le faire

if isinstance(obj, str)

2

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

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

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


2

Pour obtenir le type, utilisez le __class__membre, comme dansunknown_thing.__class__

Parler de typage de canard est inutile ici car il ne répond pas à une question parfaitement bonne. 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 y fait obstacle car tous les objets possibles ont la même API, mais un seul est correct. Aussi, parfois je gère 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 simple et rapide à développer. La version 2 est pénible, surtout si vous n'avez pas écrit la version 1. Donc, parfois, lorsque je travaille avec une fonction que je n'ai pas écrite, j'ai besoin de connaître le type d'un paramètre,

C'est là que le __class__paramètre est utile. C'est (pour autant que je sache) le meilleur moyen (peut-être le seul) d'obtenir le type d'un objet.


2

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

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

Mais pour des 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 ( ydans ce cas) avec un type de l'objet que vous souhaitez vérifier (par exemple, type(np.array())), puis d'utiliser isinstance.


0

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
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.