string.templatelib — Supporto per le Template String

Questo modulo fornisce il supporto per le template string (t-string) come definito in PEP 750. Le template string vengono create usando il prefisso t e forniscono l’accesso sia alle parti letterali della stringa sia ai valori interpolati prima che vengano combinati.

Disponibilità: Le template string non sono supportate sulle OpenMV Cam basate su STM32. Sono disponibili solo sulle OpenMV Cam basate su Alif e i.MX RT.

Classi

class string.templatelib.Template(*args)

Rappresenta una template string. Gli oggetti Template vengono tipicamente creati tramite la sintassi t-string (t"...") ma possono anche essere costruiti direttamente usando il costruttore.

strings

Una tupla di letterali stringa che compaiono tra le interpolazioni.

interpolations

Una tupla di oggetti Interpolation che rappresentano le espressioni interpolate.

values

Una proprietà di sola lettura che restituisce una tupla contenente l’attributo value di ciascuna interpolazione nel template.

__iter__() → Iterator

Itera sul contenuto del template, restituendo le parti stringa e gli oggetti Interpolation nell’ordine in cui compaiono. Le stringhe vuote vengono omesse.

__add__(other: Template) → Template

Concatena due template. Restituisce un nuovo Template che combina le stringhe e le interpolazioni di entrambi i template.

Solleva:

TypeError – se other non è un Template

La concatenazione di un template con uno str è vietata per evitare ambiguità sul fatto che la stringa debba essere trattata come letterale o come interpolazione:

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

Rappresenta un’espressione interpolata all’interno di una template string. Tutti gli argomenti possono essere passati come argomenti keyword.

value

Il valore valutato dell’espressione interpolata.

expression

La rappresentazione in stringa dell’espressione così come appariva nella template string.

conversion

Lo specificatore di conversione ('s' o 'r') se presente, altrimenti None. Nota che MicroPython non supporta la conversione 'a'.

format_spec

La stringa di specifica del formato se presente, altrimenti una stringa vuota.

Sintassi delle Template String

Le template string usano la stessa sintassi delle f-string ma con un prefisso 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 di Conversione

Le template string memorizzano gli specificatori di conversione come metadati. A differenza delle f-string, la conversione non viene applicata automaticamente:

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

Il codice di elaborazione deve applicare esplicitamente le conversioni quando necessario.

Specifiche di Formato

Le specifiche di formato vengono memorizzate come metadati nell’oggetto Interpolation. A differenza delle f-string, la formattazione non viene applicata automaticamente:

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

Secondo la PEP 750, il codice di elaborazione non è obbligato a usare le specifiche di formato, ma quando sono presenti dovrebbero essere rispettate e corrispondere al comportamento delle f-string ove possibile.

Formato di Debug

Il formato di debug {expr=} è supportato:

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

Importante

Secondo la PEP 750, a differenza delle f-string, le template string non applicano automaticamente conversioni o specifiche di formato. Questo è per scelta progettuale, per consentire al codice di elaborazione di controllare come queste vengono gestite. Il codice di elaborazione deve gestire esplicitamente questi attributi.

MicroPython non fornisce la funzione built-in format(). Usa invece i metodi di formattazione delle stringhe come str.format().

Esempio di Utilizzo

Elaborazione di base senza supporto del formato:

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)

Elaborazione di un template con supporto del formato:

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"

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

Vedi Anche