Primeros pasos con Jupyter Norebook

¿Qué es Jupyter Notebook?

Jupyter Notebook es una herramienta increíblemente poderosa para desarrollar y presentar proyectos de ciencia de datos de forma interactiva. Este artículo lo guiará a través de cómo usar Jupyter Notebooks para proyectos de ciencia de datos y cómo configurarlo en su máquina local.

Pero primero: ¿qué es un "cuaderno"?

Un cuaderno integra código y su salida en un solo documento que combina visualizaciones, texto narrativo, ecuaciones matemáticas y otros medios enriquecidos. En otras palabras: es un documento único en el que puede ejecutar código, mostrar el resultado y también agregar explicaciones, fórmulas, gráficos y hacer que su trabajo sea más transparente, comprensible, repetible y compartible.

El uso de Notebooks es ahora una parte importante del flujo de trabajo de la ciencia de datos en empresas de todo el mundo. Si su objetivo es trabajar con datos, el uso de una computadora portátil acelerará su flujo de trabajo y facilitará la comunicación y el intercambio de resultados.

Lo mejor de todo es que, como parte del proyecto de código abierto Jupyter , los cuadernos de Jupyter son completamente gratuitos. Puede descargar el software solo o como parte del kit de herramientas de ciencia de datos de Anaconda .

Aunque es posible utilizar muchos lenguajes de programación diferentes en Jupyter Notebooks, este artículo se centrará en Python, ya que es el caso de uso más común. (Entre los usuarios de R, R Studio tiende a ser una opción más popular).

Cómo seguir este tutorial

Para aprovechar al máximo este tutorial, debe estar familiarizado con la programación, específicamente Python y pandas . Dicho esto, si tiene experiencia con otro idioma, el Python en este artículo no debería ser demasiado críptico y aún lo ayudará a configurar Jupyter Notebooks localmente.

Jupyter Notebooks también puede actuar como una plataforma flexible para familiarizarse con los pandas e incluso con Python, como se verá en este tutorial.

Lo haremos:

• Cubra los conceptos básicos de la instalación de Jupyter y la creación de su primer cuaderno
• Profundice y aprenda toda la terminología importante
• Explore la facilidad con la que se pueden compartir y publicar en línea los blocs de notas.

(De hecho, este artículo se escribió como un cuaderno de Jupyter. Se publica aquí en formato de solo lectura, pero este es un buen ejemplo de lo versátiles que pueden ser los cuadernos. De hecho, la mayoría de nuestros tutoriales de programación e incluso nuestros cursos de Python se crearon utilizando Jupyter Notebooks).

Ejemplo de análisis de datos en un cuaderno Jupyter

Primero, recorreremos la configuración y un análisis de muestra para responder una pregunta de la vida real. Esto demostrará cómo el flujo de una computadora portátil hace que las tareas de ciencia de datos sean más intuitivas para nosotros mientras trabajamos y para otros una vez que llega el momento de compartir nuestro trabajo.

Entonces, digamos que es analista de datos y se le ha encomendado la tarea de averiguar cómo cambiaron históricamente las ganancias de las empresas más grandes de los EE. UU. Encontrará un conjunto de datos de compañías Fortune 500 que abarcan más de 50 años desde la primera publicación de la lista en 1955, reunidos a partir del archivo público de Fortune . Seguimos adelante y creamos un CSV de los datos que puede usar aquí .

Como demostraremos, los cuadernos de Jupyter son perfectamente adecuados para esta investigación. Primero, sigamos e instalemos Jupyter.

Instalación

La forma más fácil para que un principiante comience con Jupyter Notebooks es instalando Anaconda .

Anaconda es la distribución de Python más utilizada para la ciencia de datos y viene precargada con todas las bibliotecas y herramientas más populares.

Algunas de las bibliotecas de Python más grandes incluidas en Anaconda incluyen NumPy , pandas y Matplotlib , aunque la lista completa de más de 1000 es exhaustiva.

Por lo tanto, Anaconda nos permite comenzar con un taller de ciencia de datos completamente equipado sin la molestia de administrar innumerables instalaciones o preocuparse por las dependencias y los problemas de instalación específicos del sistema operativo (léase: específicos de Windows).

Para obtener Anaconda, simplemente:

1. Descargue la última versión de Anaconda para Python 3.8.
2. Instale Anaconda siguiendo las instrucciones en la página de descarga y / o en el ejecutable.

Si es un usuario más avanzado con Python ya instalado y prefiere administrar sus paquetes manualmente, puede usar pip :

Creación de su primer cuaderno

En esta sección, aprenderemos a ejecutar y guardar blocs de notas, a familiarizarnos con su estructura y a comprender la interfaz. Nos familiarizaremos con alguna terminología básica que lo guiará hacia una comprensión práctica de cómo usar Jupyter Notebooks por su cuenta y nos preparará para la siguiente sección, que recorre un ejemplo de análisis de datos y da vida a todo lo que aprendemos aquí.

Ejecutando Jupyter

En Windows, puede ejecutar Jupyter a través del acceso directo que Anaconda agrega a su menú de inicio, que abrirá una nueva pestaña en su navegador web predeterminado que debería parecerse a la siguiente captura de pantalla.

Este no es un cuaderno por el momento, ¡pero que no cunda el pánico! No hay mucho que hacer. Este es el panel de control del portátil, diseñado específicamente para administrar sus portátiles Jupyter. Piense en ello como la plataforma de lanzamiento para explorar, editar y crear sus cuadernos.

Tenga en cuenta que el panel le dará acceso solo a los archivos y subcarpetas que se encuentran dentro del directorio de inicio de Jupyter (es decir, donde está instalado Jupyter o Anaconda). Sin embargo, el directorio de inicio se puede cambiar .

También es posible iniciar el tablero en cualquier sistema a través del símbolo del sistema (o terminal en sistemas Unix) ingresando el comando jupyter notebook; en este caso, el directorio de trabajo actual será el directorio de inicio.

Con Jupyter Notebook abierto en su navegador, es posible que haya notado que la URL del panel de control es algo así como https://localhost:8888/tree. Localhost no es un sitio web, pero indica que el contenido se sirve desde su máquina local : su propia computadora.

Los cuadernos y el tablero de Jupyter son aplicaciones web, y Jupyter inicia un servidor Python local para servir estas aplicaciones en su navegador web, lo que lo hace esencialmente independiente de la plataforma y abre la puerta para compartir más fácilmente en la web.

(Si aún no comprende esto, no se preocupe; el punto importante es que, aunque Jupyter Notebooks se abre en su navegador, está alojado y se ejecuta en su máquina local. Sus blocs de notas no están realmente en la web hasta que decide compartirlos.)

La interfaz del tablero se explica por sí misma, aunque volveremos a ella brevemente más adelante. entonces que estamos esperando ' Busque la carpeta en la que le gustaría crear su primer cuaderno, haga clic en el botón desplegable "Nuevo" en la parte superior derecha y seleccione "Python 3":

¡Oye presto, aquí estamos! Su primer cuaderno de Jupyter se abrirá en una nueva pestaña; cada cuaderno usa su propia pestaña porque puede abrir varios cuadernos simultáneamente.

Si regresa al tablero, verá el nuevo archivo Untitled.ipynb y debería ver un texto verde que le indica que su computadora portátil se está ejecutando.

¿Qué es un archivo ipynb?

La respuesta corta: cada .ipynbarchivo es un cuaderno, por lo que cada vez que cree un nuevo cuaderno, se creará un nuevo .ipynb archivo.

La respuesta más larga: cada .ipynb archivo es un archivo de texto que describe el contenido de su cuaderno en un formato llamado JSON . Cada celda y su contenido, incluidos los archivos adjuntos de imágenes que se han convertido en cadenas de texto, se enumeran allí junto con algunos metadatos .

Puede editarlo usted mismo, ¡si sabe lo que está haciendo! - seleccionando "Editar> Editar metadatos del cuaderno" en la barra de menú del cuaderno. También puede ver el contenido de los archivos de su cuaderno seleccionando "Editar" en los controles del panel.

Sin embargo, la palabra clave puede. En la mayoría de los casos, no hay ninguna razón por la que deba editar manualmente los metadatos de su cuaderno.

La interfaz del portátil

Ahora que tiene un cuaderno abierto frente a usted, es de esperar que su interfaz no se vea del todo extraña. Después de todo, Jupyter es esencialmente un procesador de texto avanzado.

¿Por qué no echar un vistazo? Consulte los menús para familiarizarse con ellos, especialmente tómese unos minutos para desplazarse hacia abajo en la lista de comandos en la paleta de comandos, que es el botón pequeño con el ícono del teclado (o Ctrl + Shift + P).

Hay dos términos bastante prominentes que debe notar, que probablemente sean nuevos para usted: las células y los núcleos son clave tanto para comprender Jupyter como para lo que lo convierte en algo más que un procesador de texto. Afortunadamente, estos conceptos no son difíciles de entender.

• Un kernel es un "motor computacional" que ejecuta el código contenido en un documento de cuaderno.
• Una celda es un contenedor para el texto que se mostrará en el cuaderno o el código que ejecutará el kernel del cuaderno.

Celdas

Regresaremos a los núcleos un poco más tarde, pero primero hablemos de las celdas. Las células forman el cuerpo de un cuaderno. En la captura de pantalla de un nuevo cuaderno en la sección anterior, ese cuadro con el contorno verde es una celda vacía. Hay dos tipos de células principales que cubriremos:

• Una celda de código contiene código que se ejecutará en el kernel. Cuando se ejecuta el código, el portátil muestra el resultado debajo de la celda de código que lo generó.
• Una celda de Markdown contiene texto formateado con Markdown y muestra su salida en el lugar cuando se ejecuta la celda de Markdown.

La primera celda de un cuaderno nuevo es siempre una celda de código.

Probémoslo con un ejemplo clásico de Hello World: escriba print('Hello World!') en la celda y haga clic en el botón Ejecutar

en la barra de herramientas de arriba o presione Ctrl + Enter.

El resultado debería verse así:

Cuando ejecutamos la celda, su salida se muestra a continuación y la etiqueta a su izquierda habrá cambiado de In [ ] a In [1].

La salida de una celda de código también forma parte del documento, por lo que puede verla en este artículo. Siempre puede notar la diferencia entre el código y las celdas de Markdown porque las celdas de código tienen esa etiqueta a la izquierda y las celdas de Markdown no.

La parte "En" de la etiqueta es simplemente la abreviatura de "Entrada", mientras que el número de etiqueta indica cuándo se ejecutó la celda en el kernel; en este caso, la celda se ejecutó primero.

Ejecute la celda nuevamente y la etiqueta cambiará a In [2] porque ahora la celda fue la segunda en ejecutarse en el kernel. Será más claro por qué esto es tan útil más adelante cuando echemos un vistazo más de cerca a los núcleos.

En la barra de menú, haga clic en Insertar y seleccione Insertar celda debajo para crear una nueva celda de código debajo de la primera y pruebe el siguiente código para ver qué sucede. ¿Notas algo diferente?

import time
time.sleep(3)

Esta celda no produce ningún resultado, pero tarda tres segundos en ejecutarse. Observe cómo Jupyter significa cuando la celda se está ejecutando actualmente cambiando su etiqueta a In [*].

En general, la salida de una celda proviene de cualquier dato de texto impreso específicamente durante la ejecución de la celda, así como del valor de la última línea de la celda, ya sea una variable solitaria, una llamada de función u otra cosa. Por ejemplo:

def say_hello(recipient):
    return 'Hello, {}!'.format(recipient)

say_hello('Tim')

Te encontrarás usando esto casi constantemente en tus propios proyectos, y veremos más de eso más adelante.

Atajos de teclado

Una última cosa que puede haber observado al ejecutar sus celdas es que su borde se vuelve azul, mientras que era verde mientras estaba editando. En un Jupyter Notebook, siempre hay una celda "activa" resaltada con un borde cuyo color denota su modo actual:

• Contorno verde : la celda está en "modo de edición"
• Contorno azul : la celda está en "modo de comando"

Entonces, ¿qué podemos hacer con una celda cuando está en modo comando? Hasta ahora, hemos visto cómo ejecutar una celda Ctrl + Enter, pero hay muchos otros comandos que podemos usar. La mejor manera de usarlos es con atajos de teclado.

Los atajos de teclado son un aspecto muy popular del entorno de Jupyter porque facilitan un flujo de trabajo rápido basado en celdas. Muchas de estas son acciones que puede realizar en la celda activa cuando está en modo de comando.

A continuación, encontrará una lista de algunos de los atajos de teclado de Jupyter. No es necesario que los memorice todos de inmediato, pero esta lista debería darle una buena idea de lo que es posible.

• Alternar entre los modos de edición y comando con Esc y Enter, respectivamente.
• Una vez en el modo de comando:
  • Desplácese hacia arriba y hacia abajo en sus celdas con las teclas Up y Down.
  • Presione A o B para insertar una nueva celda encima o debajo de la celda activa.
  • M transformará la celda activa en una celda de Markdown.
  • Y establecerá la celda activa en una celda de código.
  • D + D ( D dos veces) eliminará la celda activa.
  • Z deshará la eliminación de la celda.
  • Mantenga Shift presionado y presione Up o Downpara seleccionar varias celdas a la vez. Con varias celdas seleccionadas, Shift + M fusionará su selección.
• Ctrl + Shift + -, en el modo de edición, dividirá la celda activa en el cursor.
• También puede hacer clic Shift + Click en y en el margen a la izquierda de sus celdas para seleccionarlas.

Continúe y pruébelos en su propio cuaderno. Una vez que esté listo, cree una nueva celda de Markdown y aprenderemos a formatear el texto en nuestros cuadernos.

Reducción

Markdown es un lenguaje de marcado ligero y fácil de aprender para formatear texto sin formato. Su sintaxis tiene una correspondencia uno a uno con las etiquetas HTML, por lo que algunos conocimientos previos aquí serían útiles, pero definitivamente no son un requisito previo.

Recuerda que este artículo fue escrito en un cuaderno de Jupyter, por lo que todo el texto narrativo y las imágenes que has visto hasta ahora se lograron escribiendo en Markdown. Cubramos los conceptos básicos con un ejemplo rápido:

# This is a level 1 heading

## This is a level 2 heading

This is some plain text that forms a paragraph. Add emphasis via **bold** and __bold__, or *italic* and _italic_. 

Paragraphs must be separated by an empty line. 

* Sometimes we want to include lists. 
* Which can be bulleted using asterisks. 

1. Lists can also be numbered. 
2. If we want an ordered list.

[It is possible to include hyperlinks](https://www.example.com)

Inline code uses single backticks: `foo()`, and code blocks use triple backticks: 
```
bar()
``` 
Or can be indented by 4 spaces: 

    foo()
    
And finally, adding images is easy: ![Alt text](https://www.example.com/image.jpg)

Así es como se vería Markdown una vez que ejecute la celda para renderizarlo:

(Tenga en cuenta que el texto alternativo de la imagen se muestra aquí porque en realidad no usamos una URL de imagen válida en nuestro ejemplo)

Al adjuntar imágenes, tiene tres opciones:

• Utilice una URL para una imagen en la web.
• Use una URL local para una imagen que mantendrá junto a su cuaderno, como en el mismo repositorio de git.
• Agregue un archivo adjunto a través de "Editar> Insertar imagen"; esto convertirá la imagen en una cadena y la almacenará dentro de su .ipynbarchivo de cuaderno . ¡Tenga en cuenta que esto hará que su .ipynb archivo sea mucho más grande!

Hay mucho más en Markdown, especialmente en torno a los hipervínculos, y también es posible incluir simplemente HTML simple. Una vez que se encuentre superando los límites de los conceptos básicos anteriores, puede consultar la guía oficial del creador de Markdown, John Gruber, en su sitio web.

Granos

Detrás de cada portátil hay un kernel. Cuando ejecuta una celda de código, ese código se ejecuta dentro del kernel. Cualquier salida se devuelve a la celda para que se muestre. El estado del kernel persiste a lo largo del tiempo y entre celdas; pertenece al documento como un todo y no a celdas individuales.

Por ejemplo, si importa bibliotecas o declara variables en una celda, estarán disponibles en otra. Probemos esto para sentirlo. Primero, importaremos un paquete de Python y definiremos una función:

import numpy as np
def square(x):
    return x * x

Una vez que hayamos ejecutado la celda de arriba, podemos hacer referencia a np y square en cualquier otra celda.

x = np.random.randint(1, 10)
y = square(x)
print('%d squared is %d' % (x, y))

Esto funcionará independientemente del orden de las celdas de su cuaderno. Siempre que se haya ejecutado una celda, las variables que declaró o las bibliotecas que importó estarán disponibles en otras celdas.

Puede probarlo usted mismo, imprimamos nuestras variables nuevamente.

print('Is %d squared %d?' % (x, y))

Is 1 squared 1?

¡No hay sorpresas aquí! Pero, ¿qué pasa si cambiamos el valor de y?

y = 10
print('Is %d squared is %d?' % (x, y))

Si ejecutamos la celda de arriba, ¿qué crees que pasaría?

Obtendremos una salida como: Is 4 squared 10?. Esto se debe a que una vez que hemos ejecutado la y = 10celda de código, y ya no es igual al cuadrado de x en el kernel.

La mayoría de las veces, cuando crea un cuaderno, el flujo será de arriba hacia abajo. Pero es común volver atrás para realizar cambios. Cuando necesitamos realizar cambios en una celda anterior, el orden de ejecución que podemos ver a la izquierda de cada celda, por ejemplo In [6], puede ayudarnos a diagnosticar problemas al ver en qué orden se han ejecutado las celdas.

Y si alguna vez deseamos restablecer las cosas, hay varias opciones increíblemente útiles en el menú Kernel:

• Reiniciar: reinicia el kernel, borrando así todas las variables, etc.que fueron definidas.
• Reiniciar y borrar la salida: igual que el anterior, pero también borrará la salida que se muestra debajo de las celdas de código.
• Reiniciar y ejecutar todo: igual que el anterior, pero también ejecutará todas sus celdas en orden de la primera a la última.

Si su kernel se atasca alguna vez en un cálculo y desea detenerlo, puede elegir la opción Interrumpir.

Elegir un kernel

Es posible que haya notado que Jupyter le brinda la opción de cambiar el kernel y, de hecho, hay muchas opciones diferentes para elegir. Cuando creó un nuevo cuaderno desde el panel de control seleccionando una versión de Python, en realidad estaba eligiendo qué kernel usar.

Hay kernels para diferentes versiones de Python, y también para más de 100 lenguajes, incluidos Java, C e incluso Fortran. Los científicos de datos pueden estar particularmente interesados ​​en los núcleos para R y Julia , así como en imatlab y Calysto MATLAB Kernel para Matlab.

El kernel de SoS proporciona compatibilidad con varios idiomas en un solo portátil.

Cada kernel tiene sus propias instrucciones de instalación, pero probablemente requiera que ejecute algunos comandos en su computadora.

¿Aprendiendo Python para la ciencia de datos? ¡Prueba una de nuestras más de 60 misiones gratuitas hoy!Empiece >>

Análisis de ejemplo

Ahora que hemos visto qué es un Jupyter Notebook, es hora de ver cómo se utilizan en la práctica, lo que debería darnos una comprensión más clara de por qué son tan populares.

Finalmente es hora de comenzar con ese conjunto de datos de Fortune 500 mencionado anteriormente. Recuerde, nuestro objetivo es averiguar cómo han cambiado históricamente las ganancias de las empresas más grandes de EE . UU .

Vale la pena señalar que todos desarrollarán sus propias preferencias y estilo, pero los principios generales aún se aplican. Si lo desea, puede seguir esta sección en su propio cuaderno o utilizarla como guía para crear su propio enfoque.

Nombrar sus cuadernos

Antes de comenzar a escribir su proyecto, probablemente querrá darle un nombre significativo. nombre de archivo Untitled en la parte superior izquierda de la pantalla para ingresar un nuevo nombre de archivo, y presione el icono Guardar (que parece un disquete) debajo de él para guardar.

Tenga en cuenta que cerrar la pestaña del cuaderno en su navegador no "cerrará" su cuaderno de la forma en que lo haría cerrar un documento en una aplicación tradicional. El kernel del portátil seguirá ejecutándose en segundo plano y debe cerrarse antes de que se "cierre" realmente, aunque esto es muy útil si cierra accidentalmente la pestaña o el navegador.

Si el kernel se apaga, puede cerrar la pestaña sin preocuparse de si todavía se está ejecutando o no.

La forma más sencilla de hacerlo es seleccionar "Archivo> Cerrar y detener" en el menú de la libreta. Sin embargo, también puede apagar el kernel yendo a "Kernel> Shutdown" desde la aplicación de la computadora portátil o seleccionando la computadora portátil en el panel de control y haciendo clic en "Apagar" (vea la imagen a continuación).

Configuración

Es común comenzar con una celda de código específicamente para las importaciones y la configuración, de modo que si elige agregar o cambiar algo, simplemente puede editar y volver a ejecutar la celda sin causar efectos secundarios.

%matplotlib inline
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns sns.set(style="darkgrid")

Importaremos pandas para trabajar con nuestros datos, Matplotlib para trazar gráficos y Seaborn para hacer que nuestros gráficos sean más bonitos. También es común importar NumPy, pero en este caso, pandas lo importa por nosotros.

Esa primera línea no es un comando de Python, pero usa algo llamado magia de línea para indicarle a Jupyter que capture los diagramas de Matplotlib y los represente en la salida de la celda. Hablaremos un poco más sobre la magia de líneas más adelante, y también se tratan en nuestro tutorial avanzado de Jupyter Notebooks .

Por ahora, sigamos adelante y carguemos nuestros datos.

df = pd.read_csv('fortune500.csv')

Es sensato hacer esto también en una sola celda, en caso de que necesitemos recargarlo en algún momento.

Guardar y comprobar

Ahora que hemos comenzado, lo mejor es ahorrar con regularidad. Al presionar Ctrl + S guardará nuestro cuaderno llamando al comando "Guardar y punto de control", pero ¿qué es este punto de control?

Cada vez que creamos un nuevo cuaderno, se crea un archivo de punto de control junto con el archivo del cuaderno. Se encuentra dentro de un subdirectorio oculto de su ubicación de guardado llamado .ipynb_checkpoints y también es un .ipynb archivo.

De forma predeterminada, Jupyter guardará automáticamente su cuaderno cada 120 segundos en este archivo de punto de control sin alterar el archivo de su cuaderno principal. Cuando "Guardar y punto de control", se actualizan tanto el cuaderno como los archivos del punto de control. Por lo tanto, el punto de control le permite recuperar su trabajo no guardado en caso de un problema inesperado.

Puede volver al punto de control desde el menú a través de "Archivo> Volver al punto de control".

Investigando nuestro conjunto de datos

¡Ahora estamos realmente rodando! Nuestro cuaderno se guarda de forma segura y hemos cargado nuestro conjunto de datos df en la estructura de datos de pandas más utilizada, que se llama DataFrame ay básicamente se parece a una tabla. ¿Qué aspecto tiene el nuestro?

Luciendo bien. Tenemos las columnas que necesitamos y cada fila corresponde a una sola empresa en un solo año.

Cambiemos el nombre de esas columnas para poder consultarlas más adelante.

df.columns = ['year', 'rank', 'company', 'revenue', 'profit']

A continuación, necesitamos explorar nuestro conjunto de datos. Esta completo? ¿Lo leyeron los pandas como se esperaba? ¿Falta algún valor?

De acuerdo, eso se ve bien, son 500 filas por cada año desde 1955 hasta 2005, inclusive.

Comprobemos si nuestro conjunto de datos se ha importado como era de esperar. Una simple verificación es ver si los tipos de datos (o dtypes) se han interpretado correctamente.

year int64 rank int64 company object revenue float64 profit object dtype: object

UH oh. Parece que hay algún problema con la columna de ganancias; esperaríamos que fuera float64 similar a la columna de ingresos. Esto indica que probablemente contiene algunos valores que no son enteros, así que echemos un vistazo.

non_numberic_profits = df.profit.str.contains('[^0-9.-]')
df.loc[non_numberic_profits].head()

¡Tal como sospechábamos! Algunos de los valores son cadenas, que se han utilizado para indicar datos faltantes. ¿Hay otros valores que se hayan infiltrado?

set(df.profit[non_numberic_profits])

Eso hace que sea fácil de interpretar, pero ¿qué debemos hacer? Bueno, eso depende de cuántos valores falten.

len(df.profit[non_numberic_profits])

Es una pequeña fracción de nuestro conjunto de datos, aunque no del todo intrascendente, ya que todavía está en torno al 1,5%.

Si las filas que contienen N.A. están distribuidas de manera aproximada y uniforme a lo largo de los años, la solución más sencilla sería eliminarlas. Así que echemos un vistazo rápido a la distribución.

bin_sizes, _, _ = plt.hist(df.year[non_numberic_profits], bins=range(1955, 2006))

De un vistazo, podemos ver que los valores más inválidos en un solo año son menos de 25, y como hay 500 puntos de datos por año, eliminar estos valores representaría menos del 4% de los datos de los peores años. De hecho, aparte de un aumento en torno a los 90, la mayoría de los años tienen menos de la mitad de los valores faltantes del pico.

Para nuestros propósitos, digamos que esto es aceptable y continúe y elimine estas filas.

df = df.loc[~non_numberic_profits]
df.profit = df.profit.apply(pd.to_numeric)

Deberíamos comprobar que funcionó.

year int64 rank int64 company object revenue float64 profit float64 dtype: object

¡Estupendo! Hemos terminado la configuración de nuestro conjunto de datos.

Si tuviéramos que presentar su cuaderno como un informe, podríamos deshacernos de las celdas de investigación que creamos, que se incluyen aquí como una demostración del flujo de trabajo con los cuadernos, y fusionar las celdas relevantes (consulte la sección Funcionalidad avanzada a continuación para más sobre esto) para crear una celda de configuración de un solo conjunto de datos.

Esto significaría que si alguna vez estropeamos nuestro conjunto de datos en otro lugar, podemos simplemente volver a ejecutar la celda de configuración para restaurarlo.

Trazando con matplotlib

A continuación, podemos llegar a abordar la cuestión en cuestión trazando el beneficio promedio por año. También podríamos trazar los ingresos, así que primero podemos definir algunas variables y un método para reducir nuestro código.

group_by_year = df.loc[:, ['year', 'revenue', 'profit']].groupby('year')
avgs = group_by_year.mean()
x = avgs.index
y1 = avgs.profit
def plot(x, y, ax, title, y_label):
    ax.set_title(title)
    ax.set_ylabel(y_label)
    ax.plot(x, y)
    ax.margins(x=0, y=0)

¡Ahora tramemos!

fig, ax = plt.subplots()
plot(x, y1, ax, 'Increase in mean Fortune 500 company profits from 1955 to 2005', 'Profit (millions)')

Vaya, eso parece exponencial, pero tiene algunas caídas enormes. Deben corresponder a la recesión de principios de la década de 1990 y a la burbuja de las puntocom . Es bastante interesante ver eso en los datos. Pero, ¿cómo es que las ganancias se recuperaron a niveles aún más altos después de cada recesión?

Quizás los ingresos puedan decirnos más.

y2 = avgs.revenue
fig, ax = plt.subplots()
plot(x, y2, ax, 'Increase in mean Fortune 500 company revenues from 1955 to 2005', 'Revenue (millions)')

Eso agrega otro lado a la historia. Los ingresos no se vieron tan afectados; ese es un gran trabajo contable de los departamentos de finanzas.

Con un poco de ayuda de Stack Overflow , podemos superponer estos gráficos con +/- sus desviaciones estándar.

def plot_with_std(x, y, stds, ax, title, y_label):
    ax.fill_between(x, y - stds, y + stds, alpha=0.2)
    plot(x, y, ax, title, y_label)
fig, (ax1, ax2) = plt.subplots(ncols=2)
title = 'Increase in mean and std Fortune 500 company %s from 1955 to 2005'
stds1 = group_by_year.std().profit.values
stds2 = group_by_year.std().revenue.values
plot_with_std(x, y1.values, stds1, ax1, title % 'profits', 'Profit (millions)')
plot_with_std(x, y2.values, stds2, ax2, title % 'revenues', 'Revenue (millions)')
fig.set_size_inches(14, 4)
fig.tight_layout()

Eso es asombroso, ¡las desviaciones estándar son enormes! Algunas empresas de Fortune 500 ganan miles de millones mientras que otras pierden miles de millones, y el riesgo ha aumentado junto con el aumento de las ganancias a lo largo de los años.

Quizás algunas empresas se desempeñen mejor que otras; ¿Son las ganancias del 10% superior más o menos volátiles que las del 10% inferior?

Hay muchas preguntas que podríamos analizar a continuación, y es fácil ver cómo el flujo de trabajo en un cuaderno puede coincidir con el propio proceso de pensamiento. Para los propósitos de este tutorial, detendremos nuestro análisis aquí, ¡pero siéntase libre de continuar investigando los datos por su cuenta!

Este flujo nos ayudó a investigar fácilmente nuestro conjunto de datos en un solo lugar sin cambiar de contexto entre aplicaciones, y nuestro trabajo se puede compartir y reproducir de inmediato. Si quisiéramos crear un informe más conciso para una audiencia en particular, podríamos refactorizar rápidamente nuestro trabajo fusionando celdas y eliminando el código intermediario.

Compartir sus cuadernos

Cuando la gente habla de compartir sus cuadernos, generalmente hay dos paradigmas que pueden estar considerando.

La mayoría de las veces, las personas comparten el resultado final de su trabajo, al igual que este artículo, lo que significa compartir versiones no interactivas y pre-renderizadas de sus cuadernos. Sin embargo, también es posible colaborar en portátiles con la ayuda de sistemas de control de versiones como Git o plataformas online como Google Colab .

Antes de compartir

Un cuaderno compartido aparecerá exactamente en el estado en el que se encontraba cuando lo exporta o lo guarda, incluida la salida de las celdas de código. Por lo tanto, para asegurarse de que su computadora portátil esté lista para compartir, por así decirlo, hay algunos pasos que debe seguir antes de compartir:

1. Haga clic en "Celda> Todos los resultados> Borrar".
2. Haga clic en "Kernel> Reiniciar y ejecutar todo".
3. Espere a que las celdas de su código terminen de ejecutarse y verifique que se haya ejecutado como se esperaba

Esto asegurará que sus cuadernos no contengan salida intermedia, tengan un estado obsoleto y se ejecuten en orden en el momento de compartir.

Exportación de sus cuadernos

Jupyter tiene soporte integrado para exportar a HTML y PDF, así como a varios otros formatos, que puede encontrar en el menú en "Archivo> Descargar como".

Si desea compartir sus cuadernos con un pequeño grupo privado, esta funcionalidad puede ser todo lo que necesite. De hecho, como a muchos investigadores de instituciones académicas se les proporciona un espacio web público o interno, y debido a que puede exportar un cuaderno a un archivo HTML, Jupyter Notebooks puede ser una forma especialmente conveniente para que los investigadores compartan sus resultados con sus pares.

Pero si compartir archivos exportados no es suficiente para usted, también existen algunos métodos inmensamente populares para compartir .ipynb archivos más directamente en la web.

GitHub

Con la cantidad de cuadernos públicos en GitHub que excedieron los 1.8 millones a principios de 2018, seguramente es la plataforma independiente más popular para compartir proyectos de Jupyter con el mundo. GitHub tiene soporte integrado para renderizar .ipynb archivos directamente tanto en repositorios como en esencias en su sitio web. Si aún no lo sabe, GitHub es una plataforma de alojamiento de código para el control de versiones y la colaboración para repositorios creados con Git. . Necesitará una cuenta para utilizar sus servicios, pero las cuentas estándar son gratuitas.

Una vez que tenga una cuenta de GitHub, la forma más fácil de compartir un cuaderno en GitHub no requiere Git en absoluto. Desde 2008, GitHub ha proporcionado su servicio Gist para alojar y compartir fragmentos de código, cada uno de los cuales tiene su propio repositorio. Para compartir un cuaderno usando Gists:

1. Inicie sesión y navegue hasta gist.github.com .
2. Abra su .ipynb archivo en un editor de texto, seleccione todo y copie el JSON dentro.
3. Pegue el JSON del cuaderno en la esencia.
4. Dale a tu Gist un nombre de archivo, recordando agregarlo .iypnb o esto no funcionará.
5. Haga clic en "Crear esencia secreta" o "Crear esencia pública".

Esto debería tener un aspecto similar al siguiente:

Si creó un Gist público, ahora podrá compartir su URL con cualquier persona, y otros podrán bifurcar y clonar su trabajo.

Crear tu propio repositorio de Git y compartirlo en GitHub está más allá del alcance de este tutorial, pero GitHub proporciona muchas guías para que comiences por tu cuenta.

Un consejo adicional para aquellos que usan git es agregar una excepción a su .gitignore para los .ipynb_checkpoints directorios ocultos que crea Jupyter, para no enviar archivos de puntos de control innecesariamente a su repositorio.

Nbviewer

Después de haber crecido hasta renderizar cientos de miles de cuadernos cada semana en 2015, NBViewer es el renderizador de cuadernos más popular en la web. Si ya tiene un lugar para alojar sus cuadernos de Jupyter en línea, ya sea en GitHub o en otro lugar, NBViewer renderizará su cuaderno y proporcionará una URL para compartir junto con él. Se proporciona como un servicio gratuito como parte del Proyecto Jupyter y está disponible en nbviewer.jupyter.org .

Desarrollado inicialmente antes de la integración de Jupyter Notebook de GitHub, NBViewer permite que cualquier persona ingrese una URL, ID de Gist o nombre de usuario / repositorio / archivo de GitHub y mostrará el cuaderno como una página web. La ID de un Gist es el número único al final de su URL; por ejemplo, la cadena de caracteres después de la última barra invertida https://gist.github.com/username/50896401c23e0bf417e89cd57e89e1de. Si ingresa un nombre de usuario o nombre de usuario / repositorio de GitHub, verá un explorador de archivos mínimo que le permite explorar los repositorios de un usuario y su contenido.

La URL que se muestra en NBViewer cuando se muestra un cuaderno es una constante basada en la URL del cuaderno que se está procesando, por lo que puede compartirla con cualquier persona y funcionará siempre que los archivos originales permanezcan en línea; NBViewer no almacena en caché los archivos durante mucho tiempo. largo.

Si no le gusta Nbviewer, existen otras opciones similares: aquí hay un hilo con algunos para considerar de nuestra comunidad.

Extras: Extensiones de Jupyter Notebook

Ya hemos cubierto todo lo que necesita para empezar a trabajar en Jupyter Notebooks.

¿Qué son las extensiones?

Las extensiones son precisamente lo que parecen: características adicionales que amplían la funcionalidad de Jupyter Notebooks. Si bien un Jupyter Notebook básico puede hacer mucho, las extensiones ofrecen algunas características adicionales que pueden ayudar con flujos de trabajo específicos o que simplemente mejoran la experiencia del usuario.

Por ejemplo, una extensión llamada "Tabla de contenido" genera una tabla de contenido para su cuaderno, para que los cuadernos grandes sean más fáciles de visualizar y navegar.

Otro, llamado Inspector de variables, le mostrará el valor, el tipo, el tamaño y la forma de cada variable en su cuaderno para una fácil referencia rápida y depuración.

Otro, llamado ExecuteTime, le permite saber cuándo y durante cuánto tiempo se ejecutó cada celda; esto puede ser particularmente conveniente si está tratando de acelerar un fragmento de su código.

Estos son solo la punta del iceberg; hay muchas extensiones disponibles.

¿Dónde puede obtener extensiones?

Para obtener las extensiones, debe instalar Nbextensions. Puede hacer esto usando pip y la línea de comando. Si tiene Anaconda, puede ser mejor hacerlo a través de Anaconda Prompt en lugar de la línea de comandos normal.

Cerrar Jupyter cuadernos, abierta Anaconda Prompt y ejecute el siguiente comando: pip install jupyter_contrib_nbextensions & jupyter contrib nbextension install.

Una vez que haya hecho eso, inicie un cuaderno y debería ver una pestaña Nbextensions. Al hacer clic en esta pestaña, se le mostrará una lista de extensiones disponibles. Simplemente marque las casillas de las extensiones que desea habilitar y ¡listo para las carreras!

Instalación de extensiones

Una vez que se ha instalado Nbextensions, no es necesario realizar una instalación adicional de cada extensión. Sin embargo, si ya instaló Nbextensons pero no ve la pestaña, no está solo. Este hilo en Github detalla algunos problemas y soluciones comunes.

Extras: Line Magics en Jupyter

Anteriormente mencionamos los comandos mágicos cuando solíamos %matplotlib inline hacer que los gráficos de Matplotlib se renderizaran directamente en nuestro cuaderno. También hay muchas otras magias que podemos usar.

Cómo usar magia en Jupyter

Un buen primer paso es abrir un Jupyter Notebook, escribir %lsmagic en una celda y ejecutar la celda. Esto generará una lista de las magias de línea y de celda disponibles, y también te dirá si "automagic" está activado.

• Las magias de línea operan en una sola línea de una celda de código
• La magia celular opera en toda la celda de código en la que se llaman

Si automagic está activado, puede ejecutar una magia simplemente escribiéndola en su propia línea en una celda de código y ejecutando la celda. Si está desactivado, deberá poner %antes de las magias de línea y %% antes de las magias de células para usarlas.

Muchas magias requieren información adicional (al igual que una función requiere un argumento) para decirles cómo operar. Veremos un ejemplo en la siguiente sección, pero puede ver la documentación de cualquier magia ejecutándola con un signo de interrogación, así:

Cuando ejecute la celda anterior en un cuaderno, aparecerá una larga cadena de documentos en la pantalla con detalles sobre cómo puede usar la magia.

Algunos comandos mágicos útiles

Cubrimos más en el tutorial avanzado de Jupyter , pero aquí hay algunos para comenzar:

%correr

Ejecuta un archivo de secuencia de comandos externo como parte de la celda que se está ejecutando.
Por ejemplo, si aparece % run myscript.py en una celda de código, el kernel ejecutará myscript.py como parte de esa celda.

%cronométralo

Cuenta bucles, mide e informa cuánto tiempo tarda en ejecutarse una celda de código.

% archivo de escritura

Guarde el contenido de una celda en un archivo.
Por ejemplo, % savefile myscript.py guardaría la celda de código como un archivo externo llamado myscript.py.

%Tienda

Guarde una variable para usarla en un cuaderno diferente.

% pwd

Imprima la ruta del directorio en el que está trabajando actualmente.

%% javascript

Ejecuta la celda como código JavaScript.

Hay mucho más de donde vino eso. Ingrese a Jupyter Notebooks y comience a explorar usando%lsmagic !

Pensamientos finales

Comenzando desde cero, nos hemos familiarizado con el flujo de trabajo natural de Jupyter Notebooks, profundizamos en las funciones más avanzadas de IPython y finalmente aprendimos cómo compartir nuestro trabajo con amigos, colegas y el mundo. ¡Y logramos todo esto desde un propio cuaderno!

Debe quedar claro cómo los cuadernos promueven una experiencia de trabajo productiva al reducir el cambio de contexto y emular un desarrollo natural de pensamientos durante un proyecto. El poder de usar Jupyter Notebooks también debería ser evidente, y cubrimos muchos clientes potenciales para que comience a explorar más funciones avanzadas en sus propios proyectos.

Si desea obtener más inspiración para sus propios cuadernos, Jupyter ha creado una galería de cuadernos de Jupyter interesantes que pueden resultarle útiles y la página de inicio de Nbviewer. enlaces a algunos ejemplos realmente elegantes de cuadernos de calidad.