Welcome! Today, we will manage exceptions within Python functions, much like an astronaut tackling obstacles in space. We will delve into the concept of functions, acquaint ourselves with the handling of exceptions, and investigate their operation during function calls.

Let's take a moment to recap: An exception, an error that can lead to a program crash, can be disruptive. However, a Python function can attempt certain tasks and catch potential exceptions using a try-except-finally block. This is similar to an astronaut preparing for potential hurdles. Below is an illustration:

def safe_division(x, y):
    try:
        return x / y
    except ZeroDivisionError:
        print("Warning: Division by zero!")

This function monitors for a ZeroDivisionError when performing division.

The raise keyword in Python triggers an exception manually within a function. Consider a function that calculates a square root — an error should occur if the input is negative!

def safe_sqrt(x):
    if x < 0:
        raise ValueError("Can't compute square root of a negative number.")
    else:
        return x ** 0.5

An exception is raised if a negative input is detected.

The code that calls a function handles any possible exceptions that the function might throw. This is illustrated as follows:

def call_sqrt():
    try:
        print(safe_sqrt(-1))
    except ValueError as e:
        print("Abort mission! Error:", e)

In this scenario, exceptions raised in safe_sqrt are captured in call_sqrt.

Exceptions can migrate from one function to another. In nested calls, a raised exception gets passed up the chain; for instance, if fun2 raises exceptions and the except block does not handle them, they're forwarded to fun1.

def fun1():
    try:
        fun2() # throws ExceptionType
    except ExceptionType2: # handling a different exception type
        # Handle exception

In this scenario, fun1() might throw ExceptionType if it occurs, as it's not handled by the except block.