क्या सूची को बिना किसी रिकर्सन के कुंजी के घोंसला वाले ताना में बदलना संभव है?

Question

मान लीजिए मैं एक सूची था इस प्रकार है:

mylist = ['a','b','c','d'] 

निम्नलिखित dict बिना प्रत्यावर्तन/एक पुनरावर्ती समारोह का उपयोग कर बनाने के लिए संभव है, इस सूची से,?

{ 
    'a': { 
    'b': { 
     'c': { 
     'd': { } 
     } 
    } 
    } 
} 

Answer 1

इस सरल मामले के लिए कम से कम, हाँ:

my_list = ['a', 'b', 'c', 'd'] 
cursor = built_dict = {} 
for value in my_list: 
    cursor[value] = {} 
    cursor = cursor[value] 

Answer 2

mydict = dict() 
currentDict = mydict 
for el in mylist: 
    currentDict[el] = dict() 
    currentDict = currentDict[el] 

Answer 3

सरल मामले के लिए, बस पुनरावृति और निर्माण, दोनों छोर से या शुरू:

result = {} 
for name in reversed(mylist): 
    result = {name: result} 

या

result = current = {} 
for name in mylist: 
    current[name] = {} 
    current = current[name] 

पहला समाधान भी एक एक लाइनर reduce() का उपयोग कर के रूप में व्यक्त किया जा सकता है:

reduce(lambda res, name: {name: res}, reversed(mylist), {}) 

Answer 4

यह उल्लेख है कि every recursion can be converted into iteration, हालांकि कभी-कभी लगता है कि इतना आसान नहीं हो सकता है लायक है। प्रश्न में विशेष उदाहरण के लिए, यह इतना आसान है, यह केवल एक चर में अपेक्षित परिणाम जमा करने और उचित क्रम में इनपुट सूची को स्थानांतरित करने का विषय है।

def convert(lst): 
    acc = {} 
    for e in reversed(lst): 
     acc = {e: acc} 
    return acc 

या भी कम, ऊपर एल्गोरिथ्म एक एक लाइनर के रूप में व्यक्त किया जा सकता है (यह मानते हुए अजगर 2.x, अजगर 3.x reduce में functools मॉड्यूल के लिए ले जाया गया था): यह मैं क्या मतलब है। गौर करें कि पिछले समाधान में चर नाम लैम्ब्डा के मानकों के अनुरूप है, और कैसे दोनों ही मामलों में संचायक का प्रारंभिक मूल्य {} है:

def convert(lst): 
    return reduce(lambda acc, e: {e: acc}, reversed(lst), {}) 

किसी भी तरह से, समारोह convert काम करता है के रूप में उम्मीद:

mylist = ['a','b','c','d'] 
convert(mylist) 

=> {'a': {'b': {'c': {'d': {}}}}} 

Answer 5

या fancyness और कम पठनीयता के लिए:

dict = reduce(lambda x, y: {y: x}, reversed(myList), {})