Check Palindrome In Python | 8 Methods With Detailed Code Examples

A palindrome is a text (word/ phrase) or a number that remains the same whether you read from the front or the back. This means that the reverse of a palindrome is the same as the original. For example, the word Mom and the number 1991 are both Palindromes. This concept is widely used in genetic analysis, computational theory, music, writing, etc.

In this article, we will discuss the various ways to write a program to check for a palindrome in Python language, with detailed examples. We will also highlight the real-world applications of palindromes.

What Is Palindrome In Python?

As mentioned, a palindrome is a number or text whose reverse is the same as the original content. A palindrome in Python usually refers to strings, whether a number (which must be represented in a string format) or any text. This is because palindrome checking inherently involves comparing sequences of characters (or digits) in this language.

In other words, when checking for a palindrome in Python programs, we typically compare the original string with its reversed version. If both are identical, the string is a palindrome. Python language offers various techniques to achieve this, including slicing, loops, and recursion.

For example, let's consider the word "madam":

1. Original string: "madam"
2. Reversed string: "madam" (when reversed, it remains the same)

Since both the original and reversed strings are identical, "madam" is a palindrome. 

Algorithm To Find Palindrome In Python

Let's look at a generalized approach for finding palindrome in Python:

1. Input: Accept a string or number to check if it's a palindrome.
2. Preprocess: (Optional) Convert the input to lowercase or remove non-alphanumeric characters if required, especially when working with sentences or phrases.
3. Reverse: Reverse the input.
4. Compare: Compare the original string input with the reversed version.
5. Result: If both are the same, the input is a palindrome; otherwise, it is not.

When working with palindromes in Python, there are multiple ways to approach the problem, each offering unique advantages regarding readability, performance, and simplicity. In the sections ahead, we will explore various methods to check if a given string or number is a palindrome.

Check Palindrome In Python Using While Loop (Iterative Approach)

In this method, we use a while loop to iterate over a string from beginning to end and determine if it is a palindrome in Python program. We iteratively compare the corresponding characters at both ends. If they match, the string is a palindrome; otherwise, it is not.

Working Mechanism:

1. Initialize two variables, start and end, to the beginning and end of the string, respectively.
2. Compare the characters at both positions using a while loop.
3. If the character mismatch, exit the iterative loop and return that the string is not a palindrome.
4. If all characters match, the string is a palindrome.

Code Example: 

ZGVmIGlzX3BhbGluZHJvbWUod29yZCk6CiAgICBzdGFydCA9IDAKICAgIGVuZCA9IGxlbih3b3JkKSAtIDEKCiAgICAjIEl0ZXJhdGUgd2hpbGUgc3RhcnQgaXMgbGVzcyB0aGFuIGVuZAogICAgd2hpbGUgc3RhcnQgPCBlbmQ6CiAgICAgICAgIyBJZiBjaGFyYWN0ZXJzIGF0IHN0YXJ0IGFuZCBlbmQgZG9uJ3QgbWF0Y2gsIGl0J3Mgbm90IGEgcGFsaW5kcm9tZQogICAgICAgIGlmIHdvcmRbc3RhcnRdICE9IHdvcmRbZW5kXToKICAgICAgICAgICAgcmV0dXJuIEZhbHNlCiAgICAgICAgIyBNb3ZlIHN0YXJ0IGZvcndhcmQgYW5kIGVuZCBiYWNrd2FyZAogICAgICAgIHN0YXJ0ICs9IDEKICAgICAgICBlbmQgLT0gMQogICAgcmV0dXJuIFRydWUKCiMgVGVzdCB0aGUgZnVuY3Rpb24KdGVzdF93b3JkID0gIm1hZGFtIgppZiBpc19wYWxpbmRyb21lKHRlc3Rfd29yZCk6CiAgICBwcmludChmIid7dGVzdF93b3JkfScgaXMgYSBwYWxpbmRyb21lLiIpCmVsc2U6CiAgICBwcmludChmIid7dGVzdF93b3JkfScgaXMgbm90IGEgcGFsaW5kcm9tZS4iKQo=

Output: 

'madam' is a palindrome.

Explanation:

In the above code example-

1. We start by defining a function is_palindrome() that takes a string "word" as input.

2. Inside, we initialize two variables: start to 0 and end to the last index of the string (i.e. length of the word minus 1).

3. Then, we enter a while loop that continues as long as start is less than end. This loop will iterate through the word from both ends, comparing characters.

4. Inside the loop, using the not equal to relational operator(!=), we check if the character at index start is not equal to the character at index end-

   • If the characters don’t match, we return False since the word is not a palindrome.

   • If they do match, we move the start index forward and the end index backward to continue checking the next pair of characters.

   • Once we finish the loop without mismatches, we return True, confirming that the word is a palindrome.

5. Finally, we test the function with the word "madam" using an if-else statement and print the result depending on whether it is a palindrome or not.

Time Complexity: O(n)
Space Complexity: O(1)

Check Palindrome In Python Using For Loop And Character Matching

In this method, we check if a string is a palindrome by using a for loop to compare characters from the beginning and the end of the string iteratively. If the characters match in every iteration, we determine that the string is a palindrome; otherwise, it is not.

Working Mechanism:

1. Take the input string.
2. Loop through the string from the start to the midpoint.
3. Compare the characters at the current index and the corresponding character from the end.
4. If any characters don’t match, return that the string is not a palindrome.
5. If all pairs match, the string is a palindrome.

Code Example:

ZGVmIGlzX3BhbGluZHJvbWUod29yZCk6CiAgICAjIEl0ZXJhdGUgb3ZlciB0aGUgZmlyc3QgaGFsZiBvZiB0aGUgc3RyaW5nCiAgICBmb3IgaSBpbiByYW5nZShsZW4od29yZCkgLy8gMik6CiAgICAgICAgIyBDb21wYXJlIGNoYXJhY3RlcnMgZnJvbSB0aGUgc3RhcnQgYW5kIGVuZAogICAgICAgIGlmIHdvcmRbaV0gIT0gd29yZFstKGkgKyAxKV06CiAgICAgICAgICAgIHJldHVybiBGYWxzZQogICAgcmV0dXJuIFRydWUKCiMgVGVzdCB0aGUgZnVuY3Rpb24KdGVzdF93b3JkID0gImxldmVsIgppZiBpc19wYWxpbmRyb21lKHRlc3Rfd29yZCk6CiAgICBwcmludChmIid7dGVzdF93b3JkfScgaXMgYSBwYWxpbmRyb21lLiIpCmVsc2U6CiAgICBwcmludChmIid7dGVzdF93b3JkfScgaXMgbm90IGEgcGFsaW5kcm9tZS4iKQo=

Output:

'level' is a palindrome.

Explanation:

In the above code example-

1. We start by defining a function is_palindrome() that accepts a string "word" as its parameter.

2. Inside, we use a for loop to iterate over the first half of the string, up to the midpoint i.e. len(word) // 2.

3. In each iteration, we compare the character at the current index (word[i]) with the character at the mirrored position from the end  i.e.(word[-(i + 1)])-

   • If the characters do not match, we return False, indicating that the word is not a palindrome.

   • If we complete the loop without finding any mismatches, we return True, confirming that the word is a palindrome.

4. Finally, we test the function with the word "level" using an if-else statement and print the result, indicating whether it is a palindrome or not.

Time Complexity: O(n)
Space Complexity: O(1)

Check Palindrome In Python Using The Reverse And Compare Method (Python Slicing)

In this native approach, we check if a string is a palindrome by reversing it and comparing it with the original string. If both the original and reversed strings are identical, then the input is a palindrome.

Here, we use the slice operator to check for the palindrome in Python program. The operator is represented by a double colon sign (::), which allows us to extract a specific portion of a string or list.

Working Mechanism:

1. Take the input string.
2. Reverse the string using Python's slicing technique.
3. Compare the original string with the reversed string.
4. If they are the same, the string is a palindrome; otherwise, it is not.

Code Example:

ZGVmIGlzX3BhbGluZHJvbWUod29yZCk6CiAgICAjIFJldmVyc2UgdGhlIHN0cmluZyB1c2luZyBzbGljaW5nCiAgICByZXZlcnNlZF93b3JkID0gd29yZFs6Oi0xXQogICAgCiAgICAjIENvbXBhcmUgb3JpZ2luYWwgYW5kIHJldmVyc2VkIHN0cmluZ3MKICAgIHJldHVybiB3b3JkID09IHJldmVyc2VkX3dvcmQKCiMgVGVzdCB0aGUgZnVuY3Rpb24KdGVzdF93b3JkID0gInJhY2VjYXIiCmlmIGlzX3BhbGluZHJvbWUodGVzdF93b3JkKToKICAgIHByaW50KGYiJ3t0ZXN0X3dvcmR9JyBpcyBhIHBhbGluZHJvbWUuIikKZWxzZToKICAgIHByaW50KGYiJ3t0ZXN0X3dvcmR9JyBpcyBub3QgYSBwYWxpbmRyb21lLiIpCg==

Output: 

'racecar' is a palindrome.

Explanation: 

In the above code example-

1. We start by defining a function is_palindrome() that takes a string "word" as input.

2. Inside the function, we create a new variable reversed_word, which stores the reversed version of the input string using Python slicing (word[::-1]).

3. Here, -1 is the step parameter that ensures the slice operator starts from the end of the string and moves one step back each time.

4. We then compare the original string word with reversed_word using an equality relational operator(==):

   • If both strings are equal, we return True, indicating that the word is a palindrome.

   • If they are not equal, we return False, indicating that the word is not a palindrome.

5. Finally, we test the function with the word "racecar" using an if-else statement and print the result, showing whether it is a palindrome or not.

Time Complexity: O(n)
Space Complexity: O(n) 

Check Palindrome In Python Using The In-built reversed() And join() Methods

In this method, we write a program to check for a palindrome in Python by first using the language's predefined function reversed(). This function returns an iterator that accesses the string elements in reverse order. Then, we use the join() function to reassemble the string and compare it to the original. If they are identical, the string is a palindrome.

Working Mechanism:

1. Convert the input string into a list of characters.
2. Reverse the list using Python's built-in reversed() function.
3. Use join() method to combine the reversed list into a string.
4. Compare the original string with the reversed string.
5. If they are the same, it is a palindrome string; otherwise, it is not.

Code Example:

ZGVmIGlzX3BhbGluZHJvbWUod29yZCk6CiAgICAjIFJldmVyc2UgdGhlIHN0cmluZyB1c2luZyByZXZlcnNlZCgpIGFuZCBqb2luKCkKICAgIHJldmVyc2VkX3dvcmQgPSAnJy5qb2luKHJldmVyc2VkKHdvcmQpKQogICAgCiAgICAjIENvbXBhcmUgdGhlIG9yaWdpbmFsIHN0cmluZyB3aXRoIHRoZSByZXZlcnNlZCBzdHJpbmcKICAgIHJldHVybiB3b3JkID09IHJldmVyc2VkX3dvcmQKCiMgVGVzdCB0aGUgZnVuY3Rpb24KdGVzdF93b3JkID0gImRlaWZpZWQiCmlmIGlzX3BhbGluZHJvbWUodGVzdF93b3JkKToKICAgIHByaW50KGYiJ3t0ZXN0X3dvcmR9JyBpcyBhIHBhbGluZHJvbWUuIikKZWxzZToKICAgIHByaW50KGYiJ3t0ZXN0X3dvcmR9JyBpcyBub3QgYSBwYWxpbmRyb21lLiIpCg==

Output: 

'deified' is a palindrome.

Explanation: 

In the above code example-

1. We start by defining the is_palindrome() function, which takes a string "word" as input.

2. Inside, we use Python's built-in function reversed() to create a reversed iterator over the word's characters.

3. We then use the join() function to join these reversed characters into a new string, effectively reversing the word.

4. Now we will compare the original string word with the newly created reversed_word using an equality relational operator(==):

   • If both strings are the same, we return True, indicating that the word is a palindrome.

   • If the strings do not match, we return False, meaning the word is not a palindrome.

5. Finally, we test the function with the word "deified" using an if-else statement and print whether it is a palindrome or not.

Time Complexity: O(n)
Space Complexity: O(n)

Check Palindrome In Python Using Recursion Method

Recursion is a technique where a function calls itself to solve smaller instances of the same problem. In this approach, we use recursion to check whether a string is a palindrome. For a palindrome check, we compare the first and last characters of the string. If they are equal, we move inward and check the next set of characters, repeating the process until we either find a mismatch or reach the centre of the string.

Working Mechanism:

1. Check if the first character of the string is the same as the last one.
2. If the characters don't match, the string is not a palindrome, so return False.
3. If the characters are equal, recursively call the function again with the substring obtained by removing the first and last characters.
4. The recursion continues until the string becomes empty or has only one character left. In either case, the string is a palindrome, so return True (base case).

Code Example: 

ZGVmIGlzX3BhbGluZHJvbWUod29yZCk6CiAgICAjIEJhc2UgY2FzZTogSWYgdGhlIHN0cmluZyBpcyBlbXB0eSBvciBoYXMgb25lIGNoYXJhY3RlcgogICAgaWYgbGVuKHdvcmQpIDw9IDE6CiAgICAgICAgcmV0dXJuIFRydWUKICAgIAogICAgIyBDaGVjayBpZiB0aGUgZmlyc3QgYW5kIGxhc3QgY2hhcmFjdGVycyBhcmUgdGhlIHNhbWUKICAgIGlmIHdvcmRbMF0gPT0gd29yZFstMV06CiAgICAgICAgIyBSZWN1cnNpdmVseSBjaGVjayB0aGUgc3Vic3RyaW5nIGJldHdlZW4gdGhlbQogICAgICAgIHJldHVybiBpc19wYWxpbmRyb21lKHdvcmRbMTotMV0pCiAgICBlbHNlOgogICAgICAgIHJldHVybiBGYWxzZQoKIyBUZXN0IHRoZSBmdW5jdGlvbgp0ZXN0X3dvcmQgPSAibWFkYW0iCmlmIGlzX3BhbGluZHJvbWUodGVzdF93b3JkKToKICAgIHByaW50KGYiJ3t0ZXN0X3dvcmR9JyBpcyBhIHBhbGluZHJvbWUuIikKZWxzZToKICAgIHByaW50KGYiJ3t0ZXN0X3dvcmR9JyBpcyBub3QgYSBwYWxpbmRyb21lLiIpCg==

Output: 

'madam' is a palindrome.

Explanation: 

In the above code example-

1. We start by defining the is_palindrome() function, which takes a string "word" as input.
2. Inside the function, we first check the base case, i.e., if the string is either empty or has only one character, we return True since such strings are always palindromes.
3. If the string is longer, we compare the first character (word[0]) with the last character (word[-1]). Here-
• If the characters match, we recursively call the is_palindrome() function on the substring between them (excluding the first and last characters). This effectively narrows down the string from both ends. The process repeats recursively until the base case is met.
• If the respective characters don't match (in any iteration), the function returns False, indicating that the string is not a palindrome.
4. Finally, we test the function with the word "madam" using an if-else statement and print whether it is a palindrome based on the function's result.

Time Complexity: O(n)
Space Complexity: O(n)

Check Palindrome In Python Using Flag

In this method, we use a boolean variable flag with a for loop to compare characters and determine if a string is a palindrome. The flag helps track whether the string satisfies the condition for palindrome.

We initially set a flag to True, assuming the string is a palindrome. Then, we iterate over the string, comparing characters from the beginning and corresponding end. At the first instance of a mismatch, we set the flag to False and terminate the loop, indicating that the string is not a palindrome.

Working Mechanism:

1. Initialize a flag variable as True.
2. Loop over the first half of the string.
3. Compare characters from the start and end of the string.
4. If any pair of characters doesn’t match, set the flag to False and break out of the loop.
5. After the loop, check the value of the flag. If it is True, the string is a palindrome; otherwise, it is not.

Code Example:

ZGVmIGlzX3BhbGluZHJvbWUod29yZCk6CiAgICAjIEluaXRpYWxpemUgZmxhZyBhcyBUcnVlCiAgICBmbGFnID0gVHJ1ZQoKICAgICMgSXRlcmF0ZSB0aHJvdWdoIHRoZSBmaXJzdCBoYWxmIG9mIHRoZSBzdHJpbmcKICAgIGZvciBpIGluIHJhbmdlKGxlbih3b3JkKSAvLyAyKToKICAgICAgICAjIENvbXBhcmUgY2hhcmFjdGVycyBmcm9tIHN0YXJ0IGFuZCBlbmQKICAgICAgICBpZiB3b3JkW2ldICE9IHdvcmRbLShpICsgMSldOgogICAgICAgICAgICBmbGFnID0gRmFsc2UKICAgICAgICAgICAgYnJlYWsgICMgRXhpdCB0aGUgbG9vcCBlYXJseSBpZiBhIG1pc21hdGNoIGlzIGZvdW5kCgogICAgIyBSZXR1cm4gdGhlIHZhbHVlIG9mIHRoZSBmbGFnCiAgICByZXR1cm4gZmxhZwoKIyBUZXN0IHRoZSBmdW5jdGlvbgp0ZXN0X3dvcmQgPSAicmFkYXIiCmlmIGlzX3BhbGluZHJvbWUodGVzdF93b3JkKToKICAgIHByaW50KGYiJ3t0ZXN0X3dvcmR9JyBpcyBhIHBhbGluZHJvbWUuIikKZWxzZToKICAgIHByaW50KGYiJ3t0ZXN0X3dvcmR9JyBpcyBub3QgYSBwYWxpbmRyb21lLiIpCg==

Output: 

'radar' is a palindrome.

Explanation: 

In the above code-

1. We start by defining the is_palindrome function(), which takes a string "word" as input.
2. Inside, we initialize a variable flag to True, assuming the word is a palindrome at the start.
3. We then use a for loop to iterate through the first half of the string (i.e., range len(word)//2) since we only need to check half of the characters.
   • In each iteration, we use an if-statement to compare the character at the current index (word[i]) with the corresponding character from the end of the string (word[-(i + 1)]).
   • If any pair of characters doesn't match, we set flag to False to indicate that the word is not a palindrome.
   • We then encounter the break statement inside the if-block and break out of the loop to stop further comparisons.
   • After the loop completes, we return the value of flag, which will be True if all characters matched, or False if there is a mismatch.
4. Finally, in the test section, we check the word "radar" using an if-else statement and print whether it is a palindrome or not, based on the result of the function.

Time Complexity: O(n)
Space Complexity: O(1)

Check Palindrome In Python Using One Extra Variable 

ZGVmIGNoZWNrUGFsaW5kcm9tZShzdHIpOgogICAgIyBJbml0aWFsaXplIGFuIGVtcHR5IHN0cmluZyB2YXJpYWJsZSB0byBzdG9yZSB0aGUgcmV2ZXJzZWQgc3RyaW5nCiAgICByZXZlcnNlZF9zdHIgPSAiIgoKICAgICMgSXRlcmF0ZSB0aHJvdWdoIHRoZSBvcmlnaW5hbCBzdHJpbmcgZnJvbSB0aGUgZW5kIHRvIHRoZSBiZWdpbm5pbmcKICAgIGZvciBpIGluIHJhbmdlKGxlbihzdHIpIC0gMSwgLTEsIC0xKToKICAgICAgICByZXZlcnNlZF9zdHIgKz0gc3RyW2ldICAjIEFwcGVuZCBlYWNoIGNoYXJhY3RlciBpbiByZXZlcnNlIG9yZGVyCgogICAgIyBDb21wYXJlIHRoZSBvcmlnaW5hbCBzdHJpbmcgd2l0aCB0aGUgcmV2ZXJzZWQgc3RyaW5nCiAgICBpZiBzdHIgPT0gcmV2ZXJzZWRfc3RyOgogICAgICAgIHJldHVybiBUcnVlCiAgICByZXR1cm4gRmFsc2UKCiMgTWFpbiBmdW5jdGlvbgpzID0gImxldmVsIgoKIyBDaGVjayBpZiB0aGUgc3RyaW5nIGlzIGEgcGFsaW5kcm9tZQpwcmludCgiUGFsaW5kcm9tZSIpIGlmIGNoZWNrUGFsaW5kcm9tZShzKSBlbHNlIHByaW50KCJOb3QgUGFsaW5kcm9tZSIpCg==

ZGVmIGNoZWNrUGFsaW5kcm9tZShzdHIpOgogICAgIyBJbml0aWFsaXplIGFuIGVtcHR5IHN0cmluZyB0byBzdG9yZSB0aGUgcmV2ZXJzZWQgc3RyaW5nCiAgICByZXZlcnNlZF9zdHIgPSAiIgoKICAgICMgSXRlcmF0ZSBvdmVyIGVhY2ggY2hhcmFjdGVyIGluIHRoZSBvcmlnaW5hbCBzdHJpbmcKICAgIGZvciBjaGFyIGluIHN0cjoKICAgICAgICAjIFByZXBlbmQgZWFjaCBjaGFyYWN0ZXIgdG8gdGhlIHJldmVyc2VkIHN0cmluZwogICAgICAgIHJldmVyc2VkX3N0ciA9IGNoYXIgKyByZXZlcnNlZF9zdHIKCiAgICAjIENvbXBhcmUgdGhlIG9yaWdpbmFsIHN0cmluZyB3aXRoIHRoZSByZXZlcnNlZCBzdHJpbmcKICAgIHJldHVybiBzdHIgPT0gcmV2ZXJzZWRfc3RyCgojIE1haW4gZnVuY3Rpb24KcyA9ICJyYWRhciIKCiMgQ2hlY2sgaWYgdGhlIHN0cmluZyBpcyBhIHBhbGluZHJvbWUKcHJpbnQoIlBhbGluZHJvbWUiKSBpZiBjaGVja1BhbGluZHJvbWUocykgZWxzZSBwcmludCgiTm90IFBhbGluZHJvbWUiKQo=