[Python] Passaggio oggetti tra classi
De Santis Luca
farolfo a hotmail.com
Lun 9 Dic 2013 11:25:10 CET
Ho risolto in questo modo, non sarà molto “pythonico” ma verifica con il programma di test:
def path(self,w):
pathname=self.nomeNodo
lst=set()
if self.nomeNodo==w:
lst.append(tuple(pathname))
self._path(self,w,pathname,lst)
return lst
def _path(self,inNodo,w,pathname,lst):
ret=pathname
for nodo in inNodo.sottoNodi:
pathname = ret + "\\"+ nodo.nomeNodo
if len(nodo.sottoNodi)>0:
self._path(nodo,w,pathname,lst)
if nodo.nomeNodo==w:
lst.add(tuple(item for item in pathname.split("\\") if item.strip()))
Prima che vi scandaliziate per il sistema usato, l’esercizio prevedeva che venisse restituito un insieme di tuple, per ogni path tovato dovevo quindi creare una tupla con tutti gli elementi del percorso. Grazie per le dritte che mi avete dato
Inviata da Windows Mail
Da: De Santis Luca
Data invio: domenica 8 dicembre 2013 20:42
A: Mailing List Python
Ho provato a seguire il tuo suggerimento, solo ce ho un comportamento strano, cioè che non capisco io, ho implementato la funzione path in questo modo:
def path(self,w):
ret=[]
ret.append(self.nomeNodo)
self._path(self,w,ret)
return ret
def _path(self,root, w,lista):
print "sono in _path"
if root.nomeNodo==w:
#print root.nomeNodo
lista.append(root.nomeNodo)
#return lista
else:
for nodo in root.sottoNodi:
#print root.nomeNodo
lst=nodo._path(nodo,w,lista)
if lst is list:
for i in lst:
print "Sono nel for"
lista.append(i.nomeNodo)
#return lista
La funzione così com’è non mi entra mai nel ciclo for, dove c’è la stampa:
for i in lst:
print "Sono nel for"
lista.append(i.nomeNodo)
e mi restituisce una lista con solo la root e il nodo finale che sto cercando, ce però aggiunge 2 volte. Se invece decommento i return la funzione mi rimane in loop ferma e non mi restituisce mai la lista.
Da: Daniele Varrazzo
Data invio: venerdì 6 dicembre 2013 23:19
A: Mailing List Python
On 2013-12-06 17:35, De Santis Luca wrote:
Ciao Luca,
> Vi ammorbo ancora con gli alberi. Devo fare una funzione per trovare
> il path di una qualsiasi foglia di un albero.
>
>
> Per fare ciò ho pensato di inserire nella classe che definisce
> l’albero un campo nodoGenitore, così, facendo la ricerca di un nodo
> per nome, quando trovo il nodo che mi interessa, vedo chi è il nodo
> padre e vado a ritroso fino alla radice e trovo il path completo
> della
> foglia.
Questo di solito non è necessario negli algoritmi ricorsivi. Tra
l'altro in Python hai anche un problema: se hai due oggetti che si
riferiscono l'uno all'altro tipo (a.figli contiene b e b.genitore punta
ad a) hai un ciclo di riferimenti. Poiché Python distrugge gli oggetti
quando il refcount scende a zero questi due oggetti si tengono in vita
l'uno con l'altro e potresti avere un memory leak. Questo è molto
semplificato: il GC di Python è abbastanza intelligente di accorgersi di
molti casi in cui un ciclo di oggetti non ha riferimenti esterni e alla
fine riesce a reclamarlo, ma non sempre e così (quando non sia possibile
è un po' complesso, ma ben documentato). Per farla corta, meno cicli hai
nel codice, meglio è (e sempre a volerla dire tutta weakref è un modo
fatto apposta per avere cicli "rompibili", ma anche di questo non ne hai
bisogno per ora: la butto là in caso ti vada di approfondire).
Tornando a bomba: secondo me il puntatore del genitore non ti serve: il
tornare a ritroso te lo dà lo srotolamento dello stack quando la
soluzione viene trovata: io farei una funzione che interroga i figli e,
se uno di loro è positivo, aggiunge sé stesso al valore di ritorno (se
uno dei miei figli è la soluzione, anche io sono la soluzione!)
Quando un nodo è la soluzione? quando w == nomeNodo. Non ti serve
chiederlo ai figli, giusto? Penso ti sia infilato in un vicolo cieco
mentale facendo:
> def _path(self,root,w):
> for node in root.sottoNodi:
> if(node.nomeNodo==w):
non serve chiederlo ai figli, e hai anche il problema che se root è la
soluzione, non la troverai, giusto?
Questa funzione deve restituire una lista di nodi: direi che se c'è una
soluzione sarebbe una lista che ha prima la radice, poi il suo figlio
che porta alla soluzione... fino alla soluzione. Essendo l'algoritmo
ricorsivo, puoi scriverlo in maniera che, gira gira, troverai un albero
la cui radice è la soluzione (che poi sia la radice complessiva o solo
un sotto-sotto-nodo non serve saperlo a lui: serve saperlo al
chiamante). Quindi qualcosa come:
def path(self, w):
# sono io la soluzione?
# sì: fico: restituisci una lista che contiene solo me stesso
# no? peccato, ma:
# per ognuno dei miei figli
# dammi il path per w
# è una lista? fico allora
# aggiungo me stesso all'inizio della lista
# e restituisco la lista a chi mi ha chiamato
questo l'ho scritto in pseudocodice, ma l'ho implementato anche in
python. Ti dò una possibilità di farlo da te se vuoi: letteralmente ogni
riga che ho scritto si trasforma in un'instruzione Python, ma così credo
sia ancora più chiaro l'algoritmo. Se vuoi la soluzione completa te la
passo (o te la passa qualcun altro).
Nota che se la parola non viene trovata in nessuno dei figli il flusso
di esecuzione esce alla fine della funzione senza incontrare un return.
Questo equivale a "return None", ed è il risultato alternativo di "è una
lista? fico". In pratica nodo.path(w) restituisce una lista se la
soluzione viene trovata, altrimenti None.
In bocca al lupo!
-- Daniele
_______________________________________________
Python mailing list
Python a lists.python.it
http://lists.python.it/mailman/listinfo/python
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20131209/b85f21b5/attachment-0001.html>
-------------- parte successiva --------------
_______________________________________________
Python mailing list
Python a lists.python.it
http://lists.python.it/mailman/listinfo/python
Maggiori informazioni sulla lista
Python