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#