Qiskit Tools (qiskit.tools)#

Parallel Routines#

A helper function for calling a custom function with python ProcessPoolExecutor. Tasks can be executed in parallel using this function. It has a built-in event publisher to show the progress of the parallel tasks.

qiskit.tools.parallel_map(task, values, task_args=(), task_kwargs={}, num_processes=2)[source]#

Parallel execution of a mapping of values to the function task. This is functionally equivalent to:

result = [task(value, *task_args, **task_kwargs) for value in values]

On Windows this function defaults to a serial implementation to avoid the overhead from spawning processes in Windows.

  • task (func) – Function that is to be called for each value in values.

  • values (array_like) – List or array of values for which the task function is to be evaluated.

  • task_args (list) – Optional additional arguments to the task function.

  • task_kwargs (dict) – Optional additional keyword argument to the task function.

  • num_processes (int) – Number of processes to spawn.


The result list contains the value of
task(value, *task_args, **task_kwargs) for

each value in values.

Return type:



QiskitError – If user interrupts via keyboard.


terra.parallel.start: The collection of parallel tasks are about to start. terra.parallel.update: One of the parallel task has finished. terra.parallel.finish: All the parallel tasks have finished.


import time
from qiskit.tools.parallel import parallel_map
def func(_):
        return 0
parallel_map(func, list(range(10)));


A helper module to get IBM backend information and submitted job status.

qiskit.tools.job_monitor(job, interval=None, quiet=False, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, line_discipline='\r')[source]#

Monitor the status of a IBMQJob instance.

  • job (BaseJob) – Job to monitor.

  • interval (int) – Time interval between status queries.

  • quiet (bool) – If True, do not print status messages.

  • output (file) – The file like object to write status messages to.

  • sys.stdout. (By default this is) –

  • line_discipline (string) – character emitted at start of a line of job monitor output,

  • r. (This defaults to) –


from qiskit import BasicAer, transpile
from qiskit.circuit import QuantumCircuit
from qiskit.tools.monitor import job_monitor
sim_backend = BasicAer.get_backend("qasm_simulator")
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
tqc = transpile(qc, sim_backend)
job_sim = sim_backend.run(tqc)

Monitor a single IBMQ backend.


backend (IBMQBackend) – Backend to monitor.


Examples: .. code-block:: python

from qiskit.providers.ibmq import IBMQ from qiskit.tools.monitor import backend_monitor provider = IBMQ.get_provider(hub=’ibm-q’) backend_monitor(provider.backends.ibmq_lima)


Gives overview information on all the IBMQ backends that are available.


from qiskit.providers.ibmq import IBMQ
from qiskit.tools.monitor import backend_overview
provider = IBMQ.get_provider(hub='ibm-q')

Events (qiskit.tools.events)#

A helper component for publishing and subscribing to events.

class qiskit.tools.events.TextProgressBar(output_handler=None)[source]#

A simple text-based progress bar.

output_handlerthe handler the progress bar should be written to, default

is sys.stdout, another option is sys.stderr


The progress bar can be used to track the progress of a parallel_map.

import numpy as np
import qiskit.tools.jupyter
from qiskit.tools.parallel import parallel_map
from qiskit.tools.events import TextProgressBar

%qiskit_progress_bar -t text
parallel_map(np.sin, np.linspace(0,10,100));

And it can also be used individually.

from qiskit.tools.events import TextProgressBar

iterations = 100
t = TextProgressBar()
for i in range(iterations):
    # step i of heavy calculation ...
    t.update(i + 1)  # update progress bar