Python Functions - Silent None Return Crashes

Every app you've ever used — Spotify, Instagram, Google Maps — is built on thousands of small, focused jobs that run on demand. When you hit Search, something processes your query. When you tap Like, something updates a counter. When a payment goes through, something generates a transaction ID and routes it to half a dozen downstream services. Each of those 'somethings' is a function.

Functions are the fundamental building block of every serious Python program, and understanding them deeply — not just syntactically — is the single biggest leap you'll make early in your Python journey.

Without functions, your code would be a giant wall of repeated instructions. Imagine writing the same 10 lines to calculate a discount every time a user adds something to a cart. Change the discount rule once and you'd have to hunt down every copy, hope you found them all, and pray you edited each one consistently. Functions solve this by letting you write that logic once, give it a name, and call it from anywhere. This is the DRY principle — Don't Repeat Yourself — and functions are the primary mechanism Python gives you to enforce it.

By the end of this article you'll know how to write your own functions, pass information into them, get results back out, and avoid the mistakes that trip up nearly every beginner — including at least one that experienced developers still walk into occasionally.

What a Function Is and How to Build Your First One

A function is a named block of code that only runs when you call it. Python needs four things to create one: the def keyword (short for 'define'), a name you choose, a pair of parentheses, and a colon. Everything indented underneath that colon is the function's body — the actual instructions it will execute.

The `def` keyword is you telling Python: 'store these instructions under this name for later.' Nothing runs at that point. It's like writing a recipe on a card and putting it in a drawer. The recipe doesn't cook itself — you have to take it out and follow it. Calling the function is you following the recipe.

Naming matters more than beginners usually expect. Use lowercase letters with underscores for readability — calculate_tax, not CalculateTax or ct. A good function name reads like a verb phrase because it does something specific. If you can't describe your function in a short verb phrase, it's almost certainly trying to do too many things at once — and that's your cue to split it up.

One thing I'd add that most beginner tutorials skip: a function defined but never called is dead code. It ships to production, takes up space, and executes exactly zero times. In large codebases, dead functions accumulate quietly over years. They confuse new engineers who can't tell whether the function is unused or critical. Delete them, or at minimum add a comment explaining why they exist but aren't being called yet.

# ── Defining a function ───────────────────────────────────────────────────────
# 'def' tells Python we're creating a reusable named block of code.
# 'greet_user' is the name we're giving it.
# The colon starts the function body — everything indented below runs when called.
def greet_user():
    # This code does NOT run yet — we are just defining it.
    # Python stores these instructions under the name 'greet_user'.
    print("Hey there! Welcome to TheCodeForge.")
    print("Let's learn Python together.")

# ── Calling the function ───────────────────────────────────────────────────────
# Now we actually execute the code inside the function.
# Write the function name followed by parentheses — the parentheses are what trigger the call.
greet_user()   # First call
greet_user()   # Second call — same result, zero extra effort
greet_user()   # Third call — same instructions, new execution

# ── What NOT to do ───────────────────────────────────────────────────────────
# Writing the name without parentheses does NOT call the function.
# It just references the function object — no code runs.
# ref = greet_user   # This stores a reference to the function, not the result.
# ref()              # This would call it — same as greet_user()

Passing Information In — Parameters and Arguments Demystified

A function with no inputs is like a vending machine with only one button. Useful, but limited. Parameters let you feed information into a function so it can work with different data each time — which is what makes functions genuinely powerful rather than just convenient shorthand for repeated code.

A parameter is the placeholder name inside the function definition. An argument is the actual value you pass in when you call the function. People use these words interchangeably in conversation and that's fine, but knowing the distinction will help you during code reviews, reading error messages, and technical interviews.

You can define as many parameters as you need, separated by commas. Python also supports default parameter values — if a caller doesn't provide an argument for a parameter that has a default, the function uses the default instead. This makes your functions flexible without requiring callers to always supply every piece of data. Think of it like a coffee order: if you don't specify milk, the barista uses the default. You can always override it, but you don't have to specify it every single time.

Keyword arguments are worth knowing early. Instead of passing arguments by position, you can pass them by name: calculate_final_price(discount_percent=20, original_price=50). The order no longer matters because Python matches by name. This makes calls with multiple parameters much easier to read and nearly impossible to mix up — particularly valuable when a function has four or five parameters and positional order is hard to remember.

One trap that catches people who've used other languages: Python's mutable default argument. If you use a list or dictionary as a default parameter value, that object is created exactly once — at function definition time, not at each call. Every invocation that uses the default shares the same object. If any call mutates it, the next call starts with the mutated version. The fix is simple but non-obvious: use None as the default and create a fresh object inside the function body.

# ── Function with parameters ──────────────────────────────────────────────────
# 'customer_name' and 'item_ordered' are PARAMETERS.
# They're placeholders — they only get real values when the function is called.
def confirm_order(customer_name, item_ordered):
    print(f"Order confirmed for {customer_name}!")
    print(f"You ordered: {item_ordered}")
    print("---")

# When we call the function, we pass ARGUMENTS — the actual values.
# 'Alice' fills 'customer_name', 'Python Book' fills 'item_ordered'.
confirm_order("Alice", "Python Book")
confirm_order("Bob", "Mechanical Keyboard")


# ── Default parameter values ──────────────────────────────────────────────────
# If 'discount_percent' isn't provided by the caller, it defaults to 10.
# The caller can override it by passing a different value.
def calculate_final_price(original_price, discount_percent=10):
    discount_amount = original_price * (discount_percent / 100)
    final_price = original_price - discount_amount
    print(f"Original: ${original_price:.2f}")
    print(f"Discount: {discount_percent}%  (saves ${discount_amount:.2f})")
    print(f"You pay:  ${final_price:.2f}")
    print("---")

# Uses the default 10% — caller doesn't need to know or specify it
calculate_final_price(100)

# Overrides the default with a custom discount
calculate_final_price(100, 25)

# Keyword argument — order doesn't matter, intent is explicit
calculate_final_price(discount_percent=20, original_price=200)


# ── The mutable default argument trap ─────────────────────────────────────────
# WRONG: the list is created ONCE at definition time — all calls share it
def broken_add_tag(tag, tags=[]):
    tags.append(tag)
    return tags

print(broken_add_tag("python"))   # ['python'] — looks fine
print(broken_add_tag("beginner")) # ['python', 'beginner'] — wrong! should be ['beginner']

# CORRECT: use None and create a fresh list on every call
def add_tag(tag, tags=None):
    if tags is None:
        tags = []           # fresh list every time — no shared state
    tags.append(tag)
    return tags

print(add_tag("python"))          # ['python']
print(add_tag("beginner"))        # ['beginner'] — correct, independent call

Getting Information Back Out — The return Statement

So far our functions print things, but printing and returning are completely different operations. print() displays text on your screen — the value is shown once and then gone. return hands the value back to the caller, where it can be stored in a variable, used in a calculation, passed into another function, or sent across a network.

This is the difference between a calculator that shows you the answer on its display (useful, but the moment you clear it the answer is gone) versus one that writes the answer on a receipt you can take with you, add to another number, or hand to someone else.

A function stops executing the moment it hits a return statement — any code written after that line in the same function won't run. You can have multiple return statements inside a function, typically inside if/else branches, which lets you return different values based on different conditions. Just make sure every branch returns something and that all branches return the same type — inconsistent return types are one of the things that makes callers fragile.

If a function reaches the end of its body without hitting any return statement, Python silently returns None. No warning, no error — just None. This is the most common source of silent bugs I've seen in production Python: a function that looks correct during manual testing because print() shows the expected output on screen, but every caller quietly receives None and breaks downstream.

One pattern worth knowing early: returning multiple values. Python lets you return more than one value by separating them with commas — return width, height. Python wraps them in a tuple automatically, and the caller can unpack them cleanly: w, h = get_dimensions(). This is idiomatic Python and appears constantly in professional code.

# ── Basic return ──────────────────────────────────────────────────────────────
# This function CALCULATES a value and GIVES IT BACK to the caller.
# Without 'return', the result would be trapped inside the function and lost.
def calculate_area_of_rectangle(width, height):
    area = width * height   # Do the calculation
    return area             # Hand the result back to whoever called us

# The returned value lands in 'living_room_area' — we can use it anywhere
living_room_area = calculate_area_of_rectangle(5, 4)
print(f"Living room area: {living_room_area} square metres")

# We can use the return value directly in an expression — no intermediate variable
total_area = calculate_area_of_rectangle(5, 4) + calculate_area_of_rectangle(3, 3)
print(f"Combined area: {total_area} square metres")


# ── Multiple return paths ─────────────────────────────────────────────────────
# The function returns a different value based on which condition is true.
# It stops the moment it hits any 'return' statement — nothing after it runs.
def classify_temperature(celsius):
    if celsius < 0:
        return "freezing"        # function exits here if celsius < 0
    elif celsius < 15:
        return "cold"            # function exits here if 0 <= celsius < 15
    elif celsius < 25:
        return "comfortable"     # function exits here if 15 <= celsius < 25
    else:
        return "hot"             # function exits here for everything else

print(classify_temperature(-5))   # freezing
print(classify_temperature(10))   # cold
print(classify_temperature(20))   # comfortable
print(classify_temperature(35))   # hot


# ── Returning multiple values ─────────────────────────────────────────────────
# Python packs multiple return values into a tuple automatically.
# The caller can unpack them cleanly with multiple assignment.
def get_price_breakdown(original, discount_pct):
    discount = original * (discount_pct / 100)
    final = original - discount
    return final, discount   # returns a tuple (final, discount)

final_price, savings = get_price_breakdown(100, 20)
print(f"Pay ${final_price:.2f}, save ${savings:.2f}")


# ── What happens without return ───────────────────────────────────────────────
# This function prints but does NOT return anything.
# Python silently returns None — no warning, no error.
def print_greeting(name):
    print(f"Hello, {name}!")

# Storing the 'result' of a function with no return statement...
result = print_greeting("Maya")
print(f"The return value was: {result}")   # None — this is the silent bug

Variable Scope — Why Your Variable Disappears Outside the Function

Scope is one of those concepts that trips up nearly every beginner, but the mental model is simple once it clicks: variables created inside a function live only inside that function. They're born when the function is called and they disappear when the function returns. Code outside the function cannot see or access them.

This is called local scope. Variables defined outside all functions live in global scope and can be read from anywhere in the same file. Modifying them from inside a function requires the global keyword — which you should almost always avoid. Global mutation creates invisible dependencies: Function A modifies a global, Function B reads the same global, and now the behaviour of B depends on whether A ran first and in what order. Under concurrency, that becomes a race condition.

The right pattern is always the same: pass data in via parameters, get data out via return. Think of a function as a sealed workshop. You pass raw materials in through a hatch (parameters), work happens inside, and finished goods come back out (return). The workshop doesn't secretly rearrange your living room while it works, and your living room can't interfere with what's happening inside the workshop.

Python actually resolves variable names by searching through four scopes in order — local, enclosing, global, built-in — known as the LEGB rule. Understanding this explains why a variable inside a nested function can see variables from the outer function (enclosing scope), and why you can always use len or print without importing them (built-in scope). When you define a local variable with the same name as a global, the local one wins inside the function — this is called shadowing, and it's usually a sign you've accidentally reused a name.

# ── Local scope demonstration ─────────────────────────────────────────────────
def brew_coffee(bean_type):
    # 'brewing_temperature' is a LOCAL variable.
    # It only exists while this function is running.
    brewing_temperature = 93   # degrees Celsius — perfect for filter coffee
    result = f"Brewing {bean_type} at {brewing_temperature}°C"
    return result

cup = brew_coffee("Ethiopian Yirgacheffe")
print(cup)

# 'brewing_temperature' does not exist out here — it died when the function returned.
# Uncomment the next line to see it: NameError: name 'brewing_temperature' is not defined
# print(brewing_temperature)


# ── Global vs local ───────────────────────────────────────────────────────────
# 'shop_name' is a GLOBAL variable — defined outside any function.
shop_name = "TheCodeForge Coffee"

def display_shop_info():
    # We can READ global variables from inside a function without any keyword.
    print(f"Welcome to {shop_name}")

display_shop_info()


# ── The LEGB rule in action ───────────────────────────────────────────────────
message = "global"   # global scope

def outer():
    message = "enclosing"   # enclosing scope for inner()

    def inner():
        # message = "local"   # uncomment to see local scope win
        print(f"inner sees: {message}")   # finds 'enclosing' — not global

    inner()
    print(f"outer sees: {message}")       # finds 'enclosing'

outer()
print(f"module sees: {message}")          # finds 'global'


# ── The right pattern: pass in, return out ────────────────────────────────────
# Data flows through parameters and return — no hidden global state.
def apply_loyalty_discount(original_price, loyalty_points):
    # All variables here are local — they cannot leak out or cause side effects.
    discount_rate = min(loyalty_points * 0.01, 0.30)   # cap at 30%
    discounted_price = original_price * (1 - discount_rate)
    return round(discounted_price, 2)

final_price = apply_loyalty_discount(50.00, 15)
print(f"Price after loyalty discount: ${final_price}")