Files

Tasks

1. Complete reading this lesson, which involves the following:
   1. Introduction
   2. Reading a file
   3. Writing in a file
   4. Working with binary files
2. Complete quiz 9 to verify your reading and understanding.
3. Read and complete the activities at Zybook, Z10: Files.

Learning Outcomes

By the end of this lesson, you should be able to:

1. Describe the difference between text files and binary files.
2. Use modes in programs to open a file for appropriate filing operations.
3. Write loops to read data from a file.
4. Write loops to write data into a file.

Key Terms/Concepts

• File, Binary files, text files, with, close, end-of-file, mode.

Introduction

Files provide the functionality to store data on a disk. Computers have two kinds of storage for saving data. One is Random Access Memory (RAM) and the other is a disk, which is also called a hard drive.

RAM has the following characteristics:

• It is a volatile memory, which means that the data on the RAM is lost as soon as the computer is turned off.  
• It is very fast to access compared to a disk. It is also called working memory. Any program or software that you are using on your computer like Microsoft Word, Adobe Illustrator, and browser is first loaded into the RAM and is then executed from there. This is the reason why it takes more time to open a software as compared to working with it once it has been loaded in the RAM.
• It has a much smaller space as compared to a disk.
• It is expensive.

A hard drive or a disk has the following features:

• It is a persistent storage and is not volatile. Anything stored on a disk is preserved when the computer is turned off and can be accessed again by turning on the computer.
• It is slower to access.
• It has a large space.
• It is cheaper.

Installing software like Eclipse stores it on the disk on your computer. When you open Eclipse for writing programs, it is loaded from the disk to the RAM (working memory), and it is executed from there. It remains in the RAM as long as you are using it, and once you close Eclipse, it can be removed from the RAM to make space for other software. It takes longer to start Eclipse, as it is on the disk initially (slower) and it is being loaded in the RAM, but it works interactively when it is open as it is present in the RAM (faster).

When you write a program, it is being stored in the RAM as you code. Once you save the program by specifying a file name, it is written on the disk. That is why you can access your programs even after you have shut down the computer and restarted it.

In this lesson we will learn how we can work with the files. The files store the data, and the directories are used to maintain a hierarchical scheme to save files. Hierarchical structure helps users organize the files.

10.1.1 Key Concepts

Let's look at a real life scenario that we can use to understand filing and its key concepts.

Consider you went on a trip with your family over the summers to see the Great Pyramids in Egypt. On your return, your parents ask you and your younger sister Maria to co-produce a writeup on your journey, so that it can be shared with your grandparents. Your younger sister decides to make the first draft that you can proof read and modify later.

Below is the sequence of events that took place.

There are some important technical points to note from the last column.

1. Files have a path that you need to access them.
2. You need to open a file before reading or writing into it. The mode for opening (read, write etc.) is mentioned while opening the file.
3. Any file that you opened MUST be closed. You can end up with some of your text missing from the file or issues with accessing your file from outside the program if you do not properly close the file.
4. The contents of the file are overwritten when you open a file for writing.
5. If you plan to add or modify to what you already have in a file, you need to open a file for appending (mode: append).

10.1.2 Key Syntax

While working with the files, programmers first need to open the file by specifying the path, the name, and the mode of opening. The following function is used in Python:

file_object = open('C:\\trip\\pyramids.txt', 'r')

file_object is the name of the variable that references the file object. It can be used toperform filing operations. open is the built-in function that is used for opening a file. Two arguments are passed to the function. The first parameter specifies the path (C:\\trip\\) and the filename (pyramids.txt) of the file to open, whereas the second one specifies the mode. r means the file will be opened for reading only.

There are modes to perform reading and writing simultaneously, but they are outside the scope of this lesson. The rest of the modes are listed below:

As explained earlier, any file that is opened, whether it is for reading, writing or appending, must be closed. The following syntax can be used to close an open file.

file_object.close()

Reading a File

In this section, we will learn about reading and processing data from a text file. The following functions are commonly used for reading data.

10.2.1 Reading a Text File

Code Listing 1 shows a simple program that reads the same file thrice using three different methods and displays the content on the console.

 # Program Name: Prog 10-01
 # This program is part of Lesson 10 of the course 
  
 def read_all (file_obj):
        contents = file_obj.read()
        print (contents)
        print ("*** Printing Ends ***")
    
 def read_line (file_obj):
        line = file_obj.readline()
        print(line)
        
        line = file_obj.readline()
    print(line)
    
        line = file_obj.readline()
    print(line)
    print ("*** Printing Ends ***")

def read_list (file_obj):
    a_list = file_obj.readlines()
    print(a_list)
    print ("*** Printing Ends ***")

2 def main ():
    file_object = open("code_listing_1.txt", 'r')
    read_all(file_object)

    file_object.seek(0)
30.         read_line(file_object)
3   
3       file_object.seek(0)
3       read_list(file_object)
3  
3       file_object.close()
3 main()

The text file that we use in this program is named code_listing_1.txt and it is present in the same directory where the Python program is saved too. The file is given below:

First line of text
Second line of text
Third line of text

It is important to note the following points about code_listing_1.txt:

• This file was created using the Notepad program. Enter (return) key was used to start a new line after the first line and the second line ends. Therefore \n is present after line 1 and line 2
• \n is not displayed, but it is stored as part of the file. It is used for line breaks when displaying the file.
• Enter was not pressed after the third line. So there is no \n after the third line.

Internally the file looks like:

First line of text\n
Second line of text\n
Third line of text

Prog 10-01 has four functions. The main function opens and closes the file, whereas the rest of the three functions print the contents of the file using three different methods.

The output of the program is given in Console 1. Let's go through the code line by line.

First line of text
Second line of text
Third line of text
*** Printing Ends ***
First line of text

Second line of text

Third line of text
*** Printing Ends ***
['First line of text\n', 'Second line of text\n', 'Third line of text']
*** Printing Ends *** 

We have noticed that there are unwanted newlines when we read a file using the readline method. This can be solved by removing the \n at the end of the string. The following code can help us achieve that.

    line = file_obj.readline()
    line = line.rstrip("\n")
    print(line)

We can also overwrite the default behaviour of print to not initiate a new line at the end of printing:

    print(line, end='')

10.2.2 Using Loops for Reading Data

The data in a file can be read conveniently using the for and the while loops. The data is often present as multiple lines of text. The read_line function in Prog 10-01 reads one line of data from the file at a time. It seems readline and readlines functions are ideally suited to extract data using a loop.

For Loop

Prog 10-02 in Code Listing 2 reads the data from code_listing_1.txt line by line. The first word of each line is then capitalized and displayed through string processing.

 # Program Name: Prog 10-02
 # This program is part of Lesson 10 of the course 
  
 def main ():
        file_object = open("code_listing_1.txt", 'r')
    
        for line in file_object:
            ind = line.index(' ')
            str = line[:ind]
            str = str.capitalize()
            print(str)
        file_object.close()
  
1 main()

The text file is opened in read only mode. A for loop is called with a target variable named line. The file object called file_object is used in the loop header. The for loop extracts one line of text from the text file in each iteration of the loop. The line of text is assigned to the variable line as a string.

Inside the loop body, the index position of the first occurrence of space is extracted using the index function and is assigned to the variable ind. The value of ind will be 5 for the first and the third iteration and 6 for the second iteration of the loop. The ind is used to slice the string, and the resulting substring is assigned to str. str is then capitalized and displayed on the console using the print function.

The output of Prog 10-02 is shown in Console 2 below.

First
Second
Third

While Loop

While loops are moregeneral purpose loops, and therefore programmers need to put in the termination condition to end the loop.

We will take the same file that we used in the last two programs and read it twice using the while loop. The data is extracted using the readline method first, and then using the readlines method. Prog 10-03 in Code Listing 3 shows the code.

 # Program Name: Prog 10-03
 # This program is part of Lesson 10 of the course 
  
 def read_data1 (file_obj):
        print("***Read Data 1***")
        line = file_obj.readline()
        while line != '':
            line = line.rstrip("\n")
            print(line.capitalize(), end=".\n")
            line = file_obj.readline()
  
 def read_data2 (file_obj):
        print("***Read Data 2***")
    lines = file_obj.readlines();
    ind = 0
    while (ind < len(lines)):
        line = lines[ind]
        line = line.rstrip("\n")
        print(line.capitalize(), end=".\n")
            ind += 1

2 def main ():
    file_object = open("code_listing_1.txt", 'r')

    read_data1 (file_object)
    file_object.seek(0)
    read_data2 (file_object)

    file_object.close()
30.     
3 main()

The main function opens the file (code_listing_1.txt) in read only mode, calls the read_data1 function and passes the file object. Once the read_data function has been completely executed, it is expected that the file position has been changed. The position is reset to zero before calling the read_line2 function. The file is closed before the program ends.

The line by line description of read_line1 is given below:

The line by line description of read_line2 is given below:

The output of Prog 10-03 is shown in Console 3.

***Read Data 1***
First line of text.
Second line of text.
Third line of text.
***Read Data 2***
First line of text.
Second line of text.
Third line of text.

10.2.3 Comma Separated Values

Files with comma separated values (csv) are commonly used when dealing with numeric data. Data elements in csv are separated by commas from each other. A csv file named code_listing_4.txt is shown below:

Quizzes,10,5,5,8,9
Assignments,10,10,9,7
Activities,5,5,10,10,10,9,9,8,7

We want to write a program to calculate the average of the data in each line of the file. Prog 10-04 shown in Code Listing 4 extracts each line of data, and then calculates the average of all the values except the first one.

 # Program Name: Prog 10-04
 # This program is part of Lesson 10 of the course 
  
 def main ():
        file_object = open("code_listing_4.txt", 'r')
        for line in file_object:
            line = line.rstrip('\n')
            a_list = line.split(',')
        
            print(f"Average of {a_list[0]}", end = ':')
            ind = 1
            total = 0
  
        while ind < len(a_list):
            total += int(a_list[ind])
            ind += 1
    
        ind -= 1
        average = total / ind   
            print(f"{average:.2f}")
    file_object.close()

main()

Let's go through the code line by line:

Iteration 1: ind = 1, total = 10
Iteration 2: ind = 2, total = 15
Iteration 3: ind = 3, total = 20
Iteration 4: ind = 4, total = 28
Iteration 5: ind = 5, total = 37

The output of Prog 10-04 is shown below:

Average of Quizzes:7.40
Average of Assignments:9.00
Average of Activities:8.11

Writing a File

The two most important tasks in filing are the ability to read a file and to write a file. In this section we will learn how we can write data into the text files. Two modes are used for opening a file for writing.

Mode 'a', which stands for append, is used when you want to add more contents to a file without deleting it. An example can be a Word document. You may start writing a report and later on you might want to take a break and then begin from where you left off.

Mode 'w' stands for write. When a file is opened in this mode, any contents that exist in the file are overwritten. Examples of its use cases can be a file that stores the highest score of a game or a file that contains the application's settings.

10.3.1 with Keyword

We have already discussed that it is not uncommon to forget to close a file that was opened by a programmer. The Python language provides a with keyword which automates the closing of an open file. A file is opened using the with keyword and the file remains open only in the body of the with block. As soon as the program execution leaves the with block, the file is automatically closed by the Python Interpreter.

Following syntax is useful when writing into the files or when using the with keyword:

In Prog 10-05 we demonstrate the file writing as well as the use of with keyword.

The program asks the user to write a story which is being saved line by line as the user writes. Later on the story is displayed back on the console for proof reading.

 # Program Name: Prog 10-05
 # This program is part of Lesson 10 of the course 
  
 def main ():
        file_object = open("code_listing_5.txt", 'w')
  
        print("Write your story:")
        bytes_written = 0
        str_input = ""
 
        while (str_input != "exit"):
            str_input = input(" ")
            bytes_written += file_object.write(str_input + '\n')

    file_object.flush()
    file_object.close()

    print(f"\nBytes Written: {bytes_written:d}")

        print("\nProof read your story")

    with open('code_listing_5.txt', 'r') as file_obj:
        list_of_lines = file_obj.readlines()

    for line in list_of_lines:
        print(line, end = '')

main() 

The line by line explanation of the code is given below:

The output of the code is given in Console 5.

Write your story:
 Very Short Story:
 Once upon a time there was a child.
 He wanted to become a programmer. He took admission at WLU.
 On track to start writing code soon!
 exit

Bytes Written: 156

Proof read your story
Very Short Story:
Once upon a time there was a child.
He wanted to become a programmer. He took admission at WLU.
On track to start writing code soon!
exit 

Conclusion

In this lesson we learnt how to read and write data into text files and in binary files. Several methods for reading data were discussed and the with keyword was also introduced. The assignment will reinforce the concepts covered in this lesson and in the textbook.

We hope you are ready to attempt this week’s assessments. They are available on MyLearningSpace. You are encouraged to consult the syllabus for clarity about the deadlines for preparation activities, quizzes, and assignments. Please regularly visit MyLearningSpace for announcements, course material, and discussion boards.