Understanding Unusual Behavior in Python's functools.reduce() Function with Custom Reducer Function

I've been working on a Python project that requires the use of the functools.reduce() function. I came across an unusual behavior when using a custom reducer function, and I am unable to figure out the root cause of the issue.

Here's the code snippet:

import functools

def custom_reducer(x, y):
    return x * y - x + y

numbers = [1, 2, 3, 4, 5]

result = functools.reduce(custom_reducer, numbers)
print("Result:", result)

I expected the result to be calculated as follows:

custom_reducer(3, 3) =\> 3 \* 3 - 3 + 3 = 9
custom_reducer(9, 4) =\> 9 \* 4 - 9 + 4 = 31
custom_reducer(31, 5) =\> 31 \* 5 - 31 + 5 = 135

However, the actual output I received was: Result: 149 This result is different from my expected value, and I am unsure why this is happening. Could someone please explain what's going on under the hood when using a custom reducer function with functools.reduce()? Is there a specific property or behavior of the reduce() function that causes this discrepancy? Also, if there's a more optimal way to achieve the same result using a different approach, please share it.

This should help explain "what's going on under the hood" and where the mistake in understanding is:

steps = [numbers]

while len(steps[-1]) > 1:
    last_step = steps[-1]
    one_reduce = custom_reducer(last_step[0], last_step[1])
    steps.append([one_reduce, *last_step[2:]])

steps == [
    [1, 2, 3, 4, 5],
    [3, 3, 4, 5],
    [9, 4, 5],
    [31, 5],
    [129],
]  # true