PyInns - Home

Anonymous Functions (Lambda) in Python – When and How to Use Them in Data Science 2026

Anonymous functions, commonly known as **lambda functions**, allow you to create small, one-time-use functions without giving them a name. In data science, they are frequently used for quick data transformations, filtering, and sorting operations.

TL;DR — When to Use Lambda Functions

Use lambda for **very short, simple** expressions
Best suited for apply(), map(), filter(), and sorted(key=...)
Avoid lambda for complex logic — use named functions instead

1. Basic Lambda Examples

import pandas as pd

df = pd.read_csv("sales_data.csv")

# Simple transformations
df["log_amount"] = df["amount"].apply(lambda x: round(x ** 0.5, 2) if x > 0 else 0)

# Conditional logic
df["value_category"] = df["amount"].apply(
    lambda x: "High" if x > 1500 else "Medium" if x > 500 else "Low"
)

# With sorted
transactions = [{"id": 101, "amount": 2340}, {"id": 102, "amount": 890}]
sorted_tx = sorted(transactions, key=lambda x: x["amount"], reverse=True)

2. Common Data Science Use Cases

# 1. Custom column creation
df["profit_margin"] = df.apply(
    lambda row: (row["profit"] / row["amount"] * 100) if row["amount"] > 0 else 0, 
    axis=1
)

# 2. Filtering with filter()
high_value = list(filter(lambda x: x["amount"] > 2000, transaction_list))

# 3. Sorting with custom key
df_sorted = df.sort_values(by="amount", key=lambda x: x.abs())

3. When to Avoid Lambda Functions

# ❌ Bad - Complex lambda, hard to read and debug
df["complex_score"] = df.apply(
    lambda row: row["amount"] * 0.9 if row["region"] == "North" 
                else row["amount"] * 0.85 if row["category"] == "Premium" 
                else row["amount"] * 0.8, axis=1
)

# ✅ Better - Use a named function
def calculate_discounted_price(row):
    if row["region"] == "North":
        return row["amount"] * 0.9
    elif row["category"] == "Premium":
        return row["amount"] * 0.85
    return row["amount"] * 0.8

df["complex_score"] = df.apply(calculate_discounted_price, axis=1)

4. Best Practices in 2026

Use lambda only for **simple, one-line** expressions
Prefer named functions with proper docstrings for any logic longer than one line
Use lambda inside apply(), map(), and sorted(key=...)
Keep lambda expressions readable — avoid deeply nested or complex logic
Use type hints and clear variable names in surrounding code to compensate for lambda's lack of documentation

Conclusion

Lambda functions (anonymous functions) are a convenient tool for quick, inline transformations in data science. In 2026, use them sparingly for simple operations, especially inside apply(), map(), and sorting functions. For anything more complex or reusable, always prefer well-named regular functions with proper docstrings and type hints. The goal is code clarity and maintainability, not cleverness.

Next steps: