Xóa nhiều khóa khỏi từ điển một cách an toàn

Tôi biết để xóa một mục nhập, 'khóa' khỏi từ điển của mình d, một cách an toàn, bạn thực hiện:

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

Tuy nhiên, tôi cần xóa nhiều mục từ từ điển một cách an toàn. Tôi đã nghĩ đến việc xác định các mục nhập trong một bộ tuple vì tôi sẽ cần phải làm điều này nhiều lần.

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

Tuy nhiên, tôi đã tự hỏi liệu có cách nào thông minh hơn để làm điều này không?

Tại sao không như thế này:

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]

Một phiên bản nhỏ gọn hơn được cung cấp bởi mattldrenki sử dụng dict.pop ()

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

Sử dụng hiểu chính xác

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

trong đó key1 và key2 sẽ bị xóa.

Trong ví dụ dưới đây, các phím "b" và "c" sẽ được xóa và nó được giữ trong danh sách khóa.

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

một giải pháp đang sử dụng mapvà filtercác chức năng

trăn 2

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

trăn 3

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

bạn lấy:

{'c': 3}

Nếu bạn cũng cần truy xuất các giá trị cho các khóa bạn đang xóa, đây sẽ là một cách khá tốt để làm điều đó:

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

Tất nhiên, bạn vẫn có thể làm điều này chỉ để xóa các khóa khỏi d, nhưng bạn sẽ không cần thiết phải tạo danh sách các giá trị với khả năng hiểu danh sách. Cũng hơi không rõ ràng khi sử dụng khả năng hiểu danh sách chỉ cho tác dụng phụ của hàm.

Đã tìm ra giải pháp với popvàmap

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

Đầu ra của cái này:

{'d': 'valueD'}

Tôi đã trả lời câu hỏi này quá muộn chỉ vì tôi nghĩ rằng nó sẽ hữu ích trong tương lai nếu có ai đó tìm kiếm tương tự. Và điều này có thể hữu ích.

Cập nhật

Đoạn mã trên sẽ xuất hiện một lỗi nếu một khóa không tồn tại trong 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)

đầu ra:

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

Tôi không có vấn đề với bất kỳ câu trả lời hiện có nào, nhưng tôi rất ngạc nhiên khi không tìm thấy giải pháp này:

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}

Lưu ý: Tôi tình cờ gặp câu hỏi này đến từ đây . Và câu trả lời của tôi có liên quan đến câu trả lời này .

Tại sao không:

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

Tôi không biết ý bạn là "cách thông minh hơn". Chắc chắn có những cách khác, có thể với cách hiểu từ điển:

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

nội tuyến

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

Một số bài kiểm tra thời gian cho cpython 3 cho thấy rằng một vòng lặp for đơn giản là cách nhanh nhất và nó khá dễ đọc. Thêm một hàm cũng không gây ra nhiều chi phí:

kết quả thời gian (10k lần lặp):

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

Đối với các lần lặp nhỏ, thực hiện 'nội tuyến' đó nhanh hơn một chút, do chi phí của lệnh gọi hàm. Nhưng del_alllint an toàn, có thể tái sử dụng và nhanh hơn tất cả các cấu trúc lập bản đồ và hiểu python.

Tôi nghĩ rằng sử dụng thực tế rằng các khóa có thể được coi là một tập hợp là cách tốt nhất nếu bạn đang sử dụng 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))

Thí dụ:

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

Sẽ rất tuyệt nếu có hỗ trợ đầy đủ cho các phương thức thiết lập cho từ điển (và không phải là mớ hỗn độn đáng ghét mà chúng tôi đang gặp phải với Python 3.9) để bạn có thể chỉ cần "loại bỏ" một bộ khóa. Tuy nhiên, miễn là không phải như vậy và bạn có một từ điển lớn với số lượng lớn các khóa cần xóa, bạn có thể muốn biết về hiệu suất. Vì vậy, tôi đã tạo một số mã tạo ra thứ gì đó đủ lớn để so sánh có ý nghĩa: ma trận 100.000 x 1000, tổng cộng 10.000.00 mục.

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 triệu mặt hàng trở lên không phải là bất thường trong một số cài đặt. So sánh hai phương pháp trên máy cục bộ của tôi, tôi thấy có một chút cải thiện khi sử dụng mapvà popcó lẽ là do ít lệnh gọi hàm hơn, nhưng cả hai đều mất khoảng 2,5 giây trên máy của tôi. Nhưng điều này nhạt nhẽo so với thời gian cần thiết để tạo từ điển ngay từ đầu (55 giây), hoặc bao gồm các kiểm tra trong vòng lặp. Nếu điều này có thể xảy ra thì tốt nhất bạn nên tạo một tập hợp là giao điểm của các khóa từ điển và bộ lọc của bạn:

keys = cells.keys() & keys

Tóm lại: delđã được tối ưu hóa rất nhiều, vì vậy đừng lo lắng về việc sử dụng nó.

Tôi đến muộn với cuộc thảo luận này nhưng cho bất kỳ ai khác. Một giải pháp có thể là tạo một danh sách các khóa như vậy.

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

Sau đó, sử dụng pop () trong một danh sách hiểu, hoặc vòng lặp for, để lặp lại các phím và bật từng phím một.

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

'N / a' là trong trường hợp khóa không tồn tại, giá trị mặc định cần được trả về.