为何我的Collatz序列代码触发"maximum recursion depth exceeded"错误？两类代码对比及修改方案问询

Hey Chris, let's break down exactly why your code is hitting that recursion depth error, how it differs from the working version, and how you can fix it (either by adjusting your code or adopting the working pattern).

First: Why Your Code Fails #

Let's look at the critical flaw in your collatz function:

def collatz(number):
    while number != 1:
        number=collatz(number)  # This is the problem!
        # None of the code below this line ever runs
        if number % 2 == 0:
            print ((int(number))//(2),sep='')
            return ((int(number))//(2))
        elif number % 2 == 1:
            print (3*int(number)+1,sep='')
            return (3*int(number)+1)

When you call collatz(5) (for example), here's what happens:

1. The function starts, checks 5 != 1, so enters the while loop.
2. Immediately, it calls collatz(5) again—this is a recursive call.
3. The new collatz(5) call does the exact same thing: enters the while loop and calls collatz(5) again.
4. This repeats infinitely, nesting function calls deeper and deeper until Python hits its default recursion depth limit (usually ~1000), triggering the maximum recursion depth exceeded error.

The kicker? Your if/elif logic never even runs—you're stuck in an infinite loop of recursive calls before you get to that code.

How the Working Code Differs #

The correct version uses a clean separation of concerns:

def collatz(number):
    if number % 2 ==0: #even number
        print ((int(number))//(2),sep='')
        return ((int(number))//(2))
    elif number % 2 ==1:#odd number
        print (3*int(number)+1,sep='')
        return (3*int(number)+1)

try:
    print('Enter number:')
    number=int(input('>')) #user input
    while number !=1: #performs loop until number becomes 1
        number=collatz(number) #number gets passed to collatz function until it arrives at 1
except ValueError:
    print('Please enter an integer')#error message if non-integer is input

• The collatz function only does one thing: take a number, calculate its next value in the Collatz sequence, print it, and return it. No loops, no recursion inside the function.
• The loop that drives the sequence (running until we hit 1) lives outside the function, in the main code. This is an iterative approach, not recursive—so there's no risk of hitting recursion depth limits.

Can You Fix Your Code? #

Absolutely! You have two solid options:

Option 1: Adjust Your Function to Match the Working Pattern #

Remove the while loop from inside your function, so it only handles a single step of the sequence, then add the loop outside:

def collatz(number):
    if number % 2 == 0:
        next_num = int(number) // 2
        print(next_num)
        return next_num
    elif number % 2 == 1:
        next_num = 3 * int(number) + 1
        print(next_num)
        return next_num

print('Enter number:')
number = int(input('>'))
while number != 1:
    number = collatz(number)

This is essentially the same as the working code, just formatted slightly differently. It'll run without recursion errors and follow the Collatz sequence correctly.

Option 2: Rewrite Your Function to Handle the Full Sequence (No External Loop) #

If you want the function to manage the entire sequence on its own, you can rewrite it to use an iterative loop inside (no recursion) or a proper recursive structure (note: recursion may still hit depth limits for very long sequences):

Iterative Version (Safe from Recursion Limits)

def collatz(number):
    while number != 1:
        if number % 2 == 0:
            number = number // 2
        else:
            number = 3 * number + 1
        print(number)

print('Enter number:')
number = int(input('>'))
collatz(number)

This keeps the loop inside the function but removes the recursive call—so it just iterates through the sequence directly.

Recursive Version (Works for Short Sequences)

def collatz(number):
    print(number)
    if number == 1:
        return
    if number % 2 == 0:
        collatz(number // 2)
    else:
        collatz(3 * number + 1)

print('Enter number:')
number = int(input('>'))
collatz(number)

This uses recursion correctly (it stops when number == 1 and only recurses for the next value), but for very large starting numbers, you might still hit recursion depth limits.

Final Recommendation #

The working code's pattern (external loop + single-step function) is the most reliable because it avoids recursion entirely, so you never have to worry about hitting depth limits. That said, either of the fixes above will get your code running correctly—you don't have to copy the working code exactly, but you do need to fix the infinite recursion in your original function.

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