Auf der Suche nach einer guten Python Tree-Datenstruktur [geschlossen]

Ich suche eine gute Tree-Datenstrukturklasse. Ich bin auf dieses Paket gestoßen , aber da ich relativ neu in Python bin (keine Programmierung), weiß ich nicht, ob es bessere gibt.

Ich würde gerne von den Pythonisten hier hören - haben Sie ein Lieblingsbaumskript, das Sie regelmäßig verwenden und empfehlen würden?

[Bearbeiten]

Zur Verdeutlichung meine ich mit 'Baum' einen einfachen ungeordneten Baum (Hmm, das ist eine rekursive Definition - aber hoffentlich klärt das die Dinge etwas). In Bezug darauf, wofür ich den Baum brauche (dh Anwendungsfall). Ich lese Baumdaten aus einer flachen Datei und muss aus den Daten einen Baum erstellen und alle Knoten im Baum durchlaufen.

Roll deinen eigenen. Modellieren Sie beispielsweise Ihren Baum einfach als Listenliste. Sie sollten Ihre spezifischen Bedürfnisse detaillieren, bevor die Leute bessere Empfehlungen geben können.

Als Antwort auf die Frage von HelloGoodbye ist dies ein Beispielcode zum Iterieren eines Baums.

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

Ein Haken ist, dass diese rekursive Implementierung O (n log n) ist. Es funktioniert gut für alle Bäume, mit denen ich umgehen muss. Vielleicht würde der Subgenerator in Python 3 helfen.

Sie können einen schönen Baum von Diktaten wie diesen bauen:

import collections

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

Es ist vielleicht nicht genau das, was Sie wollen, aber es ist sehr nützlich! Werte werden nur in den Blattknoten gespeichert. Hier ist ein Beispiel, wie es funktioniert:

>>> 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'})}) 

Weitere Informationen finden Sie im Kern .

Ich fand ein Modul von Brett Alistair Kromkamp, ​​das nicht abgeschlossen wurde. Ich habe es fertiggestellt und auf Github veröffentlicht und in treelib(Original pyTree) umbenannt:

https://github.com/caesar0301/treelib

Möge es Ihnen helfen ...

Aufbauend auf der oben angegebenen Antwort mit dem einzeiligen Baum unter Verwendung von defaultdict können Sie daraus eine Klasse machen. Auf diese Weise können Sie Standardeinstellungen in einem Konstruktor einrichten und auf andere Weise darauf aufbauen.

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

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

In diesem Beispiel können Sie eine Rückreferenz erstellen, damit jeder Knoten auf seinen übergeordneten Knoten im Baum verweisen kann.

>>> 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

Als Nächstes können Sie __setattr__ im Klassenbaum sogar überschreiben, sodass es beim erneuten Zuweisen des übergeordneten Elements als untergeordnetes Element von diesem übergeordneten Element entfernt wird. Viele coole Sachen mit diesem Muster.

Für einen Baum mit bestellten Kindern würde ich normalerweise so etwas tun (obwohl etwas weniger allgemein, zugeschnitten auf das, was ich tue):

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)

Sie könnten etwas tun, das mit a dictoder using vergleichbar ist , DictMixinoder es sind modernere Nachkommen, wenn Sie möchten, dass ungeordnete Kinder per Schlüssel aufgerufen werden.

Es kann sich lohnen, einen eigenen Tree Wrapper zu schreiben, der auf einem azyklisch gerichteten Diagramm unter Verwendung der networkx- Bibliothek basiert .

Eine weitere gute und benutzerfreundliche Implementierung von Bäumen in Python ist pyTree: https://github.com/caesar0301/pyTree

pyTree bietet auch die Möglichkeit, den Baum zu visualisieren:

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

Hier ist etwas, woran ich gearbeitet habe.

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)

Verwendung als solche (Zahlen als Beispielwerte): t = Tree(1, Tree(2, Tree(4)), Tree(3, Tree(5)))

Würde BTrees helfen? Sie sind Teil des Codes der Zope Object Database. Das Herunterladen des gesamten ZODB-Pakets ist etwas übertrieben, aber ich hoffe, dass das BTrees-Modul zumindest etwas trennbar ist.

Ich denke aus meiner eigenen Erfahrung mit Problemen mit fortgeschritteneren Datenstrukturen, dass das Wichtigste, was Sie hier tun können, darin besteht, ein gutes Wissen über das allgemeine Konzept von Tress als Datenstrukturen zu erlangen. Wenn Sie den grundlegenden Mechanismus hinter dem Konzept verstehen, ist es recht einfach, die Lösung zu implementieren, die zu Ihrem Problem passt. Es gibt viele gute Quellen, die das Konzept beschreiben. Was mich vor Jahren bei diesem speziellen Problem "gerettet" hat, war Abschnitt 2.3 in "Die Kunst der Computerprogrammierung".