Functions

A Function is a named, organized block of reusable code that performs a single, specific task. Functions are defined using the `def` keyword:

def calculate_cylinder_volume(radius, height):
    """Calculates the geometric volume of a cylinder.
    
    Parameters:
        radius (float): Radius of the circular base.
        height (float): Perpendicular height of cylinder.
    Returns:
        float: Calculated volume (pi * r^2 * h).
    """
    import math
    volume = math.pi * (radius ** 2) * height
    return volume  # Explicit return statement

The `return` Statement Mechanics

• Terminates function execution immediately and passes values back to the caller.
• Returning Multiple Values: A function can return multiple values separated by commas. Python automatically bundles them into an immutable tuple:

  def min_max(numbers):
      return min(numbers), max(numbers)  # Returns tuple (min_val, max_val)
  
  low, high = min_max([4, 1, 9, 2])     # Tuple unpacking!

• Void Functions: If a function reaches the end of its body without executing a `return` statement (or executes a bare `return`), it implicitly returns the special literal `None`.

When calling a function, values are passed as actual arguments matching formal parameters:

1. Positional Arguments: Arguments passed in exact sequential order from left to right. The number and positions of arguments must match the parameter signature exactly.
2. Default Arguments: Parameters initialized with a default fallback value in the function header. If the caller omits that argument, the default is used:

   def greet(name, msg="Welcome to TargetExams"):
       print(f"Hello {name}, {msg}!")
   
   greet("Aarav")                          # Uses default msg
   greet("Sneha", "Congratulations!")      # Overrides default msg

   Golden Syntax Rule: Non-default parameters must NEVER follow default parameters in a function signature!
   def func(a=10, b): # SYNTAX ERROR! SyntaxError: non-default argument follows default argument
3. Keyword (Named) Arguments: The caller explicitly specifies the parameter name during invocation: `func(param=val)`. Keyword arguments can be supplied in any order:

   def divide(dividend, divisor):
       return dividend / divisor
   
   print(divide(divisor=4, dividend=20))   # Perfectly legal! Output: 5.0

The Scope of a variable defines the region of program text where that variable is recognized and accessible. The Lifetime is the duration of time that variable resides in memory:

• Local Scope: Variables created inside a function. Created when function is invoked; destroyed immediately upon function return. Inaccessible from outside the function.
• Global Scope: Variables created at the top-level module indentation. Accessible anywhere within the module file.

The LEGB Name Resolution Rule

When a variable name is referenced, Python searches four concentric namespaces in strict order:

1. L (Local): Names assigned inside the currently executing function frame.
2. E (Enclosing): Names in the local scope of any enclosing outer functions (closures).
3. G (Global): Names defined at the top-level module file.
4. B (Built-in): Pre-assigned standard Python library names (`print`, `range`, `len`, `int`).

The `global` Keyword

If you assign to a variable inside a function, Python automatically treats it as a brand-new local variable, shadowing any global variable with the same name. To modify a global variable from within a function, you must explicitly declare it with `global`:

counter = 0

def increment():
    global counter  # Tells Python to bind to module-level 'counter'
    counter += 1

increment()
print(counter)      # Outputs 1

Python uses Pass-by-Object-Reference (also called Call-by-Sharing). When an argument is passed to a function, the function's formal parameter is bound to the exact same heap memory object as the caller's actual argument:

def mutate_list(lst):
    lst.append(999)  # Modifies caller's list in-place!

nums = [1, 2, 3]
mutate_list(nums)
print(nums)          # Outputs: [1, 2, 3, 999] (Caller's list was mutated!)