En Python, as funcións integradas type() e isinstance() úsanse para obter e comprobar o tipo dun obxecto, como unha variable, e para determinar se é dun tipo particular.
- class type(object) — Built-in Functions — Python 3.10.4 Documentation
- isinstance(object, classinfo) — Built-in Functions — Python 3.10.4 Documentation
Os seguintes contidos explícanse aquí, xunto co código de mostra.
- Obter e comprobar o tipo de obxecto:
type() - Determinación do tipo de obxecto:
type(),isinstance()- Determinación do tipo usando type()
- Determinación do tipo usando isinstance()
- Diferenza entre type() e isinstance()
En lugar de determinar o tipo dun obxecto, pódese usar o manexo de excepcións ou a función incorporada hasattr() para determinar se un obxecto ten os métodos e atributos correctos.
Obter e comprobar o tipo de obxecto:tipo ()
tipo(obxecto) é unha función que devolve o tipo de obxecto pasado como argumento. Isto pódese usar para descubrir o tipo dun obxecto.
print(type('string'))
# <class 'str'>
print(type(100))
# <class 'int'>
print(type([0, 1, 2]))
# <class 'list'>
O valor de retorno de type() é un obxecto tipo como str ou int.
print(type(type('string')))
# <class 'type'>
print(type(str))
# <class 'type'>
Determinación do tipo de obxecto:type(),isinstance()
Use type() ou isinstance() para determinar o tipo.
Determinación do tipo usando type()
Ao comparar o valor de retorno de type() cun tipo arbitrario, pódese determinar se o obxecto é de calquera 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 queres determinar se é un de varios tipos, utiliza o operador in e unha tupla ou lista de varios tipos.
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
Tamén é posible definir funcións que cambian de procesamento dependendo do tipo de argumento.
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
Determinación do tipo usando isinstance()
isinstance(obxecto, clase) é unha función que devolve verdadeiro se o obxecto do primeiro argumento é unha instancia do tipo ou subclase do segundo argumento.
O segundo argumento pode ser unha tupla de tipos. Se é unha instancia de calquera tipo, devólvese true.
print(isinstance('string', str))
# True
print(isinstance(100, str))
# False
print(isinstance(100, (int, str)))
# True
Unha función similar ao exemplo de determinación de tipo usando type() pódese escribir do seguinte xeito
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
Diferenza entre type() e isinstance()
A diferenza entre type() e isinstance() é que isinstance() devolve verdadeiro para as instancias de subclases que herdan a clase especificada como segundo argumento.
Por exemplo, defínense a seguinte superclase (clase base) e subclase (clase derivada).
class Base:
pass
class Derive(Base):
pass
base = Base()
print(type(base))
# <class '__main__.Base'>
derive = Derive()
print(type(derive))
# <class '__main__.Derive'>
A determinación do tipo usando type() devolve verdadeiro só cando os tipos coinciden, pero isinstance() devolve verdadeiro mesmo para as superclases.
print(type(derive) is Derive)
# True
print(type(derive) is Base)
# False
print(isinstance(derive, Derive))
# True
print(isinstance(derive, Base))
# True
Incluso para tipos estándar, por exemplo, o tipo booleano bool (verdadeiro, falso), hai que ter coidado. bool é unha subclase de tipo enteiro, polo que isinstance() devolve verdade incluso para un int do que se herda.
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 quere determinar o tipo exacto, use type(); se quere determinar o tipo coa herdanza tida en conta, use isinstance().
Tamén se proporciona a función integrada issubclass() para determinar se unha clase é unha subclase doutra clase.
print(issubclass(bool, int))
# True
print(issubclass(bool, float))
# False
