Можно ли запускать процессы пула последовательно?

Согласно документации, такого контроля над процессами в пуле не существует. Однако вы можете имитировать его с помощью блокировки:

import multiprocessing
import time

lock = multiprocessing.Lock()

def worker(nr):
    lock.acquire()
    time.sleep(0.100)
    lock.release()
    print(nr)

numbers = [i for i in range(20)]

if __name__ == '__main__':
    multiprocessing.freeze_support()
    pool = multiprocessing.Pool(processes=3)
    results = pool.map(worker, numbers)
    pool.close()
    pool.join()

Ваши 3 процесса по-прежнему будут запускаться одновременно. Ну, я имею в виду, что у вас нет контроля над тем, какой процесс начинает выполнение обратного вызова первым. Но, по крайней мере, вы получите свою задержку. Таким образом, каждый рабочий "запускается" (но на самом деле продолжает) через определенные промежутки времени.

Поправка, возникшая в результате обсуждения ниже:

Обратите внимание, что в Windows невозможно наследовать блокировку от родительского процесса. Вместо этого вы можете использовать multiprocessing.Manager().Lock() для передачи объекта глобальной блокировки между процессами (конечно, с дополнительными издержками IPC). Глобальный объект блокировки также должен быть инициализирован в каждом процессе. Это будет выглядеть так:

from multiprocessing import Process, freeze_support
import multiprocessing
import time
from datetime import datetime as dt

def worker(nr):
    glock.acquire()
    print('started job: {} at {}'.format(nr, dt.now()))
    time.sleep(1)
    glock.release()
    print('ended   job: {} at {}'.format(nr, dt.now()))

numbers = [i for i in range(6)]

def init(lock):
    global glock
    glock = lock

if __name__ == '__main__':
    multiprocessing.freeze_support()
    lock = multiprocessing.Manager().Lock()
    pool = multiprocessing.Pool(processes=3, initializer=init, initargs=(lock,))
    results = pool.map(worker, numbers)
    pool.close()
    pool.join()

Не могли бы вы сделать что-то простое вроде этого:

from multiprocessing import Process
from time import sleep

def f(n):
    print 'started job: '+str(n)
    sleep(3)
    print 'ended job: '+str(n)

if __name__ == '__main__':
    for i in range(0,100):
        p = Process(target=f, args=(i,))
        p.start()
        sleep(1)

Результат

started job: 0
started job: 1
started job: 2
ended job: 0
started job: 3
ended job: 1
started job: 4
ended job: 2
started job: 5

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

def get_numbers_on_delay(numbers, delay):
    for i in numbers:
        yield i
        time.sleep(delay)

а потом:

results = pool.map(worker, get_numbers_on_delay(numbers, 5))

Я не проверял это, поэтому я не уверен, но попробуйте.

По какой-то причине я не мог заставить блокирующий ответ работать, поэтому я реализовал его таким образом. Я понимаю, что вопрос старый, но, может быть, у кого-то еще такая же проблема.

Он порождает все процессы, аналогичные решению блокировки, но приостанавливается перед работой в зависимости от их номера имени процесса.

from multiprocessing import current_process
from re import search
from time import sleep

def worker():
    process_number = search('\d+', current_process().name).group()
    time_between_workers = 5
    sleep(time_between_workers * int(process_number))
    #do your work here

Поскольку имена, данные процессам, кажутся уникальными и добавочными, это захватывает номер процесса и засыпает на его основе. SpawnPoolWorker-1 спит 1 * 5 секунд, SpawnPoolWorker-2 спит 2 * 5 секунд и т. д.