Извличане на подмножество от двойки ключ-стойност от обекта на речника на Python?

Можете да опитате:

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

... или в Python 3 Python версии 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)

Малко сравнение на скоростта за всички споменати методи:

АКТУАЛИЗИРАНО на 13.07.2020 (thx на @user3780389): САМО за ключове от bigdict.

 IPython 5.5.0 -- An enhanced Interactive Python.
Python 2.7.18 (default, Aug  8 2019, 00:00:00) 
[GCC 7.3.1 20180303 (Red Hat 7.3.1-5)] on linux2
import numpy.random as nprnd
  ...: keys = nprnd.randint(100000, size=10000)
  ...: bigdict = dict([(_, nprnd.rand()) for _ in range(100000)])
  ...: 
  ...: %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 {key:bigdict[key] for key in set(keys) & set(bigdict.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: 2.36 ms per loop
100 loops, best of 3: 2.87 ms per loop
100 loops, best of 3: 3.65 ms per loop
100 loops, best of 3: 7.14 ms per loop
1 loop, best of 3: 577 ms per loop
1 loop, best of 3: 563 ms per loop

Както се очакваше: речниковите разбирания са най-добрият вариант.

Този отговор използва речниково разбиране, подобно на избрания отговор, но няма да се изключи липсващ елемент.

версия на python 2:

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

версия на python 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])

респ. за python 3

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

Можете също да използвате 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) от предишен отговор :)

Добре, това е нещо, което ме безпокои няколко пъти, така че благодаря ти, Джайеш, че го попита.

Отговорите по-горе изглеждат толкова добро решение, колкото и всяко друго, но ако използвате това в целия си код, има смисъл да обгърнете функционалността 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}

Още един (предпочитам отговора на Марк Лонгеър)

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

Използването на map (отговорът на halfdanrump) е най-доброто за мен, въпреки че не съм го замерил...

Но ако изберете речник и ако имате big_dict:

1. Уверете се, че преминавате през req. Това е от решаващо значение и влияе върху времето за изпълнение на алгоритъма (голямо O, тита, каквото и да е)
2. Напишете го достатъчно общо, за да избегнете грешки, ако ключовете не са там.

so e.g.:

big_dict = {'a':1,'b':2,'c':3,................................................}
req = ['a','c','w']

{k:big_dict.get(k,None) for k in req )
# or 
{k:big_dict[k] for k in req if k in big_dict)

Обърнете внимание, че в обратния случай, когато req е голям, но my_dict е малък, вместо това трябва да преминете през my_dict.

Като цяло, ние правим пресичане и сложността на проблема е O(min(len(dict)),min (len(req))). собствена реализация на пресичане на Python отчита размера на двата набора , така че изглежда оптимално. Освен това, като е в c и е част от основната библиотека, вероятно е по-бързо от повечето неоптимизирани изрази на python. Следователно решение, което бих обмислил, е:

dict = {'a':1,'b':2,'c':3,................................................}
req = ['a','c','w',...................]

{k:dic[k] for k in set(req).intersection(dict.keys())}

Той премества критичната операция вътре в c кода на python и ще работи за всички случаи.