शब्दकोश सूची में

Question

एक सूची में सूची को मानचित्र करने का कोई तरीका है? मैं जो करना चाहता हूं वह एक ऐसा कार्य है जो एक कुंजी का नाम वापस कर देगा, और मूल्य मूल मूल्य होगा। उदाहरण के लिए;

somefunction(lambda a: a[0], ["hello", "world"]) 
=> {"h":"hello", "w":"world"} 

(यह एक विशिष्ट उदाहरण है कि मैं क्या करना चाहते हैं नहीं है, मैं चाहता हूँ map() की तरह एक सामान्य समारोह है कि यह कर सकते हैं)

Answer 1

मुझे नहीं लगता कि एक मानक समारोह है कि करता है वास्तव में मौजूद है है

def somefunction(keyFunction, values): 
    return dict((keyFunction(v), v) for v in values) 

print somefunction(lambda a: a[0], ["hello", "world"]) 

आउटपुट::

{'h': 'hello', 'w': 'world'} 

, लेकिन यह dict builtin का उपयोग कर एक और एक समझ के निर्माण के लिए बहुत आसान है

लेकिन इस समारोह के लिए एक अच्छा नाम के साथ आने से इसे लागू करने से कहीं अधिक कठिन है। मैं इसे पाठक के लिए एक अभ्यास के रूप में छोड़ दूंगा।

Answer 2

अगर मैं आपके सवाल का सही ढंग से समझ, मेरा मानना ​​है कि आप map, zip के संयोजन के साथ ऐसा कर सकते हैं, और dict निर्माता:

def dictMap(f, xs) : 
    return dict(zip(map(f, xs), xs) 

और एक saner कार्यान्वयन:

def dictMap(f, xs) : 
    return dict((f(i), i) for i in xs) 

Answer 3

में पायथन 3 आप इस शब्दकोश समझ वाक्यविन्यास का उपयोग कर सकते हैं:

def foo(somelist): 
    return {x[0]:x for x in somelist} 

Answer 4

यदि आप ऐसा करने के लिए एक सामान्य कार्य चाहते हैं, तो आप लगभग सही सवाल पूछ रहे हैं। आपका उदाहरण निर्दिष्ट नहीं करता है कि क्या होता है जब कुंजी फ़ंक्शन डुप्लिकेट उत्पन्न करता है। क्या आप आखिरी रखते हैं? पहले वाला? क्या आप वास्तव में एक ही पत्र से शुरू होने वाले सभी शब्दों की एक सूची बनाना चाहते हैं? फ़ंक्शन के उपयोगकर्ता द्वारा डिजाइन किए गए इन प्रश्नों का शायद सबसे अच्छा जवाब दिया गया है।

इन परिणामों पर अधिक जटिल, लेकिन बहुत सामान्य, कार्य में पैरामीटरेटिंग। के लिए,

reduce_list(lambda s:s, lambda s,old:s[0], '', ['hello', 'world']) 
# OR 
reduce_list(lambda s:s, lambda s,old: old or s[0], '', ['hello', 'world']) 

आप पहले या अंतिम शब्द के साथ शुरू रखना चाहते हैं पर निर्भर करता है:

def reduce_list(key, update_value, default_value, l): 
    """Reduce a list to a dict. 

    key :: list_item -> dict_key 
    update_value :: key * existing_value -> updated_value 
    default_value :: initial value passed to update_value 
    l :: The list 

    default_value comes before l. This is different from functools.reduce, 
    because functools.reduce's order is wrong. 
    """ 
    d = {} 
    for k in l: 
     j = key(k) 
     d[j] = update_value(k, d.get(j, default_value)) 
    return d 

तो फिर तुम कह कर अपने कार्य लिख सकते हैं: यहाँ एक है कि मैं कई वर्षों के लिए इस्तेमाल किया गया है उदाहरण, 'एच'।

इस समारोह है, हालांकि, बहुत ही सामान्य है, इसलिए समय के सबसे यह अन्य कार्यों, group_dict या histogram तरह के लिए आधार है:

def group_dict(l): 
    return reduce_list(lambda x:x, lambda x,old: [x] + old, [], l) 
def histogram(l): 
    return reduce_list(lambda x:x, lambda x,total: total + 1, 0, l) 

Answer 5

>>> dict((a[0], a) for a in "hello world".split()) 
{'h': 'hello', 'w': 'world'} 

आप subscripting के बजाय एक समारोह का उपयोग करना चाहते हैं, तो operator.itemgetter का उपयोग करें:

>>> from operator import itemgetter 
>>> first = itemgetter(0) 
>>> dict((first(x), x) for x in "hello world".split()) 
{'h': 'hello', 'w': 'world'} 

या एक समारोह के रूप:

>>> dpair = lambda x : (first(x), x) 
>>> dict(dpair(x) for x in "hello world".split()) 
{'h': 'hello', 'w': 'world'} 

अंत में, यदि आप एक पत्र के रूप में एक से अधिक शब्द प्रति अक्षर चाहते हैं, तो संग्रह का उपयोग करें।डिफॉल्टडिक्ट

>>> from collections import defaultdict 
>>> words = defaultdict(set) 
>>> addword = lambda x : words[first(x)].add(x) 
>>> for word in "hello house home hum world wry wraught".split(): 
     addword(word) 


>>> print words['h'] 
set(['house', 'hello', 'hum', 'home']) 

Answer 6

अन्य उत्तरों से संकेत लेते हुए मैंने मानचित्र ऑपरेशन का उपयोग करके इसे हासिल किया। मुझे यकीन नहीं है कि यह वास्तव में आपके प्रश्न का उत्तर देता है या नहीं।

mylist = ["hello", "world"] 
def convert_to_dict(somelist): 
    return dict(map(lambda x: (x[0], x), somelist)) 

final_ans = convert_to_dict(mylist) 
print final_ans