Requisitos previos

¡Felicidades por comenzar tu camino en la ciencia de datos! En este capítulo te ayudaremos a instalar o acceder a las herramientas que necesitas para empezar a aprender y practicar ciencia de datos. Para que aproveches este libro al máximo, hemos asumido algunas cosas sobre lo que ya sabes. Deberías tener una base numérica general, y es útil que ya tengas algo de experiencia en programación.

Introducción

Te ayudaremos a configurar:

un entorno de desarrollo integrado, o IDE, un lugar donde escribir y ejecutar código
una instalación de Python, para que tu computadora pueda interpretar y ejecutar código Python
la instalación de paquetes, que amplían la funcionalidad de Python

Aunque más adelante habrá mucha más información sobre el cómo, primero dediquemos un momento a explicar qué son estas cosas.

Entorno de desarrollo integrado, o IDE

Un entorno de desarrollo integrado (IDE) es una aplicación de software que ofrece algunas herramientas para facilitar la programación. ¡La más importante de ellas es una forma de escribir el propio código! Los IDE no son la única manera de programar, pero quizá sean la más útil. Ten en cuenta que el lenguaje y el lugar donde lo escribes (el IDE) son cosas distintas: el lenguaje es una forma de procesar tus instrucciones y el IDE es donde escribes esas instrucciones. Existen muchísimos entornos de desarrollo integrados (IDE). Este libro recomienda encarecidamente Visual Studio Code de Microsoft, que funciona en todos los sistemas operativos principales y es uno de los más populares. Estas son algunas de las funciones útiles que ofrece Visual Studio Code:

una forma de ejecutar tu código de manera interactiva (línea por línea) o todo de una vez
una forma de depurar (buscar errores en) tu código
una forma rápida de acceder a información útil sobre los paquetes de software más utilizados
formato automático del código, para que siga las pautas de buenas prácticas
autocompletado de tu código al pulsar TAB
comprobación automática del código en busca de errores básicos
¡coloreado de los paréntesis por pares para que puedas seguir el orden lógico de ejecución de tu código!

Un intérprete de Python

Python es a la vez un lenguaje de programación que tú puedes leer y un lenguaje que las computadoras pueden leer, interpretar y a partir del cual pueden ejecutar instrucciones. Para que tu computadora pueda leer y ejecutar código Python, necesitarás instalar Python en ella. Hay muchas formas de instalar un “intérprete” de Python en tu computadora, pero este libro recomienda la distribución uv de Python por su flexibilidad y sencillez.

Paquetes

Un paquete de Python es una colección de funciones, datos y documentación que amplía las capacidades de una versión instalada de Python. Usar paquetes es clave en la mayor parte de la ciencia de datos, porque la mayoría de la funcionalidad que necesitaremos proviene de paquetes adicionales. Verás instrucciones como import numpy as np al principio de muchos scripts de Python: son instrucciones para usar un paquete instalado (aquí uno llamado numpy) y darle un nombre abreviado (np, por comodidad) en el resto del script. Después se accede a las funciones del paquete numpy mediante una sintaxis como np.; por ejemplo, puedes calcular logaritmos con np.log(x), donde x es una variable que contiene un número. Solo necesitas instalar los paquetes una vez.

Flujo de trabajo típico

El flujo de trabajo típico para un análisis con código podría ser algo así:

Abre tu entorno de desarrollo integrado (IDE)
Escribe algo de código en un script (un archivo de texto que contiene código) en tu IDE
Si es necesario para el análisis que estás haciendo, instala los paquetes adicionales
Usa el IDE para enviar fragmentos de código del script, o el script completo, para que los ejecuten Python y los paquetes complementarios, y para mostrar los resultados

Veremos dos formas de lograr este flujo de trabajo:

Instalar un IDE, Python y los paquetes adicionales en tu propia computadora
Usar una computadora en la nube a la que accedes desde tu navegador de internet. La computadora en la nube trae un IDE y Python integrados, y también puedes instalar fácilmente paquetes adicionales en ella. Sin embargo, la versión gratuita está limitada a 60 horas al mes.

¡Elige la opción con la que te sientas más cómodo! Con el tiempo, probablemente pruebes ambas.

Cómo empezar en tu propia computadora

Estas instrucciones son para el caso en que vayas a trabajar con Python localmente, en tu propia computadora.

Instalar Python

Para descargar e instalar Python, usaremos la “distribución” uv de Python, que está disponible en todos los sistemas operativos principales. Para instalarla, sigue las instrucciones de este sitio web. A diferencia de la instalación de programas normales, vamos a usar la línea de comandos para instalar Python. Linux, Mac y Windows tienen líneas de comandos integradas: busca Terminal en Mac o Linux, y Powershell en Windows. Estas aplicaciones abrirán ventanas en las que puedes escribir comandos. En el momento de escribir esto, los comandos son:

curl -LsSf https://astral.sh/uv/install.sh | sh

para Linux y Mac, y

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

para Windows. Pulsa Enter para ejecutar los comandos.

Una vez que hayas instalado uv, puedes comprobar que se instaló correctamente ejecutando uv --version. Deberías ver un mensaje que dice “uv” seguido del número de la versión más reciente.

En realidad todavía no hemos descargado Python: descargamos uv, que se encargará de gestionar nuestro entorno de Python. Así que a continuación tenemos que ejecutar

uv python install

Instalar tu entorno de desarrollo integrado, Visual Studio Code

Visual Studio Code es un IDE gratuito y open source de Microsoft, disponible en todos los sistemas operativos principales. Al igual que Python, Visual Studio se puede ampliar con paquetes, y son esos paquetes, llamados en este caso extensiones, los que lo hacen tan útil. Además de Python, Visual Studio Code admite muchísimos otros lenguajes.

Descarga e instala Visual Studio Code. Si necesitas ayuda, a continuación hay un video que te guía en la descarga e instalación de Visual Studio Code y luego en su uso para ejecutar código Python tanto en scripts como en notebooks. Repasaremos estas instrucciones en detalle en el resto de este capítulo.

Ten en cuenta que, si vas a probar los notebooks y la ventana interactiva, necesitarás crear una carpeta nueva y trabajar en ella en Visual Studio Code. Una vez que hayas abierto explícitamente una carpeta en VS Code, abre la línea de comandos dentro de Visual Studio Code y ejecuta uv init para crear una instalación de Python, y uv add jupyter para dotar a este incipiente entorno de Python de lo necesario para crear ventanas interactivas.

Cómo instalar Visual Studio Code y usarlo para ejecutar código Python

Ciencia de datos en la nube

Estas instrucciones son para el caso en que planees hacer ciencia de datos de forma remota, usando una computadora en la nube.

Hay muchas formas de hacer ciencia de datos en la nube, pero vamos a mostrarte la más sencilla de todas. Para ello, necesitarás registrarte en una cuenta de Github. Github es una organización propiedad de Microsoft que ofrece diversos servicios, entre ellos una forma de respaldar código en la nube y computación en la nube. Uno de los servicios que ofrece es Github Codespaces. Un GitHub Codespace es una computadora en la nube a la que te conectas desde la ventana de tu navegador. Ofrece unas generosas 60 horas gratuitas de cómputo al mes.

Nota

Si superas las horas del nivel gratuito de GitHub Codespaces, se cobrará en tu tarjeta de crédito cualquier hora adicional de GitHub Codespaces que utilices.

Una vez que te hayas registrado en Github, ve a Github Codespaces y haz clic en “Get Started for Free”. Deberías ver un menú de “quick start templates” (plantillas de inicio rápido). Debajo de donde dice “Jupyter Notebook”, pulsa “Use this template”.

Verás que se carga una página nueva con varios paneles. Es una versión en línea de Visual Studio Code que funciona de forma muy parecida a si lo hubieras instalado en tu propia computadora. Ya tendrá una versión de Python instalada; puedes comprobar cuál ejecutando python --version en la terminal. La terminal suele encontrarse en el panel inferior de Visual Studio Code y, en Codespaces, normalmente mostrará un mensaje de bienvenida.

Sin embargo, ten en cuenta que la distribución de Python en Codespaces podría ser distinta de la de uv que usamos en el libro. Pero puedes instalar uv en tu máquina de Codespaces y seguir las demás instrucciones de la sección “Instalar Python” anterior.

Ejecutar tu primer código Python

Familiarizarse con Visual Studio Code

Una vez que tengas Visual Studio Code instalado y abierto (ya sea en tu propia computadora o en la nube), ve a la pestaña de ‘extensiones’ en la barra vertical de iconos del lado izquierdo (es la que parece 4 cuadrados). Necesitarás instalar la extensión de Python para VS Code, que puedes buscar con el cuadro de texto del panel de extensiones de VS Code. Si usas la versión en la nube, es posible que ya esté instalada.

Hay otras extensiones que conviene tener e instalar (si aún no las tienes):

Jupyter
Pylance
indent-rainbow

Aunque todavía no tendrás código Python con el que experimentar, ni una ventana interactiva para ejecutarlo, vale la pena dedicar un momento a familiarizarnos con las distintas partes de una vista típica de Visual Studio Code.

Una vista típica de usuario en Visual Studio Code

La figura anterior muestra la disposición típica de Visual Studio Code cuando tienes una sesión de Python en ejecución y un script de Python abierto. El panel vertical largo del extremo izquierdo cambia lo que se ve en los paneles 1 y 2; ahora mismo tiene seleccionado el explorador de archivos. Repasemos las partes numeradas de la figura.

Cuando se selecciona la opción del explorador entre los iconos a la izquierda de 1 y 2, el contenido de la carpeta abierta se muestra en 1.
Es un esquema de las partes clave del archivo abierto en 3.
Es simplemente un editor de texto sofisticado. En la figura anterior, muestra un script de Python (un archivo que contiene código y cuyo nombre termina en .py). En breve veremos cómo, al seleccionar código y pulsar Shift + Enter (‘Enter’ aparece como ‘Return’ en algunos teclados), se ejecuta el código y sus resultados aparecen en el panel 5.
Es la línea de comandos o terminal, un lugar donde puedes escribir comandos que tu computadora ejecutará. Si quieres probar un comando, escribe date (Mac/Linux) o date /t (Windows). Aquí es donde instalamos paquetes adicionales.
Es la ventana interactiva de Python, donde aparecen el código y sus resultados después de seleccionarlo y ejecutarlo desde un script (ver 3). Muestra el código que ejecutaste y cualquier resultado de esa ejecución; en la captura mostrada, el código ha creado un gráfico. El nombre y la versión de Python que usas aparecen en la parte superior de la ventana interactiva.

Observa que hay mucha información útil en la barra azul de la parte inferior de la ventana, incluida la versión de Python que está usando VS Code.

Ejecutar código Python

Ahora vas a crear y ejecutar tu primer código. Si te atascas, hay un tutorial más detallado en la documentación de VS Code.

En Visual Studio Code, haz clic en el símbolo “Explorer” (unos archivos en el lado izquierdo de la pantalla) para abrir un explorador de archivos. Comprueba que estás en una ubicación adecuada de tu computadora para hacer pruebas y, si no, cambia de carpeta con File -> Open Folder hasta que estés conforme.

Ahora abre una terminal dentro de Visual Studio Code. Asegúrate de que sea el mismo tipo de terminal en el que instalaste uv, por ejemplo, usa Powershell en Windows (puedes elegir distintos tipos de terminal). El atajo para abrir el panel de la terminal es Ctrl + ` en Linux y Windows, y Cmd + ` en Mac. El panel de la terminal aparece en la parte inferior de VS Code. Ejecuta uv init en la terminal para iniciar una instalación de Python. Esta instalación de Python solo existe en tu carpeta actual. Después, para instalar el paquete que necesitamos en esta sección, ejecuta uv add jupyter. (Veremos la terminal y la instalación de paquetes con mucho más detalle en breve).

Ahora, con el panel del explorador todavía abierto a la izquierda, haz clic en el símbolo que parece una hoja en blanco con un signo “+”. Esto creará un archivo nuevo y el cursor se moverá para que le pongas nombre. Llámalo hello_world.py. La extensión del archivo, .py, es muy importante, ya que le indica implícitamente a Visual Studio Code que se trata de un script de Python.

En el editor de Visual Studio Code, añade una sola línea al archivo:

print('Hello World!')

Guarda el archivo.

Si le pusiste la extensión .py al archivo, VS Code reconocerá que es código Python y deberías ver aparecer el nombre y la versión de Python en la barra de la parte inferior de la ventana de VS Code. (Puedes tener varias versiones de Python instaladas; si alguna vez quieres cambiar la versión de Python que usa tu código, haz clic en la versión que aparece en la barra y selecciona la que quieras).

Bien, ¿vamos a ejecutar código de verdad? Selecciona/resalta el texto print("Hello world!") que escribiste en el archivo y haz clic derecho. Verás muchas opciones, pero la que quieres es “Run Selection/Line in Interactive Window”.

Esto debería hacer que aparezca un nuevo panel ‘interactivo’ en Visual Studio Code y, como por arte de magia, deberías ver:

print("Hello world!")

Hello world!

La ventana interactiva es una forma cómoda y flexible de ejecutar el código que tienes abierto en un script o que escribes directamente en su cuadro de código. La ventana interactiva ‘recordará’ cualquier variable que se haya asignado (por ejemplo, instrucciones como x = 5), tanto si proviene de ejecutar algunas líneas del script como si la escribiste directamente. Trabajar con la ventana interactiva te resultará familiar si has usado Stata, Matlab o R. No necesitas escribir el script entero de principio a fin por adelantado. En su lugar, puedes improvisar, cambiando el código sobre la marcha y (re)ejecutándolo línea a línea.

Sería engorroso tener que hacer clic derecho cada vez que quisiéramos ejecutar código, así que vamos a crear un atajo de teclado para enviar el código resaltado a la ventana interactiva y ejecutarlo. Para ello:

Abre el menú de configuración de Visual Studio Code (el engranaje de la parte inferior izquierda)
Ve a Settings
Escribe “jupyter send” en el cuadro para que aparezca la entrada “Interactive Window > Text Editor: Execute Selection”
Asegúrate de que la casilla junto a esta entrada esté marcada

Ahora vuelve a tu script, coloca el cursor en la línea con print("Hello world!") y pulsa Shift+Enter. Deberías ver aparecer “Hello world!” de nuevo, solo que esta vez fue mucho más fácil.

Ejecutar el código en la terminal en su lugar

La ventana interactiva no es la única forma de ejecutar código; también puedes hacerlo en la terminal. Esto es menos habitual en ciencia de datos, pero a veces resulta útil. Si quieres hacerlo, haz clic derecho sobre el código seleccionado y elige “Run Python -> Run Selection/Line in Terminal”.

Aprovechemos más la ventana interactiva. En su parte inferior hay un cuadro que dice ‘Type code here and press shift-enter to run’. Escribe print('Hello World!') directamente ahí para conseguir el mismo efecto que al ejecutar la línea desde tu script. Además, cualquier variable que ejecutes en la ventana interactiva (desde tu script o escribiéndola directamente en el cuadro) se conservará.

Para ver cómo se conservan las variables, escribe hello_string = 'Hello World!' en el cuadro de código de la ventana interactiva y pulsa shift-enter. Si ahora escribes hello_string y pulsas shift+enter, verás el contenido de la variable que acabas de crear. También puedes hacer clic en el símbolo de cuadrícula de la parte superior de la ventana interactiva (entre el símbolo de detener y el de guardar archivo); es el explorador de variables y abrirá un panel con todas las variables que has creado en esta sesión interactiva. Deberías ver una llamada hello_string de tipo str con el valor Hello World!.

Esto muestra las dos formas de trabajar con la ventana interactiva: ejecutar (fragmentos) desde un script o escribir código directamente en el cuadro de entrada. No importa de qué forma introdujiste las variables: todas se recordarán durante esa sesión en tu ventana interactiva.

Inicia las ventanas interactivas y las terminales dentro del directorio de tu proyecto

En Visual Studio Code, puedes asegurarte de que la ventana interactiva se inicie en el directorio raíz de tu proyecto configurando “Jupyter: Notebook File Root” como ${workspaceFolder} en el menú Settings. Para la línea de comandos integrada, cambia también “Terminal › Integrated: Cwd” a ${workspaceFolder}.

Ejercicio

Crea un nuevo script que, al ejecutarse, imprima “Welcome to Python for Data Science” y ejecútalo en una ventana interactiva.

Instalar paquetes

Usamos la terminal o línea de comandos de Visual Studio Code para instalar paquetes adicionales de Python. En la figura mostrada antes en el capítulo, es el panel número 4.

Para instalar paquetes en el entorno de Python de la carpeta que usas en Visual Studio Code, escribe lo siguiente en la terminal de Visual Studio Code (el mismo lugar donde acabas de ejecutar uv run python --version).

uv add packagename

y pulsa Enter. En lo anterior, packagename podría ser pandas, por ejemplo. Si tienes problemas al instalar, asegúrate de estar conectado a internet y de que PyPI (el índice de paquetes de Python) no esté bloqueado por tu firewall o proxy. Podrías probar a instalar así el paquete de análisis de datos polars, ejecutando uv add polars. Veremos cómo usar polars en capítulos posteriores, pero si quieres saber si se instaló correctamente, busca el mensaje “Successfully installed polars” seguido del número de versión.

Puedes ver qué paquetes has instalado previamente escribiendo uv pip list en la línea de comandos.

Veremos más sobre la instalación y el uso de paquetes en Flujo de trabajo: paquetes y entornos.

Si tienes problemas al instalar, asegúrate de estar conectado a internet y de que PyPI (el índice de paquetes de Python) no esté bloqueado por tu firewall o proxy.

Formas alternativas de ejecutar el código del libro

Además de seguir este libro con tu propia computadora o en la nube mediante Github Codespaces, puedes ejecutar el código en línea con algunas otras opciones. La primera es la más sencilla para empezar.

Google Colab notebooks. Gratuito para la mayoría de los usos. Puedes abrir de forma interactiva la mayoría de las páginas de este libro con el botón ‘Colab’, que está bajo el símbolo del cohete en la parte superior de la página. Se abrirá como un notebook (que combina código y texto) en lugar de un script (archivo .py), pero el código que escribes es el mismo. Ten en cuenta que quizá necesites actualizar los paquetes a sus versiones más recientes. En Colab, puedes hacerlo ejecutando !pip install **packagename** en una celda de código. Fíjate en el signo de exclamación adicional, que le indica a Colab que se trata de una instrucción para el sistema operativo y no para Python.
Gitpod Workspace. Una alternativa a Codespaces. Es una versión remota de Visual Studio Code en la nube, con Python instalado, que ejecuta scripts de Python. Ten en cuenta que el plan gratuito cubre 50 horas al mes.

{ “cells”: [ { “cell_type”: “markdown”, “id”: “95f0a171”, “metadata”: {}, “source”: [ “# Funciones {#sec-functions}”, “”, “## Introducción”, “”, “Una de las mejores formas de ampliar tu alcance como científico de datos es escribir funciones.”, “Las funciones te permiten automatizar tareas comunes de una manera más potente y general que copiar y pegar.”, “Escribir una función tiene tres grandes ventajas frente a copiar y pegar:”, “”, “1. Puedes darle a una función un nombre evocador que haga tu código más fácil de entender.”, “”, “2. Cuando cambian los requisitos, solo necesitas actualizar el código en un lugar, en vez de en muchos.”, “”, “3. Eliminas la posibilidad de cometer errores accidentales al copiar y pegar (por ejemplo, actualizar el nombre de una variable en un lugar, pero no en otro).”, “”, “Escribir buenas funciones es un viaje de toda la vida.”, “Incluso después de usar Python durante muchos años, todavía puedes aprender nuevas técnicas y mejores formas de abordar viejos problemas.”, “El objetivo de este capítulo no es enseñarte cada detalle esotérico de las funciones, sino ayudarte a empezar con algunos consejos pragmáticos que puedes aplicar de inmediato.”, “”, “Además de consejos prácticos para escribir funciones, este capítulo también te da algunas sugerencias sobre cómo dar estilo a tu código.”, “Un buen estilo de código es como una puntuación correcta.”, “Puedesarreglártelassinella, ¡pero sin duda hace que todo sea más fácil de leer!”, “Al igual que con los estilos de puntuación, hay muchas variaciones posibles.”, “Aquí presentamos el estilo que usamos en nuestro código, pero lo más importante es ser coherente.”, “”, “### Requisitos previos”, “”, “Necesitarás los paquetes pandas y numpy para este capítulo.” ] }, { “cell_type”: “markdown”, “id”: “a4b99b14”, “metadata”: {}, “source”: [ “## Funciones”, “”, “Una función tiene entradas, realiza su función y devuelve las salidas que tenga. Las funciones comienzan con la palabra clave def, de ‘definir una función’. Luego tienen un nombre, seguido de paréntesis, (), que pueden contener argumentos de la función y argumentos de palabra clave. A esto le siguen dos puntos. El cuerpo de la función se indenta con respecto al texto situado más a la izquierda. Los argumentos de la función se definen entre paréntesis después del nombre, con las distintas entradas separadas por comas. Las salidas se indican con la palabra clave return, de nuevo con las distintas variables separadas por comas.”, “”, “Veamos un ejemplo muy sencillo de una función con un único argumento (o arg):” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “0450ad6c”, “metadata”: {}, “outputs”: [], “source”: [ “def welcome_message(name):”, ” return f"Hello {name}, and welcome!"“,”“,”“,”# Without indentation, this code is not part of function“,”name = "Ada"“,”output_string = welcome_message(name)“,”print(output_string)” ] }, { “cell_type”: “markdown”, “id”: “08c06c6a”, “metadata”: {}, “source”: [ “Una característica potente de las funciones es que podemos definir valores por defecto para los argumentos de entrada. Estos se llaman argumentos de palabra clave (o kwargs). Veámoslo en acción definiendo un valor por defecto para name, junto con varias salidas: un mensaje de saludo y una puntuación.” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “dd49bee5”, “metadata”: {}, “outputs”: [], “source”: [ “def score_message(score, name="student"):”, ” """This is a doc-string, a string describing a function.“,” Args:“,” score (float): Raw score“,” name (str): Name of student“,” Returns:“,” str: A hello message.“,” float: A normalised score.“,” """“,” norm_score = (score - 50) / 10“,” return f"Hello {name}", norm_score“,”“,”“,”# Without indentation, this code is not part of function“,”name = "Ada"“,”score = 98“,”# No name entered“,”print(score_message(score))“,”# Name entered“,”print(score_message(score, name=name))” ] }, { “cell_type”: “markdown”, “id”: “5c4c6cdf”, “metadata”: {}, “source”: [ “::: {.callout-note title="Argumentos y argumentos con nombre (keyword arguments)"}”, “”, “Los argumentos son las variables que las funciones necesitan siempre, como a y b en def add(a, b): return a + b. ¡La función no funcionará sin ellos! A los argumentos de una función a veces se les llama args.”, “”, “Los argumentos de palabra clave son las variables opcionales de las funciones, como c en def add(a, b, c=5): return a + b - c. Si no proporcionas un valor para c al llamar a la función, se usará automáticamente c=5. A los argumentos de palabra clave a veces se les llama kwargs.”, “:::”, “”, “”, “::: {.callout-tip title="Ejercicio"}”, “¿Cuál es el tipo de retorno de una función con varios valores de retorno separados por comas después de la instrucción return?”, “:::”, “”, “En ese último ejemplo, habrás notado que añadimos algo de texto a la función. Es un docstring, o cadena de documentación. Sirve para ayudar a los usuarios (y, muy probablemente, a tu yo del futuro) a entender qué hace la función. Veamos cómo funciona llamando a help() sobre la función score_message:” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “50dfff24”, “metadata”: {}, “outputs”: [], “source”: [ “help(score_message)” ] }, { “cell_type”: “markdown”, “id”: “6e466fcd”, “metadata”: {}, “source”: [ “::: {.callout-tip title="Ejercicio"}”, “Escribe una función que devuelva un carácter unicode de "chócala" (high five) si la entrada es igual a "coding for economists" y, en caso contrario, una cara triste, ":-/".”, “”, “Añade un segundo argumento que tome por defecto un string vacío pero que, si se usa, se añada (concatene) al mensaje devuelto. Úsalo para crear la salida ":-/ here is my message."”, “”, “Escribe un docstring para tu función y llama a help sobre ella.”, “:::”, “”, “Para aprender más sobre args y kwargs, consulta estos breves videotutoriales.” ] }, { “cell_type”: “markdown”, “id”: “58c754c0”, “metadata”: {}, “source”: [ “## ¿Cuándo deberías escribir una función?”, “”, “Deberías considerar escribir una función siempre que hayas copiado y pegado un bloque de código más de dos veces (es decir, ya tienes tres copias del mismo código).”, “Por ejemplo, echa un vistazo a este código.”, “¿Qué hace?” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “7a744085”, “metadata”: {}, “outputs”: [], “source”: [ “import numpy as np”, “import pandas as pd”, “”, “df = pd.DataFrame(np.random.normal(size=(10, 4)), columns=["a", "b", "c", "d"])”, “”, “df["a"] = (df["a"] - df["a"].min()) / (df["a"].max() - df["a"].min())”, “df["b"] = (df["b"] - df["b"].min()) / (df["b"].max() - df["a"].min())”, “df["c"] = (df["c"] - df["c"].min()) / (df["c"].max() - df["c"].min())”, “df["d"] = (df["d"] - df["d"].min()) / (df["d"].max() - df["d"].min())” ] }, { “cell_type”: “markdown”, “id”: “a5da40e0”, “metadata”: {}, “source”: [ “Quizá puedas deducir que reescala cada columna para que tenga un rango de 0 a 1.”, “Pero ¿viste el error? Hubo una equivocación al copiar y pegar el código para df[\"b\"]: alguien olvidó cambiar una a por una b.”, “Extraer el código repetido a una función es una buena idea porque evita que cometas este tipo de errores.”, “”, “Para escribir una función, primero necesitas analizar el código.”, “¿Cuántas entradas tiene?”, “”, “python\n", "df[\"a\"] - df[\"a\"].min() / (df[\"a\"].max() - df[\"a\"].min())\n", "”, “”, “Este código solo tiene una entrada: df[\"a\"]. Para que las entradas sean más claras, es buena idea reescribir el código usando variables temporales con nombres generales. Aquí el código solo requiere un único vector numérico, así que lo llamaremos x y lo pondremos en una función.”, “”, “Las funciones comienzan con la palabra clave def, de ‘definir una función’. Luego tienen un nombre, seguido de paréntesis, (), que pueden contener argumentos de la función y argumentos de palabra clave. A esto le siguen dos puntos. El cuerpo de la función se indenta con respecto al texto situado más a la izquierda. Los argumentos de la función se definen entre paréntesis después del nombre, con las distintas entradas separadas por comas. Las salidas se indican con la palabra clave return, de nuevo con las distintas variables separadas por comas.”, “”, “Así, en Python, las funciones tienen la forma:”, “”, “python\n", "def name_of_function(<inputs>):\n", " <code to carry out on inputs>\n", " <return statement, if appropriate>\n", "”, “”, “Así que aquí sería:” ] }, { “cell_type”: “markdown”, “id”: “a16d6dd0”, “metadata”: {}, “source”: [ “python\n", "def rescale(x):\n", " return (x - x.min()) / (x.max() - x.min())\n", "” ] }, { “cell_type”: “markdown”, “id”: “22f6afb7”, “metadata”: {}, “source”: [ “Todavía hay algo de duplicación en este código. Estamos calculando el mínimo de los datos dos veces, así que tiene sentido hacerlo una sola vez:” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “406648b6”, “metadata”: {}, “outputs”: [], “source”: [ “def rescale(x):”, ” minimum = x.min()“,” return (x - minimum) / (x.max() - minimum)” ] }, { “cell_type”: “markdown”, “id”: “60609a8f”, “metadata”: {}, “source”: [ “Extraer los cálculos intermedios a variables con nombre es una buena práctica, porque deja más claro lo que hace el código.”, “”, “”, “Hay tres pasos clave para crear una nueva función:”, “”, “1. Debes elegir un nombre para la función. Aquí hemos usado rescale porque esta función reescala un vector para que quede entre 0 y 1.”, “”, “1. Enumeras las entradas, o argumentos, de la función dentro de function.”, ” Aquí solo tenemos un argumento.“,” Si tuviéramos más, la llamada se vería como function(x, y, z). (También podríamos tener un argumento de palabra clave con nombre, como data=, después de los argumentos.)“,”“,”3. Colocas el código que has desarrollado en el cuerpo de la función, un bloque que sigue inmediatamente a function(...):.“,”“,”Fíjate en el proceso general: solo creamos la función después de haber averiguado cómo hacerla funcionar con una entrada sencilla. Es más fácil empezar con código que funciona y convertirlo en una función; es más difícil crear una función y luego intentar que funcione.“,”“,”En este punto, es buena idea comprobar tu función con algunas entradas diferentes:” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “b72eafca”, “metadata”: {}, “outputs”: [], “source”: [ “rescale(pd.Series([-10, 0, 10]))” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “edd018c7”, “metadata”: {}, “outputs”: [], “source”: [ “rescale(pd.Series([1, 2, 3, np.nan, 5]))” ] }, { “cell_type”: “markdown”, “id”: “629f75d4”, “metadata”: {}, “source”: [ “A medida que escribas más y más funciones, con el tiempo querrás convertir estas pruebas informales e interactivas en pruebas formales y automatizadas.”, “Ese proceso se llama pruebas unitarias (unit testing). Por desgracia, queda fuera del alcance de este libro.”, “”, “Ahora que tenemos una función, podemos simplificar el ejemplo original:” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “ce066e4f”, “metadata”: {}, “outputs”: [], “source”: [ “df["a"] = rescale(df["a"])”, “df["b"] = rescale(df["b"])”, “df["c"] = rescale(df["c"])”, “df["d"] = rescale(df["d"])” ] }, { “cell_type”: “markdown”, “id”: “cb41766f”, “metadata”: {}, “source”: [ “En comparación con el original, este código es más fácil de entender y hemos eliminado un tipo de errores de copiar y pegar. Todavía hay bastante duplicación, ya que hacemos lo mismo con varias columnas; en realidad también podemos eliminarla, pero veremos cómo hacerlo más adelante en el libro.”, “”, “Otra ventaja de las funciones es que, si nuestros requisitos cambian, solo necesitamos hacer el cambio en un lugar.”, “Por ejemplo, podríamos descubrir que algunas de nuestras variables incluyen valores infinitos y que rescale() (en la práctica) falla:” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “f503c36b”, “metadata”: {}, “outputs”: [], “source”: [ “rescale(pd.Series([1, 2, 3, np.inf, 5]))” ] }, { “cell_type”: “markdown”, “id”: “f29a050e”, “metadata”: {}, “source”: [ “Como hemos extraído el código a una función, solo necesitamos hacer la corrección en un lugar:” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “67c861b6”, “metadata”: {}, “outputs”: [], “source”: [ “def rescale(x):”, ” x = x.replace(np.inf, np.nan)“,” minimum = x.min()“,” return (x - minimum) / (x.max() - minimum)“,”“,”“,”rescale(pd.Series([1, 2, 3, np.inf, 5]))” ] }, { “cell_type”: “markdown”, “id”: “ee8598d3”, “metadata”: {}, “source”: [ “Esta es una parte importante del principio "no te repitas" (o DRY, por sus siglas en inglés).”, “Cuanta más repetición tengas en tu código, más lugares tendrás que recordar actualizar cuando las cosas cambien (¡y siempre cambian!), y más probable será que introduzcas errores con el tiempo.” ] }, { “cell_type”: “markdown”, “id”: “6e5df698”, “metadata”: {}, “source”: [ “## Las funciones son para humanos y para computadoras”, “”, “Es importante recordar que las funciones no son solo para la computadora, sino también para los humanos. En general, a Python no le importa cómo se llame tu función ni qué comentarios contenga, pero esto es importante para los lectores humanos. Esta sección trata algunas cosas que deberías tener en cuenta al escribir funciones que los humanos puedan entender.”, “”, “El nombre de una función es importante. Lo ideal es que el nombre de tu función sea corto, pero que evoque claramente lo que hace la función. ¡Eso es difícil! Pero es mejor ser claro que breve, ya que el autocompletado de Visual Studio Code facilita escribir nombres largos.”, “”, “En general, los nombres de las funciones deberían ser verbos, y los argumentos, sustantivos. Hay algunas excepciones: los sustantivos están bien si la función calcula un sustantivo muy conocido (por ejemplo, mean es mejor que compute_mean) o si accede a alguna propiedad de un objeto (por ejemplo, coef es mejor que get_coefficients). Una buena señal de que un sustantivo podría ser mejor opción es que estés usando un verbo muy amplio como "get", "compute", "calculate" o "determine".”, “Usa tu mejor criterio y no tengas miedo de renombrar una función si más adelante se te ocurre un nombre mejor.”, “”, “python\n", "# Not a verb, or descriptive\n", "my_awesome_function()\n", "# Long, but clear\n", "impute_missing()\n", "collapse_years()\n", "”, “”, “Si el nombre de tu función se compone de varias palabras, usa "snake_case", donde cada palabra en minúsculas se separa con un guion bajo. Si tienes una familia de funciones que hacen cosas similares, asegúrate de que tengan nombres y argumentos coherentes. Usa un prefijo común para indicar que están relacionadas. Eso es mejor que un sufijo común, porque el autocompletado te permite escribir el prefijo y ver todos los miembros de la familia.”, “”, “python\n", "# Good\n", "input_select()\n", "input_checkbox()\n", "input_text()\n", "# Not so good\n", "select_input()\n", "checkbox_input()\n", "text_input()\n", "”, “”, “Un buen ejemplo de este diseño es el paquete pandas: si no recuerdas exactamente qué función necesitas para leer datos, puedes escribir pd.read_ y refrescar la memoria mientras el autocompletado te muestra las opciones.” ] }, { “cell_type”: “markdown”, “id”: “6735f101”, “metadata”: {}, “source”: [ “## Ámbito de las funciones”, “”, “El ámbito (scope) se refiere a qué partes de tu código pueden ver qué otras partes. Hay tres ámbitos diferentes que debes tener en cuenta: local, global y no local.”, “”, “Local”, “”, “Si defines una variable dentro de una función, el resto de tu código no podrá ‘verla’ ni usarla. Por ejemplo, aquí tienes una función que crea una variable y, a continuación, un ejemplo de cómo llamar a esa variable:”, “”, “python\n", "def var_func():\n", " str_variable = 'Hello World!'\n", "\n", "var_func()\n", "print(str_variable)\n", "”, “”, “Esto generaría un error porque, para el resto de tu código, str_variable no existe fuera de la función. Este es un ejemplo de una variable local, es decir, una que solo existe dentro de una función.”, “”, “”, “Si quieres crear variables dentro de una función y que persistan, tienes que devolverlas explícitamente usando, por ejemplo, return str_variable, así:” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “8725b986”, “metadata”: {}, “outputs”: [], “source”: [ “def var_func():”, ” str_variable = "Hello World!"“,” return str_variable“,”“,”“,”returned_var = var_func()“,”print(returned_var)” ] }, { “cell_type”: “markdown”, “id”: “ddd6f63e”, “metadata”: {}, “source”: [ “Global”, “”, “Una variable declarada fuera de una función se conoce como variable global porque es accesible desde cualquier parte:” ] }, { “cell_type”: “code”, “execution_count”: null, “id”: “b0a4fe15”, “metadata”: {}, “outputs”: [], “source”: [ “y = "I’m a global variable"”, “”, “”, “def print_y():”, ” print("y is inside a function:", y)“,”“,”“,”print_y()“,”print("y is outside a function:", y)” ] } ], “metadata”: { “interpreter”: { “hash”: “9d7534ecd9fbc7d385378f8400cf4d6cb9c6175408a574f1c99c5269f08771cc” }, “jupytext”: { “cell_metadata_filter”: “-all”, “encoding”: “# -- coding: utf-8 --”, “formats”: “md:myst”, “main_language”: “python” }, “kernelspec”: { “display_name”: “Python 3 (ipykernel)”, “language”: “python”, “name”: “python3” }, “language_info”: { “codemirror_mode”: { “name”: “ipython”, “version”: 3 }, “file_extension”: “.py”, “mimetype”: “text/x-python”, “name”: “python”, “nbconvert_exporter”: “python”, “pygments_lexer”: “ipython3”, “version”: “3.12.14” }, “toc-showtags”: true }, “nbformat”: 4, “nbformat_minor”: 5 }