Cómo comprobar si un objeto tiene un determinado método en Python

Introducción

En este laboratorio, aprenderás cómo verificar si un objeto tiene un determinado método en Python. El laboratorio abarca los métodos de objeto, centrándose en cómo encapsulan el comportamiento dentro de los objetos para obtener código organizado y reutilizable.

Explorarás la clase Dog con métodos como __init__, bark y get_name, creando instancias y llamando a estos métodos. Luego, el laboratorio te guiará en el uso de hasattr() y callable() para determinar si un objeto posee un método específico. Finalmente, entenderás el Orden de Resolución de Métodos (Method Resolution Order, MRO).

Skills Graph

Aprende sobre Métodos de Objeto

En este paso, aprenderás sobre los métodos de objeto en Python. Los métodos son funciones que están asociadas con objetos. Se utilizan para realizar operaciones sobre los datos del objeto. Comprender los métodos de objeto es crucial para trabajar con objetos y clases en Python.

Comencemos creando una clase simple llamada Dog:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        return "Woof!"

    def get_name(self):
        return self.name

Crea un archivo llamado dog.py en tu directorio ~/project utilizando el editor VS Code. Copia y pega el código anterior en el archivo dog.py.

Esta clase tiene tres métodos:

• __init__: Este es el método constructor. Se llama cuando se crea un nuevo objeto de la clase. Inicializa los atributos del objeto.
• bark: Este método devuelve la cadena "Woof!".
• get_name: Este método devuelve el nombre del perro.

Ahora, creemos un objeto de la clase Dog y llamemos a sus métodos. Crea un nuevo archivo llamado main.py en el directorio ~/project:

from dog import Dog

my_dog = Dog("Buddy", "Golden Retriever")

print(my_dog.bark())
print(my_dog.get_name())

Guarda el archivo main.py.

Para ejecutar el script main.py, abre tu terminal y navega hasta el directorio ~/project:

cd ~/project

Luego, ejecuta el script utilizando el comando python:

python main.py

Deberías ver la siguiente salida:

Woof!
Buddy

En este ejemplo, my_dog es un objeto de la clase Dog. Estamos llamando a los métodos bark y get_name en el objeto my_dog utilizando la notación de punto (.).

Los métodos de objeto te permiten encapsular el comportamiento dentro de los objetos, lo que hace que tu código sea más organizado y reutilizable. Son una parte fundamental de la programación orientada a objetos en Python.

Verificar con hasattr() y callable()

En este paso, aprenderás cómo usar las funciones hasattr() y callable() en Python. Estas funciones son útiles para inspeccionar objetos y determinar si tienen ciertos atributos o métodos.

• hasattr(object, attribute_name): Esta función verifica si un objeto tiene un atributo dado. Devuelve True si el atributo existe y False en caso contrario.
• callable(object): Esta función verifica si un objeto es llamable (es decir, se puede llamar como una función). Devuelve True si el objeto es llamable y False en caso contrario.

Continuemos con la clase Dog del paso anterior. Abre el archivo dog.py en tu directorio ~/project utilizando el editor VS Code. El contenido debe ser:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        return "Woof!"

    def get_name(self):
        return self.name

Ahora, creemos un nuevo archivo llamado check_methods.py en el directorio ~/project para demostrar el uso de hasattr() y callable():

from dog import Dog

my_dog = Dog("Buddy", "Golden Retriever")

print(hasattr(my_dog, "name"))
print(hasattr(my_dog, "bark"))
print(hasattr(my_dog, "age"))

print(callable(my_dog.bark))
print(callable(my_dog.name))

Guarda el archivo check_methods.py.

En este ejemplo:

• hasattr(my_dog, "name") verifica si el objeto my_dog tiene un atributo llamado "name". Devolverá True porque la clase Dog tiene un atributo name.
• hasattr(my_dog, "bark") verifica si el objeto my_dog tiene un atributo llamado "bark". Devolverá True porque la clase Dog tiene un método bark.
• hasattr(my_dog, "age") verifica si el objeto my_dog tiene un atributo llamado "age". Devolverá False porque la clase Dog no tiene un atributo age.
• callable(my_dog.bark) verifica si el atributo my_dog.bark es llamable (es decir, es un método). Devolverá True porque bark es un método.
• callable(my_dog.name) verifica si el atributo my_dog.name es llamable. Devolverá False porque name es un atributo de tipo cadena, no un método.

Para ejecutar el script check_methods.py, abre tu terminal y navega hasta el directorio ~/project:

cd ~/project

Luego, ejecuta el script utilizando el comando python:

python check_methods.py

Deberías ver la siguiente salida:

True
True
False
True
False

Estas funciones son útiles para escribir código más robusto y flexible que puede manejar diferentes tipos de objetos y atributos.

Entiende el Orden de Resolución de Métodos (Method Resolution Order - MRO)

En este paso, aprenderás sobre el Orden de Resolución de Métodos (MRO) en Python. El MRO es el orden en el que Python busca un método en una jerarquía de clases. Es particularmente importante cuando se trata de herencia múltiple.

Creemos un nuevo conjunto de clases para ilustrar el MRO. Crea un archivo llamado animal.py en tu directorio ~/project utilizando el editor VS Code:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "Generic animal sound"


class Mammal(Animal):
    def speak(self):
        return "Generic mammal sound"


class Dog(Mammal):
    def speak(self):
        return "Woof!"


class Cat(Mammal):
    def speak(self):
        return "Meow!"

Guarda el archivo animal.py.

Ahora, creemos un nuevo archivo llamado mro_example.py en el directorio ~/project para demostrar el MRO:

from animal import Animal, Mammal, Dog, Cat

my_dog = Dog("Buddy")
my_cat = Cat("Whiskers")

print(my_dog.speak())
print(my_cat.speak())

Guarda el archivo mro_example.py.

En este ejemplo:

• Animal es la clase base con un método speak.
• Mammal hereda de Animal y anula el método speak.
• Dog hereda de Mammal y anula el método speak.
• Cat hereda de Mammal y anula el método speak.

Cuando llamas a my_dog.speak(), Python primero busca el método speak en la clase Dog. Si no lo encuentra allí, lo busca en la clase Mammal y luego en la clase Animal. Este orden está determinado por el MRO.

Para ejecutar el script mro_example.py, abre tu terminal y navega hasta el directorio ~/project:

cd ~/project

Luego, ejecuta el script utilizando el comando python:

python mro_example.py

Deberías ver la siguiente salida:

Woof!
Meow!

Ahora, exploremos un ejemplo más complejo con herencia múltiple. Crea un nuevo archivo llamado mro_complex.py en el directorio ~/project:

class A:
    def method(self):
        return "A"

class B(A):
    def method(self):
        return "B"

class C(A):
    def method(self):
        return "C"

class D(B, C):
    pass

d = D()
print(d.method())
print(D.mro())

Guarda el archivo mro_complex.py.

En este ejemplo:

• La clase D hereda tanto de B como de C.
• Tanto B como C heredan de A.
• El método method está definido en las tres clases A, B y C.

Para ejecutar el script mro_complex.py, abre tu terminal y navega hasta el directorio ~/project:

cd ~/project

Luego, ejecuta el script utilizando el comando python:

python mro_complex.py

Deberías ver la siguiente salida:

B
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

La salida B indica que se llama al método method de la clase B. El método D.mro() devuelve una tupla que representa el orden de resolución de métodos para la clase D. En este caso, el MRO es D -> B -> C -> A -> object. Esto significa que cuando llamas a d.method(), Python primero busca el método en la clase D, luego en la clase B, luego en la clase C, luego en la clase A y finalmente en la clase base object.

Comprender el MRO es esencial para predecir el comportamiento de tu código cuando se utiliza la herencia, especialmente la herencia múltiple.

Resumen

En este laboratorio (lab), el primer paso se centra en comprender los métodos de objeto en Python. Se introduce el concepto de métodos como funciones asociadas a objetos, que son cruciales para realizar operaciones en los datos de los objetos. Se crea una clase Dog con métodos como __init__, bark y get_name para demostrar cómo los métodos encapsulan el comportamiento dentro de los objetos.

Luego, el laboratorio te guía a través de la creación de una instancia de la clase Dog y la llamada a sus métodos utilizando la notación de punto, lo que ilustra cómo los métodos de objeto contribuyen a un código organizado y reutilizable en la programación orientada a objetos.