<center>![Logo de Python](https://steemitimages.com/DQmT1MERsSVWugdrWh54xg3N1fu8Uzo8MsynCTsxhReYKEP/imagen.png)</center>

>Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis que favorezca un código legible. Se trata de un lenguaje de programación multiparadigma, ya que soporta orientación a objetos, programación imperativa y, en menor medida, programación funcional. Es un lenguaje interpretado, usa tipado dinámico y es multiplataforma.
Fuente: [Wikipedia](https://es.wikipedia.org/wiki/Python)

![Foto de una pitón](https://steemitimages.com/DQmX6w29LGxsvcjw1y4ahW9XCQSFE11r6HhJ4LvRwkBjV2B/imagen.png)
Autor: [skeeze](https://pixabay.com/es/users/skeeze-272447/)

Si has programado en el lenguaje **Python** o al menos escuchado de él, probablemente sepas que se trata de un lenguaje de tipado dinámico, es decir, una variable puede comenzar siendo un número entero, pasar a ser una cadena de texto y terminar siendo chocolate sin ningún problema. Esta característica ha generado que muchas personas lo amen mientras que otros programadores lo odien.

```python
var = 5
type(var)  # <class 'int'>

var = 'hola'
type(var)  # <class 'str'>

var = Chocolate()
type(var)  # <class '__main__.Chocolate'>
```

Si bien esta característica puede considerarse una ventaja en muchas ocasiones, y es muy común el los lenguajes interpretados, puede generar confusión en algunas ocasiones, dificultando la legibilidad y depuración de un programa. Lo que muchos no saben es que es posible incorporar al código **Python** algunas ventajas propias de los lenguajes estáticamente tipados. Haciendo uso de la sintaxis de anotación de funciones de Python3 (PEP 484) o de anotaciones basadas en comentarios en Python2 puede especificarse el tipo de datos esperado.

```python
def saludar(name: str) -> str:
    return "Hello, {}".format(name)
```

Esto ya puede suponer una mejora en la expresividad del código, si embargo, si utilizamos el *static type checker* conocido como **Mypy**, es posible detectar errores en tiempo de *compilación*. Mypy funciona como un *linter*, indicando errores generados por inconsistencia en los tipos de datos.

```python
def saludar(name: str) -> str:
    return "Hello, {}".format(name)

saludar(4)  # error: Argument 1 to "saludar" has incompatible type "int"; expected "str"
```

## Usando Mypy

Para usar **Mypy**, en primer lugar, debemos instalarlo; si estás familiarizado con los paquetes de Python no debería generarte mayor sorpresa, es tan sencillo como escribir en la terminal/linea de comandos:

```python
pip install mypy  # Para python2 o si solo tienes una versión de python agregada al path

pip3 install mypy  # Para python3
```

Una vez descargado puedes utilizarlo escribiendo en la linea de comandos:

```python
mypy nombre_del_archivo.py

python3 -m mypy nombre_del_archivo.py  # Otra opción
```

## Tipos de datos comunes

Ahora que sabemos lo fácil que es utilizar **Mypy** exploremos un poco los tipos de datos que podemos emplear:

Tipo | Descripción
------------ | -------------
int | Entero de tamaño arbitrario
Float | Número de punto flotante
bool | Booleano
str | Cadena de texto unicode
bytes | Cadena de 8-bit
object | Un objeto arbitrario
List[str] | Lista de objetos de tipo str
Tuple[int, int] | Una tupla de dos objetos de tipo int
Tuple[int, ...] | Una tupla de una cantidad arbitraria de objetos de tipo int
Dict[str, int] | Un diccionario con str como claves y int como valores
Iterable[int] | Un objeto iterable que retorna enteros (int)
Sequence[bool] | Una secuencia de valores booleanos
Any | Un tipo de asignación dinámica
Callable | Un objeto invocable (funciones, por ejemplo)

Fuente: [Documentación de Mypy](https://mypy.readthedocs.io/en/latest/)

Es importante aclarar que los tipos List, Tuple, Dict, Iterable, Sequence, Any y Callable deben ser importados del paquete **Typing** antes de poder usarlos, esto se realiza de la manera convencional, `from typing import List`. Bueno, con esto tienen suficiente para comenzar a explorar las posibilidades que ofrece **Mypy**, para más información los invito a visitar la [Wiki de Mypy](https://github.com/python/mypy/wiki).

En lo personal sólo recomiendo utilizar **Mypy** para proyectos medianos o grandes, porque facilita la escalabilidad y la refactorización de código. En otro caso, me parece que se pierde la sencillez y elegancia que caracteriza al código **Python**. Sin embargo, es sólo otra herramienta y cualquiera puede decidir si incorporarla o no a su flujo de trabajo, de hecho, permite la convivencia de  código de tipado estático y dinámico en el mismo proyecto, así que no es complicado migrar de forma progresiva de uno a otro. Espero que esta información les sea de utilidad. Hasta la próxima.