Kamus python dengan beberapa tombol yang menunjuk ke daftar yang sama dalam cara yang efisien memori

Saya memiliki persyaratan unik yang dapat dijelaskan oleh kode ini. Ini adalah kode yang berfungsi tetapi tidak efisien memori.

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

Singkatnya, saya ingin setiap item dari sub-daftar dapat diindeks dan harus mengembalikan sublist.

Metode di atas berfungsi tetapi dibutuhkan banyak memori saat data berukuran besar. Apakah ada cara yang lebih baik, ramah memori dan CPU? Data disimpan sebagai file JSON.

Sunting Saya mencoba jawaban untuk skenario penggunaan terbesar (1000 sublist, 100 item di setiap sublist, 1 juta kueri) dan berikut ini hasilnya (rata-rata 10 run):

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

Anda benar-benar berada dalam ruang trade-off antara waktu / memori yang diperlukan untuk menghasilkan kamus versus waktu yang diperlukan untuk memindai seluruh data untuk metode on-the-fly.

Jika Anda menginginkan metode memori rendah, Anda dapat menggunakan fungsi yang mencari nilai masing-masing sublist. Menggunakan generator akan mendapatkan hasil awal lebih cepat bagi pengguna, tetapi untuk set data besar, ini akan lambat di antara pengembalian.

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)

Seperti disebutkan dalam komentar, membangun tabel hash hanya berdasarkan huruf pertama atau 2 atau 3 karakter pertama mungkin merupakan tempat yang baik untuk memulai. Ini akan memungkinkan Anda untuk membuat daftar kandidat sublists, kemudian memindai mereka untuk melihat apakah nilainya ada dalam sublist.

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)

Dalam kode ini quick_hashakan membutuhkan waktu untuk membangun, karena Anda memindai seluruh struktur data Anda. Namun, cetakan kaki memori akan jauh lebih kecil. Parameter utama Anda untuk kinerja tuning adalah size. Ukuran yang lebih kecil akan memiliki jejak memori yang lebih kecil, tetapi akan memakan waktu lebih lama ketika berjalan find_list_by_hashkarena kumpulan calon Anda akan lebih besar. Anda dapat melakukan beberapa pengujian untuk melihat apa yang sizeseharusnya untuk data Anda. Ingatlah bahwa semua nilai Anda setidaknya selama size.

Anda dapat mencoba sesuatu seperti ini:

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

Tidak perlu membuat struktur pemetaan.

coba ini, menggunakan 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

ini terlihat solusi sederhana, bahkan jika data Anda tumbuh besar, ini akan menangani itu secara efisien

Saya tidak sepenuhnya yakin bagaimana ini akan berperilaku untuk data jumlah yang lebih besar, tetapi Anda dapat mencoba sesuatu di sepanjang baris:

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

Sunting: Tampaknya tidak menguntungkan dalam hal waktu, berdasarkan tes cepat dengan beberapa data skala besar palsu.