def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs) # Call the original function
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f}s")
        return result
    return wrapper

# Apply the decorator using @
@timer
def slow_function():
    import time
    time.sleep(1)
    print("Done")

slow_function()
# Output:
# Done
# slow_function took 1.0012s

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a      # Pause here and return 'a'
        a, b = b, a + b

# Usage
for num in fibonacci(10):
    print(num)

# Generator Expression (Like list comp, but with parenthesis)
# This takes almost 0 memory, even for 1 million items!
squares = (x**2 for x in range(1000000))

# The 'with' statement ensures f.close() is called
# even if an error happens inside the block.
with open("file.txt", "w") as f:
    f.write("Hello")

# Creating a custom Context Manager
from contextlib import contextmanager

@contextmanager
def database_connection():
    print("Connecting...")
    yield "db_conn"
    print("Closing...") # This runs after the 'with' block ends

with database_connection() as db:
    print(f"Using {db}")

import asyncio

# Define a coroutine with 'async def'
async def fetch_data(id):
    print(f"Fetching {id}...")
    await asyncio.sleep(1) # Simulate I/O wait (non-blocking)
    print(f"Done {id}")
    return {"id": id}

async def main():
    # Run tasks concurrently!
    # This will take ~1 second total, not 3.
    results = await asyncio.gather(
        fetch_data(1),
        fetch_data(2),
        fetch_data(3)
    )
    print(results)

if __name__ == "__main__":
    asyncio.run(main())

from typing import List, Dict, Optional, Union, Callable

# A list of integers
def process_items(items: List[int]) -> Dict[str, int]:
    return {"sum": sum(items)}

# Optional: Can be string OR None
def find_user(id: int) -> Optional[str]:
    return "Alice" if id == 1 else None

# Union: Can be int OR float
Number = Union[int, float]

def add(a: Number, b: Number) -> Number:
    return a + b