String Manipulation in Python

A String That Reads Backward

A palindrome is a text that reads the same forwards and backwards. A program can identify one by creating a reversed version of the original string and comparing the two strings. If they match, the text is a palindrome; if they do not, it is not.

Following Characters Backward

The slice text[::-1] reverses a string. The negative step tells Python to move backward through the characters. For a five-character string, Python starts at index 4, the last character, then visits index 3, index 2, index 1, and index 0. The characters collected in that order form a new string in reverse order.

text = "hello"
reversed_text = text[::-1]
print(reversed_text)

olleh

Building the Palindrome Check

The checking strategy has two operations: create a reversed version of the input text, then compare that version with the original. Python's equality operator == checks whether the strings match character for character in the same positions. A match produces True; a mismatch produces False.

def reverse(text): return text[::-1] def is_palindrome(text): reversed_text = reverse(text) return text == reversed_text word = "racecar" print(is_palindrome(word))

Matching and Mismatching Positions

Tracing an Unexpected Result

When a palindrome checker gives an unexpected result, inspect the execution in order instead of guessing. First verify the value captured as the input. Next verify that reverse() actually produces the characters in reverse order. Then verify that the comparison uses the equality operator ==. Finally check the returned Boolean result.

def reverse(text):
    return text[::-1]

def is_palindrome(text):
    reversed_text = reverse(text)
    print("original:", text)
    print("reversed:", reversed_text)
    print("comparison:", text == reversed_text)
    return text == reversed_text

print(is_palindrome("hello"))

original: hello
reversed: olleh
comparison: False
False

• Forgetting to reverse the string before comparing

  The program has not created the reversed version needed to test the palindrome property.

  Fix: Create reversed_text with the negative-step slice and compare text == reversed_text.

• Using incorrect slice syntax

  The characters will not be traversed backward as required.

  Fix: Use text[::-1] to move from the last character toward the first.

• Using an operator other than ==

  The palindrome check depends on testing whether the original and reversed strings are equal.

  Fix: Use text == reversed_text.

• Overlooking case sensitivity

  The source identifies case sensitivity as a common issue in palindrome checks.

  Fix: When debugging, check the exact characters and their case in the captured input.

• Failing to verify the captured input

  An unexpected input value can make a correct palindrome function appear to fail.

  Fix: Inspect the input value before tracing the reverse and comparison steps.

Practice the Trace

1. A palindrome reads the same forwards and backwards. Python reverses a string with the negative-step slice text[::-1], which visits characters from the last index to the first. A palindrome function can compare the original and reversed strings with == and return the resulting Boolean value. When debugging, inspect the captured input, the reversed value, the comparison, and the returned result in that order.