Python Substring: In Depth How-To

In Python, a substring is simply a part of a string (also called a slice). Python provides a number of ways to extract or manipulate substrings using powerful features like slicing, string methods, and regular expressions. Working with substrings is essential for many common tasks, such as parsing text, data extraction, and string formatting.

In this post, we’ll explore all the ways you can work with Python substrings:

What Is a Substring?

A substring is a sequence of characters within a string. For example, in the string "hello world", the substring "hello" is a part of the original string. You can extract any sequence of characters from a string to create a substring.

Basic String Slicing

The most common way to extract a substring in Python is using string slicing. Slicing allows you to extract a part of a string by specifying the start and end indices.

Syntax:

substring = string[start:end]

• start: The starting index (inclusive) where the slice begins.
• end: The ending index (exclusive) where the slice ends.

Example:

text = "hello world"
substring = text[0:5]
print(substring)  # Output: hello

Here, we are slicing the string from index 0 to index 5, which extracts the first 5 characters ("hello").

Important Notes:

• The start index is inclusive, meaning the character at the start index is included in the substring.
• The end index is exclusive, meaning the character at the end index is not included in the substring.
• Indexing starts at 0: The first character of the string is at index 0, the second character at index 1, and so on.

Omitting Start or End Indices:

You can omit the start or end index to slice from the beginning or until the end of the string.

• Omitting the start index slices from the beginning of the string:

  text = "hello world"
  print(text[:5])  # Output: hello

• Omitting the end index slices until the end of the string:

  print(text[6:])  # Output: world

Negative Indexing:

Python negative indexing allows you to index from the end of the string. It’s so cool.

• -1 refers to the last character, -2 to the second-last, and so on.

  text = "hello world"
  print(text[-5:])  # Output: world

• You can also combine negative indices with slicing:

  print(text[-5:-1])  # Output: worl

In this example, [-5:-1] slices from the fifth character from the end up to (but not including) the last character.

Extracting Substrings Using Step

You can add a third parameter, step, to the slice, which defines how many characters to skip during the slicing operation.

Syntax:

substring = string[start:end:step]

• step: The number of characters to skip between each slice.

Example:

text = "abcdefgh"
substring = text[0:8:2]  # Extract every second character
print(substring)  # Output: aceg

In this case, the slicing [0:8:2] extracts every second character between index 0 and 8, resulting in "aceg".

You can also use a negative step to reverse the string:

text = "hello"
print(text[::-1])  # Output: olleh

Checking for Substrings with in and not in

You can check if a substring exists within a string using the in and not in operators.

Syntax:

substring in string  # Returns True if substring exists
substring not in string  # Returns True if substring does not exist

Example:

text = "hello world"
print("world" in text)  # Output: True
print("bye" in text)    # Output: False

In this example, "world" is found in the string, so it returns True. "bye" is not found, so it returns False.

Finding Substrings Using find() and index()

Python provides two methods to find the position of a substring within a string:

• find(): Returns the index of the first occurrence of the substring, or -1 if the substring is not found.
• index(): Similar to find(), but raises a ValueError if the substring is not found.

Syntax:

string.find(substring)
string.index(substring)

Example Using find():

text = "hello world"
print(text.find("world"))  # Output: 6
print(text.find("bye"))    # Output: -1

In this example, "world" is found at index 6. Since "bye" is not found, find() returns -1.

Example Using index():

print(text.index("world"))  # Output: 6
# print(text.index("bye"))  # Raises ValueError: substring not found

If the substring is not found, index() raises an exception.

Extracting Substrings Using split()

The split() method splits a string into a list of substrings based on a specified delimiter.

Syntax:

string.split(delimiter)

• delimiter: The character or substring used to split the string. If no delimiter is provided, it splits by whitespace by default.

Example:

text = "apple, banana, cherry"
fruits = text.split(", ")
print(fruits)  # Output: ['apple', 'banana', 'cherry']

In this example, the string is split into a list of three substrings: "apple", "banana", and "cherry".

Splitting by Whitespace:

If no delimiter is provided, split() splits the string by any whitespace (spaces, tabs, newlines).

text = "hello world python"
words = text.split()
print(words)  # Output: ['hello', 'world', 'python']

Limiting the Number of Splits:

You can limit the number of splits by providing a second argument to split(), specifying the maximum number of splits.

text = "a-b-c-d"
parts = text.split("-", 2)
print(parts)  # Output: ['a', 'b', 'c-d']

In this case, the string is split at the first two dashes, resulting in ["a", "b", "c-d"].

Extracting Substrings with partition() and rpartition()

The partition() method splits the string into three parts: the substring before the separator, the separator itself, and the substring after the separator.

Syntax:

string.partition(separator)

Example:

text = "hello world python"
result = text.partition("world")
print(result)  # Output: ('hello ', 'world', ' python')

In this example, the string is partitioned at "world", resulting in a tuple with three parts: before the separator ("hello "), the separator itself ("world"), and after the separator (" python").

The rpartition() method works similarly but starts searching from the right (end) of the string.

Replacing Substrings with replace()

The replace() method allows you to replace all occurrences of a substring with another substring.

Syntax:

string.replace(old, new, count)

• old: The substring to be replaced.
• new: The substring to replace it with.
• count: (Optional) The maximum number of replacements.

Example:

text = "hello world"
new_text = text.replace("world", "Python")
print(new_text)  # Output: hello Python

In this example, "world" is replaced with "Python", resulting in the string "hello Python".

You can also limit the number of replacements by specifying the count argument:

text = "a-b-c-d"
new_text = text.replace("-", "+", 2)
print(new_text)  # Output: a+b+c-d

Extracting Substrings with Regular Expressions

For more complex substring extraction, Python provides the re module, which supports regular expressions (regex) for advanced string matching and manipulation.

Importing the re Module:

import re

Example of Extracting Substrings Using Regex:

import re

text = "My phone number is 123-456-7890"
match = re.search(r"\d{3}-\d{3}-\d{4}", text)
if match:
    print(match.group())  # Output: 123-456-7890

In this example, the re.search() function searches for a pattern that

matches a phone number format (\d{3}-\d{3}-\d{4}), and the group() method extracts the matching substring.

More Complex Pattern Matching:

text = "Contact me at john.doe@example.com or jane.smith@work.org"
emails = re.findall(r"\w+@\w+\.\w+", text)
print(emails)  # Output: ['john.doe@example.com', 'jane.smith@work.org']

Here, the re.findall() function extracts all email addresses from the string.

Key Concepts Recap

• Slicing is the primary way to extract substrings in Python using the syntax string[start:end].
• You can check for the existence of a substring using the in and not in operators.
• Use find() and index() to find the position of a substring.
• split() breaks a string into a list of substrings based on a delimiter.
• replace() allows you to replace parts of a string with new substrings.
• For complex substring extraction, use regular expressions from the re module.

Exercise:

1. Substring Slicing: Write a Python function that takes a string and returns the substring between the 3rd and 8th characters.
2. Find Substring: Write a script that checks if the word “Python” exists in a given string and prints its index.
3. Email Extractor: Using regular expressions, write a script that extracts all email addresses from a block of text.
4. String Replacer: Write a Python script that replaces all occurrences of the word “old” with “new” in a given string, but only for the first two occurrences.

For more info on Python strings, check out the official Python string documentation

Check out our free Learn Python Programming Masterclass to hone your skills or learn from scratch.

The course covers everything from first principles to Graphical User Interfaces and Machine Learning

FAQ

Q1: What is a substring in Python?

A1: A substring is a sequence of characters that exists within another string. In Python, you can extract or manipulate substrings using slicing, string methods like find() or replace(), or regular expressions.

Q2: How can I extract a part of a string using slicing?

A2: You can extract a substring from a string by using the slicing syntax string[start:end]. The start index is inclusive, while the end index is exclusive, meaning the character at end is not included in the result.

Example:

text = "hello world"
substring = text[0:5]
print(substring)  # Output: hello

Q3: How does negative indexing work in slicing?

A3: Negative indexing allows you to slice from the end of the string. -1 refers to the last character, -2 to the second-last character, and so on.

Example:

text = "hello"
print(text[-3:])  # Output: llo

Here, [-3:] slices the string starting from the third character from the end.

Q4: What happens if I omit the start or end index in slicing?

A4:

• Omitting the start index: Slicing will begin from the start of the string.
  Example: text[:5] extracts the first 5 characters.
• Omitting the end index: Slicing will continue until the end of the string.
  Example: text[2:] extracts everything from index 2 to the end.

Q5: How do I check if a substring exists in a string?

A5: You can use the in operator to check if a substring exists in a string. It returns True if the substring is found and False otherwise.

Example:

text = "hello world"
print("world" in text)  # Output: True

Q6: How do I find the position of a substring in a string?

A6: You can use find() or index() to find the position of a substring:

• find() returns the index of the first occurrence or -1 if the substring is not found.
• index() behaves like find() but raises a ValueError if the substring is not found.

Example:

text = "hello world"
print(text.find("world"))  # Output: 6

Q7: How do I split a string into a list of substrings?

A7: You can use the split() method to divide a string into a list of substrings based on a delimiter.

Example:

text = "apple, banana, cherry"
fruits = text.split(", ")
print(fruits)  # Output: ['apple', 'banana', 'cherry']

Q8: How can I replace part of a string with another substring?

A8: You can use the replace() method to replace occurrences of a substring with another.

Example:

text = "hello world"
new_text = text.replace("world", "Python")
print(new_text)  # Output: hello Python

Q9: How do I extract substrings using regular expressions in Python?

A9: You can use the re module (regular expressions) to extract complex patterns from strings. For example, you can extract phone numbers, emails, or specific patterns using regex.

Example:

import re
text = "Call me at 123-456-7890"
match = re.search(r"\d{3}-\d{3}-\d{4}", text)
if match:
    print(match.group())  # Output: 123-456-7890

Q10: What is the difference between partition() and split()?

A10:

• split() breaks the string into multiple parts based on a delimiter and returns a list of substrings.
• partition() splits the string into exactly three parts: the part before the separator, the separator itself, and the part after the separator. It returns a tuple.

Example:

text = "hello world python"
print(text.partition("world"))  # Output: ('hello ', 'world', ' python')

Q11: How do I reverse a string using slicing?

A11: You can reverse a string by using slicing with a negative step value. The syntax string[::-1] reverses the string.

Example:

text = "hello"
print(text[::-1])  # Output: olleh

Q12: What does the step parameter in slicing do?

A12: The step parameter in slicing allows you to skip characters in the string. For example, string[start:end:step] extracts characters between start and end, but skips every step characters.

Example:

text = "abcdefgh"
substring = text[0:8:2]  # Extract every second character
print(substring)  # Output: aceg

Q13: How do I limit the number of splits in the split() method?

A13: You can pass a second argument to split() that limits the number of splits.

Example:

text = "a-b-c-d"
parts = text.split("-", 2)
print(parts)  # Output: ['a', 'b', 'c-d']

Here, the string is split at the first two dashes, resulting in three parts.

Q14: Is it possible to replace only the first occurrence of a substring?

A14: Yes, you can replace only the first occurrence by specifying the count argument in replace().

Example:

text = "a-b-c-d"
new_text = text.replace("-", "+", 1)
print(new_text)  # Output: a+b-c-d

Q15: What happens if I try to slice a string beyond its length?

A15: Python allows slicing beyond the string’s length without raising an error. If the start or end index is out of bounds, Python will return as much of the string as possible.

Example:

text = "hello"
print(text[1:10])  # Output: ello