사전에서 안전하게 여러 키 제거

내 사전에서 'key'항목을 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]

보다 간결한 버전은 dict.pop ()을 사용하여 mattbornski에 의해 제공되었습니다.

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

Dict Comprehensions 사용

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

나는 누군가가 똑같은 것을 검색하면 미래에 도움이 될 것이라고 생각하기 때문에이 질문에 너무 늦게 대답했습니다. 그리고 이것은 도움이 될 것입니다.

최신 정보

위 코드는 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)

산출:

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에 대한 일부 타이밍 테스트는 간단한 for 루프가 가장 빠른 방법이며 매우 읽기 쉽다는 것을 보여줍니다. 함수를 추가해도 많은 오버 헤드가 발생하지 않습니다.

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보푸라기가 안전하고 재사용이 가능하며 모든 파이썬 이해 및 매핑 구조보다 빠릅니다.

파이썬 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}

딕셔너리에 대한 set 메소드를 완벽하게 지원하는 것이 좋을 것입니다 (파이썬 3.9에서 우리가 겪고있는 불성실 한 엉망이 아님). 그래서 단순히 키 세트를 "제거"할 수 있습니다. 그러나 그렇지 않고 제거 할 키가 많은 큰 사전이있는 한 성능에 대해 알고 싶을 수 있습니다. 그래서 저는 의미있는 비교를 위해 충분히 큰 무언가를 만드는 코드를 만들었습니다. 100,000 x 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")

일부 설정에서는 천만 개 이상의 항목이 드물지 않습니다. 내 로컬 컴퓨터에서 두 가지 방법을 비교하면 mapand를 사용할 때 약간의 개선을 보았습니다. pop아마도 함수 호출이 적기 때문일 것입니다.하지만 둘 다 내 컴퓨터에서 약 2.5 초가 걸립니다. 그러나 이것은 처음에 사전을 만드는 데 필요한 시간 (55 초) 또는 루프 내에 수표를 포함하는 데 필요한 시간과 비교하면 부족합니다. 이것이 가능하다면 사전 키와 필터가 교차하는 집합을 만드는 것이 가장 좋습니다.

keys = cells.keys() & keys

요약하면 : del이미 많이 최적화되어 있으므로 사용에 대해 걱정하지 마십시오.

나는이 토론에 늦었지만 다른 사람에게는 늦었습니다. 해결책은 키 목록을 만드는 것입니다.

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

그런 다음 목록 이해 또는 for 루프에서 pop ()을 사용하여 키를 반복하고 한 번에 하나씩 팝합니다.

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

'해당 없음'은 키가없는 경우 기본값을 반환해야합니다.