Alla ricerca di una buona struttura dati ad albero Python [chiuso]

Sto cercando una buona classe di struttura dati ad albero. Mi sono imbattuto in questo pacchetto , ma dal momento che sono relativamente nuovo in Python (non programmando), non so se ce ne siano di migliori là fuori.

Mi piacerebbe sentire i Pythonistas qui: hai uno script albero preferito che usi regolarmente e che consiglieresti?

[Modificare]

Per chiarire, con "Albero", intendo un semplice albero non ordinato (Hmm, questa è una definizione un po 'ricorsiva - ma si spera, questo chiarisce un po' le cose). Riguardo a cosa mi serve l'albero (cioè caso d'uso). Sto leggendo i dati dell'albero da un file flat e ho bisogno di creare un albero dai dati e attraversare tutti i nodi dell'albero.

Rotola il tuo. Ad esempio, modella il tuo albero come elenco di elenchi. Dovresti dettagliare le tue esigenze specifiche prima che le persone possano fornire consigli migliori.

In risposta alla domanda di HelloGoodbye, questo è un codice di esempio per iterare un albero.

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

Un problema è che questa implementazione ricorsiva è O (n log n). Funziona bene per tutti gli alberi con cui ho a che fare. Forse il sottogeneratore in Python 3 potrebbe aiutare.

Puoi costruire un bell'albero di dicts of dict come questo:

import collections

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

Potrebbe non essere esattamente quello che vuoi ma è abbastanza utile! I valori vengono salvati solo nei nodi foglia. Ecco un esempio di come funziona:

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

Per ulteriori informazioni dai un'occhiata all'essenza .

Ho trovato un modulo scritto da Brett Alistair Kromkamp che non è stato completato. L'ho finito e l'ho reso pubblico su GitHub e l'ho rinominato come treelib(originale pyTree):

https://github.com/caesar0301/treelib

Possa aiutarti ...

Basandosi sulla risposta data sopra con l'albero a riga singola usando defaultdict , puoi renderlo una classe. Ciò ti consentirà di impostare le impostazioni predefinite in un costruttore e di costruirle in altri modi.

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

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

Questo esempio consente di fare un riferimento all'indietro in modo che ogni nodo possa fare riferimento al suo genitore nell'albero.

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

Successivamente, potresti persino sovrascrivere __setattr__ sulla classe Tree in modo che quando riassegni il genitore, lo rimuove come figlio da quel genitore. Molte cose interessanti con questo modello.

Per un albero con bambini ordinati, di solito faccio qualcosa di simile (anche se un po 'meno generico, adattato a quello che sto facendo):

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)

Potresti fare qualcosa di paragonabile a dicto usando DictMixino è discendenti più moderni se vuoi che i bambini non ordinati accedano per chiave.

Potrebbe valere la pena scrivere il tuo tree wrapper basato su un grafo diretto aciclico usando la libreria networkx .

Un'altra implementazione buona e facile da usare degli alberi in Python è pyTree: https://github.com/caesar0301/pyTree

pyTree fornisce anche la possibilità di visualizzare l'albero:

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

Ecco qualcosa su cui stavo lavorando.

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)

Usa come tale (numeri usati come valori di esempio): t = Tree(1, Tree(2, Tree(4)), Tree(3, Tree(5)))

BTrees sarebbe d' aiuto? Fanno parte del codice Zope Object Database. Scaricare l'intero pacchetto ZODB è un po 'eccessivo, ma spero che il modulo BTrees sia almeno un po' separabile.

Penso, in base alla mia esperienza su problemi con strutture dati più avanzate, che la cosa più importante che puoi fare qui è acquisire una buona conoscenza del concetto generale di tress come strutture dati. Se comprendi il meccanismo di base alla base del concetto, sarà abbastanza facile implementare la soluzione che si adatta al tuo problema. Ci sono molte buone fonti là fuori che descrivono il concetto. Ciò che mi ha "salvato" anni fa su questo particolare problema è stata la sezione 2.3 in "The Art of Computer Programming".