Glosario de funciones mágicas IPython

   

Funciones mágicas orientadas a líneas

A

%alias
Definir un alias para un comando del sistema.
   
%alias_magic
Crear un alias para una línea o una celda mágica: %alias_magic [-l] [-c] name target.
   
%autocall
Activar/Desactivar la escritura sin paréntesis cuando se invocan funciones, métodos...
   
%automagic
Activar/Desactivar la escritura del carácter inicial "%" en las funciones mágicas
   
%autosave
Establecer el intervalo de guardado automático en Notebook (en segundos).

B

%bookmark
Gestionar el sistema de marcadores a directorios de IPython.

C
   
%cd
Cambiar el directorio de trabajo actual.

%clear
Borrar la pantalla de la consola.

%colors
Cambiar el esquema de colores para los avisos, sistema de información y excepciones.

%config
Configurar IPython.

%connect_info
Imprimir la información para la conexión de otros clientes con este kernel.

D

%debug   
Depurar programas. %debug [--breakpoint FILE: LINE] [declaración [declaración …]].

%dhist
Imprimir el historial de directorios visitados.

%dirs
Mostrar la pila de directorios actual (gestionada con %pushd y con %popd).

%doctest_mode
Activar/Desactivar el modo doctest para que IPython se comporte como la shell Python.

E

%ed
Alias ​​para la función mágica %edit.

%edit
Abrir un editor y ejecutar el código introducido (después de guardar y salir).

%env
Listar variables de entorno. Genera un diccionario varent = %env | print(varent["HOME"])

G

%gui
Activar/Desactivar la integración del bucle de eventos de varios GUI para IPython.

%guiref
Mostrar una referencia básica sobre la consola gráfica (QT console).

H

%hist
Alias para la función mágica %history.

%history
Mostrar el historial de entradas (y de salidas).

I

%install_default_config
(Obsoleto). Usar: “ipython profile create <nombre>” para crear un nuevo perfil con las opciones predeterminadas.

%install_ext
Descargar e instalar una extensión desde una URL, por ejemplo.

%install_profiles
(Obsoleto). Usar: “ipython profile list” para ver perfiles disponibles; “ipython profile create <nombre>” para crear un nuevo perfil o ”ipython –profile=<nombre>” para comenzar la sesión con el perfil indicado

K

%killbgscripts
Matar todos los procesos en segundo plano iniciados por %%scripts y su familia.

L

%less
Mostrar el contenido de un archivo.

%load
Cargar código en la sesión actual. Ejemplo: %load -r 7 script.py (carga línea 7).

%load_ext
Cargar una extensión IPython por su nombre de módulo.

%loadpy
Alias de la función mágica %load.

%logoff
Detener temporalmente el registro de entradas (y salidas) en un archivo tipo LOG.

%logon
Reiniciar el registro de entradas (y salidas) en un archivo tipo LOG.

%logstart
Comenzar el registro de entradas (y salidas) en un archivo tipo LOG.

%logstate
Mostrar el estado del sistema de registro de entradas (y salidas).
   
%logstop
Detener totalmente el registro de las entradas (y salidas) en un archivo tipo LOG.

%lsmagic
Listar las funciones mágicas disponibles en IPython.

M

%macro
Definir una nueva macro. Acepta rangos del historial.

%magic
Mostrar información general sobre las funciones mágicas.

%man
Mostrar información de ayuda de un comando del sistema (de las páginas ”man”).

%matplotlib
Activar soporte para trabajar con el módulo matplotlib.

%more
Mostrar en pantalla el contenido de un archivo.

N

%notebook
Exportar historial para notebook o convertir cuadernos a otros formatos.

P

%page
Mostrar información de un objeto aplicando convenciones de estilos de formatos de texto (pretty printing).

%pastebin
Subir código al servicio Github's Gist paste bin, devolviendo la URL.
   
%pdb
Controlar la ejecución automática del depurador interactivo pdb.
   
%pdef
Mostrar definición de llamada de un objeto. Ejemplo: %pdef func_suma → func_suma(a, b)

%pdoc
Mostrar cadena de documentación de un objeto.

%pfile
Mostrar información del archivo donde se define un objeto.
   
%pinfo
Mostrar información detallada de un objeto.

%pinfo2
Mostrar información extra de un objeto.
   
%popd
Establecer como directorio de trabajo el primer directorio de la pila y suprimirlo de la pila.

%pprint   
Activar/Desactivar salida con convenciones de estilos de formato de texto (pretty printing).
   
%precision
Ajustar precisión decimal en la salida (pretty printing): Ejemplo: from math import pi; %precision 2; pi → 3,14

%profile
Mostrar perfil activo (obsoleto). Ahora usar: get_ipython().profile

%prun
Ejecutar una instrucción a través del generador de perfiles de código Python.

%psearch
Buscar objetos en el espacios de nombres utilizando el comodín "*"

%psource
Mostrar el código fuente de un objeto.

%pushd
Añadir a la pila de directorios el diresctorio actual y cambiar si se indica el directorio actual de trabajo
   
%pwd
Mostrar ruta del directorio actual de trabajo.

%pycat
Mostrar archivo resaltando con colores su sintaxis. Ejemplo %pycat script.py

%pylab
Cargar los módulos numpy/matplotlib para trabajar con datos y gráficos. %pylab [- no-import-all].

Q

%qtconsole
Abrir una nueva consola desde la consola QT actual.
   
%quickref
Mostrar ayuda de consulta rápida.

R

%recall
Seleccionar un comando anterior para ejecutarlo o editarlo.

%rehashx
Actualizar la tabla de alias con todos los archivos ejecutables accesibles desde $PATH.

%reload_ext
Actualizar una extensión IPython por su nombre de módulo.

%rep
Alias de la función mágica %recall.

%rerun
Volver a ejecutar una entrada anterior.

%reset
Restablecer espacio de nombres eliminando todos los nombres definidos por el usuario.

%reset_selective
Restablecer espacio de nombres eliminando nombres definidos por el usuario.

%run
Ejecutar un archivo desde IPython. Ejemplo: %run programa.py.

S

%save
Guardar un conjunto de líneas o una macro en un archivo.

%sc
Ejecutar comando del sistema y capturar salida. %sc -l myfiles = ls.

%store
Persistencia ligera en variables de Python. Ejemplo %store var (guarda variable) y para usar en otra sesión: %store -r; print(var)

%sx
Ejecutar comando de la shell y capturar su salida.
   
%system
Ejecutar comando de la shell y capturar su salida.

T

%tb
Mostrar información de rastreo de la última excepción producida.

%time
Medir el tiempo en ejecutarse una sentencia o expresión Python.

%timeit
Medir el tiempo en ejecutarse una sentencia o expresión Python.

U

%unalias
Suprimir un alias de la tabla de alias.

%unload_ext
Descargar una extensión IPython por su nombre de módulo.

W

%who
Mostrar el nombre de todas las variables.

%who_ls
Mostrar una lista ordenada con todas las variables.

%whos
Mostrar una tabla con información detallada de todas las variables.

X

%xdel
Eliminar una variable, tratando de borrarla de cualquier lugar.

%xmode
Cambiar modos para control de excepciones.
       

Funciones mágicas orientadas a celdas

       
%%!
Ejecutar comando de la shell y capturar su salida.

%%HTML
Alias para la función %%HTML.

%%SVG
Alias para la función %%svg.

%%bash
Función mágica pare escribir y ejecutar scripts bash.

%%capture
Ejecutar celda y capturar salida estándar/error: %capture [--no-stderr] [--no-stdout] [out].

%%debug
Depurar código %debug [--breakpoint FILE: LINE] [declaración [declaración …]].
   
%%file
Alias de la función mágica %%writefile.

%%html
Tratar la celda como un bloque de código HTML

%%javascript
Ejecutar en la celda código Javascript.

%%latex
Tratar la celda como un bloque latex.

%%perl
Ejecutar en la celda código Perl.

%%prun
Ejecutar una declaración a través del generador de perfiles de código Python.

%%pypy
Ejecutar un script Pypy.

%%python
Ejecutar un script Python.

%%python3
Ejecutar un script Python3.

%%ruby
Ejecutar un script Ruby.

%%script
Ejecutar un script %shebang [--proc PROC] [--bg] [--err ERR] [--out OUT].

%%sh
Ejecutar un script sh.

%%svg
Tratar la celda como un literal SVG.

%%sx
Ejecutar comando de la shell y capturar su salida.

%%system
Ejecutar comando de la shell y capturar su salida.

%%time
Medir el tiempo de ejecución de una sentencia o expresión Python.

%%timeit
Medir el tiempo de ejecución de una sentencia o expresión Python.

%%writefile
Escribir el contenido de la celda a un fichero. %%writefile [-a] archivo.


Ir al índice del tutorial de IPython

Administrar sistemas con IPython

Una de la características importantes que tiene la consola IPython es su capacidad de ejecutar, además de código Python, comandos del sistema operativo, programas externos y scripts escritos en otros lenguajes; evitándonos  tener que utilizar otras consolas al mismo tiempo

Además de lo comentado, el hecho de permitir personalizar ampliamente su funcionamiento convierte a IPython en una herramienta interesante para cualquier persona que administre los sistemas de una empresa.

En ese caso el técnico contará con la inestimable ayuda de las funciones mágicas de IPython que podrán crecer en número con el transcurso del tiempo. También, probablemente, será recurrente el uso de la función mágica %alias para acortar los comandos más utilizados y el desarrollo y ejecución de scripts propios que resuelvan las tareas más comunes.

Un caso práctico de personalización básica

Para personalizar el entorno de trabajo podemos utilizar los distintos archivos de configuración que se guardan en un perfil IPython e incorporar uno o más archivos al directorio "startup" (que se encuentra también dentro del perfil) para que se ejecuten antes de comenzar una sesión de trabajo.

- Ejemplo de archivo "ipython_config.py":

c = get_config()

c.TerminalIPythonApp.display_banner = False
c.InteractiveShellApp.hide_initial_ns = False

En este ejemplo básico de archivo "ipython_config.py" se desactiva la visualización de la ayuda que se muestra al principio de una sesión IPython (display_banner = False) y si se declaran variables en un archivo ejecutable de la carpeta "startup" estarán visibles y podrán utilizarse libremente en nuestros comandos o scripts (hide_initial_ns = False).

(En el sitio oficial de IPython podrá obtenerse ayuda de muchas opciones de configuración del archivo "ipython_config.py" y de otros archivos que configuran la consola QT y Notebook).


- Ejemplo de archivo ejecutable "inicio.ipy" para la carpeta "startup":

# coding: utf-8

# Carga de módulos

import IPython
import sys

# Declaración de variables

dominio = "and.empresa.es"
equipo = "eq99999"
usuario = "us123"
grupo = "servidores"
mensaje = "mensaje"
sesion = "1"

# Personalización de la pantalla inicial

get_ipython().magic('%cls')
print("IPython: ", IPython.__version__, " - ", "Python: ", sys.winver)
print("Python 3 para impacientes - Sistemas\n")
print("Directorio actual: ")
get_ipython().magic('%alias scripts dir *.py *.cmd')
get_ipython().magic('%cd c:\\usuario/Scripts-Ipython/')
get_ipython().magic('%pwd')

Al principio del archivo "inicio.ypi" se importan los módulos IPython y sys; después se declaran algunas variables y, finalmente, se personaliza la pantalla inicial de la consola. Para esto último se realiza antes un borrado de la pantalla y a continuación se muestran, a título informativo, las versiones instaladas de Python y IPython.

Después, se define el alias "scripts" que listará, cuando lo ejecutemos, los archivos .py/.cmd; y para finalizar se cambia el directorio de trabajo predeterminado y se muestra su ruta en pantalla.

Ejecución de comandos y scripts

A partir de este momento cada vez que iniciemos una sesión de trabajo con la consola IPython se interpretarán las opciones del archivo de configuración "ipython_config.py" y se ejecutarán las líneas del archivo "inicio.ipy", visualizándose en pantalla la siguiente información:

La consola quedará lista para ejecutar cualquier comando o script que precisemos que, además, podrán incluir las variables que se declararon en el archivo "inicio.ipy". Para mostrar las variables utilizaremos las funciones mágicas %who y %whos: la primera presentará la lista de variables disponibles y %whos ampliará la información mostrando el tipo y el valor de cada una de ellas:

Ejemplos de comandos que usan las variables de inicio.ipy

1) Mostrar información de la memoria del equipo "servidor01":

: equipo = "servidor01"
: !systeminfo /S $equipo | grep "Memory"


2) Mostrar las sesiones de Escritorio Remoto abiertas en "servidor02":

: equipo = "servidor02"
: !qwinsta /SERVER:$equipo


3) Mostrar información de Active Directory de la cuenta de equipo "cd01":

: equipo = "cd01"
: !dsquery computer -name $equipo -domain $dominio | dsget computer

En este caso se utiliza la variable $dominio con el valor por defecto.


4) Listar software del equipo anterior:

: !wmic /node:$equipo product get name,version

Ejemplos de scripts que utilizan las variables de inicio.ipy

1) Script para mostrar grupos del usuario "usuario1" de Active Directory:

(grupos.py):

get_ipython().system('echo Grupos:')

info='echo dsquery user -name $usuario -domain $dominio -limit 0'
info+= '; dsget user -memberof -L'
get_ipython().system(info)

comando='dsquery user -name $usuario -domain $dominio -limit 0'
comando+=' | dsget user -memberof -L'
get_ipython().system(comando)

Para ejecutar el script:

: usuario = "usuario01"
: run grupos.py


2) Enviar un mensaje a todos los usuarios conectados al servidor "aplicacion01":

(mensaje.py):

get_ipython().system('echo Enviar mensaje a usuarios conectados:')
get_ipython().system('echo msg * /SERVER:$equipo /V $mensaje')
get_ipython().system('msg * /SERVER:$equipo /V $mensaje')
get_ipython().system('echo.')

Para ejecutar el script:

: equipo = "aplicacion01"
: mensaje = "El servidor se apagará en 30 m."
: run mensaje.py

Ejecutar scripts en otros lenguajes

IPython cuenta con funciones mágicas orientadas a celdas que permiten la escritura y ejecución de scripts en otros lenguajes como Perl, Ruby, Javascript, etc.

1) El siguiente ejemplo escrito en lenguaje Perl lee todas las líneas que contiene un archivo de texto y las muestra en pantalla. 


: %%perl
: $fich = "archivo.txt";
: open(DATA, $fich) || die "no se puede abrir";
: @lineas = <DATA>;
: print @lineas;
: close(DATA);
:

2) Para concluir el script Perl que sigue lee las líneas del archivo "entrada.txt" y si comienzan por la palabra "ERROR" las imprime por pantalla.

: %%perl
: my $ent="entrada.txt";
: open (ENTRADA,"<$ent") || die "no se puede abrir";
: while (<ENTRADA>)
: {
: print if /^ERROR/;
: }
: close (ENTRADA);
:


Ir al índice del tutorial de IPython

Gráficos en IPython

Unos de los motivos que inspiraron el desarrollo de IPython fue contar con una herramienta que uniera la posibilidad de realizar cálculos avanzados con la obtención de representaciones gráficas de los propios datos que facilitaran su análisis.

IPython utiliza Pylab para realizar los gráficos. Pylab es una API para Python de la biblioteca gráfica Matplotlib (matplotlib.pyplot) que utiliza Numpy, un módulo matemático que añade funciones para operar con vectores o matrices.

Para trabajar con representaciones gráficas de datos tenemos varias posibilidades con IPython:

Iniciar la consola interactiva y el interfaz gráfico orientado a objetos:

$ ipython3 --pylab

Iniciar la consola interactiva QT y el interfaz gráfico oriento a objetos:

$ ipython3 qtconsole --pylab

Iniciar Jupyter Notebook y el interfaz gráfico orientado a objetos:

$ jupyter notebook 

En un cuaderno utilizar las funciones `%pylab` o  `%matplotlib`.

Cuando Notebook formaba parte de Ipython:

$ ipython3 notebook

A continuación, se muestran una serie de ejemplos que pretenden ilustrar la forma de trabajar con gráficos en IPython y Jupyter.

En primer lugar iniciaremos la consola con:

$ ipython3 --pylab

El argumento --pylab hace que al iniciar la sesión se carguen los módulos matplotlib.pylab y NumPy con los alias mpl y np, respetivamente. Para obtener ayuda de estos módulos en IPython:

: numpy? ó numpy??
: pylab? ó pylab??

Dibujar un gráfico de líneas

El siguiente ejemplo crea un gráfico a partir de una lista de valores. En el eje "x" se representan 8 elementos numerados del 0 al 7 y en el eje "y" los valores de cada uno de ellos siguiendo el orden de la lista.

: lista1 = [11,2,3,15,8,13,21,34]   # Declara lista1 con 8 valores
: plt.plot(lista1)   # Dibuja el gráfico
: plt.title("Título")   # Establece el título del gráfico
: plt.xlabel("abscisa")   # Establece el título del eje x
: plt.ylabel("ordenada")   # Establece el título del eje y

Este tipo de gráficos pueden crearse también con el intérprete interactivo de Python si se importan los módulos adecuados. Hay dos modos de hacerlo:

>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> lista1 = [11,2,3,15,8,13,21,34]
>>> plt.plot(lista1)
>>> plt.show()

o bien,

>>> from pylab import *
>>> lista1 = [11,2,3,15,8,13,21,34]
>>> plt.plot(lista1)
>>> plt.show()

En el ejemplo anterior aunque se importa el módulo Numpy no es necesario porque no se utiliza. Se incluye la línea porque dicho módulo suele usarse con frecuencia cuando se trabaja con gráficos.

Activar y desactivar el modo interactivo de dibujo

A continuación, se utilizan los métodos ion() y ioff() que activan o desactivan el modo interactivo de dibujo para añadir, o no, nuevos datos sobre el gráfico actual. 

: lista1 = [11,2,3,15,8,13,21,34]   # Declara lista1 con 8 valores
: plt.plot(lista1)   # Dibuja el gráfico
: plt.xlabel("abscisa")   # Inserta el título del eje X
: plt.ylabel("ordenada")   # Inserta el título del eje Y
: plt.ioff()   # Desactiva modo interactivo de dibujo
: lista2 = [2,3,4,2,3,6,4,10]   # Declara lista2 con 8 valores
: plt.plot(lista2)   # No dibuja datos de lista2
: plt.ion()   # Activa modo interactivo de dibujo
: plt.plot(lista2)   # Dibuja datos de lista2 sin borrar datos de lista1

Para conocer en un momento dado qué modo está activo:

: plt.isinteractive()   # La función devolverá True o False

Los métodos show() o draw() fuerzan que la información se muestre en el gráfico (datos, títulos, etiquetas, etc.) aunque el modo interactivo esté desactivado: 

: plt.ioff()   # Desactiva modo interactivo
: lista3 = [9,15,9,15,9,15,9,15]   # Declara lista3 con 8 valores
: plt.plot(lista3)   # No dibuja datos de lista3
: plt.show()   # Fuerza dibujo de datos de lista3
: plt.title("Gráfica")   # Establece nuevo título pero no muestra en gráfico
: plt.show()   # Actualiza gráfico con nuevo título
: plt.grid(True)  # Activa cuadrícula del gráfico pero no se muestra
: plt.show()   # Muestra cuadrícula del gráfico
: plt.ion()   # Activa modo interactivo de dibujo

Añadir leyendas a un gráfico

Para añadir leyendas al gráfico anterior asignar al parámetro "label=" de plot() el literal de la leyenda a mostrar. Y después, ejecutar el método legend().

: plt.plot(lista1, label = "Enero")
: plt.plot(lista2, label = "Febrero")
: plt.plot(lista3, label = "Marzo")
: plt.legend()

Posición de leyendas (loc=):

• upper, arriba
• lower, abajo
• center, centro
• left, izquierda y 
• right, derecha

Para colocar la leyenda en la parte superior del gráfico y a la izquierda:

: plt.legend(loc="upper left") 

Cambiar estilos de línea, marcadores y colores de un gráfico

Para dar claridad a los gráficos pueden establecerse distintos estilos de líneas, marcadores y colores:

Estilos de Líneas (linestyle=):

• -, Línea Sólida
• --, Línea discontinua
• :, Línea punteada
• -., Línea punteada discontinua. y
• None, Ninguna línea

Marcadores (marker=):

• +, Cruz
• ., Punto
• o,Círculo
• *, Estrellas
• p, Pentágonos
• s, cuadrados
• x, Tachados
• D, Diamantes
• h, Hexágonos y
• ^, Triángulos

Colores (color=):

• b, blue
• g, green
• r, red
• c, cyan
• m, magenta
• y, yellow
• k, black
• w, white

Ejemplo:

: plt.plot(lista1, marker='x', linestyle=':', color='b', label = "Enero")
: plt.plot(lista2, marker='*', linestyle='-', color='g', label = "Febrero")
: plt.plot(lista3, marker='o', linestyle='--', color='r', label = "Marzo")
: plt.legend(loc="upper left")

También, es posible cambiar las fuentes de los textos, los grosores de las líneas y otras propiedades que modifican el aspecto de un gráfico.

Añadir rótulos a los ejes

En el siguiente ejemplo se crea un gráfico nuevo con el método figure() donde se representa sólo una lista de valores y se definen los rótulos de los ejes.

: plt.figure()  # Comenzamos un nuevo gráfico (figura)
: lista1 = [11,2,3,15,8,13,21,34]
: plt.title("Título")
: plt.xlabel("abscisa")
: plt.ylabel("ordenada")
: indice = np.arange(8)   # Declara un array
: plt.xticks(indice, ("A", "B", "C", "D", "E", "F", "G", "H"))  
: plt.yticks(np.arange(0,51,10))
: plt.plot(lista1)

Se han generado dos arrays con la funcion arange() del módulo Numpy con los siguientes valores:

- El array que se obtiene con np.arange(8) contiene los siguiente valores:

array([0, 1, 2, 3, 4, 5, 6, 7])

- El array que se obtiene con np.arange(0,51,10) contiene los siguiente valores:

array([ 0, 10, 20, 30, 40, 50])

Los arrays se utilizan para definir los rótulos que se mostrarán en ambos ejes. En el eje "x" el valor del índice es sustituido por un carácter alfabético y en el eje "y", directamente, se muestran en la escala los valores del propio array. 

   

Trabajar con varios gráficos

- Activar gráfico por su número:

Si estamos trabajando con varios gráficos a la vez para activar uno concreto indicaremos el número que aparece en su barra de título. Cualquier acción que se realice a continuación se hará sobre dicho gráfico: plt.figure(Numero)

Ejemplo:

: plt.figure()   #  Añade un nuevo gráfico y lo activa
: x = linspace(2,8,4)   # devuelve -> array([ 2.,  4.,  6.,  8.])
: y = x ** 2
: plt.plot(x, y, "r")
: plt.xlabel("x")
: plt.ylabel("y")
: plt.title("Grafico")
: plt.figure(1)   # Activa el gráfico 1
: plt.title("Título")   # Cambia el título del gráfico 1


- Activar gráfico por su nombre:

Cuando se trabaja con varios gráficos, otra posibilidad de activar un gráfico determinado es referirse a su nombre:

: plt.figure('Regiones')
: plt.figure('Dispersión')
: elementosx = np.random.rand(10)   # Genera array 10 elementos eje x
: elementosy = np.random.rand(10)   # Genera array 10 elementos eje y
: plt.scatter(elementosx, elementosy)
: plt.figure('Regiones')
: plt.plot(elementosx,elementosy)

- Generar dos gráficos en la misma ventana:

Dividir la ventana en 1 fila x 2 columnas y dibujar primer gráfico

: plt.subplot(1,2,1)
: plt.plot((1,2,3,4,5))

Dividir la ventana en 1 fila x 2 columnas y dibujar segundo gráfico

: plt.subplot(1,2,2)
: plt.plot((5,4,3,2,1))

Continuar "dibujando" o reiniciar el gráfico

Con el método hold() se conmutan dos estados: uno para continuar "dibujando" (True) sobre un gráfico y otro para reiniciar el gráfico (False).

: plt.hold()   # Conmutar de True a False y de False a True

Para comprobar el estado en un momento dado:

: plt.ishold()   # devuelve -> True / False

Borrar un gráfico. Borrar los ejes. Cerrar un gráfico

El método cla() borra toda la información relacionada con los ejes de un gráfico y el método clf() borra todo el gráfico. Por otro lado, close() termina el gráfico cerrando su ventana.

: plt.cla()   # Borrar información de los ejes
: plt.clf()   # Borrar un gráfico completo
: plt.close()   # Terminar un gráfico

Guardar un gráfico como .png/.pdf

Para guardar la imagen de un gráfico en un archivo:

: savefig("archivo.png")   # Guardar en formato .png
: savefig("archivo.pdf")   # Guardar en formato .pdf

Dibujar un gráfico de barras horizontales

: paises = ("Alemania", "España", "Francia", "Portugal")
: posicion_y = np.arange(len(paises))
: unidades = (342, 321, 192, 402)
: plt.barh(posicion_y, unidades, align = "center")
: plt.yticks(posicion_y, paises)
: plt.xlabel('Unidades vendidas')
: plt.title("Ventas en Europa")

Dibujar un gráfico de mútiples barras verticales

: datos = [[1, 2, 3, 4], [3, 5, 3, 5], [8, 6, 4, 2]]
: X = np.arange(4)
: plt.bar(X + 0.00, datos[0], color = "b", width = 0.25)
: plt.bar(X + 0.25, datos[1], color = "g", width = 0.25)
: plt.bar(X + 0.50, datos[2], color = "r", width = 0.25)
: plt.xticks(X+0.38, ["A","B","C","D"])

Dibujar un gráfico circular

: impr = ["b/n", "color", "dúplex", "A3"]
: vol = [25, 31, 46, 10]
: expl =(0, 0.05, 0, 0)
: pie(vol, explode=expl, labels=impr, autopct='%1.1f%%', shadow=True)
: plt.title("Impresión", bbox={"facecolor":"0.8", "pad":5})
: plt.legend()

Relacionado:

• Gráficos con GooPyCharts

Ir al índice del tutorial de IPython

Jupyter Notebook, la aplicación web

Jupyter Notebook es la herramienta que permite crear o utilizar cuadernos de trabajo en un navegador web. En un cuaderno de trabajo es posible combinar la ejecución de código con textos, cálculos matemáticos, representaciones gráficas y elementos multimedia.

Para facilitar el intercambio de información entre usuarios los cuadernos podrán convertirse a otros formatos extendidos tales como HTML, PDF. etc. Además, podrán compartirse mediante el visor NBViewer.

Iniciar Jupyter Notebook

Para iniciar Notebook desde la línea de comandos:

$ jupyter notebook


A continuación, se pondrá en funcionamiento un servidor web y se ejecutará el navegador web que tengamos instalado por defecto (podrá ser Firefox, Opera o Chrome) y dentro de éste se abrirá la página del panel de control o Dashboard de Jupyter Notebook.

En la página del panel de Notebook se listará el contenido del directorio de trabajo actual y se mostrará en la parte superior un menú con las opciones siguientes: "Notebooks", "Running" y "Clusters".

• La pestaña "Notebooks" la utilizaremos para crear, abrir, importar o borrar cuadernos de trabajo, que podrán organizarse en distintos directorios del sistema.

• "Running" para detener los cuadernos en ejecución, comprobar su estado o para iniciar nuevas instancias de los mismos.

• Y la pestaña "Clusters" se utilizará con trabajos de computación paralela atendiendo a los perfiles disponibles en nuestra instalación IPython.

Crear o abrir un cuaderno de trabajo

Para crear un cuaderno de trabajo haremos clic en el botón “New Notebook” y para abrir uno existente accederemos al directorio donde esté almacenado y haremos clic sobre el nombre del archivo.

A continuación, se creará un cuaderno nuevo, o bien, se cargará la información del cuaderno que hayamos seleccionado previamente.

Si el cuaderno es nuevo la aplicación le asignará un nombre predeterminado como "Untitled1.ipynb" y lo guardará en el directorio actual. Dicho nombre podrá cambiarse por otro haciendo clic sobre él en el mismo encabezado del cuaderno o en la opción "Rename..." del menú "File".

En la parte superior del cuaderno, después del encabezado, se sitúan la Barra de menú y la Barra de herramientas con las opciones de uso más frecuente.

Y justamente debajo tendremos la primera celda o área de entrada (etiquetada con el término "In") que es el lugar donde empezaremos a escribir nuestro cuaderno de trabajo.

Introducir información en una celda

¿Qué tipo de información podemos introducir en una celda?

Básicamente, se podrá introducir lo mismo que en una sesión interactiva con la consola IPython (código Python, funciones mágicas IPython, comandos del sistema, etc.); además de otro tipo de información usando el lenguaje de marcado ligero Markdown (como textos con formato, imágenes y archivos multimedia); gráficos creados a partir de datos; textos de encabezamientos de distintos tamaños y comandos para convertir la información a otros formatos.

Es necesario diferenciar entre el modo Edición y el modo Comando. El modo Edición se activa al hacer clic o [Enter] sobre una celda seleccionada (La celda seleccionada es la que está rodeada por el marco rectangular). Una celda activa mostrará un cursor vertical "|" para indicar el lugar de edición.

El modo Comando se activa cuando hacemos clic fuera del área de la celda que estemos editando o al presionar la tecla [Esc].

En una celda se podrán escribir una o más líneas. Cuando se esté editando se avanzará a la siguiente línea con la tecla [Enter] y cuando existan varias líneas podremos retroceder a la línea anterior con la tecla [Flecha Arriba] o avanzar a la línea siguiente con [Flecha Abajo].

Ejecutar una celda

Para ejecutar la celda activa pulsaremos [Ctrl+Enter]. Si además deseamos que se inserte una celda nueva después de la ejecutada utilizaremos [Alt+Enter] o si queremos seleccionar la siguiente celda después de la ejecución presionaremos [Mayúsculas+Enter].

Guardar un cuaderno

Los cuadernos de Notebook se guardan automáticamente.

Sin embargo, si queremos guardar el trabajo en un punto determinado y continuar trabajando contando con la posibilidad de revertir a la situación anterior, guardaremos con la opción "Save and Checkpoint" y regresaremos al punto inicial con la opción "Revert to Checkpoint". Estas opciones se encuentran en el menú "File".

Copiar un cuaderno

También, tendremos la posibilidad de trabajar con una copia exacta del cuaderno actual si elegimos la opción "Make a Copy..." del menú "File". Es un modo rápido de obtener distintas versiones de un mismo cuaderno.

Cerrar un cuaderno y salir

Para terminar la sesión de trabajo seleccionaremos la opción "Close and Halt" del menú "File".

En el menú "Help" la opción "User Interface Tour" explica brevemente haciendo un tour el funcionamiento del interfaz de usuario y en "Keyboard Shorcuts" consultaremos las teclas de acceso rápido de Notebook.


Ir al índice del tutorial de IPython

Editar y depurar scripts en IPython

Salvar y ejecutar código

La función %save almacena entradas en un archivo que puede ser ejecutado en cualquier momento con la función %run. Después de ejecutar el script se cargarán todos sus objetos (variables, listas, tuplas, funciones, etc.) en el espacio de nombre IPython.

Ejemplo:

In [1]: a = int(input("Unidades: "))
Unidades :5

In [2]: b = int(input("Precio: "))
Precio :10

In [3]: print("A pagar: ", a * b)
A pagar 50

Para salvar las entradas anteriores en un archivo indicaremos el nombre del archivo y las entradas desde-hasta a almacenar:

In [4]: %save script-01.py 1-3
The following commands were written to file `script-01.py`:
a = int(input("Unidades :"))
b = int(input("Precio :"))
print("A pagar", a*b)

Para ejecutar el código del script "script-01.py".

%run script-01.py

La función %run tiene parámetros especiales para medir el tiempo de ejecución de los scripts (-t), para depurar (-d) y para generar perfiles (-p).

Editar código

La función %edit permite editar scripts en nuestro editor favorito. Después de guardar IPython ejecutará inmediatamente el código editado.

%edit script-01.py

Por defecto, en GNU/Linux se utilizará el editor "vi" y en Windows "notepad" aunque en ambos casos pueden cambiarse por otro que nos resulte más cómodo.

El editor "vi" es un editor bastante completo pero para su uso es necesario conocer una lista de comandos. Si estamos intentando editar en GNU/Linux y se ha iniciado "vi": para salir sin guardar, teclear:

:q! (escribir dos puntos, "q" y el signo de cierre de admiración "!")

Para cambiar el editor por defecto en GNU/Linux por "nano", "leafpad", "gedit" u otro que sea más manejable, declarar desde la consola la siguiente variable:

export EDITOR=nano

Después, si accedemos a IPython y utlizamos la función %edit editaremos de forma más cómoda los scripts. Si se desea hacer permanente este cambio se puede incluir la línea en el archivo .bashrc del usuario que se encuentra en /home/usuario/.bashrc

Para cambiar el editor por defecto en Windows declarar la variable EDITOR en la consola con el nombre del ejecutable de nuestro editor favorito:

set EDITOR=mieditor.exe

Para que sea permanente crear la variable de entorno EDITOR en Configuración del Sistema, en Propiedades del Equipo y añadir también la ruta del ejecutable a la variable de entorno PATH.

Depurar código

Después de que se produzca una excepción se puede llamar a la función %debug para utilizar el depurador Python (pdb) y examinar el origen del problema. Alternativamente, se puede usar la función mágica %pdb para depurar los scripts. Entre otras opciones permite mostrar el valor de variables, visualizar el código, ejecutar sentencias y rastrear hacía adelante o atrás el origen de un problema.

Puede ser una forma eficiente de depurar código, permitiendo eliminar en muchos casos la necesidad de mostrar el resultado de sentencias o recurrir a herramientas externas.

También, se puede examinar la ejecución de un programa desde el comienzo con:

%run -d programa.py

Medir el tiempo de ejecución

En el ejemplo siguiente se crea una función Python que es ejecutada con la función mágica %timeit para medir el tiempo de ejecución.

In: def imprime(numero):
    for elemento in range(numero):
        print(elemento)

In: %timeit imprime(100)

Relacionado:

• Solucionando errores con el depurador
• El depurador PuDB
• Facilitando la depuración de programas con breakpoint()

Ir al índice del tutorial de IPython

Registrar y ejecutar sesiones de IPython

Registrar una sesión de trabajo

Es posible registrar todas las entradas (y salidas) de una sesión en un archivo "LOG" añadiendo al ejecutable "ipython" el argumento "--logfile=archivolog", o bien, activando dicho registro durante una sesión interactiva con la función mágica %logstart.

Un archivo "LOG" puede ser ejecutado cuando se deseen repetir los mismos comandos de una sesión anterior.

Para activar el registro de entradas durante una sesión de trabajo:

: %logstart -o [nombrearchivolog] [modo]

• La opción "-o" hará que se registren también las salidas. 
• Si no se especifica nombre de archivo se utilizará el nombre predeterminado "ipython_log.py" y será almacenado en el directorio actual con el modo "rotate" activado por defecto.
• Si se especifica un nombre de archivo se almacenará en el directorio actual usando el modo "backup".

Modos de registro:

• over: Sobreescribir el archivo de log.
• backup: Renombrar (si existe) a log_name~ y comenzar un nuevo archivo log_name.
• append: Añadir la información al archivo existente.
• rotate: Crear "LOGs" numerados con la información de sesiones anteriores.

Ejemplo:

: %logstart sesion-01.ipy  # Comenzará el registro en modo backup

Detener y reanudar el registro

Las funciones %logoff y %logon permiten detener temporalmente y reanudar el registro en un archivo que previamente se había iniciado con la función %logstart. Con la función %logstop terminaremos definitivamente el registro y con la función mágica %logstate podremos consultar en cualquier momento el estado del registro.


Para detener el registro temporalmente:

: %logoff

Para iniciar de nuevo el registro:

: %logon

Para detener el registro definitivamente y cerrar el archivo LOG:

: %logstop
 
Para consultar el estado del registro:

: %logstate

Ejemplo:

In [1]: %logstart sesion-01.ipy
Activating auto-logging. Current session state plus future input saved.
Filename       : sesion-1.py
Mode           : backup
Output logging : False
Raw input log  : False
Timestamping   : False
State          : active

In [2]: !ls *.ipy
total 1
-rw-rw-r-- 1 usuario usuario  238 jul 22 23:21 sesion-1.ipy


In [3]: %pwd
Out[3]: '/home/usuario/Local'

In [4]: %logstop

In [5]: %logstate
Logging has not been activated.


Contenido del archivo de registro "sesion-1.ipy":

# IPython log file

get_ipython().magic('logstart sesion-1.ipy')
get_ipython().system('ls *.ipy')
get_ipython().magic('pwd')
get_ipython().magic('logstop')

Editar y Ejecutar un archivo de LOG

Para ejecutar un archivo de "LOG" lo primero que debemos hacer es editar su contenido para suprimir aquellas líneas que no sean necesarias y cambiar lo que consideremos oportuno.

Para editar un archivo y ejecutar su contenido inmediatamente después:


: %edit sesion-01.ipy

En un equipo con GNU/Linux se editarán los archivos con el editor "vi". Si no conoce los comandos de este editor puede cambiarlo por otro que le resulte más cómodo: Ver Editar y depurar scripts en IPython.

Para ejecutar un archivo directamente:

: %run sesion-01.ipy

Ir al índice del tutorial de IPython

Explorar objetos en IPython

Desde el primer momento la ayuda de IPython nos muestra cómo consultar información de un objeto. Lo más frecuente es escribir el nombre del objeto precedido o seguido de uno o dos signos de interrogación:

: objeto?    # Mostrar información de un objeto

: objeto??   # Mostrar además código fuente si es posible

Sin embargo, para obtener información específica de un objeto podemos utilizar las funciones mágicas: %pdoc, %pdef, %psource y %pfile.

Mostrar documentación

Mostrar cadena de documentación o texto de ayuda de un objeto: %pdoc objeto

: import sys

: %pdoc sys

Class docstring:
    This module provides access to some objects used or maintained by the
    interpreter and to functions that interact strongly with the interpreter.

    Dynamic objects:

    argv -- command line arguments; argv[0] is the script pathname if known
    path -- module search path; path[0] is the script directory, else ''
    modules -- dictionary of loaded modules

    ...

    ...

Mostrar línea de definición

Mostrar la línea de definición de un objeto que se pueda invocar: %pdef objeto (Si el objeto es una clase mostrará la información del constructor).

: %pdef alias

alias(self, parameter_s='')

: %pdef writefile

writefile(self, line, cell)

: %pdef sys

Object is not callable.

Mostrar código fuente

Para mostrar si es posible el código fuente de un objeto: %psource objeto

: %psource lsmagic

    @line_magic

    def lsmagic(self, parameter_s=''):

        """List currently available magic functions."""

        return MagicsDisplay(self.shell.magics_manager)

Mostrar archivo de código fuente

Para mostrar el archivo de código fuente completo en el que se define un objeto, abriéndolo en la línea donde empieza su definición: %pfile objeto

: %pfile lsmagic

"""Implementation of basic magic functions.

"""

#-----------------------------------------------------------------------------

#  Copyright (c) 2012 The IPython Development Team.

#

#  Distributed under the terms of the Modified BSD License.

#

#  The full license is in the file COPYING.txt, distributed with this software.

#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------

# Imports

#-----------------------------------------------------------------------------

# Stdlib

import io

import json

import sys

from pprint import pformat

...

...

Mostrar información de los identificadores: %who / %whos

Las funciones mágicas %who / %whos proporcionan información sobre identificadores (de variables, listas, módulos, etc.) que se han definido o cargado de forma interactiva en una sesión de trabajo (no sobre lo que se ha definido o cargado de los archivos de configuración).

%who sólo visualizará la lista actual de identificadores mientras que %whos ampliará la información mostrando una tabla con algunos detalles básicos de cada identificador.

: %who

cadena     cadena2     iva     lista     math     os     sys   

: %whos

Variable   Type      Data/Info

--------------------------------

cadena     str       Andalucía

cadena2    bytes     b'Andaluc\xa1a'

iva        int       22

lista      list      n=11

math       module    <module 'math' (built-in)>

os         module    <module 'os' from '/usr/lib/python3.4/os.py'>

sys        module    <module 'sys' (built-in)>

Variables de entorno

Las variables de entorno pueden capturarse en una sesión de trabajo (de una vez) con la función mágica %env. Esta función devuelve un diccionario que contiene todas las variables de entorno con sus valores. Para acceder al valor de una variable utilizaremos como clave su propio nombre.

: variables = %env

: variables?        # Es un diccionario con las variables de entorno

Type:       dict

...

: variables

{'CLICOLOR': '1',

 'CLUTTER_IM_MODULE': 'xim',

 'DBUS_SESSION_BUS_ADDRESS': 'unix:abstract=/tmp/dbus-cdk72jbhpm',

 'DEFAULTS_PATH': '/usr/share/gconf/xubuntu.default.path',

 'DESKTOP_SESSION': 'xubuntu',

 'DISPLAY': ':0.0',

 'GDMSESSION': 'xubuntu',

 'GDM_LANG': 'es_ES',

 etc...

: variables["LOGNAME"]

'antonio'

: variables["SHELL"]

'/bin/bash'

 Ir al índice del tutorial de IPython

Historial de entradas y salidas en IPython

Durante una sesión de trabajo IPython almacena tanto los comandos introducidos en las líneas de entrada "In" como los resultados que se originan en las líneas de salida "Out".

Como ya tratamos en el capítulo de "Facilidades para la escritura" con las teclas de [Fecha arriba] y [Flecha abajo] accedemos al historial de entradas asociado al usuario actual.

Accediendo al historial de la sesión actual

Mientras trabajamos IPython va numerando secuencialmente las entradas "In" y las salidas "Out". Debemos tener en cuenta que "In" es una lista y "Out" un diccionario Python y ambos objetos podemos referenciarlos por su nombre y un número de secuencia:  In[Número] y Out[Número].

Ejemplos:

In [1]: 1 + 3
Out[1]: 4

In [2]: Out[1]
4

In [3]: In[1]
1 + 3

Otras modos de acceder al historial:

Acceder al valor de la última, penúltima y antepenúltima entrada: _i, _ii, _iii, respectivamente:

In [4]: _iii
Out[4]: '1 + 3'

Mostrar todas las entradas del historial de la sesión actual: In ó _ih

In [5]: In
Out[5]: ['', '1 + 3', 'Out[1]', 'In[1]', '_iii', 'In']

Mostrar una entrada por su número: _iNúmero ó _ih[Número]

In [6]: _i4
Out[6]: '_iii' 

Acceder al valor de la última, penúltima y antepenúltima salida, introducir uno, dos o tres guiones bajos (_, __, ___), respectivamente:

In [7]: __
Out[7]: ['', '1 + 3', 'Out[1]', 'In[1]', '_iii', 'In', '_i4', '__']

Mostrar una salida por su número: _Número

In [8]: _6
Out[8]: '_iii'

Mostrar todas las salidas del historial de la sesión actual: Out ó _oh

In [9]: Out
{1: 4,
 2: 4,
 3: '1 + 3',
 4: '1 + 3',
 5: ['', '1 + 3', 'Out[1]', 'In[1]', '_iii', 'In', '_i4', '__', '_6', 'Out'],
 6: '_iii',
 7: ['', '1 + 3', 'Out[1]', 'In[1]', '_iii', 'In', '_i4', '__', '_6', 'Out'],
 8: '_iii'}

Accediendo al historial de cualquier sesión

La función mágica %history se utiliza también para mostrar el historial de entradas y salidas, permitiéndonos acceder a los historiales de sesiones anteriores . A continuación, se muestran varios ejemplos de uso.

: %hist o %history [Inicio-Fin]     # Mostrar entradas desde inicio a fin
: %hist o %history -g cadena     # Mostrar entradas que contengan cadena

: %hist -o  ó  %history -o [Inicio-Fin]     # Mostrar entradas y salidas. 

: %hist 1-10 -pof file.txt     # Guardar historia en archivo. (-p) añade prompt
: %hist 20/1-10     # Listar 10 entradas de la sesión 20
: %hist ~2/1-10     # Listar 10 entradas de la penúltima sesión
: %hist ~2/1-10 -n     # Listar 10 entradas de la penultima sesión numerando 

El historial de entrada de sesiones anteriores se almacena en un base de datos pero es posible configurar IPython para que guarde también el historial de salida.

Ejecutar entradas anteriores con %rerun y %macro

Se pueden ejecutar varias entradas anteriores mediante el uso de las funciones mágicas %rerun y %macro.

: %rerun 1-4     # ejecutar entradas de la 1 a la 4
: %rerun 4     # ejecutar entrada número 4

: %macro calcula 1-4 1-2  # crear macro "calcula" con entradas 1 a 4 y 1 a 2
: calcula     # ejecutará la macro
: print(calcula)     # mostrará el contenido de la macro "calcula"

Varias funciones mágicas pueden utilizar el historial de entrada: %edit, %rerun, %recall, %macro, %save y %pastebin.

Editar una entrada anterior con %recall o %rep

Con las funciones mágicas %recall o %rep podemos editar una entrada anterior antes de su ejecución.

In [10]: %recall 1   # Editar la entrada número 1
In [10]: 1 + 3  |    # Una vez modificada aceptar los cambios con [Enter]

La base de datos del historial

El historial se guarda en una base de datos del tipo sqlite que podemos explorar con herramientas como SQLite Database Browser o SQLite Manager.

Para conocer la ubicación de la base de datos del historial:

In [11]: get_ipython().history_manager.hist_file
Out[11]: '/home/usuario/.ipython/profile_default/history.sqlite'

Ir al índice del tutorial de IPython

Funciones mágicas de IPython

IPython tiene un conjunto de funciones predefinidas llamadas "mágicas" que representa una de las mejoras más importantes que aporta en relación al intérprete de Python. Hay dos tipos de funciones mágicas:

Funciones mágicas orientadas a líneas

Están precedidas por el carácter "%" y reciben como argumento el resto de la línea, donde se pasan sin necesidad de usar paréntesis o comillas. Ejemplo:

: %run script-01.py

El carácter "%" puede omitirse cuando se va a ejecutar una sola línea y cuando una característica de IPython denominada "automágica" está activada (por defecto lo está):

: run script-01.py

Este comportamiento se puede cambiar con la función mágica %automagic. La función %automagic activa o desactiva la característica automágica de una función. Si está desactivada obligatoriamente tendremos que usar el prefijo "%" cuando escribimos función mágicas.

Es recomendable el uso del carácter "%" cuando se utilizan funciones mágicas, incluso en líneas aisladas, porque si no lo usamos tendrán la prioridad más baja posible en la resolución de nombres que hace IPython. Si se utiliza el carácter "%" se podrán utilizar, sin problemas, variables con los mismos nombres que las funciones mágicas:

: cd ipython     # %cd es una función que permite cambiar el directorio activo
/home/usuario/ipython

: cd=1     # Ahora "cd" es una variable

: cd ..     # Y la función no funciona porque el sistema da prioridad a la variable

File "<ipython-input-3-9fedb3aff56c>", line 1
  cd ..
      ^
SyntaxError: invalid syntax

: %cd ..     # Si anteponemos el signo "%" funcionará como es debido
/home/usuario

: del cd     # Si borramos la variable "cd" podremos usar la función sin "%"

: cd ipython
/home/usuario/ipython

Funciones mágicas orientadas a celdas

Este tipo de funciones están precedidas por "%%" y pueden recibir como argumento varias líneas.

Por ejemplo, la función mágica %%writefile permite almacenar en un archivo un conjunto de líneas. El archivo se guardará cuando avancemos con [Enter] después de dejar un línea en blanco. Si deseamos cancelar la entrada en cualquier momento pulsaremos [Ctrl+c].

: %%writefile NombreArchivo
: linea 1
: linea 2
: linea 3
:
Writing NombreArchivo

Con la función mágica %ls podemos listar el directorio y comprobar que se ha creado el archivo. Para mostrar su contenido podemos ejecutar un comando del sistema:

: !cat NombreArchivo

Consultar la lista de funciones mágicas

Con la función %lsmagic se pueden listar todas las funciones mágicas disponibles. Con %magic se puede obtener información general sobre qué son las funciones mágicas.

Obtener información de ayuda

Para obtener información de ayuda sobre una función:

: %NombreFunciónMágica?

y para obtener információn más detallada y si es posible mostrar código fuente:

: %NombreFunciónMágica??

Alias

La función mágica %alias permite definir otras funciones que pueden ejecutar comandos de forma abreviada, incluyendo parámetros.

: %alias mispy dir *.py

: mispy
script-01.py  script-02.py  script-03.py

In: usuario = "Manuel"
In: sistema = "PC00101"
In: %alias acceso echo "%s ha accedido a %s"

In: acceso Manuel PC00101
Manuel ha accedido a PC00101

In: acceso Manuel
ERROR: Alias <acceso> requires 2 arguments, 1 given.

In: acceso $usuario $sistema
Manuel ha accedido a PC00101

In: acceso {usuario} {sistema}
Manuel ha accedido a PC00101

Si se ejecuta %alias sin parámetros se mostrarán todos los alias existentes:

: %alias
Total number of aliases: 17
:
[('acceso', 'echo "%s ha accedido a %s"'),
 ('cat', 'cat'),
 ('clear', 'clear'),

La función mágica %rehashx actualiza la tabla de alias con todos los archivos ejecutables accesibles desde la variable de entorno PATH.

Crear funciones mágicas

A continuación, se muestra cómo crear una función mágica. Básicamente, se trata de editar el código de la función mágica en nuestro editor favorito y, una vez creado, ejecutarlo dentro de una sesión interactiva de IPython. Después de su ejecución podremos usar la función mágica cada vez que sea necesario.

Dentro del perfil de un usuario cualquiera IPython hay una carpeta llamada "startup" donde podemos almacenar los scripts de funciones mágicas para que cuando iniciemos una sesión de trabajo con IPython se ejecuten automáticamente.

La función mágica que vamos a crear la guardaremos en un archivo llamado "plataforma.py" y hará uso del módulo platform de Python que muestra información de nuestro equipo (nombre, sistema operativo, versión, arquitectura, etc.). La función mágica se llamará "%pf" y tendrá dos usos posibles. Si ejecutamos "%pf" mostrará una información más reducida y si ejecutamos "%pf all" mostrará una información más completa.

- Crear la función %pf (plataforma.py):

from IPython.core.oinspect import getdoc
import platform

ip = get_ipython()

def platf(obj): 
    print("Nombre :", platform.node())
    print("Sistema :", platform.system())
    print("Release :", platform.release())
    print("Version :", platform.version())
    if obj.upper() == "ALL":
        print("Equipo :", platform.machine())
        print("Procesador :", platform.processor())
        print("Arquitectura :", platform.architecture())
        print("Distribución :", platform.dist())
        print("Python Ver. :", platform.python_version())

ip.register_magic_function(platf, "line", "pf")

 

- Ejecutar el script que define la función mágica:

: %run plataforma.py

- Utilizar la función mágica "%pf":

Para mostrar información reducida

: %pf
Nombre : EQ001
Sistema : Windows
Release : 7
Version : 6.1.7601

Para mostrar información detallada

: %pf all
Nombre : EQ001
Sistema : Windows
Release : 7
Version : 6.1.7601
Equipo : x86
Procesador : x86 Family 6 Model 42 Stepping 7, GenuineIntel
Arquitectura : ('32bit', 'WindowsPE')
Distribución : ('', '', '')
Python Ver. : 3.4.1

Consultar GLOSARIO de Funciones Mágicas IPython

Ir al índice del tutorial de IPython

Ejecutar comandos del sistema en IPython

Ejecutar comandos

Para ejecutar comandos del sistema desde IPython simplemente tendremos que escribir los comandos anteponiendo el signo de exclamación "!". Ejemplos:

: !ls
: !ipconfig
: !copy archivo1.py archivo2.py

Capturar la salida de un comando en una lista

Cualquier salida de un comando se puede capturar en una lista Python

: lista = !dir

: for linea in lista:
...:     print(linea)
...:    
La lista capturada tiene algunas variantes: lista.n o lista.s devuelve una cadena delimitada por saltos de línea o espacios, respectivamente y lista.p muestra la ruta de los objetos.

: print(lista.n)
Dropbox  logdeantonio  Perfil        TVenLinux  VM
fondo     Marcadores    RedNoteBook  Varios

: print(lista.s)
Dropbox logdeantonio Perfil TVenLinux VM fondo Marcadores RedNoteBook  Varios


Para obtener explícitamente este tipo de salida sin asignar a una variable se pueden utilizar dos signos de exclamación "!!" delante del comando o la función mágica %sx.

In [1]: !!dir
Out[1]:
['Dropbox  logdeantonio  Perfil\t    TVenLinux  VM',
 'fondo\t Marcadores    RedNoteBook  Varios']

o bien

In [2]: %sx dir
Out[2]:
['Dropbox  logdeantonio  Perfil\t    TVenLinux  VM',
 'fondo\t Marcadores    RedNoteBook  Varios']

Usar variables Python en comandos

Para pasar los valores de las variables o expresiones de Python a comandos del sistema debe ir precedidas con el signo "$".

: extension = "*.py"
: !dir $extension

IPython permite utilizar el valor de variables o expresiones de Python cuando se ejecutan comandos del sistema. Para ello deben expresarse entre llaves {}.

: import sys
: sistema = sys.platform
: !echo "Sistema operativo: {sistema}"
Sistema operativo: linux

Ir al índice del tutorial de IPython

Facilidades para la escritura en IPython

Estas características requieren tener instalada la biblioteca readline de GNU. A continuación, vamos a describir el comportamiento que tiene predeterminado en una sesión interactiva de IPython.

Uso del tabulador para autocompletar

Mientras escribimos una entrada podemos presionar en cualquier momento la tecla [Tab] para completar comandos Python/IPython, nombres de variables, rutas de directorios, etc.

: import sys
: sys.v[Tab]
sys.version      sys.version_info

: sys.version

Al presionar [Tab] se completará hasta "version" porque aparece en los dos términos encontrados. Si después presionamos [_] y [Tab] el resultado será:

: sys.version[_Tab]
: sys.version_info[Enter]

sys.version_info(major=3, minor=4, micro=0, releaselevel='final', serial=0)

Búsqueda de comandos en el historial

IPython proporciona dos maneras de buscar en las líneas introducidas con anterioridad para evitar repeticiones en la escritura:

• Empezar a escribir y, a continuación, utilizar las teclas de [Flecha arriba] y [Flecha abajo] o [Ctrl-p] y [Ctrl-n] para buscar a través de los elementos del historial aquellos que coincidan con lo escrito en un momento dado.

• Presionar [Ctrl-r] para abrir un símbolo de búsqueda. Comenzar a escribir y el sistema buscará en el historial las líneas que contengan lo que se ha escrito hasta el momento, completándolo en la medida de posible.

IPython almacena el historial en una base de datos SQlite que volverá a cargar la próxima vez que iniciemos una sesión de trabajo. El archivo del historial se llama "history.sqlite" y se encuentra en la ruta del perfil activo:

/home/usuario/.ipython/profile_name

Sangrado de líneas

IPython puede reconocer las líneas que terminan en dos puntos ':' y sangrará la línea siguiente si presionamos [Enter]; y al mismo tiempo puede desangrar después de encontrar los términos "return" o "raise".

Esta función utiliza la biblioteca readline, por lo que respetará la configuración del archivo inputrc, normalmente, en la ubicación ~/.inputrc o donde apunte la variable de entorno INPUTRC.

Es posible personalizar el comportamiento de readline modificando la configuración del archivo .inputrc

Paréntesis y comillas automáticas

Tienen el propósito de permitir teclear menos en situaciones comunes. Objetos como funciones, métodos, etc. pueden ser invocados sin necesidad de escribir paréntesis. Por defecto, está desactivada. Es necesario activarla con %autocall:

: area_triangulo base, altura   # es equivalente a area_triangulo(base, altura)

Ejemplo:

In : def area_triangulo(base, altura):
    return base * altura / 2
   .....:

In : area_triangulo 4, 4
  File "<ipython-input-115-0530e8aac90d>", line 1
    area_triangulo 4, 4
                   ^
SyntaxError: invalid syntax


In : area_triangulo( 4, 4)
Out: 8.0

In : %autocall
Automatic calling is: Smart

In : area_triangulo 4, 4
---> area_triangulo(4, 4)
Out: 8.0

Caracteres que fuerzan la inclusión de paréntesis y comillas

Tienen que estar al principio de la línea

/funcion     # La "/" incluye paréntesis: 'función()'
/zip (1,2),(5,6)     # La "/" en este caso incluye corchetes: 'zip [(1,2),(5,6)]'
,funcion /home/user     # La "," incluye comillas: funcion("/home/usuario")
;function a b c     # El ";" incluye comillas: funcion("a b c")

Omitir salida

Escribir un ';' al final de una línea suprime la impresión de salida. Puede ser útil cuando se hacen cálculos con resultados intermedios que no estamos interesados en conocer.

In : a = 43
In : b = 56
In : a + b;
In : a + b
Out: 99

Ir al índice del tutorial de IPython