递归函数，最终打印语句

Question

I'm self-learning Python, using How to Think Like a Computer Scientist. I am learning "Nodes and Linked Lists". This recursive function is confusing me. To be clear, the code works fine. I am asking, how is it possible that the final line of code at the bottom ( print list, ) is being executed?

My question is regarding this recursive function:

def print_backward (list):
    if list == None: return  #shouldn't the code terminate when this is satisfied?
    print_backward(list.next)
    print list, #seems like the function would terminate before this line 
                #ever gets called

Can someone explain to me, when is this last line print head, being executed? Reading this code, I would think that we loop back to the top of the function after evaluating each node, then when we reach the 3rd and final node, the terminating statement if list == None: return will be satisfied, and the code would then exit the loop, never reaching the print statement at the very bottom. Clearly that is not happening though, since the print statement IS being called.

I'm asking because I feel like I'm not really learning if I don't understand how the code works! If someone can explain how the code gets to that final print statement (and it is getting there), I'd really appreciate it. I hope I'm not violating the rules by asking this. Thanks!

BTW I'm printing a linked, list, cargo is [1,2,3]. Printing it backward, so [3,2,1] Below, is the code for more context.

---

class Node:
    def __init__(self, cargo = None, next = None):
        self.cargo = cargo
        self.next = next

    def __str__(self):
        return str(self.cargo)

def print_list(node):
    while node:
        print node,
        node = node.next
    print


def print_backward (list):
    if list == None: return
    print_backward(list.next)
    print list,

node1 = Node(1)
node2 = Node(2)
node3 = Node(3)

node1.next = node2
node2.next = node3
node3.next = None

print_backward(node1)

Output is:

==== RESTART: /Users/Desktop/Programming Career/Untitled.py ====

3 2 1

Answer 1

Let's parse through what the code is doing node by node

1. print_backward is called with node1
2. is node1 == None none? No so we continue
3. We assign head = node1
4. We assign tail = node1.next same as tail = node2
5. We call print_backward(tail) same as print_backward(node2)
   1. print_backward is called with node2
   2. is node2 == None none? No so we continue
   3. We assign head = node2
   4. We assign tail = node2.next same as tail = node3
   5. We call print_backward(tail) same as print_backward(node3)
      1. print_backward is called with node3
      2. is node3 == None none? No so we continue
      3. We assign head = node3
      4. We assign tail = node3.next same as tail = None
      5. We call print_backward(tail) same as print_backward(None)
         1. print_backward is called with None
         2. is None == None none? Yes so we return
      6. print head, is called, same as print node3, (printing "3 ")
   6. print head, is called, same as print node2, (printing "2 ")
6. print head, is called, same as print node1, (printing "1 ")

Total output is, "3 2 1 "!

Answer 2

Recursion doesn't mean jumping to the top of the function; it means calling the same function within a function.

I think a simpler example makes it more obvious:

def count(number):
    if number <= 0: return
    count(number-1)
    print(number)

When we call count(3) , the function will print the numbers 1 through 3. Why? Because this is what happens:

1. count(3) is called.
2. number is 3, which is not below or equal to zero, so we don't return .
3. We call count(3-1) :
   1. count(2) is called.
   2. number is 2, which is not below or equal to zero, so we don't return .
   3. We call count(2-1) :
      1. count(1) is called.
      2. number is 1, which is not below or equal to zero, so we don't return .
      3. We call count(1-1) :
         1. count(0) is called.
         2. number is 0, which is equal to zero, so we return to the previous level.
      4. We print 1.
   4. We print 2.
4. We print 3.