Python strip() – How to Trim a String or Line
When working with text in Python, a common task is trimming or stripping whitespace and characters from the start and end of strings. Python provides three convenient built-in string methods for this purpose:
- strip() – removes leading and trailing characters
- lstrip() – removes only leading characters
- rstrip() – removes only trailing characters
In this guide, we‘ll take an in-depth look at how to use these methods effectively to clean up and normalize string data in your Python programs. We‘ll cover lots of examples and discuss some best practices. By the end, you‘ll be a pro at stripping strings in Python!
Removing Whitespace with strip()
The most common use case for strip() is to trim whitespace from the start and end of a string. Whitespace refers to characters like spaces, tabs (\t) and newlines (\n).
By default, calling strip() on a string will remove any leading or trailing whitespace. It returns a new string with the whitespace removed. The original string is not modified.
Here‘s a simple example:
text = " hello world! " print(text.strip())
Output:
hello world!
As you can see, the leading and trailing spaces were removed, but the spaces between "hello" and "world!" were preserved. strip() only strips from the start and end of the string.
lstrip() and rstrip() work similarly, but only strip whitespace from the left or right side, respectively:
text = " hello world! " print(text.lstrip()) # "hello world! " print(text.rstrip()) # " hello world!"
Stripping Specific Characters
In addition to whitespace, you can also specify other characters to strip by passing them as an argument to strip(). This allows you to remove any leading or trailing characters from a string.
For example, let‘s say you have a string with leading zeros:
number = "00000123"
print(number.lstrip("0")) # "123"
Or a string with trailing exclamation points:
excited = "Hello!!!"
print(excited.rstrip("!")) # "Hello"
When specifying characters to strip, the order doesn‘t matter. This line would produce the same output as above:
excited = "Hello!!!"
print(excited.rstrip("!!!")) # "Hello"
You can even specify multiple different characters. This will strip any of the specified characters from the start or end:
messy = "www.example.com/"
print(messy.strip("w./")) # "example.com"
One thing to keep in mind is that strip() only removes leading and trailing characters. It won‘t remove anything from the middle of the string.
text = "aabccbaaa"
print(text.strip("a")) # "bccb"
Normalizing User Input
One of the most useful applications of strip() is to clean up user input. When gathering text data from users, it‘s common for them to accidentally include extra whitespace before or after their input.
For example, let‘s say you prompt a user to enter their name:
name = input("What is your name? ")
print(f"Hello {name}!")
If the user types " John " with some extra spaces, your output will look odd:
What is your name? " John " Hello John !
Stripping the name before using it will give you cleaner, more predictable results:
name = input("What is your name? ").strip()
print(f"Hello {name}!")
Now the output looks much better:
What is your name? " John " Hello John!
You could even strip other characters if needed. For example, if your users often accidentally type punctuation before or after their name:
name = input("What is your name? ").strip(", .")
This would handle input like "John," or ".John." nicely.
Extracting Data from Strings
Another handy use for strip() is to extract data from the start or end of string.
For example, let‘s say you have a dataset of filenames:
files = [ "image1.jpg", "audio2.mp3", "document5.pdf" ]
To get just the file extensions, you could do:
extensions = [file.lstrip(*file.split(".")) for file in files]
This uses lstrip() to remove everything before the last "." in each filename. The * unpacks the filename parts into separate arguments.
The result:
[‘.jpg‘, ‘.mp3‘, ‘.pdf‘]
You could also use rstrip() in a similar way to get just the filenames without extensions:
names = [file.rstrip("." + file.split(".")[-1]) for file in files]
This removes the last "." and everything after it.
Result:
[‘image1‘, ‘audio2‘, ‘document5‘]
Stripping Multi-Line Strings
So far we‘ve focused on stripping single lines of text, but strip() works just as well on multi-line strings.
Let‘s say you have some data with inconsistent indentation:
data = ‘‘‘
line one
line two
line three
‘‘‘
To normalize the indentation, you can split the string into lines, strip each line, and join them back together:
lines = data.split("\n")
stripped_lines = [line.strip() for line in lines]
print("\n".join(stripped_lines))
Output:
line one line two line three
Much better! You could even take this a step further and remove blank lines:
stripped_lines = [line for line in stripped_lines if line]
Combining strip() with Other Methods
strip() is often used in combination with other string methods like split() and replace().
For example, let‘s say you want to normalize some phone numbers by removing any non-digit characters. Here‘s one way you could do it:
numbers = [ "555-123-4567", "(555) 987-6543", "555.456.7890" ]def normalize(number): return "".join(char for char in number if char.isdigit())
print([normalize(number) for number in numbers])
Output:
[‘5551234567‘, ‘5559876543‘, ‘5554567890‘]
This uses a generator expression to strip out non-digit characters, then joins the digits back into a string.
You could simplify this further using translate():
def normalize(number):
return number.translate(str.maketrans("", "", "()-. "))
This uses maketrans() to create a translation table that maps all the characters we want to remove to None.
Then translate() applies the mapping to strip those characters from the string.
How strip() Works: A Look Under the Hood
Now that you‘ve seen how to use strip() in your code, let‘s take a quick look at how it works under the hood.
When you call strip() on a string, here‘s what happens:
-
First, it checks if you passed in any characters to strip (e.g. strip("abc")). If not, it defaults to stripping whitespace.
-
Then, it iterates over the string from left to right, checking each character against the set of characters to strip.
-
If it finds a matching character, it removes it and continues. If not, it stops and returns the rest of the string.
-
Finally, it repeats the process from right to left, removing any trailing characters.
The key takeaway is that strip() only removes leading and trailing characters. It doesn‘t look at or modify the middle of the string at all.
This means that using strip() is generally much faster than alternative approaches like using a regular expression or manually slicing the string.
However, there are still some cases where other methods might be faster or more appropriate.
For example, if you only need to remove a single character and you know it will always be at the start or end, slicing would be slightly faster:
text = "$hello$" print(text[1:-1]) # "hello"
Or if you need to strip characters from the middle of the string, a regular expression would be more flexible:
import re text = "abc123def" print(re.sub(r"[a-z]", "", text)) # "123"
But in most cases, strip() will be the most concise and efficient option.
Putting It All Together
To tie everything together, let‘s walk through a few more practical examples that demonstrate how you can use strip() in real-world Python code.
Example 1: Data Cleaning
Suppose you‘re working with a dataset of user information. Some of the fields were manually entered and have inconsistent formatting.
Here‘s a function that cleans up a few common issues:
def clean(value):
return value.strip().lower().replace("n/a", "")
data = [
[" John", "DOE ", "n/a"],
["Jane", "SMITH", " "],
[" Bob ", "JOHNSON", ""]
]
cleaned_data = [[clean(value) for value in row] for row in data]
print(cleaned_data)
Output:
[[‘john‘, ‘doe‘, ‘‘], [‘jane‘, ‘smith‘, ‘‘], [‘bob‘, ‘johnson‘, ‘‘]]
This function strips any leading/trailing whitespace, converts the value to lowercase, and replaces "n/a" with an empty string.
We use a nested list comprehension to apply the function to each value in the dataset.
Example 2: Parsing Lines
Let‘s say you‘re parsing a log file where each line has the format "timestamp message". But some lines also have extra whitespace or punctuation.
Here‘s how you could extract the timestamps and messages:
def parse_line(line):
timestamp, message = line.strip("- ").split(" ", 1)
return timestamp.strip(), message.strip()
log = [
"2023-03-20 10:15:00 - User logged in",
" 2023-03-20 10:16:30 - User created document ",
"2023-03-20 10:17:00- User logged out"
]
parsed_log = [parse_line(line) for line in log]
print(parsed_log)
Output:
[ (‘2023-03-20 10:15:00‘, ‘User logged in‘), (‘2023-03-20 10:16:30‘, ‘User created document‘), (‘2023-03-20 10:17:00‘, ‘User logged out‘) ]
This function first strips any "-" or whitespace from the start and end of the line.
Then it splits the line on the first space to separate the timestamp and message. Finally, it strips any remaining whitespace from the timestamp and message before returning them.
Applying this function to each line in the log file gives us a nice, parsed version to work with.
Conclusion
As you can see, Python‘s strip() method is a powerful tool for cleaning and normalizing string data. Whether you need to remove whitespace, specific characters, or both, strip() makes it easy.
Here are a few key takeaways:
- Use strip() to remove leading and trailing whitespace or characters
- Use lstrip() and rstrip() to only strip from the left or right side
- Pass a string of characters to specify what to strip (e.g. strip(",."))
- Combine strip() with other methods like split() and replace() for more advanced cleaning
- Default to using strip() unless you have a specific reason to use slicing or regex
I hope this guide has given you a comprehensive understanding of how to use strip() effectively in your own code.
With a little practice, you‘ll be stripping strings like a pro in no time! The key is to think carefully about what characters you want to remove and from where.
Happy coding!