string.templatelib — Podrška za predloške nizova

Ovaj modul omogućuje podršku za predloške nizova (t-stringove) kako je definirano u PEP 750. Predlošci nizova stvaraju se pomoću prefiksa t i pružaju pristup i doslovnim dijelovima niza i interpoliranim vrijednostima prije nego što se one spoje.

Dostupnost: Predlošci nizova nisu podržani na OpenMV Cam kamerama temeljenima na STM32. Dostupni su samo na OpenMV Cam kamerama temeljenima na Alif i i.MX RT.

Klase

class string.templatelib.Template(*args)

Predstavlja predložak niza. Objekti Template obično se stvaraju sintaksom t-stringa (t"..."), ali se mogu i izravno konstruirati pomoću konstruktora.

strings

Torka literalnih nizova koji se pojavljuju između interpolacija.

interpolations

Torka objekata Interpolation koji predstavljaju interpolirane izraze.

values

Svojstvo samo za čitanje koje vraća torku koja sadrži atribut value iz svake interpolacije u predlošku.

__iter__() → Iterator

Iterira po sadržaju predloška, dajući dijelove niza i objekte Interpolation redoslijedom kojim se pojavljuju. Prazni nizovi se izostavljaju.

__add__(other: Template) → Template

Spaja dva predloška. Vraća novi Template koji kombinira nizove i interpolacije iz oba predloška.

Podiže:

TypeError – ako other nije Template

Spajanje predloška sa str je zabranjeno kako bi se izbjegla nejasnoća o tome treba li niz tretirati kao literal ili kao interpolaciju:

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

Predstavlja interpolirani izraz unutar predloška niza. Svi argumenti mogu se proslijediti kao imenovani argumenti.

value

Izračunata vrijednost interpoliranog izraza.

expression

Prikaz izraza u obliku niza, onako kako se pojavio u predlošku niza.

conversion

Specifikator pretvorbe ('s' ili 'r') ako je prisutan, inače None. Imajte na umu da MicroPython ne podržava pretvorbu 'a'.

format_spec

Niz specifikacije formata ako je prisutan, inače prazan niz.

Sintaksa predloška niza

Predlošci nizova koriste istu sintaksu kao f-stringovi, ali s prefiksom t

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

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

Specifikatori pretvorbe

Predlošci nizova pohranjuju specifikatore pretvorbe kao metapodatke. Za razliku od f-stringova, pretvorba se ne primjenjuje automatski:

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

Kod koji obrađuje mora izričito primijeniti pretvorbe kada je to potrebno.

Specifikacije formata

Specifikacije formata pohranjuju se kao metapodaci u objektu Interpolation. Za razliku od f-stringova, oblikovanje se ne primjenjuje automatski:

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

Prema PEP 750, od koda koji obrađuje ne zahtijeva se uporaba specifikacija formata, ali kada su prisutne treba ih poštovati i, gdje je to moguće, podudarati se s ponašanjem f-stringova.

Format za uklanjanje pogrešaka (debug)

Podržan je format za uklanjanje pogrešaka {expr=}

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

Važno

Prema PEP 750, za razliku od f-stringova, predlošci nizova ne primjenjuju automatski pretvorbe ili specifikacije formata. To je namjerno osmišljeno kako bi kod koji obrađuje mogao kontrolirati način njihove obrade. Kod koji obrađuje mora izričito obraditi te atribute.

MicroPython ne pruža ugrađenu funkciju format(). Umjesto toga koristite metode oblikovanja nizova poput str.format().

Primjer uporabe

Osnovna obrada bez podrške za 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)

Obrada predloška s podrškom za 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"

Primjer izbjegavanja HTML znakova:

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

Vidi također