Probleme mit PyQT, Python und Shell-commands [Anfänger]

[lunar]

@cofi: Kann es sein, dass Du "Closure" falsch verstehst? "Closure" bedeutet, dass eine Funktion Namen aus dem umgebenden Namensraum referenziert. "partial" ist keine Closure, sondern eine partielle Funktionsanwendung.

[cofi]

Deine Definition verliert den "Abschluss" Teil der "Closure", nämlich, dass die Closure die freien Variablen mit den zur Definitionszeit gebundenen Werten mit sich herum trägt.

Mangels besserer Quelle aus der Wikipedia:

Such a function is said to be "closed over" its free variables. The referencing environment binds the nonlocal names to the corresponding variables in scope at the time the closure is created, additionally extending their lifetime to at least as long as the lifetime of the closure itself. When the closure is entered at a later time, possibly from a different scope, the function is executed with its non-local variables referring to the ones captured by the closure.

[jerch]

Imho sind beides Closures*, nur nutzt lunar nicht den Erstellungskontext im lambda-Bsp. sondern referenziert auf eine globalen Bezeichner im Funktionskörper, welcher neu ausgewertet wird und eine anderes Objekt vorfindet.

Mit Bindung an einen lokalen Namen klappts auch mit lambda (ungetestet):

Code: Alles auswählen

a = 1
f = lambda x=a : x
f() # geht
del a
f() # geht auch

Javascript verhält sich da nicht anders und meckert auch innerhalb eines Closures über das Verschwinden globaler Variablen.

* Technisch gesehen, würde ich sagen, ist partial kein Closure, da es kein Funktionsobjekt zurückgibt. Allerdings imitiert das partial-Objekt Closure-Funktionalität. An der Stelle könnte man darüber streiten, ob in einer Sprache, bei der Funktionen Objekte sind, überhaupt echte Closures möglich sind. Zumindest werden zu first-class functions und higher-order functions Tricks mit Funktionspointern oder Objekten in Wikipedia unter Alternativen aufgeführt.

Edit: Ergänzungen eingefügt - war gestern schon spät

[lunar]

@cofi: Ein Funktionsabschluss bindet eben nicht die zur Definitionszeit vorliegenden Werte freie Variablen. Er bindet die freien Variablen selbst, im Falle von Python eben über die Referenz des übergeordneten Namensraums.

"partial()" ist schon deswegen keine Closure, weil es da überhaupt gar keine freien Variablen gibt. Die an "partial()" übergebenen Objekte werden wie gesagt übergeben, es liegt also ein ganz normaler Funktionsaufruf vor, bei dem die übergebenen Objekte innerhalb der Funktion an unabhängige, lokale und gebundene Variablen gebunden werden. Die Variablen, die im Aufruf von "partial()" stehen, sind im aufrufenden Namensraum gebunden, und gehen mit dessen Bereinigung verloren. Es wird also auch nicht die Lebenszeit dieser Variablen verlängert.

@jerch: In Deinem Beispiel ist "f" kein Funktionsabschluss mehr, da er keine freien Variablen mehr referenziert. "x" ist gebunden im Namensraum von "f", und "a" wird zum Zeitpunkt der Erzeugung von "f" ausgewertet.

[jerch]

@jerch: In Deinem Beispiel ist "f" kein Funktionsabschluss mehr, da er keine freien Variablen mehr referenziert. "x" ist gebunden im Namensraum von "f", und "a" wird zum Zeitpunkt der Erzeugung von "f" ausgewertet.

In der Tat ist mein Bsp. falsch und muss eigentlich so aussehen:

Code: Alles auswählen

lambda a : lambda :a

Nur ist

Code: Alles auswählen

f = lambda: print(s)

doch äquivalent zu

Code: Alles auswählen

def f():
    return print(s)

wo 'f()' einfach eine Referenz aus dem zur Callzeit umgebenden Namensraum (bis hoch zum globalen) mitführt und Änderungen durchschlagen. Das entspricht einem Funktionsaufruf mit nichtlokalen Referenzen.
Der Trick an Closures ist doch, dass man sich einen "Zwischennamensraum" zunutze macht, um Zustände zu speichern, die bei erneutem Aufruf restauriert werden (und nichtlokal sind, da aus dem Zwischennamensraum), Bsp in Javascript:

Code: Alles auswählen

/*
   Beispiel 1
   ist zwar ein Closure, doch nutzt a die Closurefunktionalität nicht,
   da es nicht Teil des Zwischennamensraumes ist - analog zu `lambda : print(s)`
*/
var a = 1;
function f() {
return function() {return a}
}
g = f();
g(); // --> gibt a zurück
delete a;
g(); //--> Fehler

/*
   Beispiel 2
   a wird im Zwischennamensraum gebunden und ist daher
   auch nach Löschen von a weiter in der inneren Funktion verfügbar
*/
var a = 1;
function f(a) {
return function() {return a}
}
g = f(a);
g(); // --> gibt a zurück
delete a;
g(); //--> geht

Und letzteres Verhalten imitiert partial - was es imho zu einem Closure-like Konstrukt macht. Die Variablen sind zwar nicht "frei", da immer Parameter der auszuführenden Funktion - werden aber im partial-Objekt zwischengespeichert, welches die Rolle des Zwischennamensraumes einnimmt.

[deets]

@jerch

"Closures are a poor man's objects. And objects are a poor man's closures".

Partial benutzt ein Objekt, und erreicht dadurch die Aufbewahrung des Zustandes. Aber eben *kein* Closure. Wenn du die Begriffe zur Unkenntlichkeit aufweichen willst, wem ist damit geholfen? Das alles ist irgendwie programmieren...

[lunar]

@jerch: deets hat bereits festgestellt, dass Du den falschen Schluss aus "Beispiel 2" gezogen hast. Es folgt daraus eben nicht, dass "partial()" "closure-like" ist. Du hast vielmehr gezeigt, dass man mit Funktionsabschlüssen Objektexemplare implementieren kann (und umgekehrt natürlich). Was Du mit "Zwischennamensraum" bezeichnet hast, ist nichts anderes, als der Namensraum eines Objektexemplars (im Falle von Python alle an "self" gebundenen Namen).

"partial()" selbst ist dennoch kein Funktionsabschluss, und dem auch nicht ähnlicher als jedwedes andere Objekt, schon weil das wesentliche konstituierende Element eines Funktionsabschlusses, nämlich das Vorkommen freier Variablen, bei der Verwendung von "partial()" gar nicht gegeben ist. Auch ist dieser "Zwischennamensraum" nicht die eigentliche Funktionalität [1] eines Funktionsabschlusses, sondern nur ein ganz normaler Namensraum, den man halt zusammen mit einem Funktionsabschluss nutzen kann (beispielsweise um Objekte zu implementieren).

Die Funktionalität eines Funktionsabschlusses besteht - nur um das nochmals klarzustellen - ausschließlich in der Bindung freier Variablen in einem Ausdruck an den umgebenden Namensraum. Dass Funktionsabschlüsse benutzt werden können, um Objekte zu implementieren, und diese Konzepte mithin von gleicher Mächtigkeit sind, ist nicht die konstituierende Eigenschaft eines Funktionsabschlusses. Anders gesagt, der Terminus "Funktionsabschluss" wird nicht darüber definiert, dass man damit Objekte implementieren kann. Der Zusammenhang zwischen "partial()" und einem Funktionsabschluss ist also in etwa derselbe wie zwischen zwei Programmiersprachen: Man kann jede Sprache A in jeder anderen Sprache B implementieren (vorausgesetzt, beide sind gleich mächtig), doch trotzdem sind A und B noch immer unterschiedliche Sprachen.