0Pricing
AI Prompt Engineering · Lección

Solicitar tablas y datos estructurados

Solicite tablas Markdown y resultados estructurados para tareas de comparación.

Solicitar tablas y datos estructurados es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.

Las tablas como formato de salida

Las tablas son uno de los formatos de salida de IA más útiles para la información comparativa. Facilitan la consulta rápida de las relaciones entre elementos y permiten analizarlos rápidamente unos junto a otros.

La clave para obtener buenas tablas es especificar los nombres exactos de las columnas, qué debe contener cada columna y cuántas filas se deben incluir.

Solicitud básica de una tabla

El patrón estándar para solicitar una tabla de Markdown:

'Dé formato de tabla de Markdown con las columnas: [Column1], [Column2], [Column3].'

Las tablas de Markdown se representan en GitHub, Notion, Obsidian y la mayoría de las interfaces de chat de IA. Utilizan caracteres de barra vertical para separar las columnas y guiones para los separadores de encabezado.

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)

Tablas comparativas

Las tablas comparativas son ideales cuando debe elegir entre varias opciones. Solicítelas así:

  • 'Cree una tabla comparativa de X frente a Y frente a Z...'
  • 'Haga una tabla comparativa de características para...'
  • 'Cree una tabla de ventajas y desventajas que compare...'

Coloque las opciones como filas y los criterios de evaluación como columnas, o al revés, según qué disposición resulte más legible para su contenido.

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)

Tablas de matriz de características

Una matriz de características es una tabla en la que las filas son elementos y las columnas son características, y cada celda muestra una marca de verificación, una puntuación o un valor breve. Usos habituales:

  • Comparación de características de software entre versiones o competidores
  • Comparación de planes de productos SaaS
  • Matrices de compatibilidad tecnológica (qué navegador o sistema operativo admite cada elemento)

Solicite: 'Cree una tabla de matriz de características con marcas de verificación (sí/no) para cada característica.'

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)

Tablas de datos a partir de texto

Un patrón muy útil consiste en pedir al modelo que extraiga información de texto no estructurado y la presente en forma de tabla. En esencia, se trata de análisis de datos asistido por IA:

'Extraiga del texto siguiente la información indicada y preséntela en una tabla con las columnas X, Y, Z.'

Especifique siempre los nombres de las columnas de forma explícita para obtener una estructura coherente.

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)

Salida CSV

Cuando necesite datos para importarlos a una hoja de cálculo, una base de datos o para procesarlos posteriormente, solicite una salida CSV (valores separados por comas) en lugar de tablas de Markdown.

'Devuélvalo como filas CSV con una fila de encabezado' o 'Dé formato CSV. Primera línea: encabezados de columna.'

CSV es portátil y puede pegarse directamente en Excel o Google Sheets, o analizarse mediante 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)

Salida estructurada en JSON

Para uso programático, JSON suele ser el mejor formato. Solicítelo explícitamente:

'Devuélvalo como un objeto JSON con las claves X, Y, Z.'
'Devuelva un array JSON en el que cada elemento tenga las propiedades A, B, C.'

Algunos modelos admiten un modo JSON nativo que garantiza una salida JSON válida, pero incluso sin él, una solicitud explícita de JSON y la descripción del esquema suelen producir una salida que se puede analizar.

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)

Especificar reglas para el contenido de las celdas

La calidad de una tabla mejora significativamente cuando define qué se permite dentro de cada celda:

  • 'Máximo 5 palabras por celda' — evita celdas demasiado extensas que rompan el formato de la tabla
  • 'Solo Sí/No' — matriz de características binaria
  • 'Solo el importe en dólares, sin explicación' — tablas de precios limpias
  • 'Solo una palabra' — concisión obligatoria
  • 'Puntuación de 1 a 10' — tablas de puntuación 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)

Tablas transpuestas

A veces, la orientación predeterminada de filas y columnas no es adecuada para sus datos. Una tabla transpuesta intercambia las filas y las columnas, lo que resulta útil cuando tiene muchos atributos, pero pocos elementos.

Solicite: 'Cree una tabla con los elementos como columnas y los atributos como filas' o 'Transponga la tabla para que X sean las columnas.'

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)

Cuándo NO utilizar tablas

Las tablas no siempre son el formato adecuado. Evítelas cuando:

  • Solo tenga 2 elementos: una breve comparación en un párrafo se lee mejor
  • El contenido de las celdas varíe mucho en longitud: las tablas se vuelven ilegibles
  • La salida se vaya a utilizar en un entorno de texto sin formato (cuerpo de un correo electrónico, SMS)
  • Esté generando contenido para una salida de voz
  • Las relaciones sean jerárquicas, no tabulares (utilice listas anidadas)
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()

Combinar tablas con otros formatos

Las tablas combinan bien con texto o listas a su alrededor. Una estructura habitual de salida de alta calidad es:

  1. Un breve párrafo introductorio que explique los criterios de comparación
  2. La tabla para una consulta rápida
  3. Un párrafo de recomendación con el veredicto final

Solicítelo explícitamente: 'Incluya: una introducción de 1 oración, la tabla y después una recomendación de 2 oraciones.'

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)

Comprobación de conocimientos

Un desarrollador quiere generar datos de ejemplo para probar una base de datos mediante IA. Necesita 10 filas de datos de clientes con ID, nombre, correo electrónico, país y nivel de cuenta. ¿Cuál es el mejor formato de salida que debe solicitar?

Tablas y datos estructurados: resumen

Las solicitudes de tablas y datos estructurados permiten aprovechar algunos de los formatos de salida más útiles de la IA. Técnicas clave:

  • Especifique los nombres exactos de las columnas para obtener una estructura coherente
  • Utilice tablas comparativas para analizar opciones una junto a otra
  • Utilice CSV cuando los datos se vayan a procesar mediante programación
  • Utilice JSON para la integración con API y el consumo desde código
  • Defina reglas para el contenido de las celdas: máximo de palabras, valores permitidos, escala de puntuación
  • Considere transponer la tabla cuando haya más elementos que atributos
  • Combine las tablas con texto para crear documentos completos y fáciles de leer

Preguntas frecuentes

¿La lección «Solicitar tablas y datos estructurados» es gratis?

Sí — el texto completo de «Solicitar tablas y datos estructurados» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.

¿Qué aprenderé en «Solicitar tablas y datos estructurados»?

Solicite tablas Markdown y resultados estructurados para tareas de comparación. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Prompt Engineering?

No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Solicitar tablas y datos estructurados»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?

Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Solicitar listas y viñetas
  2. Solicitar tablas y datos estructurados
  3. Formato Markdown en prompts
  4. Texto sin formato frente a resultados con formato
← Volver a AI Prompt Engineering