मानचित्र दो शब्दकोशों

Question

में से एक एकल सूची में सूचियों कल्पना कीजिए मैं इन अजगर सूचियों है:

keys = ['name', 'age'] 
values = ['Monty', 42, 'Matt', 28, 'Frank', 33] 

वहाँ एक सीधा या कम से कम एक सरल शब्दकोशों की निम्न सूची का निर्माण करने के तरीका है?

[ 
    {'name': 'Monty', 'age': 42}, 
    {'name': 'Matt', 'age': 28}, 
    {'name': 'Frank', 'age': 33} 
] 

Answer 1

यहाँ जिप रास्ता

def mapper(keys, values): 
    n = len(keys) 
    return [dict(zip(keys, values[i:i + n])) 
      for i in range(0, len(values), n)] 

Answer 2

बेवकूफ तरीका है, लेकिन एक है कि मेरे मन को तुरंत आता है:

def fields_from_list(keys, values): 
    iterator = iter(values) 
    while True: 
     yield dict((key, iterator.next()) for key in keys) 

list(fields_from_list(keys, values)) # to produce a list. 

Answer 3

zip लगभग आप क्या चाहते हैं करता है, दुर्भाग्यवश, छोटी सूची में साइकिल चलाने की बजाए, यह टूट जाता है। शायद चक्र से संबंधित एक कार्य है?

$ python 
>>> keys = ['name', 'age'] 
>>> values = ['Monty', 42, 'Matt', 28, 'Frank', 33] 
>>> dict(zip(keys, values)) 
{'age': 42, 'name': 'Monty'} 

/संपादित करें: ओह, आप एक सूची की dict चाहते हैं। निम्नलिखित कार्य (पीटर के लिए भी धन्यवाद):

from itertoos import cycle 

keys = ['name', 'age'] 
values = ['Monty', 42, 'Matt', 28, 'Frank', 33] 

x = zip(cycle(keys), values) 
map(lambda a: dict(a), zip(x[::2], x[1::2])) 

Answer 4

मेरा सरल दृष्टिकोण यहां है। ऐसा लगता है कि @ चेरी को छोड़कर मैंने इनपुट सूची को नष्ट कर दिया था।

def pack(keys, values): 
    """This function destructively creates a list of dictionaries from the input lists.""" 
    retval = [] 
    while values: 
    d = {} 
    for x in keys: 
     d[x] = values.pop(0) 
    retval.append(d) 
    return retval 

Answer 5

फिर भी एक और कोशिश है, शायद पहले एक से बेवकूफी:

def split_seq(seq, count): 
    i = iter(seq) 
    while True: 
     yield [i.next() for _ in xrange(count)] 

>>> [dict(zip(keys, rec)) for rec in split_seq(values, len(keys))] 
[{'age': 42, 'name': 'Monty'}, 
{'age': 28, 'name': 'Matt'}, 
{'age': 33, 'name': 'Frank'}] 

लेकिन यह है कि क्या यह बेवकूफी है तय करने के लिए आप पर निर्भर है।

Answer 6

जवाब में से Konrad Rudolph

ज़िप लगभग आप क्या चाहते हैं करता है; दुर्भाग्यवश, छोटी सूची में साइकिल चलाने की बजाए, यह टूट जाता है। शायद चक्र से संबंधित एक कार्य है?

यहाँ एक तरीका है:

keys = ['name', 'age'] 
values = ['Monty', 42, 'Matt', 28, 'Frank', 33] 
iter_values = iter(values) 
[dict(zip(keys, iter_values)) for _ in range(len(values) // len(keys))] 

मैं इसे नहीं देगा pythonic (मुझे लगता है कि यह बहुत चालाक है), लेकिन यह हो सकता है क्या के लिए देख रहे हैं।

वहाँ keys सूची itertools.cycle() का उपयोग कर साइकिल में कोई लाभ नहीं है, क्योंकि keys से प्रत्येक ट्रेवर्सल एक dictionnary के निर्माण से मेल खाती है है।

संपादित करें:

def iter_cut(seq, size): 
    for i in range(len(seq)/size): 
     yield seq[i*size:(i+1)*size] 

keys = ['name', 'age'] 
values = ['Monty', 42, 'Matt', 28, 'Frank', 33] 
[dict(zip(keys, some_values)) for some_values in iter_cut(values, len(keys))] 

यह बहुत अधिक pythonic है: एक स्पष्ट उद्देश्य के साथ एक पठनीय उपयोगिता समारोह है, और कोड के बाकी इसे से स्वाभाविक रूप से बहती है यहाँ एक और तरीका है।

Answer 7

यह बहुत नहीं है लेकिन यहाँ एक एक लाइनर एक सूची समझ, ज़िप और स्टेपिंग का उपयोग कर रहा है:

[dict(zip(keys, a)) for a in zip(values[::2], values[1::2])] 

Answer 8

[dict(zip(keys,values[n:n+len(keys)])) for n in xrange(0,len(values),len(keys)) ] 

स्नातकीय-LEEE। मुझे ऐसा लगता है कि कोड देखने से नफरत है। लेकिन यह सही दिखता है।

def dictizer(keys, values): 
    steps = xrange(0,len(values),len(keys)) 
    bites = (values[n:n+len(keys)] for n in steps) 
    return (dict(zip(keys,bite)) for bite in bites) 

फिर भी एक छोटे से बदसूरत, लेकिन नाम इसके बारे में समझ बनाने में मदद।