Live-Code Interpreter

[Crazed]

Inspiriert durch einen Blog auf den ich irgendwann gestoßen bin wollte ich folgendes auch mal ausprobieren:

Sequencer.py:

Code: Alles auswählen

#!/usr/bin/python

import time

class Sequencer(object):
    def __init__(self, delay):
        failed = True
        
        while failed:
            try:
                import DynamicCode
            except:
                pass
            else:
                failed = False
        
        while True:
            time.sleep(delay)
            try:
                reload(DynamicCode)
            except:                
                pass

LiveCode.py:

Code: Alles auswählen

#!/usr/bin/python

import Sequencer

Sequencer.Sequencer(1)

DynamicCode.py:

Code: Alles auswählen

#!/usr/bin/python

print 'Das hier wird dynamisch interpretiert'

Ist (bestimmt) verdammt uneffektiv und dumm gemacht aber es funktioniert. Sollte der dynamische Code einen Fehler verursachen wird solange einfach gepassed. Ich suche momentan noch eine Möglichkeit die letzte funktionierende DynamicCode.py irgendwie im Speicher zu behalten und falls das aktuelle DynamicCode.py einen Fehler wirft die DynamicCode.py die im Speicher liegt auszuführen.

Mir ist bis jetzt aber noch nichts richtiges eingefallen.

Hat jemand eine Idee?

MfG,
CracKPod

[BlackJack]

Warum ist das eine Klasse und keine einfache Funktion? Den Namen vom Modul würde ich als Argument übergeben. Und wenn man die erste Schleife in eine "Endlosschleife" umwandelt, die im Erfolgsfall durch ``break`` verlassen wird, kann man sich `failed` sparen.

[Crazed]

Also erstens:

Mach mal schnell nen Screenshot von deinem Poststand (6666) ^^.

2. Weil ich OOP der prozedualen Programmierung vorziehe, selbst wenn es, wie in diesem Falle sinnlos ist.

3. Stimmt ich dachte so wäre es eventuell eleganter.

4. Hast du ne Idee wie ich die alte funktionierende Funktion auslagern kann?

5. WIe soll ich das als Argument übergeben? Ich kann ja nicht einfach:

import variable schreiben. Dann sucht er nach variable.py...

[DasIch]

2. Weil ich OOP der prozedualen Programmierung vorziehe, selbst wenn es, wie in diesem Falle sinnlos ist.

OOP heisst Objekt Orientierte Programmierung und nicht Klassen Orientierte Programmierung oder täusche ich mich da?

[audax]

Code: Alles auswählen

import time

def sequence_load(module, delay):
        mod = []
        while True:
            try:
                mod.append(__import__(module))
            except:
                pass
            else:
                try:
                    reload(mod[0])
                except:
                    continue

        time.sleep(delay)

sequence_load(__file__, 1)

/me wantz nonlocal

[BlackJack]

@Crazed: Zu spät, Anzahl der Posting war schon bei 6667, als ich Deinen Beitrag gelesen hatte.

Das ist aber kein OOP wenn man einfach sinnlos alles in Klassen stopft. Diesen Irrglauben scheint Java ziemlich verbreitet zu haben. OOP ist, wenn man ein Programm aus Objekten zusammen setzt, die miteinander kommunizieren. In Python ist alles Objekt, auch Funktionen, dass heisst, wenn Du eine Funktion aufrufst, dann hast Du schon ein wenig OOP, und zwar genau so viel, wie hier *nötig* ist. Warum also das ganze künstlich mit einer Klasse verkomplizieren? Prozedural programmierst Du trotzdem, denn das sind die ``while``-Schleifen.

Schau Dir mal die `__import__()`-Funktion an.

[sma]

Crazed, wenn du nicht direkt das Modul lädst bzw. neu lädst, sondern `compile` benutzt, um eine manuell geladene .py-Datei in ein Code-Objekt zu verwandeln, kannst du dieses dann entweder direkt mit `exec` ausführen oder aber in ein Modul verwandeln. Sollte das `compile` fehlschlagen, hast du immer noch die ältere Version im Speicher.

Stefan