¡Muchas gracias a Brian Granger, Fernando Pérez y Robert Kern por sus aportaciones a este artículo!
Tanto para quienes están aprendiendo como para científicos de datos con más experiencia, Jupyter Notebook es una de las herramientas más populares: su entorno interactivo no solo es ideal para enseñar, aprender y compartir tu trabajo con colegas, sino que además favorece la reproducibilidad. Aun así, mientras aprendes a usar el cuaderno, verás que a menudo aparece IPython.
En algunos casos parecen sinónimos, y estarás de acuerdo conmigo en que resulta muy confuso cuando quieres profundizar: ¿los magics pertenecen a Jupyter o a IPython? ¿Guardar y cargar cuadernos es una función de IPython o de Jupyter?
Podrías seguir así con muchas más preguntas.
La entrada de hoy quiere dejar claras algunas diferencias clave entre ambos: partiremos de sus orígenes para explicar cómo se relacionan y repasaremos funciones concretas que pertenecen a uno u otro, para que te resulte más fácil distinguirlos.
Te recomendamos también leer la guía definitiva de Jupyter Notebook de DataCamp para trucos, buenas prácticas, ejemplos y mucho más.
Los orígenes de IPython y Jupyter
Para entender qué es Jupyter Notebook y en qué se diferencia de IPython, conviene conocer primero cómo encajan ambos en la historia y el futuro de los cuadernos computacionales.
El inicio de los cuadernos computacionales: MATLAB, Mathematica y Maple
A mediados de los años 80, The MathWorks lanzó MATLAB, fundada por Jack Little, Steve Bangert y Cleve Moler.
Viajemos a finales de los 80, concretamente a 1987. Theodore Gray empezó a trabajar en lo que sería la interfaz de cuaderno de Mathematica y, un año después, se lanzó al público. La GUI permitía crear y editar de forma interactiva documentos tipo cuaderno con código formateado, texto y todo tipo de funciones como matemáticas compuestas, gráficos, componentes de interfaz, tablas y sonidos. Incluía además funciones estándar de edición de texto, como corrector ortográfico multilingüe en tiempo real. Y podías exportar los documentos a un modo presentación.
Si observas cómo se estructuraban estos cuadernos, verás enseguida que se basaban en una jerarquía de celdas para organizar y seccionar documentos, algo que hoy también encuentras en los cuadernos de Jupyter.
También a finales de los 80, en 1989, Maple introdujo su primera GUI en formato cuaderno, incluida en la versión 4.3 para Macintosh. Las versiones para X11 y Windows llegaron en 1990. Aquellos primeros cuadernos inspiraron y sentaron las bases para que otros desarrollaran lo que después llamaríamos «cuadernos de ciencia de datos».
El auge de los cuadernos de ciencia de datos
Tras los cuadernos de Maple y Mathematica, surgieron muchos más cuadernos computacionales. Esta sección, sin embargo, se centrará en los que contribuyeron al auge de los cuadernos de ciencia de datos. Verás que algunos siguen siendo muy populares entre quienes están empezando y entre perfiles más avanzados.
Sage Notebook
El cuaderno de Sage, como sistema basado en navegador, se publicó por primera vez a mediados de los 2000 y, en 2007, apareció una versión más potente con cuentas de usuario y opción para hacer documentos públicos. Su interfaz recordaba a Google Docs, ya que el diseño del cuaderno de Sage se inspiró en los cuadernos de Google.
Sus creadores confirmaron que eran usuarios habituales de los cuadernos de Mathematica y las hojas de Maple. Otros factores clave en su desarrollo fueron: primero, el contacto estrecho con el equipo de IPython, también porque la versión en terminal de Sage usaba IPython. Segundo, «un intento fallido» de dos estudiantes de crear una GUI para IPython. Y tercero, el auge de las aplicaciones web «AJAX» (acrónimo coloquial de «Asynchronous JavaScript And XML»), que evitaban recargar la página a cada acción.
Esto pasa, por ejemplo, cuando rellenas un formulario web: sin AJAX, al enviar te redirigen a una página nueva con la respuesta del servidor. Con AJAX, JavaScript hace la petición, recibe el resultado y actualiza la pantalla sin recarga ni redirección.
Otros ejemplos de aplicaciones AJAX: Gmail, Google Maps, Facebook, Twitter… Como ves, casi todo usa AJAX.
IPython y Jupyter Notebook
A finales de 2001, unos veinte años después de que Guido van Rossum empezara a trabajar en Python en el CWI de los Países Bajos, Fernando Pérez comenzó a desarrollar IPython. El proyecto estuvo muy influido por los cuadernos de Mathematica y las hojas de Maple, igual que Sage y muchos otros posteriores.
En 2005 hubo un primer intento de construir un sistema de cuadernos con Wx, un toolkit y librería de herramientas para crear GUIs multiplataforma. Dos estudiantes de Google Summer of Code trabajaron en el prototipo bajo la dirección de Robert Kern y Fernando Pérez. Después, Robert avanzó algo más: no era tanto un prototipo de cuaderno como una limpieza del núcleo de IPython para facilitar crear un frontend wxPython para la shell de IPython. Estas limpiezas también allanaron el camino para un sistema de cuadernos más limpio y parte de ello se fue incorporando poco a poco a IPython cuando el esfuerzo del cuaderno, ya con éxito, despegó.
El segundo prototipo de cuaderno para IPython lo construyó en el verano de 2006 Min Ragan-Kelley, con Brian Granger como asesor. Era web y tenía un backend con base de datos SQL, pero se abandonó porque resultó demasiado complejo con las tecnologías web de la época.
El tercer prototipo llegó en octubre de 2010 y lo hizo un tercero en un hack de pocos días. Por fin, en la primavera-verano de 2011, Brian Granger trabajó a tiempo completo en el prototipo del cuaderno web, basado en trabajo de 2010, cuando creó junto a Fernando Pérez la arquitectura del kernel de IPython y la especificación de mensajes, y con Min Ragan Kelley, PyZMQ.
PyZMQ es una librería que proporciona bindings de Python para ZeroMQ; era necesaria para las funciones de computación en paralelo, la consola qt y el cuaderno de IPython.
PyZMQ y websockets fueron las tecnologías clave que hicieron posible el cuaderno. En otoño de ese mismo año, otros colaboradores (como Matthias Bussonnier, Min y Fernando) también empezaron a contribuir. El 21 de diciembre de 2011 se publicó la primera versión de IPython Notebook (0.12).
En los años siguientes, el equipo recibió premios, como el Advancement of Free Software para Fernando Pérez el 23 de marzo de 2013 y el Jolt Productivity Award, además de financiación de la Alfred P. Sloan Foundation, entre otros.
Por último, en 2014 nació Project Jupyter como un spin-off de IPython.
La última versión de IPython antes de la escisión incluía en un único repositorio una shell interactiva, el servidor del cuaderno, la consola Qt, etc. El proyecto era grande, con componentes que cada vez eran más proyectos independientes que, casualmente, pertenecían al mismo paraguas.
Pero el tamaño no fue el único motivo para crear Project Jupyter: de 2011 a 2014, el cuaderno de IPython empezó a funcionar con otros lenguajes. Primero Julia y, más tarde, R. Que IPython Notebook —un nombre que sugería que todo era Python— funcionara con kernels de otros lenguajes como Julia y R confundía a la gente.
¿Por qué «IPython» si había otros lenguajes?
El nombre «Jupyter» se inspiró pensando en los lenguajes abiertos líderes en ciencia (Julia, Python y R); aunque parezca un acrónimo más, nunca implicó que no se aceptaran otros lenguajes. Es más, representaba mejor el proyecto en el que trabajaban los desarrolladores y hacía un guiño a sus raíces científicas.
Tras el inicio de Project Jupyter, las partes independientes del lenguaje en IPython —como el formato del cuaderno, el protocolo de mensajes, la consola Qt, la aplicación web del cuaderno, etc.— pasaron al proyecto Jupyter. La organización principal de Jupyter en GitHub está aquí.
En las comunidades de Jupyter e IPython a esto se le llama «The Big Split».
IPython ahora cumple dos funciones: ser el backend de Python para Jupyter Notebook (el kernel) y una shell interactiva de Python. Pero no solo eso: dentro del ecosistema IPython también encontrarás un framework de computación en paralelo. ¡Más adelante leerás sobre ello!
Y, al igual que IPython, Project Jupyter es el nombre paraguas de varios proyectos: incluye tres aplicaciones (el propio Notebook, una Console y una consola Qt) y subproyectos como JupyterHub para desplegar cuadernos, nbgrader para educación, etc. Puedes ver un resumen de la arquitectura de Jupyter aquí.
Precisamente esta evolución explica la confusión de muchos pythonistas entre IPython y Jupyter: dado que uno salió del otro (y hace relativamente poco), a algunos aún les cuesta adoptar los nombres correctos. Y lo complica más que hay solapamientos: al derivar uno del otro, hay funciones de IPython y de Jupyter Notebook difíciles de distinguir. Cómo diferenciarlos quedará claro en las siguientes secciones. Si quieres más detalles sobre el desarrollo de IPython, echa un vistazo a los relatos personales de Fernando Pérez y William Stein sobre la historia de sus cuadernos.
Cuadernos de R
R Markdown y Jupyter Notebook comparten la apuesta por un flujo reproducible, entrelazando código, salida y texto en un mismo documento, con widgets interactivos y exportación a múltiples formatos.
Pero también difieren: R Markdown prioriza la ejecución por lotes reproducible, la representación en texto plano, el control de versiones y la salida para producción, y ofrece el mismo editor y herramientas que usas para scripts de R. Jupyter apuesta por mostrar la salida incrustada junto al código, cachear resultados entre sesiones, compartir código y salida en un único archivo. Los cuadernos ponen el acento en la ejecución interactiva. No usan representación en texto plano, sino un formato de datos estructurado como JSON.
De ahí el propósito de la aplicación de cuadernos de RStudio: combinar todas las ventajas de R Markdown con lo mejor de los cuadernos computacionales.
Si quieres aprender a trabajar con cuadernos de R y ver diferencias exactas entre Jupyter y los cuadernos de R Markdown en compartición, gestión de proyectos, control de versiones y más, consulta el artículo de DataCamp Jupyter y R: cuadernos con R.
Otros cuadernos de ciencia de datos
Por supuesto, hay más cuadernos que puedes considerar cuando te inicias en ciencia de datos. En los últimos años han aparecido muchas alternativas: desde Beaker Notebook, Apache Zeppelin, Spark Notebook, DataBricks Cloud, etc., hasta herramientas como el IDE Rodeo o nteract, que también hacen tus análisis interactivos y reproducibles. Conviene señalar que nteract se diferencia del resto porque aprovecha la arquitectura de Jupyter (protocolos y formatos).
El futuro de los cuadernos
Y parece que los cuadernos han llegado para quedarse. Recientemente se ha presentado a la comunidad la siguiente generación de Jupyter Notebook: JupyterLab. La aplicación incluye no solo soporte para cuadernos, sino también un gestor de archivos, editor de texto, emulador de terminal, monitor de procesos de Jupyter en ejecución, gestor de clústeres IPython y un visor de ayuda.
Quizá pienses que no hay nada nuevo: Jupyter Notebook ya tenía todo eso. Sin embargo, JupyterLab te permite usar todos esos bloques de construcción de la computación interactiva de formas nuevas.
Lee más sobre ello aquí.
El amplio conjunto de herramientas de Jupyter Notebook evolucionó de forma orgánica, impulsado por las necesidades de usuarios y desarrolladores. JupyterLab es una arquitectura de nueva generación para dar soporte a todas estas herramientas con una interfaz flexible y adaptable, ofreciendo un diseño controlado por el usuario que integra las piezas.
¿IPython o Jupyter?
La evolución del proyecto y la consiguiente «Big Split» son la base para entender las diferencias reales. Pero, como están intrínsecamente conectados, a veces dudarás sobre qué pertenece a qué.
En la siguiente sección repasamos funciones que forman parte del ecosistema IPython o del Project Jupyter.
Te toca a ti elegir la respuesta correcta y descubrir más sobre cada función.
¿Kernels?
Aunque los kernels hoy destacan en la aplicación Jupyter Notebook, la primera herramienta que usó un kernel completo y su protocolo fue la consola Qt, desarrollada antes que el cuaderno. Actualmente, los kernels son aprovechados con gran flexibilidad por el cuaderno, tanto histórica como arquitectónicamente, y son una función de Jupyter, no del Notebook en sí. Es decir, los kernels son mucho más que una función: son una abstracción central de la arquitectura de Jupyter, y los usan herramientas no basadas en cuadernos como la consola de texto, la consola Qt, Thebe de O’Reilly, Kernel Gateway, el editor Hydrogen de nteract. Por último, en JupyterLab, los kernels pueden conectarse a todo: desde un cuaderno a una consola web o incluso a un archivo de texto.
Un kernel es un programa que ejecuta e inspecciona el código del usuario: proporciona computación y comunicación con las interfaces frontend, como los cuadernos. La aplicación Jupyter Notebook tiene tres kernels principales: IPython, IRkernel e IJulia.
Dado que el nombre «Jupyter» se inspiró en Julia, Python y R, no sorprende. El kernel de IPython lo mantiene el equipo de Jupyter, como resultado de la evolución del proyecto.
Además, puedes ejecutar muchos otros lenguajes en Jupyter Notebook, como Scala, JavaScript, Haskell, Ruby y más. Esos son kernels mantenidos por la comunidad.
¿Despliegue de cuadernos?
Desplegar cuadernos es algo propio del trabajo con Jupyter. Hay bastantes paquetes dentro del ecosistema de Jupyter que te ayudan a desplegarlos.
Algunos son:
docker-stacks, útil cuando necesitas pilas de aplicaciones Jupyter y kernels como contenedores Docker.ipywidgetsofrece widgets HTML y JavaScript interactivos (deslizadores, casillas, cuadros de texto, gráficos, etc.) para la arquitectura de Jupyter que combinan controles frontend conectados a un kernel.jupyter-drivepermite a IPython usar Google Drive para la gestión de archivos.jupyter-sphinx-themepara añadir un tema Sphinx de Jupyter a tu cuaderno y así crear documentación más clara y atractiva.kernel_gatewayes un servidor web que admite distintos mecanismos para lanzar y comunicar con kernels de Jupyter. Mira aquí casos de uso.nbviewerpara compartir tus cuadernos. Consulta la galería aquí.tmpnbpara crear servidores temporales de Jupyter Notebook con contenedores Docker. Pruébalo aquí.traitletses un framework que permite a clases de Python tener atributos con comprobación de tipos, valores por defecto calculados dinámicamente y callbacks «on change». También sirve para configuración, cargando valores de archivos o de argumentos de línea de comandos. Traitlets impulsa el sistema de configuración de IPython y Jupyter y la API declarativa de los widgets interactivos de IPython.
¿Uso del shell del sistema?
Es posible adaptar IPython para usar el shell del sistema con el escape de shell: las líneas que empiezan por ! se pasan directamente al shell. Por ejemplo, !ls ejecutará ls en el directorio actual. Puedes asignar el resultado de un comando del sistema a una variable de Python con la sintaxis myfiles=!ls. Si quieres imprimir explícitamente el resultado de un ls como lista de strings, sin asignarlo a una variable, usa dos signos de exclamación (!!ls) o el comando mágico %sx sin asignación.
# Assign the result to `ls`
ls = !ls
# Explicit `ls`
!!ls
# Or with magics
%sx
# Assign magics result
ls = %sxTen en cuenta que los comandos !! no pueden asignarse a una variable, pero el resultado de un magic (si devuelve un valor) sí puedes asignarlo.
IPython también permite expandir el valor de variables de Python al hacer llamadas al sistema: basta con envolver variables o expresiones entre llaves ({}). Además, en un comando de shell con ! o !!, cualquier variable de Python con prefijo $ se expande. En el bloque de abajo, verás que haces echo del atributo argv de la variable sys. También puedes usar las sintaxis $/$$ para introducir variables de Python desde la salida del sistema y reutilizarlas después.
Para pasar un $ literal al shell, usa doble $$. Necesitarás ese $ literal si quieres acceder a variables del shell y del entorno como $PATH:
# Import and initialize
import math
x = 4
# System call with variable
!echo {math.factorial(x)}
# Expand a variable
!echo $sys.argv
# Use $$ for a literal $
!echo "A system variable: $$HOME"Lee más aquí.
Ten en cuenta que, además de IPython, hay otros kernels con sintaxis especial para ejecutar líneas como comandos del shell. No son realmente «magics» en el sentido estricto porque pueden implementarse con cualquier nombre y ser muy distintos (más o menos potentes) que los magics de IPython.
También hay alias que puedes definir para comandos del sistema. Son básicamente atajos a comandos de bash. Un alias es una tupla: («showTheDirectory», «ls»). Ejecuta %alias? para más información.
Truco: usa %rehashx para cargar todo tu $PATH como alias de IPython.
¿Magics?
Si has leído la guía definitiva de Jupyter Notebook de DataCamp o ya has trabajado con Jupyter, quizá conozcas los llamados «comandos mágicos». Los magics suelen consistir en un elemento de sintaxis no válido en el lenguaje subyacente y alguna palabra que implica un comando. Bajo el capó, las funciones magic son funciones de Python.
El kernel de IPython usa, como ya sabrás, el elemento de sintaxis % porque no es un operador unario válido en Python. Sin embargo, las líneas que empiezan con %% señalan un magic de celda: aceptan como argumentos no solo el resto de la línea actual, sino todas las líneas que siguen en el bloque de ejecución. Los magics de celda pueden hacer modificaciones arbitrarias a la entrada que reciben, que ni siquiera tiene por qué ser código Python válido. Reciben todo el bloque como un único string.
Los magics son específicos de cada kernel y están pensados para hacer tu trabajo y tu experiencia en Jupyter Notebook mucho más interactivos. Que existan o no en un kernel depende de sus desarrolladores y varía de un kernel a otro. Ya lo ves: los magics son una función del kernel.
Cuando usas el backend de Python para Jupyter Notebook, IPython (el kernel), puedes recurrir a los siguientes trucos para acceder a funciones que harán tu programación más rápida, fácil e interactiva. La lista no es exhaustiva: consulta esta lista de comandos mágicos integrados para un resumen completo.
Gráficos
Una gran función del kernel de IPython es la posibilidad de mostrar gráficos como salida de celdas de código. El kernel está diseñado para trabajar sin fricciones con la librería de visualización matplotlib. Para usarla, ejecuta el comando mágico %matplotlib.
Por defecto, el gráfico se mostrará en una ventana aparte. También puedes especificar un backend, como inline o qt: así la salida de los comandos de graficado se mostrará incrustada o mediante otra GUI. Puedes leer más aquí.
Navegación por el sistema de archivos
Los comandos mágicos del kernel también permiten navegar por tu sistema de archivos. Los magics %cd y %bookmark sirven para cambiar de directorio o guardar accesos directos a carpetas que uses a menudo.
Acceso al depurador
También puedes usar magics para invocar el depurador de Python %pdb cada vez que haya una excepción no capturada. Te guiará por la parte del código que la ha provocado, lo que facilita localizar el origen del error.
Otra opción es usar %run con la opción -d para ejecutar scripts bajo el control del depurador de Python. Configurará automáticamente puntos de interrupción iniciales. Por último, también puedes usar el magic %debug para un acceso aún más directo al depurador.
Extensiones de IPython
Puedes cargar una extensión de IPython por su nombre de módulo con %load_ext. Las extensiones de IPython son módulos de Python que modifican el comportamiento de la shell: pueden registrar magics, definir variables y, en general, modificar el espacio de nombres del usuario para aportar nuevas funciones en las celdas. Algunos ejemplos:
- Usa
%load_ext oct2py.ipythonpara llamar sin fricciones a archivos M y funciones de Octave desde Python, - Usa
%load_ext rpy2.ipythonpara usar una interfaz a R embebido en un proceso de Python, - Usa
%load_ext Cythonpara compilar de Python a C, - Usa
sympy.init_printing()para imprimir objetos básicos de Sympy de forma elegante automáticamente, y - Para usar Fortran en tu sesión interactiva,
%load_ext fortranmagic.
… ¡hay muchas más! Puedes crear y registrar tus propias extensiones de IPython en PyPi: eso significa que hay muchísimas extensiones y magics definidos por usuarios. Un ejemplo es ipython_unittest; echa también un ojo a este índice de extensiones.
Otra extensión a seguir de cerca es sparkmagic, un conjunto de herramientas para trabajar de forma interactiva con clústeres remotos de Spark a través de Livy (un servidor REST de Spark) en cuadernos de Jupyter. La librería sparkmagic proporciona un magic %%spark para ejecutar código fácilmente contra un clúster remoto de Spark desde un cuaderno normal de IPython.
# Load in sparkmagic
%load_ext sparkmagic.magics
# Set the endpoint
%manage_spark
# Ask for help
%spark?Ve aquí para más ejemplos de cómo usar estos magics y trabajar con un clúster de Spark de forma interactiva.
Ten en cuenta que, además de %load_ext, IPython tiene otros dos magics para gestionar extensiones desde tu Jupyter Notebook: %reload_ext y %unload_ext para recargar e importar una extensión, y para descargarla, respectivamente.
Kernels distintos, otros magics
En otros lenguajes, el elemento de sintaxis de los magics puede tener significado. El kernel de R, IRKernel, no tiene sistema de magics. Para ejecutar comandos de bash, por ejemplo, usarás funciones de R como system() para invocar un comando del SO. Un ejemplo sería system("head -5 *.csv", intern=TRUE). Si incluyes el argumento intern, indicas que quieres capturar la salida del comando como un vector de caracteres en R. Para mostrar Markdown, usa display_markdown(), al que pasas el código Markdown como vector de caracteres. Del mismo modo, el kernel de Julia, IJulia, tampoco usa «magics». En Julia hay otras sintaxis más naturales para lograr lo mismo, funcionan fuera de las celdas de IJulia y a menudo son más potentes. Aun así, los desarrolladores de IJulia han procurado que, cuando introduzcas un magic de IPython en una celda de IJulia, veas un mensaje de ayuda que explica cómo conseguir un efecto similar en Julia si es posible.
Por ejemplo, el análogo de %load de IPython en IJulia es IJulia.load().
En cambio, kernels como el de Scala, IScala, sí admiten magics de forma similar a IPython. No obstante, el conjunto de magics es distinto porque debe ajustarse a las particularidades de Scala y la JVM. Los magics consisten en un signo de porcentaje % seguido de un identificador y una entrada opcional. Algunos destacados:
# Type Information
%type 1
# Library Management
%libraryDependencies
%updateComo has leído arriba, la librería sparkmagic también proporciona kernels de Scala y Python que te permiten conectarte automáticamente a un clúster remoto de Spark, ejecutar código y consultas SQL, gestionar tu servidor Livy y la configuración de trabajos de Spark, y generar visualizaciones automáticas. ¡Y sin necesidad de código adicional!
Por ejemplo, puedes ejecutar consultas de SparkSQL con %%sql o acceder a información y logs de aplicaciones de Spark con el magic %%info.
Si trabajas con otro kernel y te preguntas si puedes usar magics, conviene saber que hay kernels basados en el proyecto metakernel que, en muchos casos, usan los mismos magics que encontrarás en IPython. Puedes ver la lista de magics de metakernel aquí. Metakernel es una plantilla de kernel para Jupyter/IPython que incluye funciones magic básicas.
Algunos ejemplos:
- El kernel de MATLAB
matlab_kernel, - El kernel de Octave
octave_kernel, - El kernel de Java9
java9_kernel, - El kernel de Wolfram
wolfram_kernel, - El kernel de SAS… ¡y muchos más!
Esto significa que, por ejemplo, cuando uses el kernel de MATLAB, tendrás disponibles los siguientes magics:
Available line magics:
%cd %connect_info %download %edit %get %help %html %install %install_magic %javascript %kernel %kx %latex %load %ls %lsmagic %magic %parallel %plot %pmap %px %python %reload_magics %restart %run %set %shell %spell
Available cell magics:
%%debug %%file %%help %%html %%javascript %%kx %%latex %%processing %%px %%python %%shell %%show %%spellSi te fijas en el bloque anterior, verás que algunos comandos resultan familiares. Para quienes no conocen bien los magics, comparad el bloque anterior con los magics disponibles por defecto en el kernel de IPython y veréis que algunos se repiten:
Available line magics:
%alias %alias_magic %autocall %automagic %autosave %bookmark %cat %cd %clear %colors %config %connect_info %cp %debug %dhist %dirs %doctest_mode %ed %edit %env %gui %hist %history %killbgscripts %ldir %less %lf %lk %ll %load %load_ext %loadpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %lx %macro %magic %man %matplotlib %mkdir %more %mv %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %popd %pprint %precision %profile %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx %reload_ext %rep %rerun %reset %reset_selective %rm %rmdir %run %save %sc %set_env %store %sx %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmode
Available cell magics:
%%! %%HTML %%SVG %%bash %%capture %%debug %%file %%html %%javascript %%js %%latex %%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%time %%timeit %%writefileEn esencia, hay una pregunta que te ayuda a distinguir qué magics son específicos de IPython y cuáles puedes usar en otros kernels: ¿esta funcionalidad es propia de Python o es algo general que también tiene sentido en el lenguaje con el que trabajas?
Por ejemplo, %pdb (el depurador de Python) o %matplotlib son específicos de Python y no tendrían sentido en el kernel de JavaScript. Sin embargo, cambiar de directorio con %cd es algo general que debería funcionar en cualquier lenguaje por ser un comando «universal». Así que es probable que ese magic esté disponible en otros kernels. Por supuesto, siempre tendrás que comprobar si tu kernel usa magics.
¿Conversión y formateo de cuadernos?
Convertir y dar formato a cuadernos son funciones del ecosistema Jupyter. Dos herramientas típicas para estas tareas son nbconvert y nbformat.
Con la primera puedes convertir cuadernos a varios formatos para presentar información en formatos conocidos, publicar investigaciones e incrustar cuadernos en artículos, colaborar y compartir contenidos con una audiencia más amplia.
La segunda contiene el formato de Jupyter Notebook y es clave para entender que los archivos de cuadernos son documentos JSON sencillos que incluyen: metadatos (como el kernel o información del lenguaje), la versión del formato del cuaderno (mayor y menor) y las celdas donde se guarda todo el texto, código, etc.
¿Guardar y cargar cuadernos?
Guardar y cargar cuadernos es una función de la aplicación Jupyter Notebook. Puedes cargar cuadernos (archivos con extensión .ipynb) creados por otras personas descargando y abriendo el archivo en la aplicación Jupyter. Concretamente, puedes crear un cuaderno nuevo y luego abrir el archivo desde la pestaña «File», haciendo clic en «Open» y seleccionando tu cuaderno descargado.
A la inversa, también puedes guardar tus propios cuadernos desde la misma pestaña «File» y seleccionando «Download as» para obtener el archivo, o elegir «Save» y crear un checkpoint. Esto es muy útil para un pequeño control de versiones y poder volver a una versión anterior. Por supuesto, tus cambios se guardan automáticamente cada pocos minutos, así que no siempre hace falta hacerlo manualmente.
También puedes optar por no guardar cambios en el cuaderno original haciendo una copia y guardando todas las modificaciones en esa copia.
¿Atajos de teclado y multicursor?
Seleccionar varias celdas, alternar la salida de las celdas, insertar celdas nuevas… Para todas estas acciones tienes atajos de teclado propios de Jupyter Notebook. Puedes ver la lista de atajos en el menú superior: ve a la pestaña «Help» y selecciona «Keyboard Shortcuts».
Además, el soporte de multicursor también es una función de Jupyter Notebook.
¿Red de computación en paralelo?
La red de computación en paralelo formaba parte del proyecto IPython, pero desde la versión 4.0 es un paquete independiente llamado ipyparallel. Básicamente es un conjunto de scripts CLI para controlar clústeres en Jupyter.
Aunque se haya separado, sigue siendo un componente potente del ecosistema IPython al que a menudo no se le presta atención; es potente porque, en lugar de ejecutar un único kernel de Python, te permite lanzar muchos kernels distribuidos en múltiples máquinas.
Casos de uso típicos de ipyparallel son, por ejemplo, ejecutar un modelo muchas veces para estimar la distribución de sus salidas o cómo varían con los parámetros de entrada. Si las ejecuciones del modelo son independientes, puedes acelerar el proceso ejecutándolas en paralelo en varias máquinas de un clúster. Piensa en entrenamiento distribuido de modelos o simulaciones.
¿Terminal?
Esta función forma parte del ecosistema Jupyter: tienes Jupyter Console y una aplicación de terminal de Jupyter. Sin embargo, desde el principio IPython se ha usado para referirse a la terminal interactiva original de Python. Ofrece un bucle REPL mejorado, especialmente adaptado al cómputo científico. Era el estándar hasta 2011, cuando se introdujo Notebook y empezó a ofrecer una potente interfaz web moderna para Python.
Después tenías la consola de IPython, que iniciaba dos procesos: la shell original de la terminal IPython y el perfil o kernel por defecto, que se inicia si no se indica otro. Por defecto era Python. La consola de IPython está ahora obsoleta y, si quieres iniciarla, debes usar Jupyter Console, un frontend de consola basado en terminal para los kernels de Jupyter. Su código se basa en la terminal de IPython de un solo proceso. Jupyter Console proporciona la experiencia interactiva de IPython en la terminal, pero con la posibilidad de conectarse a cualquier kernel de Jupyter en lugar de solo a IPython. Así puedes probar cualquier kernel instalado desde la terminal, sin necesidad de abrir un Notebook completo. La Console permite la interacción basada en consola con otros kernels como IJulia o IRKernel.
Por último, la aplicación Jupyter Notebook también incluye una Terminal: un shell bash sencillo que se ejecuta en tu navegador. La encontrarás fácilmente al iniciar la aplicación y seleccionar un nuevo terminal en el menú desplegable.
¿Consola Qt?
La consola Qt solía formar parte de IPython, pero ahora pertenece al proyecto Jupyter. Es una aplicación ligera que se parece mucho a una terminal, pero ofrece mejoras propias de una GUI, como figuras incrustadas, edición multilínea con resaltado de sintaxis, ayudas gráficas y mucho más. La consola Qt puede usar cualquier kernel de Jupyter.
Conclusión
La entrada de hoy complementa la guía definitiva de DataCamp y repasa con más detalle la historia de los cuadernos computacionales, junto con algunas de las funciones principales tanto de IPython como de Jupyter, para entender mejor su evolución y diferencias. El objetivo era mostrar que, sin la perspectiva histórica de ambos proyectos, a veces es difícil trazar la línea que los separa. En algunos casos hay una zona gris, un «entre medias», que no se clasifica fácilmente.
