string.templatelib — Unterstützung für Template-Strings

Dieses Modul bietet Unterstützung für Template-Strings (t-Strings) gemäß PEP 750. Template-Strings werden mit dem Präfix t erstellt und ermöglichen den Zugriff sowohl auf die wörtlichen Zeichenkettenteile als auch auf die interpolierten Werte, bevor diese kombiniert werden.

Verfügbarkeit: Template-Strings werden auf den STM32-basierten OpenMV Cams nicht unterstützt. Sie sind nur auf den Alif- und i.MX RT-basierten OpenMV Cams verfügbar.

Klassen

class string.templatelib.Template(*args)

Repräsentiert einen Template-String. Template-Objekte werden üblicherweise durch t-String-Syntax (t"...") erstellt, können aber auch direkt über den Konstruktor erzeugt werden.

strings

Ein Tupel von String-Literalen, die zwischen Interpolationen erscheinen.

interpolations

Ein Tupel von Interpolation-Objekten, die die interpolierten Ausdrücke repräsentieren.

values

Eine schreibgeschützte Eigenschaft, die ein Tupel mit dem value-Attribut jeder Interpolation im Template zurückgibt.

__iter__() → Iterator

Iteriert über den Inhalt des Templates und liefert Zeichenkettenteile und Interpolation-Objekte in der Reihenfolge, in der sie erscheinen. Leere Zeichenketten werden ausgelassen.

__add__(other: Template) → Template

Verkettet zwei Templates. Gibt ein neues Template zurück, das die Zeichenketten und Interpolationen beider Templates kombiniert.

Verursacht:

TypeError – wenn other kein Template ist

Die Verkettung von Templates mit str ist untersagt, um Mehrdeutigkeit darüber zu vermeiden, ob die Zeichenkette als Literal oder als Interpolation behandelt werden soll:

t1 = t"Hello "
t2 = t"World"
result = t1 + t2  # Valid

# TypeError: cannot concatenate str to Template
result = t1 + "World"
class string.templatelib.Interpolation(value: Any, expression: str = '', conversion: str | None = None, format_spec: str = '')

Repräsentiert einen interpolierten Ausdruck innerhalb eines Template-Strings. Alle Argumente können als Schlüsselwortargumente übergeben werden.

value

Der ausgewertete Wert des interpolierten Ausdrucks.

expression

Die Zeichenkettendarstellung des Ausdrucks, so wie er im Template-String erschien.

conversion

Der Konvertierungs-Spezifizierer ('s' oder 'r'), falls vorhanden, andernfalls None. Beachten Sie, dass MicroPython die Konvertierung 'a' nicht unterstützt.

format_spec

Die Formatspezifikations-Zeichenkette, falls vorhanden, andernfalls eine leere Zeichenkette.

Template-String-Syntax

Template-Strings verwenden dieselbe Syntax wie f-Strings, jedoch mit einem t-Präfix:

name = "World"
template = t"Hello {name}!"

# Access template components
print(template.strings)        # ('Hello ', '!')
print(template.values)         # ('World',)
print(template.interpolations[0].expression)  # 'name'

Konvertierungs-Spezifizierer

Template-Strings speichern Konvertierungs-Spezifizierer als Metadaten. Anders als bei f-Strings wird die Konvertierung nicht automatisch angewendet:

value = "test"
t = t"{value!r}"
# t.interpolations[0].value == "test" (not repr(value))
# t.interpolations[0].conversion == "r"

Der verarbeitende Code muss Konvertierungen bei Bedarf explizit anwenden.

Formatspezifikationen

Formatspezifikationen werden als Metadaten im Interpolation-Objekt gespeichert. Anders als bei f-Strings wird die Formatierung nicht automatisch angewendet:

pi = 3.14159
t = t"{pi:.2f}"
# t.interpolations[0].value == 3.14159 (not formatted)
# t.interpolations[0].format_spec == ".2f"

Gemäß PEP 750 ist der verarbeitende Code nicht verpflichtet, Formatspezifikationen zu verwenden, aber wenn sie vorhanden sind, sollten sie beachtet werden und nach Möglichkeit dem Verhalten von f-Strings entsprechen.

Debug-Format

Das Debug-Format {expr=} wird unterstützt:

x = 42
t = t"{x=}"
# t.strings == ("x=", "")
# t.interpolations[0].expression == "x"
# t.interpolations[0].conversion == "r"

Wichtig

Gemäß PEP 750 wenden Template-Strings, anders als f-Strings, Konvertierungen oder Formatspezifikationen nicht automatisch an. Dies ist beabsichtigt, damit der verarbeitende Code steuern kann, wie diese gehandhabt werden. Der verarbeitende Code muss diese Attribute explizit behandeln.

MicroPython stellt die eingebaute Funktion format() nicht bereit. Verwenden Sie stattdessen String-Formatierungsmethoden wie str.format().

Anwendungsbeispiel

Grundlegende Verarbeitung ohne Formatunterstützung:

def simple_process(template):
    """Simple template processing"""
    parts = []
    for item in template:
        if isinstance(item, str):
            parts.append(item)
        else:
            parts.append(str(item.value))
    return "".join(parts)

Verarbeitung eines Templates mit Formatunterstützung:

from string.templatelib import Template, Interpolation

def convert(value, conversion):
    """Apply conversion specifier to value"""
    if conversion == "r":
        return repr(value)
    elif conversion == "s":
        return str(value)
    return value

def process_template(template):
    """Process template with conversion and format support"""
    result = []
    for part in template:
        if isinstance(part, str):
            result.append(part)
        else:  # Interpolation
            value = convert(part.value, part.conversion)
            if part.format_spec:
                # Apply format specification using str.format
                value = ("{:" + part.format_spec + "}").format(value)
            else:
                value = str(value)
            result.append(value)
    return "".join(result)

pi = 3.14159
name = "Alice"
t = t"{name!r}: {pi:.2f}"
print(process_template(t))
# Output: "'Alice': 3.14"

# Other format specifications work too
value = 42
print(process_template(t"{value:>10}"))  # "        42"
print(process_template(t"{value:04d}"))  # "0042"

Beispiel für HTML-Escaping:

def html_escape(value):
    """Escape HTML special characters"""
    if not isinstance(value, str):
        value = str(value)
    return value.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")

def safe_html(template):
    """Convert template to HTML-safe string"""
    result = []
    for part in template:
        if isinstance(part, str):
            result.append(part)
        else:
            result.append(html_escape(part.value))
    return "".join(result)

user_input = "<script>alert('xss')</script>"
t = t"User said: {user_input}"
print(safe_html(t))
# Output: "User said: &lt;script&gt;alert('xss')&lt;/script&gt;"

Siehe auch