Вопрос по python – Можно ли мультипроцессировать функцию, которая возвращает что-то в Python?

18

В Python я видел много примеров, когда вызывается многопроцессорная обработка, но цель просто что-то печатает. У меня есть сценарий, где цель возвращает 2 переменные, которые мне нужно использовать позже. Например:

def foo(some args):
   a = someObject
   b = someObject
   return a,b

p1=multiprocess(target=foo,args(some args))
p2=multiprocess(target=foo,args(some args))
p3=multiprocess(target=foo,args(some args))

Что теперь? Я могу сделать .start и .join, но как мне получить отдельные результаты? Мне нужно поймать возврат a, b для всех заданий, которые я выполняю, а затем поработать над этим.

Ваш Ответ

6   ответов
25

используя несколько процессов ... так почему бы не использоватьPool? APool позаботится о запуске процессов, получении результатов и возврате результатов вам. Здесь я используюpathos, который имеет вилкуmultiprocessing, потому что он имеет намного лучшую сериализацию, чем версия, предоставляемая стандартной библиотекой.

>>> from pathos.multiprocessing import ProcessingPool as Pool
>>> 
>>> def foo(obj1, obj2):
...   a = obj1.x**2
...   b = obj2.x**2
...   return a,b
... 
>>> class Bar(object):
...   def __init__(self, x):
...     self.x = x
... 
>>> res = Pool().map(foo, [Bar(1),Bar(2),Bar(3)], [Bar(4),Bar(5),Bar(6)])
>>> res
[(1, 16), (4, 25), (9, 36)]

И ты видишь этоfoo принимает два аргумента и возвращает кортеж из двух объектов.map методPool отправляетfoo к базовым процессам и возвращает результат какres.

Вы можете получитьpathos Вот:https: //github.com/uqfoundatio

Может быть стоит раскрыть, что Майк Маккернс является автором пафоса. Nimrod
Абсолютно. К вашему сведению, эта публикация была до моего осознания того, что раскрытие авторства является стандартной практикой. Mike McKerns
18

конечно - вы можете использовать несколько методов. Одним из самых простых является общийQueue. Смотрите пример здесь:http: //eli.thegreenplace.net/2012/01/16/python-parallelizing-cpu-bound-tasks-with-multiprocessing

@ Nishant: это могут быть любые данные. Для передачи реальных файлов я бы сделал осторожный анализ с учетом размера файла. Может быть удобнее просто записать файлы на диск и передать указатели на них (то есть имена), но необходимо соблюдать осторожность с точки зрения синхронизации и атомарности Eli Bendersky
Есть ли ограничение на возвращаемое значение? Что если это бинарный файл типа pdf? Моя цель состоит в том, чтобы получить: pdf_S и затем объединить. Заказ не имеет для нас значения. Nishant
9

потому что не могу дать вам прямую ссылку на него. Обратите внимание, что он выводит результаты из done_queue, но вы можете делать с ним все что угодно.

#
# Simple example which uses a pool of workers to carry out some tasks.
#
# Notice that the results will probably not come out of the output
# queue in the same in the same order as the corresponding tasks were
# put on the input queue.  If it is important to get the results back
# in the original order then consider using `Pool.map()` or
# `Pool.imap()` (which will save on the amount of code needed anyway).
#
# Copyright (c) 2006-2008, R Oudkerk
# All rights reserved.
#

import time
import random

from multiprocessing import Process, Queue, current_process, freeze_support

#
# Function run by worker processes
#

def worker(input, output):
    for func, args in iter(input.get, 'STOP'):
        result = calculate(func, args)
        output.put(result)

#
# Function used to calculate result
#

def calculate(func, args):
    result = func(*args)
    return '%s says that %s%s = %s' % \
        (current_process().name, func.__name__, args, result)

#
# Functions referenced by tasks
#

def mul(a, b):
    time.sleep(0.5*random.random())
    return a * b

def plus(a, b):
    time.sleep(0.5*random.random())
    return a + b

#
#
#

def test():
    NUMBER_OF_PROCESSES = 4
    TASKS1 = [(mul, (i, 7)) for i in range(20)]
    TASKS2 = [(plus, (i, 8)) for i in range(10)]

    # Create queues
    task_queue = Queue()
    done_queue = Queue()

    # Submit tasks
    for task in TASKS1:
        task_queue.put(task)

    # Start worker processes
    for i in range(NUMBER_OF_PROCESSES):
        Process(target=worker, args=(task_queue, done_queue)).start()

    # Get and print results
    print 'Unordered results:'
    for i in range(len(TASKS1)):
        print '\t', done_queue.get()

    # Add more tasks using `put()`
    for task in TASKS2:
        task_queue.put(task)

    # Get and print some more results
    for i in range(len(TASKS2)):
        print '\t', done_queue.get()

    # Tell child processes to stop
    for i in range(NUMBER_OF_PROCESSES):
        task_queue.put('STOP')


if __name__ == '__main__':
    freeze_support()
    test()

Это родом из многопроцессорный модуль документации.

2

но вот мой многопроцессорный декоратор для функций, он возвращает очередь, которую вы можете опрашивать и собирать возвращенные данные из

import os
from Queue import Queue
from multiprocessing import Process

def returning_wrapper(func, *args, **kwargs):
    queue = kwargs.get("multiprocess_returnable")
    del kwargs["multiprocess_returnable"]
    queue.put(func(*args, **kwargs))

class Multiprocess(object):
    """Cute decorator to run a function in multiple processes."""
    def __init__(self, func):
        self.func = func
        self.processes = []

    def __call__(self, *args, **kwargs):
        num_processes = kwargs.get("multiprocess_num_processes", 2) # default to two processes.
        return_obj = kwargs.get("multiprocess_returnable", Queue()) # default to stdlib Queue
        kwargs["multiprocess_returnable"] = return_obj
        for i in xrange(num_processes):
            pro = Process(target=returning_wrapper, args=tuple([self.func] + list(args)), kwargs=kwargs)
            self.processes.append(pro)
            pro.start()
        return return_obj


@Multiprocess
def info():
    print 'module name:', __name__
    print 'parent process:', os.getppid()
    print 'process id:', os.getpid()
    return 4 * 22

data = info()
print data.get(False)
Сложность есть. Nishant
Не так уж и плохо, когда ты читаешь это через Jakob Bowyer
2

Перезвонит мультипроцессинга. Бассейн?

Пример

from multiprocessing import Pool
from contextlib import contextmanager

from pprint import pprint
from requests import get as get_page

@contextmanager
def _terminating(thing):
    try:
        yield thing
    finally:
        thing.terminate()

def _callback(*args, **kwargs):
    print("CALBACK")
    pprint(args)
    pprint(kwargs)

print("Processing...")
with _terminating(Pool(processes=WORKERS)) as pool:
    results = pool.map_async(get_page, URLS, callback=_callback)

    start_time = time.time()
    results.wait()
    end_time = time.time()
    print("Time for Processing: %ssecs" % (end_time - start_time))

Вот, я печатаю как арги, так и кварги. Но вы можете заменитьПерезвонит по

def _callback2(responses):
    for r in responses:
        print(r.status_code) # or do whatever with response...

Похожие вопросы