Instanzen einer Klasse geordnet ausführen

[ivka_sto]

Hallo zusammen,

Ich arbeite gerade an einem Programm, das in Schritten verläuft, wobei jeder Schritt Instanz einer Klasse ist [step1 = Schritt()]. In jedem Schritt werden bestimmte Methoden ausgeführt, die die Klasse Schritt von Oberklassen erbt, und es wird ausgewertet, ob Fehler aufgetreten ist.

Jetzt will ich für das Hauptprogramm (also das Durchlaufen der Steps) so machen, daß solange kein Fehler aufgetreten ist, man die Steps nacheinander ausführt. Ich habe keine genaue Vortellung wie ich das am besten machen sollte, aber dachte an so etwas wie:

Code: Alles auswählen

i = 1
while (error = False) and (i < 5):
	Liste[i] # soll man das mit call abrufen?
	i += 1
print 'fertig'

Allerdings hab ich keine Ahnung ob man die steps1-5 dann mit call ausführen könnte/sollte. Außerdem kommt mir das nicht so .. schön vor. Ich habe mir auch überlegt, mir die steps mit __repr__ anzeigen zu lassen, den Index um 1 zu erhöhen, und dann auszuführen. Weiß aber auch nicht wie ich die von Strings wieder in abrufbare Obj. umwandeln kann.

Kritik und Anregungen nehm ich gern entgegen

VG, ivka_sto

[numerix]

Auf jeden Fall fällt mir auf, dass Zeile 2 so nicht funktioniert und so wie du sie gemeint hast, auch nicht schön ist.
Besser so:

Code: Alles auswählen

while i<5 and not error:

oder (je nach Geschmack):

Code: Alles auswählen

for i in xrange(5):
    # machwas
    if error:
        break

[ivka_sto]

Ah, das ist schonmal 'n Anfang Danke

[ivka_sto]

Hallo zusammen Ich versuch's nochmal mit der Frage.

Mein Programm definiert Methoden in 2 Klassen, die Klasse Run und die Klasse Check. Ihre gemeinsame Unterklasse Step definiert das Verhalten bei den Schritten, in denen das Programm ausgeführt wird. Und dann wollt ich die Steps als Instanzen von der Klasse Step abrufen, aber da es mir zu unübersichtlich schien, hab ich mich für eine andere Lösung entschieden (mit der ich leider auch nicht 100% zufrieden bin), und nämlich die Schritten als Unterklassen von Step zu machen:

Code: Alles auswählen

class Check:
    def check_meth():
        # checkt ob alle nötigen Files schon da sind
class Run:
    def run_meth():
        # kontrolliert irgendwas während das Programm läuft
class Step(Check, Run):
    def print_msg(num):
        print 'das Prgramm ist gerade bei %d' %num
    def own_meth1():
        pass
        # gib jedem Step die Möglichkeit seine nötigen Methoden wie gebraucht zu grupieren
    def own_meth2():
        pass
        # genauso
        
class Schritt1(Step):
    def own_meth1():
        if data_file.isfile():
            pass
        else:
            print 'data_file existiert nicht'
    def own_meth2():
        os.getcwd # mehr passiert im ersten Schritt nicht

class Schritt2(Step):
    def own_meth1():
        Check.check_meth()
    def own_meth2():
        Run.run_meth()

# usw usf noch viele Schritte, die ihre Funktion in diesen 2 own_meths() zusammenfassen

for klass in Schritt_Liste: 
# gibt es übrigens einen eingebauten Befehl zum Aufruf aller Unterklassen einer Klasse?
    Step.print_msg(repr(klass))
    klass.own_meth1()
    klass.own_meth2()
    if Step.error:
        break

Wie findet ihr die Lösung? Wie gesagt, ich wollte die Schritte als Instanzen von der Klasse Step aufrufen, aber ich könnte dann keine speziellen Methoden definieren und wüßte nicht wie ich das umgehen könnte. Und andererseits sind es ganz viele Schritte, die ich hab .. also es kommt mir wie ein Mißbrauch des Begriffs der Klasse vor ("oh, toll, 'Klasse' .. ich mach mir sofort Tausend von denen")

Bitte viel Kritik

VG, ivka_sto

[audax]

Ich verstehe ehrlich gesagt den Sinn dahinter nicht.

Klassen nur um der Klassen willen?

[ivka_sto]

Naja .. zumindest teilweise. Ich habe den Code nur schematisch dargestellt, um das Lesen zu erleichtern. Es sind viele Methoden für jeden einzelnen Schritt nötig, und der Code wäre in Durchlaufform sehr unübersichtlich.

[audax]

Und warum nicht in ordentlich benannte Funktionen? Oo

Ich verstehe nicht ganz, warum es unbedingt Methoden sein müssen...

[ivka_sto]

Weil es viele Funktionen wären, die dann auch noch sehr oft aufgerufen werden müßten auf verschiedenen Gruppen von Files. Es wäre unübersichtlich, da man dann keine so klare Abgrenzung zwischen den Schritten hätte. Also Klassen, um die Methoden nach ihrer Bedeutung zu sortieren und Zusammenhänge innerhalb des Programms besser zu veranschaulichen.

[audax]

Öhm...na gut, wie du meinst.

Wenn du meinst, prozeduralen Code in Klassen packen zu müssen, dann kann ich dich davon wohl nicht abhalten.

[sma]

Ich verstehe dich so:

Code: Alles auswählen

class State:
  def __init__(self): self.stack = []

  def push(self, v): self.stack.append(v)

  def pop(self): self.stack.pop()

  def run(state):
    for instruction in program:
      instruction.step(state)

class Lit:
  def __init__(self, v): self.v = v

  def step(self, state): state.push(self.v)

class Add:
  def step(self, state): state.push(state.pop() + state.pop())

class Print:
  def step(self, state): print state.pop()

program = [Lit(3), Lit(4), Add(), Print()]
State().run(program)

Stefan