Voici pourquoi isinstance est mieux que type :

class Vehicle:
    pass

class Truck(Vehicle):
    pass

dans ce cas, un objet de camion est un véhicule, mais vous obtiendrez ceci:

isinstance(Vehicle(), Vehicle)  # returns True
type(Vehicle()) == Vehicle      # returns True
isinstance(Truck(), Vehicle)    # returns True
type(Truck()) == Vehicle        # returns False, and this probably won't be what you want.

en d'autres termes, isinstance vaut également pour les sous-classes.

Voir aussi: comment comparer le type d'un objet en Python?

Différences entre les isinstance() et type() en Python?

contrôle de Type avec

isinstance(obj, Base)

permet des instances de sous-classes et plusieurs bases possibles:

isinstance(obj, (Base1, Base2))

alors que le contrôle de type porte sur

type(obj) is Base

supporte uniquement le type référencé.

---

comme sidenote, is est probablement plus approprié que

type(obj) == Base

parce que les classes sont des Singleton.

Eviter la vérification de type-use polymorphisme (duck-typing)

en Python, habituellement vous voulez autoriser n'importe quel type pour vos arguments, le traiter comme prévu, et si l'objet ne se comporte pas comme prévu, il soulèvera une erreur appropriée. Ceci est connu comme le polymorphisme, aussi connu comme duck-typing.

def function_of_duck(duck):
    duck.quack()
    duck.swim()

Si le code ci-dessus fonctionne, nous pouvons présumer notre argument est un canard. Ainsi nous pouvons passer dans d'autres choses sont des sous-types réels de canard:

function_of_duck(mallard)

ou qui travaillent comme un canard:

function_of_duck(object_that_quacks_and_swims_like_a_duck)

et notre code fonctionne toujours.

toutefois, dans certains cas, il est souhaitable de procéder à un contrôle de type explicite. Peut-être avez-vous des choses sensées à faire avec différents types d'objets. Par exemple, L'objet Pandas Dataframe peut être construit à partir de dicts ou . Dans un tel cas, votre code doit savoir quel type d'argument c'est l'obtention de sorte qu'il peut gérer correctement.

donc, pour répondre à la question:

différences entre isinstance() et type() en Python?

Permettez-moi de démontrer la différence:

type

dites que vous devez vous assurer un certain comportement si votre fonction est un certain genre d'argument (un cas d'utilisation pour les constructeurs). Si vous vérifiez pour le type comme ceci:

def foo(data):
    '''accepts a dict to construct something, string support in future'''
    if type(data) is not dict:
        # we're only going to test for dicts for now
        raise ValueError('only dicts are supported for now')

si nous essayons de passer dans un dict qui est une sous-classe de dict (comme nous devrions pouvoir, si nous nous attendons à ce que notre code suive le principe de Liskov Substitution , que les sous-types peuvent être substitués pour les types) notre code casse!:

from collections import OrderedDict

foo(OrderedDict([('foo', 'bar'), ('fizz', 'buzz')]))

soulève une erreur!

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in foo
ValueError: argument must be a dict

isinstance

mais si nous utilisons isinstance , nous pouvons soutenir Liskov Substitution!:

def foo(a_dict):
    if not isinstance(a_dict, dict):
        raise ValueError('argument must be a dict')
    return a_dict

foo(OrderedDict([('foo', 'bar'), ('fizz', 'buzz')]))

renvoie OrderedDict([('foo', 'bar'), ('fizz', 'buzz')])

Classes De Base Abstraites

En fait, nous pouvons faire encore mieux. collections fournit des Classes de Base abstraites qui appliquent des protocoles minimaux pour divers types. Dans notre cas, si nous attendons seulement le protocole Mapping , nous pouvons faire ce qui suit, et notre code devient encore plus flexible:

from collections import Mapping

def foo(a_dict):
    if not isinstance(a_dict, Mapping):
        raise ValueError('argument must be a dict')
    return a_dict

réponse au commentaire:

il convient de noter que le type peut être utilisé pour vérifier la compatibilité avec plusieurs classes en utilisant type(obj) in (A, B, C)

Oui, vous pouvez tester l'égalité des types, mais au lieu de ce qui précède, utilisez les bases multiples pour le flux de contrôle, à moins que vous n'autorisiez spécifiquement que ces types:

isinstance(obj, (A, B, C))

la différence, encore une fois, est que isinstance supporte des sous-classes qui peuvent être substituées au parent sans briser le programme, une propriété connue sous le nom de substitution de Liskov.

encore mieux, cependant, inversez vos dépendances et ne Vérifiez pas du tout les types spécifiques.

Conclusion

donc, puisque nous voulons soutenir des sous-classes de substitution, dans la plupart des cas, nous voulons éviter vérification de type avec type et préférez vérification de type avec isinstance -à moins que vous ayez vraiment besoin de connaître la classe précise d'une instance.

cette dernière solution est préférable, car elle permet de traiter correctement les sous-classes. En fait, votre exemple peut être écrit encore plus facilement parce que le second paramètre de isinstance() peut être un tuple:

if isinstance(b, (str, unicode)):
    do_something_else()

ou, à l'aide de la basestring classe abstraite:

if isinstance(b, basestring):
    do_something_else()

selon la documentation de python voici une déclaration:

8.15. types-noms pour les types intégrés

à partir de Python 2.2, intégré fonctions d'usine telles que int() et str() sont également des noms pour le types correspondants.

Donc isinstance() doit être préféré à type() .

pour les différences réelles, nous pouvons le trouver dans code , mais je ne peux pas trouver l'implémentation du comportement par défaut du isinstance() .

Toutefois, nous pouvons obtenir un semblable abc.__instancecheck__ selon __instancecheck__ .

au-dessus de abc.__instancecheck__ , après avoir utilisé l'essai ci-dessous:

# file tree
# /test/__init__.py
# /test/aaa/__init__.py
# /test/aaa/aa.py
class b():
pass

# /test/aaa/a.py
import sys
sys.path.append('/test')

from aaa.aa import b
from aa import b as c

d = b()

print(b, c, d.__class__)
for i in [b, c, object]:
    print(i, '__subclasses__',  i.__subclasses__())
    print(i, '__mro__', i.__mro__)
    print(i, '__subclasshook__', i.__subclasshook__(d.__class__))
    print(i, '__subclasshook__', i.__subclasshook__(type(d)))
print(isinstance(d, b))
print(isinstance(d, c))

<class 'aaa.aa.b'> <class 'aa.b'> <class 'aaa.aa.b'>
<class 'aaa.aa.b'> __subclasses__ []
<class 'aaa.aa.b'> __mro__ (<class 'aaa.aa.b'>, <class 'object'>)
<class 'aaa.aa.b'> __subclasshook__ NotImplemented
<class 'aaa.aa.b'> __subclasshook__ NotImplemented
<class 'aa.b'> __subclasses__ []
<class 'aa.b'> __mro__ (<class 'aa.b'>, <class 'object'>)
<class 'aa.b'> __subclasshook__ NotImplemented
<class 'aa.b'> __subclasshook__ NotImplemented
<class 'object'> __subclasses__ [..., <class 'aaa.aa.b'>, <class 'aa.b'>]
<class 'object'> __mro__ (<class 'object'>,)
<class 'object'> __subclasshook__ NotImplemented
<class 'object'> __subclasshook__ NotImplemented
True
False

j'obtiens cette conclusion, Au lieu de type :

# according to `abc.__instancecheck__`, they are maybe different! I have not found negative one 
type(INSTANCE) ~= INSTANCE.__class__
type(CLASS) ~= CLASS.__class__

pour isinstance :

# guess from `abc.__instancecheck__`
return any(c in cls.__mro__ or c in cls.__subclasses__ or cls.__subclasshook__(c) for c in {INSTANCE.__class__, type(INSTANCE)})

BTW: mieux de ne pas mélanger les utiliser relative and absolutely import , utilisez absolutely import de project_dir( ajouté par sys.path )