[python] Vlastní vlákno pro dlouhý výpočet.

[Jakub Vojacek]

Ahoj

 

CHtěl radu ohledně vláken. Dělám na programu, kde chci dát uživateli možnost přeuršit výpočet, protože občas by to trvá fakt dlouho. Ale jak to naprogramovat. Hledal jsem inspiraci v http://wiki.wxpython.org/index.cgi/LongRunningTasks ale nepomohlo to.
Potřeboval bych aby to vlákno přijalo funkci, kterou musí počítat a když by se to dopočítalo tak aby vrátila data
Vlastně by to fungovalo tímto způsobem:

 

vysledek=Vlakno(moje_funkce_s_parametry)
if vysledek != None:#uživatel přeušil výpočet
    zpracuj_vysledek()

 

Děkuji za všechny nápady

 

Blujacker

[Tomáš Brabenec]

A co to počítání rozdělit na několik částí (pokud je to možné), přičemž
po dokončení jedné části by se zavolala funkce na zjištění, jestli
uživatel nepřerušil výpočet a po té teprve by se pokračovalo ve výpočtech.
Dočasné výsledky by se ukládaly někam stranou a pokud by uživatel
počítání přerušil, prostě by se dočasné výsledky "zahodily".

Tomas

Jakub Vojacek napsal(a):

> ------------------------------------------------------------------------
>
> _______________________________________________
> Python mailing list
> Pyt...@py.cz
> http://www.py.cz/mailman/listinfo/python

[RMi...@pss.sk]

Skoda, ze si tu blizsie nespecifikoval charakter funkcie, ktora trva
prilis dlho.
Napadlo ma , ze ak sa jedna o nejaky iterativny numericky vypocet, mozes
rovno do funkcie zamontovat, ze sa prerusi po urcitom maximalnom pocte
iteracii.
Ako trivialny priklad tu pouzijem strojove epsilon tzv. macheps, t.j. take
cislo, ze: macheps + n = n
Funkcii odovzdam na zaciatku 2 argumenty: startovaciu hodnotu a maximalny
vypocet iteracii.
Ak sa presiahne maximalny pocet iteracii funkcia hodi vynimku, ktoru mozes
dalej spracovat bez threadu, alebo aj s pouzitim threadu:
----------------------------------------------------------
import exceptions
from threading import Thread

# Vynimka
class TooMuchIter(exceptions.Exception):
def __init__(self, args=None):
self.args = args

# Wrapper pre class Thread
class MyThread(Thread):
def __init__(self,myfunc,*arg):
Thread.__init__(self)
self.func=myfunc
self.arg=arg
def run(self):
try:
vysledok_funkcie=self.func
print "MachEps = %1.20e" % self.func(*self.arg)
except TooMuchIter,e:
print "Vypocet predcasne ukonceny: %s" % e

# spustenie funkcie
def run_function(func, *arg):
try:
print "Vysledok = %1.20e" % func(*arg)
except TooMuchIter,e:
print "Vypocet predcasne ukonceny: %s" % e

# funkcia, ktora sa bude pocitat
def macheps(x, max_iter):
# vypocet strojovej nuly
eps=x
j = 0
while (eps+1)>1:
eps=eps/2
j += 1
print "krok %2d: %1.20e" % (j,eps)
if j > max_iter:
raise TooMuchIter, "Viac ako %d iteracii !!!" % max_iter
# return
return(eps)

if __name__ == '__main__':
### bez pouzitia threadov
# funkcia sa predcasne ukonci kvoli vela iteraciam
run_function(macheps,1.0,10)
# funkcia dobehne do konca
run_function(macheps,1.0,100)

### s pouzitim threadov
thr1=MyThread(macheps,1.0, 100)
thr1.start()
thr1.join()
thr2=MyThread(macheps,1.0, 20)
thr2.start()
thr2.join()
:
----------------------------------------------------------

Ak chces pracovat s threadmi mozno si skus precitat clanok 'Understanding
Threading in Python' tu:
http://linuxgazette.net/107/pai.html

"Jakub Vojacek" <jak...@seznam.cz>
Sent by: python-...@py.cz
01.03.2007 21:54
Please respond to
Konference PyCZ <pyt...@py.cz>

To
"Konference PyCZ" <pyt...@py.cz>
cc

Subject
[python] Vlastní vlákno pro dlouhý výpočet.

Ahoj

CHtěl radu ohledně vláken. Dělám na programu, kde chci dát uživateli
možnost přeuršit výpočet, protože občas by to trvá fakt dlouho. Ale jak to
naprogramovat. Hledal jsem inspiraci v
http://wiki.wxpython.org/index.cgi/LongRunningTasks ale nepomohlo to.
Potřeboval bych aby to vlákno přijalo funkci, kterou musí počítat a když
by se to dopočítalo tak aby vrátila data
Vlastně by to fungovalo tímto způsobem:

vysledek=Vlakno(moje_funkce_s_parametry)
if vysledek != None:#uživatel přeušil výpočet
zpracuj_vysledek()

Děkuji za všechny nápady

Blujacker_______________________________________________

Python mailing list
Pyt...@py.cz
http://www.py.cz/mailman/listinfo/python

Mgr. Ing. Roman MIKLÓŠ
Prvá stavebná sporiteľňa a.s.
Bajkalská 30, P. O. Box 48
829 48 Bratislava 25
Tel.: +421/ 2 / 582 31 174
Fax: +421/ 2 / 582 31 109

[Jakub Vojáček]

> ------------ Původní zpráva ------------
> Od: Tomáš Brabenec <konfe...@brabenec.net>
> Předmět: Re: [python] Vlastní vlákno pro dlouhý výpočet.
> Datum: 02.3.2007 08:34:44
> ----------------------------------------

> A co to počítání rozdělit na několik částí (pokud je to možné), přičemž
> po dokončení jedné části by se zavolala funkce na zjištění, jestli
> uživatel nepřerušil výpočet a po té teprve by se pokračovalo ve výpočtech.
> Dočasné výsledky by se ukládaly někam stranou a pokud by uživatel
> počítání přerušil, prostě by se dočasné výsledky "zahodily".
>
> Tomas

Jo, to je dobrý napád, ale jak ho realizovat?
příklad:

from Tkinter import*
okno=Tk()
p=True
def ok():
while p:
print "sss"
def stop():
p=False
Button(text="zacni",command=ok).pack()
Button(text="stpL",command=stop).pack()
mainloop()

To tlačítko stop se nedá zmáčknout, proto by se to asi mělo dělat přes ty vlákna.
Abych uvedl příklad tý akce co může trvat dolouho, tak například výpis prvočísel do 10000.
Další možnost je volat externí skript s parametrem a ten by výsledek pak uložil do souboru, ale to by bylo složité a blbě funkční

Blujacker

[Leos Pol]

Jakub Vojáček wrote:
> Jo, to je dobrý napád, ale jak ho realizovat?
> příklad:
>
> from Tkinter import*
> okno=Tk()
> p=True
> def ok():
> while p:
> print "sss"
> def stop():
> p=False
> Button(text="zacni",command=ok).pack()
> Button(text="stpL",command=stop).pack()
> mainloop()
>
> To tlačítko stop se nedá zmáčknout, proto by se to asi mělo dělat přes ty vlákna.
> Abych uvedl příklad tý akce co může trvat dolouho, tak například výpis prvočísel do 10000.
> Další možnost je volat externí skript s parametrem a ten by výsledek pak uložil do souboru, ale to by bylo složité a blbě funkční
>
>

Ja myslel, ze to pisete ve wxPythonu, tam se to da udelat velice hezky a
bez pouziti threadu. Nasledujici priklad je opis vaseho prikladu:

class Trida:

def __init__(self):
Button(text="zacni",command=self.ok)
Button(text="stpL",command=self.stop)
self.p = True

def ok(self):
while self.p:
print 'sss'
wx.Yield()

def stop(self):
self.p = False

Priklad je jen nazorny zpusob, jak to jde udelat. Jinak tento priklad
jste mel v te referenci, kterou jste uvedl:
http://wiki.wxpython.org/index.cgi/LongRunningTasks

Doporucuji take poradne nastudovat fci wx.Yield, protoze muze dochazet
treba k opetovnemu kliknuti na stejny button, takze se tam musi dodelat
disable apod. Mimo jine, vyuziti tohoto zpusobu dojde k i tomu, ze
nebude aplikace "zamrzavat" po dobu vypoctu, pokud tedy nebude trvat
jeden cyklus ve while dlouho.

Leo

--
----
Leos Pol
SW Engineer
Radiante Corp.

If it can be imagined,
we can implement it

[Jakub Vojáček]

> ------------ Původní zpráva ------------
> Od: Leos Pol <le...@radiante-corp.com>

> Předmět: Re: [python] Vlastní vlákno pro dlouhý výpočet.

> Datum: 02.3.2007 16:34:54

> Ja myslel, ze to pisete ve wxPythonu, tam se to da udelat velice hezky a
> bez pouziti threadu. Nasledujici priklad je opis vaseho prikladu:
>
> class Trida:
>
> def __init__(self):
> Button(text="zacni",command=self.ok)
> Button(text="stpL",command=self.stop)
> self.p = True
>
> def ok(self):
> while self.p:
> print 'sss'
> wx.Yield()
>
> def stop(self):
> self.p = False
>
> Priklad je jen nazorny zpusob, jak to jde udelat. Jinak tento priklad
> jste mel v te referenci, kterou jste uvedl:
> http://wiki.wxpython.org/index.cgi/LongRunningTasks
>
> Doporucuji take poradne nastudovat fci wx.Yield, protoze muze dochazet
> treba k opetovnemu kliknuti na stejny button, takze se tam musi dodelat
> disable apod. Mimo jine, vyuziti tohoto zpusobu dojde k i tomu, ze
> nebude aplikace "zamrzavat" po dobu vypoctu, pokud tedy nebude trvat
> jeden cyklus ve while dlouho.
>
> Leo
>

Děkuju, už sem to nějak udělal:

# -*- coding: cp1250 -*-
import wx
def dlouha_funkce(cislo):
while cislo != 50:
if not vypocet:return "Přerušeno"
cislo=cislo+1
print cislo
wx.Yield()
return "Výpočet dokončen"
class Okno:
def __init__(self):

self.okno=wx.Frame(None)
button=wx.Button(self.okno,label="Počítej")
button.Bind(wx.EVT_BUTTON, self.pocitej)
button2=wx.Button(self.okno,label="Stop",pos=(40,40))
button2.Bind(wx.EVT_BUTTON, self.stop)
self.okno.Show(True)
def pocitej(self,akce):
global vypocet
vypocet=True
vysledek=dlouha_funkce(0)
dlg = wx.MessageDialog(self.okno,vysledek, '', wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
def stop(self,akce):
global vypocet
vypocet=False
if __name__ == "__main__":
vypocet=True
p = wx.App(0)
Okno()
p.MainLoop()

Dělal sem to hodně narychlo, takže se omlouvám za to hnusný global ve třídě;)

Ještě jednou dík!!

Blujacker

[Jan Fuchs]

Ahoj,
tady máš příklad:

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys
import thread
import time
import Tkinter

def refresh(a):
global platno, obrazek

while (1):
try:
obrazek = Tkinter.PhotoImage(file = sys.argv[3])
platno.create_image(0, 0, image = obrazek, anchor=Tkinter.NW)
time.sleep(60)
except:
time.sleep(5)

def main():
global platno, obrazek

if (len(sys.argv) != 4):
print "pocasi.py sirka vyska obrazek.gif"
sys.exit(1)

okno = Tkinter.Tk()
okno.wm_title("Pocasi")
okno.resizable(0, 0)

platno = Tkinter.Canvas(okno, width = sys.argv[1], height = sys.argv[2], background = "white")
platno.pack()

thread.start_new(refresh, (okno,))

okno.mainloop()

if __name__ == '__main__':
main()

Měj se fajn Honza

--

/**************************************************************
* _ Žádný program není bezchybný, dokonalý ani nejlepší, *
* °v° to samé platí i o lidech a nejen o nich. *
* /(_)\ -- Jan Fuchs -- *
* ^ ^ *
* http://www.fuky.org ICQ: 200692177 *
**************************************************************/

[RMi...@pss.sk]

V Tkinteri by to bolo s pouzitim vlakien takto:
----------------------------------------------------------------------------------

# -*- coding: cp1250 -*-

from Tkinter import *
import thread

# globals
root = Tk()
computation = False
thread_flag = True

def compute():
global computation
j=0
while computation:
j += 1
print "%5d. step of computation" % j

def run():
global computation,thread_flag
computation=True
#print "computation = %s" % computation
#print "thread_flag = %s" % thread_flag
if thread_flag:
thread.start_new_thread(compute, ())
thread_flag = False

def stop():
global computation,thread_flag
#print "computation = %s" % computation
#print "thread_flag = %s" % thread_flag
if computation:
computation = False
thread_flag = True
#print "Stop!"

'''main section'''
# create a toolbar
toolbar = Frame(root)
b = Button(toolbar, text="run", width=6, command=run)
b.pack(side=LEFT, padx=2, pady=2)
b = Button(toolbar, text="stop", width=6, command=stop)
b.pack(side=LEFT, padx=2, pady=2)
toolbar.pack(side=TOP, fill=X)
# mainloop
mainloop()
----------------------------------------------------------------------------------

alebo lepsie bez pouzitia glob premennych
----------------------------------------------------------------------------------

# -*- coding: cp1250 -*-

from Tkinter import *
import thread

class MyApp:

def __init__(self):
self.root = Tk()
self.computation = False
self.thread_flag = True

def compute(self):
j=0
while self.computation:
j += 1
print "%5d. step of computation" % j

def run(self):
self.computation=True
#print "computation = %s" % computation
#print "thread_flag = %s" % thread_flag
if self.thread_flag:
thread.start_new_thread(self.compute, ())
self.thread_flag = False

def stop(self):
#print "computation = %s" % computation
#print "thread_flag = %s" % thread_flag
if self.computation:
self.computation = False
self.thread_flag = True
#print "Stop!"

def main(self):
'''main function'''
# create a toolbar
toolbar = Frame(self.root)
b = Button(toolbar, text="run", width=6, command=self.run)
b.pack(side=LEFT, padx=2, pady=2)
b = Button(toolbar, text="stop", width=6, command=self.stop)
b.pack(side=LEFT, padx=2, pady=2)
toolbar.pack(side=TOP, fill=X)
# mainloop
self.root.mainloop()

if __name__ == "__main__":
# Run program
myapp = MyApp()
myapp.main()
----------------------------------------------------------------------------------

"Jakub Vojacek" <jak...@seznam.cz>
Sent by: python-...@py.cz
01.03.2007 21:54
Please respond to
Konference PyCZ <pyt...@py.cz>

To
"Konference PyCZ" <pyt...@py.cz>
cc

Subject

[python] Vlastní vlákno pro dlouhý výpočet.