Python 3.7.x Notes -4 Input & Output

Posted 2022-12-14 「已注销」

Input and Output

Fancier Output Formatting

So far we’ve encountered two ways of writing values: expression statements and the print() function.
To use formatted string literals, begin a string with f or F before the opening quotation mark or triple quotation mark.

>>> year = 2016
>>> event = 'Referendum'
>>> f'Results of the year event'
'Results of the 2016 Referendum'

The str.format() method of strings requires more manual effort.

>>> yes_votes = 42_572_654
>>> no_votes = 43_132_495
>>> percentage = yes_votes / (yes_votes + no_votes)
>>> ':-9 YES votes  :2.2%'.format(yes_votes, percentage)
' 42572654 YES votes  49.67%'

The str() function is meant to return representations of values which are fairly human-readable, while repr() is meant to generate representations which can be read by the interpreter
1 Formatted String Literals
Formatted string literals (also called f-strings for short) let you include the value of Python expressions inside a string by prefixing the string with f or F and writing expressions as expression.

>>> import math
>>> print(f'The value of pi is approximately math.pi:.3f.')
The value of pi is approximately 3.142.

>>> table = 'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678
>>> for name, phone in table.items():
...     print(f'name:10 ==> phone:10d')
...
Sjoerd     ==>       4127
Jack       ==>       4098
Dcab       ==>       7678

Other modifiers can be used to convert the value before it is formatted. ‘!a’ applies ascii(), ‘!s’ applies str(), and ‘!r’ applies repr():

>>> animals = 'eels'
>>> print(f'My hovercraft is full of animals.')
My hovercraft is full of eels.
>>> print(f'My hovercraft is full of animals!r.')
My hovercraft is full of 'eels'.

2 The String format() Method

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

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

If you have a really long format string that you don’t want to split up, it would be nice if you could reference the variables to be formatted by name instead of by position. This can be done by simply passing the dict and using square brackets ‘[]’ to access the keys

>>> 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

3 Manual String Formatting
The str.rjust() method of string objects right-justifies a string in a field of a given width by padding it with spaces on the left. There are similar methods str.ljust() and str.center().

>>> 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

There is another method, str.zfill(), which pads a numeric string on the left with zeros. It understands about plus and minus signs:

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

Old string formatting
The % operator can also be used for string formatting. It interprets the left argument much like a sprintf()-style format string to be applied to the right argument, and returns the string resulting from this formatting operation.

Reading and Writing Files

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

The first argument is a string containing the filename. The second argument is another string containing a few characters describing the way in which the file will be used. mode can be ‘r’ when the file will only be read, ‘w’ etc.
It is good practice to use the with keyword when dealing with file objects. The advantage is that the file is properly closed after its suite finishes, even if an exception is raised at some point. Using with is also much shorter than writing equivalent try-finally blocks:

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

1 Methods of File Objects
The rest of the examples in this section will assume that a file object called f has already been created.

>>> 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

If you want to read all the lines of a file in a list you can also use list(f) or f.readlines().
f.write(string) writes the contents of string to the file, returning the number of characters written.

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

f.tell() returns an integer giving the file object’s current position in the file represented as number of bytes from the beginning of the file when in binary mode and an opaque number when in text mode.

>>> 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'

2 Saving structured data with json
Rather than having users constantly writing and debugging code to save complicated data types to files, Python allows you to use the popular data interchange format called JSON (javascript Object Notation). The standard module called json can take Python data hierarchies, and convert them to string representations; this process is called serializing. Reconstructing the data from the string representation is called deserializing. Between serializing and deserializing, the string representing the object may have been stored in a file or data, or sent over a network connection to some distant machine.

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

Another variant of the dumps() function, called dump(), simply serializes the object to a text file. So if f is a text file object opened for writing, we can do this:

json.dump(x, f)

To decode the object again, if f is a text file object which has been opened for reading:

x = json.load(f)