Python's `with` and `async with`, explained

# Without 'with'
file = open('file.txt')
try:
    data = file.read()
finally:
    file.close()

# With 'with' - same thing but cleaner
with open('file.txt') as file:
    data = file.read()
# File automatically closes when we exit the with block

# Without async with
actor = await Actor.initialize()
try:
    # do stuff with actor
    await actor.cleanup()
finally:
    await actor.final_cleanup()

# With async with - same thing but cleaner
async with Actor:
    # do stuff with actor
# Actor automatically cleans up when we exit the block

async def main() -> None:
    async with Actor:  # Actor starts up
        actor_input = await Actor.get_input() or {}
        # ... more code ...
        process.start()
    # Actor automatically shuts down properly here

# Without 'with'
connection = create_connection()
try:
    cursor = connection.cursor()
    cursor.execute("SELECT * FROM users")
    results = cursor.fetchall()
finally:
    connection.close()

# With 'with' - much cleaner
with create_connection() as connection:
    cursor = connection.cursor()
    cursor.execute("SELECT * FROM users")
    results = cursor.fetchall()

# You can manage multiple resources in one with statement
with open('input.txt') as input_file, open('output.txt', 'w') as output_file:
    data = input_file.read()
    output_file.write(data.upper())

import asyncpg

async def get_users():
    # Async database connection
    async with asyncpg.create_pool(database='mydb') as pool:
        async with pool.acquire() as connection:
            async with connection.transaction():
                # Do database operations
                return await connection.fetch('SELECT * FROM users')

from contextlib import contextmanager
import time

@contextmanager
def timer():
    start = time.time()
    yield  # This is where the code inside the 'with' block runs
    end = time.time()
    print(f"Operation took {end - start} seconds")

# Using it
with timer():
    # Some time-consuming operation
    time.sleep(2)

import asyncio

async def worker(lock, number):
    async with lock:  # Only one worker can enter at a time
        print(f"Worker {number} starting...")
        await asyncio.sleep(1)
        print(f"Worker {number} finished!")

async def main():
    lock = asyncio.Lock()
    workers = [worker(lock, i) for i in range(3)]
    await asyncio.gather(*workers)

from contextlib import asynccontextmanager

@asynccontextmanager
async def managed_resource():
    print("Starting up")
    try:
        yield "resource"  # This is what the 'as' variable receives
    finally:
        print("Shutting down")

async def use_resource():
    async with managed_resource() as resource:
        print(f"Using {resource}")

import aioredis

async def cache_operation():
    async with aioredis.from_url('redis://localhost') as redis:
        # Set value
        await redis.set('key', 'value')
        # Get value
        value = await redis.get('key')
        return value

import aiohttp

async def fetch_data(urls):
    async with aiohttp.ClientSession() as session:
        tasks = []
        for url in urls:
            async with session.get(url) as response:
                data = await response.text()
                tasks.append(data)
        return tasks