string.templatelib — Stöd för mallsträngar

Denna modul tillhandahåller stöd för mallsträngar (t-strängar) enligt definitionen i PEP 750. Mallsträngar skapas med prefixet t och ger åtkomst till både de literala strängdelarna och interpolerade värden innan de kombineras.

Tillgänglighet: Mallsträngar stöds inte på de STM32-baserade OpenMV Cams. De är endast tillgängliga på de Alif- och i.MX RT-baserade OpenMV Cams.

Klasser

class string.templatelib.Template(*args)

Representerar en mallsträng. Template-objekt skapas vanligtvis med t-strängssyntax (t"...") men kan även konstrueras direkt med konstruktorn.

strings

En tuppel av strängliteraler som förekommer mellan interpolationer.

interpolations

En tuppel av Interpolation-objekt som representerar de interpolerade uttrycken.

values

En skrivskyddad egenskap som returnerar en tuppel innehållande attributet value från varje interpolation i mallen.

__iter__() → Iterator

Iterera över mallens innehåll och returnera strängdelar och Interpolation-objekt i den ordning de förekommer. Tomma strängar utelämnas.

__add__(other: Template) → Template

Sammanfoga två mallar. Returnerar en ny Template som kombinerar strängarna och interpolationerna från båda mallarna.

Höjer:

TypeError – om other inte är en Template

Sammanfogning av mallar med str är förbjuden för att undvika tvetydighet om huruvida strängen ska behandlas som en literal eller en interpolation:

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 = '')

Representerar ett interpolerat uttryck inom en mallsträng. Alla argument kan skickas som nyckelordsargument.

value

Det utvärderade värdet av det interpolerade uttrycket.

expression

Strängrepresentationen av uttrycket så som det förekom i mallsträngen.

conversion

Konverteringsspecificeraren ('s' eller 'r') om sådan finns, annars None. Observera att MicroPython inte stöder konverteringen 'a'.

format_spec

Formatspecifikationssträngen om sådan finns, annars en tom sträng.

Syntax för mallsträngar

Mallsträngar använder samma syntax som f-strängar men med prefixet t

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

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

Konverteringsspecificerare

Mallsträngar lagrar konverteringsspecificerare som metadata. Till skillnad från f-strängar tillämpas konverteringen inte automatiskt:

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

Bearbetningskoden måste uttryckligen tillämpa konverteringar vid behov.

Formatspecifikationer

Formatspecifikationer lagras som metadata i Interpolation-objektet. Till skillnad från f-strängar tillämpas formateringen inte automatiskt:

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

Enligt PEP 750 krävs det inte att bearbetningskoden använder formatspecifikationer, men när de finns bör de respekteras och matcha f-strängarnas beteende där det är möjligt.

Felsökningsformat

Felsökningsformatet {expr=} stöds:

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

Viktigt

Enligt PEP 750 tillämpar mallsträngar, till skillnad från f-strängar, inte automatiskt konverteringar eller formatspecifikationer. Detta är medvetet utformat för att låta bearbetningskoden styra hur dessa hanteras. Bearbetningskoden måste uttryckligen hantera dessa attribut.

MicroPython tillhandahåller inte den inbyggda funktionen format(). Använd strängformateringsmetoder som str.format() i stället.

Exempelanvändning

Grundläggande bearbetning utan formatstöd:

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)

Bearbetning av mall med formatstöd:

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"

Exempel på HTML-undantagskodning:

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;"

Se även