Python Files and Exception

February 03, 2024•6 min read

Python provides robust file handling capabilities, allowing for the manipulation of file content, such as reading and writing. Unlike other programming languages where file handling can be complex, Python simplifies the process, offering straightforward and concise code. In Python, files are classified as either text or binary, a crucial distinction since it affects how the data is processed. Text files are composed of character sequences, where each line typically ends with an End of Line (EOL) character, like a comma (,) or a newline. These EOL characters signify the end of one line and the beginning of the next.

To start working with a file, you need to open it using Python's built-in open() function. This function requires the file's name and a mode that specifies the file's intended use:

f = open(filename, mode)

The mode can be:

r: Opens a file for reading.
w: Opens a file for writing. If the file exists, its content is overwritten. If the file doesn't exist, a new file is created.
a: Opens a file for appending. Data is added to the end of the file without altering the existing content.

Reading from a File

To read from a file in Python, you have several options:

Read the Entire File: Using file.read() reads the whole file content.

file = open("sample.txt", "r") 
print(file.read())
# Output: The entire content of the file.

Read Line by Line: Iterate over the file object to read line by line.

file = open('sample.txt', 'r')
for line in file:
    print(line)
# Output: Each line of the file printed one by one.

Using thewith Statement: This ensures that the file is properly closed after its suite finishes, even if an exception is raised.
```
with open("sample.txt") as file:  
    data = file.read() 
print(data)
# Output: The entire content of the file.
```
Reading Specific Characters: By providing a number to the read() function, you can control the number of characters to be read.
```
file = open("sample.txt", "r")
print(file.read(5))
# Output: First five characters of the file.
```
Reading and Splitting Lines: The readlines() function reads all the lines and returns a list. You can iterate through this list and use the split() function to split each line as needed.
```
with open("sample.txt", "r") as file:
    lines = file.readlines()
    for line in lines:
        words = line.split()
        print(words)
# Output: Each line split into words.
```

Writing to a File

Writing to a file is also straightforward:

Writing Text: Using write() writes the specified text to the file. If the file doesn't exist, it will be created.

file = open('sample.txt', 'w')
file.write("Sample text")
file.close()
# The text "Sample text" is written to the file.

Appending Text: In append mode, text is added at the end of the file without changing the existing content.

file = open('sample.txt', 'a')
file.write("Additional text")
file.close()
# The text "Additional text" is appended to the file.

Python also offers other utility functions for file handling, such as rstrip() to remove trailing spaces, and lstrip() for leading spaces. These tools enhance Python's file manipulation capabilities, making it an efficient choice for file operations.

Moreover, Python provides a comprehensive suite of file handling functions, as demonstrated in a comprehensive example where a file is created, read, appended, renamed, and finally deleted, showcasing the language's capability to handle various file operations efficiently and intuitively.

Exception:

Now we delve into the nuances of managing exceptions in Python, spotlighting the utilization of try, except, and finally constructs, complemented by illustrative examples.

Python categorizes errors into two distinct varieties: Syntax Errors and Exceptions. Syntax errors, often syntaxical missteps in the code, prompt an immediate halt in program execution. Exceptions, however, surface during runtime when unexpected internal events disrupt the program's standard flow.

Python is equipped with a plethora of built-in exceptions, triggered upon encountering specific errors during execution. Among these, prominent exceptions include:

SyntaxError: Triggered by syntax mishaps like incorrect keyword spelling, missing colons, or mismatched parentheses.
TypeError: Occurs when an operation or function is applied incompatibly, such as mixing a string with an integer.
NameError: Arises when a variable or function name is unrecognizable within the current scope.
IndexError: Happens when an attempt is made to access an index outside the permissible range of a list, tuple, or other sequence types.
KeyError: Surfaces when a non-existent key is accessed in a dictionary.
ValueError: Emanates when a function or method receives an argument that is invalid in the given context.
AttributeError: Triggered when an attribute or method is not found within an object instance.
IOError: Occurs during input/output operations if an error is encountered.
ZeroDivisionError: Emanates from dividing a number by zero.
ImportError: Happens when an import statement cannot locate or load a specified module.

Correctly managing these exceptions is crucial to ensuring smooth program execution, typically achieved through try-except blocks or other error-handling techniques.

Contrasting Syntax Errors with Exceptions:

Syntax Errors: Stem from incorrect code syntax, leading to program termination. For instance, a syntax error occurs if an 'if' statement lacks a colon (:) or a 'print' statement isn't properly indented within the 'if' block.

amount = 10000
if(amount > 2999)  # Missing colon
print("Eligible for purchase")  # Improper indentation

Exceptions: Emerge even from syntactically correct code when certain conditions lead to errors, altering the standard program flow but not necessarily halting execution.

marks = 10000
a = marks / 0  # Division by zero, raises ZeroDivisionError
print(a)

A fundamental class, Exception, serves as the base for all exceptions in Python. The hierarchy of exceptions can be explored further in Python documentation.

Illustrating Exception Handling:

TypeError Example: A TypeError arises when operations involve mismatched data types, like adding a string to an integer. Employing try-except blocks can gracefully manage such errors.

x = 5
y = "hello"
try:
    z = x + y
except TypeError:
    print("Error: cannot add an int and a str")

Try-Except for Catching Exceptions: The try-except structure is pivotal in Python for capturing and handling exceptions. Code segments prone to exceptions are placed within the try block, while the corresponding handlers reside in the except block.

a = [1, 2, 3]
try: 
    print ("Second element = %d" %(a[1]))
    print ("Fourth element = %d" %(a[3]))  # IndexError expected
except:
    print ("An error occurred")

Catching Specific Exceptions: Python allows for multiple except clauses within a try block to address different exceptions distinctly, ensuring that only one relevant handler is executed.

try:
    # Some code
except IndexError:
    # Handle IndexError
except ValueError:
    # Handle ValueError

Usage of Else and Finally: Python's try-except can be augmented with an else clause, executed if no exceptions are raised. The finally block, however, is always executed, serving as a cleanup segment, irrespective of prior exceptions.

try:
    k = 5 // 0
except ZeroDivisionError:
    print("Can't divide by zero")
finally:
    print('This is always executed')

Raising Exceptions: Python empowers developers to intentionally trigger exceptions using the raise statement. This can be a specific exception instance or class.

In summary, mastering exception handling in Python, characterized by the try, except, finally paradigm, is instrumental for building robust and error-resilient applications. This guide not only outlines the fundamental exception types but also demonstrates practical strategies for managing and preempting these exceptions effectively.

sunil s

Quant Developer & Mentor

Back to Blog