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
.
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
.
Réponses:
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()
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?
isinstance
mais aussi pour vérifier None
ensuite les isinstance(obj, (MyClass, type(None)))
travaux. types.NoneType
a été supprimé de Python 3, il n'est donc pas aussi portable que type(None)
pour obtenir une référence NoneType
.
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.
NoneType
. Que faire si un paramètre peut être str
, unicode
ou 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 type
dé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.
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ù 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 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 NoneType
en 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! string
est 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 obj
est 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.
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
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 ( y
dans 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
type(obj) == str