tipo y es instancia en Python

En este artículo, cubriremos las funciones type() e isinstance() en Python , y cuáles son las diferencias entre type() e isinstance() .

¿Qué es escribir en Python?

Python tiene un método incorporado llamado tipo que generalmente es útil para determinar el tipo de variable utilizada en el programa en tiempo de ejecución. La forma canónica de verificar el tipo en Python se proporciona a continuación:

Sintaxis de la función type()

type(object)
type(name, bases, dict)

Ejemplo 1: Ejemplo de type() con un único parámetro de objeto

En este ejemplo, estamos tratando de verificar el tipo de datos de cada variable, como x, s e y usando la función type() .

# Python code type() with a single object parameter
x = 5
s = "geeksforgeeks"
y = [1, 2, 3]
print(type(x))
print(type(s))
print(type(y))

Producción:

class 'int'
class 'str'
class 'list'

Ejemplo 2: Ejemplo de type() con un nombre, bases y parámetro dict 

Si necesita comprobar el tipo de un objeto, se recomienda utilizar la función Python isinstance() en su lugar. Es porque la función isinstance() también verifica si el objeto dado es una instancia de la subclase.

# Python code for type() with a name,
# bases and dict parameter
 
o1 = type('X', (object,), dict(a='Foo', b=12))
 
print(type(o1))
print(vars(o1))
 
 
class test:
    a = 'Foo'
 
 
b = 12
 
o2 = type('Y', (test,), dict(a='Foo', b=12))
print(type(o2))
print(vars(o2))

Producción:

{'b': 12, 'a': 'Foo', '__dict__': , '__doc__': None, '__weakref__': }
{'b': 12, 'a': 'Foo', '__doc__': None}

¿Qué es isinstance() en Python?

La función isinstance() verifica si el objeto (primer argumento) es una instancia o subclase de la clase de información de clase (segundo argumento).

Sintaxis de la función isinstance()

Sintaxis: isinstance (objeto, classinfo) 

Parámetro:

• objeto: objeto a comprobar
• classinfo : clase, tipo o tupla de clases y tipos

Devuelve: verdadero si el objeto es una instancia o subclase de una clase, o cualquier elemento de la tupla falso en caso contrario. 

Si la información de la clase no es un tipo o una tupla de tipos, se genera una excepción TypeError.

Ejemplo 1: 

En este ejemplo, veremos test isinstance() para el objeto de clase.

# Python code for  isinstance()
class Test:
    a = 5
 
 
TestInstance = Test()
 
print(isinstance(TestInstance, Test))
print(isinstance(TestInstance, (list, tuple)))
print(isinstance(TestInstance, (list, tuple, Test)))

Producción:

True
False
True

Ejemplo 2:

En este ejemplo, veremos test isinstance() para el objeto entero, flotante y string .

weight = isinstance(17.9, float)
print("is a float:", weight)
 
num = isinstance(71, int)
print("is an integer:", num)
 
 
string = isinstance("Geeksforgeeks", str)
print("is a string:", string)

Producción:

is a float: True
is an integer: True
is a string: True

Ejemplo 3:

En este ejemplo, veremos test isinstance() para tuple , list , dictionary y set object.

tuple1 = isinstance(('A', 'B', 'C'),tuple)
print("is a tuple:", tuple1)
 
set1 = isinstance({'A', 'B', 'C'},set)
print("is a set:", set1)
 
list1 = isinstance(['A', 'B', 'C'],list)
print("is a list:", list1)
 
dict1 = isinstance({"A":"1", "B":"2", "C":"3"},dict)
print("is a dict:", dict1)

Producción:

is a tuple: True
is a set: True
is a list: True
is a dict: True

¿Cuáles son las diferencias entre type() y isinstance()?

Un error elemental que comete la gente es usar la función type() donde isinstance() sería más apropiado.

• Si está comprobando si un objeto tiene un tipo determinado, querrá isinstance() ya que comprueba si el objeto pasado en el primer argumento es del tipo de cualquiera de los objetos de tipo pasados ​​en el segundo argumento. Por lo tanto, funciona como se esperaba con subclases y clases de estilo antiguo, todas las cuales tienen la instancia de objeto de tipo heredado.
• type(), por otro lado, simplemente devuelve el tipo de objeto de un objeto, y comparar lo que devuelve con otro tipo de objeto solo arrojará True cuando use exactamente el mismo tipo de objeto en ambos lados. En Python, es preferible usar Duck Typing (la verificación de tipos se difiere al tiempo de ejecución y se implementa mediante escritura dinámica o reflexión) en lugar de inspeccionar el tipo de un objeto. 

# Python code to illustrate duck typing
 
 
class User(object):
    def __init__(self, firstname):
        self.firstname = firstname
 
    @property
    def name(self):
        return self.firstname
 
 
class Animal(object):
    pass
 
 
class Fox(Animal):
    name = "Fox"
 
 
class Bear(Animal):
    name = "Bear"
 
 
# Use the .name attribute (or property) regardless of the type
for a in [User("Geeksforgeeks"), Fox(), Bear()]:
    print(a.name)

Producción:

Geeksforgeeks
Fox
Bear

• La siguiente razón para no usar type() es la falta de soporte para herencia .

# python code to illustrate the lack of
# support for inheritance in type()
 
 
class MyDict(dict):
    """A normal dict, that is always created with an "initial" key"""
 
    def __init__(self):
        self["initial"] = "some data"
 
 
d = MyDict()
print(type(d) == dict)
print(type(d) == MyDict)
 
d = dict()
print(type(d) == dict)
print(type(d) == MyDict)

Producción:

False
True
True
False

• La clase MyDict tiene todas las propiedades de un dict, sin ningún método nuevo. Se comportará exactamente como un diccionario. Pero type() no devolverá el resultado esperado. Es preferible usar isinstance() en este caso porque dará el resultado esperado: 

# python code to show isinstance() support
# inheritance
class MyDict(dict):
    """A normal dict, that is always created with an "initial" key"""
 
    def __init__(self):
        self["initial"] = "some data"
 
 
d = MyDict()
print(isinstance(d, MyDict))
print(isinstance(d, dict))
 
d = dict()
print(isinstance(d, MyDict))
print(isinstance(d, dict))

Producción:

True
True
False
True