Безпечне видалення декількох клавіш зі словника

Я знаю, щоб видалити запис "ключ" зі мого словника d, безпечно, ви робите:

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

Однак мені потрібно безпечно видалити кілька записів зі словника. Я думав визначити записи в кортежі, оскільки мені це потрібно буде робити не один раз.

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

Однак мені було цікаво, чи є розумніший спосіб це зробити?

Чому б не так:

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 за допомогою dict.pop ()

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

Використання розумінь Dict

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

де key1 і key2 повинні бути видалені.

У наведеному нижче прикладі потрібно видалити ключі "b" і "c", і вони зберігаються у списку ключів.

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

рішення використовує mapі filterфункціонує

пітон 2

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

пітон 3

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

Ви отримуєте:

{'c': 3}

Якщо вам також потрібно було отримати значення для ключів, які ви виймаєте, це буде досить непоганим способом:

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

Звичайно, ви все одно можете це зробити лише для видалення ключів d, але ви будете зайво створювати список значень із розумінням списку. Також трохи незрозуміло використовувати розуміння списку лише для побічного ефекту функції.

Знайшов рішення з popіmap

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

Вихід цього:

{'d': 'valueD'}

Я відповів на це питання так пізно лише тому, що думаю, що це допоможе у майбутньому, якщо хтось шукатиме те саме. І це може допомогти.

Оновлення

Вищевказаний код призведе до помилки, якщо ключ не існує в диктаті.

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)

вихід:

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

Я не маю проблем з жодною із існуючих відповідей, але я був здивований, що не знайшов цього рішення:

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}

Примітка. Я натрапив на це питання, що йде звідси . І моя відповідь пов’язана з цією відповіддю .

Чому ні:

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

Я не знаю, що ви маєте на увазі під "розумнішим способом". Звичайно, є й інші способи, можливо, із розумінням словника:

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

в лінію

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 показують, що простий цикл - це найшвидший спосіб, і він досить читабельний. Додавання функції також не спричиняє значних витрат:

Результат timeit (10k ітерацій):

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

Для невеликих ітерацій зробити це "вбудованим" було трохи швидше, через накладні витрати виклику функції. Але del_allце захищене від ворсів, багаторазове використання та швидше, ніж усі конструкції з розуміння та відображення пітона.

Я думаю, що використання того факту, що ключі можна розглядати як набір - це найприємніший спосіб, якщо ти на 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))

Приклад:

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

Було б непогано мати повну підтримку встановлених методів для словників (а не нечестивий безлад, який ми отримуємо з Python 3.9), щоб ви могли просто «видалити» набір ключів. Однак, поки це не так, і у вас є великий словник з потенційно великою кількістю клавіш, який потрібно видалити, ви, можливо, захочете дізнатися про продуктивність. Отже, я створив якийсь код, який створює щось досить велике для змістовного зіставлення: матриця 100 000 х 1000, тобто загалом 10 000,00 елементів.

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 мільйонів предметів і більше не є незвичним для деяких налаштувань. Порівнюючи два способи на моїй локальній машині, я бачу незначне поліпшення при використанні mapі pop, імовірно, через меншу кількість викликів функцій, але обидва займають близько 2,5 секунд на моїй машині. Але це бледнее порівняно з часом, необхідним для створення словника в першу чергу (55s), або включаючи перевірки всередині циклу. Якщо це можливо, тоді найкраще створити набір, який є перетином клавіш словника та вашого фільтра:

keys = cells.keys() & keys

Підсумовуючи це: delвже сильно оптимізовано, тому не хвилюйтеся використовувати його.

Я запізнююсь на цю дискусію, але для когось іншого. Рішенням може бути створення списку ключів як такого.

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

Потім використовуйте pop () у розумінні списку або для циклу, щоб перебирати клавіші та вводити їх по черзі як такі.

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

'N / a' - у випадку, якщо ключа не існує, потрібно повернути значення за замовчуванням.