import timeit

# 測試10萬次插值操作
tests = {
    "%格式化": '"Name: %s" % name',
    "str.format": '"Name: {}".format(name)',
    "f-string": 'f"Name: {name}"',
    "Template": 'Template("Name: $name").substitute(name=name)'
}

results = {}
for name, code in tests.items():
    time = timeit.timeit(
        code,
        setup="name='Alice'",
        number=100000
    )
    results[name] = time

print("10萬次操作耗時:")
for method, time in sorted(results.items(), key=lambda x: x[1]):
    print(f"{method}: {time:.4f}秒")

# 數(shù)學(xué)運算
x = 10
print(f"Result: {x * 2 + 5}")  # "Result: 25"

# 函數(shù)調(diào)用
def get_temperature():
    return 22.5

print(f"Temp: {get_temperature()}°C")  # "Temp: 22.5°C"

# 條件表達式
score = 85
print(f"Grade: {'Pass' if score >= 60 else 'Fail'}")  # "Grade: Pass"

# 數(shù)字格式化
price = 99.99
print(f"Price: ${price:.2f}")  # "Price: $99.99"

# 日期格式化
from datetime import datetime
now = datetime.now()
print(f"Date: {now:%Y-%m-%d %H:%M:%S}")  # "Date: 2024-05-01 14:30:22"

# 對齊與填充
text = "Python"
print(f"|{text:^10}|")   # "|  Python  |"
print(f"|{text:*<10}|")  # "|Python****|"

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

user = User("Alice", 30)
data = {"product": "Laptop", "price": 1200}

# 對象屬性訪問
print(f"User: {user.name}, Age: {user.age}")

# 字典鍵值訪問
print(f"Product: {data['product']}, Price: ${data['price']}")

# 復(fù)雜嵌套
print(f"User: {user.name}, Product: {data['product']}")

import sqlite3
from string import Template

def safe_sql_query(user_id):
    """安全SQL查詢"""
    # 不安全做法
    # query = f"SELECT * FROM users WHERE id = {user_id}"
    
    # 安全做法1：參數(shù)化查詢
    query = "SELECT * FROM users WHERE id = ?"
    conn = sqlite3.connect("app.db")
    cursor = conn.cursor()
    cursor.execute(query, (user_id,))
    
    # 安全做法2：模板限制
    safe_template = Template("SELECT * FROM users WHERE id = $user_id")
    query = safe_template.substitute(user_id=user_id)
    # 但需要額外驗證user_id
    
    return cursor.fetchall()

from html import escape

def render_user_profile(user):
    """安全渲染用戶資料"""
    # 危險做法
    # return f"<div>{user.bio}</div>"
    
    # 安全做法：轉(zhuǎn)義特殊字符
    safe_bio = escape(user.bio)
    return f"<div>{safe_bio}</div>"

# 高級安全模板
class SafeTemplate:
    def __init__(self, template):
        self.template = template
    
    def render(self, **context):
        # 自動轉(zhuǎn)義所有值
        safe_context = {k: escape(v) if isinstance(v, str) else v 
                       for k, v in context.items()}
        return self.template.format(**safe_context)

# 使用
template = SafeTemplate("<div>{bio}</div>")
print(template.render(bio="<script>alert('xss')</script>"))
# <div>&lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;</div>

import re

class MiniTemplateEngine:
    """簡易模板引擎"""
    def __init__(self, template):
        self.template = template
        self.pattern = re.compile(r'\{\{\s*(.*?)\s*\}\}')
    
    def render(self, **context):
        def replace(match):
            expr = match.group(1)
            # 安全沙箱執(zhí)行
            try:
                return str(eval(expr, {}, context))
            except Exception as e:
                return f"ERROR: {str(e)}"
        
        return self.pattern.sub(replace, self.template)

# 使用示例
template = """
Hello {{ name }}!
Your account balance: ${{ balance:.2f }}
Last login: {{ last_login.strftime('%Y-%m-%d') }}
"""

engine = MiniTemplateEngine(template)
output = engine.render(
    name="Alice",
    balance=99.99,
    last_login=datetime.now()
)
print(output)

class AdvancedTemplateEngine:
    """支持控制結(jié)構(gòu)的模板引擎"""
    def __init__(self, template):
        self.template = template
        self.blocks = self._parse_blocks()
    
    def _parse_blocks(self):
        # 解析條件塊
        pattern = re.compile(
            r'\{%\s*if\s+(.*?)\s*%}(.*?)\{%\s*endif\s*%\}',
            re.DOTALL
        )
        return pattern.findall(self.template)
    
    def render(self, **context):
        result = self.template
        for condition, content in self.blocks:
            # 評估條件
            try:
                condition_met = eval(condition, {}, context)
            except:
                condition_met = False
            
            # 替換內(nèi)容
            if condition_met:
                result = result.replace(
                    f"{{% if {condition} %}}{content}{{% endif %}}",
                    content
                )
            else:
                result = result.replace(
                    f"{{% if {condition} %}}{content}{{% endif %}}",
                    ""
                )
        
        # 處理變量插值
        var_pattern = re.compile(r'\{\{\s*(.*?)\s*\}\}')
        return var_pattern.sub(
            lambda m: str(eval(m.group(1), {}, context)),
            result
        )

# 使用示例
template = """
Welcome {{ user.name }}!
{% if user.is_vip %}
  VIP Status: Active (Expires: {{ user.vip_expiry }})
{% endif %}
"""

engine = AdvancedTemplateEngine(template)
output = engine.render(user={
    "name": "Alice",
    "is_vip": True,
    "vip_expiry": "2024-12-31"
})
print(output)

import gettext
from string import Template

# 設(shè)置語言環(huán)境
zh_translation = gettext.translation(
    'messages', 
    localedir='locales', 
    languages=['zh_CN']
)
zh_translation.install()

# 使用模板插值
template = Template(_("Welcome, $user_name! Your balance is $balance."))

# 渲染不同語言
def render_welcome(user_name, balance, lang='en'):
    if lang == 'zh':
        zh_translation.install()
    else:
        gettext.NullTranslations().install()
    
    return template.substitute(
        user_name=user_name,
        balance=balance
    )

# 測試
print(render_welcome("Alice", 99.99, 'en'))
print(render_welcome("張三", 99.99, 'zh'))

import locale
from babel.numbers import format_currency

def localized_report(user, amount):
    """本地化財務(wù)報告"""
    # 設(shè)置地區(qū)
    locale.setlocale(locale.LC_ALL, user.locale)
    
    # 本地化貨幣格式
    formatted_amount = format_currency(amount, user.currency, locale=user.locale)
    
    # 本地化日期
    today = datetime.now().strftime("%x")
    
    return f"""
    {_('Report for')}: {user.name}
    {_('Date')}: {today}
    {_('Amount')}: {formatted_amount}
    """

# 使用
class User:
    def __init__(self, name, locale, currency):
        self.name = name
        self.locale = locale
        self.currency = currency

user_en = User("Alice", "en_US", "USD")
user_zh = User("張三", "zh_CN", "CNY")

print(localized_report(user_en, 99.99))
print(localized_report(user_zh, 99.99))

class CompiledTemplate:
    """預(yù)編譯模板引擎"""
    def __init__(self, template):
        self.template = template
        self.compiled = self._compile_template()
    
    def _compile_template(self):
        # 解析變量位置
        var_positions = []
        pattern = re.compile(r'\{\{(\w+)\}\}')
        pos = 0
        
        parts = []
        for match in pattern.finditer(self.template):
            # 添加前段文本
            parts.append(self.template[pos:match.start()])
            # 添加變量占位
            var_name = match.group(1)
            parts.append(f"{{{var_name}}}")
            pos = match.end()
        
        # 添加剩余文本
        parts.append(self.template[pos:])
        
        # 創(chuàng)建格式化字符串
        format_string = "".join(parts)
        return lambda **kwargs: format_string.format(**kwargs)
    
    def render(self, **context):
        return self.compiled(**context)

# 使用
template = CompiledTemplate("Hello {{name}}! Your ID is {{id}}.")
print(template.render(name="Alice", id=1001))
# "Hello Alice! Your ID is 1001."

def stream_template_processing(template_path, output_path, context, chunk_size=4096):
    """大模板文件流式處理"""
    with open(template_path, 'r') as fin:
        with open(output_path, 'w') as fout:
            buffer = ""
            while True:
                chunk = fin.read(chunk_size)
                if not chunk and not buffer:
                    break
                
                buffer += chunk
                
                # 處理完整插值塊
                while True:
                    start = buffer.find("{{")
                    if start == -1:
                        # 無插值塊，直接寫入
                        fout.write(buffer)
                        buffer = ""
                        break
                    
                    end = buffer.find("}}", start)
                    if end == -1:
                        # 不完整插值塊，保留在緩沖區(qū)
                        break
                    
                    # 寫入前段內(nèi)容
                    fout.write(buffer[:start])
                    
                    # 提取變量名
                    var_name = buffer[start+2:end].strip()
                    
                    # 獲取變量值
                    value = context.get(var_name, f"{{{{{var_name}}}}}")
                    fout.write(str(value))
                    
                    # 更新緩沖區(qū)
                    buffer = buffer[end+2:]

# 循環(huán)內(nèi)避免重復(fù)解析模板
template = CompiledTemplate("Name: {name}")
for user in users:
    print(template.render(name=user.name))

# 使用gettext標記可翻譯字符串
_("Welcome, {name}").format(name=user.name)

try:
    result = f"Value: {data['missing_key']}"
except KeyError:
    result = "Value not available"

# 分離模板與代碼
with open("template.txt") as f:
    template = f.read()
result = template.format(name="Alice")

import unittest

class TestTemplates(unittest.TestCase):
    def test_welcome_template(self):
        result = render_welcome_template("Alice")
        self.assertIn("Alice", result)
        self.assertNotIn("{{name}}", result)
    
    def test_safe_render(self):
        result = safe_render("<script>alert()</script>")
        self.assertNotIn("<script>", result)