type(), isinstance() per ottenere e determinare il tipo in Python

Attività commerciale

In Python, le funzioni built-in type() e isinstance() sono usate per ottenere e controllare il tipo di un oggetto, come una variabile, e per determinare se è di un tipo particolare.

I seguenti contenuti sono spiegati qui, insieme al codice di esempio.

  • Ottenere e controllare il tipo di oggetto:type()
  • Determinazione del tipo di oggetto:type(),isinstance()
    • Determinazione del tipo usando type()
    • Determinazione del tipo usando isinstance()
    • Differenza tra type() e isinstance()

Invece di determinare il tipo di un oggetto, si può usare la gestione delle eccezioni o la funzione built-in hasattr() per determinare se un oggetto ha i metodi e gli attributi corretti.

Ottenere e controllare il tipo di oggetto: tipo()

type(object) è una funzione che restituisce il tipo dell'oggetto passato come argomento. Questo può essere usato per scoprire il tipo di un oggetto.

print(type('string'))
# <class 'str'>

print(type(100))
# <class 'int'>

print(type([0, 1, 2]))
# <class 'list'>

Il valore di ritorno di type() è un oggetto di tipo come str o int.

print(type(type('string')))
# <class 'type'>

print(type(str))
# <class 'type'>

Determinazione del tipo di oggetto: type(), isinstance()

Usare type() o isinstance() per determinare il tipo.

Determinazione del tipo usando type()

Confrontando il valore di ritorno di type() con un tipo arbitrario, si può determinare se l'oggetto è di qualsiasi tipo.

print(type('string') is str)
# True

print(type('string') is int)
# False
def is_str(v):
    return type(v) is str

print(is_str('string'))
# True

print(is_str(100))
# False

print(is_str([0, 1, 2]))
# False

Se volete determinare se è uno di più tipi, usate l'operatore in e una tupla o una lista di più tipi.

def is_str_or_int(v):
    return type(v) in (str, int)

print(is_str_or_int('string'))
# True

print(is_str_or_int(100))
# True

print(is_str_or_int([0, 1, 2]))
# False

È anche possibile definire funzioni che cambiano l'elaborazione a seconda del tipo di argomento.

def type_condition(v):
    if type(v) is str:
        print('type is str')
    elif type(v) is int:
        print('type is int')
    else:
        print('type is not str or int')

type_condition('string')
# type is str

type_condition(100)
# type is int

type_condition([0, 1, 2])
# type is not str or int

Determinazione del tipo usando isinstance()

isinstance(object, class) è una funzione che restituisce vero se l'oggetto del primo argomento è un'istanza del tipo o della sottoclasse del secondo argomento.

Il secondo argomento può essere una tupla di tipi. Se è un'istanza di uno dei due tipi, viene restituito true.

print(isinstance('string', str))
# True

print(isinstance(100, str))
# False

print(isinstance(100, (int, str)))
# True

Una funzione simile all'esempio della determinazione del tipo usando type() può essere scritta come segue

def is_str(v):
    return isinstance(v, str)

print(is_str('string'))
# True

print(is_str(100))
# False

print(is_str([0, 1, 2]))
# False
def is_str_or_int(v):
    return isinstance(v, (int, str))

print(is_str_or_int('string'))
# True

print(is_str_or_int(100))
# True

print(is_str_or_int([0, 1, 2]))
# False
def type_condition(v):
    if isinstance(v, str):
        print('type is str')
    elif isinstance(v, int):
        print('type is int')
    else:
        print('type is not str or int')

type_condition('string')
# type is str

type_condition(100)
# type is int

type_condition([0, 1, 2])
# type is not str or int

Differenza tra type() e isinstance()

La differenza tra type() e isinstance() è che isinstance() restituisce vero per le istanze delle sottoclassi che ereditano la classe specificata come secondo argomento.

Per esempio, sono definite la seguente superclasse (classe base) e sottoclasse (classe derivata)

class Base:
    pass

class Derive(Base):
    pass

base = Base()
print(type(base))
# <class '__main__.Base'>

derive = Derive()
print(type(derive))
# <class '__main__.Derive'>

La determinazione del tipo usando type() restituisce vero solo quando i tipi corrispondono, ma isinstance() restituisce vero anche per le superclassi.

print(type(derive) is Derive)
# True

print(type(derive) is Base)
# False

print(isinstance(derive, Derive))
# True

print(isinstance(derive, Base))
# True

Anche per i tipi standard, per esempio il tipo booleano bool (true,false), bisogna fare attenzione. bool è una sottoclasse del tipo integer, quindi isinstance() restituisce true anche per un int da cui è ereditato.

print(type(True))
# <class 'bool'>

print(type(True) is bool)
# True

print(type(True) is int)
# False

print(isinstance(True, bool))
# True

print(isinstance(True, int))
# True

Se volete determinare il tipo esatto, usate type(); se volete determinare il tipo con l'ereditarietà presa in considerazione, usate isinstance().

La funzione built-in issubclass() è anche fornita per determinare se una classe è una sottoclasse di un'altra classe.

print(issubclass(bool, int))
# True

print(issubclass(bool, float))
# False