Using Triple Quotes for Multiline Strings

🏷️ Working with Strings In-Depth / Multiline and Raw Strings

📚 All-in-One📖 Theory Only💻 Code Only

When you're writing Python scripts, you'll often need to work with text that spans multiple lines. This could be a long message, a block of configuration data, or even a SQL query. Instead of using multiple single-line strings and joining them together, Python gives you a cleaner option: triple quotes.

Triple quotes allow you to write strings that naturally flow across several lines, keeping your code readable and your text intact.

⚙️ What Are Triple Quotes?

Triple quotes are simply three consecutive quotation marks. You can use either:

Triple single quotes: '''your text here'''
Triple double quotes: """your text here"""

Both work exactly the same way. The key difference is that triple double quotes are more commonly used for docstrings (documentation strings) in Python, but for multiline strings, either style is perfectly fine.

🛠️ How to Use Triple Quotes

When you enclose text in triple quotes, Python preserves the line breaks exactly as you type them. This means:

Every new line in your code becomes a new line in the string.
Spaces and indentation are kept as they appear.
You don't need to add special characters like \n for new lines.

Example of a simple multiline string:

A variable called message is assigned using triple double quotes. The text spans three lines: "Hello," on the first line, "This is a multiline string." on the second, and "Enjoy learning Python!" on the third. When you print message, the output shows all three lines exactly as written.

📊 Triple Quotes vs. Single-Line Strings with Escape Characters

Here is a quick comparison to show why triple quotes are often easier to work with:

Feature	Triple Quotes	Single-Line Strings with `\n`
Readability	Very high – text looks like the final output	Lower – you must mentally parse `\n` characters
Line breaks	Automatic – just press Enter	Manual – you must insert `\n` at every break
Indentation	Preserved as typed	Must be manually added with spaces or tabs
Best for	Long messages, configuration blocks, SQL queries	Short strings, simple single-line text

🕵️ Common Use Cases for Engineers

As an engineer, you will encounter several scenarios where triple quotes make your life easier:

Writing configuration templates – You can store YAML, JSON, or INI-style configs directly in your code as a multiline string.
Creating help text or documentation – When your script needs to display usage instructions, triple quotes keep the formatting clean.
Building SQL queries – Long database queries become much more readable when written across multiple lines.
Generating email bodies or reports – Text that needs to preserve paragraph breaks is a natural fit.

⚠️ Important Notes on Indentation

One thing to watch out for: if you indent your triple-quoted string inside a function or loop, that indentation becomes part of the string. For example, if your code is indented by four spaces, those four spaces will appear at the beginning of every line in your output.

To avoid unwanted indentation, you have two options:

Start the string immediately after the opening quotes without any leading spaces.
Use the textwrap.dedent() function from Python's standard library to remove common leading whitespace from all lines.

🧪 Practical Tip: Combining Triple Quotes with Variables

You can also use triple quotes with f-strings (formatted strings) to insert variable values into multiline text. This is extremely useful for generating dynamic messages or reports.

Example of an f-string with triple quotes:

A variable called username holds the value "Alice". A variable called log_entry uses triple double quotes with an f prefix. The text includes placeholders like {username} and a date. When you print log_entry, the placeholders are replaced with actual values, and the multiline structure is preserved.

✅ Summary

Triple quotes are a simple but powerful tool for handling multiline strings in Python. They improve code readability, reduce the need for escape characters, and make your scripts easier to maintain. Whether you are writing configuration blocks, help text, or dynamic reports, triple quotes will help you keep your code clean and your text well-formatted.

Triple quotes allow you to create strings that span multiple lines in Python, preserving line breaks and spacing.

📝 Example 1: Basic Multiline String with Triple Double Quotes

Creating a simple multiline string using triple double quotes.

message = """This is a string
that spans across
three lines"""
print(message)

📤 Output: This is a string
that spans across
three lines

📝 Example 2: Using Triple Single Quotes

Creating a multiline string using triple single quotes instead of double quotes.

poem = '''Roses are red,
Violets are blue,
Python is fun,
And so are you'''
print(poem)

📤 Output: Roses are red,
Violets are blue,
Python is fun,
And so are you

📝 Example 3: Multiline String with Indentation

Preserving indentation within a multiline string for code formatting.

code_snippet = """def greet(name):
    print("Hello, " + name)
    print("Welcome to Python")"""
print(code_snippet)

📤 Output: def greet(name):
print("Hello, " + name)
print("Welcome to Python")

📝 Example 4: Multiline String as a Long Comment

Using triple quotes to create a documentation comment for a function.

def calculate_area(length, width):
    """This function calculates
    the area of a rectangle
    using length and width"""
    return length * width

print(calculate_area(5, 3))
print(calculate_area.__doc__)

📤 Output: 15
This function calculates
the area of a rectangle
using length and width

📝 Example 5: Multiline String for SQL Query

Building a readable SQL query using triple quotes for better code clarity.

query = """SELECT customer_name,
                  order_date,
                  total_amount
           FROM orders
           WHERE total_amount > 100
           ORDER BY order_date DESC"""
print(query)

📤 Output: SELECT customer_name,
order_date,
total_amount
FROM orders
WHERE total_amount > 100
ORDER BY order_date DESC

Comparison Table: Triple Quotes vs Single Line Strings

Feature	Triple Quotes	Single Line Strings
Line breaks	Preserved automatically	Must use `\n`
Readability	High for long text	Better for short text
Code comments	Can document functions	Not suitable for docs
SQL queries	Clean formatting	Messy with concatenation
Memory usage	Same as single line	Same as triple quotes