18.5.5. Subprocess — Python 3.4.0 documentation

### Navigation

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

# 18.5.5. Subprocess

## 18.5.5.1. Create a subprocess

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

  Run the shell command cmd given as a string. Return a `Process` instance.

  This function is a coroutine.

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

  Create a subprocess. Return a `Process` instance.

  This function is a coroutine.

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

See also

The `BaseEventLoop.subprocess_exec()` and `BaseEventLoop.subprocess_shell()` methods.

## 18.5.5.2. 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 stderr argument to `create_subprocess_shell()` and `create_subprocess_exec()` and indicates that standard error should go into the same handle as standard output.

## 18.5.5.3. 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.

    `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.

  `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(self):`

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

## 18.5.5.4. 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 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)

    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)
        sys.stdout.flush()
        sys.stdout.buffer.flush()
        sys.stdout.buffer.write(stdout)
        sys.stdout.buffer.flush()
    loop.close()

### Navigation

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