辞書から要素を削除する

Pythonの辞書から項目を削除する方法はありますか？

さらに、コピーを返す（つまり、元のアイテムを変更しない）ために、辞書からアイテムを削除するにはどうすればよいですか？

次のdelステートメントは要素を削除します。

del d[key]

ただし、これにより既存のディクショナリが変更されるため、同じインスタンスへの参照を持っている他の人のためにディクショナリの内容が変更されます。新しい辞書を返すには、辞書のコピーを作成します。

def removekey(d, key):
    r = dict(d)
    del r[key]
    return r

dict()コンストラクタは作る浅いコピーを。詳細なコピーを作成するには、copyモジュールを参照してください。

すべてのdict del/ assignment / etcのコピーを作成することに注意してください。は、一定の時間から線形の時間に移行し、線形空間を使用することも意味します。小さな辞書の場合、これは問題ではありません。ただし、大規模な辞書のコピーを多数作成する予定の場合は、（この回答で説明されているように）HAMTのような別のデータ構造がおそらく必要です。

pop 辞書を変更します。

 >>> lol = {"hello": "gdbye"}
 >>> lol.pop("hello")
     'gdbye'
 >>> lol
     {}

オリジナルを保持したい場合は、コピーしてください。

私はあなたの解決策がそれを行うための最良の方法だと思います。ただし、別の解決策が必要な場合は、次のように、指定したキーを含めずに、古い辞書のキーを使用して新しい辞書を作成できます。

>>> a
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> {i:a[i] for i in a if i!=0}
{1: 'one', 2: 'two', 3: 'three'}

デルのステートメントは、あなたが探しているものです。「bar」というキーを持つfooという名前の辞書がある場合、次のようにfooから「bar」を削除できます。

del foo['bar']

これにより、操作中の辞書が永久に変更されることに注意してください。元の辞書を保持したい場合は、事前にコピーを作成する必要があります。

>>> foo = {'bar': 'baz'}
>>> fu = dict(foo)
>>> del foo['bar']
>>> print foo
{}
>>> print fu
{'bar': 'baz'}

dictコールは浅いのコピーを作成します。詳細なコピーが必要な場合は、を使用してくださいcopy.deepcopy。

便宜上、コピーして貼り付けることができる方法は次のとおりです。

def minus_key(key, dictionary):
    shallow_copy = dict(dictionary)
    del shallow_copy[key]
    return shallow_copy

良い答えはたくさんありますが、一つだけ強調したいと思います。

dict.pop()メソッドとより一般的なdelステートメントの両方を使用して、ディクショナリからアイテムを削除できます。どちらも元の辞書を変更するため、コピーを作成する必要があります（以下の詳細を参照）。

そして、それらの両方はKeyError、あなたが彼らに提供しているキーが辞書に存在しない場合に発生します：

key_to_remove = "c"
d = {"a": 1, "b": 2}
del d[key_to_remove]  # Raises `KeyError: 'c'`

そして

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove)  # Raises `KeyError: 'c'`

これに注意する必要があります：

例外をキャプチャすることにより：

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    del d[key_to_remove]
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

そして

key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
    d.pop(key_to_remove)
except KeyError as ex:
    print("No such key: '%s'" % ex.message)

チェックを実行することにより：

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    del d[key_to_remove]

そして

key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
    d.pop(key_to_remove)

しかしpop()、はるかに簡潔な方法もあります-デフォルトの戻り値を提供します：

key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove, None)  # No `KeyError` here

pop()削除されるキーの値を取得するために使用しない限り、必要ではないものを提供できますNone。独自の複雑な機能を備えた関数であるためdel、incheck を使用した方が若干高速になる可能性がありますが、pop()オーバーヘッドが発生します。通常はそうではないのでpop()、デフォルト値で十分です。

主な質問については、元の辞書を保存し、キーを削除せずに新しい辞書を作成するには、辞書のコピーを作成する必要があります。

他の一部の人は、で完全な（深い）コピーを作成することを提案しますcopy.deepcopy()。これはやり過ぎかもしれませんが、copy.copy()またはを使用した「通常の」（浅い）コピーでdict.copy()十分かもしれません。辞書は、オブジェクトへの参照をキーの値として保持します。したがって、辞書からキーを削除すると、参照されているオブジェクトではなく、この参照が削除されます。メモリ内にオブジェクトへの参照が他にない場合、オブジェクト自体は後でガベージコレクタによって自動的に削除されます。ディープコピーを作成すると、シャローコピーに比べてより多くの計算が必要になるため、コピーを作成し、メモリを浪費し、GCにより多くの作業を提供することにより、コードのパフォーマンスが低下します。シャローコピーで十分な場合もあります。

ただし、ディクショナリ値として変更可能なオブジェクトがあり、返されたディクショナリでキーなしでそれらを後で変更する場合は、ディープコピーを作成する必要があります。

浅いコピー：

def get_dict_wo_key(dictionary, key):
    """Returns a **shallow** copy of the dictionary without a key."""
    _dict = dictionary.copy()
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

ディープコピー：

from copy import deepcopy


def get_dict_wo_key(dictionary, key):
    """Returns a **deep** copy of the dictionary without a key."""
    _dict = deepcopy(dictionary)
    _dict.pop(key, None)
    return _dict


d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"

new_d = get_dict_wo_key(d, key_to_remove)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d)  # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d)  # {"a": [1, 2, 3, 100], "b": 2222}

…アイテムを辞書から削除して、コピーを返す（つまり、元のアイテムを変更しない）にはどうすればよいですか？

A dictは、これに使用するのに不適切なデータ構造です。

確かに、dictをコピーしてコピーからポップすることは機能しますが、理解度のある新しいdictを構築することはできますが、すべてのコピーには時間がかかります。つまり、一定時間の操作を線形時間の操作に置き換えました。そして、生きているそれらのすべてのコピーは、スペース、つまりコピーあたりの線形スペースを使用します。

ハッシュアレイにマップされたトライなどの他のデータ構造は、まさにこの種のユースケース用に設計されています。要素を追加または削除すると、コピーが対数時間で返され、そのストレージのほとんどが元のと共有されます。¹

もちろん、いくつかの欠点があります。パフォーマンスは一定ではなく対数的です（ただし、底が大きい場合、通常は32〜128です）。また、非変更APIをと同じにすることもできますがdict、「変更」APIは明らかに異なります。そして、何よりも、PythonにはHAMTバッテリーが含まれていません。²

pyrsistentライブラリは、Python用HAMTベースのdict-置換（および種々の他のタイプ）のかなり固体実装です。また、既存の変更コードを永続コードにできるだけスムーズに移植するための洗練されたAPIさえ備えています。ただし、変更ではなくコピーを返すことを明示的にしたい場合は、次のように使用します。

>>> from pyrsistent import m
>>> d1 = m(a=1, b=2)
>>> d2 = d1.set('c', 3)
>>> d3 = d1.remove('a')
>>> d1
pmap({'a': 1, 'b': 2})
>>> d2
pmap({'c': 3, 'a': 1, 'b': 2})
>>> d3
pmap({'b': 2})

それd3 = d1.remove('a')がまさに質問が求めていることです。

のような変更可能なデータ構造がdictあり、にlist埋め込まれているpmap場合でも、エイリアスの問題が発生します。これは、pmapsとpvectorsを埋め込んで不変に移動することによってのみ修正できます。

_{1. HAMTは、Scala、Clojure、Haskellなどの言語でも人気が高まっています。ロックフリープログラミングやソフトウェアトランザクションメモリで非常にうまく機能しますが、Pythonにはあまり関係がありません。}

_{2.実際、stdlib には HAMTがあり、の実装で使用されていますcontextvars。以前に撤回されたPEPはその理由を説明しています。ただし、これはライブラリの非表示の実装詳細であり、パブリックコレクションタイプではありません。}

d = {1: 2, '2': 3, 5: 7}
del d[5]
print 'd = ', d

結果： d = {1: 2, '2': 3}

del d ['key']を呼び出すだけです。

ただし、本番環境では、dに「キー」が存在するかどうかを確認することを常にお勧めします。

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

いいえ、他に方法はありません

def dictMinus(dct, val):
   copy = dct.copy()
   del copy[val]
   return copy

ただし、わずかに変更されたディクショナリのコピーを作成することは、比較的大量のメモリを必要とするため、おそらくお勧めできません。通常、古い辞書をログに記録し（必要な場合でも）、変更することをお勧めします。

# mutate/remove with a default
ret_val = body.pop('key', 5)
# no mutation with a default
ret_val = body.get('key', 5)

>>> def delete_key(dict, key):
...     del dict[key]
...     return dict
... 
>>> test_dict = {'one': 1, 'two' : 2}
>>> print delete_key(test_dict, 'two')
{'one': 1}
>>>

これはエラー処理を行わず、キーが辞書にあることを前提としています。最初にそれを確認し、raiseそうでない場合は

ここでトップレベルの設計アプローチ：

def eraseElement(d,k):
    if isinstance(d, dict):
        if k in d:
            d.pop(k)
            print(d)
        else:
            print("Cannot find matching key")
    else:
        print("Not able to delete")


exp = {'A':34, 'B':55, 'C':87}
eraseElement(exp, 'C')

ディクショナリと必要なキーを関数に渡し、それがディクショナリかどうかと、キーに問題がないかどうかを検証し、両方とも存在する場合は、ディクショナリから値を削除して、残りを出力します。

出力： {'B': 55, 'A': 34}

お役に立てば幸いです。

以下のコードスニペットは間違いなく役立ちます。コードを理解するのに役立つコメントを各行に追加しました。

def execute():
   dic = {'a':1,'b':2}
   dic2 = remove_key_from_dict(dic, 'b')  
   print(dict2)           # {'a': 1}
   print(dict)            # {'a':1,'b':2}

def remove_key_from_dict(dictionary_to_use, key_to_delete):
   copy_of_dict = dict(dictionary_to_use)     # creating clone/copy of the dictionary
   if key_to_delete in copy_of_dict :         # checking given key is present in the dictionary
       del copy_of_dict [key_to_delete]       # deleting the key from the dictionary 
   return copy_of_dict                        # returning the final dictionary

または、dict.pop（）を使用することもできます

d = {"a": 1, "b": 2}

res = d.pop("c")  # No `KeyError` here
print (res)       # this line will not execute

またはより良いアプローチは

res = d.pop("c", "key not found")
print (res)   # key not found
print (d)     # {"a": 1, "b": 2}

res = d.pop("b", "key not found")
print (res)   # 2
print (d)     # {"a": 1}

リスト内包表記を使用した別のバリエーションを次に示します。

original_d = {'a': None, 'b': 'Some'}
d = dict((k,v) for k, v in original_d.iteritems() if v)
# result should be {'b': 'Some'}

このアプローチは、この投稿からの回答に基づいています： 辞書から空の文字列を持つキーを削除する効率的な方法

    species = {'HI': {'1': (1215.671, 0.41600000000000004),
  '10': (919.351, 0.0012),
  '1025': (1025.722, 0.0791),
  '11': (918.129, 0.0009199999999999999),
  '12': (917.181, 0.000723),
  '1215': (1215.671, 0.41600000000000004),
  '13': (916.429, 0.0005769999999999999),
  '14': (915.824, 0.000468),
  '15': (915.329, 0.00038500000000000003),
 'CII': {'1036': (1036.3367, 0.11900000000000001), '1334': (1334.532, 0.129)}}

次のコードは、dictのコピーを作成し、species存在しないアイテムを削除しますtrans_HI

trans_HI=['1025','1215']
for transition in species['HI'].copy().keys():
    if transition not in trans_HI:
        species['HI'].pop(transition)