Lazy Programming Series – try and except & File I/O (Input/Output) in Python

In Python, try and except blocks are used for exception handling. Exception handling allows you to gracefully manage errors or exceptions that may occur during the execution of your code.

Here’s a basic syntax of try and except blocks:

In this code:

• The try block contains the code that might raise an exception.
• If an exception of type ExceptionType (or any of its subclasses) occurs within the try block, Python jumps to the except block to handle it.
• If no exception occurs, the except block is skipped.
• You can catch specific types of exceptions by specifying the type after the except keyword. If you want to catch any type of exception, you can simply use except Exception:.

Here’s an example with more detail:

In this example:

If a ZeroDivisionError occurs (which happens when dividing by zero), the first except block is executed, printing “Cannot divide by zero!”.

• If any other type of exception occurs, it’s caught by the second except block, and it prints the error message along with the exception itself.

Exception handling allows your program to handle errors gracefully, preventing it from crashing and providing the opportunity to handle errors in a controlled manner.

File I/O (Input/Output) in Python

File I/O (Input/Output) in Python refers to the process of reading from and writing to files on the filesystem. Python provides built-in functions and methods for performing file I/O operations.

Here are the basic steps for working with files in Python:

1. Opening a File: To open a file, you use the open() function, specifying the file path and the mode in which you want to open the file (e.g., read mode, write mode, append mode, etc.). The basic syntax is:

Reading from a File: After opening a file, you can read its contents using various methods like read(), readline(), or readlines(). For example:

Writing to a File: To write data to a file, you use the write() method. If the file doesn’t exist, Python will create it. If it exists, it will overwrite the existing content. For example:

Appending to a File: If you want to add content to the end of an existing file without overwriting the existing content, you can open the file in append mode (“a”) and use the write() method. For example:

Closing a File: It’s important to close a file after you’re done with it to free up system resources and ensure that all data is written to the file. You can use the close() method for this purpose, or alternatively, use a context manager (with statement) to automatically close the file when you’re done with it:

Handling Errors: It’s important to handle exceptions that might occur during file I/O operations, especially when dealing with real-world scenarios where files may not exist or permissions may be insufficient. You can use try and except blocks for this purpose.

These are the basics of file I/O in Python. It’s essential to handle files carefully, especially when dealing with opening, reading, writing, and closing them, to avoid potential issues like resource leaks or data corruption.