Tutorial de comprobación de tipos en Python

La propia ayuda del intérprete realiza la comprobación de tipos en Python. Como Python es un lenguaje dinámico, no obliga a especificar el tipo de los objetos, lo que puede provocar errores difíciles de detectar. Para evitarlo, Python puede usarse junto con otras herramientas e incorporar características de comprobación estática de tipos además de su propio duck typing.

Existen dos tipos de sistemas de tipos que siguen distintos lenguajes de programación, que se muestran a continuación.

1. Lenguaje de tipado estático
2. Lenguaje de tipado dinámico

Lenguaje de tipado estático

La comprobación del tipo de una variable se hace en tiempo de compilación. Además, el sistema de tipos del lenguaje obliga a declarar explícitamente el "tipo de dato" de la variable antes de usarla. Entre los lenguajes con tipado estático están: Scala, Java, C++, etc.
Por ejemplo, la declaración de un String en Scala sería:
var myCar:String = "Mercedes";
En el código anterior, la variable "myCar" se declara explícitamente con el tipo de dato "String" y el valor "Mercedes".

Lenguaje de tipado dinámico

La comprobación del tipo de una variable se hace en tiempo de ejecución. Además, el sistema de tipos del lenguaje no obliga a declarar explícitamente el "tipo de dato" de la variable antes de usarla. Entre los lenguajes con tipado dinámico están: Python, JavaScript, Ruby, etc.
Por ejemplo, un string en Python se define así:
myCar = "Mercedes"
En el código anterior, la variable "myCar" no necesita declararse explícitamente.

"type()" e "isinstance()" en Python

Se puede conocer el tipo de las variables con la propia función "type()" de Python. "type()" puede usarse en tiempo de ejecución para depurar y averiguar el tipo exacto de una variable en el programa. Veamos el tipo de algunas variables en el siguiente ejemplo.

my_var = 12
print(type(my_var))

El código anterior mostrará "int", ya que el tipo de dato de la variable es entero y "type()" lo identifica.

La función "insinstance('obj','class')" de Python permite saber si "obj", es decir, el objeto, es instancia de la clase o no. El valor devuelto es booleano: True o False.

my_var = "Hello"
print(isinstance(my_var,str))

El código anterior mostrará True. Como el tipo de dato de la variable es un string, "isinstance()" lo identifica.

Duck typing en Python

Hay un principio muy conocido en Python: "Si parece un pato, nada como un pato y grazna como un pato, probablemente sea un pato". En resumen, el principio dice que el tipo del objeto o la clase no importa: si el objeto tiene métodos y propiedades equivalentes, puede usarse para un fin concreto.
Veamos un ejemplo para aclararlo.

En el siguiente ejemplo hay dos clases, "Duck" y "Human". Duck es una clase que incluye los métodos quack y fly. De forma similar, Human es una clase con sus propios métodos "quack" y "fly". Duck y Human son clases diferentes y, por tanto, tipos u objetos distintos. Sin embargo, Human tiene métodos análogos a "fly" y "quack" de Duck. También hay una función "fly_quack", que encaja más con "Duck" que con "Human" porque puede volar y graznar.

class Duck:
    def quack(self):
        print('Quack')
    def fly(self):
        print('Flap')
class Human:
    def quack(self):
        print('Trying to Quack like a duck')
    def fly(self):
        print('Spreading my arm to flap like a duck')      
def fly_quack(thing):
    thing.quack()
    thing.fly()

Creemos una instancia de "Duck" llamada du y pásala a la función "fly_quack(du)". De forma similar, creamos una instancia de Human "h" y la pasamos a "fly_quack(h)".

du = Duck()
fly_quack(du)
h = Human()
fly_quack(h)

La salida del código anterior es la siguiente:

Trying to Quack like a duck
Spreading my arm to flap like a duck
Quack
Flap

Aunque "Human" es una clase distinta de "Duck", Python llama a la función "fly_quack" también para Human. Aunque los tipos de objeto son diferentes, como "Human" tiene métodos equivalentes (quack y fly), se comporta y ofrece los métodos requeridos.

Type hint y mypy

El tipado dinámico de lenguajes como Python aporta accesibilidad y legibilidad, pero también tiene desventajas. Una de ellas es localizar errores en tiempo de ejecución porque Python no impone el tipo de las variables. El resultado puede ser errores y bugs difíciles de encontrar a medida que el código crece.

Python incorporó las type hints a partir de la versión 3.5. Las versiones anteriores pueden no soportar esta funcionalidad.

Veamos un ejemplo sencillo sin type hints ni mypy.

La función siguiente está pensada para restar enteros: resta dos números enteros y devuelve el resultado.

def sub_this(x,y):
    return 'Subtraction'
print(sub_this(8,'hello'))

Aquí la función debería aceptar dos enteros "x" e "y", pero como no hay reglas impuestas, puede recibir cualquier tipo de dato. Además, el valor devuelto puede ser cualquiera: se devuelve un "str" ("Subtraction") cuando lo esperado era un "int".

Veamos una implementación similar usando type hints y "mypy", que ayuda a aplicar comprobación estática de tipos y a reducir errores y bugs en el programa con facilidad.

"mypy" es un módulo de Python que permite la comprobación estática de tipos y combina el checking dinámico (duck typing) de Python con las type hints.

Necesitas instalar el paquete "mypy"
pip install mypy

Puedes crear un archivo llamado "mypy_example.py" en tu máquina local y escribir el siguiente código.
El siguiente código es un programa sencillo que acepta dos enteros como parámetros y, tras "->", indica que el tipo devuelto también es un "int". Sin embargo, la función devuelve el string "Subtracted two integers".

def sub_this(x:int,y:int) -> int:
    return 'Subtracted two integers'
print(sub_this(8,4))

Ejecuta el archivo anterior en la terminal con el siguiente comando.

mypy mypy_example.py

Verás un error que indica que se ha encontrado un valor de retorno "str" inesperado y que debería ser "int".

Cambiemos el valor de retorno para que sea la resta de los dos enteros y así se devuelva un entero.

def sub_this(x:int,y:int) -> int:
    return x - y
print(sub_this(8,4))

Los resultados anteriores muestran que se imprime el mensaje de éxito y no se detectan problemas.

¡Enhorabuena!

¡Has llegado al final de este tutorial!

En este tutorial has aprendido sobre la comprobación de tipos, los distintos sistemas de tipos en varios lenguajes, los métodos de Python ("type()" e "isinstance()"), el duck typing en Python y las type hints combinadas con "mypy".

Si quieres aprender más sobre Python, haz el curso de DataCamp Software Engineering for Data Scientists in Python.

Referencias:

1. Vídeo de Corey en YouTube sobre duck typing