Funktionen in Logiken

[Cannon]

Ich habe versucht in einer Logik eine Funktion zu schreiben. Das heißt, wie man das so in Python macht:

def Funktion(param1, param2):

Ich kann die aber nicht aufrufen, weil die nicht gefunden wurde. Geht das überhaupt in Logiken?

[Msinn]

Klar kann man Funktionen in Logiken aufrufen, mache ich ständig. Was jedoch nicht so einfach geht, ist Funktionen aus andern Funktionen in der Logik aufzurufen. Das liegt daran, dass der Kontext der Logik nicht dem globalen Kontext eines Python Programmes entspricht. Die Funktionen sind lokal zum Lauf der Logik.

Zu dem Thema gibt es hier schon mindestens einen Thread im Forum. Da musst Du mal die Suche bemühen.

[Onkelandy]

Guckst du hier: https://knx-user-forum.de/forum/supp...ionen-benutzen
Wär vielleicht mal was für die Doku..

[Cannon]

Danke den Thread habe ich gefunden. Also prinzipiell geht es wohl. :-)

Allerdings muss man wohl beachten, dass die Funktion im Code vor dem Aufruf "definiert" werden muss, sonst wird die nicht gefunden. Ich weiß nicht, ob das eine Eigenart von Python ist oder ob das hier bei SmartHomeNG so sein muss.

[Msinn]

Das ist eine "Eigenart" von Python.

[Tom Bombadil]

Das ist eine "Eigenart" von Python.

... von Python und von sämtlichen 'klassischen' Programmiersprachen.

/tom

[Cannon]

sämtlichen 'klassischen' Programmiersprachen

Dem widerspreche ich mal einfach. Weder bei BASIC, Pascal, C, C++, C# ist das notwendig. Und die bezeichne ich mal als klassische Programmiersprachen.

Das ist eine "Eigenart" von Python.

Danke. :-)

Was ich aber auch irgendwie nicht richtig gefunden habe, auch nicht im anderen Thread, wie kann ich items in der Funktion übergeben und diese daann darin auch verwenden?

def Funktion(myItem):
    myItem.timer(60, 10)

Aufruf mit:

Funktion(sh.Licht.schalten)

geht so nicht oder?

[Msinn]

Dem widerspreche ich mal einfach.

Da muss ich Dir widersprechen. Ich hatte 'Eigenart' bewusst in Anführungsstriche gesetzt, da die Definition vor Nutzung für viele Programmiersprachen gilt. Ganz besonders für Interpreter-Sprachen wie BASIC. Das schließt nicht aus, dass es Implementationen dieser Sprachen gibt, die diese Einschränkung nicht haben. Das sind dann aber keine Interpreter-Inplementationen sondern Compiler mit anschließendem Linker.

Andererseits gilt diese Beschränkung auch für Compiler Sprachen wie Delphi-Pascal:

Routinen werden wie die globalen Typen, Konstanten und Variablen im Deklarationsblock oberhalb des begin vom Hauptprogramm deklariert. Die Routinen können sich auch untereinander aufrufen. Dabei gilt die Lesereihenfolge von oben nach unten: alle oben genannten Routinen sind denen darunter bekannt und können von diesen aufgerufen werden.

[mumpf]

Hi,

C, C++,

auch in C, C++ kannst Du nur bereits definierte Funktionen aufrufen. Das fällt da nur nicht auf, weil normalerweise alle Funktionen als forward deklarationen in den Header-Files stecken und diese gleich zu Anfang inkludiert werden.

Gruß, Waldemar

[Tom Bombadil]

Jupp, insbesondere bei Compiler-Sprachen wie Turbo Pascal / Delphi, Borland C, Basic etc. Wer einmal ein größeres Projekt in damaligen Zeiten auf den Kopf stellen musste, kennt das Gefluche.

Ich habe wahrlich keinen Komplettüberblick, aber die Unsitte, Funktionen / Prozeduren auch erst nach Gebrauch definieren zu können, scheint mir eine 'Unsitte' von modernen Interpretern zu sein ...

/tom

[bmx]

Die im Prinzip einfachste Lösung ist es selbst ein Plugin für den Eigengebraucht zu schreiben und die benötigten Funktionen dort unterzubringen. Das war auch mal ursprünglich 2013 der Rat von callidomus als ich die gleiche Problematik hatte. Allerdings ist bisher nix so kompliziert gewesen, das ich unbedingt ein Plugin hätte selber schreiben müssen.
Du kannst natürlich ein Plugin bauen, das aus einem bestimmten Verzeichnis alle *.py Dateien einliest und im Namensraum eines Plugins zur Verfügung stellt. Das wäre dann mal was für die Allgemeinheit :-)

[Cannon]

auch in C, C++ kannst Du nur bereits definierte Funktionen aufrufen. Das fällt da nur nicht auf, weil normalerweise alle Funktionen als forward deklarationen in den Header-Files stecken und diese gleich zu Anfang inkludiert werden.

Das gilt aber nur für Funktionen, die du außerhalb der eigenen "Datei" aufrufen willst. Für Funktionen innerhalb eine Code-Datei braucht man das nicht.

Ich habe wahrlich keinen Komplettüberblick, aber die Unsitte, Funktionen / Prozeduren auch erst nach Gebrauch definieren zu können, scheint mir eine 'Unsitte' von modernen Interpretern zu sein ...

Was heißt "Unsitte"? Es ist nur eine Frage der Form. In den meisten Hochsprachen definiert man die Funktionen ja sowieso strukturiert in einer eigenen Datei. Bei kurzen Codezeilen ist es eher eine Frage des persönlichen Geschmacks. Und ich packe die Funktionen lieber ans Ende, weil ich die weniger oft anfasse als den eigentlichen "Programm"-Code. Wobei das sowieso sehr abstrakt ist, weil wenn man über C++ / C# redet ist sowieso fast jede Funktion woanders definiert.

Wobei mir das auch nicht ganz klare ist in Python. Hier mal ein Auszug aus einem plugin:

    # Initialize connection
    def __init__(self, smarthome, host, port=502, cycle=50):
        self.logger = logging.getLogger(__name__)
        self._host = host
        self._port = int(port)
        self._sh = smarthome
        self._cycle = int(cycle)
        self._lock = threading.Lock()
        self._is_connected = False
        self._items = {}
        self.connect()
        # pydevd.settrace("10.20.0.125")

    def connect(self):
        start_time = time.time()
        if self._is_connected:
            return True
        self._lock.acquire()
        try:
            self.logger.info("Pluggit: connecting to {0}:{1}".format(self._host, self._port))
            self._Pluggit = ModbusTcpClient(self._host, self._port)
        except Exception as e:
            self.logger.error("Pluggit: could not connect to {0}:{1}: {2}".format(self._host, self._port, e))
            return
        finally:
            self._lock.release()
        self.logger.info("Pluggit: connected to {0}:{1}".format(self._host, self._port))
        self._is_connected = True
        end_time = time.time()
        self.logger.debug("Pluggit: connection took {0} seconds".format(end_time - start_time))

Wenn ich mir das "connect" so ansehe, wird das erst nach der aufzurufenden Zeile definiert und das verstehe ich dann doch nicht.

Du kannst natürlich ein Plugin bauen, das aus einem bestimmten Verzeichnis alle *.py Dateien einliest und im Namensraum eines Plugins zur Verfügung stellt. Das wäre dann mal was für die Allgemeinheit :-)

Das ist eine gute Idee. Macht aber nur Sinn, wenn es Funktionen sind, die man immer mal wieder brauchen würde. Bei mir geht es explizit um eine Bewässerungssteuerung und die macht für globale Funktionen wenig Sinn. Ich werde die aber dennoch zur Verfügung stellen, wenn es so läuft, wie ich mir das gern vorstelle. Die Funktion aber deshalb, damit ich nicht für jeden Sprinklerkreis die kompletten Konditionen prüfen muss und dafür jedes mal den gleichen Code habe.