I favor recursive solutions when:

• The implementation of the recursion is much simpler than the iterative solution, usually because it exploits a structural aspect of the problem in a way that the iterative approach cannot

• I can be reasonably assured that the depth of the recursion will not cause a stack overflow, assuming we're talking about a language that implements recursion this way

Condition 1 doesn't seem to be the case here. The iterative solution is about the same level of complexity, so I'd stick with the iterative route.

You are actually right, the logic behind is the same and you can also apply while loop for e.g. Fibonacci sequence. Just the notation of recursion is usually shorter and more elegant.

Your code can be even simplified a bit and then you see that your solutions are kind of similar:

While loop:

def countdown(n):
    while n > 0: # Step 1 -> check
        print(n)
        n = n-1 # Step 2  -> recursive call in while loop
    print('Blast off!') # Step 3 -> end ensured by Step 1

Recursion:

def countdown(n):
    if n > 0: # Step 1 -> check
        print(n)  
        return countdown(n-1) # Step 2 -> recursive call of the countdown()
    else:
        print('Blast off!') # Step 3 -> end ensured by Step 1

Significant is that action n-1. You recursively act on a variable or object (Step 2) as long as your condition related to that variable/object is valid (Step 1).

Recursion is not intrinsically better or worse than loops - each has advantages and disadvantages, and those even depend on the programming language (and implementation).

Technically, iterative loops fit typical computer systems better at the hardware level: at the machine code level, a loop is just a test and a conditional jump, whereas recursion (implemented naively) involves pushing a stack frame, jumping, returning, and popping back from the stack. OTOH, many cases of recursion (especially those that are trivially equivalent to iterative loops) can be written so that the stack push / pop can be avoided; this is possible when the recursive function call is the last thing that happens in the function body before returning, and it's commonly known as a tail call optimization (or tail recursion optimization). A properly tail-call-optimized recursive function is mostly equivalent to an iterative loop at the machine code level.

Another consideration is that iterative loops require destructive state updates, which makes them incompatible with pure (side-effect free) language semantics. This is the reason why pure languages like Haskell do not have loop constructs at all, and many other functional-programming languages either lack them completely or avoid them as much as possible.

The reason why these questions appear so much in interviews, though, is because in order to answer them, you need a thorough understanding of many vital programming concepts - variables, function calls, scope, and of course loops and recursion -, and you have to bring the mental flexibility to the table that allows you to approach a problem from two radically different angles, and move between different manifestations of the same concept.

Experience and research suggest that there is a line between people who have the ability to understand variables, pointers, and recursion, and those who don't. Almost everything else in programming, including frameworks, APIs, programming languages and their edge cases, can be acquired through studying and experience, but if you are unable to develop an intuition for these three core concepts, you are unfit to be a programmer. Translating a simple iterative loop into a recursive version is about the quickest possible way of filtering out the non-programmers - even a rather inexperienced programmer can usually do it in 15 minutes, and it's a very language-agnostic problem, so the candidate can pick a language of their choice instead of stumbling over idiosyncracies.

If you get a question like this in an interview, that's a good sign: it means the prospective employer is looking for people who can program, not people who have memorized a programming tool's manual.

A recursive algorithm calls a function from within that same function (recursion). Whether to perform the recursion is based on some condition.

    function foo()
    {
            ?/ do work
            if( condition )
                    foo();
    }

An iterative algorithm typically calls a function some number of times (n).

    function foo()
    {}

    for(int i = 0; i < n; i++)
            foo();

A recursive function is typically used when some piece of data needs to be manipulated repeatedly and the condition of whether to repeat is dependent on the previous manipulation. Computing a truncated infinite series in math is an example of this.

An iterative function is typically used when the condition is not dependent on the previous manipulation. Inverting a matrix has a predefined n.

Either method can be used for most purposes, but you will typically find that one is easier than the other for a particular case.

Be aware of callstack overflow with recursion though. It is best to only use it if you can guarantee that the algorithm will converge and end within some number of recursions.

Better is naturally a subjective term. As mentioned in the comments, both run in O(n) time in terms of runtime complexity. However, depending on the details of the language, recursive functions often take up more space in memory.

Specifically, since you seem to be using Python, each recursive call requires a new function call frame, keeping track of that function call's variables. This takes up significantly more space than a simple loop while taking effectively the same amount of time. In fact, to limit your use of deep recursion, Python by default has a recursion depth limit of 1000; aka, you would not be able to calculate the factorial of numbers above 1000 this way.

Generally speaking, which is the better option depends on the language. And loops will almost always take up less if not equal space to a recursive function. However, this doesn't mean that recursion is useless! When it comes to a simple example like the factorial function, recursion is not at all necessary. However when you are building complex data structures or algorithms, recursion is occasionally necessary if not incredibly cleaner in order to write your solution.

Ultimately Recursion and Loops are nearly the same. I prefer to use recursion when

1. The implementation of the recursive solutions is much simpler than the iterative solution
2. I can be sure that the recursion won't cause a stack overflow by going too deep into the callstack

Tree Traversal, Graph Traversal, and Sorting are all good examples of places that recursion is likely your best option