Check if String is Palindrome
in Python – 3 Easy Methods

Introduction

You have probably heard the word palindrome before — words like madam, racecar, level, and civic are all palindromes. They read the same whether you go left to right or right to left. But how do you actually check if a string is a palindrome in Python using code?

This is one of the most common string problems asked in coding interviews at companies like Amazon, Google, and Infosys. It looks simple on the surface, but interviewers specifically look for how you handle edge cases — things like uppercase letters, spaces, and special characters.

In this guide, you will learn the palindrome algorithm using three different Python methods — from the simplest one-liner to the most interview-friendly two-pointer technique. Every method is explained with full code, dry run, and complexity analysis.

Problem Statement

Input / Output Format

Why This Problem Matters

Key Intuition — Symmetry

A palindrome is essentially a mirror image of itself. The character at position 0 must match position n-1, position 1 must match position n-2, and so on. If any pair does not match, the string is not a palindrome.

Palindrome Visualization

Let's see how the two-pointer approach works on "madam" step by step:

Flowchart

Pseudocode

FUNCTION isPalindrome(s):
    clean_s = lowercase(s) + remove non-alphanumeric chars

    left  = 0
    right = length(clean_s) - 1

    WHILE left < right:
        IF clean_s[left] != clean_s[right]:
            RETURN False
        left  = left + 1
        right = right - 1

    RETURN True

Method 1 — Reverse String (Simplest)

The most direct way to check a palindrome is to reverse the string and compare it to the original. Python makes this extremely easy with slice notation.

# Method 1: Reverse the string and compare
def is_palindrome_reverse(s):
    # Convert to lowercase to handle case insensitivity
    s = s.lower()
    return s == s[::-1]

# Test
print(is_palindrome_reverse("madam"))    # True
print(is_palindrome_reverse("hello"))    # False
print(is_palindrome_reverse("Racecar"))  # True

How it works:

• s.lower() converts everything to lowercase so "Madam" and "madam" are treated the same.
• s[::-1] creates a reversed copy of the string using Python's slice syntax.
• If the original and reversed string are equal, it's a palindrome.

Method 2 — Two Pointer Approach (Interview Preferred)

This is the method interviewers want to see. Instead of creating a reversed string, we use two pointers — one starting from the left, one from the right — and move them inward, comparing characters at each step.

# Method 2: Two Pointer — O(n) time, O(1) space
def is_palindrome_two_pointer(s):
    s = s.lower()
    left, right = 0, len(s) - 1

    while left < right:
        if s[left] != s[right]:
            return False
        left  += 1
        right -= 1

    return True

# Test
print(is_palindrome_two_pointer("racecar"))  # True
print(is_palindrome_two_pointer("hello"))    # False
print(is_palindrome_two_pointer("level"))    # True

Why this is better:

• No extra string is created — space complexity is O(1).
• Early exit — if a mismatch is found, we return immediately without checking the rest.
• Shows pattern recognition skill — interviewers love this approach.

Method 3 — Recursion (Advanced)

You can also solve this recursively. The idea is simple: check if the first and last characters match, then recursively check the middle part.

# Method 3: Recursion
def is_palindrome_recursive(s, left=0, right=None):
    if right is None:
        s     = s.lower()
        right = len(s) - 1

    if left >= right:          # Base case
        return True
    if s[left] != s[right]:    # Mismatch
        return False
    return is_palindrome_recursive(s, left+1, right-1)

print(is_palindrome_recursive("madam"))   # True
print(is_palindrome_recursive("python"))  # False

⚠️ Critical Edge Cases

❗ Case Sensitivity

The string "Madam" should return True, but without converting to lowercase, 'M' != 'm' will cause it to fail. Always call .lower() first.

❗ Spaces and Special Characters

The phrase "A man a plan a canal Panama" is a famous palindrome — but only after you remove spaces and punctuation. Here is how to handle it:

import re

def is_palindrome_clean(s):
    # Keep only alphanumeric characters, convert to lowercase
    cleaned = re.sub(r'[^a-z0-9]', '', s.lower())
    return cleaned == cleaned[::-1]

print(is_palindrome_clean("A man a plan a canal Panama"))  # True
print(is_palindrome_clean("Was it a car or a cat I saw?"))  # True
print(is_palindrome_clean("race a car"))                   # False

❗ Empty String and Single Character

print(is_palindrome_reverse(""))    # True  — empty string
print(is_palindrome_reverse("a"))   # True  — single character
print(is_palindrome_reverse("aa"))  # True  — two same chars
print(is_palindrome_reverse("ab"))  # False — two different chars

Dry Run — "madam"

Let's trace through the two-pointer method step by step on the input "madam" (length = 5):

Complete Python Program

import re

# ── Method 1: Reverse ────────────────────────────
def palindrome_reverse(s):
    s = s.lower()
    return s == s[::-1]

# ── Method 2: Two Pointer (Space Efficient) ───────
def palindrome_two_pointer(s):
    s = s.lower()
    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1; right -= 1
    return True

# ── Cleaned Version (handles spaces & symbols) ────
def palindrome_clean(s):
    cleaned = re.sub(r'[^a-z0-9]', '', s.lower())
    return cleaned == cleaned[::-1]

# ── Driver Code ───────────────────────────────────
test_cases = [
    ("madam", True),
    ("hello", False),
    ("Racecar", True),
    ("A man a plan a canal Panama", True),
    ("a", True),
    ("", True),
]

print(f"{'String':35} {'Reverse':10} {'2-Ptr':10} {'Clean'}")
print("-" * 65)
for s, expected in test_cases:
    r1 = palindrome_reverse(s)
    r2 = palindrome_two_pointer(s)
    r3 = palindrome_clean(s)
    print(f"{s!r:35} {str(r1):10} {str(r2):10} {r3}")

Time & Space Complexity

Test Cases

Mistakes Beginners Make

• Ignoring case: Treating "Madam" as non-palindrome because 'M' ≠ 'm'. Always use .lower().
• Not cleaning spaces: "race car" fails unless spaces are removed.
• Wrong index handling: Off-by-one errors when setting right = len(s) instead of len(s) - 1.
• Using recursion without base case: Forgetting the left >= right base case leads to infinite recursion.
• Not handling empty strings: An empty string is a palindrome by convention — make sure your code handles it.

Method Comparison

Real-World Applications

Common Interview Questions

1. Write a function to check if a string is a palindrome without using extra space.
2. How would you modify your palindrome check to ignore spaces and special characters?
3. Can you check if a number (integer) is a palindrome without converting it to a string?
4. What is the time and space complexity of your palindrome check solution?
5. Check if any permutation of a string can form a palindrome.
6. Find the longest palindromic substring in a given string.

Conclusion

Checking if a string is a palindrome in Python is one of those problems that looks simple but tests your understanding of string manipulation, edge cases, and algorithm design. Here is a quick recap:

• Method 1 (Reverse): Simple one-liner — good for beginners and quick solutions.
• Method 2 (Two Pointer): Space-efficient and interview-preferred — learn this one well.
• Method 3 (Recursion): Good to know as a bonus — but not ideal for production.
• Always clean the string before checking — handle case, spaces, and special characters.

Frequently Asked Questions

Tags