string.templatelib — Prise en charge des chaînes de modèle

Ce module prend en charge les chaînes de modèle (t-strings) telles que définies dans la PEP 750. Les chaînes de modèle sont créées à l’aide du préfixe t et donnent accès à la fois aux parties littérales de la chaîne et aux valeurs interpolées avant qu’elles ne soient combinées.

Disponibilité : Les chaînes de modèle ne sont pas prises en charge sur les OpenMV Cams basées sur STM32. Elles sont disponibles uniquement sur les OpenMV Cams basées sur Alif et i.MX RT.

Classes

class string.templatelib.Template(*args)

Représente une chaîne de modèle. Les objets Template sont généralement créés par la syntaxe t-string (t"...") mais peuvent également être construits directement à l’aide du constructeur.

strings

Un tuple de chaînes littérales qui apparaissent entre les interpolations.

interpolations

Un tuple d’objets Interpolation représentant les expressions interpolées.

values

Une propriété en lecture seule qui renvoie un tuple contenant l’attribut value de chaque interpolation du modèle.

__iter__() → Iterator

Itère sur le contenu du modèle, produisant les parties de chaîne et les objets Interpolation dans l’ordre où ils apparaissent. Les chaînes vides sont omises.

__add__(other: Template) → Template

Concatène deux modèles. Renvoie un nouveau Template combinant les chaînes et les interpolations des deux modèles.

Lève:

TypeError – si other n’est pas un Template

La concaténation de modèle avec str est interdite pour éviter toute ambiguïté quant à savoir si la chaîne doit être traitée comme un littéral ou une interpolation

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

Représente une expression interpolée au sein d’une chaîne de modèle. Tous les arguments peuvent être passés en tant qu’arguments nommés.

value

La valeur évaluée de l’expression interpolée.

expression

La représentation sous forme de chaîne de l’expression telle qu’elle apparaissait dans la chaîne de modèle.

conversion

Le spécificateur de conversion ('s' ou 'r') s’il est présent, sinon None. Notez que MicroPython ne prend pas en charge la conversion 'a'.

format_spec

La chaîne de spécification de format si elle est présente, sinon une chaîne vide.

Syntaxe des chaînes de modèle

Les chaînes de modèle utilisent la même syntaxe que les f-strings mais avec un préfixe t

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

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

Spécificateurs de conversion

Les chaînes de modèle stockent les spécificateurs de conversion sous forme de métadonnées. Contrairement aux f-strings, la conversion n’est pas appliquée automatiquement

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

Le code de traitement doit appliquer explicitement les conversions lorsque nécessaire.

Spécifications de format

Les spécifications de format sont stockées sous forme de métadonnées dans l’objet Interpolation. Contrairement aux f-strings, le formatage n’est pas appliqué automatiquement

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

Conformément à la PEP 750, le code de traitement n’est pas tenu d’utiliser les spécifications de format, mais lorsqu’elles sont présentes, elles doivent être respectées et correspondre au comportement des f-strings dans la mesure du possible.

Format de débogage

Le format de débogage {expr=} est pris en charge

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

Important

Conformément à la PEP 750, et contrairement aux f-strings, les chaînes de modèle n’appliquent pas automatiquement les conversions ou les spécifications de format. Ceci est intentionnel afin de permettre au code de traitement de contrôler la façon dont ils sont gérés. Le code de traitement doit gérer explicitement ces attributs.

MicroPython ne fournit pas la fonction intégrée format(). Utilisez plutôt des méthodes de formatage de chaîne telles que str.format().

Exemple d’utilisation

Traitement de base sans prise en charge du 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)

Traitement d’un modèle avec prise en charge du 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"

Exemple d’échappement 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;"

Voir aussi