2011-02-01 32 views
7

मैं निम्नलिखित कार्य हो:मेक नक्शा() वापसी एक शब्दकोश

[{'customer.customer_number': 0L}, {'customer.name': 2L}, ... ] 

मैं इस तरह सिर्फ एक शब्दकोश पसंद करेंगे:

def heading_positions(self): 
    return map(
      lambda h: 
       {'{t}.{c}'.format(t=h.table_name,c=h.column_name) : h.position }, 
       self.heading_set.all() 
      ) 

यह मुझे इस तरह उत्पादन देता है

{'customer.customer_number': 0L, 'customer.name': 2L, ... 

क्या map (या कुछ समान) बनाने का कोई तरीका है डिक्शनरी की सरणी के बजाय केवल एक एकल शब्दकोश लौटाएं मेष राशि?

उत्तर

7

तो क्यों map() का उपयोग करें?

dict(
    ('{t}.{c}'.format(t=h.table_name, c=h.column_name), h.position) 
    for h in self.heading_set.all() 
    ) 

काम करना चाहिए।

+3

या '{'{t}। {C}'। प्रारूप (...): h. के लिए h.position self.heading_set.all()} 'हाल के संस्करणों में (dict समझ के साथ)। – delnan

+1

डिक्टरी की समझ 2.7/3.1 में दिखाई देती है। –

2
return dict(('{t}.{c}'.format(t=h.table_name, c=h.column_name), h.position) 
      for h in self.heading_set.all()) 
1

अन्य उत्तर दिखाने के रूप में, आप dict() comprehensions उपयोग कर सकते हैं।

लेकिन, एक जिज्ञासा शायद के रूप में, आप भी उपयोग कर सकते हैं reduce

संपादित: टिप्पणी कहते हैं, dict() इस मामले में आसान है। लेकिन, (अजगर का जादू शब्दकोश comprehensions के बिना) केवल सिद्धांत की खातिर, मैं क्या मतलब था कि यह केवल कार्यात्मक इमारत ब्लॉकों का उपयोग कर हल करने के लिए संभव है के लिए:

def union(d1,d2): 
    result = {} 
    result.update(d1) 
    result.update(d2) 
    return result 

तब:

reduce(union, sequence_of_dictionaries, {}) 

वैकल्पिक रूप से, कम साफ लेकिन और अधिक कुशल, कि अपनी पहली तर्क देता है dict.update का एक वैकल्पिक संस्करण का उपयोग कर:

def update2(d1, d2): 
    dict.update(d1, d2) 
    return d1 

या भी:

update2 = lambda d1,d2: (d1, d1.update(d2))[0] 
फिर

:

reduce(update2, sequence_of_dictionaries, {}) 

कहाँ इस मामले में sequence_of_dictionaries होगा:

[{'{t}.{c}'.format(t=h.table_name, c=h.column_name) : h.position} 
for h in self.heading_set.all()] 
+0

...... किस लिए? – eumiro

+1

कभी भी ध्यान न दें, एक सूची समझ के साथ dict() इस मामले में एक त्वरित समाधान है। लेकिन सैद्धांतिक रूप से आप संघ और एक खाली dict पर एक गुना चाहते हैं, जो मैं लक्ष्य था ... – sinelaw

+0

यदि आपका उत्तर गलत है, इसे हटाएं या इसे ठीक करें। यदि यह सही है, तो कृपया इसे कैसे करें इसका एक उदाहरण शामिल करें। – agf

6

हां। मूल समस्या यह है कि आप सिंगल-एंट्री dict एस से एक शब्दकोश नहीं बनाते हैं, लेकिन लंबाई-दो अनुक्रमों के अनुक्रम में से (key, value)

तो, समारोह के साथ एक स्वतंत्र एकल प्रवेश dict बनाने के बजाय, एक टपल बनाने और उसके बाद आप उपयोग कर सकते dict() निर्माता:

dict(map(lambda h: ('{t}.{c}'.format(t=h.table_name, c=h.column_name), h.position), 
     self.heading_set.all())) 

या सीधे dict निर्माता के अंदर एक जनरेटर या सूची समझ का उपयोग :

dict(('{t}.{c}'.format(t=h.table_name, c=h.column_name), h.position) 
    for h in self.heading_set.all()) 

या, नवीनतम संस्करणों (2.7, 3) पर।1) एक शब्दकोश समझ सीधे:

{'{t}.{c}'.format(t=h.table_name : c=h.column_name), h.position) 
    for h in self.heading_set.all()} 
संबंधित मुद्दे