String interpolation is a simple approach to string formatting that Python borrows from the C programming language. For instance, here’s how you can control the number of decimal places in a float:

>>> x = 1/81
>>> print(x)
0.0123456790123
>>> print('value: %.2f' % x)
value: 0.01
>>> print('value: %.5f' % x)
value: 0.01235

String interpolation expressions always have the form format % values, where format is a string containing one or more occurrences of the % character. In the example 'x = %.2f' % x, the substring %.2f is a formatting command that tells Python to take the first supplied value (x) and to display it as a floating point value with two decimal places.

The character f in the format string is a conversion specifier, and it tells Python how to render the corresponding value. Table 8.1 lists the most commonly used conversion specifiers.

The e, E, and f specifiers give you different ways of representing floats. For example:

>>> x
0.012345679012345678
>>> print('x = %f' % x)
x = 0.012346
>>> print('x = %e' % x)
x = 1.234568e-02
>>> print('x = %E' % x)
x = 1.234568E-02

You can put as many specifiers as you need in a format string, although you must supply exactly one value for each specifier. For example:

>>> a, b, c = 'cat', 3.14, 6
>>> s = 'There's %d %ss older than %.2f years' % (c, a, b)
>>> s
"There's 6 cats older than 3.14 years"

As this example shows, the format string acts as a simple template that gets filled in by the values. The values are given in a tuple, and they must be in the order in which you want them replaced.

In addition to files, folders (or directories) are used to store files and other folders. The folder structure of most file systems is quite large and complex, forming a hierarchical folder structure.

A pathname is the name used to identify a file or a folder. The full pathname can be quite long. For example, the Python folder on my Windows computer has this full pathname: C:Documents and Settings jdDesktoppython.

Windows pathnames use a backward slash () character to separate names in a path, and they start with the letter of the disk drive (in this example, C:).

On Mac and Linux systems, a forward slash (/) is used to separate names. Plus, there is no drive letter at the start. For example, here is the full pathname for my Python folder on Linux: /home/tjd/Desktop/python.

Many programs use the idea of a current working directory, or cwd. This is simply one directory that has been designated as the default directory: Whenever you do something to a file or a folder without providing a full pathname, Python assumes you mean a file or a folder in the current working directory.

Perhaps the most common way of reading a text file is to read it one line at a time. For example, this prints the contents of a file to the screen:

# printfile.py
def print_file1(fname):
    f = open(fname, 'r')
    for line in f:
        print(line, end = '')
    f.close()  # optional

The first line of the function opens the file: open requires the name of the file you want to process, and also the mode you want it opened in. We are only reading the file, so we open the file in read mode 'r'. Table 8.3 lists Python’s main file modes.

The open function returns a special file object, which represents the file on disk. Importantly, open does not read the file into RAM. Instead, in this example, the file is read a line at a time using a for-loop.

The last line of print_file1 closes the file. As the comment notes, this is optional: Python almost always automatically closes files for you. In this case, variable f is local to print_file1, so when print_file1 ends, Python automatically closes and then deletes the file object (not the file itself, of course!) that f points to.

Another common way of reading a text file is to read it as one big string. For example:

# printfile.py
def print_file2(fname):
    f = open(fname, 'r')
    print(f.read())
    f.close()

This is shorter and simpler than print_file1, so many programmers prefer it. However, if the file you are reading is very large, it will take up a lot of RAM, which could slow down, or even crash, your computer.

Finally, we note that many programmers would write this function with a single-line body:

# printfile.py
def print_file3(fname):
    print(open(fname, 'r').read())

While this more compact form might take some getting used to, many programmers like this style because it is both quick to type and still relatively readable.

f = open(fname)

Writing text files is only a little more involved than reading them. For example, this function creates a new text file named story.txt:

# write.py
def make_story1():
    f = open('story.txt', 'w')
    f.write('Mary had a little lamb,
')
    f.write('and then she had some more.
')

The 'w' tells Python to open the file in write mode. To put text into the file, you call f.write with the string you want to put into the file. Strings are written to the file in the order in which they are given.

Important: If story.txt already exists, then calling open('story.txt', 'w') will delete it! If you want to avoid overwriting story.txt, you need to check to see if it exists:

# write.py
import os
def make_story2():
    if os.path.isfile('story.txt'):
        print('story.txt already exists)
    else:
        f = open('story.txt', 'w')
        f.write('Mary had a little lamb,
')
        f.write('and then she had some more.
')

One common way of adding strings to a text file is to append them to the end of the file. Unlike 'w' mode, this does not delete anything that might already be in the file. For example:

def add_to_story(line,
                 fname = 'story.txt'):
    f = open(fname, 'a')
    f.write(line)

The important thing to note here is that the file is opened in append mode 'a'.

Writing a string to the beginning of a file is not as easy as appending one to the end because the Windows, Linux, and Macintosh operating systems don’t directly support inserting text at the beginning of a text file. Perhaps the simplest way to insert text at the beginning of a file is to read the file into a string, insert the new text into the string, and then write the string back to the original file. For example:

def insert_title(title,
                 fname = 'story.txt'):
    f = open(fname, 'r+')

    temp = f.read()
    temp = title + '

' + temp

    f.seek(0)  # reset file pointer
               # to beginning
    f.write(temp)

First, notice that we open the file using the special mode 'r+', which means the file can be both read from and written to. Then we read the entire file into the string temp and insert the title using string concatenation.

Before writing the newly created string back into the file, we first have to tell the file object f to reset its internal file pointer. All text file objects keep track of where they are in the file, and after f.read() is called, the file pointer is at the very end. Calling f.seek(0) puts it back at the start of the file, so that when we write to f, it begins at the start of the file.

Accessing the individual bytes of binary files is a very low-level operation that, while useful in systems programming, is less useful in higher-level applications programming.

Pickling is often a much more convenient way to deal with binary files. Python’s pickle module lets you easily read and write almost any data structure. For example:

# picklefile.py
import pickle

def make_pickled_file():
    grades = {'alan' : [4, 8, 10, 10],
              'tom' : [7, 7, 7, 8],
              'dan' : [5, None, 7, 7],
              'may' : [10, 8, 10, 10]}

    outfile = open('grades.dat', 'wb')
    pickle.dump(grades, outfile)

def get_pickled_data():
    infile = open('grades.dat', 'rb')
    grades = pickle.load(infile)
    return grades

Essentially, pickling lets you store a data structure on disk using pickle.dump and then retrieve it later with pickle.load. This is an extremely useful feature in many application programs, so you should keep it in mind whenever you need to store binary data.