Python Programming/Input and Output

Input
Python 3.x has one function for input from user,. By contrast, legacy Python 2.x has two functions for input from user:  and.

There are also very simple ways of reading a file and, for stricter control over input, reading from stdin if necessary.

input in Python 3.x
In Python 3.x, input asks the user for a string of data (ended with a newline), and simply returns the string. It can also take an argument, which is displayed as a prompt before the user enters the data. E.g. prints out What is your name?

Example: to assign the user's name, i.e. string data, to a variable "x" you would type

In legacy Python 2.x, the above applies to what was  function, and there was also   function that behaved differently, automatically evaluating what the user entered; in Python 3, the same would be achieved via.

Links:
 * input in Built-in Functions in Library Reference for Python 3, docs.python.org
 * raw_input in Built-in Functions in Library Reference for Python 2, docs.python.org

input in Python 2.x
In legacy Python 2.x, input takes the input from the user as a string and evaluates it.

Therefore, if a script says: it is possible for a user to input:

which yields the correct answer in list form. Note that no inputted statement can span more than one line.

input should not be used for anything but the most trivial program, for security reasons. Turning the strings returned from raw_input into Python types using an idiom such as: is preferable, as input uses eval to turn a literal into a Python type, which allows a malicious person to run arbitrary code from inside your program trivially.

Links:
 * input in Built-in Functions in Library Reference for Python 2, docs.python.org

File Objects
To read from a file, you can iterate over the lines of the file using open: This will print the first character of each line. A newline is attached to the end of each line read this way. The second argument to open can be 'r', 'w', or 'rw', among some others.

The newer and better way to read from a file: The advantage is that the opened file will close itself after finishing the part within the with statement, and will do so even if an exception is thrown.

Because files are automatically closed when the file object goes out of scope, there is no real need to close them explicitly. So, the loop in the previous code can also be written as:

You can read a specific numbers of characters at a time: This will read the characters from f one at a time, and then print them if they're not whitespace.

A file object implicitly contains a marker to represent the current position. If the file marker should be moved back to the beginning, one can either close the file object and reopen it or just move the marker back to the beginning with:

Standard File Objects
There are built-in file objects representing standard input, output, and error. These are in the sys module and are called stdin, stdout, and stderr. There are also immutable copies of these in __stdin__, __stdout__, and __stderr__. This is for IDLE and other tools in which the standard files have been changed.

You must import the sys module to use the special stdin, stdout, stderr I/O handles. For finer control over input, use sys.stdin.read. To implement the UNIX 'cat' program in Python, you could do something like this: Note that sys.stdin.read will read from standard input till EOF. (which is usually Ctrl+D.)

Parsing command line
Command-line arguments passed to a Python program are stored in sys.argv list. The first item in the list is name of the Python program, which may or may not contain the full path depending on the manner of invocation. sys.argv list is modifiable.

Printing all passed arguments except for the program name itself:

Parsing passed arguments for passed minus options: Above, the arguments at which options are found are removed so that sys.argv can be looped for all remaining arguments.

Parsing of command-line arguments is further supported by library modules optparse (deprecated), argparse (since Python 2.7) and getopt (to make life easy for C programmers).

A minimum parsing example for argparse:

Parse with argparse--specify the arg type as int:

Parse with argparse--add optional switch -m to yield multiplication instead of addition:

Parse with argparse--set an argument to consume one or more items: Usage example: python ArgparseTest.py 1 3 5

Parse with argparse--as above but with a help epilog to be output after parameter descriptions upon -h:

Parse with argparse--make second integer argument optional via nargs:

Links:
 * The Python Standard Library - 28.1. sys, docs.python.org
 * The Python Standard Library - 15.4. argparse, docs.python.org
 * The Python Standard Library - 15.5. optparse, docs.python.org
 * The Python Standard Library - 15.6. getopt, docs.python.org
 * Argparse Tutorial, docs.python.org

Output
The basic way to do output is the print statement.

To print multiple things on the same line separated by spaces, use commas between them:

This will print out the following: Hello, World

While neither string contained a space, a space was added by the print statement because of the comma between the two objects. Arbitrary data types can be printed:

This will output the following: 1 2 255 511 (10+5j) -0.999  

Objects can be printed on the same line without needing to be on the same line:

This will output the following: 0 1 2 3 4 5 6 7 8 9

To end the printed line with a newline, add a print statement without any objects.

This will output the following: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

If the bare print statement were not present, the above output would look like: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

You can print to a file instead of to standard output: This will print to any object that implements write, which includes file objects.

Note on legacy Python 2: in Python 2, print is a statement rather than a function and there is no need to put brackets around its arguments. Instead of print(i, end=" "), one would write print i,.

Omitting newlines
In Python 3.x, you can output without a newline by passing end="" to the print function or by using the method write:

In Python 2.x, to avoid adding spaces and newlines between objects' output with subsequent print statements, you can do one of the following:

Concatenation: Concatenate the string representations of each object, then later print the whole thing at once.

This will output the following: 12255511(10+5j)-0.999

Write function: You can make a shorthand for sys.stdout.write and use that for output. This will output the following: 2005

You may need sys.stdout.flush to get that text on the screen quickly.

Examples
Examples of output with Python 3.x:
 * from __future__ import print_function
 * Ensures Python 2.6 and later Python 2.x can use Python 3.x print function.
 * print("Hello", "world")
 * Prints the two words separated with a space. Notice the surrounding brackets, ununsed in Python 2.x.
 * print("Hello world", end="")
 * Prints without the ending newline.
 * print("Hello", "world", sep="-")
 * Prints the two words separated with a dash.
 * print("Hello", 34)
 * Prints elements of various data types, separating them by a space.
 * print("Hello " + 34)
 * Throws an error as a result of trying to concatenate a string and an integer.
 * print("Hello " + str(34))
 * Uses "+" to concatenate strings, after converting a number to a string.
 * sum=2+2; print "The sum: %i" % sum
 * Prints a string that has been formatted with the use of an integer passed as an argument. See also.


 * print ("Error", file=sys.stderr)
 * Outputs to a file handle, in this case standard error stream.

Examples of output with Python 2.x:
 * print "Hello"
 * print "Hello", "world"
 * Separates the two words with a space.
 * print "Hello", 34
 * Prints elements of various data types, separating them by a space.
 * print "Hello " + 34
 * Throws an error as a result of trying to concatenate a string and an integer.
 * print "Hello " + str(34)
 * Uses "+" to concatenate strings, after converting a number to a string.
 * print "Hello",
 * Prints "Hello " without a newline, with a space at the end.
 * sys.stdout.write("Hello")
 * Prints "Hello" without a newline. Doing "import sys" is a prerequisite. Needs a subsequent "sys.stdout.flush" in order to display immediately on the user's screen.
 * sys.stdout.write("Hello\n")
 * Prints "Hello" with a newline.
 * print >> sys.stderr, "An error occurred."
 * Prints to standard error stream.
 * sys.stderr.write("Hello\n")
 * Prints to standard error stream.
 * sum=2+2; print "The sum: %i" % sum
 * Prints a string that has been formatted with the use of an integer passed as an argument.
 * formatted_string = "The sum: %i" % (2+2); print formatted_string
 * Like the previous, just that the formatting happens outside of the print statement.
 * print "Float: %6.3f" % 1.23456
 * Outputs "Float: 1.234". The number 3 after the period specifies the number of decimal digits after the period to be displayed, while 6 before the period specifies the total number of characters the displayed number should take, to be padded with spaces if needed.
 * print "%s is %i years old" % ("John", 23)
 * Passes two arguments to the formatter.

File Output
Printing numbers from 1 to 10 to a file, one per line: With "w", the file is opened for writing. With "file=file1", print sends its output to a file rather than standard output.

Printing numbers from 1 to 10 to a file, separated with a dash:

Opening a file for appending rather than overwriting:

In Python 2.x, a redirect to a file is done like print >>file1, i.

See also ../Files/ chapter.

Formatting
Formatting numbers and other values as strings using the string percent operator:

Formatting numbers and other values as strings using the format string method, since Python 2.6:

Formatting numbers and other values as strings using literal string interpolation, since Python 3.6:

Links:
 * 5.6.2. String Formatting Operations, docs.python.org
 * 2. Built-in Functions # format, docs.python.org
 * 7.1.2. Custom String Formatting, docs.python.org
 * 7.1.3.1. Format Specification Mini-Language, docs.python.org
 * 7.1.4. Template strings, docs.python.org
 * PEP 3101 -- Advanced String Formatting, python.org
 * PEP 498 -- Literal String Interpolation, python.org