Modul string.templatelib --- Dukungan Template String

Modul ini menyediakan dukungan untuk template string (t-string) sebagaimana didefinisikan dalam PEP 750. Template string dibuat menggunakan awalan t dan menyediakan akses ke bagian string literal maupun nilai yang diinterpolasi sebelum keduanya digabungkan.

Ketersediaan: Template string tidak didukung pada OpenMV Cam berbasis STM32. Tersedia hanya pada OpenMV Cam berbasis Alif dan i.MX RT.

Kelas

class string.templatelib.Template(*args)

Mewakili template string. Objek Template biasanya dibuat dengan sintaks t-string (t"...") tetapi juga dapat dikonstruksi secara langsung menggunakan konstruktor.

strings

Tuple dari literal string yang muncul di antara interpolasi.

interpolations

Tuple dari objek Interpolation yang mewakili ekspresi yang diinterpolasi.

values

Properti hanya-baca yang mengembalikan tuple berisi atribut value dari setiap interpolasi dalam template.

__iter__() → Iterator

Iterasi atas konten template, menghasilkan bagian string dan objek Interpolation sesuai urutan kemunculannya. String kosong dihilangkan.

__add__(other: Template) → Template

Menggabungkan dua template. Mengembalikan Template baru yang menggabungkan string dan interpolasi dari kedua template.

Pengecualian:

TypeError -- jika other bukan Template

Penggabungan template dengan str dilarang untuk menghindari ambiguitas tentang apakah string harus diperlakukan sebagai literal atau interpolasi:

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

Mewakili ekspresi yang diinterpolasi dalam template string. Semua argumen dapat diteruskan sebagai argumen kata kunci.

value

Nilai yang dievaluasi dari ekspresi yang diinterpolasi.

expression

Representasi string dari ekspresi sebagaimana muncul dalam template string.

conversion

Penentu konversi ('s' atau 'r') jika ada, jika tidak None. Perhatikan bahwa MicroPython tidak mendukung konversi 'a'.

format_spec

String spesifikasi format jika ada, jika tidak string kosong.

Sintaks Template String

Template string menggunakan sintaks yang sama dengan f-string tetapi dengan awalan t

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

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

Penentu Konversi

Template string menyimpan penentu konversi sebagai metadata. Tidak seperti f-string, konversi tidak diterapkan secara otomatis:

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

Kode pemrosesan harus secara eksplisit menerapkan konversi bila diperlukan.

Spesifikasi Format

Spesifikasi format disimpan sebagai metadata dalam objek Interpolation. Tidak seperti f-string, pemformatan tidak diterapkan secara otomatis:

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

Sesuai PEP 750, kode pemrosesan tidak diwajibkan menggunakan spesifikasi format, tetapi jika ada, spesifikasi tersebut harus dihormati dan perilakunya harus sesuai dengan f-string bila memungkinkan.

Format Debug

Format debug {expr=} didukung:

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

Penting

Sesuai PEP 750, tidak seperti f-string, template string tidak secara otomatis menerapkan konversi atau spesifikasi format. Ini dirancang demikian agar kode pemrosesan dapat mengontrol cara penanganannya. Kode pemrosesan harus secara eksplisit menangani atribut-atribut ini.

MicroPython tidak menyediakan fungsi bawaan format(). Gunakan metode pemformatan string seperti str.format() sebagai gantinya.

Contoh Penggunaan

Pemrosesan dasar tanpa dukungan 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)

Pemrosesan template dengan dukungan 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"

Contoh HTML escaping:

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

Lihat Juga