Menghapus beberapa kunci dari kamus dengan aman

Saya tahu untuk menghapus entri, 'kunci' dari kamus saya d, dengan aman, Anda melakukannya:

if d.has_key('key'):
    del d['key']

Namun, saya perlu menghapus beberapa entri dari kamus dengan aman. Saya sedang berpikir untuk mendefinisikan entri dalam tupel karena saya perlu melakukan ini lebih dari sekali.

entitiesToREmove = ('a', 'b', 'c')
for x in entitiesToRemove:
    if d.has_key(x):
        del d[x]

Namun, saya bertanya-tanya apakah ada cara yang lebih cerdas untuk melakukan ini?

Kenapa tidak seperti ini:

entries = ('a', 'b', 'c')
the_dict = {'b': 'foo'}

def entries_to_remove(entries, the_dict):
    for key in entries:
        if key in the_dict:
            del the_dict[key]

Versi yang lebih ringkas disediakan oleh mattbornski menggunakan dict.pop ()

d = {'some':'data'}
entriesToRemove = ('any', 'iterable')
for k in entriesToRemove:
    d.pop(k, None)

Menggunakan Dict Comprehensions

final_dict = {key: t[key] for key in t if key not in [key1, key2]}

di mana key1 dan key2 harus dihapus.

Pada contoh di bawah ini, kunci "b" dan "c" harus dihapus & disimpan dalam daftar kunci.

>>> a
{'a': 1, 'c': 3, 'b': 2, 'd': 4}
>>> keys = ["b", "c"]
>>> print {key: a[key] for key in a if key not in keys}
{'a': 1, 'd': 4}
>>> 

solusi menggunakan mapdan filterfungsi

python 2

d={"a":1,"b":2,"c":3}
l=("a","b","d")
map(d.__delitem__, filter(d.__contains__,l))
print(d)

python 3

d={"a":1,"b":2,"c":3}
l=("a","b","d")
list(map(d.__delitem__, filter(d.__contains__,l)))
print(d)

Anda mendapatkan:

{'c': 3}

Jika Anda juga perlu mengambil nilai untuk kunci yang Anda hapus, ini akan menjadi cara yang cukup baik untuk melakukannya:

valuesRemoved = [d.pop(k, None) for k in entitiesToRemove]

Anda tentu saja masih dapat melakukan ini hanya untuk menghapus kunci dari d, tetapi Anda tidak perlu membuat daftar nilai dengan pemahaman daftar. Juga agak tidak jelas untuk menggunakan pemahaman daftar hanya untuk efek samping fungsi.

Menemukan solusi dengan popdanmap

d = {'a': 'valueA', 'b': 'valueB', 'c': 'valueC', 'd': 'valueD'}
keys = ['a', 'b', 'c']
list(map(d.pop, keys))
print(d)

Output dari ini:

{'d': 'valueD'}

Saya telah menjawab pertanyaan ini sangat terlambat hanya karena saya pikir akan membantu di masa depan jika ada yang mencari hal yang sama. Dan ini mungkin bisa membantu.

Memperbarui

Kode di atas akan memunculkan kesalahan jika kunci tidak ada di dict.

DICTIONARY = {'a': 'valueA', 'b': 'valueB', 'c': 'valueC', 'd': 'valueD'}
keys = ['a', 'l', 'c']

def remove_keys(key):
    try:
        DICTIONARY.pop(key, None)
    except:
        pass  # or do any action

list(map(remove_key, keys))
print(DICTIONARY)

keluaran:

DICTIONARY = {'b': 'valueB', 'd': 'valueD'}

Saya tidak memiliki masalah dengan jawaban yang ada, tetapi saya terkejut tidak menemukan solusi ini:

keys_to_remove = ['a', 'b', 'c']
my_dict = {k: v for k, v in zip("a b c d e f g".split(' '), [0, 1, 2, 3, 4, 5, 6])}

for k in keys_to_remove:
    try:
        del my_dict[k]
    except KeyError:
        pass

assert my_dict == {'d': 3, 'e': 4, 'f': 5, 'g': 6}

Catatan: Saya menemukan pertanyaan ini datang dari sini . Dan jawaban saya terkait dengan jawaban ini .

Kenapa tidak:

entriestoremove = (2,5,1)
for e in entriestoremove:
    if d.has_key(e):
        del d[e]

Saya tidak tahu apa yang Anda maksud dengan "cara yang lebih cerdas". Tentunya ada cara lain, mungkin dengan pemahaman kamus:

entriestoremove = (2,5,1)
newdict = {x for x in d if x not in entriestoremove}

Di barisan

import functools

#: not key(c) in d
d = {"a": "avalue", "b": "bvalue", "d": "dvalue"}

entitiesToREmove = ('a', 'b', 'c')

#: python2
map(lambda x: functools.partial(d.pop, x, None)(), entitiesToREmove)

#: python3

list(map(lambda x: functools.partial(d.pop, x, None)(), entitiesToREmove))

print(d)
# output: {'d': 'dvalue'}

Beberapa tes waktu untuk cpython 3 menunjukkan bahwa perulangan for yang sederhana adalah cara tercepat, dan cukup mudah dibaca. Menambahkan fungsi juga tidak menyebabkan banyak overhead:

hasil timeit (10k iterasi):

• all(x.pop(v) for v in r) # 0.85
• all(map(x.pop, r)) # 0.60
• list(map(x.pop, r)) # 0.70
• all(map(x.__delitem__, r)) # 0.44
• del_all(x, r) # 0.40
• <inline for loop>(x, r) # 0.35

def del_all(mapping, to_remove):
      """Remove list of elements from mapping."""
      for key in to_remove:
          del mapping[key]

Untuk iterasi kecil, melakukan 'inline' itu sedikit lebih cepat, karena overhead pemanggilan fungsi. Tapi del_allaman untuk lint, dapat digunakan kembali, dan lebih cepat dari semua pemahaman python dan konstruksi pemetaan.

Saya pikir menggunakan fakta bahwa kunci dapat diperlakukan sebagai satu set adalah cara terbaik jika Anda menggunakan python 3:

def remove_keys(d, keys):
    to_remove = set(keys)
    filtered_keys = d.keys() - to_remove
    filtered_values = map(d.get, filtered_keys)
    return dict(zip(filtered_keys, filtered_values))

Contoh:

>>> remove_keys({'k1': 1, 'k3': 3}, ['k1', 'k2'])
{'k3': 3}

Alangkah baiknya memiliki dukungan penuh untuk metode set untuk kamus (dan bukan kekacauan tidak suci yang kita dapatkan dengan Python 3.9) sehingga Anda bisa "menghapus" satu set kunci. Namun, selama bukan itu masalahnya, dan Anda memiliki kamus besar dengan kemungkinan sejumlah besar kunci untuk dihapus, Anda mungkin ingin tahu tentang kinerjanya. Jadi, saya telah membuat beberapa kode yang membuat sesuatu yang cukup besar untuk perbandingan yang bermakna: matriks 100.000 x 1000, jadi total 10.000,00 item.

from itertools import product
from time import perf_counter

# make a complete worksheet 100000 * 1000
start = perf_counter()
prod = product(range(1, 100000), range(1, 1000))
cells = {(x,y):x for x,y in prod}
print(len(cells))

print(f"Create time {perf_counter()-start:.2f}s")
clock = perf_counter()
# remove everything above row 50,000

keys = product(range(50000, 100000), range(1, 100))

# for x,y in keys:
#     del cells[x, y]

for n in map(cells.pop, keys):
    pass

print(len(cells))
stop = perf_counter()
print(f"Removal time {stop-clock:.2f}s")

10 juta item atau lebih bukanlah hal yang aneh di beberapa pengaturan. Membandingkan dua metode pada mesin lokal saya, saya melihat sedikit peningkatan saat menggunakan mapdan pop, mungkin karena panggilan fungsi yang lebih sedikit, tetapi keduanya memakan waktu sekitar 2,5 detik pada mesin saya. Tapi ini artinya jika dibandingkan dengan waktu yang dibutuhkan untuk membuat kamus di tempat pertama (55-an), atau termasuk pemeriksaan dalam loop. Jika ini mungkin terjadi, sebaiknya buat set yang merupakan perpotongan dari kunci kamus dan filter Anda:

keys = cells.keys() & keys

Singkatnya: delsudah sangat dioptimalkan, jadi jangan khawatir tentang menggunakannya.

Saya terlambat untuk diskusi ini tetapi untuk orang lain. Solusinya mungkin dengan membuat daftar kunci seperti itu.

k = ['a','b','c','d']

Kemudian gunakan pop () dalam pemahaman daftar, atau for loop, untuk mengulang tombol dan pop satu per satu.

new_dictionary = [dictionary.pop(x, 'n/a') for x in k]

'N / a' adalah jika kunci tidak ada, nilai default perlu dikembalikan.