Skip to main content

How to Check if a String is a Palindrome

A palindrome is a sequence of characters that reads the same forward and backward, such as "madam", "racecar", or "12321". Detecting palindromes is a common algorithmic problem used in text analysis, data validation, and technical interviews.

This guide explores the most efficient ways to check for palindromes in Python, ranging from simple string slicing to handling complex sentences with punctuation.

Understanding Palindromes​

In Python, checking for a palindrome involves comparing a string with its reverse. However, standard string comparison is case-sensitive and sensitive to spaces/punctuation.

  • Strict Palindrome: "radar" (Exact match reversed).
  • Logical Palindrome: "Racecar" (Matches if case is ignored).
  • Sentence Palindrome: "A man, a plan, a canal: Panama" (Matches if case, spaces, and punctuation are ignored).

Method 1: String Slicing (The Pythonic Way)​

The easiest and most concise way to check for a palindrome in Python is using string slicing. The syntax [::-1] creates a reversed copy of the string.

text = "madam"

# ✅ Correct: Compare original string with reversed string
if text == text[::-1]:
    print(f"'{text}' is a palindrome.")
else:
    print(f"'{text}' is NOT a palindrome.")

Output:

'madam' is a palindrome.
tip

Slicing is fast and readable, but it creates a copy of the string in memory. For extremely large strings, this doubles memory usage temporarily.

Method 2: Iterative Approach (Memory Efficient)​

For a more algorithmic approach (often required in coding interviews), you can use a loop with two pointers. One pointer starts at the beginning, the other at the end, and they move toward the center comparing characters.

def is_palindrome_loop(s):
    # Initialize pointers
    left = 0
    right = len(s) - 1
    
    while left < right:
        if s[left] != s[right]:
            return False # Mismatch found
        left += 1
        right -= 1
        
    return True

# Test
word = "level"
print(f"Is '{word}' a palindrome? {is_palindrome_loop(word)}")

Output:

Is 'level' a palindrome? True

Method 3: Handling Case and Punctuation (Real-World)​

A common logic error occurs when checking mixed-case words or sentences. Standard comparison treats "Racecar" as different from "racecar".

Logical Error​

text = "Racecar"

# ⛔️ Incorrect: Fails because 'R' != 'r'
is_palindrome = text == text[::-1]
print(f"Is '{text}' a palindrome? {is_palindrome}")

Output:

Is 'Racecar' a palindrome? False

Robust Solution​

To handle real-world text, you must normalize the string:

  1. Convert to lowercase.
  2. Remove non-alphanumeric characters (spaces, commas, symbols).
import re

def is_valid_palindrome(s):
    # 1. Lowercase the string
    s = s.lower()
    
    # 2. Keep only alphanumeric characters using Regex
    # [^a-z0-9] matches anything that is NOT a letter or number
    clean_s = re.sub(r'[^a-z0-9]', '', s)
    
    # 3. Check equality
    return clean_s == clean_s[::-1]

sentence = "A man, a plan, a canal: Panama"

# ✅ Correct: Ignores punctuation and case
print(f"Original: {sentence}")
print(f"Is Palindrome: {is_valid_palindrome(sentence)}")

Output:

Original: A man, a plan, a canal: Panama
Is Palindrome: True
note

If you prefer not to use the re module, you can achieve the same result using string methods: clean_s = ''.join(char for char in s.lower() if char.isalnum())

Conclusion​

To check for palindromes effectively in Python:

  1. Use Slicing (s == s[::-1]) for simple, one-word checks where case doesn't matter.
  2. Use Normalization (lowercase + removal of punctuation) for sentences or user input.
  3. Use Loops if memory efficiency is a critical constraint.

Table of Contents