[go: up one dir, main page]
Scribd
Upload
63 views4 pages

Recursion in Python: Advantages of Using Recursion

Recursion in Python refers to a process where a function calls itself directly or indirectly. The document provides examples of recursive functions to calculate a Fibonacci sequence and factorial. It defines recursion and tail recursion, noting that tail recursion can be optimized by compilers by reusing the current stack frame rather than generating a new one. The document discusses advantages like splitting problems into smaller subproblems, and disadvantages like increased memory and time usage.

Uploaded by

Monu Kushwaha
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
63 views4 pages

Recursion in Python: Advantages of Using Recursion

Recursion in Python refers to a process where a function calls itself directly or indirectly. The document provides examples of recursive functions to calculate a Fibonacci sequence and factorial. It defines recursion and tail recursion, noting that tail recursion can be optimized by compilers by reusing the current stack frame rather than generating a new one. The document discusses advantages like splitting problems into smaller subproblems, and disadvantages like increased memory and time usage.

Uploaded by

Monu Kushwaha
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 4

Recursion in Python

The term Recursion can be defined as the process of defining something in terms of itself.


In simple words, it is a process in which a function calls itself directly or indirectly.

Advantages of using recursion


 A complicated function can be split down into smaller sub-problems utilizing
recursion.
 Sequence creation is simpler through recursion than utilizing any nested
iteration.
 Recursive functions render the code look simple and effective.

Disadvantages of using recursion


 A lot of memory and time is taken through recursive calls which makes it
expensive for use.
 Recursive functions are challenging to debug.
 The reasoning behind recursion can sometimes be tough to think through.
Syntax:
def func(): <--
|
| (recursive call)
|
func() ----
Example 1:
A Fibonacci sequence is the integer sequence of 0, 1, 1, 2, 3, 5, 8....

def recursive_fibonacci(n):
   if n <= 1:
       return n
   else:
       return(recursive_fibonacci(n-1) + recursive_fibonacci(n-2))
   
n_terms = 10
   
# check if the number of terms is valid
if n_terms <= 0:
   print("Invalid input ! Please input a positive value")
else:
   print("Fibonacci series:")
   for i in range(n_terms):
       print(recursive_fibonacci(i))

Example 2:
The factorial of 6 is denoted as 6! = 1*2*3*4*5*6 = 720.
def recursive_factorial(n):  
   if n == 1:  
       return n  
   else:  
       return n * recursive_factorial(n-1)  
  
# user input
num = 6
  
# check if the input is valid or not
if num < 0:  
   print("Invalid input ! Please enter a positive number.")  
elif num == 0:  
   print("Factorial of number 0 is 1")  
else:  
   print("Factorial of number", num, "=", recursive_factorial(num))
Tail-Recursion

A unique type of recursion where the last procedure of a function is a recursive call.
The recursion may be automated away by performing the request in the current stack
frame and returning the output instead of generating a new stack frame. The tail-
recursion may be optimized by the compiler which makes it better than non-tail
recursive functions.
Is it possible to optimize a program by making use of a tail-recursive function
instead of non-tail recursive function?
Considering the function given below in order to calculate the factorial of n, we can
observe that the function looks like a tail-recursive at first but it is a non-tail-recursive
function. If we observe closely, we can see that the value returned by Recur_facto(n-1)
is used in Recur_facto(n), so the call to Recur_facto(n-1) is not the last thing done by
Recur_facto(n).

def Recur_facto(n, a = 1): 


    
    if (n == 0): 
        return a 
    
    return Recur_facto(n - 1, n * a) 
    
# print the result
print(Recur_facto(6))
1. Write a Python program to calculate the sum of a list of numbers. 

2. Write a Python program to converting an Integer to a string in any base. 

3. Write a Python program of recursion list sum. 

Test Data: [1, 2, [3,4], [5,6]]


Expected Result: 21

4. Write a Python program to get the factorial of a non-negative integer. 

5. Write a Python program to solve the Fibonacci sequence using recursion. 

6. Write a Python program to get the sum of a non-negative integer. 


Test Data:
sumDigits(345) -> 12
sumDigits(45) -> 9

7. Write a Python program to calculate the sum of the positive integers of n+(n-2)+(n-4)...
(until n-x =< 0). 

Test Data:
sum_series(6) -> 12
sum_series(10) -> 30

You might also like