Python 在递归代码中返回另一个 function --> 它是如何工作的？

Question

I'm studying merge sort using python and I can't understand this code example.

'''

def merge(left, right):
    merged = list()
    left_point, right_point = 0, 0

    # case1 - left/right 둘다 있을때
    while len(left) > left_point and len(right) > right_point:
        if left[left_point] > right[right_point]:
            merged.append(right[right_point])
            right_point += 1
        else:
            merged.append(left[left_point])
            left_point += 1

    # case2 - left 데이터가 없을 때
    while len(left) > left_point:
        merged.append(left[left_point])
        left_point += 1

    # case3 - right 데이터가 없을 때
    while len(right) > right_point:
        merged.append(right[right_point])
        right_point += 1

    return merged


def mergesplit(data):
    if len(data) <= 1:
        return data
    medium = int(len(data) / 2)
    left = mergesplit(data[:medium])
    right = mergesplit(data[medium:])
    return merge(left, right)

''' Let's say I have an array [6,2,3,9,5,7]

Then it'll be split to a half size and it will call merge(left,right) if the len(data) is larger than 1.

BUT the thing is, isn't a stack is destroyed if you call return merge(left, right)? So how can you apply recursive here when the function returns another function? Also, merge(left, right) function return 'merged', but there's no list variable that can held merged(eg receive_list=merge(left,right)) so how can we receive merge?

I've always used java so it't my first time using python

Maybe there are some principle of python I'm missing?

Thanks in advance!

Answer 1

Perhaps this helps.

To sort array arr

We split arr in half, and call mergesplit on the left and right halves

left = mergesplit(data[:medium])
right = mergesplit(data[medium:])

Each of these mergesplit calls splits its array into left and right halves and calls mergesplit on each of these (ie left child and right child).

This can be visualized as a call tree with each parent node having two children (left & right).

The successive calls of mergesplit continues until the base case:

if len(data) <= 1:
    return data

This returns its data (single value) to its parent.

The parent has left and right (each a single value).

It returns merge of these two values (left, right) to its parent:

 return merge(left, right)

So to answer your basic question about who receives the return of merge, we see that it goes to the parent.

The higher parent has a left, right (two values) each, so an array with four elements total.

Each parent in the call tree calls merge on the right and left that it receives from its child returning the merge result to its parent.

This unwinds back up the tree until we get to the top node that returns the result of the merge to the original caller.

Add Showing of Stack

import sys
import inspect

def merge(left, right):
    show_info('merge')
    merged = list()
    left_point, right_point = 0, 0

    # case1 - left/right 둘다 있을때
    while len(left) > left_point and len(right) > right_point:
        if left[left_point] > right[right_point]:
            merged.append(right[right_point])
            right_point += 1
        else:
            merged.append(left[left_point])
            left_point += 1

    # case2 - left 데이터가 없을 때
    while len(left) > left_point:
        merged.append(left[left_point])
        left_point += 1

    # case3 - right 데이터가 없을 때
    while len(right) > right_point:
        merged.append(right[right_point])
        right_point += 1

    return merged

def mergesplit(data):
    show_info('mergesplit:')
    if len(data) <= 1:
        return data
    medium = int(len(data) / 2)
    left = mergesplit(data[:medium])
    right = mergesplit(data[medium:])
    return merge(left, right)

def show_info(message):
  " Shows locals and stack trace "
  previous_frame = sys._getframe(1)
  previous_frame_locals = previous_frame.f_locals

  # Stack Depth of caller
  depth = len(inspect.stack(0)) - 3 # 3 things to start so offset
  offset = depth*2

  print('\t'*offset + message, "\n" + '\t'*offset, previous_frame_locals)

mergesplit([4, 3, 2, 1])

Example

mergesplit([4, 3, 2, 1])

Output

This results the stack as mergesplit and merge are called illustrating the recursive nature of the calls.

mergesplit: 
 {'data': [4, 3, 2, 1]}
        mergesplit: 
         {'data': [4, 3]}
                mergesplit: 
                 {'data': [4]}
                mergesplit: 
                 {'data': [3]}
                merge 
                 {'left': [4], 'right': [3]}
        mergesplit: 
         {'data': [2, 1]}
                mergesplit: 
                 {'data': [2]}
                mergesplit: 
                 {'data': [1]}
                merge 
                 {'left': [2], 'right': [1]}
        merge 
         {'left': [3, 4], 'right': [1, 2]}