string.templatelib — suport pentru șiruri șablon

Acest modul oferă suport pentru șiruri șablon (t-strings) așa cum sunt definite în PEP 750. Șirurile șablon sunt create folosind prefixul t și oferă acces atât la părțile literale ale șirului, cât și la valorile interpolate înainte ca acestea să fie combinate.

Disponibilitate: Șirurile șablon nu sunt acceptate pe camerele OpenMV Cam bazate pe STM32. Ele sunt disponibile numai pe camerele OpenMV Cam bazate pe Alif și i.MX RT.

Clase

class string.templatelib.Template(*args)

Reprezintă un șir șablon. Obiectele Template sunt de obicei create prin sintaxa t-string (t"..."), dar pot fi construite și direct folosind constructorul.

strings

Un tuplu de literali de șir care apar între interpolări.

interpolations

Un tuplu de obiecte Interpolation care reprezintă expresiile interpolate.

values

O proprietate doar pentru citire care returnează un tuplu conținând atributul value din fiecare interpolare din șablon.

__iter__() → Iterator

Iterează peste conținutul șablonului, producând părțile de șir și obiectele Interpolation în ordinea în care apar. Șirurile goale sunt omise.

__add__(other: Template) → Template

Concatenează două șabloane. Returnează un nou Template care combină șirurile și interpolările din ambele șabloane.

Generează:

TypeError – dacă other nu este un Template

Concatenarea șabloanelor cu str este interzisă pentru a evita ambiguitatea privind faptul dacă șirul ar trebui tratat ca un literal sau ca o interpolare:

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

Reprezintă o expresie interpolată din interiorul unui șir șablon. Toate argumentele pot fi transmise ca argumente cu cuvânt-cheie.

value

Valoarea evaluată a expresiei interpolate.

expression

Reprezentarea ca șir a expresiei, așa cum a apărut în șirul șablon.

conversion

Specificatorul de conversie ('s' sau 'r') dacă este prezent, altfel None. Reține că MicroPython nu acceptă conversia 'a'.

format_spec

Șirul de specificare a formatului dacă este prezent, altfel un șir gol.

Sintaxa șirurilor șablon

Șirurile șablon folosesc aceeași sintaxă ca f-string-urile, dar cu un prefix t

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

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

Specificatori de conversie

Șirurile șablon stochează specificatorii de conversie ca metadate. Spre deosebire de f-string-uri, conversia nu este aplicată automat:

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

Codul de procesare trebuie să aplice explicit conversiile atunci când este necesar.

Specificații de format

Specificațiile de format sunt stocate ca metadate în obiectul Interpolation. Spre deosebire de f-string-uri, formatarea nu este aplicată automat:

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

Conform PEP 750, codul de procesare nu este obligat să folosească specificațiile de format, dar atunci când acestea sunt prezente ar trebui respectate și ar trebui să corespundă comportamentului f-string-urilor acolo unde este posibil.

Format de depanare

Formatul de depanare {expr=} este acceptat:

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

Important

Conform PEP 750, spre deosebire de f-string-uri, șirurile șablon nu aplică automat conversiile sau specificațiile de format. Acest lucru este intenționat, pentru a permite codului de procesare să controleze modul în care acestea sunt tratate. Codul de procesare trebuie să trateze explicit aceste atribute.

MicroPython nu oferă funcția încorporată format(). Folosește în schimb metode de formatare a șirurilor, precum str.format().

Exemplu de utilizare

Procesare de bază fără suport pentru format:

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)

Procesarea unui șablon cu suport pentru format:

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"

Exemplu de escaping HTML:

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

Vezi și