string.templatelib — Şablon Dizgesi Desteği

Bu modül, PEP 750 tarafından tanımlandığı şekliyle şablon dizgeleri (t-string’ler) için destek sağlar. Şablon dizgeleri t öneki kullanılarak oluşturulur ve hem değişmez dizge parçalarına hem de birleştirilmeden önce ara değer atanan değerlere erişim sağlar.

Kullanılabilirlik: Şablon dizgeleri STM32 tabanlı OpenMV Cam’lerde desteklenmez. Yalnızca Alif ve i.MX RT tabanlı OpenMV Cam’lerde kullanılabilir.

Sınıflar

class string.templatelib.Template(*args)

Bir şablon dizgesini temsil eder. Template nesneleri genellikle t-string sözdizimiyle (t"...") oluşturulur, ancak doğrudan yapıcı kullanılarak da oluşturulabilir.

strings

Ara değerler arasında görünen dizge değişmezlerinin bir demeti.

interpolations

Ara değer atanan ifadeleri temsil eden Interpolation nesnelerinden oluşan bir demet.

values

Şablondaki her ara değer atamasından value özniteliğini içeren bir demet döndüren salt okunur bir özellik.

__iter__() → Iterator

Şablon içeriği üzerinde yinelenir; dizge parçalarını ve Interpolation nesnelerini göründükleri sırayla verir. Boş dizgeler atlanır.

__add__(other: Template) → Template

İki şablonu birleştirir. Her iki şablondan gelen dizgeleri ve ara değer atamalarını birleştiren yeni bir Template döndürür.

Harekete geçirir:

TypeError – other bir Template değilse

Dizgenin bir değişmez mi yoksa bir ara değer atama mı olarak ele alınması gerektiği konusundaki belirsizliği önlemek için str ile şablon birleştirmesi yasaktır:

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

Bir şablon dizgesi içindeki ara değer atanan bir ifadeyi temsil eder. Tüm argümanlar anahtar sözcük argümanları olarak geçirilebilir.

value

Ara değer atanan ifadenin değerlendirilmiş değeri.

expression

İfadenin, şablon dizgesinde göründüğü haliyle dizge gösterimi.

conversion

Varsa dönüştürme belirteci ('s' veya 'r'), aksi takdirde None. MicroPython’un 'a' dönüştürmesini desteklemediğini unutmayın.

format_spec

Varsa biçim belirtim dizgesi, aksi takdirde boş bir dizge.

Şablon Dizgesi Sözdizimi

Şablon dizgeleri, f-string’lerle aynı sözdizimini kullanır ancak t önekiyle:

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

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

Dönüştürme Belirteçleri

Şablon dizgeleri dönüştürme belirteçlerini meta veri olarak saklar. f-string’lerin aksine, dönüştürme otomatik olarak uygulanmaz:

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

İşleyen kod, gerektiğinde dönüştürmeleri açıkça uygulamalıdır.

Biçim Belirtimleri

Biçim belirtimleri Interpolation nesnesinde meta veri olarak saklanır. f-string’lerin aksine, biçimlendirme otomatik olarak uygulanmaz:

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

PEP 750’ye göre, işleyen kodun biçim belirtimlerini kullanması zorunlu değildir, ancak mevcut olduklarında bunlara uyulmalı ve mümkün olduğunca f-string davranışıyla eşleşmelidir.

Hata Ayıklama Biçimi

{expr=} hata ayıklama biçimi desteklenir:

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

Önemli

PEP 750’ye göre, f-string’lerin aksine, şablon dizgeleri dönüştürmeleri veya biçim belirtimlerini otomatik olarak uygulamaz. Bu, işleyen kodun bunların nasıl ele alınacağını kontrol etmesine olanak tanımak için tasarımdan kaynaklanır. İşleyen kod, bu öznitelikleri açıkça ele almalıdır.

MicroPython format() yerleşik işlevini sağlamaz. Bunun yerine str.format() gibi dizge biçimlendirme yöntemlerini kullanın.

Örnek Kullanım

Biçim desteği olmadan temel işleme:

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)

Biçim desteğiyle şablon işleme:

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 kaçış (escaping) örneği:

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

Ayrıca Bakınız