Python provides an effective way of handling multiline strings, which you might have encountered when working with lengthy text or dealing with code that spans multiple lines. Understanding how to correctly write a raw multiline string in Python can be essential for maintaining well-structured and easily readable code.
Ordinarily, we express strings in Python using single or double quotes.
✅ Recommended: Python Strings Made Easy
However, when it comes to multiline strings, Python offers a special syntax for defining these types of text. To create a multiline string, you can use triple quotes, either single or double, at the beginning and end of your string.
To correctly write a raw multiline string in Python, use the letter “r” before your opening triple quotes while enclosing your string with triple quotes. For example: r'''This is a raw\n Multiline String'''.
This denotes a raw string and preserves special characters such as backslashes (used for escape sequences) without interpreting them as part of the string. Doing so lets you easily and efficiently handle long strings spanning multiple lines in your Python code.
Understanding Raw Strings
In Python, raw strings are a convenient way to represent strings literally, without processing escape characters. This can be particularly useful when working with regular expressions or dealing with file system paths. To create a raw string, simply prefix the string literal with an r or R character.
For example, a regular string containing a backslash (such as in a file path) would need to be escaped:
normal_string = 'C:\\Users\\John\\Documents'
With raw strings, you don’t need to escape the backslashes:
raw_string = r'C:\Users\John\Documents'
Both of these variables will hold the same string value.
When it comes to creating raw multiline strings, you can use triple quotes """ or ''' combined with the raw string prefix to achieve the desired result. Here’s an example:
raw_multiline_string = r"""This is a raw multiline string with backslashes \t and \n that are not escaped."""
This string will preserve the backslashes and newlines as they appear between the triple quotes.
It is important to note that raw strings cannot end with an odd number of backslashes, as the final backslash would escape the final quote character:
# This will raise a SyntaxError invalid_raw_string = r"This is not valid\"
To deal with this limitation, you can concatenate a regular string with the final backslash:
valid_raw_string = r"This is valid" + "\\"
Multiline Strings
In Python, multiline strings are created using triple quotes, either three single quotes (''') or three double quotes ("""). This allows you to include quotes, tabs, and newlines within the string without using escape characters. Here is an example of a multiline string:
multiline_string = """This is a multiline string in Python with newlines, tabs, and "quotes"."""
If you want to create a raw multiline string, you’ll need to use a different approach, as the r prefix only works for single-line strings. One way to achieve this is by combining raw strings and parentheses, adding an r prefix to each part of the string. This will preserve the string’s escape characters:
raw_multiline_string = (r"on\e"
r"\\tw\\o")
Keep in mind that when using parentheses, the line break will not be included in the string. You can manually add a line break using the \n escape character in the appropriate location like this:
raw_multiline_string_with_linebreak = (r"on\e" r"\n"
r"\\tw\\o")
This method allows you to create raw multiline strings while preserving the escape characters and maintaining readability in your Python code.
💡 Remember: it’s essential to use the r prefix for each part of the string to ensure it’s treated as a raw string. For more information, check out the discussion on Stack Overflow.
3 Ways to Combine Raw and Multiline Strings
In Python, you can combine raw and multiline strings to create a string that spans across multiple lines, while also preserving special characters and escape sequences. This section will explain different ways to achieve this combination.
One common approach is to use triple quotes for creating a multiline string. By using three single quotes (''') or three double quotes ("""), you can create a multiline string that retains any whitespace and can include special characters. To add a raw string, use the r prefix before the triple quotes:
raw_multiline_string = r"""This is a raw multiline string with a backslash: \\ and a new line \n is just character literals."""
Another way to write a raw multiline string is by using parentheses and string concatenation. Each line of the string can be enclosed in single or double quotes, followed by a space to ensure a single whitespace character divides them. Add the r prefix before each quoted line to maintain the raw string format:
raw_multiline_string = (r"This is a raw"
r" multiline string with a backslash: \\"
r" and a new line \n is just character literals.")
Alternatively, you can use the + operator to concatenate multiple raw strings, creating a multiline string. This approach allows you to explicitly specify newline characters or other special characters as needed:
raw_multiline_string = (r"This is a raw" + "\n"
r" multiline string with a backslash: \\" + "\n"
r" and a new line \n is just character literals.")
With these techniques, you can create raw multiline strings that are easier to read and maintain in your Python code.
Multiline Raw String Use Cases and Examples
This section reviews some use cases and examples demonstrating how to correctly write a raw multiline string in Python.
Using raw multiline strings is beneficial when dealing with strings containing many backslashes or with regular expressions. In these scenarios, raw strings prevent the need to escape backslashes, making the code more readable.
Here’s a basic example of creating a raw multiline string:
multiline_raw_string = r"""This is a raw \ multiline string in Python. \\ You don't need to escape the backslashes \\."""
In this example, the backslashes are preserved in the text as they’re written, without the need to escape them, thanks to the r prefix before the triple quotes.
Now, let’s take a look at a specific use case with regular expressions:
Suppose you want to match a file path pattern in a text, using a regular expression. Without raw strings, you’d need to escape the backslashes:
import re pattern = 'C:\\\\Users\\\\[A-Za-z0-9]+\\\\Documents' text = 'C:\\Users\\JohnDoe\\Documents\\example.txt' result = re.search(pattern, text) print(result.group())
With raw strings, the regex pattern becomes more readable, as you don’t need to escape the backslashes:
import re pattern = r'C:\\Users\\[A-Za-z0-9]+\\Documents' text = 'C:\\Users\\JohnDoe\\Documents\\example.txt' result = re.search(pattern, text) print(result.group())
In both examples, the output is the same:
C:\Users\JohnDoe\Documents
These examples demonstrate the benefits of using raw multiline strings in Python, especially when working with text that contains special characters like backslashes or incorporating regular expressions in your code.
Feel free to check out our full guide on raw strings here:
💡 Full Guide: Python Raw Strings: A Helpful Easy Guide
If you want to keep improving your programming skills, consider joining our free email academy (130,000 coders) by downloading your cheat sheets here: