key error mit lambda

[BlackJack]

Also `partial()` hat schon echte Partial-Eigenschaften und es ist halt kein Makro weil Python keine Makros kennt. Wenn Du so etwas haben willst, dann musst Du halt eine Sprache verwenden die so etwas als Sprachmittel bietet. Hy beispielsweise, wenn man sich nicht allzu weit von Python entfernen möchte, und damit leben kann, das es eine Sprache ist, die noch recht jung und „im Fluss“ ist. Oder eben ein Lisp oder Scheme das schon ausgereifter und gesetzter ist. Oder eine andere Sprache die nicht aus der Lisp-Familie stammt, aber Makros zur Übersetzungszeit bietet.

In *der* Python-Dokumentation steht bei `partial()` eine in Python geschriebene Beispielimplementierung wie `partial()` grob funktioniert. Wenn Du das nicht zu gebrauchen findest, dann liegt das vielleicht nicht an Dir sondern an noch fehlendem Verständnis wie Python funktioniert. Tatsächlich ist es in CPython in C implementiert und da CPython quelloffen ist, auch einsehbar. Das heisst man kann sich wirklich *exakt* anschauen wie es funktioniert.

Zum markieren von Interna verwendet man *einen* führenden Unterstrich. Zwei haben eine andere Bedeutung und auch einen Effekt, sind also nicht nur reine Markierung.

Der Programmierer hat nicht nur die Macht über das Teilssystem, sondern kann auch an alles andere heran kommen. Wenn er mit anderen zusammenarbeitet und er sich auf sein Teilssystem beschränken soll, dann tut er das aus freien Stücken, oder sozialem Druck, oder sonstwas, aber nicht weil er es technisch nicht könnte.

Ich habe übrigens auch bis jetzt immer noch nicht verstanden was Du da eigentlich lösen willst. Weder wenn ich mir den Quelltext anschaue, noch aus den Beschreibungen.

Hilft es vielleicht sich noch einmal klar zu machen das auch Methoden Objekte sind und/oder das selbst geschriebene Datentypen auch den Aufruf über `__call__()` überschreiben können?

[Alfons Mittelmeyer]

Da braucht man auch kein dazischengeschaltetes Proxy-Objekt. Und was das ganze mit irgendwelchen Konfigurationen, die ein Administrator macht, zu tun hat, ...

Das braucht man aus verschiedenen Gründen. Wenn Nachrichten nur jeweils an einen einzigen Empfänger im Teilsystem geht, braucht man den Proxy nicht. Es könnten aber auch mehre Empfänger erwarten, benachrichtigt zu werden. Will man dann aus einer Nachricht, etwa fünf machen und will man nochmal Hand anlegen, wenn später noch etwas Weiteres auch benachrichtigt werden will?

Außerdem braucht man es ebenfalls, wenn es darum geht Nachrichten, an andere Teilsystem zu übergeben. Die haben ihre eigene Queue, die nur im Teilsystem selber lokal bekannt ist. Und das Teilsystem ist auch nicht global vorhanden. Warum soll sich der Programmierer darum kümmern, welches Teilsystem benachrichtigt werden muß, das zudem global nicht vorhanden ist, ebenso wenig wie die App bei App(proxy).mainloop()

Im übergebenen Proxy steht drin, welche Nachrichten auch nach außen gehen, und im Zentralen Proxy steht drin, welche Nachrichten von außen er etwa and Queue (im Proxy) der GUI App übergibt. Außerdem kennt der eigene Proxy dann den zentralen Proxy und dieser wiederum den eigenen. Ansonsten wären das alles nur Unbekannte.

Welche Nachrichten von welchen Teilsystemen an welche Teilsysteme gehen, das wird konfiguriert und das macht der Adminitrator und übergibt den Teilsystemen ihren entsprechend konfigurierten und dann nur mehr lokal vorhandenen Proxy.

Das wären etwa die Methoden des Proxy die eine GUI App haben sollte, wenn auch für eine statische GUI die ersten beiden genügen:

# was man für eine GUI App haben sollte
send # senden über Queue
do_receive # einen callback registrieren
undo_receive # einen callback deregistrieren

# alle callbacks für einen Eigentümer deregistrieren,
# etwa wenn man einen Frame löscht,
# für den mehrere callback Funktionen registriert sind
undo_receive_all

# direkter callback Aufruf,
# nur in wirklichen Ausnahmefällen evtl. erforderlich,
# etwa während destroy eines GUI Elementes
# mit Benachrichtigung an andere, wenn dabei die eigene Referenz mit übergeben wird
send_immediate

do_work # zum Triggern mit after für von extern (anderer Thread) übergebene Nachrichten

[BlackJack]

@Alfons Mittelmeyer: Die Frage ist ja was diese ganze Komplexität mit dem Problem zu tun hat das Du lösen willst, beziehungsweise steht ja immer noch die Frage im Raum was dieses Problem denn überhaupt ist.

Das die Namen alle reichtlich irreführend sind, hatten wir glaube ich anderer Stelle schon mal, das ist ja nicht das erste mal das dieser ”Proxy” von Dir gezeigt wird. Unter einem Proxy versteht man üblicherweise etwas anderes. Das was Du da machst nennt man üblicherweise Dispatcher, Channel, MessageBroker, Event, oder irgend etwas in der Art. Bei `do_receive()` würde man einen Handler erwarten der etwas empfängt. Und bei `undo_receive()` eine Methode die etwas Empfangenes rückgängig macht, was dann gleich ein Fragezeichen in den Raum stellt, weil das unmöglich oder zumindest komisch klingt.

[noisefloor]

Hallo,

was mir immer noch nicht klar ist:

* Du sprichst von Nachrichten, hast aber auch das Beispiel der MP4-Datei. Warum geht's denn jetzt? Nachrichten (=Strings)? Oder Dateiobjekte? Oder beides?
* Du sprichst Teilsystemen, Empfängern etc.? Wo "leben" die denn? Alles auf dem gleichen Rechner? Im gleichen Netzwerk? Im Internet?
* Was machen die Tk-Frames, von denen du sprichst, genau? Und wie wird wann unter welche Umständen ein Frame gelöscht?
* Wo besteht der Zusammenhang zwischen Frame und Nachricht?

Außerdem beschleicht mich so das Gefühl, dass du evtl. "Signal and Slots" von Qt nachbauen willst oder gerade selber einen Message Broker baust. Letztere gibt es reichlich, auch in ausgereifter Form und OpenSource. Wie z.B. RabbitMQ, ZeroMQ oder das PubSub System von Redis.

Gruß, noisefloor

[Alfons Mittelmeyer]

Hallo,

was mir immer noch nicht klar ist:
* Du sprichst von Nachrichten, hast aber auch das Beispiel der MP4-Datei. Warum geht's denn jetzt? Nachrichten (=Strings)? Oder Dateiobjekte? Oder beides?

Eine Nachricht besteht aus einer ID und übermittelten Daten. Die ID kann zwecks guter Lesbarkeit ein String sein, mann kann natürlich auch andere Werte benützen. Bei den Daten können natürlich auch Dateinamen übergeben werden, es könnte aber auch die Bytefolge einer MP3 Datei sein.

* Du sprichst Teilsystemen, Empfängern etc.? Wo "leben" die denn? Alles auf dem gleichen Rechner? Im gleichen Netzwerk? Im Internet?

Im einfachsten Fall iist es ein callback im eigenen Thread. Im zweiteinfachsten Fall sind es Teilsysteme in anderen Threads. Und der dritte Fall ist, daß die Nachrichten etwa über TCPIP an andere Prozesse auf demselben Rechner oder auf andere Rechner etwa über Intranet oder Internet weitergeleitet werden

* Was machen die Tk-Frames, von denen du sprichst, genau? Und wie wird wann unter welche Umständen ein Frame gelöscht?

Tk-Frames sind tkinter GUI Elemente, also Widgets. Man benutzt sie um eine GUI Anwendung zu strukturieren, anstatt alles in das Hauptfenster zu klatschen. Sie sind eine rechteckige Fläche, auf der man andere Widgets anordnet. Die meisten Anwendungen sind statische Anwendungen und da löscht man normalerweise keine Widgets. Allerdings baue ich etwa in meinem GuiDesigner Inhalte auch dynamisch auf und zeige Informationen etwa durch Frames, die einen Label mit dem Namen einer Option und die Option selber zum Verändern in einem Edit Feld präsentieren. Diese Liste an Optionen ist nicht immer gleich für verschiedene Widget Typen, daher lösche ich bei Auswahl von etwas anderem alle Widgets dieser Anzeige und baue die Anzeige dann wieder neu auf unter Neuerzeugung der erforderlichen Widgets für die Anzeige. Es kommt also durchaus vor, daß man Widgets löscht, wenn auch nicht im gewohnten Normalfall

* Wo besteht der Zusammenhang zwischen Frame und Nachricht?

Wenn man irgendo einen Button drückt, wird normalerweise eine Aktion ausgelöst, die oft auch das Erscheinen anderer GUI Elemente verändert. Für dieses andere GUI Element gibt es dann eine Funktion oder Methode, die während der callback Funktion des Buttons aufgerufen wird. Was aber geschieht, wenn dieses andere GUI Element nicht mehr existiert? Dann kommt es zum Crash, wenn man die Nachrichtemfang nicht deregistriert.

Was haben jetzt Nachrichten mit Frames zu tun? Es geht dabei um Methoden, die aufgerufen werden für die Widgets in diesem Frame. Normalerweise würde man die aufzurufenden Methoden für die Widgets der Containerklasse definieren, also etwa im Frame. Die Nachricht geht dann bei Verwendung des Proxys an eine Callback Methode im Frame. Damit ist der Frame sozusagen der Eigentümer der callback Methode somit auch der Eigentümer der registrierten zu empfangenen Nachricht. Daher übergibt man ihn bei "do_receive" als Eigentümer. Das self des Frames ist da die passende ID, gewiß ist die nur einmal vorhanden. Wenn eine callback Funktion nicht mehr aufgerufen werden soll, weil etwa die betreffenden Widgets nicht mehr da sind, kann man durch "undo_receive" den Nachrichtenempfang für die betreffende callback Methode deregistrieren.

Wenn nun der ganze Frame gelöscht wird, kann man durch "undo_receive_all' den Empfang aller Nachrichten für den Eigentümer - man benützt am Beste dessen self, mit einem einzigen Methodenaufruf deregistrieren. Das ist der Grund, wehalb man bei do_receive und undo_receive den Frame als Eigentümer mit angibt, anstatt sich eine sonstige ID auszudenken. Wenn man aber von diese Methode "undo_receive_all' nicht verwenden will, ist es egal was man bei "do_receive" und "undo_receive" als owner angibt, kann auch False oder irgend etwas sein.

Außerdem beschleicht mich so das Gefühl, dass du evtl. "Signal and Slots" von Qt nachbauen willst oder gerade selber einen Message Broker baust. Letztere gibt es reichlich, auch in ausgereifter Form und OpenSource. Wie z.B. RabbitMQ, ZeroMQ oder das PubSub System von Redis.

Den Message Broker baue ich nicht gerade, sondern der steht seit 2015. Und Nachbau von Slots ist da gar, es ist nur eine allgemein übliche Methode, wie auch in einem Fahrzeug, Nachrichten über diverse Busse, wie CAN Bus, MOST Bus usw. zu versenden. Die sind dann noch weiter unterteilt, nämlich nicht nur eine ID, sondern zwei, den Funktionsblock und die Message ID. Man könnte das auch hier und statt etwa "LINKE_VORDERTÜR" schreiben "TUEREN_FENSTER_KLAPPEN.LINKE_VORDERTÜR". Das hat den Vorteil dass man dann, wenn man sich nach außen für "TUEREN_FENSTER_KLAPPEN" registriert, alle dazu gehörigen Messages bekommt. Das erleichert den Verwaltungsaufwand bei so einer enormen Menge an Nachrichten in einem Fahrzeug. Allerdings habe ich jetzt so eine Aufteilung nicht implementiert. Ja wenn man hundert verschiedene nachrichten von außen bräuchte und dann nur fünf Nachrichtenblöcke registrieren bräuchte, würde das Konfiguration sehr erleichtern. Es ginge aber auch hier. Dazu nimmt man als Message ID "TUEREN_FENSTER_KLAPPEN" und als erste Paremeter "LINKE_VORDERTÜR" und dann implementiert man einen Message Controller, welcher die "TUEREN_FENSTER_KLAPPEN" Messages in einen eigenen Proxy für "TUEREN_FENSTER_KLAPPEN" umschaufelt mit dem ersten Parameter als Message ID. Oder wenn die Message ID die ID für das Subsystem ist, an welches man senden will, erleichtert sich die Proxy und Weiterleitungs Konfiguration.

Gruß, Alfons

[Alfons Mittelmeyer]

In *der* Python-Dokumentation steht bei `partial()` eine in Python geschriebene Beispielimplementierung wie `partial()` grob funktioniert. Wenn Du das nicht zu gebrauchen findest, dann liegt das vielleicht nicht an Dir sondern an noch fehlendem Verständnis wie Python funktioniert.

Probiere doch einmal aus:

Code: Alles auswählen

from functools import partial

def example_partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*(args + fargs), **newkeywords)
    newfunc.func = func
    newfunc.args = args
    newfunc.keywords = keywords
    return newfunc

global_name = "BlackJack"

test = partial(locals)
example_test = example_partial(locals)

class Testing:
    def __init__(self):
        local_name = "BlackJack"
        print(test())
        print("=================================================")
        print(example_test())

Testing()

Das echte partial zeigt local_name, die Beispiele zeigen global_name, sind also unbrauchbar.

Und was soll das, anderen mangelndes Verständnis unterstellen zu wollen, wenn es anscheinend am eigenen Verständnis der Sache fehlt

[BlackJack]

@Alfons Mittelmeyer: Das Beispiel ist nicht unbrauchbar, es zeigt wie man `partial()` selber implementieren kann. `example_partial()` verhält sich hier anders als als `functools.partial()`, aber bei `locals()` wäre ich sowieso keine Wette eingegangen was das als Ergebnis bringt, denn man weiss ja gar nicht wie das innen drin aussieht. Man könnte das ja noch ganz anders implementieren. Oder anders gesagt: Mir war auch schon vor dem ausführen von Deinem Beispiel klar das `locals()` nicht sinnvoll mit einer `partial()`-Implementierung nutzbar ist, weil das die lokalen Namen beim *Aufruf* liefert und nicht wie Du anscheinend gerne hättest, die lokalen Namen an der Stelle wo man die Funktion als Argument übergeben hat. So funktioniert Python nun mal nicht.

Ich bekomme übrigens *nicht* `globale_name` — bei keiner der beiden Varianten. Wäre wie gesagt auch das letzte was ich erwarten würde.

Bei `functools.partial()` liefert `locals()` die lokalen Namen von einer Aufrufebene höher weil es in C geschrieben ist, also selbst gar keine lokalen Namen hat, aus Python-Sicht. Daher der Unterschied zum `example_partial()`.

Ich verstehe was Da passiert. Und Du (noch) nicht. Das ist keine Unterstellung, sonst würdest Du ja nicht die Fragen stellen die Du gerade stellst.

[kbr]

Statt 25 Zeilen verquirltes Python zu schreiben hättest Du auch zweimal locals() in unterschiedlichen Kontexten aufrufen können, um das gleiche Resultat zu erzielen, das übrigens mit der Bescheibung der Dokumentation übereinstimmt.

[Alfons Mittelmeyer]

Ich verstehe was Da passiert. Und Du (noch) nicht. Das ist keine Unterstellung, sonst würdest Du ja nicht die Fragen stellen die Du gerade stellst.

Lass bitte Deine Unterstellung. Ich verstehe genau, was passiert. Das mit global_name war ein Versehen, weil ich zuerst anderes probiert hatte. Und dann nicht mehr genau geschaut hatte. Es sind natürlich die locals innerhalb newfunc.

Eine normale Python Funktion scheidet also schon einmal aus.

Was ich brauche sind die locals eine Stufe höher und wäre auf C-Ebene lösbar, das ist mir alles klar. Anscheinend kennst Du auch keine sonstige Python Funktion, mit der man auf python Ebene an die locals herankommt wie bei partial und welche die gewünsche Syntax erlaubt. Wenn ich Fragen stelle, dann in der Hoffnung, daß so ein Fachmann wie Du, vielleicht doch einen Python Kniff kennt, mit dem es zu machen wäre. Aber anscheinend ist das nicht der Fall.

Und vielleicht hast Du ja mittlerweile auch verstanden, daß es gerade darum geht, an die richtigen locals heranzukommen. Deinen Antworten habe ich entnommen, daß Du das bisher nicht kapiert hattest.

[noisefloor]

Hallo,

ich oute mich dann auch mal: nein, ich habe es nicht verstanden, das Ziel. Was mir auch völlig unklar ist, warum der Proxy auch TCP laufen soll, wenn es um die Manipulation der Frames eines GUI Designers geht. Zumal man ja auch bei Tkinter auf alle Elemente des Root-Windows zugreifen kann und die GUI ja immer lokal läuft.

Außerdem sind wir hier im Thread ja von einem KeyError über einen wie auch immer geachteten Proxy jetzt bei locals() sind. Mal sehen, wo es am Ende wirklich endet...

Also: ich bin raus. Aber ich mache mir in weiser Voraussicht schon mal etwas Popcorn *SCNR*

Gruß, noisefloor

[__deets__]

Was ich brauche sind die locals eine Stufe höher und wäre auf C-Ebene lösbar, das ist mir alles klar.

Du kennst noch nicht mal die Semantik von Python, aber die Interna des Interpreters sind dir so sonnenklar, dass du das da loesen kannst? Iss klar

Vielleicht kommt dir ja irgendwann mal der Gedanke, dass gegen die Sprache anzuprogrammieren keine so gute Idee ist. Sondern es besser waere, idiomatisch Python zu schreiben. Aber ich setze darauf sicher kein Geld

[Alfons Mittelmeyer]

Du kennst noch nicht mal die Semantik von Python, aber die Interna des Interpreters sind dir so sonnenklar, dass du das da loesen kannst? Iss klar

Mit beträchlichem Zeitaufwand könnte ich selbstverständlich eine Erweiterungsbibliothek in C schreiben, die das Problem lösen würde. Und dabei muß auch nicht alles sonnenklar sein, da bräuchte ich mir nur die Implementierung von functools und die von partial in C-Python anzusehen.

Aber das habe ich keineswegs vor. Ich habe auch nicht vor, gegen die Sprache anzuprogrammieren, deshalb hatte ich die Frage gestellt, ob jemand von Euch etwas kennt, womit es mit Python Mitteln lösbar wäre.

Wenn einige hier überfragt sind, ist das lange kein Grund sich aufzumandeln und jemanden der eine Frage gestellt hat, anscheinend niedermachen zu wollen.

[__deets__]

So ziemlich ALLES was du hier so an Code geliefert hast ist gegen die Sprache programmiert. Und nein, dieses Prädikat gilt auch dann, wenn man es irgendwie im bestehenden Interpreter hinkriegt, das es "funktioniert".

Code, der an seinem Ausführungsort annahmen darüber trifft, WO er ausgeführt wird, ist IMMER schlechter Code. Das gilt schon wenn man sich zB durch Datenstrukturen hangelt (siehe Demeter Law ), oder aus einem Widget hochwandest in seine Eltern ( wie von dir an anderer stelle propagiert), und erst recht, wenn man sich die stackframes betrachten möchte. Was übrigens durchaus geht (und es wissen die vermeintlichen Nixkönner hier auch allesamt wie. Frohes suchen).

Also wird hier nicht gemandelt - sondern einfach nur wiederholt festgestellt, das du leider vollkommen beratungsresistent bist.

[BlackJack]

@Alfons Mittelmeyer: Das ich das Ziel nicht verstanden habe, hatte ich ja bereits explizit geschrieben, schön das Du das meinen Antworten entnommen hast.

Das `functools.partial()` die `locals()` von einer Aufrufebene höher genommen werden ist ein Nebeneffekt der Implementierung. Das wird ja nicht explizit gemacht, sondern ergibt sich halt, rein dadurch das die Funktion in C implementiert ist. Im Grunde ist das ja auch gar nicht eine Aufrufebene höher, sondern die letzte Aufrufebene in der eine in Python implementierte Funktion aufgerufen wurde.

Wie man an die lokalen Namen des Aufrufers kommen könnte, wüsste ich schon, allerings ist das zu viel Magie für ein normales Programm und muss so auch nicht in jeder Python-Implementierung funktionieren. Und natürlich gibt es Probleme wenn man anfängt beteiligte Funktionen, also zum Beipiel den Aufrufer, in C zu implementieren, weil es dann vom Aufrufer gar keine lokalen Namen gäbe und man die vom Aufrufer davor bekäme. So etwas wäre alles andere als robust.

[Alfons Mittelmeyer]

@BlackJack: Danke für Deine Antwort. Ich hatte die Idee, ob ich mit wenig Aufwand aus meinem GuiDesigner Funktionsaufrufe auf Funktionen, die von globalen Variablen Gebrauch machen, herausbekomme und duch etwas anderes ersetzen kasnn, das genauso aussieht, aber keine globale Variable benützt. Der Aufwand wäre beträchtlich, bei send und do receive wären es wohl etwa 200 Zeilen und wenn man alles so haben möchten, währen es wohl ein paar Tausend Zeilen. Die Syntax wäre auch nicht erwünscht.

Also noch mal genau, es handelt sich hier nicht um eine Biblothek, die für sonstige allgemeine Aufgaben vorgesehen. Das Kommuniksationsmodul hat keine globalen Variablen, sondern nur das DynTkInter Modul, welches nur für eine einzige Instanz von tkinter.Tk vorgesehen ist und benutzt wird innerhalb von GuiApplication().mainloop()

Bisher wird der Proxy bei GuiApplication() also bei tkinter.Tk() für die Gui Application angelegt und für diese als globale Referenz gespeichert. Bei anderen Modulen, die nicht die Gui aufbauen, wird das nicht importiert.

Es ist auch nicht der Sinn self.communication.send zu schreiben, denn die Gui Schripte sollen nicht interna der Implementierung widerspiegeln, sondern die Mittel des Befehlssatzes gebrauchen. Es wähe auch nicht der Sinn, in Python so etwas schreiben zu müssen, wie statt if schreibe man:

self.python.statements.simple_statements.if

So etwas ginge sicher gegen die Sprache und gegen die Sprache von DynTkInter GUI Skripten geht self.communication.send

Wer den Proxy benutzen will, kann sich ja einen eigenen erzeugen und es so tun. Normalerweise benutzt sowieso keiner DynTkInter, aber mein GuiDesigner braucht die erweiterte Funktionalität der Widget Klassen. Ich sollte wohl besser noch das Exportieren von Menüs im tkinter Stil fertigstellen, die Behandlung von Photoimages im tkinter Stil und Gridtabellen mit rowconfigure und columnconfigure im tkInterstil. Dann wrd eine DynTkExtend Bibliothek hinfällig und eine abgeleitete Menüklasse braucht man dann nur, wenn man in Menüs für command Buttons, cascaden usw. Namen mit angeben will, damit die dann vor dem tkinter Aufruf wieder entfernt werden.