Jak usunąć klucz ze słownika Python?

Podczas usuwania klucza ze słownika używam:

if 'key' in my_dict:
    del my_dict['key']

Czy można to zrobić w jeden sposób?

Aby usunąć klucz bez względu na to, czy znajduje się w słowniku, użyj dwuargumentowej formy dict.pop():

my_dict.pop('key', None)

Zwróci to, my_dict[key]jeśli keyistnieje w słowniku i Noneinaczej. Jeśli drugi parametr nie jest określony (tj. my_dict.pop('key')) I keynie istnieje, to KeyErrorjest wywoływane a.

Aby usunąć klucz, który na pewno istnieje, możesz również użyć

del my_dict['key']

Spowoduje to podniesienie a, KeyErrorjeśli klucza nie ma w słowniku.

W szczególności, aby odpowiedzieć „czy istnieje jeden sposób na zrobienie tego?”

if 'key' in my_dict: del my_dict['key']

... cóż, zapytałeś ;-)

Należy jednak wziąć pod uwagę, że ten sposób usuwania obiektu z niedict jest atomowy - możliwe, że 'key'może to być my_dictpodczas ifinstrukcji, ale może zostać usunięte przed delwykonaniem, w którym to przypadku delzakończy się niepowodzeniem za pomocą KeyError. Biorąc to pod uwagę, najbezpieczniej byłoby użyćdict.pop albo coś w tym stylu

try:
    del my_dict['key']
except KeyError:
    pass

co oczywiście nie jest jednoskładnikowe.

Zajęło mi trochę czasu, aby dowiedzieć się, co dokładnie my_dict.pop("key", None)robi. Dodaję to jako odpowiedź, aby zaoszczędzić czas innym użytkownikom Google:

pop(key[, default])

Jeśli klucz znajduje się w słowniku, usuń go i zwróć jego wartość, w przeciwnym razie zwróć wartość domyślną . Jeśli wartość domyślna nie jest podana, a klucza nie ma w słowniku, KeyErrorzostanie podniesiona wartość a.

Dokumentacja

del my_dict[key]jest nieco szybszy niż w my_dict.pop(key)przypadku usuwania klucza ze słownika, gdy klucz istnieje

>>> import timeit
>>> setup = "d = {i: i for i in range(100000)}"

>>> timeit.timeit("del d[3]", setup=setup, number=1)
1.79e-06
>>> timeit.timeit("d.pop(3)", setup=setup, number=1)
2.09e-06
>>> timeit.timeit("d2 = {key: val for key, val in d.items() if key != 3}", setup=setup, number=1)
0.00786

Ale kiedy klucz nie istnieje, if key in my_dict: del my_dict[key]jest nieco szybszy niż my_dict.pop(key, None). Oba są co najmniej trzy razy szybsze niż delw instrukcji try/ except:

>>> timeit.timeit("if 'missing key' in d: del d['missing key']", setup=setup)
0.0229
>>> timeit.timeit("d.pop('missing key', None)", setup=setup)
0.0426
>>> try_except = """
... try:
...     del d['missing key']
... except KeyError:
...     pass
... """
>>> timeit.timeit(try_except, setup=setup)
0.133

Jeśli chcesz usunąć wiele kluczy ze słownika w jednym wierszu kodu, myślę, że użycie map () jest dość zwięzłe i czytelne w języku Python:

myDict = {'a':1,'b':2,'c':3,'d':4}
map(myDict.pop, ['a','c']) # The list of keys to remove
>>> myDict
{'b': 2, 'd': 4}

A jeśli chcesz wychwycić błędy, w których wpisujesz wartość, której nie ma w słowniku, użyj lambda wewnątrz mapy () w następujący sposób:

map(lambda x: myDict.pop(x,None), ['a', 'c', 'e'])
[1, 3, None] # pop returns
>>> myDict
{'b': 2, 'd': 4}

lub w python3, zamiast tego musisz użyć rozumienia listy:

[myDict.pop(x, None) for x in ['a', 'c', 'e']]

To działa. I „e” nie spowodowało błędu, mimo że myDict nie miał klucza „e”.

Możesz użyć słownika, aby utworzyć nowy słownik z usuniętym kluczem:

>>> my_dict = {k: v for k, v in my_dict.items() if k != 'key'}

Możesz usunąć według warunków. Brak błędu, jeśli keynie istnieje.

Używając słowa kluczowego „del”:

del dict[key]

Możemy usunąć klucz ze słownika Python, stosując następujące metody.

Za pomocą delsłowa kluczowego; jest to prawie takie samo podejście jak ty -

 myDict = {'one': 100, 'two': 200, 'three': 300 }
 print(myDict)  # {'one': 100, 'two': 200, 'three': 300}
 if myDict.get('one') : del myDict['one']
 print(myDict)  # {'two': 200, 'three': 300}

Lub

Możemy wykonać następujące czynności:

Należy jednak pamiętać, że w tym procesie nie usuwa on żadnego klucza ze słownika, a nie wyklucza określony klucz ze słownika. Ponadto zauważyłem, że zwrócił słownik, który nie został zamówiony tak samo jak myDict.

myDict = {'one': 100, 'two': 200, 'three': 300, 'four': 400, 'five': 500}
{key:value for key, value in myDict.items() if key != 'one'}

Jeśli uruchomimy go w powłoce, wykona on coś w stylu {'five': 500, 'four': 400, 'three': 300, 'two': 200}- zauważ, że nie jest to ta sama kolejność co myDict. Ponownie, jeśli spróbujemy wydrukować myDict, możemy zobaczyć wszystkie klucze, w tym te, które wykluczyliśmy ze słownika dzięki temu podejściu. Możemy jednak utworzyć nowy słownik, przypisując następującą instrukcję do zmiennej:

var = {key:value for key, value in myDict.items() if key != 'one'}

Teraz, jeśli spróbujemy go wydrukować, będzie on zgodny z kolejnością nadrzędną:

print(var) # {'two': 200, 'three': 300, 'four': 400, 'five': 500}

Lub

Przy użyciu pop()metody

myDict = {'one': 100, 'two': 200, 'three': 300}
print(myDict)

if myDict.get('one') : myDict.pop('one')
print(myDict)  # {'two': 200, 'three': 300}

Różnica między deli poppolega na tym, że za pomocą pop()metody możemy w razie potrzeby przechowywać wartość klucza , na przykład:

myDict = {'one': 100, 'two': 200, 'three': 300}
if myDict.get('one') : var = myDict.pop('one')
print(myDict) # {'two': 200, 'three': 300}
print(var)    # 100

Rozwiąż tę istotę do wykorzystania w przyszłości, jeśli okaże się to przydatne.

Możesz użyć obsługi wyjątków, jeśli chcesz być bardzo szczegółowy:

try: 
    del dict[key]

except KeyError: pass

Jest to jednak wolniejsze niż pop()metoda, jeśli klucz nie istnieje.

my_dict.pop('key', None)

Dla kilku klawiszy nie będzie to miało znaczenia, ale jeśli robisz to wielokrotnie, to druga metoda jest lepszym rozwiązaniem.

Najszybsze podejście to:

if 'key' in dict: 
    del myDict['key']

Ale ta metoda jest niebezpieczna, ponieważ jeśli 'key'zostanie usunięta między dwiema liniami, KeyErrorzostanie podniesiona a.

Wolę niezmienną wersję

foo = {
    1:1,
    2:2,
    3:3
}
removeKeys = [1,2]
def woKeys(dct, keyIter):
    return {
        k:v
        for k,v in dct.items() if k not in keyIter
    }

>>> print(woKeys(foo, removeKeys))
{3: 3}
>>> print(foo)
{1: 1, 2: 2, 3: 3}

Innym sposobem jest użycie przedmiotów () + rozumienie dykt

items () w połączeniu ze zrozumieniem dict może również pomóc nam w realizacji zadania usuwania pary klucz-wartość, ale ma tę wadę, że nie jest techniką dyktowania w miejscu. Właściwie nowy dykt, jeśli zostanie utworzony, z wyjątkiem klucza, którego nie chcemy dołączać.

test_dict = {"sai" : 22, "kiran" : 21, "vinod" : 21, "sangam" : 21} 

# Printing dictionary before removal 
print ("dictionary before performing remove is : " + str(test_dict)) 

# Using items() + dict comprehension to remove a dict. pair 
# removes  vinod
new_dict = {key:val for key, val in test_dict.items() if key != 'vinod'} 

# Printing dictionary after removal 
print ("dictionary after remove is : " + str(new_dict)) 

Wynik:

dictionary before performing remove is : {'sai': 22, 'kiran': 21, 'vinod': 21, 'sangam': 21}
dictionary after remove is : {'sai': 22, 'kiran': 21, 'sangam': 21}

Pojedynczy filtr na kluczu

• zwróć „klucz” i usuń go z my_dict, jeśli „my” istnieje w my_dict
• return None, jeśli „klucz” nie istnieje w my_dict

to się zmieni my_dictw miejscu (zmienne)

my_dict.pop('key', None)

Wiele filtrów na klawiszach

wygeneruj nowy dykt (niezmienny)

dic1 = {
    "x":1,
    "y": 2,
    "z": 3
}

def func1(item):
    return  item[0]!= "x" and item[0] != "y"

print(
    dict(
        filter(
            lambda item: item[0] != "x" and item[0] != "y", 
            dic1.items()
            )
    )
)