How to Reverse a String in Python: The Definitive Guide

You might need to reverse a Python string. This comes up in interviews and practical problems, like checking for palindromes. There isn’t just one way to do it. Here are the methods explained, so you know which one to use and why.

Method 1: Slicing (The “Pythonic” Way)

This is the most common and direct method. If you want to reverse a string, this is your default.

Python
my_string = "hello"
reversed_string = my_string[::-1]
print(reversed_string)
# Output: "olleh"

How It Works: A Deep Dive

Slicing is a fundamental feature in Python. The syntax is [start:stop:step].

• start: The index where the slice begins.
• stop: The index where the slice ends (it does not include the character at this index).
• step: The amount to increment by.

When you use [::-1], you are telling Python:

• start is omitted: This means “start from the beginning.”
• stop is omitted: This means “go all the way to the end.”
• step is -1: This is the crucial part. A negative step means you iterate backward. Instead of going from left to right, you go from right to left.

When the step is negative, the default values for start and stop are implicitly swapped. It effectively starts from the last element and goes to the first. So, [::-1] creates a new string by taking every character from the original, starting from the end and moving one step back at a time. This is fast because it’s implemented in C at a low level.

Some argue this syntax is “arcane,” but that’s nonsense. Slicing is basic Python. Not knowing it is a significant gap in your knowledge.

Method 2: Using reversed() and join()

This method is often considered more readable by some developers because it uses explicit function names.

Python
my_string = "hello"
reversed_string = "".join(reversed(my_string))
print(reversed_string)
# Output: "olleh"

How It Works: A Deep Dive

This is a two-step process:

• reversed(my_string): The built-in reversed() function takes a sequence (like a string) and returns an iterator that yields items from the sequence in reverse order. It doesn’t create a new reversed string in memory all at once, which makes it memory-efficient, especially for very large strings.
• "".join(...): The join() method is called on an empty string "". It takes an iterable (the reverse iterator from the previous step) and concatenates its elements into a single string. It puts the calling string (in this case, nothing) between each element. The result is the final, reversed string.

This approach is explicit and very readable. Performance-wise, it’s generally fast, though slicing is often slightly faster for typical string lengths due to less overhead from function calls.

Method 3: The for Loop (The Manual Way)

This is how you would reverse a string in many other languages. It’s not the most efficient in Python, but it’s essential to understand the logic, especially for interviews where they might forbid built-ins.

Python
def reverse_string_loop(s):
    reversed_s = ""
    for char in s:
        reversed_s = char + reversed_s
    return reversed_s

my_string = "hello"
reversed_string = reverse_string_loop(my_string)
print(reversed_string)
# Output: "olleh"

How It Works: A Deep Dive

Initialize an empty string, reversed_s.

The for loop iterates through my_string from beginning to end (h, then e, then l, etc.).

In each iteration, it takes the current character (char) and concatenates it to the beginning of reversed_s.

1st iteration: reversed_s = “h” + “” -> “h”
2nd iteration: reversed_s = “e” + “h” -> “eh”
3rd iteration: reversed_s = “l” + “eh” -> “leh”
…and so on.

Performance Warning: This method is inefficient in Python. Strings are immutable, meaning they cannot be changed. Each time you do reversed_s = char + reversed_s, Python has to create a completely new string in memory. For a string of length n, this results in creating n new strings, leading to a performance complexity of O(n²). This is significantly slower than slicing or join(), which are closer to O(n). While it’s good to know, avoid this in production code.

Method 4: The while Loop with Pointers

This is another manual method that modifies a list of characters in-place. It’s a common pattern in lower-level languages and is a good exercise in understanding algorithms.

Python
def reverse_string_while(s):
    # Strings are immutable, so convert to a list
    char_list = list(s)
    left = 0
    right = len(char_list) - 1

    while left < right:
        # Swap characters
        char_list[left], char_list[right] = char_list[right], char_list[left]
        left += 1
        right -= 1
    
    return "".join(char_list)

my_string = "hello"
reversed_string = reverse_string_while(my_string)
print(reversed_string)
# Output: "olleh"

How It Works: A Deep Dive

Since strings are immutable, you first have to convert the string to a list, which is mutable.

• Initialization: Create two “pointers,” left starting at the first index (0) and right starting at the last index (len(s) - 1).
• Loop Condition: The loop continues as long as the left pointer is to the left of the right pointer. Once they meet or cross, the list is fully reversed.
• Swapping: Inside the loop, the characters at the left and right positions are swapped. This is a classic two-pointer algorithm.
• Pointer Movement: After each swap, left is incremented and right is decremented, moving the pointers closer to the center of the list.
• Final Join: After the loop finishes, the list of characters is joined back into a string.

This approach is efficient (O(n) time complexity) because it performs the reversal in place on the list, avoiding the repeated creation of new objects.

Comparison and Conclusion

Also Read:

• Guide to String Manipulation in Python
• Introduction to Python Pandas
• Python Tutorial