Python: Comment faire de programme attendez de la fonction ou de la méthode de l'achèvement

Souvent, il ya un besoin pour le programme à attendre pour une fonction d'achever ses travaux. Parfois c'est l'inverse: il n'est pas nécessaire pour un programme principal à attendre.
J'ai mis un exemple simple. Il y a quatre boutons. En cliquant sur chacun appelle les mêmes calculer() fonction. La seule différence est la façon dont la fonction est appelée.

"Appel direct" appels de bouton calculer() fonction directement. Puisqu'il y a une Fonction " Fin " d'imprimer, il est évident que le programme est en attente pour le calculer la fonction de terminer son travail.
"Appel à l'aide de Filetage" appels de la même fonction, cette fois à l'aide de mécanisme de threading. Depuis le programme imprime: la Fonction de Fin de message immidiately après que le bouton soit presses, je peux conclure que le programme n'attendez pas pour calculer() la fonction à remplir. Comment faire pour remplacer ce comportement? Comment faire de programme attendez jusqu'à calculer() la fonction est fini?
"Appel à l'aide de Multitraitement" boutons utilise le multitraitement de appelez la fonction calculer() fonction.
Tout comme avec le filetage de multitraitement n'attendez pas pour fonction d'achèvement. Ce que nous avons à mettre en ordre le faire attendre?
"Appel à l'aide de sous-processus" boutons ne fait rien puisque je n'ai pas trouver le moyen d'attirer les sous-processus à exécuter de script interne de la fonction ou de la méthode. Il serait intéressant de voir comment le faire...

Exemple:

from PyQt4 import QtCore, QtGui    
app = QtGui.QApplication(sys.argv)
def calculate(listArg=None):
print '\n\t Starting calculation...'
m=0
for i in range(50000000):
m+=i
print '\t ...calculation completed\n'
class Dialog_01(QtGui.QMainWindow):
def __init__(self):
super(Dialog_01, self).__init__()
myQWidget = QtGui.QWidget()
myBoxLayout = QtGui.QVBoxLayout()       
directCall_button = QtGui.QPushButton("Call Directly")
directCall_button.clicked.connect(self.callDirectly)      
myBoxLayout.addWidget(directCall_button) 
Button_01 = QtGui.QPushButton("Call via Threading")
Button_01.clicked.connect(self.callUsingThreads)
myBoxLayout.addWidget(Button_01)        
Button_02 = QtGui.QPushButton("Call via Multiprocessing")
Button_02.clicked.connect(self.callUsingMultiprocessing)
myBoxLayout.addWidget(Button_02) 
Button_03 = QtGui.QPushButton("Call via Subprocess")
Button_03.clicked.connect(self.callUsingSubprocess)
myBoxLayout.addWidget(Button_03) 
myQWidget.setLayout(myBoxLayout)
self.setCentralWidget(myQWidget)
self.setWindowTitle('Dialog 01')
def callUsingThreads(self):
print '------------------------------- callUsingThreads() ----------------------------------'
import threading
self.myEvent=threading.Event()
self.c_thread=threading.Thread(target=calculate)
self.c_thread.start()  
print "\n\t\t : Function End"
def callUsingMultiprocessing(self):
print '------------------------------- callUsingMultiprocessing() ----------------------------------'
from multiprocessing import Pool
pool = Pool(processes=3)
try: pool.map_async( calculate, ['some'])
except Exception, e: print e 
print "\n\t\t : Function End"
def callDirectly(self):
print '------------------------------- callDirectly() ----------------------------------'
calculate()
print "\n\t\t : Function End"
def callUsingSubprocess(self):
print '------------------------------- callUsingSubprocess() ----------------------------------'
import subprocess 
print '-missing code solution'
print "\n\t\t : Function End"
if __name__ == '__main__':
dialog_1 = Dialog_01()
dialog_1.show()
dialog_1.resize(480,320)
sys.exit(app.exec_())

Je pense que vous voulez voir dans le concept de thread's join() de la méthode.
Je ne suis pas sûr de comprendre pourquoi vous voulez utiliser des threads ou processus si vous voulez le calcul à exécuter de manière synchrone. Pourquoi ne pas simplement de l'exécuter dans les principaux processus/thread?
Je veux juste m'assurer que je sais ce que fait le programme lorsque j'utilise ou n'utilise pas de filetage, de sous-processus et le multitraitement. À part de savoir que faire et comment exactement à ceux des modules de méthodes, il pourrait être utile de savoir comment les contrôler... par exemple, un .méthode join () (filetage module) en fait un programme attendre jusqu'à ce que la fonction a terminé son calcul. Je pense que cela pourrait être assez utile pour savoir..

OriginalL'auteur alphanumeric | 2014-03-17

Utiliser une file d'attente: chaque thread une fois rempli met le résultat dans la file d'attente et ensuite vous avez juste besoin de lire le nombre de résultats et d'ignorer le reste:

#!python3.3
import queue    # For Python 2.x use 'import Queue as queue'
import threading, time, random
def func(id, result_queue):
print("Thread", id)
time.sleep(random.random() * 5)
result_queue.put((id, 'done'))
def main():
q = queue.Queue()
threads = [ threading.Thread(target=func, args=(i, q)) for i in range(5) ]
for th in threads:
th.daemon = True
th.start()
result1 = q.get()
result2 = q.get()
print("Second result: {}".format(result2))
if __name__=='__main__':
main()

De la Documentation pour la File d'attente.get() (sans arguments, c'est équivalent à la File d'attente.get(Vrai, None):

    Queue.get([block[, timeout]])
Remove and return an item from the queue. If optional args block is true and timeout is None (the default), block if necessary until an item is available. If timeout is a positive number, it blocks at most timeout seconds and raises the Empty exception if no item was available within that time. Otherwise (block is false), return an item if one is immediately available, else raise the Empty exception (timeout is ignored in that case).

Comment faire pour attendre jusqu'à ce que seulement le premier thread est terminé en Python

Vous pouvez utiliser .méthode join ().
qu'est-ce que l'utilisation de join() en python threading

Merci!! Toujours en attente de voir comment les sous-processus module peut être utilisé avec elle aussi!
Wow cette menace a sauvé ma journée. En python2.7 la file d'attente du module n'existe pas, mais au lieu de cela, il a appelé la File d'attente 😀

OriginalL'auteur Victor C. Martins

1

Je trouve que l'utilisation de la "piscine" sous-module dans "le multitraitement" fonctionne étonnamment pour l'exécution de plusieurs processus à la fois à l'intérieur d'un Script Python.

Voir l'Article: en Utilisant un pool de travailleurs

Regarder attentivement "# lancement de plusieurs évaluations de manière asynchrone peut utilisation des processus plus" dans l'exemple. Une fois que vous comprenez ce que ces lignes sont en train de faire, l'exemple suivant, j'ai construit va faire beaucoup de sens.
```
import numpy as np
from multiprocessing import Pool
def desired_function(option, processes, data, etc...):
# your code will go here. option allows you to make choices within your script
# to execute desired sections of code for each pool or subprocess.
return result_array   # "for example"
result_array = np.zeros("some shape")  # This is normally populated by 1 loop, lets try 4.
processes = 4
pool = Pool(processes=processes)
args = (processes, data, etc...)    # Arguments to be passed into desired function.
multiple_results = []
for i in range(processes):          # Executes each pool w/option (1-4 in this case).
multiple_results.append(pool.apply_async(param_process, (i+1,)+args)) # Syncs each.
results = np.array(res.get() for res in multiple_results)  # Retrieves results after
# every pool is finished!
for i in range(processes):
result_array = result_array + results[i]  # Combines all datasets!
```
Le code va s'exécuter la fonction souhaitée pour un certain nombre de processus. Vous devrez veiller avec soin, vous êtes à la fonction peut distinguer entre chaque processus (c'est pourquoi j'ai ajouté la variable "option".) En outre, il n'a pas à être un tableau qui est remplie à la fin, mais pour mon exemple, c'est comment je l'ai utilisé. Espérons que cela simplifie ou vous aide à mieux comprendre la puissance de multitraitement en Python!

OriginalL'auteur Patrick Kantorski

Vous devez vous connecter pour publier un commentaire.