Higher Order Functions in Python — map, filter, reduce and Beyond

# Demonstrating that functions are first-class objects in Python

def apply_discount(price):
    """Returns the price after a 10% discount."""
    return round(price * 0.90, 2)

def apply_tax(price):
    """Returns the price after adding 8% sales tax."""
    return round(price * 1.08, 2)

# Here we store functions in a plain list — just like integers or strings
price_operations = [apply_discount, apply_tax]

original_price = 100.00

for operation in price_operations:
    # We're calling whichever function we pulled out of the list
    result = operation(original_price)
    print(f"{operation.__name__}(${original_price}) → ${result}")

# Now a higher order function: it accepts a function as an argument
def apply_to_cart(prices, pricing_function):
    """
    Takes a list of prices and a pricing function.
    Returns a new list with the function applied to each price.
    The key insight: we don't care WHICH function — we just apply it.
    """
    return [pricing_function(p) for p in prices]

cart_prices = [29.99, 49.99, 9.99, 199.00]

discounted_cart = apply_to_cart(cart_prices, apply_discount)
taxed_cart = apply_to_cart(cart_prices, apply_tax)

print("\nOriginal cart: ", cart_prices)
print("After discount:", discounted_cart)
print("After tax:     ", taxed_cart)

# Real-world scenario: processing a list of e-commerce orders

orders = [
    {"id": 1001, "customer": "Alice",   "total": 85.00,  "status": "shipped"},
    {"id": 1002, "customer": "Bob",     "total": 12.50,  "status": "pending"},
    {"id": 1003, "customer": "Carol",   "total": 340.00, "status": "shipped"},
    {"id": 1004, "customer": "David",   "total": 5.99,   "status": "cancelled"},
    {"id": 1005, "customer": "Eve",     "total": 220.00, "status": "shipped"},
]

# --- filter() example ---
# Predicate: returns True only for shipped orders
def is_shipped(order):
    return order["status"] == "shipped"

# filter() returns a lazy iterator — wrap in list() to materialise it
shipped_orders = list(filter(is_shipped, orders))

print("Shipped orders:")
for order in shipped_orders:
    print(f"  Order {order['id']} — {order['customer']}: ${order['total']}")

# --- map() example ---
# Transform each shipped order into a concise summary string
def format_receipt(order):
    """Converts an order dict into a human-readable receipt line."""
    return f"Receipt #{order['id']}: {order['customer']} paid ${order['total']:.2f}"

receipts = list(map(format_receipt, shipped_orders))

print("\nReceipts:")
for receipt in receipts:
    print(" ", receipt)

# --- Chaining map and filter (lazy, memory efficient) ---
# Only shipped orders over $100, formatted — nothing is computed until list() is called
high_value_receipts = list(
    map(
        format_receipt,
        filter(lambda o: o["status"] == "shipped" and o["total"] > 100, orders)
    )
)

print("\nHigh-value shipped receipts:")
for receipt in high_value_receipts:
    print(" ", receipt)

from functools import reduce

# --- reduce() example ---
# Calculating the total revenue from a list of order totals
order_totals = [85.00, 12.50, 340.00, 5.99, 220.00]

# reduce applies the lambda left-to-right:
# Step 1: accumulator=85.00,  next=12.50  → 97.50
# Step 2: accumulator=97.50,  next=340.00 → 437.50
# ... and so on until one value remains
total_revenue = reduce(lambda accumulator, amount: accumulator + amount, order_totals)
print(f"Total revenue: ${total_revenue:.2f}")

# For simple sums, sum() is cleaner — reduce shines when logic is more complex:
most_expensive = reduce(
    lambda current_max, amount: amount if amount > current_max else current_max,
    order_totals
)
print(f"Most expensive order: ${most_expensive:.2f}")


# --- Writing our own higher order function (a closure / factory) ---
# Problem: we need multiple discount tiers — 10%, 15%, 20%
# Bad approach: write three nearly-identical functions
# Good approach: write a factory that generates them

def make_discount_function(discount_rate):
    """
    Returns a NEW function configured with a specific discount rate.
    The returned function 'remembers' discount_rate via closure.
    """
    def apply_discount(price):
        # discount_rate is captured from the enclosing scope — this is a closure
        discounted = round(price * (1 - discount_rate), 2)
        return discounted
    return apply_discount  # returning a function, not calling it!

# Create specialised discount functions without repeating logic
silver_discount = make_discount_function(0.10)  # 10% off
gold_discount   = make_discount_function(0.15)  # 15% off
vip_discount    = make_discount_function(0.20)  # 20% off

product_price = 150.00

print(f"\nProduct price: ${product_price}")
print(f"Silver member pays: ${silver_discount(product_price)}")
print(f"Gold member pays:   ${gold_discount(product_price)}")
print(f"VIP member pays:    ${vip_discount(product_price)}")

# Real power: store them in a dict and look up by membership tier
discount_by_tier = {
    "silver": make_discount_function(0.10),
    "gold":   make_discount_function(0.15),
    "vip":    make_discount_function(0.20),
}

customer_tier = "gold"
calculate = discount_by_tier[customer_tier]
print(f"\n{customer_tier.capitalize()} customer price: ${calculate(product_price)}")

import time
import functools

# A decorator is a higher order function:
# — it accepts a function (the one being decorated)
# — it returns a new function (the wrapper)

def execution_timer(func):
    """
    Wraps any function to log how long it takes to run.
    Works with ANY function — we don't need to know its arguments in advance.
    """
    @functools.wraps(func)  # preserves the original function's name and docstring
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()         # record start
        result = func(*args, **kwargs)            # call the ORIGINAL function
        end_time = time.perf_counter()            # record end
        elapsed = (end_time - start_time) * 1000 # convert to milliseconds
        print(f"[Timer] {func.__name__} completed in {elapsed:.4f}ms")
        return result  # return what the original function returned — don't swallow it!
    return wrapper  # return the wrapper function, not the result of calling it


# Apply the decorator — this is equivalent to:
# process_orders = execution_timer(process_orders)
@execution_timer
def process_orders(order_list):
    """Simulates processing a batch of orders with a small delay."""
    time.sleep(0.05)  # simulating I/O or database work
    return [f"processed:{order_id}" for order_id in order_list]


@execution_timer
def calculate_totals(prices):
    """Sums a list of prices."""
    return sum(prices)


# The decorator fires transparently — our calling code doesn't change at all
order_ids = [1001, 1002, 1003, 1004]
processed = process_orders(order_ids)
print("Processed:", processed)

total = calculate_totals([29.99, 49.99, 9.99])
print(f"Total: ${total:.2f}")

# Verify functools.wraps preserved the function name
print(f"\nFunction name is still: {process_orders.__name__}")