Python Input and Output | Python 3 Inputs Outputs Tutorial 2020

1. Formatted output

We have two very different output value method: expression statements and the print () function (A third way is to use the file object write()methods, standard output file can reference sys.stdout, See the Library Reference Manual).

Normally, you want more formatting control over the output, rather than simply printing a space-separated value. There are two ways to format your output: The first method is to handle the entire string by yourself, and you can create any output form you want by using string cuts and join operations. The string type contains some useful operations for populating the string with the width of the specified column, which will be discussed later. The second method is to use the str.format()method.

The standard module string includes operations that are useful when filling a given column with a string. We will discuss this part later. The second method is to use the Template method.

Of course, there is a problem, how to convert the value into a string? Fortunately, Python has a way to convert any value to a string: pass it into the repr() or str() function.

The function str() is used to convert values into human-readable form, and repr() is converted to a form that is read by the interpreter (if there is no equivalent syntax, a SyntaxError exception occurs ).

Reading the interpretation of the form, str () will return the same value as repr () . Many types of structures, such as numeric or linked lists and dictionaries, have a unified interpretation of each function. Strings and floating-point numbers have a unique way of reading.

Here are some examples:

>>> s  =  'Hello, world.' 
>>> str ( s ) 
'Hello, world.' 
>>> repr ( s ) 
"'Hello, world.'" 
>>> str ( 1 / 7 ) 
'0.14285714285714285 ' 
>>> x  =  10  *  3.25 
>>> y  =  200  *  200 
>>> s  =  'The value of x is '  +  repr ( x )  +  ', and y is ' +  repr ( y)  +  '...' 
>>> print ( s ) 
The value of x is 32.5, and y is 40000... 
>>> # The repr() of a string adds string quotes and backslashes: 
... hello  =  'hello, world \n ' 
>>> hellos  =  repr ( hello ) 
>>> print ( hellos ) 
'hello, world\n' 
>>> # The argument to repr() may be any Python object: 
... repr (( x ,  y ,  ( 'spam' , 'eggs'))) 
"(32.5, 40000, ('spam', 'eggs'))"

There are two ways to write square and cubic tables:

>>> for  x  in  range ( 1 ,  11 ): 
...     print ( repr ( x ) . rjust ( 2 ),  repr ( x * x ) . rjust ( 3 ),  end = ' ' ) 
...     # Note Use of 'end' on previous line 
...     print ( repr ( x * x * x ) . rjust ( 4)) 
... 
1 1 1 
2 4 8 
3 9 27 
4 16 64 
5 25 125 
6 36 216 
7 49 343 
8 64 512 
9 81 729 
10 100 1000

>>> for  x  in  range ( 1 ,  11 ): 
...     print ( ' {0:2d} {1:3d} {2:4d} ' . . format ( x , x * x , x * x * x ) ) ... 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000    

(Note that in the first example, print() adds a space between each column. It always includes spaces between the arguments.)

Related Article: Python Interpreter Tutorial

The above is a demonstration of the str.rjust() method, which outputs a string to a column and aligns it to the right by padding the space to the left. Similar methods are str.ljust() and str.center() .

These functions simply output a new string and do not change anything. If the output string is too long, they will not truncate it, but output as it is, which will confuse your output format, but it will always be stronger than the alternative (truncate the string) because that will cause an error. The output value (if you really need to truncate it, you can use a cut operation, for example: x.ljust(n)[:n]).

There is another method, str.zfill(), which is used to fill the left side of a numeric string representation with 0. The function can correctly understand the sign:

>>> '12' . zfill ( 5 ) 
'00012' 
>>> '-3.14' . zfill ( 7 ) 
'-003.14' 
>>> '3.14159265359' . zfill ( 5 ) 
'3.14159265359'

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

>>> print ( 'We are the {} who say " {} !"' . format ( 'knights' ,  'Ni' )) 
We are the knights who say "Ni!"

Curly braces and their characters are replaced with the arguments passed to str.format() . The value in the braces indicates which of the objects passed into the str.format() method:

>>> print ( ' {0} and {1} ' . format ( 'spam' ,  'eggs' )) 
spam and eggs 
>>> print ( ' {1} and {0} ' . format ( 'spam' ,  'eggs' )) 
eggs and spam

If you use the keyword argument when calling str.format() , you can refer to the value by its parameter name:

>>> print ( 'This {food} is {adjective} .' . format ( 
...       food = 'spam' ,  adjective = 'absolutely horrible' )) 
This spam is absolutely horrible.

Positional parameters and keyword parameters can be freely combined:

>>> print ( 'The story of {0} , {1} , and {other} .' . format ( 'Bill' ,  'Manfred' , 
                                                       other='Georg'))) 
The story of Bill, Manfred, and Georg .

'!a'(Applying ascii() ), '!s'(using str() ) and '!r'(applying repr() ) can convert values before formatting:

>>> import  math 
>>> print ( 'The value of PI is approximately {} .' . format ( math . pi )) 
The value of PI is approximately 3.14159265359. 
>>> print ( 'The value of PI is approximately { !r} .' . format ( math . pi )) 
The value of PI is approximately 3.141592653589793.

After allows the optional field name ':'and format commands. This allows more in-depth control of the formatting of the values. The following example converts Pi to three-digit precision.

>>> Import  Math 
>>> Print ( 'IS Approximately the PI of The value of {0: .3f} .' . The format ( Math . PI )) 
of The value of the PI IS Approximately 3.142.

In the field ':'behind the increase will be an integer defining the minimum width of the field, which is useful when beautification table:

>>> table  =  { 'Sjoerd' :  4127 ,  'Jack' :  4098 ,  'Dcab' :  7678 } 
>>> for  name ,  phone  in  table . items (): 
...     print ( ' {0:10} = => {1:10d} ' . format ( name ,  phone )) 
... 
Jack ==> 4098 
Dcab ==> 7678 
Sjoerd ==> 4127

If you have a really long format string, don’t want to split it. If you can refer to the formatted variable instead of the position by name. There is a simple way to pass in a dictionary and '[]'access its keys with brackets ( ):

>>> table  =  { 'Sjoerd' :  4127 ,  'Jack' :  4098 ,  'Dcab' :  8637678 } 
>>> print ( 'Jack: {0[Jack]:d} ; Sjoerd: {0[Sjoerd]:d } ; ' 
          'Dcab: {0[Dcab]:d}'.format(table)) 
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

You can also use the ‘**’ flag to pass this dictionary as a keyword argument:

>>> table  =  { 'Sjoerd' :  4127 ,  'Jack' :  4098 ,  'Dcab' :  8637678 } 
>>> print ( 'Jack: {Jack:d} ; Sjoerd: {Sjoerd:d} ; Dcab: {Dcab :d} ' . format ( ** table )) 
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

This is very effective in combination with the new built-in function vars() . This function returns a dictionary containing all local variables.

Related Articles: Learn Python In One Day

To learn more about string formatting method str.format () , see the format string syntax .

>>> import  math 
>>> print ( 'The value of PI is about %5.3f .'  %  math . pi ) 
The value of PI is approximately 3.142.

2. Reading and Writing Files

Function open () returns a file object , commonly used with two arguments: .open(filename, mode)

>>> f  =  open ( 'workfile' ,  'w' )

The first parameter is a string containing the file name. The second parameter is also a string containing several characters that describe how to use the file. mode is 'r'when showing only read files; 'w'represents only written to the file (the file with the same name already exists will be deleted); 'a'denotes open file is additionally written to any data files will be automatically added to the end. 'r+'Indicates that the file is opened for reading and writing. The mode parameter is optional and defaults to 'r'.

Typically, the file to text open, which means that you read from the file and the string will be written to the file specified encoding (default is UTF-8) encoding. Mode back 'b'to binary mode to open a file: data is read and written in bytes of the object. This mode should be used for all files that do not contain text.

Related Article: Python For Machine Learning

In text mode, when reading, the platform-dependent line terminator (on Unix, yes \non Windows \r\n) is converted to \n. When writing in text mode, the default will appear \nconverted into a platform-dependent line terminator. This is not secretly modified for ASCII text files, but will damage JPEGor EXEdata such as a binary file. Use binary mode to read and write such files with special care.

>>> f . read () 
'This is the entire file.\n' 
>>> f . read () 
''

>>> f . readline () 
'This is the first line of the file.\n' 
>>> f . readline () 
'Second line of the file\n' 
>>> f . readline () 
''

>>> for  line  in  f : 
...     print ( line ,  end = '' ) 
... 
This is the first line of the file. 
Second line of the file

>>> f . write ( 'This is a test \n ' ) 
15

>>> value  =  ( 'the answer' ,  42 ) 
>>> s  =  str ( value ) 
>>> f . write ( s ) 
18

>>> f  =  open ( 'workfile' ,  'rb+' ) 
>>> f . write ( b '0123456789abcdef' ) 
16 
>>> f . seek ( 5 )      # Go to the 6th byte in the file 
5 
>>> f . read ( 1 ) 
b'5' 
>>> f . seek ( - 3 ,  2 )  # Go to the 3rd byte before the end 
13 
>>> f .Read( 1 ) 
b'd'

>>> f . close () 
>>> f . read () 
Traceback (most recent call last): 
  File "<stdin>" , line 1 , in ? 
ValueError : I/O operation on closed file

>>> with  open ( 'workfile' ,  'r' )  as  f : 
...     read_data  =  f . read () 
>>> f . closed 
True

>>> json . dumps ([ 1 ,  'simple' ,  'list' ]) 
'[1, "simple", "list"]'

Json . dump ( x ,  f )

x  =  json . load ( f )