Using files to file stuff...

Everything we’ve dealt with up to this point has had no real permanence. That is to say that all of the data we’ve processed only exists during the life of the program, once the program is complete, the data is destroyed. This is ok for programs like calculators, but most programs require data to be contained between uses. In order to do that the data needs to be saved to disk in the form of a file. Luckily, reading and writing from files is pretty easy using Python. Let’s begin by opening the interpreter and making a new file like this:

f = open(<path to file/filename>, “w”)

Notice that this immediately creates a file in my file system. I created a text file, but you can add any extension you want to. However, adding a jpg or mov extension won’t automatically make your file an image or a video. Certain file types require special readers and writers to work properly. This method only allows you to save data in readable form, such as text or numbers. I will discuss more advanced methods of file reading and writing in a later post. For now, we’ll stick with the text file.

The open( ) function takes the filepath as its first argument, followed by an optional argument, which in our case was “w”. The “w” stands for write, because we wanted to write a file at the path that we specified. Without the “w” the open function would have errored because the file didn’t already exist on disk. So when creating a new file, use the “w” argument. 

Now we have a blank file open in a file object. Let’s add some text into it using the write( ) method that is built in to our file object.

Remember the “\n” represents an “end of line” character. Now that we’ve added some data to our file object we can close the file using the close( ) method. This will write the data to disk because we invoked the “w” argument when we created the file object.

Now we can re-open our file by using the open( ) function again, but this time we will pass it “r” as a second argument. “r” stands for read and will prevent the file from being modified inadvertently by opening it as a read-only file stream.

Now we can iterate through our file object using a for loop to read the data from it:

If we repeat the for loop we will get nothing.

This is because the file has already been read through and our file “cursor” is sitting at the end of the file. We can confirm this by using the tell( ) method, which tells us what position our cursor is at in the file.

Now we can see that we are at the 103rd position in the file. In order to move the cursor back to the beginning of the file we can use the seek( ) method.

The seek( ) method will set the file cursor to the position specified. Using an argument of 0 will set the cursor back to the beginning of the file.

Now we can invoke a different method to read our file. The read( ) method can be used to assign the entire contents of the file to a variable.

There are lots of methods that can be used on file objects. The last one I’ll talk about is the readline( ) method. This method, as you might guess, reads the file until it finds a newline character “\n”.

Putting it all together

We now have the tools to save information from a program and read it back in again later. There are many ways we can go about this. For instance, let’s pretend we are writing a video game in which our player’s character has different attributes like health, speed, strength, and items. Each time we load our game we can read the attributes from a file, and each time we close the program we can write the data out to a file.

Let’s assume that the file looks something like this:

Name:Bob
Health:50
Strength:10
Speed:5
Handsomeness:2

We could load these lines in using a file object and read through each line to get the attribute and it’s value. Attribute:value should give you an idea of how this data might be stored once we load it into the program. We could load it into a dictionary. We can do this in the following manner:

file = open(“D:/character.txt”,”r”)
character = {}
for line in file:
    attributes = line.split(“:”)
    key = attributes[0]
    value = attributes[1].replace(“\n”,””)
    if key == “Name”:
        character[key] = value
    else:
        character[key] = int(value)

Notice that each value has the newline character “\n” removed before loading. Also, if the item to be loaded is numeric it is converted from a string to an integer using int(value) when being assigned to the dictionary value.

Once the data is loaded into a dictionary it can be manipulated using standard methods.

Then when the program is closed or the user prompts a save if can be written out using a similar method:

file = open(“D:/character.txt”,”w”)
for key in character.keys():
    line = key + ’:’ + str(character[key]) + “\n”
    file.write(line)

file.close()

 

Now the data your programs generate can live on long after your program has been closed. There are many pre-existing methods to read and write files of different types which I will cover in future posts, but for now, go wild with the possibilities inherit in long term data storage and retrieval.