string.templatelib — Ondersteuning voor template-strings

Deze module biedt ondersteuning voor template-strings (t-strings) zoals gedefinieerd in PEP 750. Template-strings worden gemaakt met het voorvoegsel t en bieden toegang tot zowel de letterlijke stringdelen als de geïnterpoleerde waarden voordat deze worden gecombineerd.

Beschikbaarheid: Template-strings worden niet ondersteund op de op STM32 gebaseerde OpenMV Cams. Ze zijn alleen beschikbaar op de op Alif en i.MX RT gebaseerde OpenMV Cams.

Classes

class string.templatelib.Template(*args)

Vertegenwoordigt een template-string. Template-objecten worden doorgaans gemaakt met de t-string-syntaxis (t"...") maar kunnen ook rechtstreeks worden geconstrueerd met de constructor.

strings

Een tuple van stringliteralen die tussen interpolaties voorkomen.

interpolations

Een tuple van Interpolation-objecten die de geïnterpoleerde expressies vertegenwoordigen.

values

Een alleen-lezen property die een tuple teruggeeft met het value-attribuut van elke interpolatie in de template.

__iter__() → Iterator

Itereert over de inhoud van de template en levert stringdelen en Interpolation-objecten op in de volgorde waarin ze voorkomen. Lege strings worden weggelaten.

__add__(other: Template) → Template

Voegt twee templates samen. Geeft een nieuwe Template terug die de strings en interpolaties van beide templates combineert.

Veroorzaakt:

TypeError – als other geen Template is

Het samenvoegen van een template met een str is verboden om ambiguïteit te voorkomen over de vraag of de string als literal of als interpolatie moet worden behandeld:

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

Vertegenwoordigt een geïnterpoleerde expressie binnen een template-string. Alle argumenten kunnen als keyword-argumenten worden doorgegeven.

value

De geëvalueerde waarde van de geïnterpoleerde expressie.

expression

De stringweergave van de expressie zoals deze in de template-string verscheen.

conversion

De conversiespecificatie ('s' of 'r') indien aanwezig, anders None. Merk op dat MicroPython de 'a'-conversie niet ondersteunt.

format_spec

De format-specificatiestring indien aanwezig, anders een lege string.

Syntaxis van template-strings

Template-strings gebruiken dezelfde syntaxis als f-strings, maar met een t-voorvoegsel:

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

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

Conversiespecificaties

Template-strings slaan conversiespecificaties op als metadata. In tegenstelling tot f-strings wordt de conversie niet automatisch toegepast:

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

Verwerkingscode moet conversies expliciet toepassen wanneer dat nodig is.

Format-specificaties

Format-specificaties worden opgeslagen als metadata in het Interpolation-object. In tegenstelling tot f-strings wordt de opmaak niet automatisch toegepast:

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

Volgens PEP 750 is verwerkingscode niet verplicht om format-specificaties te gebruiken, maar wanneer ze aanwezig zijn moeten ze worden gerespecteerd en waar mogelijk overeenkomen met het gedrag van f-strings.

Debug-formaat

Het debug-formaat {expr=} wordt ondersteund:

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

Belangrijk

Volgens PEP 750 passen template-strings, in tegenstelling tot f-strings, niet automatisch conversies of format-specificaties toe. Dit is opzettelijk zo ontworpen zodat verwerkingscode kan bepalen hoe deze worden afgehandeld. Verwerkingscode moet deze attributen expliciet afhandelen.

MicroPython biedt de ingebouwde functie format() niet. Gebruik in plaats daarvan stringopmaakmethoden zoals str.format().

Voorbeeldgebruik

Basisverwerking zonder format-ondersteuning:

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)

Een template verwerken met format-ondersteuning:

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"

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

Zie ook