How to resolve typeError: __init__() missing 'stdout' and 'stderr' in subprocess.Popen?

While automating server updates and database migrations for a web application using Python’s subprocess module. And use subprocess.Popen to execute shell commands and capture their outputs for logging. However, the script fails with TypeError: init() missing 2 required positional arguments: ‘stdout’ and ‘stderr’.

Can anyone help me to resolve this issue

1 Like

To address the TypeError: init() missing ‘stdout’ and ‘stderr’ error encountered with subprocess.Popen, it’s essential to understand and correctly implement the instantiation of the Popen class within the subprocess module.

This error suggests the omission of the stdout and stderr arguments, which are critical for directing the subprocess’s output and error streams.

subprocess.Popen enables the execution of new processes from Python, granting access to their IO pipes and return statuses. It’s a key method for executing and managing shell commands.

Solution to the Error

Specifying stdout and stderr: Correcting the error involves explicitly defining the stdout and stderr parameters in the Popen constructor. These dictate how the subprocess’s outputs and errors are processed.

Here are the options for redirecting stdout and stderr:

  1. Capture these streams with subprocess.PIPE.

  2. Ignore outputs or errors using subprocess.DEVNULL.

  3. Merge stderr into stdout with stderr=subprocess.STDOUT.

Corrected Example

To rectify the issue, adjust the subprocess.Popen invocation as follows:

import subprocess

# Capturing stdout and stderr separately

process = subprocess.Popen(['your_command', 'arg1'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)

# Capturing stdout while ignoring stderr

process = subprocess.Popen(['your_command', 'arg1'], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)

# Merging stderr into stdout

process = subprocess.Popen(['your_command', 'arg1'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

# Executing the process and retrieving its output and errors

output, error = process.communicate()

# Demonstrating how to use the retrieved output and error

print("Output:", output.decode())

if error:

print("Error:", error.decode())

Processing Outputs: The output and error captured are in byte format, necessitating decoding for standard use.

Asynchronous Execution: For ongoing interaction with a subprocess, you might explore or asynchronous reading strategies, keeping in mind the complexity and risk of deadlock.

Robust Error Checks: Implement checks for process.returncode to assess command success and ensure comprehensive error management.

By ensuring the inclusion of stdout and stderr in your subprocess.Popen setup, you facilitate nuanced control over subprocess interaction, enhancing the capability of your Python scripts to execute and monitor external commands effectively.

Thankyou for your response!

How can I handle real-time output and error streams from a subprocess in Python?

To manage real-time outputs from a subprocess, you need a non-blocking approach that allows your main program to continue running while simultaneously checking for new output from the subprocess. This can be achieved through threading or using non-blocking IO operations. Here’s how you can implement it:

Using subprocess.Popen with Threads

Python’s threading module can be used to read the subprocess’s output in a separate thread, preventing the main program from being blocked. Here’s an example:

import subprocess
import threading

def read_output(pipe, func):
    """Read subprocess pipe and apply func to each line."""
    for line in iter(pipe.readline, b''):

def print_output(line):
    """Print each line of the subprocess output."""
    print(line, end='')

process = subprocess.Popen(['your_long_running_command'],

# Create threads to read stdout and stderr concurrently
thread_stdout = threading.Thread(target=read_output, args=(process.stdout, print_output))
thread_stderr = threading.Thread(target=read_output, args=(process.stderr, print_output))



# Wait for the subprocess to finish
Using Non-blocking IO
Another approach involves using non-blocking IO operations available in the os and select modules. This method requires more care to avoid deadlocks and may involve platform-specific considerations.

Copy code
import subprocess
import select
import os
import fcntl

process = subprocess.Popen(['your_long_running_command'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)

# Set the pipes to be non-blocking
flags_stdout = fcntl.fcntl(process.stdout.fileno(), fcntl.F_GETFL)
flags_stderr = fcntl.fcntl(process.stderr.fileno(), fcntl.F_GETFL)
fcntl.fcntl(process.stdout.fileno(), fcntl.F_SETFL, flags_stdout | os.O_NONBLOCK)
fcntl.fcntl(process.stderr.fileno(), fcntl.F_SETFL, flags_stderr | os.O_NONBLOCK)

# Continuously check and read from the pipes
while True:
    reads = [process.stdout.fileno(), process.stderr.fileno()]
    ret =, [], [])

    for fd in ret[0]:
        if fd == process.stdout.fileno():
            print("stdout: ", process.stdout.readline().decode())
        if fd == process.stderr.fileno():
            print("stderr: ", process.stderr.readline().decode())

    if process.poll() is not None:

In short, handling real-time output and error streams from subprocesses in Python can be complex but is highly manageable with the right approach, whether through threading for concurrent output handling or non-blocking IO for more granular control. Each method has its advantages and suitable use cases, depending on the requirements of your application and the nature of the subprocesses you are working with.