# minte9 LearnRemember

S R Q

### Line

p05 Programming languages remember the line that called the function.
``````  """ Programming languages remembers the line of code that called
a function. It returns to that line when the function
finishes its execution.
"""

def line_remembering_function():
print('Line 08')
goto()

print('Line 10')
return

def goto():
return

line_remembering_function()

"""
Line 08
Line 10
"""
``````

### Stacks

p06 The stacks are used to manage the order of function calls.
``````  """ Stacks
A stack stores multiple values like a list.
Stacks are LIFO data structure (last in, first out)
"""

cards = []
cards.append('5'); print(' '.join(cards))
cards.append('3'); print(' '.join(cards))
cards.append('7'); print(' '.join(cards))
cards.pop();       print(' '.join(cards)) # Last in, First out

"""
5
5 3
5 3 7
5 3
"""
``````

### Frame objects

p09 A frame object is a data structure that represents the state of a function call.
``````  """ Frame objects
A Frame contain information about a single function call.
Frames are created and pushed onto the stack when function is called.

When the function returns, that frame is popped off the stack,
and the previous frame object becomes the current one,
resuming the execution of the calling function from where it left off.
"""

def frame_objects(i=1):
print('A Frame', 'No.', i)
second_func(i+1)
print('A Frame', 'No.', i)
return

def second_func(i):
print('B Frame', 'No.', i)
third_func(i+1)
print('B Frame', 'No.', i)
return

def third_func(i):
print('C Frame', 'No.', i)
return

frame_objects()

"""
A Frame No. 1
B Frame No. 2
C Frame No. 3
B Frame No. 2
A Frame No. 1
"""
``````

### Stack overflow

p13 The limit of stack size is 1000 function calls in Python.
``````  """ Stack overflow
The limit of calls is called maximum recursion depth.
Stack overflows don't damage the computer, it just terminate the program.
For Python, this size is set to 1000.
"""

def repeat():
repeat()

repeat() # RecursionError: maximum recursion depth exceeded
``````

### Base case

p15 To avoid a crash there must be a base case.
``````  """ Base case
To avoid a crash, there must be a base case,
where function stop calling itself and just returns.

The code in a recursive call can be split in two parts,
before the recursive call and after recursive call.
"""

def show_frame(i=1):
print('Frame', i)

if i == 3:
print(i * " ", 'Base case')
return

print(i * " ",'Recursive case', i)
show_frame(i+1)

print(i * " ",'Recursive return', i)
return

show_frame()

"""

Frame 1
Recursive case 1
Frame 2
Recursive case 2
Frame 3
Base case
Recursive return 2
Recursive return 1

"""
``````

Questions