Cómo comprobar si un diccionario en Python tiene un cierto número de claves

Introducción

En este laboratorio, aprenderás cómo verificar si un diccionario de Python tiene un número específico de claves. Esto implica explorar el tamaño del diccionario utilizando la función incorporada len() para determinar el número de pares clave-valor.

Crearás un script de Python para definir un diccionario, usar len() para obtener su tamaño e imprimir el resultado. También experimentarás con un diccionario vacío para observar la salida. Esta experiencia práctica demostrará cómo usar eficazmente len() para verificar la cantidad de claves en los diccionarios.

Explorar el tamaño del diccionario

En este paso, aprenderás cómo determinar el tamaño de un diccionario en Python. El tamaño de un diccionario se refiere al número de pares clave-valor que contiene. Saber el tamaño de un diccionario puede ser útil para diversas tareas, como comprobar si un diccionario está vacío o determinar si ha alcanzado una cierta capacidad.

Para encontrar el tamaño de un diccionario, puedes usar la función incorporada len(). Esta función devuelve el número de elementos (pares clave-valor) en el diccionario.

Comencemos creando un sencillo script de Python para explorar esto.

Abre el editor de VS Code en el entorno de LabEx.
Crea un nuevo archivo llamado dictionary_size.py en el directorio ~/project.
```
touch ~/project/dictionary_size.py
```
Abre el archivo dictionary_size.py en el editor y agrega el siguiente código de Python:
```
## Create a sample dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Get the size of the dictionary using the len() function
dict_size = len(my_dict)

## Print the size of the dictionary
print("The size of the dictionary is:", dict_size)
```
Este código primero crea un diccionario llamado my_dict con tres pares clave-valor. Luego, utiliza la función len() para obtener el tamaño del diccionario y lo almacena en la variable dict_size. Finalmente, imprime el tamaño del diccionario en la consola.
Ahora, ejecuta el script de Python utilizando el siguiente comando en la terminal:
```
python ~/project/dictionary_size.py
```
Deberías ver la siguiente salida:
```
The size of the dictionary is: 3
```
Esta salida confirma que la función len() devuelve correctamente el número de pares clave-valor en el diccionario.

Intentemos con un diccionario vacío. Modifica el archivo dictionary_size.py para que sea el siguiente:

## Create an empty dictionary
my_dict = {}

## Get the size of the dictionary using the len() function
dict_size = len(my_dict)

## Print the size of the dictionary
print("The size of the dictionary is:", dict_size)

Ejecuta el script nuevamente:
```
python ~/project/dictionary_size.py
```
Deberías ver la siguiente salida:
```
The size of the dictionary is: 0
```
Esto muestra que un diccionario vacío tiene un tamaño de 0.

Usar len() en las claves

En el paso anterior, aprendiste cómo usar la función len() para determinar el número total de pares clave-valor en un diccionario. En este paso, explorarás cómo usar len() en conjunto con el método .keys() para encontrar el número de claves en un diccionario.

El método .keys() devuelve un objeto de vista que muestra una lista de todas las claves en el diccionario. Luego, puedes usar la función len() en este objeto de vista para obtener el recuento de claves. Esto puede ser útil cuando solo necesitas saber el número de claves y no el número total de pares clave-valor.

Modifiquemos el script de Python del paso anterior para demostrar esto.

Abre el archivo dictionary_size.py en el editor de VS Code (si no está ya abierto).
Modifica el archivo dictionary_size.py para que contenga el siguiente código de Python:
```
## Create a sample dictionary
my_dict = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

## Get the keys of the dictionary using the .keys() method
keys = my_dict.keys()

## Get the number of keys using the len() function
num_keys = len(keys)

## Print the number of keys
print("The number of keys in the dictionary is:", num_keys)
```
En este código, primero creamos un diccionario llamado my_dict. Luego, usamos el método .keys() para obtener un objeto de vista que contiene todas las claves del diccionario. Almacenamos este objeto de vista en la variable keys. Finalmente, usamos la función len() para obtener el número de claves en el objeto de vista keys e imprimimos el resultado.
Ejecuta el script de Python utilizando el siguiente comando en la terminal:
```
python ~/project/dictionary_size.py
```
Deberías ver la siguiente salida:
```
The number of keys in the dictionary is: 3
```
Esta salida confirma que la función len(), cuando se usa con el método .keys(), devuelve correctamente el número de claves en el diccionario.

Ahora, intentemos agregar un nuevo par clave-valor al diccionario y veamos cómo afecta el número de claves. Modifica el archivo dictionary_size.py para que sea el siguiente:

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

## Add a new key-value pair
my_dict["occupation"] = "Engineer"

## Get the keys of the dictionary using the .keys() method
keys = my_dict.keys()

## Get the number of keys using the len() function
num_keys = len(keys)

## Print the number of keys
print("The number of keys in the dictionary is:", num_keys)

Ejecuta el script nuevamente:
```
python ~/project/dictionary_size.py
```
Deberías ver la siguiente salida:
```
The number of keys in the dictionary is: 4
```
Esto muestra que agregar un nuevo par clave-valor aumenta el número de claves en el diccionario.

Comparar con el recuento deseado

En los pasos anteriores, aprendiste cómo determinar el tamaño de un diccionario y cómo contar el número de claves. En este paso, aprenderás cómo comparar el tamaño de un diccionario (o el número de claves) con un recuento deseado. Esto es útil cuando necesitas validar que un diccionario tenga un número específico de pares clave-valor o claves antes de continuar con otras operaciones.

Modifiquemos el script de Python del paso anterior para demostrar esto.

Abre el archivo dictionary_size.py en el editor de VS Code (si no está ya abierto).

Modifica el archivo dictionary_size.py para que contenga el siguiente código de Python:

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

## Desired count
desired_count = 3

## Get the size of the dictionary
dict_size = len(my_dict)

## Compare with desired count
if dict_size == desired_count:
    print("The dictionary size matches the desired count.")
else:
    print("The dictionary size does not match the desired count.")

## Get the number of keys
num_keys = len(my_dict.keys())

## Compare the number of keys with desired count
if num_keys == desired_count:
    print("The number of keys matches the desired count.")
else:
    print("The number of keys does not match the desired count.")

En este código, primero creamos un diccionario llamado my_dict y establecemos una variable desired_count en 3. Luego, obtenemos el tamaño del diccionario utilizando la función len() y lo comparamos con el desired_count. Imprimimos un mensaje que indica si el tamaño del diccionario coincide con el recuento deseado. Luego repetimos el mismo proceso para el número de claves en el diccionario.

Ejecuta el script de Python utilizando el siguiente comando en la terminal:
```
python ~/project/dictionary_size.py
```
Deberías ver la siguiente salida:
```
The dictionary size matches the desired count.
The number of keys matches the desired count.
```
Esta salida confirma que tanto el tamaño del diccionario como el número de claves coinciden con el recuento deseado de 3.

Ahora, modifiquemos el diccionario y el recuento deseado para ver cómo cambia la comparación. Modifica el archivo dictionary_size.py para que sea el siguiente:

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

## Add a new key-value pair
my_dict["occupation"] = "Engineer"

## Desired count
desired_count = 4

## Get the size of the dictionary
dict_size = len(my_dict)

## Compare with desired count
if dict_size == desired_count:
    print("The dictionary size matches the desired count.")
else:
    print("The dictionary size does not match the desired count.")

## Get the number of keys
num_keys = len(my_dict.keys())

## Compare the number of keys with desired count
if num_keys == desired_count:
    print("The number of keys matches the desired count.")
else:
    print("The number of keys does not match the desired count.")

Ejecuta el script nuevamente:
```
python ~/project/dictionary_size.py
```
Deberías ver la siguiente salida:
```
The dictionary size matches the desired count.
The number of keys matches the desired count.
```
Ahora, tanto el tamaño del diccionario como el número de claves coinciden con el recuento deseado actualizado de 4.

Resumen

En este laboratorio, aprendiste cómo determinar el tamaño de un diccionario de Python utilizando la función len(). El laboratorio implicó crear un script de Python, dictionary_size.py, para explorar esta funcionalidad. Creaste un diccionario de muestra con pares clave-valor y luego utilizaste len(my_dict) para obtener el número de elementos en el diccionario, imprimiendo el resultado en la consola.

El laboratorio también demostró cómo funciona la función len() con un diccionario vacío, destacando su capacidad para devolver con precisión el número de pares clave-valor, incluso cuando el diccionario está vacío. Este conocimiento es crucial para tareas como comprobar si un diccionario está vacío o determinar si ha alcanzado una capacidad específica.