Python - Détermine le type d'un objet?

Question

Y a-t-il un moyen simple de déterminer si une variable est une liste, dictionnaire ou autre chose ? Fondamentalement, j’obtiens un objet retour qui peut-être être du type et je dois être capable de faire la différence.

Answer 1

Pour obtenir le type d'un objet, vous pouvez utiliser le haut- type() fonction. Passage d'un objet comme le seul paramètre permet de retourner le type d'objet de l'objet:

>>> type([]) is list
True
>>> type({}) is dict
True
>>> type('') is str
True
>>> type(0) is int
True

Bien sûr, cela fonctionne également pour les types personnalisés:

>>> class Test1 (object):
        pass
>>> class Test2 (Test1):
        pass
>>> a = Test1()
>>> b = Test2()
>>> type(a) is Test1
True
>>> type(b) is Test2
True

Notez que type() ne retour immédiat type de l'objet, mais ne sera pas en mesure de vous dire sur le type d'héritage.

>>> type(b) is Test1
False

Pour ce, vous devez utiliser l' isinstance fonction. Bien sûr, cela fonctionne également pour les types intégrés:

>>> isinstance(b, Test1)
True
>>> isinstance(b, Test2)
True
>>> isinstance(a, Test1)
True
>>> isinstance(a, Test2)
False
>>> isinstance([], list)
True
>>> isinstance({}, dict)
True

isinstance() est généralement la meilleure façon de s'assurer que le type d'un objet parce qu'il acceptera également les types dérivés. Donc, sauf si vous avez réellement besoin le type de l'objet (pour quelque raison que ce soit), à l'aide de isinstance() qui est privilégiée type().

Le second paramètre de la isinstance() accepte également un tuple de types, de sorte qu'il est possible de vérifier plusieurs types à la fois. isinstance sera alors retourner la valeur true si l'objet est d'un de ces types:

>>> isinstance([], (tuple, list, set))
True

Answer 2

Vous pouvez le faire qu’en utilisant `` :

Answer 3

Il pourrait être plus Pythonic d'utiliser un try...except bloc. De cette façon, si vous avez une classe qui charlatans comme une liste, ou des charlatans comme un dict, il va se comporter correctement indépendamment de ce type de vraiment est.

Pour clarifier, la méthode préférée de "faire la différence" entre les types de variables est avec quelque chose qui s'appelle le duck-typing: tant que les méthodes (et les types de retour) qu'une variable répond à sont ce que votre sous-routine s'attend, la traiter comme vous l'attendez. Par exemple, si vous avez une classe qui surcharge le support des opérateurs avec getattr et setattr, mais utilise une drôle de système interne, il serait approprié pour qu'il se comporte comme un dictionnaire si c'est ce qu'elle essaie de les imiter.

L'autre problème avec l' type(A) is type(B) vérification, c'est que si A est une sous-classe de B, il évalue false lorsque, par programmation, vous espère true. Si un objet est une sous-classe d'une liste, il devrait fonctionner comme une liste: vérification du type tel que présenté dans l'autre réponse de l'en empêcher. (isinstance va fonctionner, cependant).

Answer 4

Sur les instances de l'objet, vous avez également la:

__class__

attribut. Voici un exemple de prise de Python 3.3 console

>>> str = "str"
>>> str.__class__
<class 'str'>
>>> i = 2
>>> i.__class__
<class 'int'>
>>> class Test():
...     pass
...
>>> a = Test()
>>> a.__class__
<class '__main__.Test'>

Méfiez-vous qu'en python 3.x et en Nouvelle-classes de Style (aviable éventuellement à partir de la version 2.6 de Python) la classe et le genre ont été fusionnés, ce qui peut parfois mener à des résultats inattendus. Principalement pour cette raison, ma façon préférée de tests types/classes est à la isinstance construit en fonction.

Answer 5

Vous pouvez utiliser type() ou isinstance().

>>> type([]) is list
True

Soyez averti que vous pouvez tabasser list ou tout autre type par l'affectation d'une variable dans la portée actuelle du même nom.

>>> the_d = {}
>>> t = lambda x: "aight" if type(x) is dict else "NOPE"
>>> t(the_d) 'aight'
>>> dict = "dude."
>>> t(the_d) 'NOPE'

Ci-dessus, nous voyons qu' dict obtient réaffecté à une chaîne, donc le test:

type({}) is dict

...échoue.

Pour contourner ce problème et d'utiliser type() avec plus de prudence:

>>> import __builtin__
>>> the_d = {}
>>> type({}) is dict
True
>>> dict =""
>>> type({}) is dict
False
>>> type({}) is __builtin__.dict
True