How To Use 'with as' In File Handling, Database Connection And Custom Context Manager Example

Python, celebrated for its clean and readable syntax, provides developers with a wealth of tools to write efficient and elegant code. One such feature that stands out for its versatility and importance is the ‘with as‘ statement. In this article, we’ll explore the intricacies of the ‘with as‘ statement in Python, unraveling its various use cases through practical examples, and demonstrating how it can enhance code readability and resource management.

Table of Contents

1. Understanding the ‘with as’ Statement.

The ‘with‘ statement in Python is primarily used for resource management, ensuring that acquired resources are properly released.

The ‘with as‘ variant goes a step further by allowing the assignment of a name to the result of the ‘with‘ statement.
This can be particularly beneficial in scenarios where the context manager returns a specific object that you want to work with.

2. File Handling with ‘with as’.

One of the most common use cases for the ‘with as‘ statement is in file handling.

When opening a file, the ‘with‘ statement ensures that the file is properly closed after the code block executes, even if an exception occurs.

The ‘as‘ clause allows you to assign the file object a name for easy reference within the block:

def open_file_with_as_example():
    # Traditional file handling without 'with' statement
    file = open('example.txt', 'r')
    content = file.read()
    print(file.closed)
    file.close()
    print(file.closed)

    # Using 'with as' for automatic resource management
    with open('example.txt', 'r') as file:
        content = file.read()
        # Process the file content within this block
        print(file.closed)

    print(file.closed)


if __name__ == "__main__":
    open_file_with_as_example()

Output.
```
False
True
False
True
```

In the second example, the file is automatically closed when the code block is exited, leading to more robust and readable code.

3. Database Connection with ‘with as’.

The ‘with as‘ statement is particularly useful when dealing with database connections.
Python provides modules like SQLite that implement the ‘contextlib‘ module, allowing you to use the ‘with as‘ statement seamlessly.

Example table in SQLite.

CREATE TABLE users (
    id   INTEGER,
    name TEXT
);

The with as statement will not close the connection and cursor object automatically when the code exits the with as block.

import sqlite3

def db_connection_not_auto_close_with_as_example():
    # Traditional database connection handling
    connection = sqlite3.connect('example.db')
    cursor = connection.cursor()
    cursor.execute("SELECT * FROM users")
    data = cursor.fetchall()
    print(data)
    # if you close the db connection manually.
    connection.close()
    # then the below code will throw an error.
    #cursor.fetchall()
    
    conn = None
    cursor = None
    # Using 'with as' for automatic resource management
    with sqlite3.connect('example.db') as conn:
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM users")
        data = cursor.fetchall()
        print(data)

    #cursor.close()
    # you will find the connection and cursor object is not closed automatically outside the above with as block.
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM users")
    data = cursor.fetchall()
    print(data)

if __name__ == "__main__":
    db_connection_not_auto_close_with_as_example()

Output.

[(1, 'Tom'), (2, 'Jerry')]
[(1, 'Tom'), (2, 'Jerry')]
[(1, 'Tom'), (2, 'Jerry')]

But the with as statement will commit the transaction automatically when the code exits the with as block.

The below code insert data (3, ‘Kevin’) into the users table, although the inserted row can be shown in the later code (SELECT * from users) because they are in the same db transaction, but it can not be shown in the SQLite database manager if not run the code connection.commit().

import sqlite3

def db_connection_auto_commit_transaction_with_as_example():
    # Traditional database connection handling
    connection = sqlite3.connect('example.db')
    cursor = connection.cursor()
    cursor.execute("SELECT * FROM users")
    data = cursor.fetchall()
    print(data)

    # if you do not commit the transaction, then the below data will not be inserted into the table.
    cursor.execute("Insert into users(id, name) values(3, 'Kevin')")
    # connection.commit()

    cursor.execute("SELECT * from users")
    data = cursor.fetchall()
    print(data)


if __name__ == "__main__":
    db_connection_auto_commit_transaction_with_as_example()

The below code will insert the row data (6, ‘zhao’) into the table users, when the code exits with as block, it will commit the change to the table automatically, and you can see the inserted row in the db without need to commit manually.

import sqlite3

def db_connection_auto_commit_transaction_with_as_example():
    conn = None
    cursor = None
    # Using 'with as' for automatic resource management
    with sqlite3.connect('example.db') as conn:
        cursor = conn.cursor()
        cursor.execute("Insert into users(id, name) values(6, 'Zhao')")

    cursor.execute("SELECT * from users")
    data = cursor.fetchall()
    print(data)


if __name__ == "__main__":
    db_connection_auto_commit_transaction_with_as_example()

4. Custom Context Managers with ‘with as’.

You can create your own context managers by defining a class with `__enter__` and `__exit__` methods. The ‘with as‘ statement makes it easy to use these custom context managers:

Example source code.

class CustomContextManager:
    def __enter__(self):
        print("Entering the custom context")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the custom context")

def custom_context_manager_use_with_as():
    # Using 'with as' with a custom context manager
    with CustomContextManager() as custom_context:
        print("Inside the custom context")
        # Perform operations within the custom context

    # The '__exit__' method is automatically called when exiting the 'with' block
    print('Outside the "with as" code block')


if __name__ == "__main__":
    custom_context_manager_use_with_as()

Output.

Entering the custom context
Inside the custom context
Exiting the custom context
Outside the "with as" code block

Custom context managers are a powerful tool for encapsulating resource management logic, and the ‘with as’ statement ensures their proper usage.

5. Conclusion.

In this comprehensive guide, we’ve delved into the ‘with as‘ statement in Python, exploring its various applications in file handling, database connections and custom context managers.
By embracing the ‘with as‘ statement, you not only enhance the readability of your code but also ensure proper resource management, reducing the risk of memory leaks and enhancing the overall robustness of your programs.

Whether you are dealing with files, databases, or crafting your own context managers, the ‘with as‘ statement will undoubtedly be an asset in your Python programming toolkit.

How To Use ‘with as’ In File Handling, Database Connection And Custom Context Manager Example

1. Understanding the ‘with as’ Statement.

2. File Handling with ‘with as’.

3. Database Connection with ‘with as’.

4. Custom Context Managers with ‘with as’.

5. Conclusion.

Leave a Comment Cancel Reply