Từ điển Python: Nhận danh sách các giá trị cho danh sách các khóa

Có cách nào tích hợp / nhanh chóng để sử dụng danh sách các khóa vào từ điển để lấy danh sách các mục tương ứng không?

Chẳng hạn tôi có:

>>> mydict = {'one': 1, 'two': 2, 'three': 3}
>>> mykeys = ['three', 'one']

Làm cách nào tôi có thể sử dụng mykeysđể lấy các giá trị tương ứng trong từ điển dưới dạng danh sách?

>>> mydict.WHAT_GOES_HERE(mykeys)
[3, 1]

Một sự hiểu biết danh sách dường như là một cách tốt để làm điều này:

>>> [mydict[x] for x in mykeys]
[3, 1]

Một vài cách khác ngoài list-comp:

• Xây dựng danh sách và ném ngoại lệ nếu không tìm thấy khóa: map(mydict.__getitem__, mykeys)
• Xây dựng danh sách với Nonenếu không tìm thấy khóa:map(mydict.get, mykeys)

Ngoài ra, sử dụng operator.itemgettercó thể trả về một tuple:

from operator import itemgetter
myvalues = itemgetter(*mykeys)(mydict)
# use `list(...)` if list is required

Lưu ý : trong Python3, maptrả về một iterator chứ không phải là một danh sách. Sử dụng list(map(...))cho một danh sách.

Một chút so sánh tốc độ:

Python 2.7.11 |Anaconda 2.4.1 (64-bit)| (default, Dec  7 2015, 14:10:42) [MSC v.1500 64 bit (AMD64)] on win32
In[1]: l = [0,1,2,3,2,3,1,2,0]
In[2]: m = {0:10, 1:11, 2:12, 3:13}
In[3]: %timeit [m[_] for _ in l]  # list comprehension
1000000 loops, best of 3: 762 ns per loop
In[4]: %timeit map(lambda _: m[_], l)  # using 'map'
1000000 loops, best of 3: 1.66 µs per loop
In[5]: %timeit list(m[_] for _ in l)  # a generator expression passed to a list constructor.
1000000 loops, best of 3: 1.65 µs per loop
In[6]: %timeit map(m.__getitem__, l)
The slowest run took 4.01 times longer than the fastest. This could mean that an intermediate result is being cached 
1000000 loops, best of 3: 853 ns per loop
In[7]: %timeit map(m.get, l)
1000000 loops, best of 3: 908 ns per loop
In[33]: from operator import itemgetter
In[34]: %timeit list(itemgetter(*l)(m))
The slowest run took 9.26 times longer than the fastest. This could mean that an intermediate result is being cached 
1000000 loops, best of 3: 739 ns per loop

Vì vậy, hiểu danh sách và itemgetter là cách nhanh nhất để làm điều này.

CẬP NHẬT: Đối với các danh sách và bản đồ ngẫu nhiên lớn, tôi có một số kết quả khác nhau:

Python 2.7.11 |Anaconda 2.4.1 (64-bit)| (default, Dec  7 2015, 14:10:42) [MSC v.1500 64 bit (AMD64)] on win32
In[2]: import numpy.random as nprnd
l = nprnd.randint(1000, size=10000)
m = dict([(_, nprnd.rand()) for _ in range(1000)])
from operator import itemgetter
import operator
f = operator.itemgetter(*l)
%timeit f(m)
%timeit list(itemgetter(*l)(m))
%timeit [m[_] for _ in l]  # list comprehension
%timeit map(m.__getitem__, l)
%timeit list(m[_] for _ in l)  # a generator expression passed to a list constructor.
%timeit map(m.get, l)
%timeit map(lambda _: m[_], l)
1000 loops, best of 3: 1.14 ms per loop
1000 loops, best of 3: 1.68 ms per loop
100 loops, best of 3: 2 ms per loop
100 loops, best of 3: 2.05 ms per loop
100 loops, best of 3: 2.19 ms per loop
100 loops, best of 3: 2.53 ms per loop
100 loops, best of 3: 2.9 ms per loop

Vì vậy, trong trường hợp này, người chiến thắng rõ ràng là f = operator.itemgetter(*l); f(m), và người ngoài cuộc rõ ràng : map(lambda _: m[_], l).

CẬP NHẬT cho Python 3.6.4:

import numpy.random as nprnd
l = nprnd.randint(1000, size=10000)
m = dict([(_, nprnd.rand()) for _ in range(1000)])
from operator import itemgetter
import operator
f = operator.itemgetter(*l)
%timeit f(m)
%timeit list(itemgetter(*l)(m))
%timeit [m[_] for _ in l]  # list comprehension
%timeit list(map(m.__getitem__, l))
%timeit list(m[_] for _ in l)  # a generator expression passed to a list constructor.
%timeit list(map(m.get, l))
%timeit list(map(lambda _: m[_], l)
1.66 ms ± 74.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
2.1 ms ± 93.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.58 ms ± 88.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.36 ms ± 60.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.98 ms ± 142 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
2.7 ms ± 284 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
3.14 ms ± 62.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Vì vậy, kết quả cho Python 3.6.4 gần như giống nhau.

Đây là ba cách.

Tăng KeyErrorkhi không tìm thấy khóa:

result = [mapping[k] for k in iterable]

Giá trị mặc định cho các khóa bị thiếu.

result = [mapping.get(k, default_value) for k in iterable]

Bỏ qua các phím bị thiếu.

result = [mapping[k] for k in iterable if k in mapping]

Thử cái này:

mydict = {'one': 1, 'two': 2, 'three': 3}
mykeys = ['three', 'one','ten']
newList=[mydict[k] for k in mykeys if k in mydict]
print newList
[3, 1]

Thử cái này:

mydict = {'one': 1, 'two': 2, 'three': 3}
mykeys = ['three', 'one'] # if there are many keys, use a set

[mydict[k] for k in mykeys]
=> [3, 1]

new_dict = {x: v for x, v in mydict.items() if x in mykeys}

Pandas thực hiện điều này rất thanh lịch, mặc dù việc hiểu danh sách sẽ luôn mang tính kỹ thuật hơn Pythonic. Tôi không có thời gian để đưa ra một so sánh tốc độ ngay bây giờ (tôi sẽ quay lại sau và đưa nó vào):

import pandas as pd
mydict = {'one': 1, 'two': 2, 'three': 3}
mykeys = ['three', 'one']
temp_df = pd.DataFrame().append(mydict)
# You can export DataFrames to a number of formats, using a list here. 
temp_df[mykeys].values[0]
# Returns: array([ 3.,  1.])

# If you want a dict then use this instead:
# temp_df[mykeys].to_dict(orient='records')[0]
# Returns: {'one': 1.0, 'three': 3.0}

Hoặc chỉ mydict.keys()Đó là một phương thức dựng sẵn gọi cho từ điển. Cũng khám phá mydict.values()và mydict.items().

// À, bài OP làm tôi bối rối.

Sau khi đóng cửa Python: cách hiệu quả để tạo danh sách từ các giá trị dict với một thứ tự nhất định

Lấy các khóa mà không xây dựng danh sách:

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)

import collections


class DictListProxy(collections.Sequence):
    def __init__(self, klist, kdict, *args, **kwargs):
        super(DictListProxy, self).__init__(*args, **kwargs)
        self.klist = klist
        self.kdict = kdict

    def __len__(self):
        return len(self.klist)

    def __getitem__(self, key):
        return self.kdict[self.klist[key]]


myDict = {'age': 'value1', 'size': 'value2', 'weigth': 'value3'}
order_list = ['age', 'weigth', 'size']

dlp = DictListProxy(order_list, myDict)

print(','.join(dlp))
print()
print(dlp[1])

Đầu ra:

value1,value3,value2

value3

Khớp với thứ tự được đưa ra bởi danh sách

reduce(lambda x,y: mydict.get(y) and x.append(mydict[y]) or x, mykeys,[])

Trong đó có các phím không trong dict.