Find the minimum path sum in a binary tree
There's no docstring. What kind of thing is a TreeNode? What does the min_path method do? What should I pass for each of the parameters?
The code is written in Python 2.7, which is obsolescent (it gets bug fixes but no new features). We'll see later that this causes inconvenience because of the lack of the nonlocal statement. I suggest switching to Python 3.
The duplicated code for pushing and popping the prefix list, and updating sum_so_far, can be avoided, like this:

def min_path(self, sum_so_far, prefix, result, result_path):
    prefix.append(self.value)
    sum_so_far += self.value
    if self.left:
        self.left.min_path(sum_so_far, prefix, result, result_path)
    if self.right:
        self.right.min_path(sum_so_far, prefix, result, result_path)
    if not self.left and not self.right: # leaf node
        if sum_so_far &lt; result[0]:
            result[0] = sum_so_far
            if len(result_path) &gt; 0:
                result_path.pop(0)
            result_path.append(prefix[:])
    prefix.pop(-1)

The duplicated code for visiting the children can be avoided, like this:

children = [c for c in (self.left, self.right) if c]
if children:
    for child in children:
        child.min_path(sum_so_far, prefix, result, result_path)
else: # leaf node
    # etc.

But a better approach would be to use a locally defined function, like this:

def min_path(root):
    """Return list of values on the minimum path from root to a leaf."""
    min_path = []
    min_sum = [float('inf')]
    prefix = []

    def visit(node, sum_so_far):
        prefix.append(node.value)
        sum_so_far += node.value
        children = [c for c in (node.left, node.right) if c]
        if children:
            for child in children:
                visit(child, sum_so_far)
        elif sum_so_far &lt; min_sum[0]:
            min_sum[0] = sum_so_far
            min_path[:] = prefix[:]
        prefix.pop(-1)

    visit(root, 0)
    return min_path


This still uses the trick of updating the first element of a list in order to update a result inside a possibly nested function call, but at least here the trick is hidden inside the implementation, and not exposed to the caller.

(In Python 3, you could write nonlocal min_sum and so avoid the need for the trick.)
Alternatively, you could use the stack of iterators pattern. This avoids making recursive function calls, and so there's no difficulty in maintaining the running minimum.

def min_path(root):
    """Return list of values on the minimum path from root to a leaf."""
    min_path = []
    min_sum = float('inf')
    current_path = [0]
    current_sum = 0
    stack = [iter([root])]
    while stack:
        for node in stack[-1]:
            current_path.append(node.value)
            current_sum += node.value
            children = [n for n in (node.left, node.right) if n]
            stack.append(iter(children))
            if not children and current_sum &lt; min_sum:
                min_sum = current_sum
                min_path = current_path[1:]
            break
        else:
            current_sum -= current_path.pop()
            stack.pop()
    return min_path