Il modo migliore riconoscimento somiglianza lista lunghezze

Question

Ho un dict contenenti liste sotto i suoi tasti:

dct = {'a': [1, 2, 3], 
     'b': [1, 2, 3, 4], 
     'c': [1, 2]} 

Qual è il modo migliore per riconoscere se la lunghezza delle liste sono stesso o no ?

Questa è la mia soluzione:

import itertools 
len(set(itertools.imap(len, dct.viewvalues()))) == 1 

True se simile e False se non

UPD: In riferimento al consiglio @RaymondHettinger sostituire map a itertools.imap

Answer 1

La vostra soluzione sembra a posto.

Se si vuole tweek un po ', usare itertools.imap() al posto dimappa(). Ciò collasserà l'impronta di memoria su O (1) anziché su O (n).

Answer 2

Nota: ovgolovin's solution è molto meglio. Lascio questa risposta qui perché c'è una discussione che si riferisce ad essa.

La soluzione va bene, ma si potrebbe usare un generatore di espressione che usa meno memoria ed è più leggibile:

len(set(len(x) for x in dct.viewvalues()))) == 1 

Answer 3

In primo luogo, vorrei bastone con itervalues, che utilizza facile valutazione.

In secondo luogo, sarei cauto nel fare affidamento sull'utilizzo di set poiché esegue la ricerca del valore nell'insieme a ogni iterazione del dizionario. È O(1) in caso di eccedenza (e O(n) nel caso peggiore che è O(1) nel nostro caso se tutte le lunghezze sono uguali e O(n) se la lunghezza è diversa) in base allo docs. Ma è difficile valutare il sovraccarico dell'utilizzo del set.

Vorrei utilizzare all in questo caso. all non riesce quando trova il primo valore False. Quindi, la prima mancata corrispondenza della lunghezza interromperebbe il processo di interazione. Mentre, se si utilizza set, passerebbe attraverso tutta la lista fino alla fine e solo allora confrontare la sua lunghezza a 1.

>>> dct = {'a': [1, 2, 3], 
     'b': [1, 2, 3, 4], 
     'c': [1, 2]} 
>>> lenght_1 = len(dct.itervalues().next()) 
>>> all(len(value)==lenght_1 for value in dct.itervalues()) 
False 

>>> dct = {'a': [1, 2, 3], 
     'b': [1, 2, 4], 
     'c': [1, 2, 5]} 
>>> lenght_1 = len(dct.itervalues().next()) 
>>> all(len(value)==lenght_1 for value in dct.itervalues()) 
True 

Il codice può essere ottimizzato utilizzando lo stesso iteratore it che non passerà attraverso il primo valore due volte:

>>> it = dct.itervalues() 
>>> length_1 = len(next(it)) 
>>> all(len(value)==l1 for value in it) 
True 

Answer 4

Come Michael J. Barber ha suggerito nei commenti a the answer, ecco il codice che utilizza groupby e imap dal modulo itertools.

imap applica la funzione len ad ogni elenco.

groupby solo spilla i valori in blocchi della stessa lunghezza.

Quindi, se c'è più di una porzione di lunghezza, le lunghezze sono diverse. Se esiste un solo chuck di lunghezze, significa che le lunghezze degli elenchi sono uguali e che il secondo accesso all'iteratore groupby deve produrre StopIteration restituendo None (il valore predefinito della funzione next).

Il grande vantaggio di questo codice è che imap e groupby sono scritti in C e sono piuttosto veloci.

from itertools import imap,groupby 

dct = {'a': [1, 2, 3], 
     'b': [1, 2, 3, 4], 
     'c': [1, 2]} 

dct2 = {'a': [1, 2, 3], 
     'b': [1, 2, 34], 
     'c': [1, 2, 5]} 

def check_lenghts(iterable): 
    it = groupby(imap(len,iterable.itervalues())) 
    next(it,None) 
    return True if next(it,None)==None else False 

print(check_lenghts(dct)) 
print(check_lenghts(dct2))