Hoe kan ik een sleutel uit een Python-woordenboek verwijderen?

Als ik een sleutel uit een woordenboek verwijder, gebruik ik:

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

Is er een eenregelige manier om dit te doen?


Antwoord 1, autoriteit 100%

Als u een sleutel wilt verwijderen, ongeacht of deze in het woordenboek staat, gebruikt u de tweeargumentenvorm van dict.pop():

my_dict.pop('key', None)

Hiermee wordt my_dict[key] geretourneerd als key in het woordenboek voorkomt, en anders None. Als de tweede parameter niet is opgegeven (bijv. my_dict.pop('key')) en key niet bestaat, wordt een KeyError weergegeven .

Als u een sleutel wilt verwijderen die gegarandeerd bestaat, kunt u ook

del my_dict['key']

Dit geeft een KeyError als de sleutel niet in het woordenboek staat.


Antwoord 2, autoriteit 11%

Specifiek om te antwoorden “is er een manier om dit in één regel te doen?”

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

…nou, je vroeg het 😉

Je moet er echter rekening mee houden dat deze manier om een ​​object uit een dict te verwijderen niet atomair het is mogelijk dat 'key' in my_dict staat tijdens de if-instructie, maar kan worden verwijderd vóór del wordt uitgevoerd, in welk geval del zal mislukken met een KeyError. Daarom zou het het veiligst zijn om dict.pop te gebruiken of iets in de trant van

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

wat natuurlijk zeker geen een oneliner is.


Antwoord 3, autoriteit 5%

Het kostte me wat tijd om erachter te komen wat my_dict.pop("key", None) precies doet. Dus ik voeg dit toe als antwoord om anderen tijd te besparen met googlen:

pop(key[, default])

Als sleutel in het woordenboek staat, verwijder het dan en geef de waarde terug, anders
retourneer standaard. Als default niet is opgegeven en de key niet in de
woordenboek, wordt een KeyError weergegeven.

Documentatie


Antwoord 4, autoriteit 2%

del my_dict[key] is iets sneller dan my_dict.pop(key) voor het verwijderen van een sleutel uit een woordenboek wanneer de sleutel bestaat

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

Maar als de sleutel niet bestaat if key in my_dict: del my_dict[key] is iets sneller dan my_dict.pop(key, None). Beide zijn minstens drie keer sneller dan del in een try/except-statement:

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

Antwoord 5, autoriteit 2%

Als je veel sleutels uit een woordenboek in één regel code moet verwijderen, denk ik dat het gebruik van map() vrij beknopt en Pythonisch leesbaar is:

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}

En als u fouten moet opvangen waarbij u een waarde invoert die niet in het woordenboek staat, gebruik dan lambda inside map() als volgt:

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

of in python3, moet u in plaats daarvan een lijstbegrip gebruiken:

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

Het werkt. En ‘e’ veroorzaakte geen fout, ook al had myDict geen ‘e’-toets.


Antwoord 6

Je kunt een woordenboekbegrip gebruiken om een ​​nieuw woordenboek met die sleutel te maken verwijderd:

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

U kunt op voorwaarden verwijderen. Geen fout als key niet bestaat.


Antwoord 7

Het trefwoord “del” gebruiken:

del dict[key]

Antwoord 8

U kunt het afhandelen van uitzonderingen gebruiken als u zeer uitgebreid wilt zijn:

try: 
    del dict[key]
except KeyError: pass

Dit is echter langzamer dan de methode pop() als de sleutel niet bestaat.

my_dict.pop('key', None)

Het maakt niet uit voor een paar toetsen, maar als je dit herhaaldelijk doet, is de laatste methode een betere gok.

De snelste aanpak is deze:

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

Maar deze methode is gevaarlijk, want als 'key' tussen de twee regels wordt verwijderd, wordt een KeyError weergegeven.


Antwoord 9

We kunnen een sleutel uit een Python-woordenboek verwijderen op de volgende manieren.

Het del trefwoord gebruiken; het is echter bijna dezelfde benadering als jij deed –

 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}

Of

We kunnen het volgende doen:

Maar men moet er rekening mee houden dat het in dit proces in feite geen enkele sleutel uit het woordenboek verwijdert in plaats van een specifieke sleutel uitgesloten te maken van dat woordenboek. Bovendien merkte ik op dat het een woordenboek terugstuurde dat niet hetzelfde was besteld als myDict.

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

Als we het in de shell uitvoeren, voert het iets uit als {'five': 500, 'four': 400, 'three': 300, 'two': 200} – merk op dat het niet dezelfde volgorde is als myDict. Nogmaals, als we myDict proberen af ​​te drukken, kunnen we alle sleutels zien, inclusief die we door deze aanpak uit het woordenboek hebben uitgesloten. We kunnen echter een nieuw woordenboek maken door de volgende instructie toe te wijzen aan een variabele:

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

Als we het nu proberen af ​​te drukken, volgt het de bovenliggende volgorde:

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

Of

Met behulp van de pop() methode.

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

Het verschil tussen del en pop is dat we, met behulp van de pop()-methode, de waarde van de sleutel indien nodig, zoals het volgende:

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

Fork deze kern voor toekomstig gebruik, als u dit nuttig vindt.


Antwoord 10

Het gegevenstype

Woordenboek heeft een methode genaamd dict_name.pop(item) en dit kan worden gebruikt om een ​​key:value-paar te verwijderen uit een woordenboek.

a={9:4,2:3,4:2,1:3}
a.pop(9)
print(a)

Dit geeft de output als:

{2: 3, 4: 2, 1: 3}

Op deze manier kun je in één regel een item uit een woordenboek verwijderen.


Antwoord 11

Een andere manier is door items() + dictumbegrip te gebruiken.

items() in combinatie met dict-begrip kunnen ons ook helpen bij het verwijderen van sleutel-waardeparen, maar het heeft het nadeel dat het geen bestaande dict-techniek is. Eigenlijk een nieuw dictaat indien gemaakt, behalve de sleutel die we niet willen opnemen.

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

Uitvoer:

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

Antwoord 12

Ik geef de voorkeur aan de onveranderlijke versie

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}

Antwoord 13

Enkel filter op toets

  • retourneer “sleutel” en verwijder het uit my_dict als “key” bestaat in my_dict
  • retourneer Geen als “sleutel” niet bestaat in my_dict

dit verandert my_dict op zijn plaats (veranderbaar)

my_dict.pop('key', None)

Meerdere filters op toetsen

genereer een nieuw dictaat (onveranderlijk)

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

LEAVE A REPLY

Please enter your comment!
Please enter your name here

twelve + 5 =

Other episodes