Para recopilar la misma celda de varias tablas de inventario repetidas, exporta cada tabla como CSV y luego ejecuta un atajo de Finder que lea esa posición y cree un resumen. Esta guía recopila B3, conserva el nombre de cada archivo de origen y evita sobrescribir un resultado existente.

Elige las entradas adecuadas antes de crear el atajo

Este flujo de trabajo está pensado para quien mantiene varias tablas de inventario con la misma estructura y quiere una fila por tabla en un resumen aparte. El ejemplo usa tres archivos desechables con recuentos sintéticos. Cada archivo representa una tabla exportada; la celda de destino está en la columna B, fila 3, incluida la fila de encabezado.

Distingue estos tres elementos: el documento de hoja de cálculo, la tabla que contiene y el archivo CSV exportado. La documentación de Numbers de Apple permite exportar CSV como archivos separados para cada tabla o combinar las tablas. Para esta tarea, elige archivos separados: combinar tablas puede cambiar la ubicación del registro de destino. Las exportaciones CSV contienen valores de celdas, así que el resumen resultante es una instantánea. Exportar a otros formatos de archivo en Numbers en Mac.

El atajo que se describe a continuación delega la extracción a un pequeño programa de Python. No trata un documento de Numbers ni un libro de Excel como texto sin formato, ni presupone que aceptar un archivo de hoja de cálculo permita a una acción acceder a sus celdas. Apple explica cómo consultar los tipos de entrada aceptados por una acción y el resultado que genera mediante su panel de información. Usa ese panel para comprobar las acciones disponibles en tu Mac. Navegar por la lista de acciones en Atajos en Mac.

Usa esta tabla de decisión antes de empezar:

Punto de partida Preparación para este flujo de trabajo
Una tabla coincidente en cada documento de Numbers Exporta cada tabla como CSV.
Varias tablas coincidentes en un documento Exporta archivos CSV separados e identifica las tablas previstas.
Archivos CSV existentes delimitados por comas Confirma la codificación, la estructura y la posición de destino.
Estructuras distintas o filas de inventario que cambian de lugar Estandariza primero los ejemplos desechables; una coordenada fija por sí sola no permite identificar la cantidad prevista.

Para el ejemplo, cada archivo de origen debe tener Counted units en A3 y el valor deseado en B3. Comprobar la etiqueta contigua también sirve como diagnóstico: si la fila se ha desplazado, la ejecución se detiene en vez de recopilar silenciosamente un valor que no corresponde. No detecta todos los posibles errores de estructura, así que confirma ambas celdas al preparar las entradas.

Prepara archivos de inventario desechables

Para este ejemplo, necesitas tener Python 3 instalado por separado. Con el instalador estándar del sitio web de Python, los enlaces a los ejecutables se colocan en /usr/local/bin/. Los comandos siguientes usan explícitamente /usr/local/bin/python3, por lo que no dependen de la ruta de búsqueda de comandos del atajo. Sigue las instrucciones de instalación de la versión de Python compatible y luego comprueba que este comando funcione. Usar Python en macOS.

/usr/local/bin/python3 --version

Si esa ruta no existe, completa la instalación de Python antes de continuar. El programa solo usa la biblioteca estándar de Python; no hace falta instalar paquetes adicionales. La guía de Terminal de Apple explica que se pueden invocar comandos con la ruta completa del ejecutable seguida de sus argumentos. Ejecutar comandos y herramientas en Terminal en Mac.

Para crear las entradas sintéticas, pega este comando completo en Terminal. Crea Inventory Demo en el Escritorio y se detiene si esa carpeta ya existe. Usa una carpeta desechable nueva en lugar de combinar estos ejemplos con un directorio existente.

/usr/local/bin/python3 - <<'PY'
import csv
from pathlib import Path

root = Path.home() / "Desktop" / "Inventory Demo"
root.mkdir()
examples = [
    ("Birch", "A", "12"),
    ("Cedar", "B", "7"),
    ("Maple", "C", "0"),
]
for name, bin_name, count in examples:
    with (root / f"{name}.csv").open(
        "x", encoding="utf-8", newline=""
    ) as handle:
        csv.writer(handle).writerows([
            ["Item", "Value"],
            ["Bin", bin_name],
            ["Counted units", count],
        ])
print(root)
PY

Para probar por separado el paso de exportación de Numbers, abre un CSV desechable en Numbers y expórtalo a otra carpeta desechable con Archivo > Exportar a > CSV. Elige un archivo por tabla, deja desactivada la opción Incluir nombres de tabla y usa la codificación UTF-8. Inspecciona la tabla exportada para confirmar que A3 y B3 siguen conteniendo la etiqueta y el valor previstos. Apple documenta estas opciones de exportación. Ajustes de exportación de Numbers.

No cambies la extensión de una hoja de cálculo a .csv como sustituto de exportarla. Este programa espera texto delimitado por comas. Guarda juntos los tres archivos CSV sintéticos originales para seguir la guía que viene a continuación.

Crea el programa que genera el resumen

Guarda el siguiente programa completo como overview.py dentro de Inventory Demo, usando un editor de texto sin formato. Confirma que el nombre del archivo termine en .py, no en .py.txt. El programa acepta como argumentos las rutas de los archivos de origen, lee B3 y crea overview.csv en la carpeta que comparten.

import csv
import io
import sys
from pathlib import Path

ROW, COLUMN = 2, 1  # Zero-based: B3
LABEL = "Counted units"

def build_overview(arguments):
    if not arguments:
        raise ValueError("Select at least one source CSV.")
    paths = [Path(name).expanduser().resolve(strict=True)
             for name in arguments]
    if len(set(paths)) != len(paths):
        raise ValueError("The same source was supplied twice.")
    if len({path.parent for path in paths}) != 1:
        raise ValueError("Keep all source CSVs in one folder.")
    rows = []
    for path in sorted(paths, key=lambda p: p.name):
        if (not path.is_file() or path.suffix.lower() != ".csv"
                or path.name.casefold() == "overview.csv"):
            raise ValueError(f"Not a source CSV: {path.name}")
        with path.open(encoding="utf-8-sig", newline="") as handle:
            records = list(csv.reader(handle, strict=True))
        if len(records) <= ROW or len(records[ROW]) <= COLUMN:
            raise ValueError(f"{path.name}: B3 does not exist.")
        if records[ROW][0] != LABEL:
            raise ValueError(f"{path.name}: A3 must be {LABEL!r}.")
        value = records[ROW][COLUMN]
        status = "blank" if value.strip() == "" else "present"
        rows.append([path.name, "B3", value, status])
    buffer = io.StringIO(newline="")
    writer = csv.writer(buffer)
    writer.writerow(["Source file", "Cell", "Value", "Status"])
    writer.writerows(rows)
    return paths[0].parent / "overview.csv", buffer.getvalue()

def main(arguments):
    try:
        destination, content = build_overview(arguments)
        with destination.open("x", encoding="utf-8", newline="") as handle:
            handle.write(content)
    except (OSError, ValueError, csv.Error) as error:
        print(f"Stopped: {error}", file=sys.stderr)
        return 1
    print(f"Created: {destination}")
    return 0

if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))

El programa usa un analizador de CSV en vez de separar el texto por comas o saltos de línea. El lector de Python devuelve los campos como cadenas y su documentación especifica que se deben abrir los archivos CSV con newline="". Esto permite procesar campos entrecomillados que contengan comas o saltos de línea. El programa conserva el valor extraído sin sumarlo ni convertirlo en un número. Lectura y escritura de archivos CSV.

El programa tiene varios límites deliberados que facilitan la comprobación del resultado. Cada entrada debe existir, todas las rutas de origen resueltas deben estar en la misma carpeta y se rechazan las rutas resueltas duplicadas. El programa ordena los archivos por nombre, en lugar de depender del orden de selección en Finder. También rechaza una entrada llamada overview.csv, para evitar incluir por accidente el resultado anterior.

Se leen y comprueban todas las fuentes antes de empezar a crear el archivo de salida. Si falta B3 o hay una etiqueta inesperada en A3, la ejecución se detiene. Si B3 existe, pero está vacía, se genera una fila marcada como blank; un valor de 0 se conserva como 0 y se marca como present. Así, una celda ausente, una celda vacía y un recuento de cero tienen resultados distintos.

La salida usa el modo de creación exclusiva, \"x\". Python documenta que este modo falla si el destino ya existe. Por tanto, el programa no reemplaza el resumen anterior ni genera un nombre de archivo con número. Si se produce un error durante la escritura, puede quedar un archivo nuevo incompleto; inspecciona cualquier archivo que quede tras un error de escritura antes de volver a intentarlo. Modos de apertura de archivos de Python.

Conecta el programa a un atajo de Finder

Crea un atajo llamado Inventory Overview en Atajos. Abre Detalles, activa Usar como acción rápida y selecciona Finder. En la configuración de entrada, deja activado Archivos y desactiva los tipos de contenido que no correspondan. Apple documenta la disponibilidad de Finder para los atajos que aceptan archivos o carpetas, así como los controles para limitar las entradas aceptadas. Ejecutar un atajo mientras trabajas en el Mac, Limitar la entrada de un atajo.

Configura el comportamiento cuando no haya entradas como Detener y responder, con un mensaje como Selecciona los archivos CSV de origen en Finder. Así, una selección vacía no da lugar a una ejecución ambigua. La guía de configuración de entradas de Apple describe esta opción y el campo de respuesta. Elegir la respuesta cuando no haya entradas.

Añade Ejecutar script de shell. Configura Shell como /bin/zsh, conecta Entrada a Entrada del atajo y establece Pasar entrada como como argumentos. Sustituye el script de ejemplo por este comando completo:

/usr/local/bin/python3 "$HOME/Desktop/Inventory Demo/overview.py" "$@"

Mantén las comillas. \"$@\" entrecomillado pasa los argumentos de entrada por separado y conserva los nombres de archivo que contienen espacios. La ruta del script también va entre comillas por el mismo motivo. El manual de zsh documenta los parámetros posicionales y la expansión por separado de los elementos de una matriz entrecomillados; la guía de Terminal de Apple también explica cómo entrecomillar las rutas. Parámetros, Especificar archivos y carpetas en Terminal.

Si Atajos requiere que se activen los scripts, selecciona Atajos > Ajustes > Avanzado y activa Permitir ejecutar scripts. Apple documenta este ajuste en la sección sobre cómo permitir que se ejecuten scripts desde un atajo. Ajustes avanzados de Atajos.

El flujo configurado es el siguiente: los objetos de archivo seleccionados entran en el atajo, sus rutas se convierten en argumentos del shell y Python lee esos archivos y escribe el resumen. El resultado textual correcto de la acción de shell es un mensaje Created: que contiene la ruta del archivo de destino. Ese mensaje no es el archivo CSV. No hace falta ninguna acción de guardado posterior porque el programa ya ha creado el archivo.

En Finder, selecciona solo Birch.csv, Cedar.csv y Maple.csv. Haz clic en la selección con la tecla Control pulsada y elige Acciones rápidas > Inventory Overview. Si el atajo no aparece, usa Más > Personalizar para revisar las extensiones de Finder activadas y vuelve a comprobar los tipos de entrada aceptados. Apple documenta cómo personalizar las acciones rápidas de Finder y cómo añadir atajos a ese menú. Realizar acciones rápidas en Finder en Mac.

Comprueba el resultado y gestiona las ejecuciones repetidas

Abre overview.csv desde la carpeta de demostración en Numbers. Con los archivos sintéticos proporcionados, su contenido debería ser:

Source file,Cell,Value,Status
Birch.csv,B3,12,present
Cedar.csv,B3,7,present
Maple.csv,B3,0,present

Comprueba que haya una fila de salida por cada archivo de origen seleccionado y que los nombres de archivo identifiquen las tablas previstas. Los valores del ejemplo son ilustrativos; no son resultados de un inventario medido. El programa indica si hay un valor, pero no comprueba que sea un recuento válido.

Si el resultado es distinto, sigue esta secuencia de diagnóstico:

  1. El atajo no aparece en Finder: comprueba el ajuste Finder, la entrada aceptada Archivos y que la extensión esté activada.
  2. Falta el ejecutable o el script: confirma la ruta de Python y que overview.py siga en la carpeta de demostración especificada.
  3. Falta B3 o A3 es incorrecto: inspecciona los registros exportados del archivo de origen y las opciones de exportación antes de cambiar el programa.
  4. Aparece un espacio en blanco inesperado: inspecciona B3; el programa deja los valores vacíos tal como están a propósito.
  5. El destino ya existe: cambia el nombre del resumen desechable anterior o muévelo fuera de la carpeta de origen antes de volver a ejecutar el programa.

También puedes ejecutar el mismo atajo desde Terminal para comprobar la ruta de entrada. Apple documenta -i para pasar entradas de archivo; canalizar una ruta de archivo pasa texto. Usa los archivos explícitos que aparecen a continuación, sin una opción de salida, porque el programa de Python se encarga de crear el archivo de salida. La misma regla para los conflictos de nombres sigue vigente. Ejecutar atajos desde la línea de comandos.

shortcuts run "Inventory Overview" -i \
  "$HOME/Desktop/Inventory Demo/Birch.csv" \
  "$HOME/Desktop/Inventory Demo/Cedar.csv" \
  "$HOME/Desktop/Inventory Demo/Maple.csv"

Cada resumen nuevo representa los archivos CSV seleccionados para esa ejecución. Si una hoja de cálculo cambia, hay que exportarla de nuevo y volver a ejecutar el atajo. Conservar el nombre del archivo de origen, comprobar la etiqueta contigua y distinguir los valores en blanco del cero facilita verificar este pequeño resumen antes de usarlo en la próxima revisión del inventario.

Fuentes