Is er een eenvoudige manier om te bepalen of een variabele een lijst, woordenboek, of iets anders is? Ik krijg een object terug dat beide typen kan zijn en ik moet het verschil kunnen zien.
Om het type van een object te krijgen, kun je de ingebouwde type()
functie gebruiken. Als je een object als enige parameter doorgeeft, krijg je het type object van dat object terug:
>>> type([]) is list
True
>>> type({}) is dict
True
>>> type('') is str
True
>>> type(0) is int
True
>>> type({})
<type 'dict'>
>>> type([])
<type 'list'>
Dit werkt natuurlijk ook voor aangepaste types:
>>> class Test1 (object):
pass
>>> class Test2 (Test1):
pass
>>> a = Test1()
>>> b = Test2()
>>> type(a) is Test1
True
>>> type(b) is Test2
True
Merk op dat type()
alleen het directe type van het object teruggeeft, maar je niets kan vertellen over type overerving.
>>> type(b) is Test1
False
Om dat af te dekken, moet je de isinstance
functie gebruiken. Dit werkt natuurlijk ook voor ingebouwde types:
>>> isinstance(b, Test1)
True
>>> isinstance(b, Test2)
True
>>> isinstance(a, Test1)
True
>>> isinstance(a, Test2)
False
>>> isinstance([], list)
True
>>> isinstance({}, dict)
True
isinstance()
is meestal de aangewezen manier om het type van een object te verzekeren, omdat het ook afgeleide types zal accepteren. Dus tenzij je het type object echt nodig hebt (om welke reden dan ook), is het gebruik van isinstance()
te verkiezen boven type()
.
De tweede parameter van isinstance()
accepteert ook een tupel van types, dus het is mogelijk om op meerdere types tegelijk te controleren. isinstance
zal dan true teruggeven, als het object van een van deze types is:
>>> isinstance([], (tuple, list, set))
True
Het is misschien meer Pythonisch om een try
...except
blok te gebruiken. Op die manier, als je een klasse hebt die kwaakt als een lijst, of kwaakt als een dict, zal het zich goed gedragen, ongeacht wat het type echt is.
Ter verduidelijking, de voorkeursmethode om het verschil te bepalen tussen variabele types is met iets dat duck typing heet: zolang de methodes (en return types) waarop een variabele reageert zijn wat je subroutine verwacht, behandel je hem als wat je verwacht dat hij is. Bijvoorbeeld, als u een klasse hebt die de haakjesoperatoren met getattr
en setattr
overlaadt, maar een of ander grappig intern schema gebruikt, zou het passend zijn dat het zich gedraagt als een woordenboek als dat'is wat het probeert te emuleren.
Het andere probleem met de type(A) is type(B)
controle is dat als A
een subklasse is van B
, het evalueert op false
terwijl, programmatisch, je zou hopen dat het true
zou zijn. Als een object een subklasse is van een lijst, zou het moeten werken als een lijst: het controleren van het type zoals in het andere antwoord wordt gepresenteerd zal dit voorkomen. (isinstance
zal echter wel werken).