# Jupyter y JupyterLab

> Una página de la documentación de phonometry, en Markdown. Índice: https://docs.jmrp.io/phonometry/llms.txt

Canonical: https://docs.jmrp.io/phonometry/es/start/environments/jupyter/
Language: es
Alternate: https://docs.jmrp.io/phonometry/start/environments/jupyter/index.md
Version: phonometry 4.0.0
Install: pip install "phonometry[full]"
Unreleased: esta página cambió después de phonometry 4.0.0, la última versión publicada en PyPI, así que puede describir código que esa versión aún no tiene; lo nuevo desde entonces figura en Unreleased en https://github.com/jmrplens/phonometry/blob/main/CHANGELOG.md#unreleased
Author: José Manuel Requena Plens (https://orcid.org/0000-0003-1250-6212)
Published: 2026-11-11
Updated: 2026-11-18T01:01:07Z
License: MIT (https://github.com/jmrplens/phonometry/blob/main/LICENSE)
Summary: Usa phonometry en Jupyter y JupyterLab: el kernel y los extras, las tablas de los resultados, figuras en línea y en SVG, vídeos, fichas y avisos en una celda.

---

Un cuaderno ejecuta phonometry en un kernel de IPython corriente, así que se
instala igual que en cualquier otro sitio; lo que añade el cuaderno es cómo se
muestra un resultado bajo una celda. [En un
cuaderno](https://docs.jmrp.io/phonometry/es/start/getting-started/#en-un-cuaderno), en Primeros
pasos, recorre una primera celda y la tabla que muestra; esta página es el
resto de lo que encuentra quien trabaja en un cuaderno.

Comprobado el 17 de noviembre de 2026 con phonometry 4.0.0 de PyPI, en la
imagen `python:3.13-slim` con Python 3.13.18: JupyterLab 4.6.6, ipykernel
7.4.0, matplotlib 3.11.2 y el ffmpeg 7.1.5 de Debian, con cada celda de esta
página ejecutada en el kernel.

## Instalación

```bash
python -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install jupyterlab "phonometry[full]"
jupyter lab
```

En Windows, el entorno se activa con `.venv\Scripts\activate.bat` en cmd o
con `.venv\Scripts\Activate.ps1` en PowerShell en lugar de
`source .venv/bin/activate`.
En un equipo cliente de Windows, PowerShell rechaza los scripts con la
directiva de ejecución predeterminada, así que `Activate.ps1` se ejecuta allí
cuando `Set-ExecutionPolicy -Scope CurrentUser RemoteSigned` ha permitido los
locales; cmd no necesita ese paso.

Ese único entorno contiene
[JupyterLab](https://jupyterlab.readthedocs.io/en/stable/), el kernel de
IPython que arranca y phonometry con todos los extras salvo `[torch]`.

En Windows y Linux de 32 bits numba no tiene soporte, ni lo tiene `[full]`,
que lo incluye:
`python -m pip install jupyterlab "phonometry[plot,report,audio]"` instala
JupyterLab con los otros tres extras. PyPI no tiene wheel para Windows de 32
bits de SciPy, matplotlib ni kiwisolver, ni de psutil y pywinpty, que
JupyterLab necesita allí, ni de PyYAML en Python 3.14, así que pip los compila
allí desde el código fuente, lo que pide un compilador de C y otro de C++, un
compilador de Fortran con BLAS y LAPACK para SciPy, y para pywinpty Rust y la
herramienta de línea de órdenes de NuGet, `nuget.exe`, en el `PATH`. En
Linux de 32 bits, medido en las imágenes de 32 bits de `python:3.13-slim`,
PyPI no tiene wheel de NumPy, SciPy, matplotlib, Pillow, contourpy,
kiwisolver, psutil, PyYAML, tornado ni argon2-cffi-bindings, ni de
cffi y pyzmq en ARM, de MarkupSafe en `linux/386` y `linux/arm/v5`, o de lxml
y rpds-py en `linux/arm/v5`, así que pip los compila allí, con los mismos
compiladores, los archivos de desarrollo de las bibliotecas que enlazan y Rust
para rpds-py. En `linux/arm/v5`, cuya ABI de coma flotante por software no
cubre ningún wheel manylinux, las compilaciones de NumPy, SciPy, matplotlib y
pyzmq piden además ninja, patchelf y cmake, y pip también los compilaría desde
el código fuente, lo que ejecuta `make` y autoreconf, salvo que
`apt-get install ninja-build patchelf cmake` haya puesto los de la imagen en
el `PATH`.

## Un resultado se muestra como tabla

El valor de la última línea de una celda se muestra como una tabla de sus
campos, con sus unidades, y la línea de debajo dice qué puede dibujar el
resultado:

```python
import numpy as np
from phonometry import building, filters, io

fs = 48000
t = np.arange(fs) / fs
x = 0.4 * np.sin(2 * np.pi * 1000.0 * t)
bands = filters.octave_filter(x, fs, fraction=3)
bands       # la última línea de la celda: el cuaderno muestra su tabla
```

## Figuras

`.plot()` dibuja bajo la celda con el backend en línea, sin `plt.show()`. La
celda imprime además los ejes que devuelve, como
`<Axes: title={'center': 'Band levels'}, ...>`; un punto y coma tras la
llamada deja solo la figura. Las figuras salen en PNG, y una línea en una
celda pasa la sesión a SVG:

```py
%config InlineBackend.figure_formats = ["svg"]
bands.plot();
```

Un `.plot()` que lanza un error, por ejemplo por una palabra clave mal escrita
como `colour=`, no deja bajo la celda ninguna figura a medio dibujar, solo el
error.

## Fichas

```python
rating = building.weighted_rating(
    [30, 34, 38, 41, 45, 49, 50, 53, 54, 55, 56, 57, 58, 58, 58, 58]
)
rating.report("rating.pdf")
```

El PDF se escribe en la ruta que le das, relativa al directorio de trabajo
del cuaderno; `[report]` lo escribe y `[plot]` dibuja su gráfica.

## Vídeos

`io.write_video` y las funciones que escriben animaciones FDTD ejecutan
ffmpeg, un programa que pip no instala. En Debian llega con los paquetes del
sistema, con `apt install ffmpeg`, y [Escribir
vídeos](https://docs.jmrp.io/phonometry/es/io/videos/) da la orden para conda, macOS y Windows.
Las clases de visualización del propio IPython muestran después el archivo
bajo la celda:

```python
from matplotlib.animation import FuncAnimation
from matplotlib.figure import Figure

fig = Figure(figsize=(3.2, 2.4), dpi=100)
ax = fig.add_subplot()
phase = np.linspace(0.0, 2.0 * np.pi, 200)
(line,) = ax.plot(phase, np.sin(phase))


def update(k):
    line.set_ydata(np.sin(phase - 0.2 * k))
    return (line,)


animation = FuncAnimation(fig, update, frames=30, interval=50)
io.write_video("wave.mp4", animation)
io.write_video("wave.gif", animation, video=io.VideoOptions(quality="small"))
```

```py
from IPython.display import Image, Video, display

display(Video("wave.mp4", embed=True))  # un MP4 o un WebM, incrustado en el cuaderno
display(Image(filename="wave.gif"))     # un GIF
```

Una celda muestra solo el valor de su última línea, así que los dos pasan por
`display`: como dos líneas sueltas, la celda mostraría el GIF y no el vídeo.

## Avisos en una celda

Un aviso de la biblioteca nombra la línea de la celda que hizo la llamada, y
aparece bajo cada celda que la hace, no solo bajo la primera:

```text
/tmp/ipykernel_2485/1280619122.py:1: FilterBankWarning: Low sampling rate: fs = 48000 Hz cannot hold the 25 kHz band, whose upper edge 28184 Hz is above fs/2 = 24000 Hz; it was left out of the bank.
  wide = filters.octave_filter(x, fs, fraction=3, limits=[12.0, 25000.0])
```

Para que los avisos lancen un error, pon el filtro en una celda. Todos:

```py
import warnings

warnings.simplefilter("error")
```

o solo los de la biblioteca, con `warnings.simplefilter("error",
phonometry.PhonometryWarning)`. No arranques el kernel con
`PYTHONWARNINGS=error`: el propio kernel se detiene entonces en un
DeprecationWarning de su bucle de eventos antes de responder al cuaderno, y el
cuaderno informa de un kernel que ha muerto.

## VS Code y Colab

Los dos ejecutan los cuadernos sobre un kernel de IPython, así que lo que
muestra esta página debería valer también allí. No se ha probado en ninguno
de los dos.
