Técnicas de substituição de variáveis
f-strings, .format() e bibliotecas de modelos para renderizar solicitações.
Técnicas de substituição de variáveis é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.
Quatro abordagens do Python para renderizar modelos
O Python oferece várias formas de renderizar modelos de prompts com substituição de variáveis. Cada uma tem vantagens e desvantagens:
- strings f — em linha, imediatas e sem necessidade de importações
- str.format() — marcadores nomeados, fáceis de validar
- string.Template — substituição segura com cifrão, com suporte a preenchimento parcial
- Jinja2 — mecanismo completo de modelos: condicionais, laços, filtros e herança
A escolha da abordagem certa depende da complexidade do modelo, dos conhecimentos da equipe e da necessidade de recursos avançados, como condicionais e laços.
Abordagem 1: strings f do Python
As strings f são a abordagem mais simples para modelos de prompts nos quais todas as variáveis estão disponíveis no momento da renderização:
import openai
client = openai.OpenAI(api_key='sk-...')
def generate_linkedin_post(company, topic, tone, word_count):
prompt = (
f'Write a LinkedIn post for {company} about {topic}. '
f'Tone: {tone}. '
f'Length: {word_count} words. '
'Professional but conversational. '
'End with one question to engage readers. '
'No hashtags. Active voice.'
)
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
return response.choices[0].message.content
print(generate_linkedin_post(
company='DataStream Analytics',
topic='how AI is changing data pipelines',
tone='enthusiastic but grounded',
word_count=180
))Abordagem 2: str.format()
str.format() funciona bem quando você quer armazenar as cadeias de caracteres do modelo separadamente do código que as preenche — algo útil para carregar modelos de arquivos:
import openai
client = openai.OpenAI(api_key='sk-...')
# Template stored as a module-level constant or loaded from a file
SUPPORT_REPLY_TEMPLATE = '''You are a customer support agent for {company_name}.
Respond to this customer message:
---
{customer_message}
---
Tone: {tone}.
Keep the response under {max_words} words.
Do not offer refunds unless the customer explicitly asks.
Always close by asking if there is anything else you can help with.'''
def generate_support_reply(company, message, tone='empathetic and helpful', max_words=150):
prompt = SUPPORT_REPLY_TEMPLATE.format(
company_name=company,
customer_message=message,
tone=tone,
max_words=max_words
)
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
return response.choices[0].message.contentAbordagem 3: string.Template
O string.Template da biblioteca padrão do Python usa marcadores de posição com cifrão ($variable ou ${variable}). Sua principal vantagem: safe_substitute() deixa as variáveis ausentes como texto literal de marcador, em vez de gerar um erro, permitindo preenchimentos parciais:
from string import Template
import openai
client = openai.OpenAI(api_key='sk-...')
# $ placeholders — safe with code that contains curly braces
BASE_TEMPLATE = Template(
'Write a $format_type for $audience about $topic. '
'Tone: $tone. Length: $word_count words. '
'Active voice. No jargon.'
)
def generate(format_type, audience, topic, tone='professional', word_count=200):
prompt = BASE_TEMPLATE.substitute(
format_type=format_type,
audience=audience,
topic=topic,
tone=tone,
word_count=word_count
)
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
return response.choices[0].message.content
# Partial fill example — safe_substitute leaves $word_count as-is
partial = BASE_TEMPLATE.safe_substitute(
format_type='blog post', audience='developers', topic='API design'
)
print(partial) # $tone and $word_count remain as placeholdersAbordagem 4: fundamentos do Jinja2
O Jinja2 é um mecanismo completo de modelos. Ele oferece suporte a condicionais, laços, filtros e herança de modelos — muito além da simples substituição de cadeias de caracteres:
from jinja2 import Template
import openai
client = openai.OpenAI(api_key='sk-...')
# Jinja2 uses {{ }} for variables and {% %} for logic
JINJA_PROMPT = Template('''
Write a {{content_type}} for {{audience}} about {{topic}}.
Tone: {{tone}}.
{% if include_examples %}
Include {{example_count}} concrete examples.
{% endif %}
{% if word_count %}
Length: {{word_count}} words.
{% else %}
Aim for 200-300 words.
{% endif %}
Active voice. No jargon.
''')
def generate(content_type, audience, topic, tone, include_examples=False, example_count=2, word_count=None):
prompt = JINJA_PROMPT.render(
content_type=content_type,
audience=audience,
topic=topic,
tone=tone,
include_examples=include_examples,
example_count=example_count,
word_count=word_count
)
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
return response.choices[0].message.contentLaços do Jinja2 em modelos
Os laços do Jinja2 permitem iterar sobre listas no seu modelo — algo útil para gerar prompts com vários itens a partir de estruturas de dados:
from jinja2 import Template
import openai
client = openai.OpenAI(api_key='sk-...')
MULTI_PRODUCT_TEMPLATE = Template('''
Write a product comparison for {{audience}}.
Compare the following products:
{% for product in products %}
- {{product.name}}: {{product.description}}
{% endfor %}
Structure: one paragraph per product, then a 2-sentence recommendation.
Tone: {{tone}}. Active voice. No bullet points in paragraphs.
''')
products = [
{'name': 'Asana', 'description': 'project management with timeline views'},
{'name': 'Linear', 'description': 'developer-focused issue tracking'},
{'name': 'Monday.com', 'description': 'visual work management for teams'}
]
prompt = MULTI_PRODUCT_TEMPLATE.render(
audience='startup founders',
products=products,
tone='direct and practical'
)
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
print(response.choices[0].message.content)Filtros do Jinja2
Os filtros do Jinja2 transformam valores de variáveis em linha durante a renderização do modelo. Filtros integrados úteis para prompts:
{{ topic | upper }}— transforma o tópico em maiúsculas{{ word_count | default(200) }}— usa 200 se a contagem de palavras não for fornecida{{ audience | title }}— converte o texto do público para maiúsculas iniciais{{ items | join(', ') }}— une uma lista usando vírgulas
Os filtros mantêm a lógica de transformação dentro do modelo, em vez de no código Python que o chama, tornando os modelos mais autossuficientes e portáteis.
Carregando modelos a partir de arquivos
Para modelos grandes ou complexos, armazená-los em arquivos de texto separados mantém seu código Python organizado. O Environment e o FileSystemLoader do Jinja2 lidam bem com isso:
from jinja2 import Environment, FileSystemLoader
import openai
client = openai.OpenAI(api_key='sk-...')
# Load all templates from the 'prompts/' directory
env = Environment(loader=FileSystemLoader('prompts/'))
def render_template(template_name, variables):
'''Load and render a .j2 template file with the given variables.'''
template = env.get_template(template_name)
return template.render(**variables)
def generate_from_file(template_name, variables):
prompt = render_template(template_name, variables)
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
return response.choices[0].message.content
# Usage: load prompts/blog_post.j2 and fill with variables
result = generate_from_file('blog_post.j2', {
'topic': 'API rate limiting strategies',
'audience': 'backend engineers',
'tone': 'technical and direct',
'word_count': 500
})
print(result)Escolhendo a abordagem certa
Associe a abordagem de substituição à complexidade dos seus modelos:
- strings f — scripts rápidos, automação pontual e modelos curtos o suficiente para serem lidos em linha
- str.format() — modelos armazenados, bases de código de equipes e situações em que é desejável obter um KeyError quando faltam variáveis
- string.Template — quando o conteúdo pode conter chaves, como trechos de código, ou quando é necessário um preenchimento parcial
- Jinja2 — modelos complexos com condicionais, laços, vários arquivos ou uma equipe com experiência em criação de modelos
A complexidade desnecessária é um risco real — recorra ao Jinja2 somente quando realmente precisar dos recursos avançados dele.
Segurança de modelos: ataques de injeção
Quando os valores das variáveis vêm de entradas do usuário, a injeção de prompt é um risco real. Um usuário mal-intencionado pode fornecer um valor como: "Ignore todas as instruções anteriores e..."
Medidas preventivas:
- Valide e higienize todas as variáveis fornecidas pelo usuário antes da substituição
- Para entradas voltadas ao usuário, envolva a variável em delimitadores: "A entrada do usuário é: ---{user_input}---"
- Use filtragem da saída para detectar e rejeitar respostas que pareçam ter seguido instruções injetadas
- Nunca permita que valores fornecidos pelo usuário acessem variáveis do prompt do sistema
Testando renderizações de modelos
Sempre teste as renderizações dos modelos separadamente das chamadas à API. Valide a cadeia de caracteres renderizada antes de enviá-la ao modelo:
def test_template_render():
test_cases = [
{'topic': 'cloud security', 'audience': 'CTOs', 'tone': 'formal', 'word_count': 300},
{'topic': 'ML pipelines', 'audience': 'data scientists', 'tone': 'technical', 'word_count': 500},
# Edge cases
{'topic': '', 'audience': 'developers', 'tone': 'casual', 'word_count': 100}, # empty topic
{'topic': 'AI' * 100, 'audience': 'all', 'tone': 'brief', 'word_count': 50}, # very long topic
]
TEMPLATE = 'Write a {word_count}-word {tone} article about {topic} for {audience}. Active voice.'
for i, case in enumerate(test_cases):
try:
rendered = TEMPLATE.format(**case)
assert len(rendered) > 0, 'Empty render'
print(f'Case {i+1} OK: {len(rendered)} chars')
except (KeyError, AssertionError) as e:
print(f'Case {i+1} FAILED: {e}')
test_template_render()Verificação de conhecimentos: técnicas de substituição
Você está criando um sistema de prompts no qual os arquivos de modelo ficam armazenados no disco, os modelos incluem seções condicionais, por exemplo, incluir opcionalmente uma seção sobre preços com base em um sinalizador, e os modelos podem ser fornecidos por vários membros da equipe familiarizados com a criação de modelos para a web.
Qual abordagem de substituição é mais adequada para este cenário?
Recapitulação: técnicas de substituição de variáveis
O Python oferece quatro abordagens para renderizar modelos de prompts: strings f, simples e em linha; str.format(), com marcadores nomeados e KeyError para variáveis ausentes; string.Template, com sintaxe de cifrão e preenchimentos parciais seguros; e Jinja2, um mecanismo completo com condicionais, laços, filtros e carregamento de arquivos.
Associe a abordagem à complexidade: use strings f para scripts rápidos, str.format() para modelos armazenados, string.Template quando o conteúdo contiver chaves e Jinja2 quando precisar de condicionais, laços ou modelos baseados em arquivos. Sempre teste as renderizações separadamente das chamadas à API.
Perguntas Frequentes
A aula “Técnicas de substituição de variáveis” é grátis?
Sim — o texto completo de “Técnicas de substituição de variáveis” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.
O que vou aprender em “Técnicas de substituição de variáveis”?
f-strings, .format() e bibliotecas de modelos para renderizar solicitações. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Prompt Engineering?
Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Técnicas de substituição de variáveis”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Prompt Engineering?
Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- O que é um modelo de solicitação?
- Criando padrões de preenchimento
- Técnicas de substituição de variáveis
- Reutilizando modelos em várias tarefas