Consider the following code:

`````` 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47"""
This program will ask the user to enter the side lengths
of a rectangle.

Two functions will be used to compute the area and perimeter
of the rectangle.

The area and perimeter will be printed back to the user.
"""
def perimeter_rectangle(length, width):
"""
Compute the perimeter of a rectangle
Args:
length (int): the length of the rectangle
width (int): the width of the rectangle
Returns:
int: the perimeter of the rectangle
"""
computed_perimieter = (length + width) * 2
return computed_perimieter

def area_rectangle(length, width):
"""
Compute the area of a rectangle
Args:
length (int): the length of the rectangle
width (int): the width of the rectangle
Returns:
int: the area of the rectangle
"""
computed_area = length * width
return computed_area

def main():
print("Let's compute data about a rectangle!")
side_one = int(input("Enter length: "))
side_two = int(input("Enter width: "))

area = area_rectangle(side_one, side_two)

# STOP DRAWING: show the stack before we run the next line
perimeter = perimeter_rectangle(side_one, side_two)

print("The area is %d" % (area))
print("The perimeter is %d" % (perimeter))

main()
``````

Let’s draw the stack:

1. Draw the empty stack and the heap.

2. When a function is called, create a stack frame for the function and put the frame on top of the stack. Usually, the first function called is `main`.

1. Allocate parameters, if any, on the stack. The `main` function typically does not have parameters but many other functions do.

2. Allocate variables used in the function. NOTE: For very large programs, you may want to skip drawing loop variables because they change frequently and can clutter your diagram. However, you should get in the habit of including them until you are comfortable enough to understand when they can be excluded. A loop variable is:

```for <loop_variable> in <sequence>:
<statements>
...```
3. Execute the function line-by-line.

• If another function is called, repeat at step 2.

• If the function has a `return` value, we say that the function evaluates to be that value. Be sure to set the variable in the calling function to the returned value, if applicable.

4. When you reach the end of the function, remove it from the stack.

3. Continue executing the function that is now on top of the stack. If the stack is empty, the program is complete.

Below are the steps for drawing the stack for the code shown above. Line numbers are included so you can see how each line impacts the drawing. Try drawing the stack yourself and see if you get the same drawing!

Step Line # What happens to the stack diagram

0

Create the stack and the heap.

Figure 1. Stack Diagram after step 0.

1

47

Put a frame for `main` on the stack.

Figure 2. Stack Diagram after step 1.

2

35

Put the variables `side_one`, `side_two`, `area`, and `perimeter` in the stack frame for `main`.

Figure 3. Stack Diagram after step 2.

3

36-37

Assume that the user types `3` for `side_one` and `5` for `side_two`. Draw arrows from the variables `side_one` and `side_two` to `3` and `5`, respectively.

Figure 4. Stack Diagram after step 3.

4

22

The `area_rectangle` function is called, so we make a stack frame for `area_rectangle` and put it on top of the stack.

5

22

Put parameters `length` and `width` in the stack frame for `area_rectangle`. We also put the local variable `computed_area` in the stack frame.

Figure 5. Stack Diagram after step 5.

6

22

We assign the first parameter, `length`, to be equal to the first argument, `side_one`. Draw an arrow from `length` to the same value as `side_one`.

7

22

We assign the second parameter, `width`, to be equal to the second argument, `side_two`. Draw an arrow from `width` to the same value as `side_two`.

Figure 6. Stack Diagram after step 7.

8

31

Calculate `length * width` and draw an arrow from `computed_area` to that value on the heap.

Figure 7. Stack Diagram after step 8.

9

32

We reach the `return` value at the end of the function. Keep track of the value being returned (shown here with the purple arrow). We say that the `area_rectangle` function evaluates to the value `15`.

Figure 8. Stack Diagram after step 9.

10

39

Since the function is complete, we remove the stack frame for `area_rectangle` and we assign the returned value to the variable `area`.

Figure 9. Stack Diagram after step 10.

11

42

Can you continue drawing the stack diagram starting on line 42?