Advanced Functions

Python supports multi-paradigm programming, allowing functions to be treated with first-class citizens status. Let’s explore how to write advanced and powerful functions.

In Python, functions are first-class objects. This means that just like integers, strings, or lists, a function is an object in memory with a type, identity, and value. You can:

Assign them to new variables.
Store them inside lists, tuples, or dictionaries.
Pass them as arguments to other functions.
Access their built-in attributes (like __name__).

Here are examples demonstrating functions behaving as objects:

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

# 1. Assign to another variable
say_hello = greet
print(say_hello("Aarav"))  # Hello, Aarav!

# 2. Store in a list and loop through them
def shout(name):
    return f"HELLO, {name}!"

actions = [greet, shout]
for action in actions:
    print(action("Amit"))  # Prints "Hello, Amit!" then "HELLO, Amit!"

# 3. Pass as an argument (Higher-Order Function)
def run_action(name, action_func):
    return action_func(name)

print(run_action("Dev", greet))  # Hello, Dev!

# 4. Access attributes and memory identity
print(greet.__name__)  # "greet"
print(id(greet))       # Memory address integer

Lambda Functions

A lambda function is a small, anonymous (unnamed) function defined using the lambda keyword.

Syntax

lambda arguments: expression

Lambda functions can have any number of arguments, but only one single expression.
The expression is evaluated and returned automatically (no return keyword is used).

# Standard function
def add(x, y):
    return x + y

# Lambda equivalent
add_lambda = lambda x, y: x + y

print(add_lambda(3, 7))  # 10

Real-World Inline Lambda Example

For quick, single-line mapping operations like adding 18% GST to prices:

prices = [100, 250, 500]
prices_with_gst = list(map(lambda price: price * 1.18, prices))
print(prices_with_gst)  # [118.0, 295.0, 590.0]

Limitations with Multi-line Logic

Python lambda functions are syntactically restricted to a single expression. They cannot contain statements, loops, or variable assignments. However, you can write a multi-line expression (such as nested conditional ternaries) by wrapping the lambda body inside parentheses ().

1. Multi-line Lambda Expression (Nested Conditionals)

For classifying numerical scores into categories using nested ternary expressions formatted across multiple lines:

classify_score = lambda score: (
    "Excellent" if score >= 90 else
    "Good" if score >= 75 else
    "Pass" if score >= 50 else
    "Fail"
)

print(classify_score(82))  # "Good"
print(classify_score(45))  # "Fail"

Bad Practice Warning: While you can format single expressions across multiple lines using parentheses, writing complex nested conditionals or multi-line expressions inside a lambda is considered bad practice. It significantly hurts code readability and makes debugging difficult. Always prefer standard def functions for any logic that spans multiple lines or requires complex conditions.

2. Normal Function Alternative for Multiple Statements

If your logic requires executing multiple separate statements (like logs, assignments, or loops), you must define a normal function using the def keyword:

def process_user_data(user):
    # Multiple statements cannot be done in a lambda!
    name = user.get("name", "Guest")
    cleaned_name = name.strip().title()
    print(f"Processing database record for: {cleaned_name}")
    return cleaned_name

user_record = {"name": "  aarav sharma  "}
print(process_user_data(user_record))

Lambdas are best used as quick arguments for higher-order functions like sorted(), map(), or filter():

points = [(1, 2), (3, 1), (5, 0)]
# Sort points based on the Y-coordinate (index 1 of tuple)
sorted_points = sorted(points, key=lambda p: p[1])
print(sorted_points)  # [(5, 0), (3, 1), (1, 2)]

Variable-Length Arguments (`*args` and `**kwargs`)

When defining functions, you can accept an arbitrary number of arguments:

*args (Positional): Collects additional positional arguments into a tuple.
**kwargs (Keyword): Collects additional keyword arguments into a dictionary.

def print_everything(*args, **kwargs):
    print("Positional args:", args)
    print("Keyword args:", kwargs)

print_everything(1, 2, 3, name="Alice", age=25)
# Output:
# Positional args: (1, 2, 3)
# Keyword args: {'name': 'Alice', 'age': 25}

Closures

A closure is a nested function that retains access to variables from its enclosing (outer) function’s scope, even after the outer function has finished executing. To create a closure:

You must have a nested function.
The nested function must refer to a value defined in the enclosing function.
The enclosing function must return the nested function.

def make_multiplier(factor):
    def multiplier(number):
        # Accesses 'factor' from outer scope
        return number * factor
    return multiplier

# Create specialized multiplier functions
double = make_multiplier(2)
triple = make_multiplier(3)

print(double(10))  # 20
print(triple(10))  # 30

Decorators

A decorator is a design pattern in Python that allows you to modify or extend the behavior of a function or class without permanently changing its source code. Under the hood, a decorator is a higher-order function that takes another function as an argument, wraps it with additional behavior, and returns the wrapper.

Writing a Custom Decorator

# 1. Define the decorator
def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()  # Execute the original function
        print("Something is happening after the function is called.")
    return wrapper

# 2. Apply it using the @ symbol
@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# Output:
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.

Decorating Functions with Arguments

To decorate functions that take arguments, use *args and **kwargs inside the wrapper function:

def log_arguments(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned: {result}")
        return result
    return wrapper

@log_arguments
def add_numbers(a, b):
    return a + b

add_numbers(10, 20)

Practice & Exercises

To reinforce what you’ve learned in this section (Higher-order functions, lambdas, closures, and custom decorators), practice with these interactive notebooks:

Follow-Along Practice

Practice passing functions as arguments, defining single-expression anonymous lambdas, sorting coordinates dynamically, building closure scopes, and applying custom decorators.💻 VS Code | 🚀 Colab | 📥 Download

Practice Exercises

Test your knowledge with hands-on exercises on higher-order operations, sorting product list prices using lambda keys, creating greeting closure builders, and writing bold-formatting decorators.💻 VS Code | 🚀 Colab | 📥 Download

What’s next?

Now let’s explore Pythonic programming patterns: comprehensions, the iterator protocol, generators, and context managers!

Comprehensions

Learn comprehensions, iterators, and context managers

Advanced Concepts

Pydantic

Lambda Functions

Syntax

Real-World Inline Lambda Example

Limitations with Multi-line Logic

1. Multi-line Lambda Expression (Nested Conditionals)

2. Normal Function Alternative for Multiple Statements

Variable-Length Arguments (`*args` and `**kwargs`)

Closures

Decorators

Writing a Custom Decorator

Decorating Functions with Arguments

Practice & Exercises

Follow-Along Practice

Practice Exercises

What’s next?

Comprehensions

​Lambda Functions

​Syntax

​Real-World Inline Lambda Example

​Limitations with Multi-line Logic

​1. Multi-line Lambda Expression (Nested Conditionals)

​2. Normal Function Alternative for Multiple Statements

​Variable-Length Arguments (*args and **kwargs)

​Closures

​Decorators

​Writing a Custom Decorator

​Decorating Functions with Arguments

​Practice & Exercises

Follow-Along Practice

Practice Exercises

​What’s next?

Comprehensions

Lambda Functions

Syntax

Real-World Inline Lambda Example

Limitations with Multi-line Logic

1. Multi-line Lambda Expression (Nested Conditionals)

2. Normal Function Alternative for Multiple Statements

Variable-Length Arguments (`*args` and `**kwargs`)

Closures

Decorators

Writing a Custom Decorator

Decorating Functions with Arguments

Practice & Exercises

What’s next?