Comment comparer le type d'un objet en Python?

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.

isinstance()

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

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

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

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.

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.

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.

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!

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.

Utilisez str au lieu de string

type ( obj ) == str

Explication

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

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

je pense que ça 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 __class__méthode, comme suit:

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

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

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.

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.

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