कंसोल विंडो

Question

में एक किनारे पेड़ प्रारूप में सुंदर प्रिंट आउटपुट मेरे पास पाइथन का उपयोग करके इस तरह का एक शब्दकोश है।

d = {'a': ['Adam', 'Book', 4], 'b': ['Bill', 'TV', 6, 'Jill', 'Sports', 1, 'Bill', 'Computer', 5], 'c': ['Bill', 'Sports', 3], 'd': ['Quin', 'Computer', 3, 'Adam', 'Computer', 3], 'e': ['Quin', 'TV', 2, 'Quin', 'Book', 5], 'f': ['Adam', 'Computer', 7]} 

मैं इसे कंसोल पर एक किनारे के पेड़ प्रारूप में प्रिंट करना चाहता था। मैंने सुंदर प्रिंट करने की कोशिश की है, लेकिन जब शब्दकोश लंबा हो जाता है, तो इसे पढ़ना मुश्किल हो जाता है।

उदाहरण के लिए, इस शब्दकोश के साथ, यह वापसी होगी:

a -> Book -> Adam -> 4 
b -> TV -> Bill -> 6 
    -> Sports -> Jill -> 1 
    -> Computer -> Bill -> 5 
c -> Sports -> Bill -> 3 
d -> Computer -> Quin -> 3 
       -> Adam -> 3 
e -> TV -> Quin -> 2 
    Book -> Quin -> 5 
f -> Computer -> Adam -> 7 

अनिवार्य रूप से, सुंदर प्रिंट, गतिविधि, या सूची में दूसरे स्थान पर आइटम द्वारा आयोजित किया जाता तो नाम से और फिर से नंबर।

उपरोक्त नमूना आउटपुट सिर्फ एक उदाहरण है। मैंने Pretty print a tree के साथ काम करने की कोशिश की लेकिन यह पता लगाने में असमर्थ था कि इसे कैसे एक तरफ प्रारूप में बदलना है।

Answer 1

def treePrint(tree): 
    for key in tree: 
     print key, # comma prevents a newline character 
     treeElem = tree[key] # multiple lookups is expensive, even amortized O(1)! 
     for subElem in treeElem: 
      print " -> ", subElem, 
      if type(subElem) != str: # OP wants indenting after digits 
       print "\n " # newline and a space to match indenting 
     print "" # forces a newline 

Answer 2

यहां मैं यह कैसे करूँगा। चूंकि पेड़ केवल दो स्तरों का गहराई है - इसके बावजूद आपका वांछित आउटपुट प्रारूप क्या प्रतीत होता है - इसकी सामग्री को पार करने के लिए रिकर्सन का उपयोग करने की आवश्यकता नहीं है, क्योंकि पुनरावृत्ति काफी अच्छी तरह से काम करती है। शायद यह आपके द्वारा संदर्भित # एफ कोड की तरह कुछ नहीं है, क्योंकि मुझे भाषा नहीं पता है, लेकिन यह बहुत कम और अधिक पठनीय है - कम से कम मेरे लिए।

from itertools import izip 

def print_tree(tree): 
    for key in sorted(tree.iterkeys()): 
     data = tree[key] 
     previous = data[0], data[1], data[2] 
     first = True 
     for name, activity, value in izip(*[iter(data)]*3): # groups of three 
      activity = activity if first or activity != previous[1] else ' '*len(activity) 
      print '{} ->'.format(key) if first else ' ', 
      print '{} -> {} -> {}'.format(activity, name, value) 
      previous = name, activity, value 
      first = False 

d = {'a': ['Adam', 'Book', 4], 
    'b': ['Bill', 'TV', 6, 'Jill', 'Sports', 1, 'Bill', 'Computer', 5], 
    'c': ['Bill', 'Sports', 3], 
    'd': ['Quin', 'Computer', 3, 'Adam', 'Computer', 3], 
    'e': ['Quin', 'TV', 2, 'Quin', 'Book', 5], 
    'f': ['Adam', 'Computer', 7]} 

print_tree(d) 

आउटपुट:

from itertools import izip 

def print_tree(tree): 
    for key in sorted(tree.iterkeys()): 
     data = tree[key] 
     previous = data[0], data[1], data[2] 
     first = True 
     for name, activity, value in sorted(izip(*[iter(data)]*3)): # changed 
      name = name if first or name != previous[0] else ' '*len(name) # changed 
      print '{} ->'.format(key) if first else ' ', 
      print '{} -> {} -> {}'.format(name, activity, value) # changed 
      previous = name, activity, value 
      first = False 

:

a -> Book -> Adam -> 4 
b -> TV -> Bill -> 6 
    Sports -> Jill -> 1 
    Computer -> Bill -> 5 
c -> Sports -> Bill -> 3 
d -> Computer -> Quin -> 3 
       -> Adam -> 3 
e -> TV -> Quin -> 2 
    Book -> Quin -> 5 
f -> Computer -> Adam -> 7 

अद्यतन

गतिविधि के बजाय नाम से उत्पादन आप तीन लाइनों को बदलने की जरूरत होगी व्यवस्थित करने के लिए नीचे दिए गए संकेत के रूप में

संशोधन के बाद आउटपुट:

a -> Adam -> Book -> 4 
b -> Bill -> Computer -> 5 
      -> TV -> 6 
    Jill -> Sports -> 1 
c -> Bill -> Sports -> 3 
d -> Adam -> Computer -> 3 
    Quin -> Computer -> 3 
e -> Quin -> Book -> 5 
      -> TV -> 2 
f -> Adam -> Computer -> 7 

Answer 3

आप ETE toolkit के कोड पर एक नज़र डाल सकते हैं। समारोह _asciiArt पेड़ भी with internal node labels

from ete2 import Tree 
t = Tree("(((A,B), C), D);") 
print t 

#    /-A 
#   /---| 
#  /---|  \-B 
# | | 
#----|  \-C 
# | 
#  \-D