.. include:: global.rst

======================================
Control Abstraction in Python
======================================

Overview
--------
Control abstraction refers to the use of functions and other structures to
hide complex control flow and allow code to be reused and organized more
effectively. Instead of repeating logic, developers encapsulate behavior
into callable units.

Functions
---------
Functions are the primary mechanism for control abstraction in Python.

- Defined using the ``def`` keyword
- Can take parameters and return values
- Help break programs into modular, reusable pieces

Example::

    def greet(name):
        return f"Hello, {name}!"

    print(greet("Alice"))

Benefits:
- Code reuse
- Improved readability
- Easier debugging and maintenance

Lambda Functions
----------------
Lambda functions are small, anonymous functions defined using the ``lambda`` keyword.

Example::

    add = lambda x, y: x + y
    print(add(2, 3))

Use cases:
- Short, simple operations
- Often used with functions like ``map()``, ``filter()``, and ``sorted()``

Higher-Order Functions
----------------------
A higher-order function is a function that:
- Takes another function as an argument, or
- Returns a function as a result

Example::

    def apply_function(func, value):
        return func(value)

    def square(x):
        return x * x

    print(apply_function(square, 5))

Built-in examples:
- ``map()``
- ``filter()``
- ``reduce()`` (from ``functools``)

Closures
--------
A closure is a function that remembers values from its enclosing scope
even after that scope has finished executing.

Example::

    def outer(x):
        def inner(y):
            return x + y
        return inner

    add_five = outer(5)
    print(add_five(3))  # Output: 8

Decorators
----------
Decorators are functions that modify the behavior of other functions
without changing their code.

Example::

    def my_decorator(func):
        def wrapper():
            print("Before function call")
            func()
            print("After function call")
        return wrapper

    @my_decorator
    def say_hello():
        print("Hello!")

    say_hello()

Summary
-------
Control abstraction in Python allows developers to:
- Simplify complex logic
- Promote code reuse
- Improve readability and structure

Key tools include:
- Functions
- Lambda expressions
- Higher-order functions
- Closures
- Decorators