Obtener la longitud del diccionario en Python

Los diccionarios en Python son una colección de pares de datos clave-valor. Estos se utilizan en muchas manipulaciones en Python y son una de las estructuras de datos más importantes en Python. Para calcular la longitud del diccionario, len()se utiliza el método integrado.

método len() en Python:

Este método incorporado toma un objeto de Python como argumento y devuelve la cantidad de elementos que contiene. Se puede usar en strings, listas, diccionarios, tuplas y conjuntos. Lo único que se debe anotar es que el argumento debe ser una secuencia o una colección.

Encontrar la longitud de un diccionario simple:

Considere los siguientes detalles de una persona:

Name:Steve
Age:30
Designation:Programmer

Esta información se puede denotar mediante un diccionario simple. Un diccionario simple contiene solo algunos pares clave-valor. No son muy complejos. Cuando len()se aplica el método, da directamente la respuesta. Da el número de entradas en el diccionario. Por ejemplo:

# Python program to find 
# length of the dictionary
  
  
# a simple dictionary
dict1 ={'Name':'Steve', 'Age':30, 'Designation':'Programmer'}
  
# using len() counts the
# number of entries
print("len() method :", len(dict1))
  
# using dict.keys() counts
# the no.of.keys in dictionary
print("len() method with keys() :", len(dict1.keys()))
  
# using dict.values() counts
# the no.of.valuess in dictionary
print("len() method with values():", len(dict1.values()))

Producción:

len() method : 3
len() method with keys() : 3
len() method with values(): 3

Encontrar la longitud del diccionario anidado:

Considere los siguientes detalles acerca de una persona:

Name:Steve
Age:30
Designation:Programmer
address:
      Street:Brigade  Road
      City:Bangalore
      Country:India

Este tipo de información se puede representar mediante diccionarios anidados. Los diccionarios anidados contienen diccionarios dentro de diccionarios. En un par clave-valor, para una clave, otro diccionario puede ser el valor. En tales casos, si simplemente se pasa el diccionario al len()método, la salida no será correcta. Mira el código a continuación:

# Python program to find 
# length of the nested dictionary
  
  
# A nested dictionary
dict2 ={ # outer dictionary
       'Name':'Steve',
       'Age':30,
       'Designation':'Programmer',
       'address':{# inner dictionary
           'Street':'Brigade Road',
           'City':'Bangalore',
           'Country':'India'
         
                 }
      }
  
print("len() method :", len(dict2))
print("len() method with keys() :", len(dict2.keys()))
print("len() method with values():", len(dict2.values()))

Producción:

len() method : 4
len() method with keys() : 4
len() method with values(): 4

Aquí, cualquiera que sea el método que aplique, obtendrá solo ‘4’ como salida. Pero el número real de entradas es ‘7’. Las claves son nombre, edad, designación, dirección, calle, ciudad y país. El método considera el diccionario interno que es un valor para una de las claves como un valor único. Para superar este problema, debemos agregar explícitamente la longitud del diccionario interno al externo. Se puede codificar como se indica a continuación:

# Python program to find the
# length of the nested dictionary
  
  
# A nested dictionary
  
dict2 ={                   
       'Name':'Steve',
       'Age':30,
       'Designation':'Programmer',
       'address':
              {
           'Street':'Brigade Road',
           'City':'Bangalore',
           'Country':'India'
              }
      }
  
# total length = length of outer dict +
# length of inner dict
length = len(dict2)+len(dict2['address'])
  
print("The length of the nested dictionary is ", length)

Producción:

The length of the nested dictionary is  7

Ahora funciona bien!!!

Sin embargo, ¿es posible programar explícitamente para agregar la longitud de los diccionarios internos cada vez? ¿Qué pasa si no sabemos a priori cuántos diccionarios internos hay? Ahora considere el siguiente detalle:

Name:
    first name:Steve
    last name:Jobs
Age:30
Designation:Programmer
address:
      Street:Brigade  Road
      City:Bangalore
      Country:India

Aquí tenemos dos diccionarios internos. No es una forma optimizada de agregar explícitamente la longitud de los diccionarios internos cada vez. Podemos resolver este problema combinando isinstance()con el len()método.

método isinstance():

Este método toma dos argumentos. El primero es objeto . Necesitamos pasarle un objeto de Python. El objeto puede ser un int, un float, un iterable o cualquier cosa. El segundo argumento a pasar es tipo/clase . Denota el tipo/clase contra el cual se verifica el primer argumento para su instancia. Este método puede ayudarnos a encontrar la longitud de un diccionario anidado.

La idea es almacenar primero la longitud de todo el diccionario en una variable (por ejemplo, ‘longitud’ aquí) . Luego recorre todo el values()diccionario y verifica si es una instancia de dict. Si 'True'entonces se encuentra la longitud de ese diccionario interno y se agrega a la variable length. De esta forma se podría encontrar la longitud total de un diccionario anidado. El código de ejemplo se proporciona a continuación.

# Python program to find
# length of nested dictionary
  
  
# nested dictionary
dict2 ={
       'Name':
           {
               'first_name':'Steve',
               'Last_name':'Jobs'
           },
       'Age':30,
       'Designation':'Programmer',
       'address':
           {
           'Street':'Rockins Road',
           'City':'Bangalore',
           'Country':'India'
           }       
      }
  
# storing the outer dictionary length 
length = len(dict2)
  
# iterating to find the length
#  of all inner dictionaries
for i in dict2.values():
      
    # checking whether the value is a dictionary
    if isinstance(i, dict):
        length += len(i)
          
print("The length of the dictionary is", length)

Producción:

The length of the dictionary is  9

Si el diccionario está más profundamente anidado como se muestra a continuación:

Name:
    first name:Steve
    last name:Jobs
Age:30
Designation:Programmer
address:
      Street:
          St_number:4
          St_name:Brigade  Road
      City:Bangalore
      Country:India

Luego modifique el código como se indica a continuación:

# Python program to find 
# length of nested dictionary
  
  
# nested dictionary
dict2 ={
       'Name':
           {
               'first_name':'Steve',
               'Last_name':'Jobs'
           },
       'Age':30,
       'Designation':'Programmer',
       'address':
           {
           'Street':
               {
                   'st_number':4,
                   'st_name':'Rockins Road'
               },
           'City':'Bangalore',
           'Country':'India'
           }       
      }
  
# storing the outer dictionary length 
length = len(dict2)
  
# iterating to find the length 
# of all inner dictionaries
for i in dict2.values():
      
    # checking whether the value is a dictionary
    if isinstance(i, dict):
          
        # add the length of inner dictionary
        length += len(i)
          
        # check whether th inner dictionary
        # is further nested
        for j in i.values():
              
             if isinstance(j, dict):
                length += len(j)
          
print("The total length of the dictionary is ", length)

Producción:

The total length of the dictionary is  11