Do you want to learn **to check Armstrong numbers in Python using recursion**? You have come to the right place.

In this Python article, we will** **discuss the **Armstrong number in Python**. Also, **what is recursion**, and why do we use it in Python? I will also explain, with an example, how to **check the Armstrong number in Python using recursion**.

## What is Armstrong Number in Python?

An **Armstrong number**, also known as a **narcissistic number**. It is a special number equal to the sum of its digits. Each number is raised to the power of the number of digits.

For example, **371** is an Armstrong number because the **sum** of the **cube**(cube because it is a 3-digit number) of each digit, i.e., 3^3 + 7^3 + 1^3 = 371, is **equal to** the original number.

## Check Armstrong Number in Python Using Recursion

**Recursion** in Python is a process in which a **function calls itself** directly or indirectly. It can be split down into smaller sub-problems utilizing recursion. It is the way of defining repetitively.

We can use Recursion to find the Armstrong number in Python, as it calculates the sum of the digits raised to the appropriate power.

Here is the complete Python program to check the **Armstrong number using recursion in Python**.

```
def count_digits(num):
if num == 0:
return 0
return 1 + count_digits(num // 10)
def is_armstrong(num, digit_count):
if num == 0:
return 0
return ((num % 10) ** digit_count) + is_armstrong(num // 10, digit_count)
def check_armstrong(num):
digit_count = count_digits(num)
return num == is_armstrong(num, digit_count)
number = int(input("Enter a number: "))
print(check_armstrong(number))
```

The below part of Python code is used to check if num is **equal to 0**; it means there are no more digits left, so it **returns 0**. If it is not, then extract the last digit of num using integer **division (//) by 10** and add 1 to the result of count_digit for the remaining last part of num.

```
if num == 0:
return 0
return 1 + count_digits(num // 10)
```

Then, calculate the **sum of each digit raised to the power** of **digit_count **and add it to the result of **is_armstrong**.

`return ((num % 10) ** digit_count) + is_armstrong(num // 10, digit_count)`

Here, by calling the **count_digita function**, it calculates the count of digits in the number **n**. It returns **True** if the number num is equal to the result of the **is_armstrong **function having argument num and **digit_count**. Else, it returns **False**.

```
digit_count = count_digits(num)
return num == is_armstrong(num, digit_count)
```

**Output 1:** here is the output of a number that is an Armstrong number.

```
Enter a number: 153
True
```

Refer to the screenshot below to see the result of the Python program to check the Armstrong number using recursion.

**Output 2: **Here is an output of numbers that is not an Armstrong number:

```
Enter a number: 2458
False
```

After the code was implemented in the Pycharm editor, the subsequent screenshot was taken to illustrate the output.

## Conclusion

I hope the information provided in the above Python article gives a clear picture of the **Armstrong number in Python** and **recursion in Python**. Also, check the Armstrong number in Python using recursion with an example.

You may also like to read the following articles:

- How to Check N-Digit Armstrong Numbers in Python [3 Examples]
- Add zeros before a number in Python
- How to reverse a number in Python
- Python Program to Find Armstrong Number in an Interval

I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etcâ€¦ for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.