Déterminer le type d'un objet?

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
>>> type({})
<type 'dict'>
>>> type([])
<type 'list'>

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

Noter 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 couvrir cela, vous devez utiliser le 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() est préféré au type().

Le deuxième paramètre de 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

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 appelé 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 la 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érez il serait 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).

Déterminer le type d'un objet Python

Déterminer le type d'un objet avec type

>>> obj = object()
>>> type(obj)
<class 'object'>

Bien que cela fonctionne, d'éviter le double soulignement des attributs comme __class__ - ils ne sont pas sémantiquement public, et, peut-être pas dans ce cas, les fonctions internes ont généralement un meilleur comportement.

>>> obj.__class__ # avoid this!
<class 'object'>

vérification de type

Est-il un moyen simple de déterminer si une variable est une liste, dictionnaire, ou quelque chose d'autre? Je suis un objet qui peut être de type et j'ai besoin d'être en mesure de faire la différence.

Bien, c'est une autre question, ne pas utiliser de type - utilisation isinstance:

def foo(obj):
    """given a string with items separated by spaces, 
    or a list or tuple, 
    do something sensible
    """
    if isinstance(obj, str):
        obj = str.split()
    return _foo_handles_only_lists_or_tuples(obj)

Ce couvre le cas où votre utilisateur peut être en train de faire quelque chose d'intelligent et raisonnable de le subclassing str - selon le principe de Liskov Substitution, vous voulez être en mesure d'utiliser la sous-classe des instances sans casser votre code et isinstance prend en charge cette.

Utiliser Des Abstractions

Encore mieux, vous pouvez regarder pour une Classe de Base Abstraite collections ou numbers:

from collections import Iterable
from numbers import Number

def bar(obj):
    """does something sensible with an iterable of numbers, 
    or just one number
    """
    if isinstance(obj, Number): # make it a 1-tuple
        obj = (obj,)
    if not isinstance(obj, Iterable):
        raise TypeError('obj must be either a number or iterable of numbers')
    return _bar_sensible_with_iterable(obj)

Ou tout Simplement Ne sont pas explicitement de Type case à

Ou, peut-être le meilleur de tous, l'utilisation de canard-typage, et ne sont pas explicitement de type vérifier votre code. Duck-typing prend en charge Liskov Substitution avec plus d'élégance et de moins de verbosité.

def baz(obj):
    """given an obj, a dict (or anything with an .items method) 
    do something sensible with each key-value pair
    """
    for key, value in obj.items():
        _baz_something_sensible(key, value)

Conclusion

• Utilisation type à réellement obtenir une instance de la classe.
• Utilisation isinstance explicitement vérifier effectivement les sous-classes ou inscrits abstractions.
• Et juste éviter de vérification de type où il fait sens.

être prudent en utilisant isinstance

isinstance(True, bool)
True
>>> isinstance(True, int)
True

mais le type

type(True) == bool
True
>>> type(True) == int
False

Comme un de côté pour les réponses précédentes, il est intéressant de mentionner l'existence de collections.abc qui contient plusieurs classes de base abstraites (Occ) qui complètent duck-typing.

Par exemple, au lieu d'explicitement vérifier si quelque chose est une liste avec:

isinstance(my_obj, list)

vous pourriez, si vous êtes seulement intéressé de voir si l'objet vous permet d'obtenir des objets, les utiliser collections.abc.Séquence:

from collections.abc import Sequence
isinstance(my_obj, Sequence) 

si vous êtes strictement intéressé par les objets qui permettent d'obtenir, réglage et la suppression d'éléments (j'.e mutable séquences), vous pourriez opter pour collections.abc.MutableSequence.

Beaucoup d'autres Notions sont définies, Mapping pour les objets qui peuvent être utilisées comme des cartes, des Iterable, Callable, et cetera. Une liste complète de tous ces peut être vu dans la documentation de collections.abc.

type() est une meilleure solution que isinstance(), en particulier pour les booleans:

True et False sont seulement des mots-clés qui signifie 1 et 0 en python. Ainsi,

isinstance(True, int)

et

isinstance(False, int)

fois de retour True. Les deux booléens sont un exemple d'un nombre entier. type(), cependant, est plus intelligent:

type(True) == int

retourne False.