Reversing Strings Through Slicing

Slicing is a useful technique that allows you to extract items from a given sequence using different combinations ofinteger indices known asoffsets. When it comes to slicing strings, these offsets define the index of the first character in the slicing, the index of the character that stops the slicing, and a value that defines how many characters you want to jump through in each iteration.

To slice a string, you can use the following syntax:

a_string[start:stop:step]

Your offsets arestart,stop, andstep. This expression extracts all the characters fromstart tostop − 1 bystep. You’re going to look more deeply at what all this means in just a moment.

All the offsets are optional, and they have the following default values:

Here,start represents the index of the first character in the slice, whilestop holds the index that stops the slicing operation. The third offset,step, allows you to decide how many characters the slicing will jump through on each iteration.

Thestep offset allows you to fine-tune how you extract desired characters from a string while skipping others:

>>>letters="AaBbCcDd">>># Get all characters relying on default offsets>>>letters[::]'AaBbCcDd'>>>letters[:]'AaBbCcDd'>>># Get every other character from 0 to the end>>>letters[::2]'ABCD'>>># Get every other character from 1 to the end>>>letters[1::2]'abcd'

Here, you first sliceletters without providing explicit offset values to get a full copy of the original string. To this end, you can also use a slicing that omits the second colon (:). Withstep equal to2, the slicing gets every other character from the target string. You can play around with different offsets to get a better sense of how slicing works.

Why are slicing and this third offset relevant to reversing strings in Python? The answer lies in howstep works with negative values. If you provide a negative value tostep, then the slicing runs backward, meaning from right to left.

For example, if you setstep equal to-1, then you can build a slice that retrieves all the characters in reverse order:

>>>letters="ABCDEF">>>letters[::-1]'FEDCBA'>>>letters'ABCDEF'

This slicing returns all the characters from the right end of the string, where the index is equal tolen(letters) - 1, back to the left end of the string, where the index is0. When you use this trick, you get a copy of the original string in reverse order without affecting the original content ofletters.

Another technique to create a reversed copy of an existing string is to useslice(). The signature of this built-in function is the following:

slice(start,stop,step)

This function takes three arguments, with the same meaning of the offsets in the slicing operator, and returns aslice object representing the set of indices that result from callingrange(start, stop, step).

You can useslice() to emulate the slicing[::-1] and reverse your strings quickly. Go ahead and run the following call toslice() inside square brackets:

>>>letters="ABCDEF">>>letters[slice(None,None,-1)]'FEDCBA'

PassingNone to the first two arguments ofslice() tells the function that you want to rely on its internal default behavior, which is the same as a standard slicing with no values forstart andstop. In other words, passingNone tostart andstop means that you want a slice from the left end to the right end of the underlying sequence.

Reversing Strings With.join() andreversed()

The second and arguably the most Pythonic approach to reversing strings is to usereversed() along withstr.join(). If you pass a string toreversed(), you get an iterator that yields characters in reverse order:

>>>greeting=reversed("Hello, World!")>>>next(greeting)'!'>>>next(greeting)'d'>>>next(greeting)'l'

When you callnext() withgreeting as an argument, you get each character from the right end of the original string.

An important point to note aboutreversed() is that the resulting iterator yields characters directly from the original string. In other words, it doesn’t create a new reversed string but reads characters backward from the existing one. This behavior is fairly efficient in terms of memory consumption and can be a fundamental win in some contexts and situations, such as iteration.

You can use the iterator that you get from callingreversed() directly as an argument to.join():

>>>"".join(reversed("Hello, World!"))'!dlroW ,olleH'

In this single-line expression, you pass the result of callingreversed() directly as an argument to.join(). As a result, you get a reversed copy of the original input string. This combination ofreversed() and.join() is an excellent option for reversing strings.

Reversing Strings in a Loop

The first technique you’ll use to reverse a string involves afor loop and the concatenation operator (+). With two strings as operands, this operator returns a new string that results from joining the original ones. The whole operation is known asconcatenation.

Here’s a function that takes a string and reverses it in a loop using concatenation:

>>>defreversed_string(text):...result=""...forcharintext:...result=char+result...returnresult...>>>reversed_string("Hello, World!")'!dlroW ,olleH'

In every iteration, the loop takes a subsequent character,char, fromtext and concatenates it with the current content ofresult. Note thatresult initially holds an empty string (""). The new intermediate string is then reassigned toresult. At the end of the loop,result holds a new string as a reversed copy of the original one.

If you prefer using awhile loop, then here’s what you can do to build a reversed copy of a given string:

>>>defreversed_string(text):...result=""...index=len(text)-1...whileindex>=0:...result+=text[index]...index-=1...returnresult...>>>reversed_string("Hello, World!")'!dlroW ,olleH'

Here, you first compute theindex of the last character in the input string by usinglen(). The loop iterates fromindex down to and including0. In every iteration, you use theaugmented assignment operator (+=) to create an intermediate string that concatenates the content ofresult with the corresponding character fromtext. Again, the final result is a new string that results from reversing the input string.

Reversing Strings With Recursion

You can also userecursion to reverse strings. Recursion is when a function calls itself in its own body. To prevent infinite recursion, you should provide abase case that produces a result without calling the function again. The second component is therecursive case, which starts the recursive loop and performs most of the computation.

Here’s how you can define a recursive function that returns a reversed copy of a given string:

>>>defreversed_string(text):...iflen(text)==1:...returntext...returnreversed_string(text[1:])+text[:1]...>>>reversed_string("Hello, World!")'!dlroW ,olleH'

In this example, you first check for the base case. If the input string has exactly one character, you return the string back to the caller.

The last statement, which is the recursive case, callsreversed_string() itself. The call uses the slicetext[1:] of the input string as an argument. This slice contains all the characters intext, except for the first one. The next step is to add the result of the recursive call together with the single-character stringtext[:1], which contains the first character oftext.

A significant issue to note in the example above is that if you pass in a long string as an argument toreversed_string(), then you’ll get aRecursionError:

>>>very_long_greeting="Hello, World!"*1_000>>>reversed_string(very_long_greeting)Traceback (most recent call last):...RecursionError:maximum recursion depth exceeded while calling a Python object

Hitting Python’s default recursion limit is an important issue that you should consider in your code. However, if you really need to use recursion, then you still have the option to set the recursion limit manually.

You can check the recursion limit of your current Python interpreter by callinggetrecursionlimit() fromsys. By default, this value is usually1000. You can tweak this limit usingsetrecursionlimit() from the same module,sys. With these functions, you can configure the Python environment so that your recursive solution can work. Go ahead and give it a try!

Usingreduce() to Reverse Strings

If you prefer using a functional programming approach, you can usereduce() fromfunctools to reverse strings. Python’sreduce() takes afolding or reduction function and an iterable as arguments. Then it applies the provided function to the items in the input iterable and returns a single cumulative value.

Here’s how you can take advantage ofreduce() to reverse strings:

>>>fromfunctoolsimportreduce>>>defreversed_string(text):...returnreduce(lambdaa,b:b+a,text)...>>>reversed_string("Hello, World!")'!dlroW ,olleH'

In this example, thelambda function takes two strings and concatenates them in reverse order. The call toreduce() applies thelambda totext in a loop and builds a reversed copy of the original string.

Thereversed() Built-in Function

The most readable and Pythonic approach to iterate over a string in reverse order is to usereversed(). You already learned about this function a few moments ago when you used it along with.join() to create reversed strings.

However, the main intent and use case ofreversed() is to support reverse iteration on Python iterables. With a string as an argument,reversed() returns an iterator that yields characters from the input string in reverse order.

Here’s how you can iterate over a string in reverse order withreversed():

>>>greeting="Hello, World!">>>forcharinreversed(greeting):...print(char)...!dlroW,olleH>>>reversed(greeting)<reversed object at 0x7f17aa89e070>

Thefor loop in this example is very readable. The name ofreversed() clearly expresses its intent and communicates that the function doesn’t produce anyside effects on the input data. Sincereversed() returns an iterator, the loop is also efficient regarding memory usage.

The Slicing Operator,[::-1]

The second approach to perform reverse iteration over strings is to use the extended slicing syntax you saw before in thea_string[::-1] example. Even though this approach won’t favor memory efficiency and readability, it still provides a quick way to iterate over a reversed copy of an existing string:

>>>greeting="Hello, World!">>>forcharingreeting[::-1]:...print(char)...!dlroW,olleH>>>greeting[::-1]'!dlroW ,olleH'

In this example, you apply the slicing operator ongreeting to create a reversed copy of it. Then you use that new reversed string to feed the loop. In this case, you’re iterating over a new reversed string, so this solution is less memory-efficient than usingreversed().