ลบองค์ประกอบจากพจนานุกรม

มีวิธีลบรายการจากพจนานุกรมใน Python หรือไม่?

นอกจากนี้ฉันจะลบรายการออกจากพจนานุกรมเพื่อส่งคืนสำเนาได้อย่างไร (เช่นไม่แก้ไขต้นฉบับ)

delงบเอาองค์ประกอบ:

del d[key]

อย่างไรก็ตามสิ่งนี้จะกลายเป็นพจนานุกรมที่มีอยู่ดังนั้นเนื้อหาของพจนานุกรมจะเปลี่ยนแปลงสำหรับใครก็ตามที่มีการอ้างอิงถึงอินสแตนซ์เดียวกัน หากต้องการส่งคืนพจนานุกรมใหม่ให้ทำสำเนาของพจนานุกรม:

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

dict()คอนสตรัคทำให้สำเนาตื้น เมื่อต้องการทำสำเนาลึกให้ดูที่โมดูลcopy

โปรดทราบว่าการทำสำเนาทุก dict del/ assignment / etc หมายความว่าคุณกำลังไปจากเวลาคงที่ถึงเวลาเชิงเส้นและใช้พื้นที่เชิงเส้น สำหรับ dicts ขนาดเล็กนี่ไม่ใช่ปัญหา แต่ถ้าคุณวางแผนที่จะทำสำเนาขนาดใหญ่จำนวนมากคุณอาจต้องการโครงสร้างข้อมูลที่แตกต่างกันเช่น 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'}

เดลคำสั่งคือสิ่งที่คุณกำลังมองหา หากคุณมีพจนานุกรมชื่อ foo ที่มีคีย์ชื่อ 'bar' คุณสามารถลบ 'bar' จาก foo ดังนี้:

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กับการinตรวจสอบจะเร็วขึ้นเล็กน้อยเนื่องจากpop()เป็นฟังก์ชั่นที่มีภาวะแทรกซ้อนของตัวเองทำให้เกิดค่าใช้จ่าย มักจะไม่ใช่กรณีดังนั้นpop()ค่าเริ่มต้นก็ดีพอ

สำหรับคำถามหลักคุณจะต้องทำสำเนาพจนานุกรมของคุณเพื่อบันทึกพจนานุกรมต้นฉบับและสร้างใหม่โดยไม่ต้องลบกุญแจ

บางคนที่นี่แนะนำให้ทำสำเนาเต็มรูปแบบด้วยcopy.deepcopy()ซึ่งอาจเป็น overkill สำเนา "ปกติ" (ตื้น) ใช้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 และ popping จากงานลอกเลียนแบบและสร้าง dict ใหม่ด้วยความเข้าใจ แต่การทำสำเนาทั้งหมดนั้นต้องใช้เวลา - คุณได้แทนที่การดำเนินการเวลาคงที่ด้วยเวลาเชิงเส้น และสำเนาทั้งหมดนั้นยังมีชีวิตอยู่ในคราวเดียวใช้พื้นที่ - พื้นที่เชิงเส้นต่อสำเนา

โครงสร้างข้อมูลอื่น ๆ เช่นอาร์เรย์กัญชาแมปพยายามได้รับการออกแบบสำหรับตรงชนิดของกรณีการใช้งานนี้: การเพิ่มหรือลบองค์ประกอบผลตอบแทนสำเนาในเวลาลอการิทึมร่วมกันมากที่สุดของการจัดเก็บข้อมูลที่มีเดิม ¹

แน่นอนว่ามีข้อเสียอยู่บ้าง ประสิทธิภาพเป็นลอการิทึมมากกว่าค่าคงที่ (แม้ว่าจะมีฐานขนาดใหญ่มักเป็น 32-128) และในขณะที่คุณสามารถทำให้ API ที่ไม่ใช่การกลายพันธุ์เหมือนกับ API dict"การกลายพันธุ์" นั้นแตกต่างกันอย่างเห็นได้ชัด และที่สำคัญที่สุดไม่มีแบตเตอรี่ HAMT ที่มาพร้อมกับ Python ²

pyrsistentห้องสมุดเป็นการนำของแข็งสวยของ HAMT ตาม Dict-ทดแทน (และประเภทอื่น ๆ ) สำหรับงูหลาม มันยังมีAPI Evolver ที่ดีสำหรับการย้ายรหัสการกลายพันธุ์ที่มีอยู่ไปยังรหัสถาวรอย่างราบรื่นที่สุด แต่ถ้าคุณต้องการชัดเจนเกี่ยวกับการส่งคืนสำเนามากกว่าการกลายพันธุ์คุณเพียงแค่ใช้มันในลักษณะนี้:

>>> 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คุณจะยังคงมี aliasing ประเด็นที่คุณสามารถแก้ไขเพียงแค่นั้นโดยจะไม่เปลี่ยนรูปทั้งหมดลงวิธีการฝังpmapและpvectors

_{1. HAMT ได้กลายเป็นที่นิยมในภาษาเช่น Scala, Clojure, Haskell เพราะพวกเขาเล่นอย่างดีกับการเขียนโปรแกรมล็อคฟรีและหน่วยความจำทรานแซคชันของซอฟต์แวร์}

_{2. ในความเป็นจริงมีเป็น HAMT ใน STDLIB contextvarsที่ใช้ในการดำเนินการ PEP ที่ถอนก่อนหน้านี้อธิบายว่าทำไม แต่นี่เป็นรายละเอียดการใช้งานที่ซ่อนอยู่ของไลบรารีไม่ใช่ประเภทคอลเล็กชันสาธารณะ}

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

ผลลัพธ์: d = {1: 2, '2': 3}

เพียงแค่เรียกเดล [[กุญแจ]]

อย่างไรก็ตามในการผลิตมันเป็นแนวปฏิบัติที่ดีในการตรวจสอบว่ามี '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}
>>>

นี้ไม่ได้ทำจัดการข้อผิดพลาดใด ๆ ก็ถือว่าสำคัญคือใน Dict คุณอาจต้องการที่จะตรวจสอบว่าเป็นครั้งแรกและ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'}

วิธีการจะขึ้นอยู่กับคำตอบจากโพสต์นี้: วิธีที่มีประสิทธิภาพในการลบคีย์ด้วยสตริงว่างจาก dict

    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)