Python递归调用函数时为何使用return？无return但结果相同是否可行？

Great questions—let’s break these down with practical examples to make things crystal clear!

Recursion works by breaking a problem into smaller subproblems, solving each one, and combining their results to get the final answer. The return statement is what lets us pass the result of a subproblem back up to the parent call. Without it, those intermediate results just vanish into thin air.

Let’s take a classic factorial example to see this in action. Here’s a broken recursive function without return:

def factorial(n):
    if n == 1:
        print("Hit base case: 1")
    else:
        # We calculate n * factorial(n-1), but never send this value back
        factorial(n-1) * n

If you call factorial(5), you’ll see the base case print, but the function will return None instead of 120. Why? Because when we reach the base case (n=1), we don’t return that 1 to the call factorial(2). So factorial(2) tries to multiply None * 2, which doesn’t produce a meaningful value—and we never return that either.

Now here’s the fixed version with return:

def factorial(n):
    if n == 1:
        return 1  # Send base case value back up
    else:
        # Calculate n * subproblem result, then return that to the parent
        return factorial(n-1) * n

Each recursive call returns its result to the one that called it, building up the final value step by step. Without return, there’s no way to pass those results up the chain—your recursion just does work but doesn’t hand you the final answer.

First, we need to clarify: are we talking about console output (like things printed to the screen) or the function’s return value (the data it passes back to the code that called it)? These are two very different things.

Let’s use a simple greeting function to illustrate:

# With return: prints and returns the message
def greet(name):
    msg = f"Hey, {name}!"
    print(msg)
    return msg

# Without return: only prints the message
def greet_no_return(name):
    msg = f"Hey, {name}!"
    print(msg)

If you call both greet("Charlie") and greet_no_return("Charlie"), you’ll see the same line printed to the console. But the similarity ends there. Suppose you want to save that greeting to a variable or use it elsewhere:

my_greeting = greet("Charlie")
my_empty_greeting = greet_no_return("Charlie")

print(my_greeting)  # Outputs: Hey, Charlie!
print(my_empty_greeting)  # Outputs: None

The function without return automatically returns None (Python’s way of saying "nothing useful here"). So if your function is only meant to perform a side effect (like printing, writing to a file, or updating a global variable), you might get away without return for now. But this is risky:

• If you later need to use the function’s output in another part of your code, you’ll have to go back and add the return statement.
• It makes your code less clear: other developers (or future you) won’t know if the function is supposed to return something or just do a task.

As a rule of thumb: if your function computes a value that someone might want to use, always use return. If it’s just performing an action with no useful value to pass back, you can omit it—but even then, some developers prefer to add return None explicitly to make the function’s behavior clear.

内容的提问来源于stack exchange，提问作者Amanda