try:
    # Your code here
 except IOError:
    # Handle I/O errors
 except Exception as e:
    # Handle other exceptions
 finally:
    # Cleanup, runs no matter what

class MyCustomError(Exception):
    pass
 
 try:
    raise MyCustomError("A specific error occurred")
 except MyCustomError as e:
    print(e)

try:
    # Attempt operation
 except Exception:
    # Handle error
 else:
    # Executes if no exceptions

try:
    # Some operation
 except Exception as e:
    print(f"Error: {e}")

try:
    # Risky operation
 except (TypeError, ValueError) as e:
    # Handle both exceptions

try:
    # Some operation
 except Exception as original_error:
    raise RuntimeError("Something bad happened") from original_error

from contextlib import suppress
 
 with suppress(FileNotFoundError):
    # Operation that might not find a file

assert condition, "Condition was not met"

import traceback
 
 try:
    raise ValueError("An error occurred")
 except:
    traceback.print_exc() # Print exception information to stderr

import warnings
 
 warnings.warn("This is a warning message", UserWarning)

from contextlManaging Resources: Illustrates creating context managers for resource management, ensuring resources are properly cleaned up after use. The suppress function is shown to ignore specific exceptions.ib import contextmanager, suppress
 
 @contextmanager
 def managed_resource():
    try:
        resource = "Resource"
        yield resource
    finally:
        print("Resource cleanup")
 
 with managed_resource() as res:
    print(res)
 
 with suppress(FileNotFoundError):
    open('non_existent_file.txt', 'r') # Suppresses the FileNotFoundError

from functools import wraps
 
 def exception_handler(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            print(f"Handled exception: {e}")
            return None
    return wrapper
 
 @exception_handler
 def risky_function():
    raise ValueError("Something went wrong")
 
 risky_function()

import sys
 
 try:
    raise TypeError("An error occurred")
 except:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print(exc_type, exc_value)

import inspect
 
 def current_exception():
    for frame in inspect.trace():
        if frame[3] == 'risky_function':
            return frame[0].f_locals.get('e')
 
 try:
    risky_function()
 except Exception as e:
    print(current_exception())

import types
 
 DynamicException = types.new_class('DynamicException', (Exception,))
 raise DynamicException("A dynamically created exception")

import builtins
 
 for name in dir(builtins):
    obj = getattr(builtins, name)
    if isinstance(obj, type) and issubclass(obj, BaseException):
        print(name)

class MyException(Exception):
    def __str__(self):
        return "This is a custom message for MyException"
 
    def __repr__(self):
        return "MyException()"
 
 raise MyException

class MyCriticalError(BaseException):
    pass
 
 try:
    raise MyCriticalError("A critical error")
 except Exception as e:
    print("This will not catch MyCriticalError")

import sys
 
 try:
    while True:
        continue
 except KeyboardInterrupt:
    print("User interrupted the process")
    sys.exit(0)

def my_generator():
    try:
        yield "Hello"
    except GeneratorExit:
        print("Generator closing")
        raise
 
 gen = my_generator()
 next(gen)
 gen.close()