string.templatelib — Template String támogatás

Ez a modul támogatást nyújt a sablonkarakterláncokhoz (t-stringek), ahogyan azt a PEP 750 definiálja. A sablonkarakterláncokat a t prefixszel hozzák létre, és hozzáférést biztosítanak mind a literális karakterlánc-részekhez, mind az interpolált értékekhez, mielőtt azok összeállnának.

Elérhetőség: A sablonkarakterláncok nem támogatottak az STM32-alapú OpenMV Cam eszközökön. Csak az Alif- és i.MX RT-alapú OpenMV Cam eszközökön érhetők el.

Osztályok

class string.templatelib.Template(*args)

Egy sablonkarakterláncot reprezentál. A Template objektumokat tipikusan a t-string szintaxis (t"...") hozza létre, de közvetlenül is megalkothatók a konstruktor használatával.

strings

Az interpolációk között megjelenő karakterlánc-literálok tuple-je.

interpolations

Az interpolált kifejezéseket reprezentáló Interpolation objektumok tuple-je.

values

Csak olvasható tulajdonság, amely egy tuple-t ad vissza, amely a sablonban lévő minden interpoláció value attribútumát tartalmazza.

__iter__() → Iterator

Bejárja a sablon tartalmát, a karakterlánc-részeket és a Interpolation objektumokat megjelenésük sorrendjében szolgáltatva. Az üres karakterláncok kimaradnak.

__add__(other: Template) → Template

Két sablon összefűzése. Egy új Template objektumot ad vissza, amely mindkét sablon karakterláncait és interpolációit egyesíti.

Kivétel:

TypeError – ha az other nem Template

A sablon str típussal való összefűzése tilos, hogy elkerülhető legyen a kétértelműség arról, hogy a karakterláncot literálként vagy interpolációként kell-e kezelni:

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

Egy interpolált kifejezést reprezentál egy sablonkarakterláncon belül. Minden argumentum átadható kulcsszó-argumentumként.

value

Az interpolált kifejezés kiértékelt értéke.

expression

A kifejezés karakterlánc-reprezentációja úgy, ahogyan a sablonkarakterláncban megjelent.

conversion

A konverziós specifikáló ('s' vagy 'r'), ha jelen van, egyébként None. Vedd figyelembe, hogy a MicroPython nem támogatja az 'a' konverziót.

format_spec

A formátumspecifikációs karakterlánc, ha jelen van, egyébként egy üres karakterlánc.

Template String szintaxis

A sablonkarakterláncok ugyanazt a szintaxist használják, mint az f-stringek, de t prefixszel:

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

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

Konverziós specifikálók

A sablonkarakterláncok a konverziós specifikálókat metaadatként tárolják. Az f-stringekkel ellentétben a konverzió nem alkalmazódik automatikusan:

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

A feldolgozó kódnak szükség esetén kifejezetten alkalmaznia kell a konverziókat.

Formátumspecifikációk

A formátumspecifikációk metaadatként tárolódnak az Interpolation objektumban. Az f-stringekkel ellentétben a formázás nem alkalmazódik automatikusan:

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

A PEP 750 szerint a feldolgozó kódnak nem kötelező használnia a formátumspecifikációkat, de ha jelen vannak, akkor tiszteletben kell tartani őket, és ahol lehetséges, illeszkedniük kell az f-string viselkedéséhez.

Debug formátum

A debug formátum {expr=} támogatott:

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

Fontos

A PEP 750 szerint, az f-stringekkel ellentétben, a sablonkarakterláncok nem alkalmazzák automatikusan a konverziókat vagy a formátumspecifikációkat. Ez szándékos, hogy a feldolgozó kód irányíthassa, hogyan kezelik ezeket. A feldolgozó kódnak kifejezetten kezelnie kell ezeket az attribútumokat.

A MicroPython nem biztosítja a format() beépített függvényt. Helyette használj karakterlánc-formázó metódusokat, mint a str.format().

Példa használat

Alapszintű feldolgozás formátumtámogatás nélkül:

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)

Sablon feldolgozása formátumtámogatással:

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"

HTML escapelési példa:

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

Lásd még