Remove the First and Last Character of a Python String

There are various string manipulation methods that you can use to remove the first and last character of a Python string. In this article, we will discuss three different ways that you can achieve this objective.

Whether you know the contents of the string that you are working with or not, there is a method here for you. Read on to find out how and get coding!

Method 1: Using String Slicing to Remove the First and Last Characters From a Python String

String slicing is perhaps the easiest and most elegant method for removing the first and last characters of a string. String slicing allows you to extract only a snippet of your original string. This snippet is called a ‘slice’. You’ll use the indices of the string to specify the boundaries of your slice. If this sounds a little confusing, don’t worry. We’ll get into the details below!

String Indexing: What are String Indices and How are They Used in String Slicing?

For the uninitiated, “indices” is simply the plural of “index.” In order to understand string slicing, you must first understand string indexing. We’ll go through some examples below to make sure you have a good understanding of how string indexing works in Python, then move on to string slicing.

Simple String Indexing with No Whitespace

A string’s index is a list of characters that appear in the string, organized in order of appearance. Each character in a string has an index number. The string index starts at zero (0) and increases by 1 for each consecutive character. Let’s look at a simple example. We’ll first create a string called mystring:

mystring = ‘mystring’

Now, let’s take a look at how this string is indexed. Remember, indexing starts at zero, so our index will look like this:

As you can see, the string ‘mystring’ has 8 characters, and thus has an index running from 0-7. If we want to check the length of mystring, we can use len(mystring).

Putting it all together, our code to create the mystring string, check its length, and print the length to the terminal would look like this:

mystring = 'mystring'
print(len(mystring))

The output should be 8.

Whitespace Characters in String Indexing

All characters in a given Python string are indexed, including whitespace characters like spaces and tabs. Importantly, a tab takes up more than one character’s worth of space when printed, but is only counted as one position in the string index.

In the following code, we will use the ‘\t’ special character to add a full tab to the beginning of the ‘mystring’ object:

mystring = '\t mystring'

If we were to run print(mystring), we would see the text ‘mystring’ printed behind a tab. Although a standard tab takes up 8 characters, it will only take up one position in the string index. Therefore, when we check the length of mystring, the output will be 9 rather than 13:

input:

print(len(mystring))

output:

9

Because string indexing starts at zero, the tab character would have an index position of 0 and the letter ‘m’ would have an index position of 1.

Now that we understand how string indexing works and how whitespace characters behave within a string index, we’ll look at how we can pull specific characters from a string using their indices.

Using String Indexing to View Specific Characters Within a String

To look at a single character within a string variable, we will call the variable name and place the index number of the character that we want to see within a set of square braces in the form stringname[index_position].

In the following example, we’ll use the indices to call the letter ‘s’ from mystring:

mystring[2]

Because indexing starts at 0, we would call mystring[7] (rather than mystring[8]) to return the letter ‘g’.

Reverse Indexing

To start your search of the index at the end of the string rather than the beginning, you can use reverse indexing. In contrast to normal indexing, there is no position 0 in the reverse index. Instead, the reverse index starts at -1 and counts down from there (-1, -2, -3, . . . -n).

You’ll recall that ‘mystring’, had a length of 8 and thus an index of 0 through 7, with ‘m’ at index position 0 and ‘g’ at index position 7. The reverse index of the same string would start with ‘g’ at reverse index position -1 and end with ‘m’ at position -8.

Let’s take a look at a few examples, just to make sure we understand how reverse indexing works in Python.

Input:

#creating a few strings for us to work with
string1 = 'simple_string'
string2 = 'A bit more complex.'
string3 = 'It was the best of times, it was the worst of times'

#finding and printing the last character of each string
print('The last character of String 1 is: ' + string1[-1])
print('The last character of String 2 is: ' + string1[-1])
print('The last character of String 3 is: ' + string1[-1])

Output:

The last character of String 1 is: 'g'
The last character of String 2 is: '.'
The last character of String 3 is: 's'

Now that you understand how indexing works, you can learn how to use indexing to grab ‘slices’ of strings.

String Slicing in Python

String slicing in Python is a bit more complicated than string indexing. With string slicing, we are grabbing a piece of the string rather than a single character. We will use string indices to define the boundaries of the ‘slice’ that we want to grab from the string.

To begin, we’ll use ‘mystring’ again. Recalling string indexing, if we want to call the letter ‘t’ from the ‘mystring’ object, we would write mystring[3]. (Remember: indexing begins at zero!)

To get the ‘slice’ of the string that starts with ‘t’ and runs until the end of the string, we can add a colon after the index position as shown in the example below.

Input:

mystring[3:]

Output:

tring

If we want to grab the section of the string from the beginning through the letter ‘t’, we can use the right instead of the left side of the colon. This is called a “stop index.”

You should take note that when using a stop index, the output will be the beginning of the string up to, but not including, the stop index position. So, to grab ‘myst’ from our string, we would write mystring[4] rather than mystring[3], because we want to include the character at index position three.

Input:

mystring[:4]

Output:

myst

Using String Slicing to Remove the First and Last Character From a Python String

Now that you understand string indexing and basic string slicing, you can put together everything that you’ve learned to remove the first and last character of your Python string.

First, we can use basic slicing to grab the second through next to last character of our string:

mystring[1:7]

Now, you may be wondering what we do when we have a long string. For instance:

longstring = 'This string is so long. I really do not want to count how many individual characters there are!'

In that case, we can use negative indices for the stop index! Let’s take a look:

Input:

longstring[0:-1]

Output:

This string is so long. I really do not want to count how many individual characters there are!

Finally, we can also use negative indices on both sides of the colon, e.g. mystring[-7:-1].

Now that you understand how to remove the first and last characters of your string using string slicing, let’s take a look at how we can achieve the same goal using the strip() string method.

Method 2: Use the strip() Method to Remove the First and Last Character from a Python String

The strip() method is a string method that comes built in to Python. For us to use the strip() method, though, we will need to know what the first and last characters of our string actually are. Let’s take a look at how it works.

Introduction to the strip() Method

The strip() method is a special Python method that can be used on strings. The basic syntax for using the strip() method without any parameters is:

stringname.strip()

Using this basic syntax, the strip() method will remove any white space from the beginning (left) and end (right) of the string. For example, imagine there was a leading and trailing tab in ‘mystring’:

mystring = '\t mystring \t'

And let’s go ahead and insert the string into a sentence so that you can see what this looks like when printed.

Input

sentence = "This is what" + mystring + "looks like with leading and trailing tabs."
print(sentence)

Output:

This is what     mystring     looks like with leading and trailing tabs.

As you can see, the word “mystring” has tabs padding it on either side. But let’s see what happens when we use the strip() method inside the sentence variable:

Input:

sentence = "This is what" + strip(mystring) + "looks like without leading and trailing tabs."
print(sentence)

Output:

This is what mystring looks like without leading and trailing tabs.

Using Parameters in the strip() Method

Without any parameters, the strip() method will clear any leading and trailing whitespace from a string, as we saw above. However, we can also pass string characters as parameters to tell the strip() method Which characters we want to remove from the beginning and end of the string.

Now, let’s try to take the ‘m’ away from mystring using the strip() method:

Input:

mystring.strip('m')

Output:

ystring

W can also remove the ‘g’ using the same method, i.e., mystring.strip('g').

It is important to remember that the strip() method removes leading and trailing characters only. Therefore, if you are trying to remove a character that appears at the beginning and end of a string, but also somewhere in the middle, those middle characters will be safe.

Let’s take a look at what I mean.

Input:

sentence = 'This is a gorgeous sentence. What a beautiful thing'
sentence.strip('g')

Output:

This is a gorgeous sentence. What a beautiful thin

Note how the g’s in the word ‘gorgeous’ remain in the string after stripping because they are not at the beginning or the end of the string.

We should also note how the strip() method will behave when there are repeated characters at the beginning or end of a string. Consider the following string objects:

repeat_start = 'AA Rated Law Firm At Your Service"
repeat_end = 'The troops are stationed at Fort Bragg"

If we were to run the following code:

repeat_start.strip('A')
repeat_end.strip('g')

We would get the following output:

'Rated Law Firm At Your Service'
'The troops are stationed at Fort Bra'

The strip() method gets rid of all of the specified characters at the beginning and end of the string. As you can see from the example, if there is a repeated character at the beginning or end of the string, all instances of that character are removed.

Because the strip() method removes all trailing and leading characters that are specified, we should not use it to remove the first and last character of a string unless we are sure that there are no repeated characters at the start or end of the string.

Removing the First and Last Character Using the strip() Method

To use the strip() method to remove the first and last character of a Python string, we have to be sure of two things before we begin. First, we must know what the first and last characters of the string actually are. In order to pass them as parameters to be removed by the strip() method, we have to know what those characters are.

Second, we have to be sure that there are no repeated characters at the beginning or end of the string.

If our objective is to remove only the very first and the very last character of a string, then we have to be sure that those characters are not repeated before using strip() to remove them.

In our case, we know that ‘mystring’ does not have any repeated characters, and we know that it begins with ‘m’ and ends with ‘g’. Therefore, we can use the following code to remove the first and last character of our string:

stripped = mystring.strip('mg')

Method 3: Using Regular Expressions to Remove the First and Last Character From a String

Although it is a rather clunky method, you can also use regular expressions to remove the first and last characters from a Python string. To work with regular expressions in Python, we will first have to import the ‘re’ (RegEx) module:

import re

Regular Expression Metacharacters

Metacharacters are characters that have a special meaning. There are many metacharacters associated with the RegEx module. Discussing all of them is beyond the scope of this tutorial. However, we will need to know a couple of the RegEx metacharacters to achieve our objective.

In RegEx, a period (‘.’) represents any character except for a newline character. the carrot (‘^’) means ‘starts with,’ and a dollar sign (‘$’) stands for ‘ends with.’ Let’s look at a few examples.

The following will return a match if there is a ‘q’ at the start of ‘mystring’. Otherwise, it will return None.

import re
check_start = re.seasrch('^q', mystring)

We can do the same thing with the end of the string. Note, however, that the RegEx symbol comes after the character that we are looking for.

import re
check_end = re.search('g$'), mystring)

Using RegEx to Remove the First and Last Characters From a String

Now that we understand how to use regular expressions in Python, we can use what we have learned to remove the first and last characters from a string.

To do so, we could use the following code:

import re

mystring = 'mystring'
trimmmed_string = re.sub('^.|.$', '', mystring)
print(trimmed_string)

In this example, we’ve created a new string called ‘trimmed_string’ and used the re.sub() method to replace the first and last character of the string with empty strings. Our regular expression pattern, contained in single quotes, is:

^.|.$

The carrot with the period (‘^.’) means RegEx will search for any character at the beginning of the string. The period and dollar sign on the right side of the pipe mean that RegEx will also search for any character at the end of the string. The pipe means that whether there is any character at the beginning of the string or any character at the end, or both, RegEx will perform the substitution function on that character.

The empty set of quotes that follow our regular expression represent the empty string that will replace the first and last characters in our original string. Finally, we call the string to be searched by RegEx, in this case, ‘mystring’

Conclusion

In this article, we’ve learned three different methods for removing the first and last character from a Python string. Each method has advantages and disadvantages, and there are use cases for which one method may be better suited than another. By learning and understanding all three of these methods, you’ll be prepared to tackle this task no matter what situation you are dealing with!