File handling Revision Notes

When a program runs, it often needs to use data that should remain available even after the program stops. Storing data in files allows this persistence because files are saved on non-volatile storage devices like hard drives or SSDs. Unlike variables stored in RAM, which lose their values when the computer is turned off or the program ends, files keep data intact until explicitly changed or deleted.

For example, a student record system saves student details in a file so that the information is still available the next day when the program is run again. Without files, all data would be lost once the program closes, requiring re-entry every time.

• Files provide long-term storage of data beyond program runtime.
• Non-volatile storage ensures data is not lost when power is off.
• Variables in memory are temporary and cleared after program ends.

Files allow data to be stored in a structured way, such as lines of text or records, which makes it easier for programs to find and use specific pieces of information. Organised data can be read sequentially or accessed randomly depending on the file type and program design.

For instance, a program that manages a library catalogue might store each book’s details on a separate line in a text file. This organisation helps the program quickly locate a particular book’s information without scanning unrelated data.

This structure also supports data manipulation, such as updating, deleting, or adding records, by reading and rewriting parts of the file as needed.

• Structured files enable targeted data retrieval.
• Organisation reduces complexity when searching or modifying data.
• Supports operations like reading, updating, and appending data efficiently.

Loading all data into a program’s memory at once can be inefficient or impossible if the data is large. Files allow programs to read only the necessary data when needed, reducing memory consumption and improving performance.

For example, a video game might store player statistics in a file and load only the current player’s data into memory during gameplay, rather than loading all players’ data at once.

This selective access is crucial for programs running on devices with limited memory or when handling large datasets.

• Files enable partial data loading to save memory.
• Improves program speed by avoiding unnecessary data processing.
• Essential for handling large or multiple datasets efficiently.

Storing data in files is fundamental for programs that require data to be saved permanently, organised logically, and accessed efficiently. Understanding this helps in designing programs that manage data effectively, avoid data loss, and perform well.

When writing programs, consider what data needs to be persistent, how it should be structured in files, and how to access it without overloading memory. This approach leads to robust and user-friendly software.

• Files ensure data is saved and available for future use.
• Proper file organisation simplifies program design and maintenance.
• Efficient file handling optimises resource use and program responsiveness.

Before a program can access data stored in a file, it must open the file. Opening a file establishes a connection between the program and the file stored on disk or other storage media.

Files can be opened in different modes depending on the intended operation:

Read mode ('r'): Opens an existing file to read its contents. The file must exist; otherwise, an error occurs. No writing is allowed in this mode, and the file pointer starts at the beginning of the file. Example: opening 'data.txt' to read stored scores line by line for processing in a program.

• Opening a file in read mode allows data retrieval but prevents modification.
• Opening a file in write mode ('w') creates a new file or overwrites an existing one, allowing data to be written.
• Append mode ('a') opens a file to add data at the end without deleting existing content.

After completing operations on a file, it is essential to close it. Closing a file ensures that all data buffered in memory is properly saved to the storage device and that system resources are freed for other processes.

Failing to close a file can lead to data loss, corruption, or resource leaks, which may cause a program or system to behave unpredictably.

Example: After writing new user information to 'users.txt', closing the file guarantees that the data is fully saved and the file is no longer locked by the program.

• Always close files after finishing reading or writing.
• Use commands or functions specific to the programming language to close files.
• Some languages automatically close files when the program ends, but explicit closing is best practice.

Reading from a file can be done at different granularities: individual data items or entire lines of text.

Reading individual data items involves extracting specific pieces of data, such as numbers or words, often separated by delimiters like spaces or commas.

Reading lines involves retrieving a whole line of text at once, which is useful for processing structured data line by line, such as records in a CSV file or paragraphs in a text document.

• Use functions or methods to read one line at a time, which returns the line as a string including or excluding the newline character.
• To read individual data items, parse the line by splitting it based on delimiters.
• Example: Reading a line '23,45,67' and splitting it by commas to get three separate numbers.

Writing to a file can also be done by outputting individual data items or entire lines of text.

When writing individual items, the program may convert data types to strings and add delimiters to separate items.

Writing lines involves outputting a complete string followed by a newline character to ensure data is stored in a readable format line by line.

• Writing overwrites existing content if the file is opened in write mode, or appends if opened in append mode.
• Example: Writing a list of scores to a file, each on a new line, to preserve readability and structure.

Consider a program that reads a file 'scores.txt' containing student scores, calculates the average, and writes the result to 'average.txt'.

Steps: 1) Open 'scores.txt' in read mode. 2) Read each line, convert the text to numbers, and accumulate the total and count. 3) Close 'scores.txt'. 4) Calculate the average by dividing total by count. 5) Open 'average.txt' in write mode. 6) Write the average as a line of text. 7) Close 'average.txt'.

This example demonstrates opening files for reading and writing, reading individual data items (scores), writing a line of text (average), and closing files properly.

• Always check if files open successfully before proceeding.
• Handle possible errors such as missing files or permission issues.