Dizionario Python con più chiavi che punta allo stesso elenco in modo efficiente della memoria

Ho questo requisito unico che può essere spiegato da questo codice. Questo è un codice funzionante ma non efficiente in termini di memoria.

data = [[
        "A 5408599",
        "B 8126880",
        "A 2003529",
    ],
    [
        "C 9925336",
        "C 3705674",
        "A 823678571",
        "C 3205170186",
    ],
    [
        "C 9772980",
        "B 8960327",
        "C 4185139021",
        "D 1226285245",
        "C 2523866271",
        "D 2940954504",
        "D 5083193",
    ]]

temp_dict = {
    item: index for index, sublist in enumerate(data)
        for item in sublist
}

print(data[temp_dict["A 2003529"]])

out: ['A 5408599', 'B 8126880', 'A 2003529']

In breve, desidero che ogni elemento dell'elenco secondario sia indicizzabile e che debba restituire l'elenco secondario.

Il metodo sopra funziona ma richiede molta memoria quando i dati sono grandi. Esiste un modo migliore per la memoria e la CPU? I dati sono archiviati come file JSON.

Modifica Ho provato le risposte per lo scenario di utilizzo più ampio possibile (1000 elenchi secondari, 100 elementi in ciascun elenco secondario, 1 milione di query) e qui sono riportati i risultati (media di 10 esecuzioni):

Method,    Time (seconds),    Extra Memory used
my,        0.637              40 Mb
deceze,    0.63               40 Mb
James,     0.78               200 kb
Pant,      > 300              0 kb
mcsoini,   forever            0 kb

Sei davvero in uno spazio di scambio tra il tempo / memoria necessaria per generare il dizionario rispetto al tempo necessario per scansionare tutti i dati per un metodo al volo.

Se si desidera un metodo di memoria insufficiente, è possibile utilizzare una funzione che ricerca il valore in ciascun elenco secondario. L'uso di un generatore otterrà i risultati iniziali più velocemente per l'utente, ma per i set di dati di grandi dimensioni, questo sarà lento tra i ritorni.

data = [[
        "A 5408599",
        "B 8126880",
        "A 2003529",
    ],
    [
        "C 9925336",
        "C 3705674",
        "A 823678571",
        "C 3205170186",
    ],
    [
        "C 9772980",
        "B 8960327",
        "C 4185139021",
        "D 1226285245",
        "C 2523866271",
        "D 2940954504",
        "D 5083193",
    ]]


def find_list_by_value(v, data):
    for sublist in data:
        if v in sublist:
            yield sublist

for s in find_list_by_value("C 9772980", data):
    print(s)

Come menzionato nei commenti, la creazione di una tabella hash basata solo sulla prima lettera o sui primi 2 o 3 caratteri potrebbe essere un buon punto di partenza. Ciò ti consentirà di creare un elenco candidato di elenchi secondari, quindi scansionarli per vedere se il valore è nell'elenco secondario.

from collections import defaultdict

def get_key(v, size=3):
    return v[:size]

def get_keys(sublist, size=3):
    return set(get_key(v, size) for v in sublist)

def find_list_by_hash(v, data, hash_table, size=3):
    key = get_key(v, size)
    candidate_indices = hash_table.get(key, set())
    for ix in candidates:
        if v in data[ix]:
            yield data[ix]

# generate the small hash table
quick_hash = defaultdict(set)
for i, sublist in enumerate(data):
    for k in get_keys(sublist, 3):
        quick_hash[k].add(i)

# lookup a value by the small hash
for s in find_list_by_hash("C 9772980", data, quick_hash, 3):
    print(s)

In questo codice quick_hashoccorrerà del tempo per la compilazione, poiché si esegue la scansione dell'intera struttura dei dati. Tuttavia, il footprint della memoria sarà molto più piccolo. Il parametro principale per ottimizzare le prestazioni è size. Le dimensioni più ridotte avranno un footprint di memoria più piccolo, ma impiegheranno più tempo durante l'esecuzione find_list_by_hashperché il pool dei candidati sarà più grande. Puoi fare alcuni test per vedere quale sizedovrebbe essere il diritto per i tuoi dati. Basta essere consapevoli del fatto che tutti i tuoi valori sono almeno lunghi size.

Puoi provare qualcosa del genere:

list(filter(lambda x: any(["C 9772980" in x]),data))

Non è necessario creare una struttura di mappatura.

prova questo, usando i panda

import pandas as pd
df=pd.DataFrame(data)
rows = df.shape[0]
for row in range(rows):
    print[[row]]    #Do something with your data

questa sembra una soluzione semplice, anche se i tuoi dati crescono in grandi quantità, questo lo gestirà in modo efficiente

Non sono del tutto sicuro di come ciò si comporterebbe per grandi quantità di dati, ma potresti provare qualcosa sulla falsariga di:

import pandas as pd
df = pd.DataFrame(data).T
df.loc[:, (df == 'A 2003529').any(axis=0)]
Out[39]: 
           0
0  A 5408599
1  B 8126880
2  A 2003529
3       None
4       None
5       None
6       None

Modifica: non sembra essere utile in termini di tempo, basato su un test rapido con alcuni dati falsi su larga scala.