Tipado estático en Python

Clase 5 de 21 • Curso Profesional de Python

Alfonso Morán

student•

Yo aquí veo un área de oportunidad para tener mejores prácticas de código. Este es el tipo de cosas que esperaba aprender en un curso avanzado. Demasiada información nueva para mi en esta clase, tengo muchas preguntas sobre esto y me gusta. Espero que se resuelvan en las siguientes clases.

Anthony Jean Paul Blaz Lazo

student•

Me paso lo mismo

Reinaldo Mendoza

student•

Excelente que se pueda hacer eso en python, lo echaba en falta

Kevin Mejia

student•

Tipado estático en Python

. Para hacer que Python sea de tipado estático es necesario agregar algo de sintaxis adicional a lo aprendido, además, esta característica solo se puede aplicar a partir de la versión 3.6.

# De esta manera se declara una variable, se colocan los dos puntos (:), el tipo de dato y para finalizar se usa el signo igual para asignar el valor a la variable.

<variable> : <tipo_de_dato> = <valor_asignado>

a: int = 5
print(a)

b: str = "Hola"
print(b)

c: bool = True
print(c)

Del mismo modo se puede usar esta metodología de tipado en Python a funciones adicionando el signo menos a continuación del signo mayor que para determinar el tipo de dato. Ejemplo:

def <nombre_func> ( <parametro1> : <tipo_de_dato>, <parametro2> : <tipo_de_dato> ) ->  <tipo_de_dato> :
	pass

def suma(a: int, b: int) -> int :
	return a + b

print(suma(1,2))

# 3

Existe una librería de fabrica que viene preinstalada con Python que se llama typing, que es de gran utilidad para trabajar con tipado con estructuras de datos entre la versión 3.6 y 3.9, entonces: .

from typing import Dict, List

positives: List [int] = [1,2,3,4,5]

users: Dict [str, int] = {
	"argentina": 1.
	"mexico": 34,
	"colombia": 45,
}

countries: List[Dict[str, str]] = [
	{
		"name" : "Argentina",
		"people" : "45000",
	},
	{
		"name" : "México",
		"people" : "9000000",
	},
	{
		"name" : "Colombia",
		"people" : "99999999999",
	}
]

from typing import Tuple, Dict, List

CoordinatesType = List[Dict[str, Tuple[int, int]]]

coordinates: CoordinatesType = [
	{
		"coord1": (1,2),
		"coord2": (3,5)
	},
	{
		"coord1": (0,1),
		"coord2": (2,5)
	}
]

Modulo mypy

. El modulo mypy se complementa con el modulo typing ya que permitirá mostrar los errores de tipado debil en Python.

fidel angel ochoa

student•

EXCELENTE RESUMEN!

María Jimena Rodríguez Contreras

student•

muchas gracias

Kevin Mejia

student•

Los lenguajes de tipado fuerte y estático orgullosos porque estamos aplicando este tipo de conceptos en Python. 😎👌 .

Reinaldo Mendoza

student•

jaja

Mauricio Gonzalez Falcon

student•

JAJAJA

Andrés Gutiérrez Arcia

student•

Recomiendo usar Optional[], de la libreria typing, es para cuando ocupamos retornar None u otra variable

def foo() -> Optional[List]:
  if b:
    return []
  else:
    None

Cesar Hernández Ramírez

student•

Buen dato

Carlos Rodríguez

student•

Grandioso dato.

Ernesto Crespo

student•

Existe Pydantic que es un validador de tipos. pydantic

Carlos Rodríguez

student•

Gran aporte.

Daniel Alejandro Franco Meneses

student•

JavaScript también necesitaba un tipado más estático, entonces crearon TypeScript. Un tipado más fuerte no solo da mucho feedback al programador, sino que se pueden evitar muchos errores y el programa puede ser más robusto.

Mauricio Gonzalez Falcon

student•

Es incluso más sencillo de programar en algunas ocasiones por eso mismo, se evitan errores!

Carlos Rodríguez

student•

Genial.

Cesar Hernández Ramírez

student•

Resumen express Para decirle a python de qué tipo de dato será una variable utilizaremos la siguiente sintaxis: Ejemplos

En el caso de los int : total: int = 120
En el caso de los strings : frase: str = 'Hola mundo'
En el caso de los booleanos : hambre: bool = True
En el caso de los float : velocidad: float = 48.2

Si se fijan es siempre la misma sintaxis, primero el nombre de la variable, después su tipo y su valor.

Para las estructuras de datos Con las listas, diccionarios y tuplas necesitaremos importar la librería typing y sus respectivos módulos, los cuales algunos son Dict, List y Tuple. Ejemplos

Para una lista : edades: List[int] = [24, 18, 22]
Para un **diccionario ** (primero el tipo de la llave y luego el del valor): poblacion: Dict[str, int] = { 'México': 131214372, 'Colombia': 50.374.000 }
Para una **tupla ** declararémos el tipo de cada valor individualmente, no de manera general: constantes: Tuple[int, str, int, int, str] = ( 2, 'Hola', 4, 6, 'Adiós' )

Ahora que sabes las bases Puedes replicar todo esto en cualquier otra cosa, por ejemplo al declarar los argumentos de una función, es exactamente la misma sintaxis, o al hacer una lista con diccionarios dentro, es exactamente lo mismo a anidar lo anterior.

walter Jorge

student•

Buen aporte .

Gabriel Missael Barco

student•

Tipado estático en Python

Podemos convertir a Python a un lenguaje de tipado estático 🤯. Para eso, usamos Static Typing, y es muy sencillo, solo debemos añadir una sintaxis adicional, en la cual declaramos variables con su tipo.
```
a: int = 5
b: str = 'Hola'
c: bool = True

print(a, b, c)
```
Esto funciona desde Python 3.6 👀. Para hacerlo con funciones (con sus variables y con lo que retorna la función):
```
def suma(a: int, b: int) -> int:
	return a + b

print(suma(1, 2))
```
Si le pasamos strings a la función suma, si funcionará y nos va a regresar las strings sumadas, para evitar esto, debemos añadir un módulo.

Podemos hacer tipado en estructuras de datos. Para definir que una variable es de un tipo (de una estructura de datos), desde la versión 3.9, podemos hacerlo con las palabras claves de ese tipo. Antes de la versión 3.9, es con:

from typing import Dict, List

positives: List[int] = [1, 2, 3, 4, 5]

users: Dict[str, int] = {
	'argentina': 1,
	'mexico': 34,
	'colombia': 45
}

countries: List[Dict[str, str]] = [
	{
		'name':'Argentina'
		'people':'45000'
	},
	{
		'name':'México'
		'people':'900000'
	},
	{
		'name':'Colombia'
		'people':'9999999'
	}
]

Podemos hacer lo mismo con las tuplas:

from typing import Tuple

numbers: Tuple[int, float, int] = (1, 0.5, 1)

Podemos definir nuestros propios tipos de variable y usarlas:

from typing import Tuple, Dict, List

CoordinateType = List[Dict[str, Tuple[int, int]]]

coordinates: CoordinateType = [
	{
		'coord1': (1, 2),
		'coord2': (3, 5)
	},
	{
		'coord1': (0, 1),
		'coord2': (2, 5)
	}
]

Para que Python considere este tipado estático y no se salte, es con el módulo mypy que nos detiene cuando hay errores de tipado 👀.

María Jimena Rodríguez Contreras

student•

gracias

Andrés Felipe Lopez gomez

student•

Excelente ejemplo

Edinson Requena

student•

Estos son los ejemplos de la clase (con algo extra)

"""
Pratice Static Typing
"""

from typing import Dict, List, Tuple

# Example 1
a: int = 1
b: str = 'I am a string'
c: bool = True

# Example 2
def add(a: int, b: int) -> int:
    return a + b

# Example 3
positives_numbers: List[int] = [1, 2, 3, 4, 6, 6, 7, 8]

# Example 4
users_at_platzi: Dict[str, int] = {
    'Venezuela': 5000,
    'Mx': 100000,
    'Argentina': 2000
}

# Example 5
countries: List[Dict[str, str]] = [
    {
        'name': 'Venezuela',
        'capital': 'Caracas'
    },
    {
        'name': 'Argentina',
        'capital': 'Buenos Aires'
    }
]

# Example 6
num: Tuple[int, bool, str, float] = (1, False, 'Hola', 3.5)

# Example 7
msg: str = 'This are the coordinates'
CoordinatesType = list[Dict[str, Tuple[int, int, str]]]

coordinates: CoordinatesType = [
    {
        'place1': (4, 5, msg),
        'place2': (10, 45, msg),
    },
        {
        'place1': (42, 555, msg),
        'place2': (104, 945, msg),
    },
]

Javier Suárez Meerhoff

student•

gracias!

ANDREA FERNANDA OTÁLORA FIGUEROA

student•

++TIPADO ESTÁTICO EN PYTHON++

mypy -> módulo que permite trabajar con tipos en Python y permite ver los errores en consola. Se complementa con el módulo Typing. VENTAJAS
Aporta claridad y calidad al código. Así va a ser más entendible para otros desarrolladores.
Nos devuelve los errores antes de que el programa se ejecute.

David Jesús Rodríguez La Riva

student•

muy buen aporte gracias

Jhon Edward Bedoya

student•

🟢 Hello!

Te felicito, tomas excelentes apuntes! 👏🏼 Te invito a que pruebes la herramienta Notion, en ella lograrías cosas increíbles con tu capacidad de síntesis 🤗

Si quieres dominar la herramienta, te recomiendo el Curso de Organización y Productividad con Notion, está ¡genial! 🚀

Un abrazo de gol! 🦾

Daniel Toro

student•

¿Cómo se hace para especificar un diccionario cuyos items tienen diferentes tipos? Por ejemplo, si mi diccionario tiene la siguiente estructura:

my_dict = { 'a': 'hola', 'b': 4}

¿Cómo debería definirlo?

Daniel Toro

student•

Ya vi en la documentación que se puede especificando el tipo Any, en el caso del ejemplo que puse en la pregunta, quedaría de la siguiente manera:

from typing import Any, Dict
my_dict: Dict[str, Any] = {'a': 'hola', 'b': 4}

Dejo el link de donde saqué me guié: https://docs.python.org/3/library/typing.html#the-any-type

Omar Daniel Centeno

student•

Hola

He visto que para los diccionarios el tipado es más complejo y puedes hacer uso de un módulo que se llama typing y expresando en una clase cada tipo del key dentro del diccionario de la siguiente manera:

from typing import TypedDict


class NameInfo(TypedDict):
    name: str
    first_letter: str


def get_info(name: str) -> NameInfo:
    return {'name': name, 'first_letter': name[0]}

NICOLAS DAVID PASTRAN ZAMORA

student•

Creación de un tipo con clases

En la clase no se evaluó, el caso en que un diccionario debe tener una llave concreta y esa llave es de un tipo particular. Les dejo esta captura que muestra como crear este escenario y como verificarlo.

Carlos Mazzaroli

student•

Gracias por el aporte rey!

Miguel Angel Reyes Moreno

student•

Tipado estático en Python

Documentación oficial del tipado estático en Python

El tipado estático nos hará evitar errores de tipado antes de que el programa se ejecute.

a: int = 5
print(a) # 5

b: str = 'Hola'
print(b) # Hola

c: bool = True
print(c) # True

Esta sintaxís está disponible desde la versión 3.6 de Python.

def suma(a: int, b: int) -> int:
  return a + b

print(suma(1,2)) # 3

def suma(a: int, b: int) -> int:
  return a + b

print(suma('1','2')) # 12 😅

Usando tipado en estructuras de datos. Desde la versión 3.6 debemos importar librerias.

from typing import Dict, List

positives: List[int] = [1,2,3,4,5]

users: Dict[str, int] = {
  'argentina': 1,
  'mexico': 34,
  'colombia': 45,
}

countries: List[Dict[str,str]] = [
  {
    'name': 'Argentina',
    'people': '450000', # Cuatrocientos cincuenta mil
  },
  {
    'name': 'México',
    'people': '90000000', # Noventa millones
  },
  {
    'name': 'Colombia',
    'people': '99999999999', #novecientos noventa y nueve mil millones novecientos mil novecientos noventa y nueve
  }
]

from typing import Tuple

numbers: Tuple[int, float, int] = (1, 0.5, 1)

from typing import Tuple, Dict, List

CoordinatesType = List[Dict[str, Tuple[int, int]]]

#Una variable que es de tipo CoordinatesType 🤯
coordinates: CoordinatesType = [
  {
    'coord1': (1,2),
    'coord2': (3,5),
  },
  {
    'coord1': (0,1),
    'coord2': (2,5),
  },
]

Ventajas de esto: claridad del código.

Luis Alejandro Vera Hernandez

student•

Buen resumen, gracias

Wilmer Felipe Pungo

student•

Resumen de la clase

Tipado estático en Python

FALLBACK_PHONE = '+e00000000'

def get_phone():
	phone = input('Give me your phone: ')
	if not phone:
		return FALLBACK_PHONE.round()
	return int(phone)

def run():
	my_phone = get_phone()
	print(f'Your phone is: {my_phone}')

run()

print("Hello, world!")
# some code
a = 1
print(type(a))

# Hello, world!
# <class 'int'>

Se puede hacer de la siguiente forma: feacture desde la versión: python 3.6

a: int = 5
print(a)  

b: str = 'hola'
print(b)

c: bool = True
print(c)

# 5
# hola
# True

Puedo definir el tipo de variable a recibir y retornar def suma(a: int, b: int) -> int:

(aun se esta probando)

def suma(a: int, b: int) -> int:
	return a + b

print(suma(1, 2)

# 3

def suma(a: int, b: int) -> int:
	return a + b

print(suma("1", "2")

# 12

# se define el tipo de dato de las tuplas
from typing import Dict, Tuple, List

numbers: Tuple[int, float, int] = (1, 0.5, 1)
CoordinatesTypes = list[Dict[str, Tuple[int, int]]]
coordinates: CoordinatesTypes = [
    {
        'coord1': (1, 2),
        'coord2': (3, 4)
    },
    {
        'coord1': (0, 2),
        'coord2': (3, 5)
    },
]

Ventajas: nos va a devolver los errores antes de que el programa se ejecute

mypy nos permite trabajar con tipos y mostrar errores en consola, complementando con el modulo typing

Héctor Adrián Avilés Ramírez

student•

Interesante, pero entonces la pregunta si esto al final es una buena práctica y se entienden sus ventajas; ¿por qué python decidió ser un lenguaje de tipado dinámico o más bien por qué existen lenguajes así? Se entiende que tener la libertad de omitir los tipos de datos es una ventaja cuando se empieza a aprender algún lenguaje de programación pero quizá en un ambiente productivo algo así se vuelve un riesgo alto como lo ha explicado el profesor en sus clases.

Omar Daniel Centeno

student•

Hola

Hay que compensar el tiempo y trabajo que conlleva aprendizaje, el trabajo escribiendo código y otros factores. Al final existen muchas capas que se pueden abstraer para llegar al mismo resultado.

Con respecto al tema del tipado dinámico creo que es una abstracción para poder enfocar nuestra mente en cómo resolver el problema en lugar de enfocarse en definir exactamente el tipo del dato que se utilizará.

Es parte de la filosofía que sustenta este lenguaje de programación.

Adolfo Hristo David Roque Gámez

student•

Aparte, el tipado ayuda a atrapar ciertos bugs pero no todos, y para el autor de Python, es mejor manejar esos bugs con tests que con tipado. Es más conciso y fácil de leer una función sin anotaciones de tipos que con anotaciones de tipo. Pero creo que lo que dices de "tener la libertad de omitir los tipos" es al revés, se tiene la libertad de añadir type hints. Un tipado gradual que según Guido ayudará a los desarrolladores que quieran tener un poco más de correctitud.

Los primeros minutos de este vídeo explican cómo el tipado de Python funciona, qué opina el autor del tipado estático y el dinámico y cómo surgió Mypy: https://www.youtube.com/watch?v=GiZKuyLKvAA

Nicolás García Caicedo

student•

En el caso de que yo quisiera tener en un diccionarios llaves de diferente tipo, es decir, que la primera sea un string y su valor sea un string, pero que la segunda la lleva sea string y la segunda sea un entero ¿Cómo sería? Algo así:

person = {
	"Name": "Nicolas",
	"Edad": 15
}

Pablo Antipan Quiñenao

student•

Hola! Te refieres a algo como esto?

def this_test():
    a = {
        "name": "Pablo",
        "edad": 23,
        1: 2,
    }
    print(a)


if __name__ == "__main__":
    this_test()

Diego Guerrero

student•

Si, es correcto. Así debes plantear ese diccionario. Podrías meter hasta listas dentro de una llave.

Sebastian Wilde Alarcón Arenas

student•

None o cualquier tipo

from typing import Optional

def get_number() -> Optional[int]:
    """
	Esta function retorna int or None
	"""
	....

Más de un tipo

from typing import Union

def get_number() -> Union[int, float]:
	"""
	Esta function retorna int or float
	"""
	....

Luis Kennedy Saavedra Fuentes

student•

Las ventajas de utilizar tipado estático en python:

Nos aporta claridad del código.
Nos da calidad a lo que estamos programando.
Nuestro código va a ser mas entendible a otros programadores si trabajamos con tipos.
Nos va a devolver los errores antes del que programa se ejecute. ¿Cómo? Bueno la siguiente clase seguro lo vamos a ver :D. Éxitos codeando!!

Reinaldo Duguet

student•

'casteo' .. proviene de CASTING, que hace relación a la transformación del tipo de variable, ejemplo:

x = int("3")     # x será 3
y = str(2)       # y  será '2'
z = str(3.0)    # z será '3.0'

Juan Carlos Ortiz Romero

student•

Mypy es un verificador de tipo estático opcional para Python que tiene como objetivo combinar los beneficios de la escritura dinámica (o "pato") y la escritura estática.