File Handling in Python Class 12 Notes and Solutions

Comprehensive Guide to File Handling in Python for Class 12 Students

File handling in Python is an essential skill, especially for Class 12 students learning to manage data efficiently. This guide offers a detailed exploration of file handling concepts, techniques, and best practices.

Introduction to File Handling in Python

File handling refers to the process of creating, opening, reading, writing, and closing files. It is a fundamental aspect of programming that allows you to maintain and manipulate data for various applications.

Types of Files in Python

Text Files

Text files contain human-readable characters. Examples include .txt, .py, and .csv files. They are easily accessible using any text editor.

Binary Files

Binary files consist of non-human-readable characters and symbols and often hold data like images, audio, videos, and executable files.

Opening and Closing a Text File

Using the open() Function

To open a file in Python, use the open() function with the syntax:

file_object = open(file_name, access_mode)

This function returns a file object, which you can use to perform various file operations.

Closing Files

It’s crucial to close a file after operations to free up system resources. Use the close() method:

file_object.close()

Writing to a Text File

Using the write() Method

The write() method writes a single string to a file:

file_object.write("Hello, World!\n")

Using the writelines() Method

For writing multiple strings, use the writelines() method:

lines = ["Line1\n", "Line2\n"]
file_object.writelines(lines)

Reading from a Text File

Using the read() Method

This method reads a specified number of bytes from a file:

content = file_object.read(10)

Using the readline() Method

The readline() method reads one complete line from a file:

line = file_object.readline()

Using the readlines() Method

The readlines() method reads all the lines in a file and returns them as a list:

lines = file_object.readlines()

Understanding File Access Modes

Different access modes control how a file is opened and manipulated:

• r: Read-only mode.

• w: Write-only mode. Overwrites the file if it exists or creates a new one.

• a: Append mode. Writes data at the end of the file.

• r+: Read and write mode.

• w+: Write and read mode. Overwrites the file if it exists or creates a new one.

• a+: Append and read mode.

Creating and Traversing a Text File

Creating a New File

To create a file, use the open() method with "w" mode:

file_object = open("newfile.txt", "w")

Traversing a File

To traverse and read from a file:

file_object = open("newfile.txt", "r")
line = file_object.readline()
while line:
    print(line)
    line = file_object.readline()
file_object.close()

Setting Offsets in a File

Using the tell() Method

This method returns the current file object position:

position = file_object.tell()

Using the seek() Method

The seek() method moves the file object to a specified position:

file_object.seek(10, 0)

Working with Binary Files

Understanding how to handle binary files is crucial for dealing with non-text data like images or video. Binary files are accessed using similar methods but in binary mode ("rb", "wb" etc.).

The Pickle Module

The Pickle module is used for serialising (pickling) and de-serialising (unpickling) Python objects, making it possible to save complex data types like lists and dictionaries.

The dump() Method

This method serialises Python objects into a binary file:

import pickle
data = {"name": "John", "age": 30}
with open("data.pkl", "wb") as file:
    pickle.dump(data, file)

The load() Method

To deserialise and read data:

with open("data.pkl", "rb") as file:
    data = pickle.load(file)

Exception Handling in File Operations

It's essential to manage exceptions to prevent your program from crashing due to file operation errors. Using try-except blocks will help:

try:
    file_object = open("file.txt", "r")
    content = file_object.read()
    file_object.close()
except FileNotFoundError:
    print("File not found.")

Summary and Best Practices

To summarise, file handling in Python involves several key operations: opening, reading, writing, closing files, and managing data types. Best practices include:

• Always close files after operations

• Use the with statement for better resource management

• Handle exceptions to make your code robust

By mastering these file handling techniques, Class 12 students can efficiently manage data in their Python applications.

This guide offers a thorough understanding of file handling in Python, equipping students with the knowledge to perform advanced file operations and manage data effectively.

Key Concepts Flowchart

This flowchart summarises the basic flow of file handling operations in Python. It shows how you can open a file, either read or write to it, and then close the file, ensuring proper file management.

By following this comprehensive guide, students will gain a solid foundation in file handling, preparing them for more complex programming projects and professional development.