एक अच्छा अजगर ट्री डेटा संरचना की तलाश [बंद]

Question 1

बन्द है। यह प्रश्न स्टैक ओवरफ्लो दिशानिर्देशों को पूरा नहीं करता है । यह वर्तमान में उत्तर स्वीकार नहीं कर रहा है।

इस प्रश्न को सुधारना चाहते हैं? सवाल को अपडेट करें ताकि यह स्टैक ओवरफ्लो के लिए विषय पर हो ।

5 साल पहले बंद हुआ ।

मैं एक अच्छे ट्री डेटा स्ट्रक्चर क्लास की तलाश में हूं। मैं इस पैकेज में आया हूं , लेकिन चूंकि मैं पायथन (प्रोग्रामिंग नहीं) के लिए अपेक्षाकृत नया हूं, मुझे नहीं पता कि वहां कोई बेहतर व्यक्ति हैं या नहीं।

मैं यहाँ पर पाइथोनिस्टस से सुनना चाहता हूँ - क्या आपके पास एक पसंदीदा ट्री स्क्रिप्ट है जिसे आप नियमित रूप से उपयोग करेंगे और सुझाएंगे?

[संपादित करें]

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

Question 2

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

HelloGoodbye के सवाल के जवाब में, यह एक पेड़ को पुनरावृत्त करने के लिए एक नमूना कोड है।

def walk(node):
    """ iterate tree in pre-order depth-first search order """
    yield node
    for child in node.children:
        for n in walk(child):
            yield n

एक पकड़ यह पुनरावर्ती कार्यान्वयन हे (एन लॉग एन) है। यह उन सभी पेड़ों के लिए ठीक काम करता है जिनसे मुझे निपटना है। शायद पायथन 3 में उपसमूह मदद करेगा।

Question 3

आप इस तरह से dicts के एक अच्छे पेड़ का निर्माण कर सकते हैं:

import collections

def Tree():
    return collections.defaultdict(Tree)

यह बिल्कुल वैसा नहीं हो सकता जैसा आप चाहते हैं लेकिन यह काफी उपयोगी है! मान केवल पत्ती नोड्स में सहेजे जाते हैं। यह कैसे काम करता है इसका एक उदाहरण है:

>>> t = Tree()
>>> t
defaultdict(<function tree at 0x2142f50>, {})
>>> t[1] = "value"
>>> t[2][2] = "another value"
>>> t
defaultdict(<function tree at 0x2142f50>, {1: 'value', 2: defaultdict(<function tree at 0x2142f50>, {2: 'another value'})})

अधिक जानकारी के लिए जिस्ट पर एक नज़र डालें ।

Question 4

मुझे ब्रेट एलिस्टेयर क्रॉम्पम्प द्वारा लिखा गया एक मॉड्यूल मिला जो पूरा नहीं हुआ था। मैंने इसे समाप्त किया और इसे गीथूब पर सार्वजनिक किया और इसका नाम बदलकर treelib(मूल pyTree) रखा:

https://github.com/caesar0301/treelib

यह आपकी मदद कर सकता है ....

Question 5

डिफ़ॉल्ट लाइन का उपयोग करके सिंगल लाइन ट्री के साथ ऊपर दिए गए उत्तर पर निर्माण करना , आप इसे एक वर्ग बना सकते हैं। यह आपको एक कंस्ट्रक्टर में चूक को स्थापित करने और अन्य तरीकों से उस पर निर्माण करने की अनुमति देगा।

class Tree(defaultdict):
    def __call__(self):
        return Tree(self)

    def __init__(self, parent):
        self.parent = parent
        self.default_factory = self

यह उदाहरण आपको एक बैक रेफरेंस बनाने की अनुमति देता है ताकि प्रत्येक नोड पेड़ में अपने माता-पिता को संदर्भित कर सके।

>>> t = Tree(None)
>>> t[0][1][2] = 3
>>> t
defaultdict(defaultdict(..., {...}), {0: defaultdict(defaultdict(..., {...}), {1: defaultdict(defaultdict(..., {...}), {2: 3})})})
>>> t[0][1].parent
defaultdict(defaultdict(..., {...}), {1: defaultdict(defaultdict(..., {...}), {2: 3})})
>>> t2 = t[0][1]
>>> t2
defaultdict(defaultdict(..., {...}), {2: 3})
>>> t2[2]
3

इसके बाद, आप क्लास ट्री पर __setattr__ को भी ओवरराइड कर सकते हैं, ताकि जब माता-पिता को आश्वस्त किया जाए, तो यह उस माता-पिता से एक बच्चे के रूप में इसे हटा देता है। इस पैटर्न के साथ बहुत सारी सामग्री।

Question 6

आदेश दिए गए बच्चों के साथ एक पेड़ के लिए, मैं आमतौर पर इस तरह का कुछ करूँगा (हालांकि थोड़ा कम सामान्य, जो मैं कर रहा हूं उसके अनुरूप):

class TreeNode(list):

    def __init__(self, iterable=(), **attributes):
        self.attr = attributes
        list.__init__(self, iterable)

    def __repr__(self):
        return '%s(%s, %r)' % (type(self).__name__, list.__repr__(self),
            self.attr)

आप एक dictया उपयोग करने के साथ तुलनीय कुछ कर सकते हैं DictMixinया यह अधिक आधुनिक वंशज हैं यदि आप चाहते हैं कि बिना मोड के बच्चों को कुंजी द्वारा एक्सेस किया जाए।

Question 7

यह नेटवर्कएक्स लाइब्रेरी का उपयोग करके एक चक्रीय निर्देशित ग्राफ के आधार पर अपने स्वयं के ट्री रैपर लिखने के लायक हो सकता है ।

Question 8

पायथन में पेड़ों के कार्यान्वयन के लिए एक और अच्छा और आसान तरीका है pyTree: https://github.com/caesar0301/pyree

पेड़ से पेड़ को देखने की क्षमता भी मिलती है:

Harry[harry]
|___ Jane[jane]
|    |___ Diane[diane]
|         |___ George[george]
|              |___ Jill[jill]
|         |___ Mary[mary]
|    |___ Mark[mark]
|___ Bill[bill]

Question 9

यहाँ कुछ मैं काम कर रहा था।

class Tree:
    def __init__(self, value, *children):
        '''Singly linked tree, children do not know who their parent is.
        '''
        self.value = value
        self.children = tuple(children)

    @property
    def arguments(self):
        return (self.value,) + self.children

    def __eq__(self, tree):
        return self.arguments == tree.arguments

    def __repr__(self):
        argumentStr = ', '.join(map(repr, self.arguments))
        return '%s(%s)' % (self.__class__.__name__, argumentStr)

इस तरह से उपयोग करें (उदाहरण मान के रूप में प्रयुक्त संख्या): t = Tree(1, Tree(2, Tree(4)), Tree(3, Tree(5)))

Question 10

क्या बीट्रीज़ मदद करेंगे ? वे ज़ोप ऑब्जेक्ट डेटाबेस कोड का हिस्सा हैं। पूरे ZODB पैकेज को डाउनलोड करना थोड़ा अधिक है, लेकिन मुझे उम्मीद है कि BTrees मॉड्यूल कम से कम कुछ अलग होगा।

Question 11

मुझे लगता है, अधिक उन्नत डेटा संरचनाओं के साथ समस्याओं पर अपने स्वयं के अनुभव से, कि आप यहां सबसे महत्वपूर्ण बात कर सकते हैं, डेटा संरचनाओं के रूप में तनाव की सामान्य अवधारणा पर एक अच्छा ज्ञान प्राप्त करना है। यदि आप अवधारणा के पीछे मूल तंत्र को समझते हैं तो आपकी समस्या को हल करने वाले समाधान को लागू करना काफी आसान होगा। अवधारणा का वर्णन करने वाले कई अच्छे स्रोत हैं। इस विशेष समस्या पर सालों पहले मुझे "बचाया", "द आर्ट ऑफ़ कंप्यूटर प्रोग्रामिंग" में धारा 2.3 था।