Ci sono due grandi considerazioni che il poster originale deve considerare:
- Ci sono problemi di clobbering nello spazio dei tasti? Per esempio,
{'a_b':{'c':1}, 'a':{'b_c':2}} si tradurrebbe in {'a_b_c':???}. La soluzione seguente elude il problema restituendo un iterabile di coppie.
- Se le prestazioni sono un problema, la funzione di riduzione della chiave (che in seguito definisco 'join') richiede l'accesso all'intero percorso della chiave, oppure può semplicemente fare O (1) funzionare su tutti i nodi dell'albero? Se vuoi essere in grado di dire
joinedKey = '_'.join(*keys), questo ti costerà O (N ^ 2) tempo di esecuzione. Tuttavia, se sei disposto a dirlo nextKey = previousKey+'_'+thisKey, ti farà guadagnare O (N) tempo. La soluzione seguente ti consente di fare entrambe le cose (poiché potresti semplicemente concatenare tutte le chiavi, quindi postprocessarle).
(Le prestazioni non sono probabilmente un problema, ma approfondirò il secondo punto nel caso in cui a chiunque interessi: Nell'attuare questo, ci sono numerose scelte pericolose. Se lo fai in modo ricorsivo e cedi e cedi, o qualcosa di equivalente che tocchi i nodi più di una volta (che è abbastanza facile da fare per caso), si stanno facendo potenzialmente O (2 ^ N) lavoro, piuttosto che O (N). Questo perché forse si sta calcolando una chiave apoi a_1poi a_1_i... e poi calcolando aallora a_1poi a_1_ii..., ma in realtà non dovresti dover calcolare di a_1nuovo. Anche se non lo stai ricalcolando, riproporlo (un approccio "livello per livello") è altrettanto negativo. Un buon esempio è pensare alla performance su {1:{1:{1:{1:...(N times)...{1:SOME_LARGE_DICTIONARY_OF_SIZE_N}...}}}})
Di seguito è una funzione che ho scritto flattenDict(d, join=..., lift=...)che può essere adattata a molti scopi e può fare quello che vuoi. Purtroppo è abbastanza difficile creare una versione pigra di questa funzione senza incorrere nelle penalità di prestazione sopra (molti builtin di Python come chain.from_iterable non sono effettivamente efficienti, che ho realizzato solo dopo test approfonditi di tre diverse versioni di questo codice prima di accontentarmi di questo).
from collections import Mapping
from itertools import chain
from operator import add
_FLAG_FIRST = object()
def flattenDict(d, join=add, lift=lambda x:x):
results = []
def visit(subdict, results, partialKey):
for k,v in subdict.items():
newKey = lift(k) if partialKey==_FLAG_FIRST else join(partialKey,lift(k))
if isinstance(v,Mapping):
visit(v, results, newKey)
else:
results.append((newKey,v))
visit(d, results, _FLAG_FIRST)
return results
Per capire meglio cosa sta succedendo, di seguito è riportato un diagramma per chi non ha familiarità con reduce(a sinistra), altrimenti noto come "piega a sinistra". A volte viene disegnato con un valore iniziale al posto di k0 (non parte dell'elenco, passato nella funzione). Ecco la Jnostra joinfunzione. Preelaboriamo ogni k n con lift(k).
[k0,k1,...,kN].foldleft(J)
/ \
... kN
/
J(k0,J(k1,J(k2,k3)))
/ \
/ \
J(J(k0,k1),k2) k3
/ \
/ \
J(k0,k1) k2
/ \
/ \
k0 k1
Questo è in realtà lo stesso di functools.reduce, ma dove la nostra funzione fa questo a tutti i percorsi chiave dell'albero.
>>> reduce(lambda a,b:(a,b), range(5))
((((0, 1), 2), 3), 4)
Dimostrazione (che altrimenti metterei in docstring):
>>> testData = {
'a':1,
'b':2,
'c':{
'aa':11,
'bb':22,
'cc':{
'aaa':111
}
}
}
from pprint import pprint as pp
>>> pp(dict( flattenDict(testData, lift=lambda x:(x,)) ))
{('a',): 1,
('b',): 2,
('c', 'aa'): 11,
('c', 'bb'): 22,
('c', 'cc', 'aaa'): 111}
>>> pp(dict( flattenDict(testData, join=lambda a,b:a+'_'+b) ))
{'a': 1, 'b': 2, 'c_aa': 11, 'c_bb': 22, 'c_cc_aaa': 111}
>>> pp(dict( (v,k) for k,v in flattenDict(testData, lift=hash, join=lambda a,b:hash((a,b))) ))
{1: 12416037344,
2: 12544037731,
11: 5470935132935744593,
22: 4885734186131977315,
111: 3461911260025554326}
Prestazione:
from functools import reduce
def makeEvilDict(n):
return reduce(lambda acc,x:{x:acc}, [{i:0 for i in range(n)}]+range(n))
import timeit
def time(runnable):
t0 = timeit.default_timer()
_ = runnable()
t1 = timeit.default_timer()
print('took {:.2f} seconds'.format(t1-t0))
>>> pp(makeEvilDict(8))
{7: {6: {5: {4: {3: {2: {1: {0: {0: 0,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0,
6: 0,
7: 0}}}}}}}}}
import sys
sys.setrecursionlimit(1000000)
forget = lambda a,b:''
>>> time(lambda: dict(flattenDict(makeEvilDict(10000), join=forget)) )
took 0.10 seconds
>>> time(lambda: dict(flattenDict(makeEvilDict(100000), join=forget)) )
[1] 12569 segmentation fault python
... sospiro, non pensare che sia colpa mia ...
[nota storica non importante a causa di problemi di moderazione]
Per quanto riguarda il presunto duplicato di Flatten, un dizionario di dizionari (2 livelli di profondità) di elenchi in Python :
La soluzione di quella domanda può essere implementata in termini di questa facendo sorted( sum(flatten(...),[]) ). Il contrario non è possibile: mentre è vero che i valori di flatten(...)possono essere recuperati dal presunto duplicato mappando un accumulatore di ordine superiore, non è possibile recuperare le chiavi. (modifica: Inoltre si scopre che la presunta domanda del proprietario duplicato è completamente diversa, in quanto tratta solo dizionari con una profondità esattamente di 2 livelli, sebbene una delle risposte in quella pagina fornisca una soluzione generale.)