Python-Wörterbuch mit mehreren Schlüsseln, die speichereffizient auf dieselbe Liste verweisen

Ich habe diese einzigartige Anforderung, die durch diesen Code erklärt werden kann. Dies ist Arbeitscode, aber nicht speichereffizient.

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']

Kurz gesagt, ich möchte, dass jedes Element der Unterliste indexierbar ist und die Unterliste zurückgibt.

Die obige Methode funktioniert, benötigt jedoch viel Speicher, wenn die Datenmenge groß ist. Gibt es einen besseren, speicher- und CPU-freundlichen Weg? Die Daten werden als JSON-Datei gespeichert.

Bearbeiten Ich habe die Antworten für das größtmögliche Anwendungsfall-Szenario ausprobiert (1000 Unterlisten, 100 Elemente in jeder Unterliste, 1 Million Abfragen). Hier sind die Ergebnisse (Mittelwert aus 10 Durchläufen):

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

Sie befinden sich wirklich in einem Kompromiss zwischen der Zeit / dem Speicher, die zum Generieren des Wörterbuchs benötigt wird, und der Zeit, die zum Scannen der gesamten Daten für eine On-the-Fly-Methode benötigt wird.

Wenn Sie eine Methode mit geringem Arbeitsspeicher wünschen, können Sie eine Funktion verwenden, die jede Unterliste nach dem Wert durchsucht. Die Verwendung eines Generators führt zu schnelleren ersten Ergebnissen für den Benutzer. Bei großen Datenmengen ist dies jedoch zwischen den Rückgaben langsam.

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)

Wie in den Kommentaren erwähnt, kann das Erstellen einer Hash-Tabelle, die nur auf dem ersten Buchstaben oder den ersten 2 oder 3 Zeichen basiert, ein guter Anfang sein. Auf diese Weise können Sie eine Kandidatenliste mit Unterlisten erstellen und diese dann scannen, um festzustellen, ob sich der Wert in der Unterliste befindet.

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)

Das quick_hashErstellen dieses Codes dauert einige Zeit, da Sie Ihre gesamte Datenstruktur scannen. Der Speicherbedarf wird jedoch viel kleiner sein. Ihr Hauptparameter für die Optimierung der Leistung ist size. Kleinere Größen haben einen geringeren Speicherbedarf, dauern jedoch beim Ausführen länger, find_list_by_hashda Ihr Kandidatenpool größer ist. Sie können einige Tests durchführen, um festzustellen, welches Recht sizefür Ihre Daten gelten sollte. Denken Sie nur daran, dass alle Ihre Werte mindestens so lang sind wie size.

Sie können so etwas ausprobieren:

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

Es ist keine Mapping-Struktur erforderlich.

Versuchen Sie dies mit Pandas

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

Dies sieht nach einer einfachen Lösung aus, selbst wenn Ihre Daten groß werden, wird dies effizient erledigt

Ich bin mir nicht ganz sicher, wie sich dies bei größeren Datenmengen verhalten würde, aber Sie könnten Folgendes ausprobieren:

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

Bearbeiten: Scheint zeitlich nicht vorteilhaft zu sein, basierend auf einem Schnelltest mit einigen gefälschten Daten in größerem Maßstab.