Code: Alles auswählen
import name_des_funktionsskriptes
Code: Alles auswählen
class Events:
def __init__(self, name):
self.name = name
def __call__(self, x = None):
if (x == None):
print "Aufruf ohne Parameteruebergabe"
else:
print "Aufruf mit Parameteruebergabe "
def connect()
...
for event in events:
exec event + " = Events("+ `event` +")"
...
Code: Alles auswählen
import functions
connect()
...
# und hier möchte ich nun gerne den Objektaufruf machen
huepfe_hoch()
...
Code: Alles auswählen
import functions.py
events = connect()
for event in events:
exec event + " = Events("+ `event` +")"
...
huepfe_hoch()
...
Das 'huepfe_hoch' ist die Instanz, die eigentlich in der Funktion 'connect()' erzeugt werden soll. Aber dann habe ich keinen Zugriff auf diese Instanz.cofi hat geschrieben:Woher kommt das `huepfe_hoch`?
Ok soweit so gut. Aber welche Konsequenz ergibt sich aus dieser Schlußfolgerung für mich? Oder anders gefragt, wie bekomme ich die dahin?Aber ich glaube ich erahne was das Problem ist: Die Objekte werden nicht in den globalen Namensraum des aktuellen Moduls kopiert.
Ich stehe gerade auf der Leitung. Du meinst was?Du solltest dir auch abgewoehnen, dass Funktionen auf globale Namen zugreifen, und ihnen stattdessen die Objekte als Argument uebergeben.
Wie wäre es denn besser? Ohne funktioniert es scheinbar nicht.
1. Backticks um `repr` auf ein Objekt aufzurufen sind deprecated.
Code: Alles auswählen
`foo` == repr(foo)Code: Alles auswählen
#!/usr/bin/python
# Importiere die Funktionen
from dobject_functions import *
# Rufe als erstes Schritt die Init-Funktion aus dobject_functions.py auf
init()
# Rufe das in init() erzeugte Objekte huepf_hoch() auf -> Das Ergebnis sollte die Ausgabe "Aufruf mit Parameter" sein, was aber nicht funktioniert.
huepf_hoch(1)
# Zum Schluss die close-Funktion aus dobject_functions.py
close()
Code: Alles auswählen
#!/usr/bin/python
# Die Klasse dobject
class dobject:
def __init__(self, name):
self.name = name
def __call__(self, x = None):
if x == None:
print "Aufruf ohne Parameter"
else:
print "Aufruf mit Parameter"
# Funktion zur initialisierung, hier werden aus den Werten der Liste obj_names gleichnamige Objekte der Klasse dobject erzeugt
def init():
obj_names = ["huepf_hoch", "huepf_runter", "irgendwas_beliebiges"]
for obj_name in obj_names:
exec obj_name + " = dobject(" + repr(obj_name) + ")"
print " ... initialised ..."
return 1
# dummy Funktion
def close():
print " ... closed ..."
return 1
Ok, das ist eine interessante Aussage.BlackJack hat geschrieben:@[LC]: ``from modulname import *`` importiert das Modul und bindet die Objekte, die nach dem Importieren in dem Modul existieren, auch im importierenden Modul an die gleichen Namen. Deine Exemplare existieren zu dem Zeitpunkt halt noch nicht.
Das ist aber gerade die Idee dahinter, weil ich zur Laufzeit des Skriptes erst die wesentlichen Dinge zusammensetzen kann. Genau genommen werden die obj_namen, anders als in dem Beispiel mittels TCP/IP abgefragt. Erst wenn ich die habe, kann ich die Objekte daraus erzeugen. Jedes Objekt für sich stellt dann augenscheinlich nichts anderes als ein Befehl dar, der bei Aufruf mit seinem Argument über das Netzwerk in eine andere Applikation getunnelt wird. Was ich von Python nutzen möchte ist, dass ein Nutzer sich mit diesen (dynamischen) Befehlen und mittels der einfach Python-Syntax für Schleifen und Kontrollstrukturen einfache Skripte schreiben kann, die einen Ausführungsfluss in der anderen Applikation widerspiegeln. Wie die Kommunikation zwischen Python und der anderen Applikation aussieht braucht er gar nicht zu wissen, denn das soll alles in der dobject_function.py umgesetzt sein. Ich könnte auch einen anderen Weg beschreiten und jeden Befehl als Funktion hardcodiert umsetzen. Inhaltlich wären alle Funktionen identischen, nur eben mit einen anderen Namen versehen.Aber sowohl Dein Wunsch, dass das so funktioniert, als auch die Verwendung von ``exec`` halte ich für ziemlich "unpythonisch". Das ``exec`` würde ich auf jeden Fall loswerden. Quelltext zur Laufzeit zusammen zu bauen ist unsauber.
Ja dein Eindruck geht in die richtige Richtung. Ich möchte weniger in Python explizit programmieren, vielmehr möchte ich mit Python scripten.Zusammen mit den komischen ``return 1`` am Ende der Funktionen habe ich den Eindruck Du möchtest nicht in Python programmieren, sondern versuchst die Semantik einer anderen Programmiersprache irgendwie in Python-Syntax quetschen zu wollen.
Da gibt es keinen Unterschied. Was nützt dir irgend ein unsauberes und unwartbares Stück Code, welches eine Sprache nicht richtig verwendet und voller "Unarten" anderer Sprachen steckt? Dann kannst du Python auch ganz sein lassen und die entsprechende Sprache nutzen.[LC] hat geschrieben:Ja dein Eindruck geht in die richtige Richtung. Ich möchte weniger in Python explizit programmieren, vielmehr möchte ich mit Python scripten.
Ich habe nur die Idee beschrieben, nicht wie es letztlich aussieht. Und ja, stimme dir vollkommen zu, was auch explizit und sogar 2x passiert. Exec brauche ich eigentlich nur, um aus einer Liste von Namen zur Laufzeit Synonyme zu generieren, die bei ihrem Aufruf immer dieselbe Routine enthalten. Mehr eigentlich nicht. Dabei verwende ich absolut keinerlei Semantik von einer anderen Programmiersprache. Ich habe mein eigenes Datenprotokoll, packe das was ich dann brauche dahingehend explizit zusammen. Ich will nur einen Möglichkeit schaffen, dem Nutzer eine einfach Semantik zur Verfügung zu stellen.EyDu hat geschrieben:Hallo.
Genau in so einem Fall sollten die Daten selber geparst und verarbeitet werden.
Schon richtig Sebastian.Da gibt es keinen Unterschied. Was nützt dir irgend ein unsauberes und unwartbares Stück Code, welches eine Sprache nicht richtig verwendet und voller "Unarten" anderer Sprachen steckt? Dann kannst du Python auch ganz sein lassen und die entsprechende Sprache nutzen.
Wenn ich das richtig überblicke, verliere ich dann aber die Möglichkeit ein Argument zu übergeben, oder?cofi hat geschrieben:Schau dir Dictionaries an. Damit wirst du sowohl `exec` als auch das Problem mit dem Objekten los.
Code: Alles auswählen
from functools import partial
class RemoteCaller(object):
def __init__(self):
method_names = ['huepf_hoch', 'huepf_runter', 'irgendwas_beliebiges']
for method_name in method_names:
setattr(self, method_name, partial(self._remote_call, method_name))
def _remote_call(self, method_name, argument=None):
print ('Aufruf von %s %s Parameter'
% (method_name, 'ohne' if argument is None else 'mit'))
def main():
caller = RemoteCaller()
caller.huepf_hoch()
caller.huepf_runter(42)
if __name__ == '__main__':
main()