Trabajar con JSON y Pandas DataFrame es común en análisis de datos, informes y tuberías ETL. Mientras que Pandas proporciona readjson para un análisis básico, puede tener dificultades con estructuras profundamente anidadas, archivos muy grandes o flujos de trabajo que priorizan Excel. Aquí es donde Aspose.Cells for Python ayuda. Proporciona un rico flujo de trabajo de JSON a Excel, que puedes integrar fácilmente con Pandas para obtener DataFrames limpios para análisis. En esta publicación del blog, aprenderás cómo convertir JSON a dataframes de Pandas en Python.

Biblioteca de Python para convertir JSON a DataFrame de Pandas

Aspose.Cells for Python via .NET es una potente API de hojas de cálculo que no requiere Microsoft Excel. Más allá de la automatización clásica de Excel, admite la importación y exportación directa de JSON, lo que la hace ideal cuando deseas convertir JSON en un DataFrame de Pandas y luego guardarlo o procesarlo en Excel.

Con Aspose.Cells, puedes:

  • Importar JSON en hojas de trabajo utilizando JsonUtility, con opciones para manejar arreglos y estructuras anidadas.
  • Convierte los rangos de las hojas de trabajo en DataFrames de Pandas para análisis y visualización.
  • Cree, cargue y maneje JSON dentro de archivos de Excel, que se ajuste a las tuberías de análisis.
  • Exportar DataFrames de vuelta a Excel (XLSX, CSV, ODS, PDF) para informes.

En resumen, la biblioteca facilita el movimiento de datos de JSON a Excel para informes, mientras que utilizas Pandas para un análisis más profundo. El JsonUtility importa JSON en una hoja de cálculo, y JsonLayoutOptions controla cómo se expanden las matrices y los objetos anidados.

Convertir JSON a DataFrame

Aspose.Cells importa JSON directamente en una hoja de cálculo. Luego lees la fila de encabezado y las filas de datos para construir un DataFrame de Pandas.

Sigue los pasos a continuación para convertir JSON a un DataFrame de pandas:

  1. Crea un libro de trabajo y obtén la primera hoja de cálculo.
  2. Configura JsonLayoutOptions para tratar los arreglos como tablas.
  3. Importar la cadena JSON en la fila 0, columna 0.
  4. Utilice la primera fila como encabezados de columna.
  5. Extraer las filas restantes como datos.
  6. Construya un DataFrame de Pandas.

El siguiente ejemplo de código muestra cómo convertir JSON a un DataFrame de pandas en Python:

import pandas as pd
import aspose.cells as ac

# Crea un nuevo libro de trabajo y obtén la primera hoja de trabajo (índice basado en 0)
wb = ac.Workbook()
ws = wb.worksheets.get(0)

# Configurar cómo se debe organizar JSON en la hoja de cálculo.
options = ac.utility.JsonLayoutOptions()
options.array_as_table = True           # Treat a top-level JSON array as a table (rows/columns)

# Ejemplo de arreglo JSON de objetos simples
json_data = '[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]'

# Importar JSON en la hoja de cálculo empezando en fila=0, col=0 (celda A1)
ac.utility.JsonUtility.import_data(json_data, ws.cells, 0, 0, options)

# Ubique la primera fila que contiene datos (esta será nuestra fila de encabezado)
header_idx = ws.cells.min_data_row

# Extraer los valores del encabezado de esa fila para usarlos como nombres de columnas del DataFrame.
columns = [cell.value for cell in ws.cells.rows[header_idx]]

# Extraer todas las filas siguientes como datos (saltar la fila del encabezado)
data = [
    [cell.value for cell in row]
   for idx, row in enumerate(ws.cells.rows)
    if row and idx != header_idx
]

# Construya el DataFrame utilizando los encabezados y filas recopilados.
df = pd.DataFrame(data, columns=columns)

# Display the result
print(df)

Output

    id   name
0  1.0  Alice
1  2.0    Bob

Convertir JSON anidado a DataFrame de Pandas

Si su JSON contiene objetos anidados, Aspose.Cells importa JSON en una hoja de cálculo utilizando JsonUtility, que luego puede exportar a un DataFrame. Las JsonLayoutOptions controlan cómo se expanden las matrices y los objetos anidados.

Siga los pasos a continuación para convertir JSON anidado a un DataFrame de pandas:

  1. Crear un libro de trabajo y seleccionar la primera hoja de cálculo.
  2. Establezca las propiedades requeridas de JsonLayoutOptions tales como arrayastable=True, ignorearraytitle=True, ignoreobjecttitle=True y keptschema=True.
  3. Importa el JSON anidado en la fila 0, columna 0.
  4. Detectar el rango utilizado y leer la fila de encabezado a lo largo de todo el alcance.
  5. Leer todas las filas subsiguientes a través de la misma extensión (ancho fijo).
  6. Construya el DataFrame; opcionalmente cambie los tipos de datos (p. ej., total a numérico).

El siguiente ejemplo de código muestra cómo convertir JSON anidado a un DataFrame de pandas en Python:

import pandas as pd
import aspose.cells as ac

# Crear libro de trabajo y obtener la primera hoja de trabajo
wb = ac.Workbook()
ws = wb.worksheets.get(0)

# Opciones de diseño para JSON anidado
opt = ac.utility.JsonLayoutOptions()
opt.array_as_table = True  # Treat 'orders' array as a table (rows)
opt.ignore_array_title = True  # Do not place a title row for the 'orders' array
opt.ignore_object_title = True  # Do not place extra title rows for nested objects (e.g., 'buyer')
opt.kept_schema = True  # Keep a stable set of columns even if some records miss fields

# Paso 3: Tu JSON anidado
nested = '''
{
  "batch": "A1",
  "orders": [
    {"orderId": "1001", "total": "49.90", "buyer": {"city": "NYC", "zip": "10001"}},
    {"orderId": "1002", "total": "79.00", "buyer": {"city": "Boston", "zip": "02108"}}
  ]
}
'''

# Importar en A1 (fila=0, col=0) utilizando las opciones anteriores
ac.utility.JsonUtility.import_data(nested, ws.cells, 0, 0, opt)

# Detect used range
first_row = ws.cells.min_data_row
first_col = ws.cells.min_data_column
last_row = ws.cells.max_data_row
last_col = ws.cells.max_data_column

# Leer la fila del encabezado a lo largo de todo el ancho de columna utilizado (ancho fijo)
raw_columns = [ws.cells.get(first_row, c).value for c in range(first_col, last_col + 1)]

# Haz los encabezados seguros: reemplaza None/vacío con \"Columna{n}\" y convierte a str
columns = [
    (str(v) if v is not None and str(v).strip() != "" else f"Column{idx + 1}")
   for idx, v in enumerate(raw_columns)
]

# Leer filas de datos a lo largo del mismo tramo (el ancho fijo garantiza la alineación)
data = []
for r in range(first_row + 1, last_row + 1):
    row_vals = [ws.cells.get(r, c).value for c in range(first_col, last_col + 1)]
    data.append(row_vals)

# Construir DataFrame
df = pd.DataFrame(data, columns=columns)

# Opcional: limpiar los nombres de columnas (por ejemplo, reemplazar espacios)
df.columns = [str(c).strip() for c in df.columns]

# Optional typing:
# - Mantener los ZIP como cadenas (los ceros a la izquierda son importantes)
# - Convertir totales a numéricos (forzar no numéricos a NaN)
for col in list(df.columns):
    if col.lower().endswith("total"):
        df[col] = pd.to_numeric(df[col], errors="coerce")

# Print
print(df)

Output

     A1  1001  49.90     NYC  10001
0  None  1002  79.00  Boston  02108

Nota: Si habilitas convertnumericordate=True, las cadenas que parecen numéricas (por ejemplo, totales) pueden convertirse en números, pero los códigos postales como \"02108\" pueden perder ceros a la izquierda. Mantenlo en False si necesitas que los códigos postales sean cadenas.

Convertir Excel a DataFrame de Pandas a través de JSON

Exportar cualquier rango de Excel a JSON con Aspose.Cells, luego carga ese JSON en Pandas como un DataFrame. Esto es útil cuando necesitas una transferencia JSON estructurada para servicios o pipelines.

Sigue los pasos a continuación para convertir Excel a un DataFrame de pandas a través de JSON:

  1. Crea un nuevo libro de trabajo, obtén la primera hoja de trabajo y agrega valores de muestra.
  2. Cree JsonSaveOptions con valores predeterminados.
  3. Exporta el rango utilizado a una cadena JSON con el método exportrangetojson().
  4. Leer la cadena JSON en un DataFrame utilizando el método pd.readjson(io.StringIO(jsontext)).
  5. Inspeccione o procese el DataFrame según sea necesario.

El siguiente ejemplo de código muestra cómo convertir Excel a un DataFrame de pandas a través de JSON en Python:

import io
import pandas as pd
from aspose.cells.utility import JsonUtility  # JSON export utility
from aspose.cells import Workbook, JsonSaveOptions, License

# Crea un nuevo libro de trabajo y accede a la primera hoja de trabajo.
workbook = Workbook()
worksheet = workbook.worksheets.get(0)

# Obtener las celdas de la hoja de cálculo
cells = worksheet.cells

# Rellena una tabla pequeña (encabezados + filas)
cells.get("A1").value = "Name"
cells.get("B1").value = "Age"
cells.get("C1").value = "City"

cells.get("A2").value = "Alice"
cells.get("B2").value = 25
cells.get("C2").value = "New York"

cells.get("A3").value = "Bob"
cells.get("B3").value = 30
cells.get("C3").value = "San Francisco"

cells.get("A4").value = "Charlie"
cells.get("B4").value = 35
cells.get("C4").value = "Los Angeles"

# Configurar opciones de guardado en JSON (los valores predeterminados son suficientes para una tabla simple)
json_save_options = JsonSaveOptions()

# Exporta el rango utilizado a una cadena JSON.
# maxdisplayrange captura toda la región rectangular que contiene datos
json_text = JsonUtility.export_range_to_json(cells.max_display_range, json_save_options)

# Leer la cadena JSON en un DataFrame de Pandas
#    Los pandas pueden analizar una cadena JSON directamente
df = pd.read_json(io.StringIO(json_text))

# Usa el DataFrame
print(df)

Output

      Name  Age           City
0    Alice   25       New York
1      Bob   30  San Francisco
2  Charlie   35    Los Angeles

Obtén una Licencia Gratuita

Evalúe Aspose.Cells for Python a través de .NET sin límites de funcionalidad aplicando una licencia temporal gratuita. Visite la página de licencia temporal para desbloquear la funcionalidad completa, incluyendo la importación de JSON (JsonUtility), el control de diseño (JsonLayoutOptions), la preservación de esquemas y la conversión de numéricos/fechas.

Recursos adicionales gratuitos

Puedes utilizar los recursos a continuación para profundizar en la importación de JSON, opciones de diseño y otras manipulaciones de Excel con Aspose.Cells for Python.

Conclusión

Convertir JSON en DataFrames de Pandas se vuelve sencillo con Aspose.Cells for Python. Obtiene un manejo confiable para estructuras anidadas, opciones para la estabilidad del esquema y un camino fácil para la exportación a Excel cuando sea necesario. Combine la flexibilidad de Pandas con el pipeline de JSON/Excel en Aspose.Cells para simplificar el procesamiento de datos y desbloquear un análisis poderoso en Python.

Si tiene preguntas, visite nuestro foro de soporte gratuito.Estamos felices de ayudarle.

Ver también