How to Reverse a String in Python

You will learn why strings cannot be reversed in place, how Python slicing reverses a string, and when alternatives such as reversed() or a loop are useful.

Python strings are immutable: once a string is created, its individual characters cannot be changed. That is why str has no .reverse() method like lists do.

To reverse a string, create a new string whose characters appear in the opposite order. The most common Python approach is extended slicing:

reversed_text = text[::-1]

This reads the string from end to beginning and returns a new string.

Reversing text is useful for tasks such as checking whether a word is a palindrome, processing suffixes, transforming identifiers, and displaying data in reverse order.

Think of a string as a row of letters printed on a strip of paper:

P y t h o n

You cannot rearrange the letters already printed on the strip. Instead, you make a new strip by copying letters from right to left:

n o h t y P

text[::-1] tells Python to copy every character, but walk backward through the string.

The slicing form is:

sequence[start:stop:step]

To reverse a sequence, use a step of -1:

text = "Python"
reversed_text = text[::-1]

print(reversed_text)

Output:

nohtyP

The empty start and stop positions mean "use the whole string." The -1 step means "move backward one character at a time."

You can also use reversed(), which returns an iterator:

text = "Python"
reversed_text = "".join(reversed(text))

print(reversed_text)

"".join(...) combines the characters produced by the iterator into one new string.

For a readable manual approach, build a result in a loop:

text = "Python"
reversed_text = ""

 character  text:
    reversed_text = character + reversed_text

(reversed_text)

Consider this code:

word = "cat"
backward = word[::-1]
print(backward)

Python processes it as follows:

1. word refers to the string "cat".
2. [::-1] requests the whole string because the start and stop are omitted.
3. The step is -1, so Python starts at the final character: "t".
4. It continues backward: "a", then "c".
5. Python creates the new string "tac" and stores it in backward.
6. print(backward) displays:

tac

The original value is unchanged:

print(word)      # cat
print(backward)  # tac

• Palindrome checks: Compare normalized text with its reverse.

  word = "level"
  is_palindrome = word == word[::-1]
  

• Display newest-first text: Reverse a short sequence before presentation when its order is meaningful.

• Suffix-oriented parsing: Reverse data temporarily when an algorithm is easier to express from the end.

• Data transformations: Reverse a generated token or identifier only when a specification explicitly requires it.

• Learning algorithms: String reversal demonstrates indexing, slicing, iteration, and immutability.

In production Python code, direct slicing is common when the intent is simply to reverse a string:

display_name = raw_name[::-1]

Developers often validate inputs before transforming them, especially in functions that may receive user or API data:

def reverse_text(value: str) -> str:
    if not isinstance(value, str):
        raise TypeError("value must be a string")

    return value[::-1]

This uses a guard clause: invalid input is handled immediately, leaving the successful path simple.

When working with a generic iterable rather than specifically a string, reversed() can make the intention explicit:

def reverse_characters(characters) -> str:
    return "".join(reversed(characters))

For most normal text, avoid manually concatenating strings repeatedly in a large loop. Slicing or "".join(reversed(...)) is more idiomatic.

Calling .reverse() on a string

This does not work because strings have no .reverse() method:

text = "hello"
text.reverse()

It raises an AttributeError. Use slicing instead:

text = "hello"
reversed_text = text[::-1]

Expecting slicing to change the original string

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

The reversed result was created but not saved. Assign it:

text = text[::-1]

Forgetting that reversed() is not a string

text = "hello"
result = reversed(text)
print(result)

This prints an iterator representation, not "olleh". Convert it with :

# Recommended: returns a new reversed string
text[::-1]

# Using reversed(): join characters into a string
"".join(reversed(text))

# Reversed characters as a list
list(reversed(text))

# Reverse a mutable list in place
items.reverse()

• Strings are immutable, so reversal creates a new string.
• Slice syntax is sequence[start:stop:step].
• A step of -1 moves from the end toward the beginning.
• reversed(text) returns an iterator, not a string.
• list.reverse() changes a list and returns None.

Is [::-1] the best way to reverse a string in Python?

Usually, yes. It is concise, idiomatic, and directly returns a new reversed string.

Why does Python not have str.reverse()?

Strings are immutable. An in-place .reverse() operation would imply changing the existing object, which strings cannot do.

Does reversed("hello") return "olleh"?

No. It returns an iterator over the characters in reverse order. Use "".join(reversed("hello")) to produce a string.

Can I reverse words instead of characters?

Yes. Split the sentence into words, reverse the resulting list, then join it:

sentence = "Python is fun"
result = " ".join(reversed(sentence.split()))
# fun is Python

Does reversing a string modify the original variable?

No. text[::-1] creates a new string. Assign the result if you want the variable to refer to it.

Can I use .reverse() after converting a string to a list?

Yes. Convert to a list, call .reverse(), and use to turn the characters back into a string.

• Python string slicing — Explains the [start:stop:step] syntax used by [::-1].
• String immutability — Explains why strings cannot be changed in place.
• Lists and list methods — Lists support the in-place .reverse() method.
• The reversed() function — Produces a reverse iterator for suitable sequences and iterables.
• join() in Python — Combines an iterable of strings into one string.
• Palindrome checking — A common exercise that uses string reversal.
• Python indexing — Helps explain positions from the beginning and end of a string.