How Do You Reverse a String in Python?

There are three standard ways to reverse a string in Python, and all three of them give you exactly the same result.

text = 'python'

print(text[::-1])                    # slicing with a negative step
print(''.join(reversed(text)))       # reversed() plus join
print(''.join(list(reversed(text)))) # explicit list

print(list(text))                    # ['p', 'y', 't', 'h', 'o', 'n']
print(list(reversed(text)))          # ['n', 'o', 'h', 't', 'y', 'p']

The slicing version is the one to give first. It is a single character, it reads clearly once you know the idiom, and it is the fastest of the three because the work happens inside the interpreter.

The reversed() version is the most explicit about what is happening. reversed() works with any sequence and it gives you an iterator, so the join call is what turns that iterator back into a string. The list version does the same job with one extra step, and it is occasionally useful when you want to look at the intermediate list.

Why join is needed at all is worth explaining, because it trips people up. reversed() gives you an iterator of characters and not a string, and strings do not have a reverse method, so there is no text.reverse() in Python. The join call is the standard way of putting an iterable of characters back together into one string.

One more thing is worth saying in an interview. The strip() family of methods gives you a new string rather than changing the string in place, and every reversing approach behaves in the same way. If you need to keep the original, put the result into a new name.

Reversing the order of the words with split() and join() is one line, but it loses the original spacing, so the manual version below is worth writing once.

sentence = 'the quick brown fox'

# The one-liner: the word order is reversed.
print(' '.join(reversed(sentence.split())))

# Each word is reversed, but the word order stays the same.
print(' '.join(word[::-1] for word in sentence.split()))


def reverse_words(text):
    """Return the words of text in the opposite order."""
    words = []
    current = []

    for char in reversed(text):
        if char == ' ':
            if current:
                words.append(''.join(current))
                current = []
        else:
            current.append(char)

    if current:
        words.append(''.join(current))

    return ' '.join(reversed(words))


print(reverse_words(sentence))

The one-liner prints fox brown quick the. The second line prints the reverse of each word but keeps the original order. The manual function walks the string backwards and collects characters until it meets a space, and then it joins the collected words in reverse order, so it also gives you fox brown quick the without ever building a list of words up front.

Why bother with the manual version? It is the answer to the interview question that asks you to write a string reversal one character at a time, and it shows that you understand the algorithm rather than the library call. It also handles the details that the one-liner does not. Several spaces in a row collapse into one, and leading or trailing whitespace does not produce empty words, because the empty list of characters is simply skipped.

For real work, use the one-liner. In an interview, it is perfectly fine to write the one-liner first and then mention that the manual version avoids the intermediate list if the interviewer asks you about memory.

The simplest way to reverse a string in Python is text[::-1]. That is one slice and one expression, with no helper function anywhere.

It works because of the way that Python defines a slice with three parts. text[start:stop:step] walks from the start towards the stop and moves step positions at a time. When you leave the start and the stop out, the defaults are the beginning and the end of the sequence. When you set the step to -1, the walk goes backwards instead of forwards, so it starts at the last character and moves towards the beginning. Because the slice is taken with a step, the result is a new sequence that holds the characters in the opposite order.

The important consequence is that the step changes what the missing bounds mean. With a positive step, a missing stop means the end of the sequence. With a negative step, a missing start means the end. That is why text[::-1] gives you the whole string reversed, while text[:0:-1] gives you everything except the first character. The two results differ by exactly one character, and it is a classic interview detail.

Two related points are worth adding. Slicing works on any sequence, so the very same idiom reverses a list. And the result is always a new object, because strings are immutable and there is nothing to change. The work happens inside the interpreter rather than inside a Python-level loop, which is the reason why this approach is the fastest of the available ones.