
Standard streams

In computer programming, standard streams are interconnected input and output communication channels between a computer program and its environment when it begins execution. The three input/output (I/O) connections are called standard input (stdin), standard output (stdout) and standard error (stderr). Originally I/O happened via a physically connected system console (input via keyboard, output via monitor), but standard streams abstract this. When a command is executed via an interactive shell, the streams are typically connected to the text terminal on which the shell is running, but can be changed with redirection or a pipeline. More generally, a child process inherits the standard streams of its parent process.
Application.
Users generally know standard streams as input and output channels that handle data coming from an input device, or that write data from the application. The data may be text with any encoding, or binary data.
In many modern systems, the standard error stream of a program is redirected into a log file, typically for error analysis purposes.
Streams may be used to chain applications, meaning that the output stream of one program can be redirected to be the input stream to another application. In many operating systems this is expressed by listing the application names, separated by the vertical bar character, for this reason often called the pipeline character. A well-known example is the use of a pagination application, such as more, providing the user control over the display of the output stream on the display.
Background.
In most operating systems predating Unix, programs had to explicitly connect to the appropriate input and output devices. OS-specific intricacies caused this to be a tedious programming task. On many systems it was necessary to obtain control of environment settings, access a local file table, determine the intended data set, and handle hardware correctly in the case of a punch card reader, magnetic tape drive, disk drive, line printer, card punch, or interactive terminal.
One of Unix's several groundbreaking advances was "abstract devices", which removed the need for a program to know or care what kind of devices it was communicating with. Older operating systems forced upon the programmer a record structure and frequently non-orthogonal data semantics and device control. Unix eliminated this complexity with the concept of a data stream: an ordered sequence of data bytes which can be read until the end of file. A program may also write bytes as desired and need not, and cannot easily declare their count or grouping.
Another Unix breakthrough was to automatically associate input and output to terminal keyboard and terminal display, respectively, by default — the program (and programmer) did absolutely nothing to establish input and output for a typical input-process-output program (unless it chose a different paradigm). In contrast, previous operating systems usually required some—often complex—job control language to establish connections, or the equivalent burden had to be orchestrated by the program.
Since Unix provided standard streams, the Unix C runtime environment was obliged to support it as well. As a result, most C runtime environments (and C's descendants), regardless of the operating system, provide equivalent functionality.
Standard input (stdin).
Standard input is a stream from which a program reads its input data. The program requests data transfers by use of the "read" operation. Not all programs require stream input. For example, the "dir" and "ls" programs (which display file names contained in a directory) may take command-line arguments, but perform their operations without any stream data input.
Unless redirected, standard input is inherited from the parent process. In the case of an interactive shell, that is usually associated with the keyboard.
The file descriptor for standard input is 0 (zero); the POSIX "<unistd.h>" definition is codice_1; the corresponding C "<stdio.h>" variable is codice_2; similarly, the C++ "<iostream>" variable is codice_3.
Standard output (stdout).
Standard output is a stream to which a program writes its output data. The program requests data transfer with the "write" operation. Not all programs generate output. For example, the "file rename" command (variously called "mv", "move", or "ren") is silent on success.
Unless redirected, standard output is inherited from the parent process. In the case of an interactive shell, that is usually the text terminal which initiated the program.
The file descriptor for standard output is 1 (one); the POSIX "<unistd.h>" definition is codice_4; the corresponding C "<stdio.h>" variable is codice_5; similarly, the C++ "<iostream>" variable is codice_6.
Standard error (stderr).
Standard error is another output stream typically used by programs to output error messages or diagnostics. It is a stream independent of standard output and can be redirected separately. This solves the semi-predicate problem, allowing output and errors to be distinguished, and is analogous to a function returning a pair of values – see Semi-predicate problem: Multi valued return. The usual destination is the text terminal which started the program to provide the best chance of being seen even if "standard output" is redirected (so not readily observed). For example, output of a program in a pipeline is redirected to input of the next program, but errors from each program still go directly to the text terminal.
It is acceptable and normal to direct "standard output" and "standard error" to the same destination, such as the text terminal. Messages appear in the same order as the program writes them, unless buffering is involved. For example, in common situations the standard error stream is unbuffered but the standard output stream is line-buffered; in this case, text written to standard error later may appear on the terminal earlier, if the standard output stream buffer is not yet full.
The file descriptor for standard error is defined by POSIX as 2 (two); the "<unistd.h>" header file provides the symbol codice_7; the corresponding C "<stdio.h>" variable is codice_8. The C++ "<iostream>" standard header provides two variables associated with this stream: codice_9 and codice_10, the former being unbuffered and the latter using the same buffering mechanism as all other C++ streams.
Bourne-style shells allow "standard error" to be redirected to the same destination that standard output is directed to using
 2>&1
csh-style shells allow "standard error" to be redirected to the same destination that standard output is directed to using
Standard error was added to Unix in the 1970s after several wasted phototypesetting runs ended with error messages being typeset instead of displayed on the user's terminal.
Timeline.
1950s: Fortran.
Fortran has the equivalent of Unix file descriptors: By convention, many Fortran implementations use unit numbers codice_11 for stdin, codice_12 for stdout and codice_13 for stderr. In Fortran-2003, the intrinsic codice_14 module was standardized to include the named constants codice_15, codice_16, and codice_17 to portably specify the unit numbers.
! FORTRAN 77 example
 PROGRAM MAIN
 INTEGER NUMBER
 READ(UNIT=5,*) NUMBER
 WRITE(UNIT=6,'(A,I3)') ' NUMBER IS: ',NUMBER
 END
! Fortran 2003 example
program main
 use iso_fortran_env
 implicit none
 integer :: number
 read (unit=INPUT_UNIT,*) number
 write (unit=OUTPUT_UNIT,'(a,i3)') 'Number is: ', number
end program
1960: ALGOL 60.
ALGOL 60 was criticized for having no standard file access.
1968: ALGOL 68.
ALGOL 68's input and output facilities were collectively referred to as the transput. Koster coordinated the definition of the "transput" standard. The model included three standard channels: codice_18, codice_19, and codice_20.
1970s: C and Unix.
In the C programming language, the standard input, output, and error streams are attached to the existing Unix file descriptors 0, 1 and 2 respectively. In a POSIX environment the "<unistd.h>" definitions "STDIN_FILENO", "STDOUT_FILENO" or "STDERR_FILENO" should be used instead rather than magic numbers. File pointers "stdin", "stdout", and "stderr" are also provided.
Ken Thompson (designer and implementer of the original Unix operating system) modified sort in Version 5 Unix to accept "-" as representing standard input, which spread to other utilities and became a part of the operating system as a special file in Version 8. Diagnostics were part of standard output through Version 6, after which Dennis M. Ritchie created the concept of standard error.
1995: Java.
In Java, the standard streams are referred to by (for stdin), (for stdout), and (for stderr). 
public static void main(String args[]) {
 try {
 BufferedReader br = 
 new BufferedReader(new InputStreamReader(System.in));
 String s = br.readLine();
 double number = Double.parseDouble(s);
 System.out.println("Number is:" + number);
 } catch (Exception e) {
 System.err.println("Error:" + e.getMessage());
2000s: .NET.
In C# and other .NET languages, the standard streams are referred to by codice_21 (for stdin), codice_22 (for stdout) and codice_23 (for stderr). Basic read and write capabilities for the stdin and stdout streams are also accessible directly through the class codice_24 (e.g. codice_25 can be used instead of codice_26).
codice_21, codice_22 and codice_23 are codice_30 (stdin) and codice_31 (stdout, stderr) objects, which only allow access to the underlying standard streams on a text basis. Full binary access to the standard streams must be performed through the codice_32 objects returned by codice_33, codice_34 and codice_35 respectively.
// C# example
public static int Main(string[] args)
 try {
 string s = System.Console.In.ReadLine();
 double number = double.Parse(s);
 System.Console.Out.WriteLine("Number is: {0:F3}", number);
 return 0;
 // If Parse() threw an exception
 } catch (ArgumentNullException) { 
 System.Console.Error.WriteLine("No number was entered!");
 } catch (FormatException) {
 System.Console.Error.WriteLine("The specified value is not a valid number!");
 } catch (OverflowException) {
 System.Console.Error.WriteLine("The specified number is too big!");
 return -1;
' Visual Basic .NET example
Public Function Main() As Integer
 Try
 Dim s As String = System.Console.[In].ReadLine()
 Dim number As Double = Double.Parse(s)
 System.Console.Out.WriteLine("Number is: {0:F3}", number)
 Return 0
 ' If Parse() threw an exception
 Catch ex As System.ArgumentNullException
 System.Console.[Error].WriteLine("No number was entered!")
 Catch ex2 As System.FormatException
 System.Console.[Error].WriteLine("The specified value is not a valid number!")
 Catch ex3 As System.OverflowException
 System.Console.[Error].WriteLine("The specified number is too big!")
 End Try
 Return -1
End Function
When applying the codice_36 class one can use the instance properties codice_37, codice_38, and codice_39 of that class to access the standard streams of the process.
Python.
Python provides file-like objects that represent stdin, stdout, and stderr. We can show how we could use these objects to work with the input and output of our program.
sys.stdin.
Python's sys module provides us with all three file objects for stdin, stdout, and stderr. For the input file object, we use sys.stdin. This is similar to a file, where you can open and close it, just like any other file.
here a basic example:
program stdin.py
import sys
stdin_fileno = sys.stdin
for line in stdin_fileno:
 # Remove trailing newline characters using strip()
 if "exit" == line.strip():
 print("Found exit. Terminating the program")
 exit(0)
 else:
 print("Message from sys.stdin: ---> {} <---".format(line))
Usage:
$ printf "these \n are different \n words" | python stdin.py
Message from sys.stdin: ---> these <--- <br>
Message from sys.stdin: ---> are different <--- <br>
Message from sys.stdin: ---> words <--- <br>
The above snippet keeps reading input from stdin and prints the message to the Console (stdout) until the word exit is encountered.
NOTE: We do not normally close the default stdin file object, although it is allowed. So stdin_fileno.close() is valid Python code.
Now that we know a little bit about stdin, let us move to stdout.
sys.stdout.
For the output file object, we use sys.stdout. It is similar to sys.stdin, but it directly displays anything written to it to the Console.
The below snippet shows that we get the Output to the Console if we write to sys.stdout.
program stdout.py
import sys
stdout_fileno = sys.stdout
sample_input = ["Hi", "Hello from Python", "exit"]
for ip in sample_input:
 # Prints to stdout
 stdout_fileno.write(ip + "\n")
To execute: <br>
python stdout.py
Output: <br>
Hi <br>
Hello from Python <br>
exit
sys.stderr.
This is similar to sys.stdout because it also prints directly to the Console. But the difference is that can be used to print Exceptions and Error messages and also info/debugging comments. (Which is why it is called Standard Error). This can be very useful when the stdout is used to write data instead.
Here an example.
program stderr.py
import sys
stdout_fileno = sys.stdout
stderr_fileno = sys.stderr
sample_input = ["Hi", "Hello from Python", "exit"]
for ip in sample_input:
 # Prints to stdout
 # Tries to add an Integer with string. Raises an exception
 try:
 stdout_fileno.write(ip + "\n")
 # Catch exceptions
 except:
 stderr_fileno.write("Exception Occurred!\n ")
 stderr_fileno.write("ip = " + ip)
 try:
 ip = ip + 100
 # Catch all exceptions
 except:
 stderr_fileno.write("Exception Occurred! ip = " + ip + "\n")
To execute:
python stderr.py
Output: <br> 
Hi <br> 
Exception Occurred! ip = Hi <br> 
Hello from Python <br> 
Exception Occurred! ip = Hello from Python <br> 
exit <br> 
Exception Occurred! ip = exit
As you can observe, for all the input strings, we try to add to an Integer, which will raise an Exception. We catch all such exceptions and print another debug message using sys.stderr.
Redirection to a file
We can redirect the stdout and also stderr file handles to any other file (file-handle). This may be useful if you want to log events to a file without using any other module such as Logging.
The below snippet redirects output(stdout) to a file called Output.txt.
So, we will not see anything printed to the Console, because it is now being printed to the file itself! This is the essence of Output redirection. You ‘redirect’ the Output to some other place. (This time, to Output.txt, instead of the Console)
import sys
stdout_fileno = sys.stdout
sample_input = ["Hi", "Hello from Python", "exit"]
sys.stdout = open("Output.txt", "w")
for ip in sample_input:
 # Prints to the redirected stdout (Output.txt)
 sys.stdout.write(ip + '\n')
 # Prints to the actual saved stdout handler
 stdout_fileno.write(ip + '\n')
sys.stdout.close()
sys.stdout = stdout_fileno
Output:
$ root@ubuntu:~# python3 output_redirection.py
Hi
Hello from Python
exit
$ root@ubuntu:~# cat Output.txt
Hi
Hello from Python
exit
As you can see, we have printed the output to both the Console, as well as to Output.txt.
We first save the original sys.stdout file handler object to another Variable. We not only need this to restore sys.stdout to the old handler (pointing to the Console), but we can also print to the console using this Variable!
Note that after writing to the file, we close it, similar to how we close a file because that file was still open.
We finally restore the handler of sys.stdout to the Console, using the variable stdout_fileno.
A similar process can be followed for Input and Error redirection, replacing sys.stdout with sys.stdin or sys.stderr and working with Inputs and Exceptions instead of Output.
Here was described about using stdin, stdout and stderr in Python, using the sys module. And also how to manipulate the corresponding file handlers for redirection to/from a file.
GUIs.
Graphical user interfaces (GUIs) don't always make use of the standard streams; they do when GUIs are wrappers of underlying scripts and/or console programs, for instance the Synaptic package manager GUI, which wraps apt commands in Debian and/or Ubuntu. GUIs created with scripting tools like Zenity and KDialog by KDE project make use of stdin, stdout, and stderr, and are based on simple scripts rather than a complete GUI programmed and compiled in C/C++ using Qt, GTK, or other equivalent proprietary widget framework.
The Services menu, as implemented on NeXTSTEP and Mac OS X, is also analogous to standard streams. On these operating systems, graphical applications can provide functionality through a system-wide menu that operates on the current selection in the GUI, no matter in what application.
Some GUI programs, primarily on Unix, still write debug information to standard error. Others (such as many Unix media players) may read files from standard input. Popular Windows programs that open a separate console window in addition to their GUI windows are the emulators pSX and DOSBox.
GTK-server can use stdin as a communication interface with an interpreted program to realize a GUI.
The Common Lisp Interface Manager paradigm "presents" GUI elements sent to an extended output stream.