Seite 1 von 1

lokale Funktionen und deren Geltungsbereich

Verfasst: Dienstag 5. Mai 2009, 15:05
von 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.

Verfasst: Dienstag 5. Mai 2009, 15:15
von 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.

Verfasst: Dienstag 5. Mai 2009, 15:32
von 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 :(

Verfasst: Dienstag 5. Mai 2009, 15:38
von 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,))]``?

Verfasst: Dienstag 5. Mai 2009, 15:45
von 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).

Re: lokale Funktionen und deren Geltungsbereich

Verfasst: Dienstag 5. Mai 2009, 16:37
von Darii
Thuught hat geschrieben: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

Verfasst: Dienstag 5. Mai 2009, 17:43
von 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

Verfasst: Dienstag 5. Mai 2009, 18:39
von 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.

Verfasst: Dienstag 5. Mai 2009, 21:32
von 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.

Verfasst: Dienstag 5. Mai 2009, 22:00
von Leonidas
BlackJack hat geschrieben:'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 :)