Bir sözlükten birden fazla anahtarı güvenle kaldırmak

Sözlüğümden bir girişi, 'anahtarı' kaldırmayı biliyorum d, güvenli bir şekilde şunları yaparsınız:

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

Ancak, sözlükten birden fazla girişi güvenli bir şekilde kaldırmam gerekiyor. Bunu bir kereden fazla yapmam gerekeceği için girişleri bir demet içinde tanımlamayı düşünüyordum.

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

Ancak, bunu yapmanın daha akıllıca bir yolu olup olmadığını merak ediyordum.

Neden böyle değil:

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]

Mattbornski tarafından dict.pop () kullanılarak daha kompakt bir sürüm sağlandı

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

Dikte Anlamalarını Kullanma

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

burada key1 ve key2 kaldırılacaktır.

Aşağıdaki örnekte, "b" ve "c" tuşları kaldırılacak ve bir anahtarlar listesinde tutulacaktır.

>>> 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}
>>> 

bir çözüm kullanıyor mapve filterişlevler

piton 2

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

piton 3

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

alırsın:

{'c': 3}

Ayrıca kaldırmakta olduğunuz anahtarların değerlerini de almanız gerekiyorsa, bunu yapmanın oldukça iyi bir yolu olacaktır:

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

Elbette bunu sadece anahtarların kaldırılması için yapabilirsiniz d, ancak liste anlayışıyla gereksiz yere değerler listesi oluşturursunuz. Ayrıca, yalnızca işlevin yan etkisi için bir liste anlamanın kullanılması biraz belirsizdir.

popVe ile bir çözüm buldummap

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

Bunun çıktısı:

{'d': 'valueD'}

Bu soruyu çok geç cevapladım çünkü gelecekte biri aynı şeyi ararsa yardımcı olacağını düşünüyorum. Ve bu yardımcı olabilir.

Güncelleme

Yukarıdaki kod, diktede bir anahtar yoksa bir hata atacaktır.

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)

çıktı:

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

Mevcut cevapların hiçbiriyle sorunum yok, ancak bu çözümü bulamadığım için şaşırdım:

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}

Not: Buradan gelen bu soruyla karşılaştım . Ve cevabım bu cevapla ilgili .

Neden olmasın:

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

"Daha akıllı yol" ile ne demek istediğini bilmiyorum. Elbette başka yollar da vardır, belki sözlük anlamaları ile:

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

Çizgide

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

Cpython 3 için bazı zamanlama testleri, basit bir for döngüsünün en hızlı yol olduğunu ve oldukça okunabilir olduğunu gösterir. Bir işlev eklemek çok fazla ek yüke neden olmaz:

timeit sonuçları (10k yineleme):

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

Küçük yinelemeler için, bunu 'satır içi' yapmak, işlev çağrısının ek yükü nedeniyle biraz daha hızlıydı. Ancak del_alltüy bırakmayan, yeniden kullanılabilir ve tüm python anlama ve haritalama yapılarından daha hızlıdır.

Python 3'teyseniz, anahtarların bir set olarak ele alınabileceği gerçeğini kullanmanın en güzel yolu olduğunu düşünüyorum:

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))

Misal:

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

Sözlükler için set metotları için tam desteğe sahip olmak güzel olurdu (Python 3.9 ile karşılaştığımız kutsal karmaşa değil), böylece bir anahtar setini basitçe "kaldırabilirsiniz". Ancak, durum böyle olmadığı ve kaldırılması gereken çok sayıda anahtarın bulunduğu büyük bir sözlüğünüz olduğu sürece, performans hakkında bilgi edinmek isteyebilirsiniz. Bu yüzden, anlamlı karşılaştırmalar için yeterince büyük bir şey oluşturan bir kod yarattım: 100.000 x 1000 matris, yani toplamda 10.000,00 öğe.

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")

Bazı ayarlarda 10 milyon veya daha fazla öğe alışılmadık değildir. Yerel makinemdeki iki yöntemi karşılaştırdığımda mapve popmuhtemelen daha az işlev çağrısı nedeniyle ve kullanırken küçük bir gelişme görüyorum , ancak her ikisi de makinemde yaklaşık 2,5 saniye sürüyor. Ancak bu, sözlüğü ilk etapta (55s) oluşturmak veya döngü içinde kontroller dahil etmek için gereken süreye kıyasla sönük kalır. Bu büyük olasılıkla, sözlük tuşları ile filtrenizin kesişim noktası olan bir küme oluşturmak en iyisidir:

keys = cells.keys() & keys

Özetle: delzaten yoğun bir şekilde optimize edilmiştir, bu nedenle onu kullanma konusunda endişelenmeyin.

Bu tartışmaya geç kaldım ama bir başkası için. Bunun gibi bir anahtar listesi oluşturmak bir çözüm olabilir.

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

Ardından, anahtarlar üzerinde yinelemek ve her seferinde birini açmak için bir liste anlamasında veya for döngüsünde pop () kullanın.

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

'N / a', anahtarın mevcut olmaması durumunda, varsayılan bir değerin döndürülmesi gerektiğidir.