Cómo comprobar si un objeto es una instancia de una clase en Python

Introducción

En este laboratorio, explorarás clases e instancias en Python y aprenderás cómo verificar si un objeto es una instancia de una clase. Comenzarás creando una clase Dog con atributos de clase e instancia, luego crearás instancias de la clase Dog y accederás a sus atributos.

Luego aprenderás a usar isinstance() para la comprobación de tipos y la compararás con type() para coincidencias exactas. Esto te permitirá determinar si un objeto pertenece a una clase específica o a una subclase de esa clase, brindándote una comprensión más profunda de la programación orientada a objetos en Python.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/ObjectOrientedProgrammingGroup(["Object-Oriented Programming"]) python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") python/ObjectOrientedProgrammingGroup -.-> python/classes_objects("Classes and Objects") python/ObjectOrientedProgrammingGroup -.-> python/constructor("Constructor") python/ObjectOrientedProgrammingGroup -.-> python/inheritance("Inheritance") subgraph Lab Skills python/build_in_functions -.-> lab-559613{{"Cómo comprobar si un objeto es una instancia de una clase en Python"}} python/classes_objects -.-> lab-559613{{"Cómo comprobar si un objeto es una instancia de una clase en Python"}} python/constructor -.-> lab-559613{{"Cómo comprobar si un objeto es una instancia de una clase en Python"}} python/inheritance -.-> lab-559613{{"Cómo comprobar si un objeto es una instancia de una clase en Python"}} end

Explorar Clases e Instancias

En este paso, aprenderás sobre clases e instancias en Python. Las clases son como planos para crear objetos, y las instancias son los objetos reales creados a partir de esos planos. Comprender las clases y las instancias es fundamental para la programación orientada a objetos en Python.

Primero, creemos una clase simple llamada Dog.

Abre el editor de VS Code en el entorno de LabEx.
Crea un nuevo archivo llamado dog.py en el directorio ~/project.
```
~/project/dog.py
```
Agrega el siguiente código a dog.py:
```
## Define a class called Dog
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## Instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age
```
Aquí, definimos una clase llamada Dog. El atributo species es un atributo de clase, lo que significa que es compartido por todas las instancias de la clase Dog. El método __init__ es un método especial llamado constructor. Se utiliza para inicializar los atributos de instancia name y age cuando se crea un nuevo objeto Dog.

Ahora, creemos instancias de la clase Dog. Agrega el siguiente código al final de dog.py:

## Create instances of the Dog class
buddy = Dog("Buddy", 9)
miles = Dog("Miles", 4)

## Access instance attributes
print(f"{buddy.name} is {buddy.age} years old.")
print(f"{miles.name} is {miles.age} years old.")

## Access class attribute
print(f"{buddy.name} is a {buddy.species}.")
print(f"{miles.name} is a {miles.species}.")

En esta parte, creamos dos instancias de la clase Dog: buddy y miles. Luego accedemos a sus atributos de instancia (name y age) y al atributo de clase (species) utilizando la notación de punto (.).

Para ejecutar el script dog.py, abre una terminal en VS Code y ejecuta el siguiente comando:
```
python dog.py
```
Deberías ver la siguiente salida:
```
Buddy is 9 years old.
Miles is 4 years old.
Buddy is a Canis familiaris.
Miles is a Canis familiaris.
```
Esta salida confirma que has creado exitosamente instancias de la clase Dog y has accedido a sus atributos.

Usar `isinstance()` para la comprobación de tipos

En este paso, aprenderás cómo usar la función isinstance() en Python para verificar si un objeto es una instancia de una clase en particular. Esta es una herramienta útil para garantizar que tu código maneje correctamente diferentes tipos de objetos.

A partir de la clase Dog del paso anterior, creemos un nuevo archivo de Python para explorar isinstance().

Abre el editor de VS Code en el entorno de LabEx.
Crea un nuevo archivo llamado type_check.py en el directorio ~/project.
```
~/project/type_check.py
```

Copia la definición de la clase Dog de dog.py a type_check.py. Tu archivo type_check.py ahora debería verse así:

class Dog:
    species = "Canis familiaris"

    def __init__(self, name, age):
        self.name = name
        self.age = age

Ahora, agreguemos algo de código para usar la función isinstance(). Agrega el siguiente código al final de type_check.py:
```
## Create instances of the Dog class
buddy = Dog("Buddy", 9)
miles = Dog("Miles", 4)

## Check if buddy is an instance of the Dog class
print(isinstance(buddy, Dog))

## Check if miles is an instance of the Dog class
print(isinstance(miles, Dog))

## Check if a string is an instance of the Dog class
print(isinstance("Hello", Dog))
```
Aquí, creamos dos instancias de la clase Dog, buddy y miles. Luego usamos la función isinstance() para verificar si estas instancias son de tipo Dog. También verificamos si una cadena "Hello" es una instancia de la clase Dog.
Para ejecutar el script type_check.py, abre una terminal en VS Code y ejecuta el siguiente comando:
```
python type_check.py
```
Deberías ver la siguiente salida:
```
True
True
False
```
La salida muestra que buddy y miles son efectivamente instancias de la clase Dog, mientras que la cadena "Hello" no lo es.

Comparar con `type()` para coincidencias exactas

En este paso, aprenderás cómo usar la función type() en Python y compararla con isinstance() para la comprobación de tipos. Mientras que isinstance() verifica si un objeto es una instancia de una clase o de sus subclases, type() devuelve el tipo exacto de un objeto.

Para ilustrar la diferencia, creemos una subclase de la clase Dog y luego usemos tanto isinstance() como type() para verificar el tipo de las instancias.

Abre el editor de VS Code en el entorno de LabEx.
Modifica el archivo type_check.py en el directorio ~/project.
```
~/project/type_check.py
```

Agrega una nueva clase llamada GermanShepherd que herede de la clase Dog. Tu archivo type_check.py ahora debería verse así:

class Dog:
    species = "Canis familiaris"

    def __init__(self, name, age):
        self.name = name
        self.age = age

class GermanShepherd(Dog):
    def __init__(self, name, age, training_level):
        super().__init__(name, age)
        self.training_level = training_level

Aquí, GermanShepherd es una subclase de Dog. Hereda los atributos name y age de la clase Dog y agrega un nuevo atributo training_level.

Ahora, agreguemos algo de código para usar las funciones isinstance() y type(). Agrega el siguiente código al final de type_check.py:

## Create instances of the Dog and GermanShepherd classes
buddy = Dog("Buddy", 9)
sparky = GermanShepherd("Sparky", 3, "Advanced")

## Check types using isinstance()
print(f"buddy isinstance Dog: {isinstance(buddy, Dog)}")
print(f"sparky isinstance Dog: {isinstance(sparky, Dog)}")
print(f"sparky isinstance GermanShepherd: {isinstance(sparky, GermanShepherd)}")

## Check types using type()
print(f"type(buddy) == Dog: {type(buddy) == Dog}")
print(f"type(sparky) == Dog: {type(sparky) == Dog}")
print(f"type(sparky) == GermanShepherd: {type(sparky) == GermanShepherd}")

En esta parte, creamos una instancia de la clase Dog (buddy) y una instancia de la clase GermanShepherd (sparky). Luego usamos isinstance() y type() para verificar sus tipos.

Para ejecutar el script type_check.py, abre una terminal en VS Code y ejecuta el siguiente comando:
```
python type_check.py
```
Deberías ver la siguiente salida:
```
buddy isinstance Dog: True
sparky isinstance Dog: True
sparky isinstance GermanShepherd: True
type(buddy) == Dog: True
type(sparky) == Dog: False
type(sparky) == GermanShepherd: True
```
La salida muestra que isinstance(sparky, Dog) devuelve True porque sparky es una instancia de la clase GermanShepherd, que es una subclase de Dog. Sin embargo, type(sparky) == Dog devuelve False porque type(sparky) devuelve el tipo exacto, que es GermanShepherd, no Dog.

Resumen

En este laboratorio, exploraste los fundamentos de las clases y las instancias en Python. Aprendiste cómo definir una clase, incluyendo atributos de clase y atributos de instancia inicializados dentro del constructor __init__.

Luego, creaste instancias de la clase Dog, asignando valores a sus atributos específicos. Finalmente, accediste tanto a los atributos de instancia (nombre, edad) como al atributo de clase (especie) utilizando la notación de punto, demostrando cómo recuperar información asociada con objetos y sus clases.