Learn How to Use Triple Quotes in Python: Absolute Beginners Tutorial

Triple quotes are one of Python's simplest and most useful features for working with text. Whether you need a string that spans several lines, want to document a function, or need to embed quotation marks without escape characters, triple quotes handle all of it cleanly. This tutorial walks through every common use case from the ground up.

In Python, you typically create strings using single quotes ('hello') or double quotes ("hello"). Both produce the same result. But when your string needs to contain line breaks, or when it includes a mix of quotation marks, standard quoting gets awkward fast. That is where triple quotes come in. They give you a third way to define strings that handles multiline content and embedded quotes with no extra effort.

What Are Triple Quotes and Why Do They Exist?

A triple-quoted string begins and ends with three consecutive quote characters. Python supports two styles: three single quotes (''') and three double quotes ("""). Both are functionally identical. The string they produce is the same str type you get from regular single or double quotes.

# Triple double quotes
message_a = """This is a triple-quoted string."""

# Triple single quotes
message_b = '''This is also a triple-quoted string.'''

# They produce the exact same result
print(message_a == message_b)  # True

The key difference between triple quotes and regular quotes is that triple-quoted strings can span multiple lines. With regular single or double quotes, pressing Enter in the middle of a string causes a SyntaxError. Triple quotes let you include real line breaks directly.

The other advantage is embedding quotes. Inside a triple double-quoted string, you can freely use single quotes and double quotes without backslash escaping. Inside a triple single-quoted string, the same applies. This makes triple quotes ideal for text that contains dialogue, HTML, JSON, or SQL where quotation marks appear frequently.

# Embedding both quote types without escaping
dialogue = """She said, "I can't believe it's that simple." """
print(dialogue)

Creating Multiline Strings

The primary use of triple quotes is writing strings that span more than one line. Without triple quotes, you would need to insert \n escape characters or concatenate separate strings. Triple quotes let you write the text naturally, and Python preserves every line break exactly as you typed it.

# Without triple quotes — hard to read
menu_old = "Breakfast: eggs\nLunch: sandwich\nDinner: pasta"

# With triple quotes — clear and readable
menu = """Breakfast: eggs
Lunch: sandwich
Dinner: pasta"""

print(menu)

The output of both approaches is identical, but the triple-quoted version is far easier to read in your source code. This matters when you work with longer text blocks such as email templates, help messages, or configuration strings.

# Starts with a blank line (newline after opening """)
with_blank = """
First line
Second line
"""

# No leading blank line (backslash suppresses newline)
no_blank = """\
First line
Second line
"""

print(repr(with_blank))
# '\nFirst line\nSecond line\n'

print(repr(no_blank))
# 'First line\nSecond line\n'

Docstrings: Documenting Your Code

The second major use of triple quotes is writing docstrings. A docstring is a string literal placed as the very first statement inside a function, class, or module. Python attaches it to the object's __doc__ attribute, making it accessible through the built-in help() function and through IDE tooltips.

def celsius_to_fahrenheit(celsius):
    """Convert a temperature from Celsius to Fahrenheit.

    Parameters:
        celsius (float): Temperature in degrees Celsius.

    Returns:
        float: Temperature in degrees Fahrenheit.
    """
    return celsius * 9 / 5 + 32

# Access the docstring
print(celsius_to_fahrenheit.__doc__)

# Or use the help() function
help(celsius_to_fahrenheit)

PEP 257, the Python docstring conventions guide, recommends using triple double quotes (""") for all docstrings. For a one-liner, keep the opening quotes, text, and closing quotes on the same line. For longer documentation, start with a one-line summary, leave a blank line, then provide detailed descriptions of parameters and return values.

"Always use triple double quotes around docstrings." — PEP 257, Python Docstring Conventions

# Complete example following all four steps
address = """123 Main Street
Apartment 4B
Springfield, IL 62704"""

print(address)
# Output:
# 123 Main Street
# Apartment 4B
# Springfield, IL 62704

Combining Triple Quotes with f-strings and Raw Strings

Triple quotes work with Python's string prefixes. An f prefix turns a triple-quoted string into a multiline f-string, letting you embed variables and expressions inside curly braces. An r prefix creates a raw triple-quoted string where backslashes are treated as literal characters.

Multiline f-strings

name = "Alex"
role = "Developer"
login_count = 47

welcome = f"""Hello, {name}!
Your role: {role}
Total logins: {login_count}"""

print(welcome)
# Output:
# Hello, Alex!
# Your role: Developer
# Total logins: 47

This pattern is common for email templates, CLI output messages, and any situation where you need structured text with dynamic values inserted at runtime.

Raw triple-quoted strings

# Raw string — backslashes stay literal
regex_pattern = r"""
\d{3}       # area code
[-.\s]?     # optional separator
\d{3}       # exchange
[-.\s]?     # optional separator
\d{4}       # subscriber number
"""

print(regex_pattern)
# The \d and \s remain as literal text, not escape sequences

Raw triple-quoted strings are especially useful for regular expressions and Windows file paths where backslashes are meaningful characters rather than escape sequence markers.

Managing Indentation and Whitespace

One of the most common surprises beginners encounter with triple-quoted strings is unwanted indentation. Because triple quotes preserve whitespace literally, any spaces you add for code readability inside a function or class become part of the string itself.

def get_help_text():
    # The 8 spaces of indentation become part of the string
    text = """
        Usage: app [OPTIONS]
        Options:
            --help    Show this message
            --version Show version
    """
    return text

print(repr(get_help_text()))
# '\n        Usage: app [OPTIONS]\n        Options: ...'

Python's standard library provides textwrap.dedent() to solve this. It finds the common leading whitespace across all lines and removes it, so you can indent your triple-quoted strings to match your code structure without polluting the string content.

from textwrap import dedent

def get_help_text():
    text = dedent("""\
        Usage: app [OPTIONS]
        Options:
            --help    Show this message
            --version Show version
    """)
    return text

print(get_help_text())
# Output starts at column 0 — no extra leading spaces

Python Learning Summary Points

1. Triple quotes (""" or ''') create strings that can span multiple lines and embed both single and double quotation marks without escape characters.
2. A triple-quoted string placed as the first statement in a function, class, or module becomes a docstring, stored in the __doc__ attribute and accessible through help().
3. Triple quotes are string literals, not comments. The interpreter processes them as objects. Use # for actual comments that the interpreter should ignore.
4. You can combine triple quotes with the f prefix for multiline f-strings with variable interpolation, or the r prefix for raw strings where backslashes stay literal.
5. Triple-quoted strings preserve all whitespace, including code indentation. Use textwrap.dedent() to strip unwanted leading spaces when the string is defined inside indented code.
6. Place a backslash immediately after the opening triple quotes to suppress a leading blank line in the string content.

Triple quotes are a small feature that saves significant effort across a wide range of Python tasks. Whether you are formatting a help message for a command-line tool, writing clear docstrings for your functions, or embedding a block of HTML in a script, triple-quoted strings keep your code readable and your output clean. Start using them in your next project, and the difference will be immediately apparent.