Contenido del curso
Ejecución de Notebooks en Deepnote con %run
¡Hola! Te doy la bienvenida a este pequeño tutorial para conocer cómo ejecutar las funciones de una Jupyter Notebook dentro de otra en Deepnote.
Por una actualización de Deepnote notarás que ahora las Notebooks están separadas de los archivos (Files).
Por esta actualización tendrás que subir la notebook al sistema de archivos de Deepnote, para poder ejecutarla dentro de otra notebook utilizando la magia %run.
Tendrás que hacer lo anterior en tu proyecto de Deepnote del curso, ya que utilizaremos una notebook llamada pandas-missing-extension.ipynb dentro de nuestra notebook principal para utilizar métodos predefinidos en ella. Por ahora, no te preocupes por el contenido de esa notebook, en la siguiente clase hablaremos de ello. 🤗
Sigue estos pasos para subir tu notebook como archivo (File) a Deepnote:
pandas-missing-extension y da clic sobre Export as .ipynb. Esto descargará la notebook a tu computadora.
Después da clic en en el signo de + en la sección FILES y sube la notebook pandas-missing-extension.ipynb que descargaste en el paso anterior en la opción Upload File.
Repite los pasos 1-3 cada vez que desees subir la notebook pandas-missing-extension.ipynb a la sección FILES. dentro de tu proyecto en Deepnote.
Para terminar, ejecuta la siguiente línea dentro de la notebook exploration-missing-values o live-exploration-missing-values para cargar las funciones de la notebbok pandas-missing-extension.ipynb y poder utilizarlas.
¡Nos vemos en la próxima clase! Conoceremos cómo funciona la notebook donde extendemos Pandas para manejar valores faltantes! 🤓✨
si no entiendes que hace %run
La línea de código "%run pandas-missing-extension.ipynb" se utiliza en el entorno de Deepnote para ejecutar un archivo de notebook de Jupyter llamado "pandas-missing-extension.ipynb".
Este comando carga y ejecuta el notebook en la sesión actual de Deepnote, lo que significa que cualquier código contenido en el notebook se ejecutará como si se hubiera copiado y pegado directamente en la sesión de Deepnote.
En particular, es probable que el notebook "pandas-missing-extension.ipynb" contenga definiciones de funciones o variables que se utilizarán posteriormente en la sesión de Deepnote. Al ejecutar el notebook, se asegura que estas definiciones estén disponibles en la sesión actual y puedan ser utilizadas en el análisis de datos o en cualquier otro trabajo que se esté realizando en Deepnote.
Descubre los comandos mágicos de Jupyter Notebook: una guía para mejorar tu productividad 🧙
In Jupyter Notebook, %run is a magic command that allows you to run external Python scripts or modules within the notebook environment. When you use %run, Jupyter Notebook executes the specified script or module as if you were running it from the command line.
Here's how %run is typically used:
%run script.py: This command runs the Python script script.py in the current notebook cell. The script can contain multiple lines of code, and any output or results generated by the script will be displayed in the notebook output area.
%run -i script.py: The -i flag allows the script to interact with the notebook's namespace. This means that any variables or functions defined in the script will be accessible in the notebook after running it.
%run -t script.py: The -t flag runs the script under the Python profiler. It provides detailed timing information about each function call and line of code, helping you analyze the script's performance.
Using %run is a convenient way to execute external Python scripts and incorporate their functionality or results into your Jupyter Notebook workflow.
Estoy trabajando en Visual Studio Code
Si también trabajas en VSCode, sigue este tutorial para importar pandas-missing-extension como un modulo para nuestro notebook principal:
Tutorial para Importar un Jupyter Notebook como Módulo en otro Notebook
Pasos Preliminares
pandas-missing-extension.ipynb) en la misma carpeta donde se encuentra el notebook en el que deseas importar el contenido.Exportación del Notebook a un Script de Python
pandas-missing-extension.ipynb con Visual Studio Code.... > Exportar > Script de Python. Esto convertirá tu notebook en un script .py.pandas_missing_extension.py.Importación del Módulo en el Notebook Destino
pandas-missing-extension.ipynb.import pandas_missing_extensionVerificación y Uso del Módulo Importado
Usar el Módulo:
pandas-missing-extension.ipynb tenía una función llamada clean_data, puedes usarla así:pythonCopy codecleaned_data = pandas_missing_extension.clean_data(raw_data)Manejo de Errores:
Prueba del Código:
Consejos Finales
Este tutorial te ayudará a importar eficientemente el contenido de un notebook de Jupyter en otro, utilizando Visual Studio Code, de una manera que es fácil de seguir y de replicar en el futuro.
Les dejo el código del archivo pandas-missing-extension corregido para que no anden batallando, porque vengo del futuro y da error en algunas partes
Simplemente vayan al archivo pandas-missing-extension.ipynb y cambien el código que hay allí por esto
import itertools import pandas as pd import upsetplot
try: del pd.DataFrame.missing except AttributeError: pass
@pd.api.extensions.register_dataframe_accessor("missing") class MissingMethods: def __init__(self, pandas_obj): self._obj = pandas_obj def number_missing(self) -> int: return self._obj.isna().sum().sum() def number_complete(self) -> int: return self._obj.size - self._obj.missing.number_missing() def missing_variable_summary(self) -> pd.DataFrame: return self._obj.isnull().pipe( lambda df_1: ( df_1.sum() .reset_index(name="n_missing") .rename(columns={"index": "variable"}) .assign( n_cases=len(df_1), pct_missing=lambda df_2: df_2.n_missing / df_2.n_cases * 100, ) ) ) def missing_case_summary(self) -> pd.DataFrame: return self._obj.assign( case=lambda df: df.index, n_missing=lambda df: df.apply( axis="columns", func=lambda row: row.isna().sum() ), pct_missing=lambda df: df["n_missing"] / df.shape[1] * 100, )[["case", "n_missing", "pct_missing"]] def missing_variable_table(self) -> pd.DataFrame: return ( self._obj.missing.missing_variable_summary() .value_counts("n_missing") .reset_index(name="n_variables") .rename(columns={"n_missing": "n_missing_in_variable"}) .assign( pct_variables=lambda df: df.n_variables / df.n_variables.sum() * 100 ) .sort_values("pct_variables", ascending=False) ) def missing_case_table(self) -> pd.DataFrame(): return ( self._obj.missing.missing_case_summary() .value_counts("n_missing") .reset_index(name="n_cases") .rename(columns={"n_missing": "n_missing_in_case"}) .assign(pct_case=lambda df: df.n_cases / df.n_cases.sum() * 100) .sort_values("pct_case", ascending=False) ) def missing_variable_span(self, variable: str, span_every: int) -> pd.DataFrame: return ( self._obj.assign( span_counter=lambda df: ( np.repeat(a=range(df.shape[0]), repeats=span_every)[: df.shape[0]] ) ) .groupby("span_counter") .aggregate( n_in_span=(variable, "size"), n_missing=(variable, lambda s: s.isnull().sum()), ) .assign( n_complete=lambda df: df.n_in_span - df.n_missing, pct_missing=lambda df: df.n_missing / df.n_in_span * 100, pct_complete=lambda df: 100 - df.pct_missing, ) .drop(columns=["n_in_span"]) .reset_index() ) def missing_variable_run(self, variable) -> pd.DataFrame: rle_list = self._obj[variable].pipe( lambda s: [[len(list(g)), k] for k, g in itertools.groupby(s.isnull())] ) return pd.DataFrame(data=rle_list, columns=["run_length", "is_na"]).replace( {False: "complete", True: "missing"} ) def sort_variables_by_missingness(self, ascending = False): return ( self._obj .pipe( lambda df: ( df[df.isna().sum().sort_values(ascending = ascending).index] ) ) ) def create_shadow_matrix( self, true_string: str = "Missing", false_string: str = "Not Missing", only_missing: bool = False, ) -> pd.DataFrame: return ( self._obj .isna() .pipe(lambda df: df[df.columns[df.any()]] if only_missing else df) .replace({False: false_string, True: true_string}) .add_suffix("_NA") ) def bind_shadow_matrix( self, true_string: str = "Missing", false_string: str = "Not Missing", only_missing: bool = False, ) -> pd.DataFrame: return pd.concat( objs=[ self._obj, self._obj.missing.create_shadow_matrix( true_string=true_string, false_string=false_string, only_missing=only_missing ) ], axis="columns" ) def missing_scan_count(self, search) -> pd.DataFrame: return ( self._obj.apply(axis="rows", func=lambda column: column.isin(search)) .sum() .reset_index() .rename(columns={"index": "variable", 0: "n"}) .assign(original_type=self._obj.dtypes.reset_index()[0]) ) # Plotting functions --- def missing_variable_plot(self): df = self._obj.missing.missing_variable_summary().sort_values("n_missing") plot_range = range(1, len(df.index) + 1) plt.hlines(y=plot_range, xmin=0, xmax=df.n_missing, color="black") plt.plot(np.array(df.n_missing), plot_range, 'o', color="black") plt.yticks(plot_range, df.variable) plt.grid(axis="y") plt.xlabel("Number missing") plt.ylabel("Variable") def missing_case_plot(self): df = self._obj.missing.missing_case_summary() sns.displot(data=df, x="n_missing", binwidth=1, color="black") plt.grid(axis="x") plt.xlabel("Number of missings in case") plt.ylabel("Number of cases") def missing_variable_span_plot( self, variable: str, span_every: int, rot: int = 0, figsize=None ): ( self._obj.missing.missing_variable_span( variable=variable, span_every=span_every ).plot.bar( x="span_counter", y=["pct_missing", "pct_complete"], stacked=True, width=1, color=["black", "lightgray"], rot=rot, figsize=figsize, ) ) plt.xlabel("Span number") plt.ylabel("Percentage missing") plt.legend(["Missing", "Present"]) plt.title( f"Percentage of missing values\nOver a repeating span of { span_every } ", loc="left", ) plt.grid(False) plt.margins(0) plt.tight_layout(pad=0) def missing_upsetplot(self, variables: list[str] = None, **kwargs): if variables is None: variables = self._obj.columns.tolist() return ( self._obj.isna() .value_counts(variables) .pipe(lambda df: upsetplot.plot(df, **kwargs)) )
Gracias, compañero.
Como haría para importar el codigo así en visualcode, con import??
Sobre las carpetas no hay que preocuparse aparentemente, no haces nada esos pasos, luego usas el %run. Me dio curiosidad y estuve probando.
Sí pude importar funciones de un .py a un .ipynb con el from/import. Sí pude importar funciones de un .py a un .py con el from/import. No pude importar funciones de un .ipynb a un .py con el import ni con el %run. Podría exportarse a .py. SI pude importar funciones de un .ipynb a un .ipynb con el %run
Nueva funcionalidad... Mue buena!
que cvr funcion poder ejecutar un notebook denro de otro notebook con %run <notebook>
Creo que es mas facil usar un entorno virtual con jupyter en vscode asi que voy a ignorar todos estos pasos...
Cómo se haría en Google colab?
Debería ser muy parecido. Solo busca en la barra lateral la opcion de subir archivos. Luego ejecutas la linea de codigo y listo.
Super wow
Buenísimo!