Puntos clave: Los Cuadernos Jupyter son una herramienta vital para la analítica de datos, ofreciendo un entorno interactivo para la codificación y la visualización. La guía detalla los métodos de instalación mediante Pipenv y Anaconda y explica componentes clave como cuadernos, kernels y celdas para una gestión eficaz de datos.
- Soporta múltiples lenguajes de programación, principalmente Python.
- Combina código, salidas y medios enriquecidos en un único formato de documento.
La importancia del análisis de datos está creciendo de forma constante en todos los sectores. Contar con herramientas adecuadas de análisis y visualización de datos se ha vuelto más importante que nunca. Jupyter Notebooks está una de las principales herramientas de código abierto para desarrollar y gestionar análisis de datos.
Jupyter comenzó su vida como una rama del proyecto iPython en 2014, y ha evolucionado hasta convertirse en una plataforma interactiva completa de ciencia de datos. Gestionado por la organización sin ánimo de lucro Project Jupyter, Jupyter tiene como objetivo ofrecer la plataforma de ciencia de datos más completa.
En este artículo, te mostraremos cómo configurar y configurar un entorno local de Jupyter. Tú puedes utilizar este tutorial como el punto de partida perfecto para comenzar el trabajo de análisis de datos.
¿Qué es un Cuaderno Jupyter?
Jupyter Notebook están una aplicación web de código abierto que proporciona un entorno computacional interactivo. Produce documentos (cuadernos) que combinan tanto entradas (código) como salidas en un solo archivo. Ofrece un único documento que contiene:
- Visualizaciones
- Ecuaciones matemáticas
- Modelado estadístico
- Texto narrativo
- Cualquier otro medio rico
Este enfoque de documento único permite a los usuarios desarrollar, visualizar los resultados y añadir información, gráficos y fórmulas que Haz el trabajo más comprensible, repetible y compartible.
Los cuadernos Jupyter soportan más de 40 lenguajes de programación, con un enfoque especial en Python. Dado que están una herramienta libre y de código abierto, cualquiera puede utilizarla libremente para sus proyectos de ciencia de datos. Son dos variantes del cuaderno Jupyter:
- Jupyter Classic Notebook, con todas las capacidades mencionadas anteriormente.
- JupyterLab, una nueva interfaz de portátil de próxima generación diseñada para ser mucho más extensible y modular, con soporte para una amplia variedad de flujos de trabajo, desde ciencia de datos, aprendizaje automático y computación científica.
Hoy en día, JupyterLab es el cuaderno predeterminado para cualquier proyecto Jupyter.
(Obtén con estas herramientas de Python.)
Instalación de Jupyter Notebook (JupyterLab)
Son múltiples formas de instalar y utilizar Jupyter Notebooks, desde instalar vía conda, mamba, pip, pipenv o incluso como contenedor Docker.
En esta sección, hablamos de dos métodos para instalar Jupyter Notebooks en tu entorno local. (Por favor, consulta la documentación oficial de Jupyter Notebook para conocer todos los métodos de instalación.) Utilizaremos Windows como entorno del sistema operativo para configurar JupyterLab.
Instala vía Pipenv
Pipenv permite a los usuarios Crea un entorno virtual determinista reproducible con una gestión adecuada de dependencias para proyectos Python. Como Jupyter viene como un paquete pip, podemos simplemente instalarlo en este entorno virtual.
Primero, vamos a Crea una carpeta que actúa como entorno virtual. En este ejemplo, tenemos una carpeta llamada "jupyter_notebook" que se usará para Crea el entorno usando Pipenv.
Simplemente ejecuta el siguiente comando para iniciar esta carpeta y configura la versión de Python a la 3.8. Sin embargo, podemos utilizar cualquier versión de Python compatible para esto.
| pipenv --python 3.8 |
Luego ejecuta el siguiente comando para instalar el paquete Jupyter mediante pip:
| Pipenv instala Jupyterlab |
Por último, podemos ejecutar JupyterLab usando el comando run.
| Pipenv dirige Jupyter Lab |
Tras ejecutar JupyterLab, podremos acceder a la instalación de JupyterLab a través de la URL proporcionada (https://localhost:8888).
De este modo, el método Pipenv ofrece un entorno JupyterLab aislado para trabajar sin conflictos con:
- Cualquier otro proyecto de Python
- Escenarios
- Paquetes instalados globalmente
Instala a través del kit de herramientas de ciencia de datos Anaconda
Anaconda está una distribución de código abierto de lenguajes de programación Python y R que tiene como objetivo simplificar el despliegue y la gestión de paquetes. Viene con sus propios conceptos:
- Sistema de gestión de paquetes (conda)
- Capacidades del entorno virtual
- Paquetes de software orientados a proyectos de ciencia de datos
La edición individual de anaconda te permite configurar rápidamente un entorno local de ciencia de datos simplemente instalando el paquete de instalación de anaconda.
Ahora, vamos a instalar Jupyter Notebook vía Anaconda. Primero, navega por la web de Anaconda y descarga el paquete de instalación de Individual Edition adecuado para tu entorno de sistema operativo.
Luego instala el software en la máquina local usando el instalador (paquete .exe).
Después de eso, abre la aplicación recién instalada llamada Anaconda Navigator una vez que la instalación están completada. están la interfaz gráfica utilizada para instala aplicaciones y paquetes para el entorno conda. te notará que tanto Jupyter Notebook como JupyterLab son disponibles en la sección de aplicaciones de Anaconda Navigator.
A continuación, selecciona el tipo de portátil que prefieras e instala. Después de eso, haz clic en el botón "Iniciar" para Comienza el Cuaderno Jupyter. Esto abrirá una ventana del navegador con el cuaderno abierto.
Por defecto, Juptyper obtén acceso a todos los archivos y carpetas dentro de la ubicación de inicio. Esta es la ubicación de instalación de Anaconda, mientras que es la ubicación de carpetas del entorno virtual de Pipenv.
Crear un cuaderno
Ya que hemos completado el proceso de instalación, ahora podemos pasar a crear un Cuaderno. Haz clic en el botón del cuaderno en la página principal de la interfaz web de JupyterLab o navega a Archivo > Nuevo > Cuaderno para Crea un nuevo cuaderno.
Esto abrirá un nuevo cuaderno sin título llamado untitled.ipynb, donde podremos Comienza a programar nuestro proyecto.
Componentes del cuaderno Jupyter
En esta sección, abordaremos los componentes principales del cuaderno Jupyter que son esenciales para interactuar con el entorno Jupyter.
El archivo ipynb
El archivo .ipynb están la extensión utilizada para Define un único cuaderno. Este archivo contiene todos los datos de tu cuaderno en formato JSON. Además, incluye todo el contenido de celdas, archivos anexos de imágenes como cadenas convertidas y metadatos relacionados con el cuaderno.
Crea un cuaderno sencillo llamado test.ipynb y añadamos allí una instrucción simple de impresión, como se muestra a continuación.
Ahora, si abrimos el archivo test.ipynb como archivo JSON, podemos Ve cómo está almacenada toda la información relacionada con el cuaderno.
Núcleo de notebooks
El núcleo actúa como el cerebro del cuaderno. Cualquier código dentro de una celda se ejecutará en el núcleo y la salida están devuelta al cuaderno. El núcleo considera todo el documento (cuaderno) como una sola entidad y mantiene el estado entre celdas.
En el siguiente ejemplo, hemos definido una variable (data_x) en una celda y accedido a la misma variable en una celda separada para un cálculo simple de suma.
Si necesitamos borrar todas las variables, podemos simplemente reiniciar el núcleo o utilizar otras opciones como "Reiniciar y limpiar todas las salidas" o "Ejecutar todas las celdas" según el resultado requerido. Además, tenemos la opción de interrupción para detener el núcleo si está atascado debido a un problema computacional.
El núcleo también determina el lenguaje de programación soportado en el cuaderno, desde Java, Scala, R, Lua, etc. Además, los usuarios pueden instalar cualquier núcleo compatible y utilizarlo para Crear un cuaderno. Algunos núcleos como el núcleo SoS extienden el soporte para múltiples lenguajes en un solo cuaderno.
Celdas en un cuaderno
Las celdas son los bloques de construcción de un cuaderno. Todo lo que hacemos en un cuaderno, lo hacemos dentro de un bloque de celdas específico. son Hay dos tipos de celdas en un cuaderno:
- Celda de código. Estas celdas contienen el código que se ejecutará en el kernel. Cuando se están ejecutado el cuaderno, la salida resultante se mostrará debajo de la celda de código (fuera de la celda).
- Celda Markdown. Estas celdas contienen el contenido de texto usando Markdown. En tiempo de ejecución, el resultado se generará en el lugar de la celda de markdown.
Tipos celulares:
Celdas en tiempo de ejecución:
Celdas en tiempo de ejecución:
Hay dos modos para todo tipo de celdas son llamados modo de edición y modo de comando:
- Cuando hacemos clic en una celda y Comienza a editar, cambia su aspecto con un borde azul para indicar el modo de edición.
- Cuando salimos de la celda, cambia a un cuadro gris para indicar el modo de comando.
Modo de edición móvil:
Modo de comando celda:
Modo de comando celda:
Empezar con el análisis de datos
Ahora que podemos instalar Jupyter Notebooks y entender sus componentes principales, vamos a realizar análisis de datos y visualizaciones usando el Notebook.
Primero, Crea un nuevo cuaderno llamado "race_data". Vamos a utiliza el conjunto de datos del Campeonato Mundial de Fórmula 1 (1950-2021) disponible de Kaggle para este análisis.
El objetivo de este análisis está identificar el piloto con más victorias en F1. Antes de empezar, Haz de te haber instalado las librerías necesarias para el entorno Python. Tú puedes utilizar el comando "pipenv instala" para instalar Pipenv y utilizar conda para instalar Anaconda.
Paso 1
Importa los datos del conjunto de datos de Kaggle (archivo .csv) a los marcos de datos de Pandas.
| importar numpy como np importar pandas como pd# Importar datos results_dataframe = pd.read_csv('G:\data\results.csv') circuits_dataframe = pd.read_csv('G:\data\circuits.csv') drivers_dataframe = pd.read_csv('G:\data\drivers.csv') races_dataframe = pd.read_csv('G:\data\races.csv') constructor_dataframe = pd.read_csv('G:\data\constructors.csv') |
Paso 2
Verifica la importación imprimiendo algunos marcos de datos.
| # Imprime el marco de datos de resultados results_dataframe.head()# Imprime el marco de datos de los controladores drivers_dataframe.cabeza() |
Paso 3
Únete todas las tramas de datos para Crea una única trama de datos primaria que contenga todos los datos necesarios.
|
# Unir tramas de datos driver_result_dataframe = pd.merge(results_dataframe,drivers_dataframe,on='driverId') race_result_dataframe = pd.merge(driver_result_dataframe,races_dataframe,on='raceId') complete_race_data_dataframe = pd.merge(race_result_dataframe,constructor_dataframe,on='constructorId') complete_race_data_dataframe.cabeza() |
Paso 4
Limpia el marco de datos. Eliminaremos todas las columnas innecesarias del marco de datos.
| complete_race_data_dataframe = complete_race_data_dataframe.drop (columns=['url_x','url_y','name_y','nationality_y','url', 'time_y']) complete_race_data_dataframe.head() |
|---|
Paso 5
Calcula el total de victorias de cada piloto. En el siguiente bloque de código, nosotros:
- Filtra los datos de la carrera para que contengan solo los termines de la primera posición y Crea una nueva columna entera llamada "position_mod".
- Agrupa los datos por las columnas "driverRef" y "nationality_x" con la suma de las postion_mod.
- Ordena los datos por orden descendente y recupera las primeras diez filas.
| # Filtrar y calcular resultados total_wins = complete_race_data_dataframe[(complete_race_data_dataframe['posición']== '1')] total_wins['position_mod'] = total_wins['posición'].astipo(int) total_wins = total_wins.groupby(['driverRef','nationality_x'])['position_mod'].sum().reset_index() total_wins = total_wins.valores_sort(by=['position_mod'], ascendente=Falso) total_wins = total_wins.cabeza(10) |
Paso 6
Crea un gráfico de barras usando el nuevo conjunto de datos recuperado en el Paso 5 utilizando la biblioteca plotly.
| importar plotly.graph_objects como se fuera de Plotly.Offline Import Iplot Importación plotly.io como PIO pio.renderers.default = "iframe"# Crea gráfico de barras gráfico = ya. Figura(data=[ir. Bar( x= total_wins['driverRef'], y= total_wins['position_mod'], hovertext = total_wins['nationality_x'] )])chart.update_layout(título={ 'texto': "TOP 10 PILOTOS CON MÁS VICTORIAS EN F1", 'y':0.9, 'x':0.5, 'xanchor': 'centro', 'yanchor': 'top'}, yaxis=dict( título='No hay victorias', titlefont_size=16, tickfont_size=14), xaxis=dict( título='Conductor', titlefont_size=16, tickfont_size=14), plantilla = "plotly_dark" ) iplot(gráfico) |
Gráfico creado
Comienza el análisis de datos con Jupyter
Jupyter Notebooks están el lugar ideal para Obtén una Comienza en el campo del análisis de datos. Jupyter ofrece un entorno rico en funciones, robusto y fácil de usar utilizando múltiples métodos de instalación. Los usuarios pueden utilizar Jupyter en cualquier entorno, independientemente de la plataforma.
Lecturas relacionadas
- BMC Machine Learning & Big Data
- Habilitando a los científicos de datos ciudadanos
- Certificaciones en Ciencia de Datos: Una Introducción
- Arquitectura de datos explicada: Componentes, estándares y arquitecturas cambiantes
- Métodos de aprendizaje automático supervisados, no supervisados y otros
- Ética de los Datos para Empresas
Estas publicaciones son mías y no representan necesariamente la posición, estrategias u opinión de BMC.