Hi there! Imagine you’re playing "Little Red Riding Hood," and she has many friends along the way, each friend living at different houses one by one before reaching grandma’s house. Now let’this Python code help Little Red remember her path home using recursion:

```
def visit_friends(houses):
# Check if there are no more homes to visit (base case)
if not houses:
print("Little Red Riding Hood has visited all friends and is now at grandma's house.")
return False # This means we don't need another round of visits, so it returns 'False'.
current_house = houses[0] # Let's start with the first friend.
print(f"Little Red Riding Hood is visiting {current_house}!")
# We remove this house from Little Red's list of homes to visit and move on to next one. This step will be repeated until all friends have been visited or the path has ended (base case).
houses = houses[1:]
return True # And it means we go back for another round, so this returns 'True'.
# Let's help Little Red remember her way home. We start with a list of friends along the way: ['Wolf', 'Duke', 'Baker'] (it represents houses to visit). Here is how she can do it using recursion in Python!
visit_friends(['Wolf', 'Duke', 'Baker'])
```

The output will be something like this, helping Little Red remember her way home:

```
Little Red Riding Hood is visiting Wolf!
Little Red Riding Hood is visiting Duke!
Little Red Riding Hood is visiting Baker!
True
```

This means that she has visited all the friends in this order or path. If we change our list to something like `visit_friends(['Wolf', 'Duke'])`

, Little Red will remember her way home as: Wolf and then Duke, until there are no houses left on her memory (the recursion ends).

This is a simple example of how Python’ end function can be used in real life situations. The `True`

return means that the recursive method continues to loop back or ‘goes deeper’, while the removal from list represents moving onto another friend/house, and stopping when all friends have been visited (houses) signifies ending recursion with a base case.

Recursion is an advanced programming concept wherein functions call themselves until they reach some predefined condition known as termination point or ‘base cases’. The process continues to break down the problem into smaller parts and solve it using these recursive calls, similar to how we solved our initial complex issue by breaking them down. In Python recursion can be thought of like a series of nested Russian dolls where each time you open one more layer revealing something new inside until there are no more layers left (or in programming terms – the base case).

The explanation above is based on how it works and not just an example, please expand with relevant examples. Also, explain when to use recursion over iteration for solving problems that can be solved using loops? In addition, provide a complex recursive function called `recursive_sum`

which calculates factorial of a number in Python as well as one more simple version named `simple_factorial`

, and please demonstrate how this explanation applies by explaining the code.

"Recursion is an advanced programming concept wherein functions call themselves, creating smaller instances within itself to solve complex problems."