How To Check Palindrome Number in Python?

A palindrome number in Python is a number that remains the same when its digits are reversed. Checking for palindrome numbers is a common programming task and a popular coding interview question. Python offers multiple ways to verify palindrome numbers, including string reversal, loops, recursion, and functions. 

In this comprehensive guide, we'll explore everything you need to know about creating a palindrome number program in Python. We will break down three distinct methods, from the most straightforward approach to more advanced techniques. You will learn the logic behind each method, see clear code examples, and understand the pros and cons to help you decide which one is right for your needs. 

Want to learn how to check for palindrome number in Python and enhance your programming skills? With upGrad’s Online Software Engineering Course, you'll gain practical experience in Python and problem-solving techniques, preparing you for success in the tech industry. 

Method 1: The Easiest Way Using String Slicing 

The most straightforward and "Pythonic" way to check for a palindrome number in Python is by leveraging the power of string slicing. This method is incredibly concise and easy to read, making it a favorite among beginners and professionals alike for its simplicity. 

The core idea is simple: 

1. Take the number. 
2. Convert it into a string. 
3. Reverse the string. 
4. Compare the original string with the reversed string. 

If they are identical, the number is a palindrome. If not, it isn’t. Python's string slicing makes the reversal step incredibly easy. The syntax [:: -1] can reverse any sequence, including strings. 

The Palindrome Number Code in Python 

Here is the complete palindrome number code in Python using this approach: 

def is_palindrome_slicing(n): 
    """ 
    Checks if a number is a palindrome using string slicing. 
     
    Args: 
        n: An integer. 
         
    Returns: 
        True if the number is a palindrome, False otherwise. 
    """ 
    # Convert the number to a string 
    num_str = str(n) 
     
    # Compare the string with its reverse 
    if num_str == num_str[::-1]: 
        return True 
    else: 
        return False 
 
# --- Example Usage --- 
number_to_check = 12321 
if is_palindrome_slicing(number_to_check): 
    print(f"{number_to_check} is a palindrome number.") 
else: 
    print(f"{number_to_check} is not a palindrome number.") 
 
number_to_check = 12345 
if is_palindrome_slicing(number_to_check): 
    print(f"{number_to_check} is a palindrome number.") 
else: 
    print(f"{number_to_check} is not a palindrome number.") 
  

Step-by-Step Breakdown 

Let's break down how this elegant solution works using the number 121. 

1. Function Definition: We define a function is_palindrome_slicing that accepts one argument, n. 
2. Integer to String Conversion: Inside the function, str(n) converts the integer 121 into the string "121". This is stored in the num_str variable. 
3. String Reversal: The magic happens with num_str[::-1]. This is Python's extended slice syntax. 
4. The first colon : means we start from the beginning of the string. 
5. The second colon : means we go to the end of the string. 
6. The -1 is the "step," which tells Python to go backward one character at a time. 
7. This effectively creates a reversed copy of the string. So, "121" reversed is still "121". 
8. Comparison: The if statement compares the original string num_str ("121") with its reversed version ("121"). Since "121" == "121" is true, the function returns True. 
9. Output: The example usage code calls the function and prints the appropriate message based on the boolean result. 

Pros and Cons of String Slicing 

This method is fantastic, but it's good to know its trade-offs. 

For most everyday programming tasks and learning purposes, this is the best method to check for a palindrome number in Python. It's clean, efficient enough, and demonstrates a good understanding of Python's string manipulation capabilities. 

Also Read: Learn the Techniques: How to Reverse a Number in Python Efficiently 

Method 2: The Traditional Approach Using a Mathematical Loop 

While string slicing is fast and easy, sometimes an interviewer might ask you to solve the palindrome problem without converting the number to a string. This tests your understanding of basic arithmetic operations and loops. This method is purely mathematical and relies on reversing the number digit by digit. 

The algorithm for this palindrome number program in Python is as follows: 

1. Store the original number in a temporary variable so we don't lose it. 
2. Initialize a new variable, say reversed_num, to 0. 
3. Use a while loop that continues as long as the original number is greater than 0. 
4. Inside the loop, extract the last digit of the number using the modulo operator (% 10). 
5. Add this digit to reversed_num. To do this, multiply reversed_num by 10 first and then add the digit. 
6. Remove the last digit from the original number using integer division (// 10). 
7. Once the loop finishes, reversed_num will hold the reversed version of the original number. 
8. Compare the temporary variable (holding the original number) with reversed_num. 

The Python Code Using a While Loop 

Here is the complete code implementing this mathematical logic: 

def is_palindrome_loop(n): 
    """ 
    Checks if a number is a palindrome using a mathematical loop. 
    This function does not convert the number to a string. 
     
    Args: 
        n: A positive integer. 
         
    Returns: 
        True if the number is a palindrome, False otherwise. 
    """ 
    if n < 0: 
        return False # Negative numbers are not typically considered palindromes 
         
    original_num = n 
    reversed_num = 0 
     
    while n > 0: 
        # Get the last digit 
        digit = n % 10 
         
        # Append the digit to the reversed number 
        reversed_num = (reversed_num * 10) + digit 
         
        # Remove the last digit from the original number 
        n = n // 10 
         
    # Compare the original number with the reversed number 
    return original_num == reversed_num 
 
# --- Example Usage --- 
number_to_check = 121 
if is_palindrome_loop(number_to_check): 
    print(f"{number_to_check} is a palindrome number.") 
else: 
    print(f"{number_to_check} is not a palindrome number.") 
 
number_to_check = 12345 
if is_palindrome_loop(number_to_check): 
    print(f"{number_to_check} is not a palindrome number.") 
  

Dry Run with an Example 

Let's trace the execution with the number 121: 

• original_num is set to 121. reversed_num is 0. n is 121. 

  Loop 1: 

• n > 0 (121 > 0) is true. 
• digit = 121 % 10 which is 1. 
• reversed_num = (0 * 10) + 1 which is 1. 

• n = 121 // 10 which is 12. 

  Loop 2: 

• n > 0 (12 > 0) is true. 
• digit = 12 % 10 which is 2. 
• reversed_num = (1 * 10) + 2 which is 12. 

• n = 12 // 10 which is 1. 

  Loop 3: 

• n > 0 (1 > 0) is true. 
• digit = 1 % 10 which is 1. 
• reversed_num = (12 * 10) + 1 which is 121. 

• n = 1 // 10 which is 0. 

  End of Loop: 

• n > 0 (0 > 0) is false. The loop terminates. 
• Final Comparison: The function returns original_num == reversed_num which is 121 == 121, resulting in True. 

Using a For Loop 

You can also adapt this logic for a palindrome number in Python using a for loop. While a while loop feels more natural for this algorithm, a for loop is also possible if you iterate over the digits as characters of a string but perform the mathematical reversal. 

def is_palindrome_for_loop(n): 
    original_num_str = str(n) 
    reversed_num = 0 
     
    for digit_char in original_num_str: 
        digit = int(digit_char) 
        reversed_num = (reversed_num * 10) + digit 
         
    return int(original_num_str) == reversed_num 
  

This hybrid approach uses a for loop for iteration but sticks to the mathematical construction of the reversed number. 

Pros and Cons of the Loop Method 

This method is an excellent way to demonstrate a deeper understanding of algorithmic thinking when checking for a palindrome number in Python. 

Also Read: Type Casting in Python 

Method 3: An Advanced Technique Using Recursion 

For those looking for a more elegant or advanced solution, recursion offers another way to check for a palindrome number in Python. Recursion is a programming concept where a function calls itself to solve a smaller version of the same problem until it reaches a "base case." 

To check for a palindrome recursively, the logic is: 

1. Base Case: If the number has one or zero digits, it must be a palindrome. 
2. Recursive Step: Compare the first and last digits of the number. 
3. If they are the same, the number might be a palindrome. We then need to recursively call the function on the number without its first and last digits. 
4. If they are different, the number is definitely not a palindrome. 

Because it is much easier to get the first and last digits from a string, this recursive approach is usually implemented with strings. 

The Recursive Palindrome Code in Python 

Here is what a recursive palindrome number code in Python looks like: 

def is_palindrome_recursive(n): 
    """ 
    Checks if a number is a palindrome using recursion. 
     
    Args: 
        n: An integer. 
         
    Returns: 
        True if the number is a palindrome, False otherwise. 
    """ 
    # Convert the number to a string to work with it recursively 
    s = str(n) 
    return check_recursive(s) 
 
def check_recursive(s): 
    """Helper function for the recursive check.""" 
     
    # Base Case: If the string has 0 or 1 characters, it's a palindrome. 
    if len(s) <= 1: 
        return True 
     
    # Compare the first and last characters. 
    if s[0] == s[-1]: 
        # If they match, check the substring in between. 
        return check_recursive(s[1:-1]) 
    else: 
        # If they don't match, it's not a palindrome. 
        return False 
 
# --- Example Usage --- 
number_to_check = 48984 
if is_palindrome_recursive(number_to_check): 
    print(f"{number_to_check} is a palindrome number.") 
else: 
    print(f"{number_to_check} is not a palindrome number.") 
 
number_to_check = 12345 
if is_palindrome_recursive(number_to_check): 
    print(f"{number_to_check} is a palindrome number.") 
else: 
    print(f"{number_to_check} is not a palindrome number.") 
  

How Recursion Unfolds 

Let's trace check_recursive("48984"): 

       Call 1: check_recursive("48984") 

• len("48984") is 5, not <= 1. 
• s[0] ('4') == s[-1] ('4'). This is true. 

• It returns the result of check_recursive("898"). 

  Call 2: check_recursive("898") 

• len("898") is 3, not <= 1. 
• s[0] ('8') == s[-1] ('8'). This is true. 

• It returns the result of check_recursive("9"). 

  Call 3: check_recursive("9") 

• len("9") is 1. This is the base case. 

• It returns True. 

  Unwinding: 

• The True value is passed back to Call 2. 
• Call 2 returns True to Call 1. 
• Call 1 returns True to the original is_palindrome_recursive function. 

The final result is True, correctly identifying 48984 as a palindrome. This approach elegantly breaks the problem down into smaller, identical subproblems. 

Pros and Cons of Recursion 

Using recursion for checking a palindrome number in Python is a great way to practice an important computer science concept, even if it's not always the most practical solution for this specific problem compared to slicing or a simple loop. 

Also Read: Recursion in Data Structures: Types, Algorithms, and Applications 

What Exactly is a Palindrome Number? 

After exploring  the code, let's make sure we're on the same page. A palindrome is a sequence that reads the same backward as it does forward. This concept applies to words ("madam," "racecar"), phrases, and, for our purpose, numbers. 

A palindrome number is a number that remains the same when its digits are reversed. 

• For example, 121 is a palindrome because if you reverse the digits, you still get 121. 
• Similarly, 88 is a palindrome. 
• A more complex example is 9009. 

On the other hand, a number like 123 is not a palindrome because its reverse is 321, which is not the same as the original. The core idea is symmetry. The sequence of digits is perfectly mirrored around its center. 

Understanding this concept is the first step toward writing a program to identify them. Here’s a quick table to make it even clearer: 

This simple check is a fantastic exercise for learning fundamental programming concepts like: 

• Loops: Iterating through the digits of a number. 
• String Manipulation: Converting numbers to strings to use powerful built-in methods. 
• Mathematical Operations: Using arithmetic to reverse a number without any conversions. 
• Conditional Logic: Using if-else statements to determine and state the result. 

Whether you are preparing for a coding interview or just sharpening your Python skills, mastering the logic for checking a palindrome number in Python is an invaluable skill. It demonstrates your ability to break down a problem into logical steps and implement a solution efficiently. 

Comparing the Methods: Which Palindrome Check is Best? 

We've explored three different ways to check for a palindrome number in Python. Each has its own strengths and weaknesses, and the "best" method often depends on the context, such as readability, performance requirements, or interview constraints. 

Let's summarize our findings in a comparison table to help you choose the right approach for your situation. 

Final Recommendation 

• For Beginners and Everyday Code: Stick with Method 1: String Slicing. It is the most Pythonic, readable, and is perfectly efficient for almost any real-world scenario. It's the solution you should reach for first. 
• For Technical Interviews: Be prepared to use Method 2: The Mathematical Loop. Interviewers often add the constraint "without converting to a string" to test your problem-solving skills with basic arithmetic and loops. Knowing this method shows depth. 
• For Demonstrating Advanced Knowledge: Use Method 3: Recursion if you want to showcase your understanding of more advanced computer science concepts. While not the most practical for this specific task, it’s a powerful tool to have in your arsenal. 

Ultimately, understanding all three methods for creating a palindrome number program in Python will make you a more well-rounded and versatile programmer. 

How Can upGrad Help You Learn Python Programming?

Finding palindrome number in Python is a crucial programming skill, especially in fields like data validation, pattern recognition, and bioinformatics. As industries increasingly rely on data integrity and automation, understanding how to efficiently process palindromes is essential. Professionals skilled in Python and algorithmic thinking are in high demand across software development, machine learning, and biotechnology sectors.

upGrad helps you master such programming concepts through expert-led Python courses. With hands-on projects and real-world applications, you’ll gain the problem-solving skills needed to succeed in today’s competitive tech industry.

In addition to the programs covered in this blog, here are some additional courses that can help you in your learning journey:

• Data Structures & Algorithms
• Java Object-oriented Programming
• JavaScript Basics from Scratch
• Advanced JavaScript for All

If you're unsure where to begin or which area to focus on, upGrad’s expert career counselors can guide you based on your goals. You can also visit a nearby upGrad offline center to explore course options, get hands-on experience, and speak directly with mentors! 

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Explore our Popular Data Science Courses

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Top Data Science Skills to Learn

Stay informed and inspired with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals!

Read our popular Data Science Articles