Kommando wiederholen

[Gast]

Klingt ziemlich einfach, darum suche ich auch nach einer möglicht einfachen Lösung.

Möchte mein Kommando immer in gewissen Abständen wiederholen, also z.B.
print "my commando"
soll alle 10 Minuten selbstständig wiederholt werden.

Danke!

[Leonidas]

Du baust dir einen kleinen Timer, der alle 10*60 Sekunden einen Befehl per subprocess ausführt. Kein Problem. Zeig mal deinen Code, wie weit du bist.

[gerold]

Möchte mein Kommando immer in gewissen Abständen wiederholen, also z.B. print "my commando" soll alle 10 Minuten selbstständig wiederholt werden.

Hi!

Mit "sleep" vom "time"-Modul kannst du dein Programm eine kurze Zeit warten lassen.

Code: Alles auswählen

import time

for i in range(10):
    print "Hallo"
    time.sleep(2)

Allerdings wartet dabei dein Programm komplett. Es reagiert in dieser Zeit auf nichts. Wenn du mehr haben willst, dann musst du mit Threads arbeiten oder wie schon von Leonidas aufgezeigt, einen anderen Prozess starten, der deine Aktionen durchführt.

mfg
Gerold

[Damaskus]

Hi,
ungefähr so:

Code: Alles auswählen

import gobject
import popen2
import subprocess

startbefehl = "myprog.exe"
frequenz = 10 * 60000
gobject.timeout_add(frequenz, subprocess.Popen(startbefehl))

[Leonidas]

Hallo Damaskus!

Dein Programm ist zwar ganz nett, nur ist popen2 darin unnötig und gobject wird nicht jeder haben, da gobject ein Modul von PyGTK ist (allerdings habe ich mir auch bei der Frage des OP gedacht, dass das ein Fall für timeout_add() wäre )

[Damaskus]

Stimmt...
War halt auf die schnelle aus nem anderen Script rauskopiert.

[mitsuhiko]

help(sched)

[gerold]

help(sched)

Hi blackbird!

Nicht schlecht dieses "sched". Super Hinweis! Das kannte ich noch nicht oder ist mir zumindest beim Überfliegen der Module noch nie aufgefallen.

http://docs.python.org/lib/module-sched.html

lg
Gerold

[Gast]

Also das ist das was ich bis jetzt habe:

Code: Alles auswählen

import sched, time
import thread

s=sched.scheduler(time.time, time.sleep)

def print_time(): print "3 seconds"

def print_some_times():   
    s.enter(3, 1, print_time, ())
    s.run()
       
i= 0
while i == 0:
    thread.start_new(print_some_times, ())
    time.sleep(3)

print "goes along"

Bis zum print "goes along" komm ich aber nicht.
Muss jetzt den thread im Hinterground laufen lassen, oder?

[mr.hide]

Ganz klar das du nicht bis zum goes along kommst.


Das liegt an der while schleife!
Die termininiert nicht, d.h. nirgends wird das i auf != 0 gesetzt!

[gerold]

Code: Alles auswählen

import sched, time

sch=sched.scheduler(time.time, time.sleep)

def print_time(suff): 
    print time.time(), suff
    
sch.enter(3, 1, print_time, ("Start nach 3 sec.",))
sch.enter(6, 1, print_time, ("Start nach 6 sec.",))
sch.run()

print "Ende"

[Gast]

Ganz klar das du nicht bis zum goes along kommst.


Das liegt an der while schleife!
Die termininiert nicht, d.h. nirgends wird das i auf != 0 gesetzt!

Das stimmt schon, aber ich möchte ja auch, dass mein Thread solange weiterläuft, bis mein Programm beendet wird. Ich müsste also meine while-Schleife irgendwie als Hintergrundprozess laufen lassen.

[gerold]

Code: Alles auswählen

import time
import thread
import threading


def print_time(suff, e):
    for i in range(5):
        print time.time(), suff
        time.sleep(2)
    e.set()

e1 = threading.Event()
e2 = threading.Event()
e1.clear()
e2.clear()

time.sleep(3)
thread.start_new(print_time, ("Start nach 3 sec.", e1))
time.sleep(3)
thread.start_new(print_time, ("Start nach 6 sec.", e2))

print "Warte auf Event 1"
e1.wait()
print "Warte auf Event 2"
e2.wait()

print "Ende" 

[gerold]

aber ich möchte ja auch, dass mein Thread solange weiterläuft, bis mein Programm beendet wird. Ich müsste also meine while-Schleife irgendwie als Hintergrundprozess laufen lassen.

Code: Alles auswählen

import time
import thread
import threading

def print_time(abbruch_event):
    while True:
        print time.time()
        time.sleep(1)
        if abbruch_event.isSet():
            break

abbruch_event = threading.Event()
thread.start_new(print_time, (abbruch_event,))
time.sleep(10)
abbruch_event.set()

print "Ende" 

[Gast]

also das klappt schon mal ganz gut so, danke schonmal.

Mein Hauptproblem ist aber immernoch, dass ich den Thread nicht im Hintergrund laufen lassen kann. Also ich möchte, dass print "Ende" erreicht wird und mein thread trotzdem noch weiterläuft.

Also ich möchte meinen Thread im kompletten Programm im Hintergrund ständig laufen lassen und gleichzeitig den Rest des Programms ungestört weiterlaufen lassen.

Meine Ausgabe soll also in deinem Beispiel ungefähr so aussehen:

1136818813.88 Start nach 3 sec.
1136818815.88 Start nach 3 sec.
Warte auf Event 1
1136818816.88 Start nach 6 sec.
1136818817.88 Start nach 3 sec.
1136818818.88 Start nach 6 sec.
Ende
1136818819.88 Start nach 3 sec.
1136818820.88 Start nach 6 sec.
1136818821.88 Start nach 3 sec.
1136818822.88 Start nach 6 sec.
Warte auf Event 2
1136818824.88 Start nach 6 sec.
...
...

[mr.hide]

z.B.: so?

Code: Alles auswählen

import threading
import time


class OwnThread(threading.Thread):
   
    def __init__(self):
        threading.Thread.__init__(self)
        print "Ich bin ein eigener Prozess"

    def run(self):
        while not abbruch_event.isSet():
            print "laufe noch"
            time.sleep(2)
           


abbruch_event = threading.Event()

t = OwnThread()
t.start()

print "Ich bin schon fertig, warte noch und schliesse dann den Thread"

time.sleep(4)
abbruch_event.set()

- Natürlich kanns du die beiden letzten Zeilen auskommentieren, aber dann hast du ne Endlosschleife

Geht natürlich auch noch anders.
Aber hiermit erschaffst du eine Klasse die als neuer Prozess läuft.
Dadurch terminiert sie nicht wenn das Programm das Sie startet zu Ende ist. Ausser du setzt es als Deamon.

[Gast]

Wow, danke!

Ist genau das, was ich wollte!

[Gast]

Ach ja, so sieht jetzt übrigens mein Programmteil aus, falls es jemanden interessiert:

Code: Alles auswählen

import threading
import time

class MyRegularThread(threading.Thread):
	def __init__(self):
		threading.Thread.__init__(self)			
		
	def run(self):
		sleep_time = 60  
		i = 1
		while i == 1:   
			print "does anything"
			time.sleep(sleep_time)
			
t = MyRegularThread()
t.start()	

[BlackJack]

Das `i` kannst'e weglassen und ``while True:`` stattdessen schreiben.

[Gast]

Jo, habs jetzt noch ein bisschen verändert und erweitert - klappt wunderbar!

Danke für eure Hilfe!

Code: Alles auswählen

import threading
import time

class MyRegularThread(threading.Thread):
	def __init__(self):
		threading.Thread.__init__(self)           
		global abbruch_event
		abbruch_event = threading.Event()
	def run(self):
		sleep_time = 2 
		while not abbruch_event.isSet():  
			print "does anything"
			time.sleep(sleep_time)
	def close(self):
		abbruch_event.set()



class MyMainProgram:
	def begin_MyRegularThread(self):
		t = MyRegularThread()
		t.start()   
	def close_MyRegularThread(self):
		t = MyRegularThread()
		t.close()
	def somethingElse(self):
		print "does something else"
		
do = MyMainProgram()
do.begin_MyRegularThread()
do.somethingElse()

time.sleep(10)

do.close_MyRegularThread()