¿Cómo obtener el valor de retorno de un hilo en python?

Recabamos por el mundo on line y así darte la solución a tu problema, si tienes dudas déjanos la duda y contestamos porque estamos para servirte.

Solución:

FWIW, el multiprocessing El módulo tiene una buena interfaz para esto usando el Pool clase. Y si quiere apegarse a los hilos en lugar de a los procesos, puede usar el multiprocessing.pool.ThreadPool clase como reemplazo directo.

def foo(bar, baz):
  print 'hello 0'.format(bar)
  return 'foo' + baz

from multiprocessing.pool import ThreadPool
pool = ThreadPool(processes=1)

async_result = pool.apply_async(foo, ('world', 'foo')) # tuple of args for foo

# do some other stuff in the main process

return_val = async_result.get()  # get the return value from your function.

Una forma que he visto es pasar un objeto mutable, como una lista o un diccionario, al constructor del hilo, junto con un índice u otro identificador de algún tipo. El subproceso puede almacenar sus resultados en su ranura dedicada en ese objeto. Por ejemplo:

def foo(bar, result, index):
    print 'hello 0'.format(bar)
    result[index] = "foo"

from threading import Thread

threads = [None] * 10
results = [None] * 10

for i in range(len(threads)):
    threads[i] = Thread(target=foo, args=('world!', results, i))
    threads[i].start()

# do some other stuff

for i in range(len(threads)):
    threads[i].join()

print " ".join(results)  # what sound does a metasyntactic locomotive make?

si realmente quieres join() para devolver el valor de retorno de la función llamada, puede hacerlo con un Thread subclase como la siguiente:

from threading import Thread

def foo(bar):
    print 'hello 0'.format(bar)
    return "foo"

class ThreadWithReturnValue(Thread):
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=, Verbose=None):
        Thread.__init__(self, group, target, name, args, kwargs, Verbose)
        self._return = None
    def run(self):
        if self._Thread__target is not None:
            self._return = self._Thread__target(*self._Thread__args,
                                                **self._Thread__kwargs)
    def join(self):
        Thread.join(self)
        return self._return

twrv = ThreadWithReturnValue(target=foo, args=('world!',))

twrv.start()
print twrv.join()   # prints foo

Eso se vuelve un poco peliagudo debido a la manipulación de algunos nombres, y accede a estructuras de datos “privadas” que son específicas de Thread implementación… pero funciona.

para python3

class ThreadWithReturnValue(Thread):
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=, Verbose=None):
        Thread.__init__(self, group, target, name, args, kwargs)
        self._return = None
    def run(self):
        print(type(self._target))
        if self._target is not None:
            self._return = self._target(*self._args,
                                                **self._kwargs)
    def join(self, *args):
        Thread.join(self, *args)
        return self._return

En Python 3.2+, stdlib concurrent.futures El módulo proporciona una API de nivel superior para threadingincluido el paso de valores devueltos o excepciones de un subproceso de trabajo al subproceso principal:

import concurrent.futures

def foo(bar):
    print('hello '.format(bar))
    return 'foo'

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(foo, 'world!')
    return_value = future.result()
    print(return_value)

Tienes la opción de añadir valor a nuestra información tributando tu veteranía en las explicaciones.

---

---

Utiliza Nuestro Buscador