### Navigation

- index
- modules |
- next |
- previous |
- Python »
- 3.4.2 Documentation »
- The Python Standard Library »
- 18. Interprocess Communication and Networking »
- 18.5. `asyncio` – Asynchronous I/O, event loop, coroutines and tasks »

# 18.5.6. Subprocess

## 18.5.6.1. Windows event loop

On Windows, the default event loop is `SelectorEventLoop` which does not support subprocesses. `ProactorEventLoop` should be used instead. Example to use it on Windows:

    import asyncio, os

    if os.name == 'nt':
        loop = asyncio.ProactorEventLoop()
        asyncio.set_event_loop(loop)

See also

Available event loops and Platform support.

## 18.5.6.2. Create a subprocess: high-level API using Process

`asyncio.``create_subprocess_shell`(cmd, stdin=None, stdout=None, stderr=None, loop=None, limit=None, **kwds)

  Run the shell command cmd. See `BaseEventLoop.subprocess_shell()` for parameters. Return a `Process` instance.

  The optional limit parameter sets the buffer limit passed to the `StreamReader`.

  This function is a coroutine.

`asyncio.``create_subprocess_exec`(*args, stdin=None, stdout=None, stderr=None, loop=None, limit=None, **kwds)

  Create a subprocess. See `BaseEventLoop.subprocess_exec()` for parameters. Return a `Process` instance.

  The optional limit parameter sets the buffer limit passed to the `StreamReader`.

  This function is a coroutine.

Use the `BaseEventLoop.connect_read_pipe()` and `BaseEventLoop.connect_write_pipe()` methods to connect pipes.

## 18.5.6.3. Create a subprocess: low-level API using subprocess.Popen

Run subprocesses asynchronously using the `subprocess` module.

`BaseEventLoop.``subprocess_exec`(protocol_factory, *args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)

  Create a subprocess from one or more string arguments (character strings or bytes strings encoded to the filesystem encoding), where the first string specifies the program to execute, and the remaining strings specify the program’s arguments. (Thus, together the string arguments form the `sys.argv` value of the program, assuming it is a Python script.) This is similar to the standard library `subprocess.Popen` class called with shell=False and the list of strings passed as the first argument; however, where `Popen` takes a single argument which is list of strings, `subprocess_exec()` takes multiple string arguments.

  Other parameters:

  - stdin: Either a file-like object representing the pipe to be connected to the subprocess’s standard input stream using `connect_write_pipe()`, or the constant `subprocess.PIPE` (the default). By default a new pipe will be created and connected.
  - stdout: Either a file-like object representing the pipe to be connected to the subprocess’s standard output stream using `connect_read_pipe()`, or the constant `subprocess.PIPE` (the default). By default a new pipe will be created and connected.
  - stderr: Either a file-like object representing the pipe to be connected to the subprocess’s standard error stream using `connect_read_pipe()`, or one of the constants `subprocess.PIPE` (the default) or `subprocess.STDOUT`. By default a new pipe will be created and connected. When `subprocess.STDOUT` is specified, the subprocess’s standard error stream will be connected to the same pipe as the standard output stream.
  - All other keyword arguments are passed to `subprocess.Popen` without interpretation, except for bufsize, universal_newlines and shell, which should not be specified at all.

  Returns a pair of `(transport, protocol)`, where transport is an instance of `BaseSubprocessTransport`.

  This method is a coroutine.

  See the constructor of the `subprocess.Popen` class for parameters.

`BaseEventLoop.``subprocess_shell`(protocol_factory, cmd, *, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)

  Create a subprocess from cmd, which is a character string or a bytes string encoded to the filesystem encoding, using the platform’s “shell” syntax. This is similar to the standard library `subprocess.Popen` class called with `shell=True`.

  See `subprocess_exec()` for more details about the remaining arguments.

  Returns a pair of `(transport, protocol)`, where transport is an instance of `BaseSubprocessTransport`.

  This method is a coroutine.

  See the constructor of the `subprocess.Popen` class for parameters.

See also

The `BaseEventLoop.connect_read_pipe()` and `BaseEventLoop.connect_write_pipe()` methods.

## 18.5.6.4. Constants

`asyncio.subprocess.``PIPE`

  Special value that can be used as the stdin, stdout or stderr argument to `create_subprocess_shell()` and `create_subprocess_exec()` and indicates that a pipe to the standard stream should be opened.

`asyncio.subprocess.``STDOUT`

  Special value that can be used as the stderr argument to `create_subprocess_shell()` and `create_subprocess_exec()` and indicates that standard error should go into the same handle as standard output.

`asyncio.subprocess.``DEVNULL`

  Special value that can be used as the stdin, stdout or stderr argument to `create_subprocess_shell()` and `create_subprocess_exec()` and indicates that the special file `os.devnull` will be used.

## 18.5.6.5. Process

class `asyncio.subprocess.``Process`
  `pid`

    The identifier of the process.

    Note that if you set the shell argument to `True`, this is the process identifier of the spawned shell.

  `returncode`

    Return code of the process when it exited. A `None` value indicates that the process has not terminated yet.

    A negative value `-N` indicates that the child was terminated by signal `N` (Unix only).

  `stdin`

    Standard input stream (write), `None` if the process was created with `stdin=None`.

  `stdout`

    Standard output stream (read), `None` if the process was created with `stdout=None`.

  `stderr`

    Standard error stream (read), `None` if the process was created with `stderr=None`.

  `communicate`(input=None)

    Interact with process: Send data to stdin. Read data from stdout and stderr, until end-of-file is reached. Wait for process to terminate. The optional input argument should be data to be sent to the child process, or `None`, if no data should be sent to the child. The type of input must be bytes.

    If a `BrokenPipeError` or `ConnectionResetError` exception is raised when writing input into stdin, the exception is ignored. It occurs when the process exits before all data are written into stdin.

    `communicate()` returns a tuple `(stdoutdata, stderrdata)`.

    Note that if you want to send data to the process’s stdin, you need to create the Process object with `stdin=PIPE`. Similarly, to get anything other than `None` in the result tuple, you need to give `stdout=PIPE` and/or `stderr=PIPE` too.

    Note

    The data read is buffered in memory, so do not use this method if the data size is large or unlimited.

    This method is a coroutine.

    Changed in version 3.4.2: The method now ignores `BrokenPipeError` and `ConnectionResetError`.

  `kill`()

    Kills the child. On Posix OSs the function sends `SIGKILL` to the child. On Windows `kill()` is an alias for `terminate()`.

  `send_signal`(signal)

    Sends the signal signal to the child process.

    Note

    On Windows, `SIGTERM` is an alias for `terminate()`. `CTRL_C_EVENT` and `CTRL_BREAK_EVENT` can be sent to processes started with a creationflags parameter which includes `CREATE_NEW_PROCESS_GROUP`.

  `terminate`()

    Stop the child. On Posix OSs the method sends `signal.SIGTERM` to the child. On Windows the Win32 API function `TerminateProcess()` is called to stop the child.

  `wait():`

    Wait for child process to terminate. Set and return `returncode` attribute.

    This method is a coroutine.

## 18.5.6.6. Example

Implement a function similar to `subprocess.getstatusoutput()`, except that it does not use a shell. Get the output of the “python -m platform” command and display the output:

    import asyncio
    import os
    import sys
    from asyncio import subprocess

    @asyncio.coroutine
    def getstatusoutput(*args):
        proc = yield from asyncio.create_subprocess_exec(
                                      *args,
                                      stdout=subprocess.PIPE,
                                      stderr=subprocess.STDOUT)
        try:
            stdout, _ = yield from proc.communicate()
        except:
            proc.kill()
            yield from proc.wait()
            raise
        exitcode = yield from proc.wait()
        return (exitcode, stdout)

    if os.name == 'nt':
        loop = asyncio.ProactorEventLoop()
        asyncio.set_event_loop(loop)
    else:
        loop = asyncio.get_event_loop()
    coro = getstatusoutput(sys.executable, '-m', 'platform')
    exitcode, stdout = loop.run_until_complete(coro)
    if not exitcode:
        stdout = stdout.decode('ascii').rstrip()
        print("Platform: %s" % stdout)
    else:
        print("Python failed with exit code %s:" % exitcode, flush=True)
        sys.stdout.buffer.write(stdout)
        sys.stdout.buffer.flush()
    loop.close()

### Navigation

- index
- modules |
- next |
- previous |
- Python »
- 3.4.2 Documentation »
- The Python Standard Library »
- 18. Interprocess Communication and Networking »
- 18.5. `asyncio` – Asynchronous I/O, event loop, coroutines and tasks »