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#