lokale Funktionen und deren Geltungsbereich

[Thuught]

Hallo zusammen,
Ich bin dabei mir eine anonyme Funktion anzulegen und hätte eine Frage dazu.
Soweit ich das verstanden habe, kann eine lokale Funktion die Variabeln ihrer globalen maximal auslesen, aber nicht überschreiben. Aber genau das will ich eigentlich erreichen:

Bei der verschachtelten Funktion handelt es sich um einen Generator, der Teilabschnitte einer zu iterierenden Liste in der Hauptfunktion übernimmt. Es geht mir um die Position des Iterators, der gewissermaßen "vererbt" wird.

Ich kann mir vorstellen, dass das gesamte Konzept absolut unpraktisch klingt, aber ich wäre trotzdem dankbar, wenn mir jemand in dieser Sache helfen könnte.

[EyDu]

Ich verstehe nicht so ganz, worauf du hinaus möchtest. Vielleicht könntest du etwas Beispielcode posten, wie es in etwa aussehen soll und was du am Ende als Ergebnis erwartest.

[Thuught]

Ok, aber bitte nicht nörgeln.

Code: Alles auswählen

def parsetree(liste):
	it=iter(liste)
	token=it.next()
	def scope(x):
        #liefert aus a(b(c)d(e)) die items: b(c)d(e) oder aus a->None
       boo="nix" 
		while boo!=0:
			if token==")":
				boo-=1
				if (boo!=0 and token==")"): yield token
			elif boo!="nix":yield token
			if token=="(":
				if boo=="nix": boo=1
				else: boo+=1
			token=it.next()
	baum=Tree(token)
	for i in scope(liste):
		baum.addSubtree(parsetree(i))

Es handelt sich um eine Übungsaufgabe, wobei man aus einer Liste nach dem Stil [a,(,b,(,c,),)] als Baum darstellen soll. Klingt zwar einfach, aber irgendwie bereitete mir das von anfang an Probleme. Ich hasse Bäume

[derdon]

Code: Alles auswählen

>>> [a,(,b,(,c,),)]
  File "<stdin>", line 1
    [a,(,b,(,c,),)]
        ^
SyntaxError: invalid syntax

Also: Wie soll diese Struktur vor der Verarbeitung aussehen und wie nachher?


Edit: Ich rate einfach mal: Meinst du vielleicht ``[a, (b, (c,))]``?

[Thuught]

Das sollte eine Liste aus Strings darstellen, also:
"a(b(c()))">> ["a","(","b","(","c",")",")"]>>Baumklasse

ich hatte zuvor mit REs herumexperimentiert, aber da gabs auch irgendwie Probleme(abgesehen vom meterlangen Ausdrücken).

[Darii]

Soweit ich das verstanden habe, kann eine lokale Funktion die Variabeln ihrer globalen maximal auslesen, aber nicht überschreiben. Aber genau das will ich eigentlich erreichen:

In Python 3 gibt es dafür das Schlüsselwort ``nonlocal``. In Python 2.x kannst du dir mit einer Liste o.ä. behelfen.

Code: Alles auswählen

def outer():
    foo = ["hallo"]
    def inner():
        foo[0] = "ciau"
    print foo[0]
    inner()
    print foo[0]
#--------------------------#
>>> outer()
hallo
ciau

[Thuught]

Vielen Dank für den Hinweis, das war echt hilfreich

Code: Alles auswählen

def test(liste):
	it=iter(liste)
	def next(x=it):return x.next()
	def scope(x):
		token[0]=next()
		print token[0]
	token=[next()]
	print token[0]
	scope(liste)
	scope(liste)

test([1,2,3])
1
2
3

[Leonidas]

``next`` ist ein schlechter Name im Hinblick auf Python 3.0 und außerdem sehe ich nicht ganz wozu es nötig wäre eine lokale Funktion zu definieren wenn man die Struktur doch einfach auch rekursiv verarbeiten kann.

[BlackJack]

@Thuught: Anstelle der `next()`-Funktion könntest Du auch einfach die `next()`-Methode des Iterators an einen lokalen Namen binden: ``next = iter(liste).next``

Ansonsten verstehe ich auch nicht so recht was Du da eigentlich versuchst, denn 'a(b(c()))' sieht nicht wirklich nach einem Baum aus, oder wenn, dann nach einem ziemlich entarteten. Ist eher eine rekursiv definierte Liste.

[Leonidas]

'a(b(c()))' sieht nicht wirklich nach einem Baum aus, oder wenn, dann nach einem ziemlich entarteten. Ist eher eine rekursiv definierte Liste.

Vielleicht will er ja Paare 'cons'en