Cómo comprobar si un diccionario en Python contiene solo tipos específicos

Introducción

En este laboratorio, aprenderás cómo verificar si un diccionario de Python contiene solo tipos específicos para sus claves y valores. El laboratorio se centra en comprender la importancia de la comprobación de tipos dentro de los diccionarios para garantizar la integridad de los datos.

Comenzarás creando un diccionario de muestra y explorando el concepto de comprobación de tipos. Luego, aprenderás cómo usar la función isinstance() en conjunto con la función all() para verificar que todas las claves y valores en un diccionario se ajusten a los tipos de datos esperados. Esta experiencia práctica te proporcionará las habilidades necesarias para validar el contenido de los diccionarios y mantener la confiabilidad del código.

Skills Graph

Comprender la comprobación de tipos en diccionarios

En este paso, exploraremos la importancia de la comprobación de tipos dentro de los diccionarios en Python. Los diccionarios son estructuras de datos versátiles que pueden almacenar pares clave-valor. Sin embargo, para garantizar la integridad y confiabilidad de tu código, es crucial entender cómo comprobar los tipos de las claves y valores almacenados en un diccionario.

Los diccionarios en Python se definen utilizando llaves {}. Cada elemento en un diccionario consta de una clave y un valor correspondiente, separados por dos puntos :.

Comencemos creando un diccionario simple:

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

print(my_dict)

Guarda el código anterior en un archivo llamado type_checking.py dentro de tu directorio ~/project. Puedes usar el editor VS Code para crear y editar este archivo.

Ahora, ejecuta el script utilizando el siguiente comando en la terminal:

python ~/project/type_checking.py

Deberías ver la siguiente salida:

{'name': 'Alice', 'age': 30, 'city': 'New York'}

En este diccionario, las claves son cadenas de texto ("name", "age", "city") y los valores son una cadena de texto ("Alice"), un entero (30) y otra cadena de texto ("New York").

La comprobación de tipos se vuelve importante cuando quieres asegurarte de que los datos almacenados en tu diccionario se ajusten a tus expectativas. Por ejemplo, podrías querer verificar que la edad siempre sea un entero o que el nombre siempre sea una cadena de texto.

Consideremos un escenario en el que quieres agregar un nuevo par clave-valor al diccionario, pero quieres asegurarte de que el valor sea de un tipo específico.

Abre el archivo type_checking.py en VS Code y modifícalo de la siguiente manera:

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Function to add a key-value pair with type checking
def add_item(dictionary, key, value, expected_type):
    if isinstance(value, expected_type):
        dictionary[key] = value
        print(f"Added {key}: {value} to the dictionary.")
    else:
        print(f"Error: {key} must be of type {expected_type.__name__}.")

## Example usage
add_item(my_dict, "occupation", "Engineer", str)
add_item(my_dict, "salary", 75000, int)
add_item(my_dict, "is_active", True, bool)
add_item(my_dict, "height", "5.8", float) ## Intentionally incorrect type

print(my_dict)

En este código, definimos una función add_item que toma un diccionario, una clave, un valor y un tipo esperado como entrada. La función utiliza la función isinstance() para comprobar si el valor es del tipo esperado. Si lo es, el par clave-valor se agrega al diccionario. De lo contrario, se imprime un mensaje de error.

Ejecuta el script nuevamente:

python ~/project/type_checking.py

Deberías ver la siguiente salida:

Added occupation: Engineer to the dictionary.
Added salary: 75000 to the dictionary.
Added is_active: True to the dictionary.
Error: height must be of type float.
{'name': 'Alice', 'age': 30, 'city': 'New York', 'occupation': 'Engineer', 'salary': 75000, 'is_active': True}

Como puedes ver, la función add_item agregó con éxito los pares clave-valor "occupation", "salary" y "is_active" al diccionario porque sus valores coincidieron con los tipos esperados. Sin embargo, imprimió un mensaje de error para "height" porque el valor proporcionado ("5.8") es una cadena de texto, mientras que el tipo esperado era float.

Este ejemplo demuestra el concepto básico de comprobación de tipos en diccionarios. En los siguientes pasos, exploraremos técnicas más avanzadas para garantizar la seguridad de tipos en tu código Python.

Comprobar los tipos de claves y valores

En el paso anterior, aprendimos cómo comprobar el tipo de los valores al agregarlos a un diccionario. Ahora, profundicemos y exploremos cómo comprobar los tipos de tanto las claves como los valores dentro de un diccionario.

Es esencial asegurarse de que las claves en un diccionario sean tipos inmutables como cadenas de texto, números o tuplas. Los valores, por otro lado, pueden ser de cualquier tipo. Modifiquemos nuestro archivo type_checking.py para incluir la comprobación del tipo de las claves.

Abre el archivo type_checking.py en VS Code y modifícalo de la siguiente manera:

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Function to add a key-value pair with type checking for both key and value
def add_item(dictionary, key, value, expected_key_type, expected_value_type):
    if not isinstance(key, expected_key_type):
        print(f"Error: Key must be of type {expected_key_type.__name__}.")
        return
    if not isinstance(value, expected_value_type):
        print(f"Error: Value must be of type {expected_value_type.__name__}.")
        return
    dictionary[key] = value
    print(f"Added {key}: {value} to the dictionary.")

## Example usage
add_item(my_dict, "occupation", "Engineer", str, str)
add_item(my_dict, "salary", 75000, str, int)
add_item(my_dict, 123, "Some Value", str, str) ## Intentionally incorrect key type

print(my_dict)

En este código actualizado, la función add_item ahora toma expected_key_type y expected_value_type como argumentos. Comprueba si la clave y el valor proporcionados son del tipo esperado utilizando isinstance(). Si la clave o el valor tienen un tipo incorrecto, se imprime un mensaje de error y la función devuelve sin agregar el elemento al diccionario.

Ahora, ejecuta el script:

python ~/project/type_checking.py

Deberías ver la siguiente salida:

Added occupation: Engineer to the dictionary.
Added salary: 75000 to the dictionary.
Error: Key must be of type str.
{'name': 'Alice', 'age': 30, 'city': 'New York', 'occupation': 'Engineer', 'salary': 75000}

La salida muestra que los pares clave-valor "occupation" y "salary" se agregaron con éxito al diccionario porque tanto sus claves como sus valores coincidieron con los tipos esperados. Sin embargo, cuando intentamos agregar un par clave-valor con una clave entera (123), la función imprimió un mensaje de error porque el tipo de clave esperado era str.

Comprobar los tipos de tanto las claves como los valores ayuda a mantener la consistencia y corrección de tus datos. Evita errores inesperados y asegura que tu diccionario se comporte como se espera.

Usar all() con isinstance()

En este paso, exploraremos cómo usar la función all() en combinación con isinstance() para comprobar de manera eficiente los tipos de todas las claves y valores en un diccionario. Este enfoque es especialmente útil cuando necesitas validar todo el diccionario frente a un conjunto de tipos esperados.

La función all() en Python devuelve True si todos los elementos en un iterable son verdaderos. Podemos usar esta función para iterar a través del diccionario y comprobar si todas las claves y valores coinciden con los tipos esperados.

Modifiquemos nuestro archivo type_checking.py para incorporar este enfoque.

Abre el archivo type_checking.py en VS Code y modifícalo de la siguiente manera:

## Create a dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Function to check types of all keys and values in a dictionary
def check_dictionary_types(dictionary, expected_key_type, expected_value_type):
    key_types_correct = all(isinstance(key, expected_key_type) for key in dictionary)
    value_types_correct = all(isinstance(value, expected_value_type) for value in dictionary.values())

    if key_types_correct and value_types_correct:
        print("All keys and values have the correct types.")
        return True
    else:
        print("Not all keys and values have the correct types.")
        return False

## Example usage
check_dictionary_types(my_dict, str, (str, int)) ## Expecting keys to be strings and values to be either strings or integers

my_dict["zip"] = "10001"
check_dictionary_types(my_dict, str, (str, int))

my_dict["country"] = 123
check_dictionary_types(my_dict, str, (str, int))

En este código, la función check_dictionary_types toma un diccionario, un tipo de clave esperado y un tipo de valor esperado como entrada. Utiliza la función all() con una expresión generadora para comprobar si todas las claves son del tipo esperado y si todos los valores son del tipo esperado. Si ambas condiciones son verdaderas, imprime un mensaje de éxito y devuelve True. De lo contrario, imprime un mensaje de error y devuelve False.

Ejecuta el script:

python ~/project/type_checking.py

Deberías ver la siguiente salida:

All keys and values have the correct types.
All keys and values have the correct types.
Not all keys and values have the correct types.

La primera llamada a check_dictionary_types devuelve True porque todas las claves son cadenas de texto y todos los valores son cadenas de texto o enteros. La segunda llamada también devuelve True después de agregar la clave "zip". Sin embargo, la tercera llamada devuelve False después de agregar la clave "country" con un valor entero, porque ahora una de las claves es un entero, lo que viola el tipo de clave esperado.

Usar all() con isinstance() proporciona una forma concisa y eficiente de validar los tipos de todos los elementos en un diccionario, asegurando la integridad de los datos y evitando errores inesperados en tu código Python.

Resumen

En este laboratorio, comenzamos por entender la importancia de la comprobación de tipos en los diccionarios de Python, que son estructuras de datos versátiles que almacenan pares clave-valor. Creamos un diccionario de muestra con claves de tipo cadena de texto y valores de tipos mixtos (cadena de texto y entero) y destacamos la necesidad de garantizar la integridad de los datos verificando los tipos de las claves y los valores.

El primer paso resaltó la importancia de la comprobación de tipos para asegurarse de que los datos almacenados en un diccionario se ajusten a los tipos esperados, como verificar que una edad siempre sea un entero o un nombre siempre sea una cadena de texto. La configuración del laboratorio implicó crear un archivo type_checking.py y ejecutarlo para mostrar el contenido del diccionario.