Parsing XML with ElementTree

Readable XML in Python

XML is structured across multiple lines, but an ordinary Python string requires escape sequences such as \n to represent line breaks. Those escape sequences can make the code harder to read and hide the XML structure. Triple-quoted strings provide a way to write multi-line XML directly in Python code while preserving the line breaks and indentation you type.

How Formatting Becomes Content

A triple-quoted string begins with either three single quotes or three double quotes and ends with the matching three quotes. Everything between those boundaries becomes part of the string value. If the text spans several lines, the line breaks become newline characters. If a line contains indentation or other spaces, those spaces are preserved as well. The layout you see inside the quotes is therefore not merely visual code formatting; it contributes to the actual string.

A Multi-Line XML Value

xml_text = '''<catalog>
    <book>Python</book>
</catalog>'''

<catalog>
    <book>Python</book>
</catalog>

The value contains three XML lines. The second line begins with four spaces because those spaces were written between the triple quotes. The displayed XML structure is therefore also represented in the string itself.

Two Equivalent Quote Styles

Triple single quotes and triple double quotes both create multi-line strings. They preserve line breaks, indentation, and spaces in the same way. Choosing one over the other is a matter of style and convenience; neither form provides a different kind of multi-line string.

xml_with_single_quotes = '''<catalog>
    <book>Python</book>
</catalog>'''

xml_with_double_quotes = """<catalog>
    <book>Python</book>
</catalog>"""

From XML Text to Python Data

When XML is represented in Python, the process begins with XML text and produces a Python string value containing that text. Triple quotes make this representation readable because the XML remains visibly arranged across lines rather than being flattened into one long line or filled with explicit newline escape sequences. This is useful when storing XML for testing, embedding configuration data, or preparing a payload to send across the web.

Mistakes with Preserved Whitespace

• Treating indentation as decoration that Python will discard

  The spaces before the book element are inside the triple-quoted string, so they are part of its value.

  Fix: Inspect the layout between the opening and closing triple quotes as actual string content.

• Using explicit newline escapes when the XML should remain readable in the code

  This represents the line breaks, but the XML structure is less visible because the code contains escape sequences instead of visibly separated lines.

  Fix: Use a triple-quoted string when preserving and displaying the XML layout directly is useful.

• Assuming triple single quotes and triple double quotes have different multi-line behavior

  Both forms create multi-line strings and preserve the same kinds of formatting.

  Fix: Choose the quote style based on readability, consistency, or convenience.

• Forgetting the closing triple-quote delimiter

  Python needs matching opening and closing triple quotes to determine the complete string.

  Fix: Close the string with the same triple-quote style used to open it.

Practice the Representation

Key Takeaways

1. Triple single quotes and triple double quotes both create multi-line Python strings.
2. Line breaks, indentation, and spaces between the delimiters become part of the string value.
3. Triple-quoted strings keep formatted XML readable in Python code without requiring explicit newline escape sequences.
4. The choice between triple single quotes and triple double quotes is a matter of style and convenience.
5. Always treat the visual layout inside the delimiters as possible string content.