string.templatelib — podpora šablonových řetězců

Tento modul poskytuje podporu pro šablonové řetězce (t-strings), jak jsou definovány v PEP 750. Šablonové řetězce se vytvářejí pomocí prefixu t a umožňují přístup jak k literálním částem řetězce, tak k interpolovaným hodnotám předtím, než jsou spojeny.

Dostupnost: Šablonové řetězce nejsou podporovány na OpenMV Cams založených na STM32. Jsou dostupné pouze na OpenMV Cams založených na Alif a i.MX RT.

Třídy

class string.templatelib.Template(*args)

Reprezentuje šablonový řetězec. Objekty Template jsou obvykle vytvářeny syntaxí t-string (t"..."), ale lze je také vytvořit přímo pomocí konstruktoru.

strings

N-tice řetězcových literálů, které se objevují mezi interpolacemi.

interpolations

N-tice objektů Interpolation reprezentujících interpolované výrazy.

values

Vlastnost pouze pro čtení, která vrací n-tici obsahující atribut value z každé interpolace v šabloně.

__iter__() → Iterator

Iteruje přes obsah šablony a postupně vrací řetězcové části a objekty Interpolation v pořadí, v jakém se objevují. Prázdné řetězce jsou vynechány.

__add__(other: Template) → Template

Spojí dvě šablony. Vrací novou Template kombinující řetězce a interpolace z obou šablon.

Vyvolá:

TypeError – pokud other není Template

Spojování šablon s str je zakázáno, aby se předešlo nejednoznačnosti ohledně toho, zda by měl být řetězec považován za literál, nebo za interpolaci:

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

Reprezentuje interpolovaný výraz uvnitř šablonového řetězce. Všechny argumenty lze předat jako pojmenované argumenty.

value

Vyhodnocená hodnota interpolovaného výrazu.

expression

Řetězcová reprezentace výrazu tak, jak se objevil v šablonovém řetězci.

conversion

Specifikátor konverze ('s' nebo 'r'), pokud je přítomen, jinak None. Vezměte na vědomí, že MicroPython nepodporuje konverzi 'a'.

format_spec

Řetězec specifikace formátu, pokud je přítomen, jinak prázdný řetězec.

Syntaxe šablonových řetězců

Šablonové řetězce používají stejnou syntaxi jako f-strings, ale s prefixem t

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

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

Specifikátory konverze

Šablonové řetězce ukládají specifikátory konverze jako metadata. Na rozdíl od f-strings se konverze neaplikuje automaticky:

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

Zpracovávající kód musí konverze v případě potřeby aplikovat explicitně.

Specifikace formátu

Specifikace formátu jsou ukládány jako metadata v objektu Interpolation. Na rozdíl od f-strings se formátování neaplikuje automaticky:

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

Podle PEP 750 zpracovávající kód není povinen specifikace formátu používat, ale pokud jsou přítomny, měly by být respektovány a tam, kde je to možné, odpovídat chování f-strings.

Ladicí formát

Ladicí formát {expr=} je podporován:

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

Důležité

Podle PEP 750, na rozdíl od f-strings, šablonové řetězce neaplikují automaticky konverze ani specifikace formátu. Toto je záměrné, aby zpracovávající kód mohl řídit, jak se s nimi nakládá. Zpracovávající kód musí tyto atributy zpracovat explicitně.

MicroPython neposkytuje vestavěnou funkci format(). Místo toho používejte metody formátování řetězců jako str.format().

Příklad použití

Základní zpracování bez podpory formátování:

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)

Zpracování šablony s podporou formátování:

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"

Příklad escapování 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;"

Viz také