RugvAI Labs

Functions: Reusable Code Blocks

Functions are the unit of thought in Python. CPython itself is ~600,000 lines of functions. Anthropic's Claude SDK exposes its entire API through one core function: client.messages.create(...). Master functions — parameters, returns, scope, closures — and you've mastered 70% of what makes a Python engineer effective.

Learning Objectives

After this lesson, you will be able to:

Define functions with def, parameters, and return values
Use default arguments to make function parameters optional
Understand *args and **kwargs for flexible argument passing
Write concise lambda functions for simple, throwaway operations
Explain variable scope -- why local variables do not leak outside their function
Optional, for later: closures, nonlocal, and functools helpers like lru_cache

Prerequisites

Before You Start

Review

#What Is a Function?

A function is a named, reusable block of code that takes input, does something, and (optionally) returns output.

You have already used built-in functions: print(), len(), type(), range(), int(), input(). Now you will learn to create your own.

pythonrunnable cell

# Defining a function
def greet(name):
    """Say hello to someone."""
    return f"Hello, {name}! Welcome to Python."

# Calling (using) the function
message = greet("Alex")
print(message)  # Hello, Alex! Welcome to Python.

print(greet("AI"))  # Hello, AI! Welcome to Python.

Let us break down the syntax:

def -- keyword that starts a function definition
greet -- the function's name (use snake_case)
(name) -- the parameter (input variable)
""" ... """ -- docstring (documentation). Describes what the function does
return -- sends a value back to the caller. Without it, the function returns None

Loading visualization...

#Parameters and Arguments

Parameters are the variable names in the function definition. Arguments are the actual values you pass when calling the function.

pythonrunnable cell

def calculate_bmi(weight_kg, height_m):
    """Calculate Body Mass Index."""
    bmi = weight_kg / (height_m ** 2)
    return round(bmi, 1)

# Positional arguments (order matters)
result = calculate_bmi(70, 1.75)
print(f"BMI: {result}")  # BMI: 22.9

# Keyword arguments (order does not matter)
result = calculate_bmi(height_m=1.75, weight_kg=70)
print(f"BMI: {result}")  # BMI: 22.9

Quick check

Given `def calculate_bmi(weight_kg, height_m):`, which call computes the BMI for someone who weighs 70kg and is 1.75m tall?

#Multiple Return Values

Functions can return multiple values using tuples:

pythonrunnable cell

def analyze_scores(scores):
    """Return statistics about a list of scores."""
    avg = sum(scores) / len(scores)
    highest = max(scores)
    lowest = min(scores)
    return avg, highest, lowest  # returns a tuple

# Unpack the results
average, high, low = analyze_scores([85, 92, 78, 95, 88])
print(f"Average: {average}, High: {high}, Low: {low}")
# Average: 87.6, High: 95, Low: 78

What Do You Think?

What does a function return if there is no return statement?

The answer is None. If a function has no return statement (or just return with no value), it returns None -- Python's way of saying "no value." This is important to know because accidentally forgetting return is a very common bug.

pythonrunnable cell

def say_hello(name):
    print(f"Hello, {name}!")  # this PRINTS but does not RETURN

result = say_hello("Alex")
print(result)  # None -- because there is no return statement!

Loading visualization...

#Now trace it yourself

The animation above was canned. Now you drive: edit the code below, click Trace it, and watch Python build a new frame for greet, bind name and the default greeting, and pop the frame on return — every variable change, every print, live.

pythonLive tracer· Function call framesCtrl/⌘ + Enter to trace

Edit the code, then click Trace it. Python actually runs in your browser — every line, every variable, every print.

Click Trace it to capture the execution trace. The scrubber below will let you step through every variable change line-by-line.

#Default Arguments

You can give parameters default values, making them optional when calling the function:

pythonrunnable cell

def train_model(data, epochs=10, learning_rate=0.001, verbose=True):
    """Simulate model training with configurable parameters."""
    if verbose:
        print(f"Training on {len(data)} samples")
        print(f"Epochs: {epochs}, LR: {learning_rate}")

    # Simulate training
    loss = 100.0
    for epoch in range(epochs):
        loss *= (1 - learning_rate * 10)
        if verbose and epoch % 3 == 0:
            print(f"  Epoch {epoch}: loss = {loss:.4f}")

    return loss

# Use all defaults
train_model([1, 2, 3, 4, 5])

# Override some defaults
train_model([1, 2, 3, 4, 5], epochs=20, learning_rate=0.01)

# Override just one
train_model([1, 2, 3, 4, 5], verbose=False)

Rule: Parameters with defaults must come after parameters without defaults.

pythonrunnable cell

# WRONG
# def bad_func(x=10, y):  # SyntaxError

# RIGHT
def good_func(y, x=10):
    return x + y

This pattern is used everywhere in AI libraries. When you see model.fit(X, y, epochs=10, batch_size=32, verbose=1), those keyword arguments with defaults are exactly this pattern.

What Do You Think?

What does the second call print? def add_item(item, items=[]): items.append(item) return items print(add_item("a")) print(add_item("b"))

The answer is ['a'] then ['a', 'b']. Python evaluates the default items=[] exactly ONCE — at function-definition time — and reuses that SAME list on every call that omits the argument. So the first call appends "a" to the shared list, and the second call appends "b" to the SAME list (which still has "a" in it). This is Python's most infamous gotcha, and it has caused real production bugs. The fix: use items=None and create a fresh list inside: if items is None: items = [].

Watch Out

Using a mutable object as a default argument: `def f(items=[]):`

Fix: Use None as the placeholder, then build a fresh container inside the function body.

pythonrunnable cell

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

Default arguments are evaluated exactly ONCE — when the function is defined. With items=[], every call that uses the default shares the same list object. This is Python's most infamous gotcha.

#*args and **kwargs

Sometimes you want a function to accept any number of arguments.

`*args` -- Variable Positional Arguments

pythonrunnable cell

def average(*args):
    """Calculate the average of any number of values."""
    if not args:
        return 0
    return sum(args) / len(args)

print(average(10, 20))           # 15.0
print(average(1, 2, 3, 4, 5))   # 3.0
print(average(100))              # 100.0

*args collects all positional arguments into a tuple. The name args is a convention -- you could call it *numbers or *values.

`**kwargs` -- Variable Keyword Arguments

pythonrunnable cell

def create_model(**kwargs):
    """Create a model configuration from keyword arguments."""
    config = {
        "type": "neural_network",     # default
        "layers": 3,                  # default
        "learning_rate": 0.001,       # default
    }
    config.update(kwargs)  # override defaults with provided values
    return config

model1 = create_model()
print(model1)
# {'type': 'neural_network', 'layers': 3, 'learning_rate': 0.001}

model2 = create_model(layers=12, dropout=0.1, name="GPT-mini")
print(model2)
# {'type': 'neural_network', 'layers': 12, 'learning_rate': 0.001, 'dropout': 0.1, 'name': 'GPT-mini'}

**kwargs collects all keyword arguments into a dictionary. This is extremely common in AI libraries where models have dozens of optional parameters.

#Combining Everything

pythonrunnable cell

def flexible_function(required, *args, default="hello", **kwargs):
    print(f"Required: {required}")
    print(f"Extra positional: {args}")
    print(f"Default: {default}")
    print(f"Extra keyword: {kwargs}")

flexible_function("yes", 1, 2, 3, default="world", color="blue", size=10)
# Required: yes
# Extra positional: (1, 2, 3)
# Default: world
# Extra keyword: {'color': 'blue', 'size': 10}

The order must be: regular parameters, *args, keyword-only parameters (with defaults), **kwargs.

#Lambda Functions

A lambda is a small, anonymous (unnamed) function written in one line:

pythonrunnable cell

# Regular function
def double(x):
    return x * 2

# Same thing as a lambda
double = lambda x: x * 2

print(double(5))  # 10

Lambdas are most useful when passed to other functions:

pythonrunnable cell

# Sort a list of tuples by the second element
students = [("Alice", 92), ("Bob", 78), ("Charlie", 95), ("Diana", 88)]

# Sort by grade (second element of each tuple)
students.sort(key=lambda student: student[1])
print(students)
# [('Bob', 78), ('Diana', 88), ('Alice', 92), ('Charlie', 95)]

# Sort by grade descending
students.sort(key=lambda student: student[1], reverse=True)
print(students)
# [('Charlie', 95), ('Alice', 92), ('Diana', 88), ('Bob', 78)]

# Filter with a lambda
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6, 8, 10]

# Map with a lambda
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

When to use lambdas: For short, throwaway functions you pass as arguments. If the logic is more than one expression, use a regular def function instead.

#Scope -- Local vs Global

Intuition

Build Your Intuition

Simple rule: Variables inside a function stay inside — like notes on a whiteboard that gets erased when you leave the room. Variables outside can be read inside, but changes don't escape.

pythonrunnable cell

name = "Alex"       # Outside — everyone can read this

def greet():
    message = "Hello"   # Inside — only exists here
    print(name)         # ✅ Can read outside variables
    print(message)      # ✅ Fine inside the function

greet()
# print(message)  ← ❌ This fails — message doesn't exist out here

That's 90% of what you need to know about scope. The LEGB rule below explains the full picture.

Scope determines where a variable is visible and accessible.

pythonrunnable cell

# Global variable -- accessible everywhere
model_name = "GPT-4"

def train():
    # Local variable -- only exists inside this function
    epochs = 10
    print(f"Training {model_name} for {epochs} epochs")  # can READ global

train()
# print(epochs)  # NameError: 'epochs' is not defined (it is local to train)

print(model_name)  # "GPT-4" -- global variables persist

#The Key Rules

Functions can READ global variables but should not modify them
Local variables exist only inside the function -- they are created when the function runs and destroyed when it returns
Local variables shadow global ones -- if you create a variable with the same name as a global, the local one takes priority inside the function

pythonrunnable cell

x = 100  # global

def demo():
    x = 999  # local x -- does NOT change the global x
    print(f"Inside function: x = {x}")  # 999

demo()
print(f"Outside function: x = {x}")  # 100 -- unchanged!

#Why Scope Matters

Scope prevents functions from accidentally breaking each other. Imagine two functions both using a variable called count. Without scope, they would overwrite each other's values. With scope, each function has its own private count that cannot interfere.

What Do You Think?

What gets printed? count = 10 def bump(): count = count + 1 print(count) bump()

The answer is UnboundLocalError. The moment Python sees count = ... anywhere in a function body, it marks count as a LOCAL variable for the entire function — even on lines BEFORE the assignment. So count + 1 tries to read a local count that hasn't been assigned yet, and crashes. The global count = 10 is invisible inside bump() because of the assignment. To actually modify the global, you need global count at the top of the function (or, more commonly, just return the new value: return count + 1).

Scope prevents accidents like this, but the error message can confuse beginners — it says "local variable referenced before assignment," but the cause is the assignment LATER in the function.

pythonrunnable cell

def count_vowels(text):
    count = 0  # local to this function
    for char in text.lower():
        if char in "aeiou":
            count += 1
    return count

def count_words(text):
    count = len(text.split())  # different variable, local to THIS function
    return count

# These do not interfere with each other
print(count_vowels("Hello World"))  # 3
print(count_words("Hello World"))   # 2

Hit UnboundLocalError or TypeError: missing argument? Reading a name that's later assigned inside the same function triggers UnboundLocalError, and forgetting a positional arg triggers TypeError. See the error decoder for both.

#Practical Examples for AI

#Example 1: Data Preprocessing Pipeline

pythonrunnable cell

def clean_text(text):
    """Lowercase, strip whitespace, remove punctuation."""
    import string
    text = text.lower().strip()
    text = text.translate(str.maketrans("", "", string.punctuation))
    return text

def tokenize(text):
    """Split text into individual words."""
    return text.split()

def remove_stop_words(tokens, stop_words=None):
    """Remove common words that do not carry meaning."""
    if stop_words is None:
        stop_words = {"the", "a", "an", "is", "are", "was", "in", "on", "at", "to", "of"}
    return [word for word in tokens if word not in stop_words]

def preprocess(text):
    """Full preprocessing pipeline."""
    cleaned = clean_text(text)
    tokens = tokenize(cleaned)
    filtered = remove_stop_words(tokens)
    return filtered

# Use it
result = preprocess("The Cat is sitting ON the Mat!")
print(result)  # ['cat', 'sitting', 'mat']

#Example 2: Model Evaluation

pythonrunnable cell

def accuracy(predictions, actual):
    """Calculate classification accuracy."""
    correct = sum(p == a for p, a in zip(predictions, actual))
    return correct / len(actual)

def precision(predictions, actual, positive_label="spam"):
    """Of all items we predicted as positive, how many were actually positive?"""
    true_positives = sum(p == a == positive_label for p, a in zip(predictions, actual))
    predicted_positive = sum(p == positive_label for p in predictions)
    return true_positives / predicted_positive if predicted_positive > 0 else 0.0

def evaluate_model(predictions, actual):
    """Run full evaluation suite."""
    acc = accuracy(predictions, actual)
    prec = precision(predictions, actual)
    return {
        "accuracy": round(acc, 4),
        "precision": round(prec, 4),
        "total_samples": len(actual),
    }

# Test it
preds = ["spam", "ham", "spam", "spam", "ham", "spam", "ham", "ham"]
truth = ["spam", "ham", "ham",  "spam", "ham", "spam", "spam", "ham"]

results = evaluate_model(preds, truth)
for metric, value in results.items():
    print(f"{metric}: {value}")

#Code Playground

pythonplayground.py · Pyodide

# Functions in Python -- def, *args, **kwargs, lambdas
import math

# Basic function with parameters and return
def calculate_bmi(weight_kg: float, height_m: float) -> float:
  """Calculate Body Mass Index."""
  return round(weight_kg / (height_m ** 2), 1)

print("BMI:", calculate_bmi(70, 1.75))  # 22.9
print("BMI:", calculate_bmi(90, 1.80))  # 27.8

# Function with default parameters
def greet(name: str, greeting: str = "Hello") -> str:
  return f"{greeting}, {name}!"

print(greet("Alex"))              # Hello, Alex!
print(greet("Alex", "Welcome"))   # Welcome, Alex!

# Lambda functions (Python's one-line anonymous functions)
double = lambda x: x * 2
add = lambda a, b: a + b

print("Double 5:", double(5))  # 10
print("3 + 4:", add(3, 4))    # 7

# Using lambdas with filter/map and list comprehensions
numbers = list(range(1, 11))
evens = [n for n in numbers if n % 2 == 0]
squared = [n ** 2 for n in numbers]

print("Evens:", evens)      # [2, 4, 6, 8, 10]
print("Squared:", squared)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# Sorting with a key function
students = [
  {"name": "Alice", "grade": 92},
  {"name": "Bob", "grade": 78},
  {"name": "Charlie", "grade": 95},
]

students.sort(key=lambda s: s["grade"], reverse=True)
print("\nRanked students:")
for i, s in enumerate(students, 1):
  print(f"  #{i} {s['name']}: {s['grade']}")

# CHALLENGES:
# 1. Write a function celsius_to_fahrenheit(c) that converts C to F
# 2. Write a function is_prime(n) that returns True if n is prime
# 3. Write a function count_vowels(text) that returns the number of vowels
# 4. Write a function that takes a list of numbers and returns {"min", "max", "avg"}
# 5. Use sorted() with a key to sort words by LENGTH

Tests · Write each function, then test it with print() to verify it works!

#Functions Calling Functions

Functions can call other functions, building up complexity from simple pieces:

pythonrunnable cell

def is_positive(text):
    """Check if text contains positive words."""
    positive_words = {"good", "great", "awesome", "love", "amazing", "excellent"}
    words = set(text.lower().split())
    return len(words & positive_words) > 0

def is_negative(text):
    """Check if text contains negative words."""
    negative_words = {"bad", "terrible", "awful", "hate", "horrible", "worst"}
    words = set(text.lower().split())
    return len(words & negative_words) > 0

def classify_sentiment(text):
    """Classify text as positive, negative, or neutral."""
    pos = is_positive(text)
    neg = is_negative(text)

    if pos and not neg:
        return "positive"
    elif neg and not pos:
        return "negative"
    elif pos and neg:
        return "mixed"
    else:
        return "neutral"

# Test the pipeline
reviews = [
    "This movie was great and amazing!",
    "Terrible experience, the worst ever.",
    "It was okay, nothing special.",
    "I love the great food but hate the terrible service.",
]

for review in reviews:
    sentiment = classify_sentiment(review)
    print(f"[{sentiment:>8}] {review}")

This pattern -- small, focused functions composed into larger workflows -- is how real AI systems are built. Each function does one thing well, and you chain them together.

#Interactive Visualization: Scope & Call Stack

Visualize Python's LEGB scope resolution, call stack frames, and closure variable capture:

Loading visualization...

#Watch frames stack and unwind

Every call creates a fresh stack frame that holds local variables and a pointer back to whoever called you. When the function returns, that frame is destroyed and its return value flows back to the caller. Step through three scenarios — a simple call chain, deep recursion, and exception unwinding — to see how the LIFO discipline actually plays out.

Loading visualization...

#LEGB: name lookup, animated

When Python sees a bare name like x, it searches four concentric scopes in a fixed order: Local → Enclosing → Global → Built-in. The first match wins; if none match, you get NameError. The visualizer below makes the search visible — a ball expands outward through the rings until it finds the binding, then snaps back to the call site with the value. Six presets cover every shape this lookup can take, including the nonlocal / global write-target rules.

Loading visualization...

Fix this codeFix the mutable default argument

This function should return a fresh list with the new item each time it's called. Instead, items keep accumulating across calls. Fix the function.

Expected output

['apple']
['banana']
['cherry']

Mini project

Build a tip calculator

~6 min

Write a function `calculate_total(bill, tip_pct=15)` that returns the total amount to pay (bill + tip). The tip percentage should default to 15%. Then call it twice — once with default tip, once with a custom tip — and print both totals.

Expected output

Total on $50 (default 15%): $57.50
Total on $80 (20% tip): $96.00

Your code

pythonrunnable cell

def calculate_total(bill, tip_pct=15):
  # TODO: compute tip and return bill + tip
  pass

# Call once with default tip, once with custom tip
total1 = calculate_total(50)
total2 = calculate_total(80, 20)
print(f"Total on $50 (default 15%): ${total1:.2f}")
print(f"Total on $80 (20% tip): ${total2:.2f}")

#Key Takeaways

Functions are reusable code recipes -- define with def, pass inputs as parameters, send outputs back with return. A function without return gives back None
Default arguments make parameters optional -- def train(epochs=10) lets callers skip the epochs argument. This pattern is everywhere in AI libraries
*args and **kwargs accept variable arguments -- *args collects extra positional arguments into a tuple, **kwargs collects extra keyword arguments into a dictionary
Lambda functions are one-line throwaway functions -- lambda x: x * 2 is perfect for sorting keys and filter/map operations. Use def for anything more complex
Scope keeps variables private -- local variables exist only inside their function and cannot interfere with other functions or global variables

Quick Check1 / 5

What does this function return? def add(a, b): c = a + b

Your Reflection

Continue Learning

Discussion

Functions: Reusable Code Blocks

After this lesson, you will be able to:

Before You Start

#What Is a Function?

#Parameters and Arguments

#Multiple Return Values

#Now trace it yourself

#Default Arguments

#*args and **kwargs

`*args` -- Variable Positional Arguments

`**kwargs` -- Variable Keyword Arguments

#Combining Everything

#Lambda Functions

#Scope -- Local vs Global

#The Key Rules

#Why Scope Matters

#Practical Examples for AI

#Example 1: Data Preprocessing Pipeline

#Example 2: Model Evaluation

#Code Playground

#Functions Calling Functions

Functions Are Objects in Python

#Interactive Visualization: Scope & Call Stack

#Watch frames stack and unwind

#LEGB: name lookup, animated

Closures, nonlocal, and functools — advanced patterns (skip if you're new)

Build a tip calculator

#Key Takeaways

Related Lessons

Your Reflection

Continue Learning

Discussion

Functions: Reusable Code Blocks

#What Is a Function?

#Parameters and Arguments

#Multiple Return Values

#Now trace it yourself

#Default Arguments

#*args and **kwargs

*args -- Variable Positional Arguments

**kwargs -- Variable Keyword Arguments

#Combining Everything

#Lambda Functions

#Scope -- Local vs Global

#The Key Rules

#Why Scope Matters

#Practical Examples for AI

#Example 1: Data Preprocessing Pipeline

#Example 2: Model Evaluation

#Code Playground

#Functions Calling Functions

Functions Are Objects in Python

#Interactive Visualization: Scope & Call Stack

#Watch frames stack and unwind

#LEGB: name lookup, animated

Closures, nonlocal, and functools — advanced patterns (skip if you're new)

#Key Takeaways

Related Lessons

`*args` -- Variable Positional Arguments

`**kwargs` -- Variable Keyword Arguments