How do you build an XML document with ElementTree's SubElement and write it out?

## Constructing the tree Two constructors cover almost everything. `ET.Element(tag, attrib={}, **extra)` creates a free-standing element — typically your root. `ET.SubElement(parent, tag, attrib={}, **extra)` creates one *and appends it to the parent* in a single call, returning the new element. That attachment is the whole point: writing `child = ET.Element('x'); parent.append(child)` produces the same result with more moving parts, and forgetting the `append` is a common bug that yields a silently empty document. Attributes go in either as a dict or as keyword arguments, and the dict form is required for names that are not Python identifiers, such as anything hyphenated or namespaced. Character data is assigned to `.text`; the text that follows an element's closing tag, inside its parent, is `.tail`, which matters mainly when you are editing an existing document and want to preserve or produce spacing. ```python root = ET.Element("batch", {"run": "nightly"}) txn = ET.SubElement(root, "txn", id="1") ET.SubElement(txn, "score").text = str(0.93) ``` Editing is symmetric: `parent.remove(child)` detaches, `parent.insert(i, child)` places at a position, `parent.extend(iterable)` adds several, and slice assignment works because an element behaves like a sequence of children. ## Everything is a string `ElementTree` stores whatever object you assign to `.text` or to an attribute value and validates nothing at assignment time. The serializer, however, only knows how to write `str`. So `elem.text = 0.93` raises `TypeError: cannot serialize 0.93 (type float)` — but only when you serialize, potentially far from the line that caused it. The same applies to `elem.set('n', 3)`. Convert at the point of assignment, and make the formatting decision there too: `f"{value:.4f}"` says something a bare `str(value)` does not. There is no schema and no type system here. An XML document carries text; anything about numbers, dates or booleans is a convention between you and the consumer, and a fraud-scoring service emitting `<score>` values had better agree on precision and on the timezone rules for any timestamp before a clock-skew artefact turns into a downstream reconciliation dispute. ## Pretty-printing `ElementTree` writes no gratuitous whitespace: the default output is one long line. `ET.indent(tree, space=' ', level=0)`, added in 3.9, walks the tree and rewrites `text` and `tail` to produce indentation **in place**. That is a mutation, not a rendering option, so it changes the document's character data — harmless for most consumers, meaningful for anything whitespace-sensitive, and worth doing only when a human or a diff will read the output. ## Serialisation and its defaults Two entry points exist. `ET.tostring(element, encoding=None, ...)` returns the serialized form; `ET.ElementTree(root).write(file_or_filename, ...)` writes it. Their defaults are identical and both surprise people: - **Encoding.** The default is `us-ascii`, so `tostring(elem)` returns `bytes` and any non-ASCII character is escaped as a numeric character reference such as `caf&#233;`. Pass `encoding='utf-8'` for real UTF-8 bytes, or the special `encoding='unicode'` to get a `str` back — which is also what you need when writing to a file opened in text mode. - **The XML declaration.** `xml_declaration` defaults to `None`, meaning "write one only if the encoding is something other than UTF-8, US-ASCII or unicode". So `write(f, encoding='utf-8')` produces **no** `<?xml ...?>` line. Pass `xml_declaration=True` explicitly when the consumer expects one. - **Empty elements.** `short_empty_elements` defaults to `True`, giving `<x />`; set it `False` when a consumer insists on `<x></x>`. - **Namespaces.** URIs are serialized with generated prefixes (`ns0`, `ns1`) unless you call `ET.register_namespace(prefix, uri)` beforehand or pass `default_namespace=uri`. ## Why not just format strings? The interview subtext of this question is usually escaping. Building XML with f-strings works until a value contains `&`, `<` or a quote character, at which point the output is malformed or, worse, subtly restructured by attacker-controlled input. `ElementTree` escapes text and attribute values on serialization, so correctness is the default rather than a review checklist item. The only real cost is that the whole document is materialised before writing, which is fine for a report and wrong for a multi-gigabyte export — for that, an incremental writer or a hand-managed chunked emission is the right shape.