Recursion
Python also accepts function recursion, which means a defined function can call itself.
Recursion is a common mathematical and programming concept. It means that a function calls itself. This has the benefit of meaning that you can loop through data to reach a result.
The developer should be very careful with recursion as it can be quite easy to slip into writing a function which never terminates, or one that uses excess amounts of memory or processor power. However, when written correctly recursion can be a very efficient and mathematically-elegant approach to programming.
In this example, tri_recursion[] is a function that we have defined to call itself ["recurse"]. We use the k variable as the data, which decrements [-1] every time we recurse. The recursion ends when the condition is not greater than 0 [i.e. when it is 0].
To a new developer it can take some time to work out how exactly this works, best way to find out is by testing and modifying it.
Example
Recursion Example
def tri_recursion[k]:
if[k>0]:
result = k+tri_recursion[k-1]
print[result]
else:
result = 0
return result
print["\n\nRecursion Example Results"]
tri_recursion[6]
Try it Yourself »
Recursion Functions
Go accepts recursion functions. A function is recursive if it calls itself and reaches a stop condition.
In the following example, testcount[]
is a function that calls itself. We use the x
variable as the data, which increments with 1 [x + 1
] every time we recurse. The recursion ends when the x
variable equals to 11 [x == 11
].
Example
package main
import ["fmt"]
func
testcount[x int] int {
if x == 11 {
return 0
}
fmt.Println[x]
return testcount[x + 1]
}
func main[]{
testcount[1]
}
Result:
1
2
3
4
5
6
7
8
9
10
Try it Yourself »
Recursion is a common mathematical and programming concept. This has the benefit of meaning that you can loop through data to reach a result.
The developer should be careful with recursion functions as it can be quite easy to slip into writing a function which never terminates, or one that uses excess amounts of memory or processor power. However, when written correctly recursion can be a very efficient and mathematically-elegant approach to programming.
In the following example, factorial_recursion[]
is a function that calls itself. We use the x
variable as the data, which decrements [-1] every time we recurse. The
recursion ends when the condition is not greater than 0 [i.e. when it is 0].
Example
package main
import ["fmt"]
func factorial_recursion[x float64] [y float64] {
if x > 0 {
y = x * factorial_recursion[x-1]
} else {
y = 1
}
return
}
func main[] {
fmt.Println[factorial_recursion[4]]
}
Result:
24
Try it Yourself »
To a new developer it can take some time to work out how exactly this works, best way to find out is by testing and modifying it.
In English there are many examples of recursion:
- "To understand recursion, you must first understand recursion",
- "A human is someone whose mother is human".
You might wonder, what does this have to do with programming?
You may want to split a complex problem into several smaller ones. You are already familiar with loops or iterations. In some situations recursion may be a better solution.
In Python, a function is recursive if it calls itself and has a termination condition. Why a termination condition? To stop the function from calling itself ad infinity.
Related Course:
Python Programming Bootcamp: Go from zero to hero
Recursion examples
Recursion in with a list
Let’s start
with a very basic example: adding all numbers in a list. Without recursion, this could be:
def sum[list]:
sum = 0
for i in range[0, len[list]]:
sum = sum + list[i]
return sum
print[sum[[5,7,3,8,10]]]
Where we simply call the sum function, the function adds every element to the variable sum and returns. To do this recursively:
def sum[list]:
if len[list] == 1:
return list[0]
else:
return list[0] + sum[list[1:]]
print[sum[[5,7,3,8,10]]]
If the length of the list is one it returns the list [the termination condition]. Else, it returns the element and a call to the function sum[] minus one element of the list. If all calls are executed, it returns reaches the termination condition and returns the answer.
Factorial with recursion
The mathematical definition of factorial is: n! = n * [n-1]!, if n > 1 and f[1] = 1. Example: 3! = 3 x 2 x 1 = 6. We can implement this in Python using a recursive function:
def factorial[n]:
if n == 1:
return 1
else:
return n * factorial[n-1]
print[factorial[3]]
When calling the factorial function n = 3. Thus it returns n * factorial[n-1]. This process will continue until n = 1. If n==1 is reached, it will return the result.
Limitations of recursions
Everytime a function calls itself and stores some memory. Thus, a recursive function could hold much more memory than a traditional function. Python stops the function calls after a depth of 1000 calls. If you run this example:
def factorial[n]:
if n == 1:
return 1
else:
return n * factorial[n-1]
print[factorial[3000]]
You will get the error:
RuntimeError: maximum recursion depth exceeded
In other programming languages, your program could simply crash. You can resolve this by modifying the number of recursion calls such as:
import sys
sys.setrecursionlimit[5000]
def factorial[n]:
if n == 1:
return 1
else:
return n * factorial[n-1]
print[factorial[3000]]
but keep in mind there is still a limit to the input for the factorial function. For this reason, you should use recursion wisely. As you learned now for the factorial problem, a recursive function is not the best solution. For other problems such as traversing a directory, recursion may be a good solution.
Related
Course:
Python Programming Bootcamp: Go from zero to hero