5 Best Ways to Check if a String is a Palindrome in Python

Rate this post

πŸ’‘ Problem Formulation: A palindrome is a word, phrase, number, or other sequences of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization). This article demonstrates how to determine if a given string is a palindrome in Python. For example, the input β€˜radar’ should return True as it is a palindrome, while the input ‘hello’ should return False.

Method 1: Reversed String Comparison

This method involves generating a reversed copy of the original string and comparing the two. If they are equal, the string is a palindrome. It’s a simple, straightforward approach that utilizes Python’s slicing features.

Here’s an example:

def is_palindrome(s):
    return s == s[::-1]

print(is_palindrome("radar"))
print(is_palindrome("hello"))

Output:

True
False

This code defines a function is_palindrome, which returns True if the input string s is equal to its reversed version s[::-1]. Strings such as ‘radar’ will return True, while ‘hello’ will return False.

Method 2: Iterative Comparison

In this method, we iterate over the string and compare characters from the beginning and the end progressively moving towards the center. It’s more explicit than the slicing method and might be easier to understand for beginners.

Here’s an example:

def is_palindrome(s):
    for i in range(len(s) // 2):
        if s[i] != s[-(i + 1)]:
            return False
    return True

print(is_palindrome("radar"))
print(is_palindrome("hello"))

Output:

True
False

The is_palindrome function iterates over half of the string and compares characters at symmetrical positions from both ends. If any pair doesn’t match, the function returns False, indicating the string is not a palindrome.

Method 3: Using Built-in Functions

This method leverages Python’s built-in reversed function and join method to reverse the string for comparison. This is slight variation of the first method, abstracting the reversal of the string into a function call.

Here’s an example:

def is_palindrome(s):
    reversed_s = ''.join(reversed(s))
    return s == reversed_s

print(is_palindrome("radar"))
print(is_palindrome("hello"))

Output:

True
False

The function is_palindrome creates a new string reversed_s by using the reversed function and joining the results. It then compares the original string with reversed_s to determine if the string is a palindrome.

Method 4: Recursive Approach

A recursive function is a function that calls itself to solve a problem. For checking palindromes, a recursive method can successively strip and compare the first and last characters of a string until it concludes the check or reaches the middle character.

Here’s an example:

def is_palindrome(s):
    if len(s) <= 1:
        return True
    if s[0] != s[-1]:
        return False
    return is_palindrome(s[1:-1])

print(is_palindrome("radar"))
print(is_palindrome("hello"))

Output:

True
False

The is_palindrome function uses recursion, eliminating the first and last characters each time through the function call until it either detects a discrepancy or validates the string as a palindrome.

Bonus One-Liner Method 5: List Comprehension and Comparisons

For pythonic brevity, list comprehensions can be used alongside the all function to check for a palindrome in a single line of code. It’s a concise and elegant one-liner, albeit less transparent for beginners.

Here’s an example:

is_palindrome = lambda s: all(s[i] == s[-(i + 1)] for i in range(len(s) // 2))

print(is_palindrome("radar"))
print(is_palindrome("hello"))

Output:

True
False

The one-liner lambda function uses list comprehension to compare each character and the all function to ensure all comparisons return True. This indicates that the string is the same forwards and backward.

Summary/Discussion

  • Method 1: Reversed String Comparison. Simple and efficient but does not perform early termination if a mismatch is found midway.
  • Method 2: Iterative Comparison. Easy to understand and can terminate early on finding a non-palindrome character pair. However, it’s slightly more verbose than other methods.
  • Method 3: Using Built-in Functions. Pythonic, using high-level abstractions, but similar to Method 1, it doesn’t allow for early termination.
  • Method 4: Recursive Approach. Conceptually elegant and less code-heavy, but not as memory efficient due to recursive function calls.
  • Method 5: List Comprehension and Comparisons. Extremely concise, but perhaps not the most readable for those unfamiliar with Python list comprehensions.