แยกชุดย่อยของคู่คีย์ - ค่าจากวัตถุพจนานุกรม Python หรือไม่

ฉันมีวัตถุพจนานุกรมขนาดใหญ่ที่มีคู่ค่าคีย์หลายค่า (ประมาณ 16) แต่ฉันสนใจเพียง 3 รายการเท่านั้น อะไรคือวิธีที่ดีที่สุด (สั้นที่สุด / มีประสิทธิภาพ / สวยที่สุด) เพื่อให้บรรลุถึงสิ่งนั้น?

สิ่งที่ดีที่สุดที่ฉันรู้คือ:

bigdict = {'a':1,'b':2,....,'z':26} 
subdict = {'l':bigdict['l'], 'm':bigdict['m'], 'n':bigdict['n']}

ฉันแน่ใจว่ามีวิธีที่หรูหรากว่านี้ ไอเดีย?

คุณสามารถลอง:

dict((k, bigdict[k]) for k in ('l', 'm', 'n'))

... หรือใน Python 3Python เวอร์ชั่น 2.7 หรือใหม่กว่า(ขอบคุณFábio Dinizสำหรับการชี้ให้เห็นว่ามันทำงานได้ใน 2.7 ด้วย) :

{k: bigdict[k] for k in ('l', 'm', 'n')}

อัปเดต: เมื่อHåvard Sชี้ให้เห็นฉันคิดว่าคุณรู้ว่ากุญแจจะอยู่ในพจนานุกรม - ดูคำตอบของเขาหากคุณไม่สามารถทำการสันนิษฐานได้ อีกวิธีหนึ่งคือtimboชี้ให้เห็นในความคิดเห็นหากคุณต้องการรหัสที่ขาดหายไปในbigdictแผนที่Noneคุณสามารถทำได้:

{k: bigdict.get(k, None) for k in ('l', 'm', 'n')}

หากคุณใช้ Python 3 และคุณต้องการเพียงคีย์ใน dict ใหม่ที่มีอยู่จริงในต้นฉบับคุณสามารถใช้ข้อเท็จจริงเพื่อดูออบเจ็กต์ที่ใช้การดำเนินการบางอย่าง:

{k: bigdict[k] for k in bigdict.keys() & {'l', 'm', 'n'}}

สั้นลงอย่างน้อย:

wanted_keys = ['l', 'm', 'n'] # The keys you want
dict((k, bigdict[k]) for k in wanted_keys if k in bigdict)

interesting_keys = ('l', 'm', 'n')
subdict = {x: bigdict[x] for x in interesting_keys if x in bigdict}

เปรียบเทียบความเร็วเล็กน้อยสำหรับวิธีการที่กล่าวถึงทั้งหมด:

Python 2.7.11 |Anaconda 2.4.1 (64-bit)| (default, Jan 29 2016, 14:26:21) [MSC v.1500 64 bit (AMD64)] on win32
In[2]: import numpy.random as nprnd
keys = nprnd.randint(1000, size=10000)
bigdict = dict([(_, nprnd.rand()) for _ in range(1000)])

%timeit {key:bigdict[key] for key in keys}
%timeit dict((key, bigdict[key]) for key in keys)
%timeit dict(map(lambda k: (k, bigdict[k]), keys))
%timeit dict(filter(lambda i:i[0] in keys, bigdict.items()))
%timeit {key:value for key, value in bigdict.items() if key in keys}
100 loops, best of 3: 3.09 ms per loop
100 loops, best of 3: 3.72 ms per loop
100 loops, best of 3: 6.63 ms per loop
10 loops, best of 3: 20.3 ms per loop
100 loops, best of 3: 20.6 ms per loop

ตามที่คาดไว้: ความเข้าใจในพจนานุกรมเป็นตัวเลือกที่ดีที่สุด

คำตอบนี้ใช้ความเข้าใจในพจนานุกรมคล้ายกับคำตอบที่เลือก แต่จะไม่ยกเว้นในรายการที่ขาดหายไป

หลาม 2 รุ่น:

{k:v for k, v in bigDict.iteritems() if k in ('l', 'm', 'n')}

หลาม 3 รุ่น:

{k:v for k, v in bigDict.items() if k in ('l', 'm', 'n')}

อาจจะ:

subdict=dict([(x,bigdict[x]) for x in ['l', 'm', 'n']])

Python 3 รองรับสิ่งต่อไปนี้:

subdict={a:bigdict[a] for a in ['l','m','n']}

โปรดทราบว่าคุณสามารถตรวจสอบการมีอยู่ในพจนานุกรมดังนี้:

subdict=dict([(x,bigdict[x]) for x in ['l', 'm', 'n'] if x in bigdict])

รับผิดชอบ สำหรับหลาม 3

subdict={a:bigdict[a] for a in ['l','m','n'] if a in bigdict}

โอเคนี่เป็นสิ่งที่รบกวนฉันสองสามครั้งดังนั้นขอขอบคุณ Jayesh ที่ถามมัน

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

ดังนั้นสำหรับค่าสองเพนเนทของฉันฉันขอแนะนำให้เขียนพจนานุกรมย่อยเช่น

class my_dict(dict):
    def subdict(self, keywords, fragile=False):
        d = {}
        for k in keywords:
            try:
                d[k] = self[k]
            except KeyError:
                if fragile:
                    raise
        return d

ตอนนี้คุณสามารถดึงพจนานุกรมย่อยออกมาด้วย

orig_dict.subdict(keywords)

ตัวอย่างการใช้งาน:

#
## our keywords are letters of the alphabet
keywords = 'abcdefghijklmnopqrstuvwxyz'
#
## our dictionary maps letters to their index
d = my_dict([(k,i) for i,k in enumerate(keywords)])
print('Original dictionary:\n%r\n\n' % (d,))
#
## constructing a sub-dictionary with good keywords
oddkeywords = keywords[::2]
subd = d.subdict(oddkeywords)
print('Dictionary from odd numbered keys:\n%r\n\n' % (subd,))
#
## constructing a sub-dictionary with mixture of good and bad keywords
somebadkeywords = keywords[1::2] + 'A'
try:
    subd2 = d.subdict(somebadkeywords)
    print("We shouldn't see this message")
except KeyError:
    print("subd2 construction fails:")
    print("\toriginal dictionary doesn't contain some keys\n\n")
#
## Trying again with fragile set to false
try:
    subd3 = d.subdict(somebadkeywords, fragile=False)
    print('Dictionary constructed using some bad keys:\n%r\n\n' % (subd3,))
except KeyError:
    print("We shouldn't see this message")

หากคุณเรียกใช้รหัสทั้งหมดข้างต้นคุณจะเห็นผลลัพธ์ดังนี้ (ขออภัยสำหรับการจัดรูปแบบ):

พจนานุกรมต้นฉบับ:
{'a': 0, 'c': 2, 'b': 1, 'e': 4, 'd': 3, 'g': 6, 'f': 5, 'i': 8, 'h': 7, 'k': 10, 'j': 9, 'm': 12, 'l': 11, 'o': 14, 'n': 13, 'q': 16, 'p': 15, 's': 18, 'r': 17, 'u': 20, 't': 19, 'w': 22, 'v': 21, 'y': 24, 'x ': 23,' z ': 25}

พจนานุกรมจากปุ่มหมายเลขคี่:
{'a': 0, 'c': 2, 'e': 4, 'g': 6, 'i': 8, 'k': 10, 'm': 12, ' o ': 14,' q ': 16,' s ': 18,' u ': 20,' w ': 22,' y ': 24}

การสร้าง subd2 ล้มเหลว:
พจนานุกรมดั้งเดิมไม่มีคีย์บางปุ่ม

พจนานุกรมที่สร้างโดยใช้คีย์ที่ไม่ดี:
{'b': 1, 'd': 3, 'f': 5, 'h': 7, 'j': 9, 'l': 11, 'n': 13, 'p': 15, 'r': 17, 't': 19, 'v': 21, 'x': 23, 'z': 25}

คุณยังสามารถใช้map(ซึ่งเป็นฟังก์ชั่นที่มีประโยชน์มากในการทำความรู้จัก):

sd = dict(map(lambda k: (k, l.get(k, None)), l))

ตัวอย่าง:

large_dictionary = {'a1':123, 'a2':45, 'a3':344}
list_of_keys = ['a1', 'a3']
small_dictionary = dict(map(lambda key: (key, large_dictionary.get(key, None)), list_of_keys))

PS: ฉันยืม.get(key, None)คำตอบก่อนหน้านี้ :)

อีกอันหนึ่ง (ฉันชอบคำตอบของ Mark Longair)

di = {'a':1,'b':2,'c':3}
req = ['a','c','w']
dict([i for i in di.iteritems() if i[0] in di and i[0] in req])

สารละลาย

from operator import itemgetter
from typing import List, Dict, Union


def subdict(d: Union[Dict, List], columns: List[str]) -> Union[Dict, List[Dict]]:
    """Return a dict or list of dicts with subset of 
    columns from the d argument.
    """
    getter = itemgetter(*columns)

    if isinstance(d, list):
        result = []
        for subset in map(getter, d):
            record = dict(zip(columns, subset))
            result.append(record)
        return result
    elif isinstance(d, dict):
        return dict(zip(columns, getter(d)))

    raise ValueError('Unsupported type for `d`')

ตัวอย่างการใช้งาน

# pure dict

d = dict(a=1, b=2, c=3)
print(subdict(d, ['a', 'c']))

>>> In [5]: {'a': 1, 'c': 3}

# list of dicts

d = [
    dict(a=1, b=2, c=3),
    dict(a=2, b=4, c=6),
    dict(a=4, b=8, c=12),
]

print(subdict(d, ['a', 'c']))

>>> In [5]: [{'a': 1, 'c': 3}, {'a': 2, 'c': 6}, {'a': 4, 'c': 12}]