Python3 Input and Output

In the previous chapters, we have actually already touched upon Python's input and output functionality. In this chapter, we will specifically introduce Python's input and output.

Fancier Output Formatting

Python has two ways to output values: expression statements and the print() function.

A third way is using the write() method of file objects; the standard output file can be referenced as sys.stdout.

If you want more variety in the form of output, you can use the str.format() function to format output values.

If you want to convert output values to strings, you can use the repr() or str() functions.

• str()：The function returns a user-readable representation.
• repr()：It produces an interpreter-readable representation.

Example

Here are two ways to output a table of squares and cubes:

Note:In the first example, spaces between columns are added by print().

This example demonstrates the string object's rjust() method, which right-justifies a string and pads spaces on the left.

There are similar methods, such as ljust() and center(). These methods do not write anything; they simply return new strings.

Another method, zfill(), pads zeros on the left of a number, as shown below:

The basic usage of str.format() is as follows:

The brackets and the characters inside them (called format fields) will be replaced by the arguments in format().

Numbers in the brackets are used to refer to the position of the passed-in object in format(), as shown below:

If keyword arguments are used in format(), their values will point to the arguments using that name.

Positional and keyword arguments can be combined arbitrarily:

!a(Usingascii()), !s(Usingstr()) and!r(Using repr()) can be used to convert a value before formatting it:

An optional:and format specifier can follow the field name. This allows for better formatting of the value. The following example rounds Pi to three decimal places:

In:Passing an integer afterwards ensures that the field is at least that many characters wide. This is useful for making tables look nice.

If you have a very long format string and you don't want to split it up, it is a good idea to format by variable name rather than by position.

The simplest way is to pass in a dictionary, and then use square brackets[]to access the keys:

You can also achieve the same functionality by using**before the table variable:

Old string formatting

%The operator can also perform string formatting. It interprets the left argument as asprintf()-style format string, substitutes the right argument, and then returns the formatted string. For example:

Because str.format() is a relatively new function, most Python code still uses the % operator. However, because this old-style formatting will eventually be removed from the language, str.format() should be used more often.

Reading Keyboard Input

Python providesthe input() built-in functionto read a line of text from standard input; the default standard input is the keyboard.

This produces the following result corresponding to the input:

Please enter: Example  
The content you entered is: Example

Reading and Writing Files

In Python, file operations are done through theopen()function. This function returns a file object for subsequent reading or writing operations.

open()The basic syntax is as follows:

open(filename, mode)

• filename：The path (string) of the file to access.
• mode：The file opening mode, used to specify how to read or write (such as read-only, write, append, etc.). This parameter is optional, with the default valuer(read-only).

Common file opening modes are as follows (it is recommended to focus on mastering r / w / a):

Explanation:Addingbafter the mode means operating on the file in binary mode, often used for processing non-text files such as images and audio.

The following diagram summarizes these modes well:

The following example writes a string to the file foo.txt:

• The first argument is the name of the file to be opened.
• The second parameter describes how the file will be used. mode can be 'r' if the file is read-only, 'w' only for writing (an existing file with the same name will be deleted), and 'a' for appending to the file; any data written will be automatically added to the end. 'r+' is for both reading and writing. The mode parameter is optional; 'r' will be the default value.

At this point, open the file foo.txt, which displays as follows:

$ cat /tmp/foo.txt 
Python 是一个非常好的语言。
是的，的确非常好!!

Methods of File Objects

The remaining examples in this section assume that a file object called f has already been created.

f.read()

To read a file's contents, call f.read(size), which reads a certain amount of data and then returns it as a string or bytes object.

size is an optional numeric parameter. When size is omitted or negative, all contents of the file will be read and returned.

The following example assumes that the file foo.txt already exists (it was created in the above example):

After executing the above program, the output is:

Python 是一个非常好的语言。
是的，的确非常好!!

f.readline()

f.readline() reads a single line from the file. The newline character is '\n'. If f.readline() returns an empty string, it means the last line has already been read.

After executing the above program, the output is:

Python 是一个非常好的语言。

f.readlines()

f.readlines() returns all the lines contained in the file.

If the optional parameter sizehint is set, it reads the specified length of bytes and splits these bytes by lines.

After executing the above program, the output is:

['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']

Another way is to iterate over a file object and then read each line:

After executing the above program, the output is:

Python 是一个非常好的语言。
是的，的确非常好!!

This method is simple, but it does not provide very good control. Because the processing mechanisms of the two are different, it is best not to mix them.

f.write()

f.write(string) writes string to the file, and then returns the number of characters written.

After executing the above program, the output is:

29

If you want to write something that is not a string, you will need to convert it first:

After executing the above program, open the foo1.txt file:

$ cat /tmp/foo1.txt 
('www.example.com', 14)

f.tell()

f.tell() is used to return the current read/write position of the file (i.e., the position of the file pointer). The file pointer represents the byte-number offset from the beginning of the file. f.tell() returns an integer indicating the current position of the file pointer.

f.seek()

If you want to change the current position of the file pointer, you can use the f.seek(offset, from_what) function.

f.seek(offset, whence) is used to move the file pointer to the specified position.

offset represents the offset relative to the whence parameter. The value of from_what: if it is 0, it means the beginning; if it is 1, it means the current position; 2 means the end of the file. For example:

• seek(x,0): moves x characters from the starting position, i.e., the first character of the first line of the file.
• seek(x,1): means moving x characters backward from the current position.
• seek(-x,2): means moving x characters backward from the end of the file.

The default value of from_what is 0, i.e., the beginning of the file. A complete example is given below:

f.close()

In text files (those opened in modes without b), positioning is only relative to the starting position of the file.

When you have finished processing a file, call f.close() to close the file and release the system's resources. If you try to call the file again, an exception will be thrown.

When dealing with a file object, using the with keyword is a very good approach. After it finishes, it will close the file correctly for you. It is also shorter to write than a try-finally statement block:

File objects have other methods, such as isatty() and truncate(), but these are usually less commonly used.

The pickle Module

Python's pickle module implements basic data serialization and deserialization.

Through the serialization operation of the pickle module, we can save the object information running in a program to a file for permanent storage.

Through the deserialization operation of the pickle module, we can create the object saved by the previous program from a file.

Basic interface:

pickle.dump(obj, file, [,protocol])

With this pickle object, you can open the file in read mode:

x = pickle.load(file)

Note:Read a string from the file and reconstruct it into the original Python object.

file:A file-like object, with read() and readline() interfaces.