Per calcolare la lunghezza di un dizionario, possiamo usare il metodo len() integrato in Python. Il metodo len() restituisce il numero di chiavi in a Dizionario Python .
Sintassi Python Dict len()
Sintassi: len(Dict)
Ritorno: Restituisce un numero intero che rappresenta la lunghezza della stringa.
Name:Steve Age:30 Designation:Programmer>
Esempio base per trovare la lunghezza di un dizionario
Python3
stringa ti int
dict1>=>{>'Name'>:>'Steve'>,>'Age'>:>30>,>'Designation'>:>'Programmer'>}> print>(>'Dictionary:'>, dict1)> print>(>'Length of dictionary:'>,>len>(dict1))> |
>
>
Produzione:
Dictionary: {'Name': 'Steve', 'Age': 30, 'Designation': 'Programmer'} Length of dictionary: 3> Ricerca della lunghezza del dizionario nidificato
Considera i seguenti dettagli su una persona:
Name:Steve Age:30 Designation:Programmer address: Street:Brigade Road City:Bangalore Country:India>
Problema durante il tentativo di trovare la lunghezza del dizionario nidificato:
Python3
# 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()))> |
modello di progettazione del costruttore
>
>
Produzione:
metodo len() con keys() : 4
metodo len() con valori(): 4
Qui, qualunque sia il metodo applicato, otterrai solo '4' come output. Ma il numero effettivo di voci è '7'. Le chiavi sono nome, età, designazione, indirizzo, via, città e paese. Il metodo considera il dizionario esterno che è un valore per una delle chiavi come un valore singolo.
Per superare questo problema dobbiamo aggiungere esplicitamente la lunghezza del dizionario interno a quello esterno. Può essere codificato come indicato di seguito:
Python3
# 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)> |
>
>
Produzione:
The length of the nested dictionary is: 7>
Ora funziona bene!!! Tuttavia, è possibile programmare esplicitamente per aggiungere ogni volta la lunghezza dei dizionari interni? Cosa succede se non sappiamo in anticipo quanti dizionari interni ci sono? Consideriamo ora il seguente dettaglio:
Name: first name:Steve last name:Jobs Age:30 Designation:Programmer address: Street:Brigade Road City:Bangalore Country:India>
Qui abbiamo due dizionari interni. Non è un modo ottimizzato per aggiungere esplicitamente ogni volta la lunghezza dei dizionari interni. Possiamo risolvere questo problema combinando isinstance() con il metodo len(). L'idea è di memorizzare prima la lunghezza dell'intero dizionario in una variabile (dì 'lunghezza' qui) . Quindi scorrere tutti i valori() del dizionario e verificare se si tratta di un'istanza di dict. Se 'VERO' quindi la lunghezza di quel dizionario interno viene trovata e aggiunta alla variabile lunghezza . In questo modo è possibile trovare la lunghezza totale di un dizionario nidificato.
Esempio 1: ricerca dinamica della lunghezza del dizionario nidificato utilizzando il ciclo for:
Quando abbiamo più chiavi in un dizionario i cui valori sono ancora dizionari. Quindi dobbiamo verificare se il tipo del valore di ciascuna chiave, se è un dizionario, quindi usiamo len() sul valore e aggiungiamo il valore alla lunghezza del dizionario esterno.
ops
Python3
# 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)> |
>
>
Produzione:
The length of the dictionary is 9>
Nota: Questo approccio funzionerà solo quando la nidificazione dei dizionari è solo fino a 2 livelli.
Se il dizionario è ulteriormente annidato in profondità, come di seguito:
Name: first name:Steve last name:Jobs Age:30 Designation:Programmer address: Street: St_number:4 St_name:Brigade Road City:Bangalore Country:India>
Esempio 2: utilizzo della ricorsione per trovare la lunghezza del dizionario nidificato:
Qui abbiamo utilizzato una funzione ricorsiva count_nested_len() per contare la lunghezza di ciascun dizionario, iteriamo sulle chiavi dei dizionari, non appena un valore è un dizionario, ricusiamo su quel dizionario.
Python3
# 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'> >}> >}> # we use recursive function to count> # length of nested dictionaries> def> count_nested_len(d):> >length>=> len>(d)> >for> key, value>in> d.items():> >if> isinstance>(value,>dict>):> >length>+>=> count_nested_len(value)> >return> length> print>(>'Nested dictionary length:'>,> >count_nested_len(dict2))> |
>
>
Produzione:
Nested dictionary length: 11>
Approccio 3: Utilizzo della comprensione del dizionario
Python3
programmazione dinamica
# dizionario annidato
dict2 ={
'Nome':
{
'nome':'Steve',
'Cognome': 'Lavoro'
},
'Età': 30,
‘Designazione’:’Programmatore’,
'indirizzo':
{
'Strada':
{
'st_number':4,
'st_name':'Rockins Road'
},
'Città': 'Bangalore',
'Paese': 'India'
}
}
# Utilizzo della comprensione del dizionario per trovare la lunghezza del dizionario nidificato
lunghezza = len({k: v per k, v in dict2.items()})
print(La lunghezza del dizionario è, lunghezza)
#Questo codice è stato fornito da Edula Vinay Kumar Reddy
METODO 4:Utilizzo di un'espressione generatrice con la funzione sum().
APPROCCIO:
Un'espressione generatrice viene utilizzata per creare una sequenza di 1, dove ogni 1 corrisponde a una chiave nel dizionario. La funzione sum() viene quindi utilizzata per sommare gli 1, che danno la lunghezza del dizionario.
ALGORITMO:
1.Crea un'espressione generatrice che generi una sequenza di 1 per ciascuna chiave nel dizionario.
2.Utilizzare la funzione sum() per sommare gli 1 nella sequenza.
3.Restituisce la somma, che rappresenta la lunghezza del dizionario.
Python3
dict1>=> {>'Name'>:>'Steve'>,>'Age'>:>30>,>'Designation'>:>'Programmer'>}> length>=> sum>(>1> for> key>in> dict1)> print>(length)> |
>
>Produzione
aws sns
3>
La complessità temporale di questo approccio è O(n), dove n è il numero di chiavi nel dizionario.
La complessità spaziale di questo approccio è O(1)