파이썬 사전 객체에서 키-값 쌍의 하위 집합을 추출합니까?

몇 가지 키 값 쌍 (약 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'))

... 또는 파이썬 3파이썬 버전 2.7 이상 ( 2.7에서 작동한다는 것을 지적한 Fábio Diniz 덕분에 ) :

{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')}

파이썬 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))

추신 : 나는 .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}]