0Pricing
AI Prompt Engineering · Aula

Solicitando tabelas e dados estruturados

Solicite tabelas em markdown e resultados estruturados para tarefas de comparação.

Solicitando tabelas e dados estruturados é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 2 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.

Tabelas como formato de saída

As tabelas são um dos formatos de saída de IA mais úteis para informações comparativas. Elas tornam as relações entre os itens fáceis de examinar e permitem uma análise rápida lado a lado.

A chave para obter boas tabelas é especificar os nomes exatos das colunas, o que cada coluna deve conter e quantas linhas incluir.

Solicitação básica de tabela

O padrão para solicitar uma tabela em Markdown:

'Formate como uma tabela Markdown com as colunas: [Coluna1], [Coluna2], [Coluna3].'

As tabelas Markdown são renderizadas no GitHub, Notion, Obsidian e na maioria das interfaces de bate-papo de IA. Elas usam caracteres de barra vertical para separar as colunas e traços para os separadores dos cabeçalhos.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Compare Python, JavaScript, and Go for building REST APIs. '
            'Format as a markdown table with columns: '
            'Language, Performance, Learning Curve, Ecosystem, Best Use Case. '
            'One row per language. Be concise — max 8 words per cell.'
        )
    }]
)
print(response.choices[0].message.content)

Tabelas de comparação

As tabelas de comparação são ideais ao escolher entre opções. Solicite-as com:

  • 'Crie uma tabela de comparação entre X, Y e Z...'
  • 'Faça uma tabela de comparação de recursos para...'
  • 'Crie uma tabela de prós e contras comparando...'

Coloque as opções nas linhas e os critérios de avaliação nas colunas — ou o inverso, dependendo de qual disposição for mais legível para o seu conteúdo.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=400,
    messages=[{
        'role': 'user',
        'content': (
            'Create a comparison table for three cloud database options: '
            'Supabase, PlanetScale, and Neon.\n'
            'Rows: one per database.\n'
            'Columns: Free tier storage, Scaling model, Pricing at 10GB, '
            'Branching support, SQL compatibility.\n'
            'Format: markdown table. Cell content: max 6 words each.'
        )
    }]
)
print(response.content[0].text)

Tabelas de matriz de recursos

Uma matriz de recursos é uma tabela em que as linhas são itens e as colunas são recursos, com cada célula exibindo uma marca de seleção, uma pontuação ou um valor breve. Usos comuns:

  • Comparação de recursos de software entre versões ou concorrentes
  • Comparação de planos de produtos SaaS
  • Matrizes de compatibilidade tecnológica (qual navegador ou OS oferece suporte a cada recurso)

Solicite: 'Crie uma tabela de matriz de recursos com marcas de seleção (sim/não) para cada recurso.'

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Create a feature matrix table for our SaaS pricing tiers: Free, Pro, Enterprise.\n'
            'Rows: API access, Custom domains, SSO login, SLA guarantee, Priority support, '
            'Data export, Team collaboration, Audit logs.\n'
            'Columns: Free, Pro, Enterprise.\n'
            'Use: YES / NO / PARTIAL for each cell.\n'
            'Format: markdown table.'
        )
    }]
)
print(response.choices[0].message.content)

Tabelas de dados a partir de texto

Um padrão poderoso é pedir ao modelo que extraia informações de texto não estruturado e as formate como uma tabela. Isso é essencialmente uma análise de dados com tecnologia de IA:

'Extraia as informações a seguir do texto abaixo e formate-as como uma tabela com as colunas X, Y e Z.'

Especifique sempre os nomes das colunas explicitamente para obter uma estrutura consistente.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

meeting_notes = (
    'Sarah will handle the API documentation by next Friday. '
    'John needs to fix the authentication bug — aim for Wednesday. '
    'Maria is responsible for the mobile UI update, due in 2 weeks. '
    'The DevOps team (lead: Alex) must set up staging by Monday. '
    'Carlos will write unit tests — deadline: end of sprint (Thursday).'
)

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=300,
    messages=[{
        'role': 'user',
        'content': (
            'Extract all action items from the meeting notes below. '
            'Format as a markdown table with columns: Task, Owner, Deadline.\n\n'
            f'Meeting notes:\n{meeting_notes}'
        )
    }]
)
print(response.content[0].text)

Saída em CSV

Quando precisar de dados para importar para uma planilha, um banco de dados ou para processamento posterior, solicite a saída em CSV em vez de tabelas Markdown.

'Exiba linhas em CSV com uma linha de cabeçalho' ou 'Formate como CSV. Primeira linha: cabeçalhos das colunas.'

O CSV é portátil e pode ser colado diretamente no Excel ou no Google Sheets, ou analisado por código.

import openai
import csv
import io

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Generate 5 sample customer support tickets for an e-commerce store. '
            'Output as CSV with header row. '
            'Columns: ticket_id, customer_name, issue_type, priority, status. '
            'issue_type values: SHIPPING / BILLING / PRODUCT / RETURNS. '
            'priority values: LOW / MEDIUM / HIGH. '
            'status values: OPEN / IN_PROGRESS / RESOLVED. '
            'No markdown formatting — raw CSV only.'
        )
    }]
)

csv_text = response.choices[0].message.content.strip()
reader = csv.DictReader(io.StringIO(csv_text))
for row in reader:
    print(row)

Saída estruturada em JSON

Para uso programático, JSON costuma ser o melhor formato. Solicite-o explicitamente:

'Exiba como um objeto JSON com as chaves X, Y e Z.'
'Retorne uma matriz JSON em que cada elemento tenha as propriedades A, B e C.'

Alguns modelos oferecem um modo JSON nativo que garante uma saída JSON válida — mas, mesmo sem ele, uma solicitação explícita de JSON e a descrição do esquema geralmente produzem uma saída analisável.

import anthropic
import json

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=400,
    messages=[{
        'role': 'user',
        'content': (
            'Generate 3 fictional user profiles for testing a fitness app. '
            'Output as a JSON array. '
            'Each object must have exactly these keys: '
            'id (integer), name (string), age (integer 18-65), '
            'fitness_level ("BEGINNER" | "INTERMEDIATE" | "ADVANCED"), '
            'goals (array of strings, max 3), weekly_sessions (integer 1-7). '
            'Output raw JSON only — no explanation, no markdown code fences.'
        )
    }]
)

try:
    data = json.loads(response.content[0].text)
    print(f'Parsed {len(data)} profiles successfully.')
    for profile in data:
        print(f'  {profile["name"]}, {profile["age"]}, {profile["fitness_level"]}')
except json.JSONDecodeError as e:
    print('JSON parse error:', e)

Especificando regras para o conteúdo das células

A qualidade da tabela melhora significativamente quando você define o que é permitido dentro de cada célula:

  • 'No máximo 5 palavras por célula' — evita células prolixas que prejudicam a formatação da tabela
  • 'Somente Sim/Não' — matriz binária de recursos
  • 'Somente valores em dólares, sem explicação' — tabelas de preços limpas
  • 'Somente uma palavra' — brevidade obrigatória
  • 'Avaliação de 1 a 10' — tabelas de pontuação numérica
import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Rate the following programming languages for these criteria.\n'
            'Languages (rows): Python, Rust, TypeScript, Go.\n'
            'Criteria (columns): Speed, Safety, Developer Experience, Job Market, Learning Curve.\n'
            'Cell format: integer score 1-10 only. No words, no explanation inside cells.\n'
            'After the table, add one sentence explaining your scoring philosophy.'
        )
    }]
)
print(response.choices[0].message.content)

Tabelas transpostas

Às vezes, a orientação padrão de linhas e colunas não é adequada aos seus dados. Uma tabela transposta inverte linhas e colunas — útil quando você tem muitos atributos, mas poucos itens.

Solicite: 'Crie uma tabela com os itens nas colunas e os atributos nas linhas' ou 'Transponha a tabela para que X sejam as colunas.'

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=300,
    messages=[{
        'role': 'user',
        'content': (
            'Compare two job candidates: Alice and Bob. '
            'Create a transposed table where candidates are COLUMNS and attributes are ROWS. '
            'Attributes (rows): Years Experience, Primary Language, Education, '
            'Previous Employer, Salary Expectation Range. '
            'Format: markdown table. Cell content: factual, max 6 words.\n\n'
            'Alice: 7 years Python/ML, MS Computer Science MIT, ex-Google, expects $180-220k.\n'
            'Bob: 4 years JavaScript/Node, BS from UC Berkeley, ex-Stripe startup, expects $140-170k.'
        )
    }]
)
print(response.content[0].text)

Quando NÃO usar tabelas

As tabelas nem sempre são o formato adequado. Evite-as quando:

  • Você tiver apenas 2 itens — uma breve comparação em parágrafo será mais clara
  • O conteúdo das células variar muito de tamanho — as tabelas ficarão ilegíveis
  • A saída for usada em um ambiente de texto simples (corpo de e-mail, SMS)
  • Você estiver gerando conteúdo para saída de voz
  • As relações forem hierárquicas, não tabulares (use listas aninhadas)
import openai

client = openai.OpenAI(api_key='sk-your-key-here')

# Table works: structured comparison
table_prompt = (
    'Compare MySQL vs PostgreSQL. '
    'Format: markdown table, columns: Feature, MySQL, PostgreSQL. '
    '6 rows covering: JSON support, Full-text search, Replication, Transactions, License, Best for.'
)

# No table needed: simple 2-option choice with prose reasoning
not_table_prompt = (
    'Should I use SQLite or PostgreSQL for a personal hobby project '
    'that will have at most 5 users? 2-sentence answer, no table.'
)

for label, prompt in [('TABLE APPROPRIATE', table_prompt), ('TABLE OVERKILL', not_table_prompt)]:
    response = client.chat.completions.create(
        model='gpt-4o', max_tokens=200,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(f'--- {label} ---')
    print(response.choices[0].message.content.strip()[:300])
    print()

Combinando tabelas com outros formatos

As tabelas combinam bem com textos ou listas ao seu redor. Uma estrutura comum de saída de alta qualidade:

  1. Breve parágrafo introdutório explicando os critérios de comparação
  2. A tabela para uma consulta rápida
  3. Um parágrafo de recomendação com o veredito final

Solicite isso explicitamente: 'Inclua: uma introdução de 1 frase, a tabela e depois uma recomendação de 2 frases.'

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=500,
    messages=[{
        'role': 'user',
        'content': (
            'Compare three Python testing frameworks: pytest, unittest, and nose2. '
            'Structure your response as:\n'
            '1. One-sentence intro explaining the comparison scope.\n'
            '2. Markdown table: columns = Framework, Ease of Use, Plugin Ecosystem, '
            'Speed, Community Activity. Rows = one per framework.\n'
            '3. One-sentence recommendation for a team starting a new project.'
        )
    }]
)
print(response.content[0].text)

Verificação de conhecimento

Uma pessoa desenvolvedora quer gerar dados de exemplo para testes de banco de dados usando IA. Ela precisa de 10 linhas de dados de clientes com ID, nome, e-mail, país e nível da conta. Qual é o melhor formato de saída a solicitar?

Recapitulação: tabelas e dados estruturados

As solicitações de tabelas e dados estruturados desbloqueiam alguns dos formatos de saída mais úteis da IA. Principais técnicas:

  • Especifique nomes exatos das colunas para obter uma estrutura consistente
  • Use tabelas de comparação para analisar opções lado a lado
  • Use CSV quando os dados forem processados programaticamente
  • Use JSON para integração com API e consumo por código
  • Defina regras para o conteúdo das células: máximo de palavras, valores permitidos, escala de avaliação
  • Considere transpor a tabela quando houver mais itens do que atributos
  • Combine tabelas com texto para criar documentos completos e legíveis

Perguntas Frequentes

A aula “Solicitando tabelas e dados estruturados” é grátis?

Sim — o texto completo de “Solicitando tabelas e dados estruturados” é 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 “Solicitando tabelas e dados estruturados”?

Solicite tabelas em markdown e resultados estruturados para tarefas de comparação. 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 2 de 4.

Quanto tempo leva a aula “Solicitando tabelas e dados estruturados”?

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

  1. Solicitando listas e tópicos
  2. Solicitando tabelas e dados estruturados
  3. Formatação markdown nas solicitações
  4. Texto simples versus resultado formatado
← Voltar para AI Prompt Engineering