Tail Recursion
A special sort of Recursion in which a function's last procedure is a recursive call. Instead of establishing a new stack frame, the loop can be avoided by performing the request in the existing stack frame and returning the output. The compiler may optimize tailrecursion, making it better than nontail recursive routines.
Most of the modernday compilers convert tail call recursive calls into goto statements on their own
Is it feasible to utilize a tailrecursive function instead of a nontail recursive function to optimize a program?
Consider a recursive function to implement the sum of consecutive numbers up to n.
Code  Nontailrecursive
def recurSum(x):
if x == 0:
return 0
# base case, if x is 0, return 0
else:
return x + recurSum(x  1)
# recursive case, if x is not 0, return x + recurSum(x  1)
print(recurSum(5))
# inital call
Compiler Interpretation
recurSum(5)
5 + recurSum(4)
5 + (4 + recurSum(3))
5 + (4 + (3 + recurSum(2)))
5 + (4 + (3 + (2 + recurSum(1))))
5 + (4 + (3 + (2 + (1 + recurSum(0)))))
5 + (4 + (3 + (2 + (1 + 0))))
5 + (4 + (3 + (2 + 1)))
5 + (4 + (3 + 3))
5 + (4 + 6)
5 + 10
15
Output
15
With that much function overhead, normal recursion is not optimized at all
Code  Tail recursive
def recurSum(x, runSum=0):
if x == 0:
return runSum
# base case, if x is 0, return running sum
else:
return recurSum(x  1, runSum+x)
# recursive case, if x is not 0, return recurSum(x  1, runSum+x)
print(recurSum(5))
# inital call
Compiler interpretation
recurSum(5, 0)
recurSum(4, 5)
recurSum(3, 9)
recurSum(2, 12)
recurSum(1, 14)
recurSum(0, 15)
15
Output
15
Since there is much less function overhead than usual recursive functions, thatâ€™s why it is considered optimized recursion.
Strategy for solving Recursive Problem:
The strategy for solving a recursive problem is that first, we have to think about the smallest size of problems and write down their solution that is nothing but abase case, now when we solved the base case then we go through the recursive case and at last we have to assemble all these smaller cases to solve the bigger cases so combining both of the base case and recursive cases we got the solution of our original problems which may have of any size.
Benefits of using Recursion:
 By using recursion in our code we can make our program clean and elegant.
 Hereby using recursion, we can solve the more and more complex programs by broken down into simpler subproblems and finding the solution of them through which collectively we solve whole the task.
 In Recursion, It takes fewer lines of code to solve a problem.
 One thing that is easier, by using recursion is that sequence generation other than using some nested iteration
Drawbacks of using Recursion:
 Sometimes it is hard to follow the logic behind the recursion as not all the problems can be solved using recursion.
 Here, If you donâ€™t define the base cases then the code would run infinitely.
 Recursive calls are inefficient as they take up a lot of memory spaces and time.
 They are hard to debug as the function calling itself in a loop and it is hard to understand which call is causing the issue.
Frequently Asked Questions
What is tail recursion, and what is it used for?
If the recursive call is the last and only call in the recursive function, then it is considered as tail recursion, it is used to further optimize the recursive function and reduce the function overhead
Why do we need base cases?
Base cases are the most important part of any recursive function, without base cases, the function will execute infinitely and never end and will cause RecursionError in python.
What are some of the recursion's drawbacks?
In recursion, weâ€™ve to be very careful writing base cases or there will be memory overflow or stack overflow if the base case isnâ€™t written correctly, or the limit of recursion exceeds during the program and at last, itâ€™s really hard to debug.
What are the basic qualities of recursive functions?
In recursive programming, a larger problem can be easily broken down into smaller segments and then can easily be solved and the code structure becomes really easy to understand.
Conclusion
 Cheers if you reached here! In this blog, we saw and learned Recursion in Python
 We have also seen different types of examples and how to decide the base cases in recursion.

Further, we saw how to optimize recursion using the tail recursion technique.
If you want to master questions on recursions and practice for Interviews, you can visit Top Recursion and Backtracking Interview Questions.
Also check out  Rod Cutting Problem, Fibonacci Series in Python
Recommended Readings:
On the other hand, learning never ceases, and there is always more to learn. So, keep learning and keep growing, ninjas!
Good luck with your preparation!