Sección 1 - Getting Started With Panda

Machine Translated by Google
Prefacio
La ciencia de datos a menudo se describe como un campo interdisciplinario donde se cruzan las habilidades de
programación, el conocimiento estadístico y el conocimiento del dominio. Se ha convertido rápidamente en uno de
los campos más candentes de nuestra sociedad y saber cómo trabajar con datos se ha vuelto esencial en las carreras
actuales. Independientemente de la industria, la función o el proyecto, las habilidades en materia de datos tienen una
gran demanda y aprender a analizar datos es clave para generar un impacto.
Los campos de la ciencia de datos cubren muchos aspectos diferentes del espectro: los analistas de datos se
centran más en extraer información empresarial, mientras que los científicos de datos se centran más en
aplicar técnicas de aprendizaje automático a los problemas de la empresa. Los ingenieros de datos se
centran en diseñar, construir y mantener canales de datos utilizados por analistas y científicos de datos.
Los ingenieros de aprendizaje automático comparten gran parte del conjunto de habilidades de los científicos de
datos y, al igual que los ingenieros de datos, son ingenieros de software expertos. El panorama de la ciencia de
datos abarca muchos campos, pero para todos ellos, el análisis de datos es un componente fundamental. Este
libro le brindará las habilidades para comenzar, dondequiera que lo lleve su viaje.
El conjunto de habilidades tradicionales en ciencia de datos implica saber cómo recopilar datos de
diversas fuentes, como bases de datos y API, y procesarlos. Python es un lenguaje popular para la
ciencia de datos que proporciona los medios para recopilar y procesar datos, así como para
crear productos de datos con calidad de producción. Dado que es de código abierto, es fácil
comenzar con la ciencia de datos aprovechando las bibliotecas escritas por otros para resolver
problemas y tareas de datos comunes.
Pandas es la poderosa y popular biblioteca sinónimo de ciencia de datos en Python. Este libro le brindará una
introducción práctica al análisis de datos utilizando pandas en conjuntos de datos del mundo real, como los
relacionados con el mercado de valores, intentos de piratería simulados, tendencias climáticas, terremotos, vino y datos
astronómicos. Pandas facilita la manipulación y visualización de datos al brindarnos la capacidad de trabajar de
manera eficiente con datos tabulares.
x Prefacio
Una vez que hayamos aprendido cómo realizar análisis de datos, exploraremos una serie de
aplicaciones. Construiremos paquetes de Python y probaremos el análisis de existencias, la detección
de anomalías, la regresión, la agrupación y la clasificación con la ayuda de bibliotecas adicionales
comúnmente utilizadas para la visualización de datos, la manipulación de datos y el aprendizaje
automático, como Matplotlib, Seaborn, NumPy y Scikit-aprende. Cuando termine este libro, estará
bien equipado para emprender sus propios proyectos de ciencia de datos en Python.
para quien es este libro

Este libro está escrito para personas con distintos niveles de experiencia que desean aprender
sobre ciencia de datos en Python, tal vez para aplicarla a un proyecto, colaborar con científicos
de datos y/o avanzar para trabajar en código de producción de aprendizaje automático con
ingenieros de software. Sacará el máximo provecho de este libro si su experiencia es similar a uno
(o ambos) de los siguientes:
• Tiene experiencia previa en ciencia de datos en otro idioma, como R, SAS o

MATLAB y desea aprender pandas para poder trasladar su flujo de trabajo a Python.
• Tienes algo de experiencia en Python y buscas aprender sobre ciencia de datos.

usando Python.
Qué cubre este libro

El Capítulo 1, Introducción al análisis de datos, le enseña los fundamentos del análisis de datos, le
brinda una base en estadística y lo guía para configurar su entorno para trabajar con datos en
Python y usar Jupyter Notebooks.
El Capítulo 2, Trabajar con Pandas DataFrames, le presenta la biblioteca de pandas y le muestra los
conceptos básicos para trabajar con DataFrames.
El Capítulo 3, Gestión de datos con Pandas, analiza el proceso de manipulación de datos, le

muestra cómo explorar una API para recopilar datos y lo guía a través de la limpieza y remodelación
de datos con pandas.
El Capítulo 4, Agregación de Pandas DataFrames, le enseña cómo consultar y fusionar

DataFrames, cómo realizar operaciones complejas en ellos, incluidos cálculos continuos y
agregaciones, y cómo trabajar de manera efectiva con datos de series de tiempo.
El Capítulo 5, Visualización de datos con Pandas y Matplotlib, le muestra cómo crear sus propias
visualizaciones de datos en Python, primero usando la biblioteca matplotlib y luego directamente
desde los objetos pandas .
Prefacio xi
El Capítulo 6, Trazado con Seaborn y técnicas de personalización, continúa la discusión sobre la visualización de datos
enseñándole cómo usar la biblioteca de Seaborn para visualizar sus datos de formato largo y brindándole las herramientas
que necesita para personalizar sus visualizaciones, preparándolas para presentaciones.
El Capítulo 7, Análisis financiero: Bitcoin y el mercado de valores, lo guía a través de la creación de un paquete Python
para analizar acciones, basándose en todo lo aprendido desde el Capítulo 1, Introducción al análisis de datos, hasta el Capítulo
6, Trazado con Seaborn y técnicas de personalización, y aplicándolo a una aplicación financiera.
El Capítulo 8, Detección de anomalías basada en reglas, cubre la simulación de datos y la aplicación de todo lo aprendido
desde el Capítulo 1, Introducción al análisis de datos, hasta el Capítulo 6, Trazado con Seaborn y técnicas de personalización,
para detectar a los piratas informáticos que intentan autenticarse en un sitio web mediante el uso de reglas. Estrategias
para la detección de anomalías.
El Capítulo 9, Introducción al aprendizaje automático en Python, le presenta el aprendizaje automático y la construcción de

modelos utilizando la biblioteca scikit-learn .
El Capítulo 10, Cómo hacer mejores predicciones: optimización de modelos, muestra estrategias para ajustar y mejorar
el rendimiento de sus modelos de aprendizaje automático.
El Capítulo 11, Detección de anomalías en el aprendizaje automático, revisa la detección de anomalías en los datos de
los intentos de inicio de sesión, utilizando técnicas de aprendizaje automático, al mismo tiempo que le brinda una idea de
cómo se ve el flujo de trabajo en la práctica.
El Capítulo 12, El camino por delante, cubre recursos para llevar sus habilidades al siguiente nivel y más vías de exploración.
Para aprovechar al máximo este libro

Debes estar familiarizado con Python, particularmente con Python 3 y versiones posteriores. También debe saber cómo
escribir funciones y scripts básicos en Python, comprender conceptos de programación estándar como variables, tipos de
datos y flujo de control (si/si no, bucles for/ while) y poder utilizar Python como lenguaje de programación funcional. .
Algunos conocimientos básicos de programación orientada a objetos pueden resultar útiles, pero no son necesarios. Si su
destreza en Python aún no está en este nivel, la documentación de Python incluye un tutorial útil para ponerse al día
rápidamente: https://docs.python.org/3/tutorial/index.html.
xiii Prefacio
El código adjunto a este libro se puede encontrar en GitHub en https://github.

com/stefmolin/Hands-On-Data-Analysis-with-Pandas-2nd-edition.
Para aprovechar al máximo este libro, debe seguir los Jupyter Notebooks a medida que lee cada capítulo.
Cubriremos la configuración de su entorno y la obtención de estos archivos en el Capítulo 1, Introducción al
análisis de datos. Tenga en cuenta que también hay un cuaderno Python 101 que proporciona un curso intensivo/
repaso, si es necesario: https://github.com/
stefmolin/Análisis-práctico-de-datos-con-pandas-segunda-edición/blob/
master/ch_01/python_101.ipynb.
Por último, asegúrese de hacer los ejercicios al final de cada capítulo. Algunos de ellos pueden ser bastante
desafiantes, pero te harán mucho más fuerte con el material. Las soluciones para los ejercicios de cada capítulo
se pueden encontrar en https://github.com/stefmolin/Hands-On-Data-Analysis-with-Pandas-2nd-edition/tree/
master/solutions en sus respectivas carpetas.
Descarga las imágenes en color

También proporcionamos un archivo PDF que tiene imágenes en color de las capturas de pantalla/
diagramas utilizados en este libro. Puedes descargarlo aquí: https://static.packt-cdn.com/
descargas/9781800563452_ColorImages.pdf.
Convenciones utilizadas
Hay una serie de convenciones textuales utilizadas a lo largo de este libro.
Código en texto: indica palabras de código en texto, nombres de tablas de bases de datos, nombres de
carpetas, nombres de archivos, extensiones de archivos, nombres de rutas, URL ficticias y entradas del usuario.
Aquí hay un ejemplo: "Utilice pip para instalar los paquetes en el archivo requisitos.txt ".
Un bloque de código se establece de la siguiente manera. El inicio de la línea estará precedido por >>>
y las continuaciones de esa línea estarán precedidas por ...:
>>> df = pd.read_csv(
... 'datos/fb_2018.csv', index_col='fecha', parse_dates=Verdadero
... )
>>> df.cabeza()
Prefacio xiii
Cualquier código sin el >>> o ... anterior no es algo que ejecutaremos; es como referencia:
intentar:
del df['unos']
excepto error clave:
pase # manejar el error aquí
Cuando deseamos llamar su atención sobre una parte particular de un bloque de código, las líneas o elementos
relevantes se establecen en negrita:
>>> df.precio.plot(
... title='Precio sobre el tiempo', ylim=(0, Ninguno)
... )
Los resultados se mostrarán sin nada antes de las líneas:
>>> pd.Series(np.random.rand(2), nombre='aleatorio')

0 0.235793
1 0,257935
Nombre: aleatorio, tipo d: float64
Cualquier entrada o salida de la línea de comandos se escribe de la siguiente manera:
# Ventanas:
C:\ruta\de\su\elección> mkdir pandas_exercises
# Linux, Mac y taquigrafía:

$ mkdir pandas_ejercicios
Negrita: indica un término nuevo, una palabra importante o palabras que ves en pantalla. Por ejemplo,
las palabras de menús o cuadros de diálogo aparecen en el texto de esta manera. Aquí hay un ejemplo:
"Usando el panel del Explorador de archivos , haga doble clic en la carpeta ch_01 , que contiene el
Jupyter Notebook que usaremos para validar nuestra configuración".
Consejos o notas
importantes Aparecen así.
xiv Prefacio
Ponerse en contacto
Los comentarios de nuestros lectores es siempre bienvenido.
Comentarios generales: si tiene preguntas sobre algún aspecto de este libro, mencione el título del
libro en el asunto de su mensaje y envíenos un correo electrónico a [email protected].
Fe de erratas: Aunque hemos tomado todas las medidas necesarias para garantizar la exactitud de
nuestro contenido, ocurren errores. Si ha encontrado un error en este libro, le agradeceríamos
que nos lo informara. Visite www.packtpub.com/support/errata, seleccione su libro, haga clic en el
enlace Formulario de envío de erratas e ingrese los detalles.
Piratería: si encuentra copias ilegales de nuestros trabajos en cualquier forma en Internet, le

agradeceríamos que nos proporcione la dirección de ubicación o el nombre del sitio web.
Por favor contáctenos en [email protected] con un enlace al material.
Si está interesado en convertirse en autor: si hay un tema en el que tiene experiencia y está
interesado en escribir o contribuir a un libro, visite autores.
packtpub.com.
Reseñas
Por favor deja una reseña. Una vez que haya leído y utilizado este libro, ¿por qué no deja una
reseña en el sitio donde lo compró? Los lectores potenciales pueden ver y utilizar su opinión
imparcial para tomar decisiones de compra, nosotros en Packt podemos entender lo que piensa
sobre nuestros productos y nuestros autores pueden ver sus comentarios sobre su libro. ¡Gracias!
Para obtener más información sobre Packt, visite packt.com.

Sección 1:
Empezar con
pandas
Nuestro viaje comienza con una introducción al análisis de datos y las estadísticas, que
sentará una base sólida para los conceptos que cubriremos a lo largo del libro. Luego,
configuraremos nuestro entorno de ciencia de datos Python, que contiene todo lo que
necesitamos para trabajar con los ejemplos y comenzar a aprender los conceptos básicos de pandas.
Esta sección comprende los siguientes capítulos:
• Capítulo 1, Introducción al análisis de datos
• Capítulo 2, Trabajar con Pandas DataFrames

1
Introducción a los datos
Análisis
Antes de que podamos comenzar nuestra introducción práctica al análisis de datos con pandas, debemos
aprender sobre los fundamentos del análisis de datos. Aquellos que alguna vez han consultado la
documentación de una biblioteca de software saben lo abrumador que puede ser si no tienes idea de lo que
estás buscando. Por lo tanto, es esencial que dominemos no solo el aspecto de la codificación, sino también
el proceso de pensamiento y el flujo de trabajo necesarios para analizar los datos, lo que
resultará más útil para aumentar nuestro conjunto de habilidades en el futuro.
Al igual que el método científico, la ciencia de datos tiene algunos flujos de trabajo comunes que podemos
seguir cuando queremos realizar un análisis y presentar los resultados. La columna vertebral de este
proceso son las estadísticas, que nos brindan formas de describir nuestros datos, hacer predicciones y
también sacar conclusiones sobre ellos. Dado que el conocimiento previo de estadística no es un requisito
previo, este capítulo nos brindará una exposición a los conceptos estadísticos que utilizaremos a lo largo de
este libro, así como áreas para una mayor exploración.
Después de cubrir los fundamentos, configuraremos nuestro entorno Python para el resto de este
libro. Python es un lenguaje poderoso y sus usos van mucho más allá de la ciencia de datos: creación de
aplicaciones web, software y web scraping, por nombrar algunos. Para trabajar eficazmente en todos los
proyectos, necesitamos aprender a crear entornos virtuales, que aislarán las dependencias de cada
proyecto. Finalmente, aprenderemos a trabajar con Jupyter Notebooks para poder seguir el texto.
4 Introducción al análisis de datos
Los siguientes temas se cubrirán en este capítulo:
• Los fundamentos del análisis de datos.

• Fundamentos estadísticos
• Configurar un entorno virtual
Materiales del capítulo

Todos los archivos de este libro están en GitHub en https://github.com/stefmolin/
Análisisprácticodedatosconpandassegundaedición. Si bien no es necesario tener una
cuenta de GitHub para trabajar en este libro, es una buena idea crear una, ya que servirá
como portafolio para cualquier proyecto de datos/codificación. Además, trabajar con Git
proporcionará un sistema de control de versiones y facilitará la colaboración.
Consejo
Consulte este artículo para aprender algunos conceptos básicos de Git: https://www.
freecodecamp.org/news/learnthebasicsofgitinunder10 Minutes-da548267cc91/.
Para obtener una copia local de los archivos, tenemos algunas opciones (ordenadas de menos útiles
a más útiles):
• Descargue el archivo ZIP y extraiga los archivos localmente.
• Clonar el repositorio sin bifurcarlo.
• Bifurcar el repositorio y luego clonarlo.
Este libro incluye ejercicios para cada capítulo; por lo tanto, para aquellos que quieran
conservar una copia de sus soluciones junto con el contenido original en GitHub, se recomienda
bifurcar el repositorio y clonar la versión bifurcada. Cuando bifurcamos un repositorio, GitHub
creará un repositorio bajo nuestro propio perfil con la última versión del original. Luego, cada vez que
hagamos cambios en nuestra versión, podremos volver a publicar los cambios. Tenga en cuenta que si
simplemente clonamos, no obtendremos este beneficio.
Materiales del capítulo 5
Los botones relevantes para iniciar este proceso están rodeados por un círculo en la siguiente captura de pantalla:
Figura 1.1: Obtener una copia local del código para seguirlo
Nota IMPORTANTE
El proceso de clonación copiará los archivos al directorio de trabajo actual en una carpeta
llamada Hands-On-Data-Analysis-with-Pandas-2nd-edition. Para crear una carpeta para
colocar este repositorio, podemos usar mkdir my_folder && cd my_folder. Esto
creará una nueva carpeta (directorio) llamada mi_carpeta y luego cambiará el directorio
actual a esa carpeta, después de lo cual podremos clonar el repositorio. Podemos encadenar
estos dos comandos (y cualquier número de comandos) agregando && entre ellos. Esto se
puede considerar como y luego (siempre que el primer comando tenga éxito).
Este repositorio tiene carpetas para cada capítulo. Los materiales de este capítulo se
pueden encontrar en https://github.com/stefmolin/Hands-On-Data-Analysis-with-
Pandas-2nd-edition/tree/master/ch_01. Si bien la mayor parte de este capítulo no implica
ningún tipo de codificación, siéntase libre de seguir el cuaderno de
introducción_to_data_analysis.ipynb en el sitio web de GitHub hasta que configuremos
nuestro entorno hacia el final del capítulo. Después de hacerlo, usaremos el cuaderno
check_your_environment.ipynb para familiarizarnos con los Jupyter Notebooks y ejecutar
algunas comprobaciones para asegurarnos de que todo esté configurado correctamente
para el resto de este libro.
Dado que el código que se utiliza para generar el contenido de estos cuadernos no es el
foco principal de este capítulo, la mayor parte se ha separado en el paquete visual_aids,
que se utiliza para crear elementos visuales para explicar conceptos a lo largo del libro, y
check_environment. archivo py. Si decide inspeccionar estos archivos, no se preocupe
abrumado; Todo lo que es relevante para la ciencia de datos se cubrirá en este libro.
Cada capítulo incluye ejercicios; sin embargo, sólo para este capítulo, hay un cuaderno
de ejercicios.ipynb , con código para generar algunos datos iniciales. Será necesario tener
conocimientos básicos de Python para completar estos ejercicios. Para aquellos que deseen
repasar los conceptos básicos, asegúrese de consultar el cuaderno python_101.ipynb , incluido en
los materiales de este capítulo, para un curso intensivo. El tutorial oficial de Python es un buen punto de
partida para una introducción más formal: https://docs.python.org/3/
tutorial/index.html.
Los fundamentos del análisis de datos.

El análisis de datos es un proceso altamente iterativo que implica recopilación, preparación (disputa),
análisis exploratorio de datos (EDA) y extracción de conclusiones. Durante un análisis, revisaremos
con frecuencia cada uno de estos pasos. El siguiente diagrama muestra un flujo de trabajo
generalizado:
Datos
EDA +
Recolectar datos ¿Obtener más datos? No Sacar conclusiones
Disputa de datos
Sí
Comunicar
resultados
Figura 1.2 – El flujo de trabajo del análisis de datos

Los fundamentos del análisis de datos 7
En las próximas secciones, obtendremos una descripción general de cada uno de estos pasos, comenzando
con la recopilación de datos. En la práctica, este proceso está muy sesgado hacia la preparación de datos.
Las encuestas han encontrado que, aunque los científicos de datos son los que menos disfrutan
de la parte de preparación de datos de su trabajo, representa el 80% de su trabajo (https://www.forbes.
com/sites/gilpress/2016/03/23/data-preparation-most-time-consuming-least-
enjoyable-data-science-task-survey-says/).
Este paso de preparación de datos es donde Pandas realmente brilla.
Recopilación de datos
La recopilación de datos es el primer paso natural para cualquier análisis de datos: no podemos analizar
datos que no tenemos. En realidad, nuestro análisis puede comenzar incluso antes de que tengamos
los datos. Cuando decidimos qué queremos investigar o analizar, tenemos que pensar qué tipo de datos
podemos recopilar que serán útiles para nuestro análisis. Si bien los datos pueden provenir de cualquier
lugar, exploraremos las siguientes fuentes a lo largo de este libro:
• Web scraping para extraer datos del HTML de un sitio web (a menudo con paquetes de Python
como selenium, requests, scrapy y beautifulsoup)
• Interfaces de programación de aplicaciones (API) para servicios web desde los cuales
puede recopilar datos con solicitudes HTTP (quizás usando cURL o las solicitudes
paquete Python)
• Bases de datos (los datos se pueden extraer con SQL u otro lenguaje de consulta de bases de datos)
• Recursos de Internet que proporcionan datos para descargar, como sitios web gubernamentales.
o Yahoo! Finanzas
• Archivos de registro
Nota IMPORTANTE
El Capítulo 2, Trabajar con Pandas DataFrames, nos brindará las habilidades que necesitamos
para trabajar con las fuentes de datos antes mencionadas. El Capítulo 12, El camino por delante,
proporciona numerosos recursos para encontrar fuentes de datos.
Estamos rodeados de datos, por lo que las posibilidades son ilimitadas. Sin embargo, es importante
asegurarnos de que estamos recopilando datos que nos ayudarán a sacar conclusiones. Por ejemplo, si
intentamos determinar si las ventas de chocolate caliente son mayores cuando la temperatura es más baja,
deberíamos recopilar datos sobre la cantidad de chocolate caliente vendido y las temperaturas cada día. Si
bien podría ser interesante ver qué distancia viajaron las personas para conseguir el chocolate
caliente, no es relevante para nuestro análisis.
No se preocupe demasiado por encontrar los datos perfectos antes de comenzar un análisis.
Lo más probable es que siempre habrá algo que queramos agregar/eliminar del conjunto de datos inicial, reformatear,
fusionar con otros datos o cambiar de alguna manera. Aquí es donde entra en juego la disputa de datos.
Disputa de datos
La manipulación de datos es el proceso de preparar los datos y convertirlos en un formato que pueda usarse para el
análisis. La desafortunada realidad de los datos es que a menudo están sucios, lo que significa que es necesario
limpiarlos (prepararlos) antes de poder utilizarlos. Los siguientes son algunos problemas que podemos encontrar con
nuestros datos:
• Errores humanos: los datos se registran (o incluso se recopilan) incorrectamente, como poner 100
en lugar de 1000 o errores tipográficos. Además, pueden existir múltiples versiones del mismo
entrada registrada, como Nueva York, Nueva York y Nueva York.
• Error de computadora: Quizás no estuvimos registrando entradas por un tiempo (faltan datos).
• Valores inesperados: Quizás quien estaba registrando los datos decidió utilizar
un signo de interrogación por un valor faltante en una columna numérica, por lo que ahora todas las entradas
en la columna se tratará como texto en lugar de valores numéricos.
• Información incompleta: piense en una encuesta con preguntas opcionales; no todo el mundo
las responderá, por lo que nos faltarán datos, pero no debido a la computadora o
error humano.
• Resolución: Es posible que los datos se hayan recopilado por segundo, mientras que necesitamos cada hora.
datos para nuestro análisis.
• Relevancia de los campos: A menudo, los datos se recopilan o generan como producto de alguna
proceso en lugar de explícitamente para nuestro análisis. Para llevarlo a un estado utilizable,
tendremos que limpiarlo.
• Formato de los datos: los datos pueden registrarse en un formato que no sea propicio para
análisis, lo que requerirá que le reformemos.
• Configuraciones erróneas en el proceso de registro de datos: datos provenientes de fuentes como

ya que a los rastreadores y/o webhooks mal configurados pueden faltar campos o pasarse en el
orden incorrecto.
La mayoría de estos problemas de calidad de los datos se pueden solucionar, pero algunos no, como cuando los
datos se recopilan a diario y los necesitamos con una resolución cada hora. Es nuestra responsabilidad examinar
cuidadosamente nuestros datos y manejar cualquier problema para que nuestro análisis no se distorsione.
Cubriremos este proceso en profundidad en el Capítulo 3, Gestión de datos con Pandas, y en el Capítulo 4, Agregación
de marcos de datos de Pandas.
Los fundamentos del análisis de datos 9
Una vez que hayamos realizado una limpieza inicial de los datos, estamos listos para EDA. Tenga en cuenta que
durante la EDA, es posible que necesitemos algunas disputas de datos adicionales: estos dos pasos están
muy entrelazados.
Análisis exploratorio de datos

Durante EDA, utilizamos visualizaciones y estadísticas resumidas para comprender mejor los datos. Dado que el cerebro
humano destaca por detectar patrones visuales, la visualización de datos es esencial para cualquier análisis. De hecho, algunas
características de los datos sólo pueden observarse en un gráfico. Dependiendo de nuestros datos, podemos crear gráficos
para ver cómo ha evolucionado una variable de interés a lo largo del tiempo, comparar cuántas observaciones pertenecen
a cada categoría, encontrar valores atípicos, observar distribuciones de variables continuas y discretas, y mucho más. En
el Capítulo 5, Visualización de datos con Pandas y Matplotlib, y el Capítulo 6, Trazado con Seaborn y técnicas de
personalización, aprenderemos cómo crear estos gráficos tanto para EDA como para presentación.
Nota IMPORTANTE
Las visualizaciones de datos son muy poderosas; desafortunadamente, a menudo pueden

ser engañosos. Un problema común surge de la escala del eje y porque la mayoría de las
herramientas de trazado hacen zoom de forma predeterminada para mostrar el patrón de cerca.
Sería difícil para el software saber cuáles son los límites de eje apropiados para cada gráfico
posible; por lo tanto, es nuestro trabajo ajustar adecuadamente los ejes antes de presentar nuestros
resultados. Puede leer sobre otras formas en que las tramas pueden ser engañosas en https://
venngage.com/blog/misleading-graphs/.
En el diagrama de flujo de trabajo que vimos anteriormente (Figura 1.2), EDA y la manipulación de datos compartían un
cuadro. Esto se debe a que están estrechamente relacionados:
• Los datos deben prepararse antes de la EDA.
• Las visualizaciones que se crean durante la EDA pueden indicar la necesidad de

limpieza de datos.
• La manipulación de datos utiliza estadísticas resumidas para buscar posibles problemas de datos, mientras
EDA los utiliza para comprender los datos. Una limpieza inadecuada distorsionará los resultados.
cuando estamos realizando EDA. Además, se necesitarán habilidades de manipulación de datos para
obtener estadísticas resumidas en subconjuntos de datos.
Al calcular las estadísticas resumidas, debemos tener en cuenta el tipo de datos que recopilamos.
Los datos pueden ser cuantitativos (cantidades mensurables) o categóricos (descripciones, agrupaciones o categorías).
Dentro de estas clases de datos, tenemos más subdivisiones que nos permiten saber qué tipos de operaciones
podemos realizar con ellos.
Por ejemplo, los datos categóricos pueden ser nominales, donde asignamos un valor numérico a cada nivel de la
categoría, como encendido = 1/apagado = 0. Tenga en cuenta que el hecho de que encendido sea mayor que apagado
no tiene sentido porque elegimos esos números arbitrariamente. representar a los estados en
y fuera. Cuando hay un ranking entre las categorías, son ordinales, es decir, podemos ordenar los niveles (por
ejemplo, podemos tener bajo < medio < alto).
Los datos cuantitativos pueden utilizar una escala de intervalo o una escala de razón. La escala de intervalo
incluye cosas como la temperatura. Podemos medir las temperaturas en grados Celsius y comparar las
temperaturas de dos ciudades, pero no significa nada decir que una ciudad es dos veces más calurosa que la
otra. Por lo tanto, los valores de la escala de intervalo se pueden comparar significativamente usando suma/
resta, pero no multiplicación/división. La escala de razones, entonces, son aquellos valores que se pueden
comparar significativamente con razones (usando multiplicación y división).
Ejemplos de escala de relación incluyen precios, tamaños y recuentos.
Cuando completemos nuestra EDA, podremos decidir los próximos pasos sacando conclusiones.
Sacar conclusiones
Una vez que hayamos recopilado los datos para nuestro análisis, los hayamos limpiado y realizado una EDA
exhaustiva, es hora de sacar conclusiones. Aquí es donde resumimos nuestros hallazgos de la EDA y decidimos
los próximos pasos:
• ¿Notamos algún patrón o relación al visualizar los datos?

• ¿Parece que podemos hacer predicciones precisas a partir de nuestros datos? ¿Tiene
sentido pasar a modelar los datos?
• ¿Deberíamos manejar los puntos de datos faltantes? ¿Cómo?
• ¿Cómo se distribuyen los datos?
• ¿Los datos nos ayudan a responder las preguntas que tenemos o nos dan una idea del
problema que estamos investigando?
• ¿Necesitamos recopilar datos nuevos o adicionales?
Fundamentos estadísticos 11
Si decidimos modelar los datos, esto se incluye en el aprendizaje automático y la estadística. Si bien
técnicamente no es un análisis de datos, suele ser el siguiente paso y lo cubriremos en el Capítulo 9,
Introducción al aprendizaje automático en Python, y en el Capítulo 10, Cómo hacer mejores predicciones:
optimización de modelos. Además, veremos cómo funcionará todo este proceso en la práctica en el Capítulo
11, Detección de anomalías del aprendizaje automático. Como referencia, en la sección Flujo de trabajo de
aprendizaje automático del Apéndice, hay un diagrama de flujo de trabajo que describe el proceso completo,
desde el análisis de datos hasta el aprendizaje automático. El Capítulo 7, Análisis financiero: Bitcoin y el
mercado de valores, y el Capítulo 8, Detección de anomalías basada en reglas, se centrarán en sacar
conclusiones del análisis de datos, en lugar de construir modelos.
La siguiente sección será una revisión de las estadísticas; aquellos con conocimientos de estadística pueden
pasar a la sección Configuración de un entorno virtual.
Fundamentos estadísticos
Cuando queremos hacer observaciones sobre los datos que estamos analizando, a menudo, si no siempre,
recurrimos de alguna manera a las estadísticas. Los datos que tenemos se denominan muestra, que fue
observada de (y es un subconjunto de) la población. Dos categorías amplias de estadísticas son las
estadísticas descriptivas y las inferenciales. Con estadística descriptiva, como su nombre lo indica, buscamos
describir la muestra. La estadística inferencial implica el uso de estadísticas de muestra para inferir o deducir
algo sobre la población, como la distribución subyacente.
Nota IMPORTANTE
Las estadísticas muestrales se utilizan como estimadores de los parámetros poblacionales, lo

que significa que tenemos que cuantificar su sesgo y varianza. Hay multitud de métodos para
ello; algunos harán suposiciones sobre la forma de la distribución (paramétrica) y otros no (no
paramétrica). Todo esto va mucho más allá del alcance de este libro, pero es bueno tenerlo en
cuenta.
A menudo, el objetivo de un análisis es crear una historia para los datos; Desafortunadamente, es muy
fácil hacer un mal uso de las estadísticas. Es el tema de una cita famosa:
"Hay tres tipos de mentiras: mentiras, malditas mentiras y estadísticas".

- Benjamín Disraeli
Esto es especialmente cierto en el caso de la estadística inferencial, que se utiliza en muchos estudios y
artículos científicos para mostrar la importancia de los hallazgos de los investigadores. Este es un tema
más avanzado y, dado que no es un libro de estadística, sólo abordaremos brevemente algunas de las
herramientas y principios detrás de la estadística inferencial, que pueden profundizarse más. Nos
centraremos en estadísticas descriptivas para ayudar a explicar los datos que estamos analizando.
Muestreo
Hay algo importante que recordar antes de intentar cualquier análisis: nuestra muestra debe ser aleatoria y representativa de la
población. Esto significa que los datos deben ser muestreados sin sesgos (por ejemplo, si preguntamos a las personas si les
gusta un determinado equipo deportivo, no podemos preguntar sólo a los fanáticos del equipo) y que deberíamos tener
(idealmente) miembros de todos los distintos equipos. grupos de la población de nuestra muestra (en el ejemplo del equipo
deportivo, no podemos preguntarles solo a los hombres).
Cuando analicemos el aprendizaje automático en el Capítulo 9, Introducción al aprendizaje automático en Python,
necesitaremos tomar una muestra de nuestros datos, que serán una muestra para empezar. Esto se llama remuestreo.
Dependiendo de los datos, tendremos que elegir un método de muestreo diferente. A menudo, nuestra mejor opción es una
muestra aleatoria simple: utilizamos un generador de números aleatorios para seleccionar filas al azar. Cuando tenemos
distintos grupos en los datos, queremos que nuestra muestra sea una muestra aleatoria estratificada, lo que preservará la
proporción de los grupos en los datos. En algunos casos, no tenemos suficientes datos para las estrategias de muestreo antes
mencionadas, por lo que podemos recurrir al muestreo aleatorio con reemplazo (bootstrapping); esto se llama muestra de
arranque. Tenga en cuenta que nuestra muestra subyacente debe haber sido una muestra aleatoria o corremos el riesgo de
aumentar el sesgo del estimador (podríamos elegir ciertas filas con más frecuencia porque están en los datos con más
frecuencia si se tratara de una muestra de conveniencia, mientras que en la población real estas las filas no son tan frecuentes).
Veremos un ejemplo de arranque en el Capítulo 8, Detección de anomalías basada en reglas.
Nota IMPORTANTE
Una discusión exhaustiva de la teoría detrás del bootstrapping y sus consecuencias está mucho más allá del alcance de este
libro, pero mire este video para obtener una introducción: https://www.youtube.com/watch?v=gcPIyeqymOU.
Puede leer más sobre los métodos de muestreo, junto con sus fortalezas y debilidades, en https://www.khanacademy.org/math/
statistics-probability/designing-studies/sampling-methods-stats/a/sampling-methods-review.
Estadísticas descriptivas
Comenzaremos nuestra discusión sobre estadística descriptiva con estadísticas univariadas; univariante
simplemente significa que estas estadísticas se calculan a partir de una (uni) variable. Todo lo contenido
en esta sección se puede extender a todo el conjunto de datos, pero las estadísticas se calcularán por
variable que estemos registrando (lo que significa que si tuviéramos 100 observaciones de pares de
velocidad y distancia, podríamos calcular los promedios en todo el conjunto de datos, lo que nos daría
las estadísticas de velocidad promedio y distancia promedio).
La estadística descriptiva se utiliza para describir y/o resumir los datos con los que estamos
trabajando. Podemos comenzar nuestro resumen de los datos con una medida de tendencia central,
que describe dónde se centra la mayoría de los datos, y una medida de dispersión, que indica qué tan
alejados están los valores.
Medidas de tendencia central
Las medidas de tendencia central describen el centro de nuestra distribución de datos. Hay tres
estadísticas comunes que se utilizan como medidas del centro: media, mediana y moda. Cada uno
tiene sus propios puntos fuertes, dependiendo de los datos con los que estemos trabajando.
Media
Quizás la estadística más común para resumir datos sea el promedio o media. La media poblacional
se denota por μ (la letra griega mu) y la media muestral se escribe como (se pronuncia Xbar).
La media muestral se calcula sumando todos los valores y dividiendo por el recuento de valores; por
ejemplo, la media de los números 0, 1, 1, 2 y 9 es 2,6 ((0 + 1 + 1 + 2 + 9)/5):
Usamos xi para representar la iésima observación de la variable X. Observe cómo la variable en su

conjunto se representa con una letra mayúscula, mientras que la observación específica está en
minúscula. Σ (la letra griega mayúscula sigma) se utiliza para representar una sumatoria, que, en la
ecuación de la media, va de 1 a n, que es el número de observaciones.
Una cosa importante a tener en cuenta sobre la media es que es muy sensible a los valores atípicos
(valores creados por un proceso generativo diferente al de nuestra distribución). En el ejemplo anterior,
tratábamos sólo con cinco valores; sin embargo, el 9 es mucho más grande que los otros números y
eleva la media más que todos menos el 9. En los casos en los que sospechamos
Si en nuestros datos hay valores atípicos, es posible que deseemos utilizar la mediana como nuestra
medida de tendencia central.
Mediana
A diferencia de la media, la mediana es resistente a los valores atípicos. Consideremos los ingresos
en Estados Unidos; el 1% superior es mucho más alto que el resto de la población, por lo que esto
sesgará la media para que sea más alta y distorsionará la percepción del ingreso de la persona
promedio. Sin embargo, la mediana será más representativa del ingreso promedio porque es el
percentil 50 de nuestros datos; esto significa que el 50% de los valores son mayores que la mediana y
el 50% son menores que la mediana.:
Consejo
El percentil ith es el valor en el que el i% de las observaciones son menores que ese
valor, por lo que el percentil 99 es el valor en X donde el 99% de las x son menores
que ese valor.
La mediana se calcula tomando el valor medio de una lista ordenada de valores; en los casos
en que tenemos un número par de valores, tomamos la media de los dos valores del medio. Si
volvemos a tomar los números 0, 1, 1, 2 y 9, nuestra mediana es 1. Observe que la media y la
mediana de este conjunto de datos son diferentes; sin embargo, dependiendo de la distribución
de los datos, pueden ser iguales.
Modo
La moda es el valor más común en los datos (si, una vez más, tenemos los números 0, 1, 1, 2 y
9, entonces 1 es la moda). En la práctica, a menudo escucharemos cosas como que la
distribución es bimodal o multimodal (a diferencia de unimodal) en los casos en que la
distribución tiene dos o más valores más populares. Esto no significa necesariamente que cada
uno de ellos haya ocurrido la misma cantidad de veces, sino que son mucho más comunes que
los otros valores. Como se muestra en los siguientes gráficos, una distribución unimodal tiene
solo una moda (en 0), una distribución bimodal tiene dos (en -2 y 3) y una distribución
multimodal tiene muchas (en -2, 0,4 y 3):
Figura 1.3 – Visualizando el modo con datos continuos
Comprender el concepto de moda resulta útil al describir distribuciones continuas; sin embargo,
la mayoría de las veces, cuando describimos nuestros datos continuos, usaremos la media o la
mediana como medida de tendencia central. Por otro lado, cuando trabajamos con datos
categóricos, normalmente usaremos el modo.
Medidas de propagación
Saber dónde está el centro de la distribución solo nos permite resumir parcialmente la
distribución de nuestros datos: necesitamos saber cómo se ubican los valores alrededor del
centro y qué tan separados están. Las medidas de dispersión nos dicen cómo se dispersan los
datos; esto indicará qué tan delgada (baja dispersión) o amplia (muy extendida) es nuestra
distribución. Al igual que con las medidas de tendencia central, tenemos varias formas de
describir la dispersión de una distribución, y cuál elegimos dependerá de la situación y los
datos.
Rango
El rango es la distancia entre el valor más pequeño (mínimo) y el valor más grande (máximo).
Las unidades del rango serán las mismas unidades que nuestros datos. Por lo tanto, a menos
que dos distribuciones de datos estén en las mismas unidades y midan lo mismo, no podemos
comparar sus rangos y decir que una está más dispersa que la otra:
Solo por la definición del rango, podemos ver por qué no siempre sería la mejor manera de
medir la dispersión de nuestros datos. Nos da límites superiores e inferiores de lo que tenemos
en los datos; sin embargo, si tenemos valores atípicos en nuestros datos, el rango quedará
inútil.
Otro problema con el rango es que no nos dice cómo se dispersan los datos alrededor de su
centro; en realidad sólo nos dice qué tan disperso está todo el conjunto de datos. Esto nos
lleva a la varianza.
Varianza
La varianza describe qué tan alejadas están las observaciones de su valor promedio (la
media). La varianza de la población se denota como σ2 (se pronuncia sigma cuadrado) y la
varianza de la muestra se escribe como s2. Se calcula como la distancia promedio al cuadrado
de la media. Tenga en cuenta que las distancias deben elevarse al cuadrado para que las
distancias por debajo de la media no cancelen las que están por encima de la media.
Si queremos que la varianza muestral sea un estimador insesgado de la varianza poblacional,
dividimos por n - 1 en lugar de n para tener en cuenta el uso de la media muestral en lugar de
la media poblacional; esto se llama corrección de Bessel (https://en.wikipedia.org/wiki/Bessel%
27s_correction). La mayoría de las herramientas estadísticas nos darán la varianza muestral
de forma predeterminada, ya que es muy raro que tengamos datos para toda la población:
...........................
La varianza nos da una estadística con unidades al cuadrado. Esto significa que si comenzamos
con datos sobre el ingreso en dólares ($), entonces nuestra varianza sería en dólares al
cuadrado ($2). Esto no es realmente útil cuando intentamos ver cómo describe los datos;
Podemos usar la magnitud (tamaño) en sí para ver qué tan extendido está algo (valores grandes
= gran dispersión), pero más allá de eso, necesitamos una medida de dispersión con unidades
que sean las mismas que nuestros datos. Para ello utilizamos la desviación estándar.
Desviación Estándar
Podemos usar la desviación estándar para ver qué tan lejos están en promedio los puntos de
datos de la media. Una desviación estándar pequeña significa que los valores están cerca de la
media, mientras que una desviación estándar grande significa que los valores están más
dispersos. Esto está relacionado con cómo imaginaríamos la curva de distribución: cuanto menor
sea la desviación estándar, más delgado será el pico de la curva (0,5); cuanto mayor es la
desviación estándar, más ancho es el pico de la curva (2):
Figura 1.4 – Uso de la desviación estándar para cuantificar la dispersión de una distribución
La desviación estándar es simplemente la raíz cuadrada de la varianza. Al realizar esta

operación, obtenemos una estadística en unidades a la que podemos volver a entender ($ para
nuestro ejemplo de ingresos):
Tenga en cuenta que la desviación estándar de la población se representa como σ y la

desviación estándar de la muestra se denota como s.
Coeficiente de variación
Cuando pasamos de la varianza a la desviación estándar, buscábamos llegar a unidades que
tuvieran sentido; sin embargo, si luego queremos comparar el nivel de dispersión de un
conjunto de datos con otro, necesitaríamos tener las mismas unidades nuevamente. Una forma
de solucionar esto es calcular el coeficiente de variación (CV), que no tiene unidades. El CV es
la relación entre la desviación estándar y la media:
Usaremos esta métrica en el Capítulo 7, Análisis financiero: Bitcoin y el mercado de valores;

Dado que el CV no tiene unidades, podemos usarlo para comparar la volatilidad de diferentes
activos.
Rango intercuartil
Hasta ahora, aparte del rango, hemos analizado medidas de dispersión basadas en la media;
Ahora veremos cómo podemos describir el diferencial con la mediana como nuestra medida de
tendencia central. Como se mencionó anteriormente, la mediana es el percentil 50 o el segundo
cuartil (Q2). Tanto los percentiles como los cuartiles son cuantiles: valores que dividen los datos
en grupos iguales, cada uno de los cuales contiene el mismo porcentaje de los datos totales.
Los percentiles dividen los datos en 100 partes, mientras que los cuartiles lo hacen en cuatro
(25%, 50%, 75% y 100%).
Dado que los cuantiles dividen claramente nuestros datos y sabemos cuántos datos van en
cada sección, son un candidato perfecto para ayudarnos a cuantificar la dispersión de nuestros
datos. Una medida común para esto es el rango intercuartil (IQR), que es la distancia entre el
tercer y el primer cuartil:
El IQR nos da la dispersión de los datos alrededor de la mediana y cuantifica cuánta dispersión
tenemos en el 50% medio de nuestra distribución. También puede resultar útil al comprobar los
datos en busca de valores atípicos, lo que cubriremos en el Capítulo 8, Detección de anomalías
basada en reglas. Además, el IQR se puede utilizar para calcular una medida de dispersión sin
unidades, que analizaremos a continuación.
Coeficiente de dispersión cuartil

Así como teníamos el coeficiente de variación cuando usamos la media como medida de
tendencia central, tenemos el coeficiente de dispersión del cuartil cuando usamos la
mediana como medida del centro. Esta estadística tampoco tiene unidades, por lo que
puede usarse para comparar conjuntos de datos. Se calcula dividiendo el rango del
semicuartil (la mitad del IQR) por la bisagra media (punto medio entre el primer y el tercer
cuartil):
Veremos esta métrica nuevamente en el Capítulo 7, Análisis financiero: Bitcoin y el

mercado de valores, cuando evaluemos la volatilidad de las acciones. Por ahora, echemos
un vistazo a cómo podemos utilizar medidas de tendencia central y dispersión para resumir
nuestros datos.
Resumiendo datos
Hemos visto muchos ejemplos de estadística descriptiva que podemos utilizar para resumir
nuestros datos por su centro y dispersión; En la práctica, mirar el resumen de 5 números y
visualizar la distribución resultan ser primeros pasos útiles antes de sumergirse en algunas
de las otras métricas antes mencionadas. El resumen de 5 números, como su nombre
indica, proporciona cinco estadísticas descriptivas que resumen nuestros datos:
Figura 1.5 – El resumen de 5 números

Un diagrama de caja (o diagrama de caja y bigotes) es una representación visual del resumen de 5
números. La mediana se indica con una línea gruesa en el cuadro. La parte superior de la caja es
Q3 y la parte inferior de la caja es Q1. Las líneas (bigotes) se extienden desde ambos lados de los
límites de la caja hacia el mínimo y el máximo. Sin embargo, según la convención que utiliza
nuestra herramienta de trazado, es posible que solo se extiendan a una determinada estadística;
cualquier valor más allá de estas estadísticas se marca como valor atípico (usando puntos). Para
este libro en general, el límite inferior de los bigotes será Q1 – 1,5 * IQR y el límite superior será Q3
+ 1,5 * IQR, lo que se denomina diagrama de caja de Tukey:
Figura 1.6 – Diagrama de caja de Tukey
Si bien el diagrama de caja es una gran herramienta para obtener una comprensión inicial de la
distribución, no podemos ver cómo se distribuyen las cosas dentro de cada uno de los cuartiles.
Para ello, recurrimos a histogramas para variables discretas (por ejemplo, el número de personas o
libros) y estimaciones de densidad del núcleo (KDE) para variables continuas (por ejemplo, alturas
o tiempo). No hay nada que nos impida utilizar KDE en variables discretas, pero es fácil confundir a
la gente de esa manera. Los histogramas funcionan tanto para variables discretas como continuas;
sin embargo, en ambos casos, debemos tener en cuenta que la cantidad de contenedores que
elegimos para dividir los datos puede cambiar fácilmente la forma de la distribución que vemos.
Para hacer un histograma, se crea una cierta cantidad de contenedores de igual ancho y luego
se agregan barras con alturas para la cantidad de valores que tenemos en cada contenedor.
El siguiente gráfico es un histograma con 10 contenedores que muestra las tres medidas de
tendencia central para los mismos datos que se utilizaron para generar el diagrama de caja de
la Figura 1.6:
Figura 1.7 – Ejemplo de histograma
Nota IMPORTANTE
En la práctica, debemos jugar con la cantidad de contenedores para encontrar el
mejor valor. Sin embargo, debemos tener cuidado ya que esto puede
tergiversar la forma de la distribución.
Los KDE son similares a los histogramas, excepto que en lugar de crear contenedores para
los datos, dibujan una curva suavizada, que es una estimación de la función de densidad de
probabilidad (PDF) de la distribución. La PDF es para variables continuas y nos dice cómo se
distribuye la probabilidad entre los valores. Los valores más altos para la PDF indican mayores
probabilidades:
Figura 1.8 – KDE con medidas marcadas del centro

Cuando la distribución comienza a estar un poco desequilibrada con colas largas en un lado,
la medida media del centro puede fácilmente desplazarse hacia ese lado. Las distribuciones
que no son simétricas tienen cierta asimetría. Una distribución sesgada hacia la izquierda
(negativa) tiene una cola larga en el lado izquierdo; una distribución sesgada hacia la derecha
(positiva) tiene una cola larga en el lado derecho. En presencia de un sesgo negativo, la media
será menor que la mediana, mientras que ocurre lo contrario con un sesgo positivo. Cuando
no hay sesgo, ambos serán iguales:
Figura 1.9 – Visualización del sesgo
Nota IMPORTANTE
También existe otra estadística llamada curtosis, que compara la densidad del centro de la
distribución con la densidad en las colas. Tanto la asimetría como la curtosis se pueden
calcular con el paquete SciPy.
Cada columna de nuestros datos es una variable aleatoria, porque cada vez que la
observamos, obtenemos un valor de acuerdo con la distribución subyacente; no es estática.
Cuando estamos interesados en la probabilidad de obtener un valor de x o menos, usamos la
función de distribución acumulativa (CDF), que es la integral (área bajo la curva) de la PDF:
La probabilidad de que la variable aleatoria X sea menor o igual al valor específico de x se

denota como P(X ≤ x). Con una variable continua, la probabilidad de obtener exactamente x es
0. Esto se debe a que la probabilidad será la integral de la PDF de x a x (área bajo una curva
con ancho cero), que es 0:
Para visualizar esto, podemos encontrar una estimación de la CDF de la muestra, llamada
función de distribución acumulativa empírica (ECDF). Dado que esto es acumulativo, en el
punto donde el valor en el eje x es igual a x, el valor de y es la probabilidad acumulativa de P(X
≤ x). Visualicemos P(X ≤ 50), P(X = 50) y P(X > 50) como ejemplo:
Figura 1.10 – Visualizando el CDF
Además de examinar la distribución de nuestros datos, podemos encontrar la necesidad de

utilizar distribuciones de probabilidad para usos como la simulación (que se analiza en el
Capítulo 8, Detección de anomalías basada en reglas) o la prueba de hipótesis (consulte la
sección de Estadísticas inferenciales); echemos un vistazo a algunas distribuciones con las que
probablemente nos encontraremos.
Distribuciones comunes
Si bien existen muchas distribuciones de probabilidad, cada una con casos de uso específicos,
hay algunas con las que nos encontraremos con frecuencia. La gaussiana, o normal, parece
una curva de campana y está parametrizada por su media (μ) y su desviación estándar (σ). La
normal estándar (Z) tiene una media de 0 y una desviación estándar de 1. Muchas cosas en la
naturaleza siguen la distribución normal, como las alturas. Tenga en cuenta que comprobar si
una distribución es normal no es trivial; consulte la sección Lecturas adicionales para obtener
más información.
La distribución de Poisson es una distribución discreta que se utiliza a menudo para modelar
llegadas. El tiempo entre llegadas se puede modelar con la distribución exponencial. Ambos se
definen por su media, lambda (λ). La distribución uniforme asigna la misma probabilidad a cada
valor dentro de sus límites. A menudo usamos esto para la generación de números aleatorios.
Cuando generamos un número aleatorio para simular un único resultado de éxito/fracaso, se
denomina ensayo de Bernoulli. Esto está parametrizado por la probabilidad de éxito (p).
Cuando ejecutamos el mismo experimento varias veces (n), el número total de éxitos es una
variable aleatoria binomial. Tanto la distribución de Bernoulli como la binomial son discretas.
Podemos visualizar distribuciones tanto discretas como continuas; sin embargo, las
distribuciones discretas nos dan una función de masa de probabilidad (PMF) en lugar de una
PDF:
Figura 1.11 – Visualización de algunas distribuciones comúnmente utilizadas
Usaremos algunas de estas distribuciones en el Capítulo 8, Detección de anomalías basada en

reglas, cuando simulemos algunos datos de intentos de inicio de sesión para la detección de
anomalías.
Datos de escala
Para comparar variables de diferentes distribuciones, tendríamos que escalar los datos, lo que
podríamos hacer con el rango usando la escala mínima-máxima. Tomamos cada punto de
datos, restamos el mínimo del conjunto de datos y luego lo dividimos por el rango. Esto
normaliza nuestros datos (los escala al rango [0, 1]):
Esta no es la única forma de escalar datos; También podemos usar la media y la desviación
estándar. En este caso, restaríamos la media de cada observación y luego dividiríamos por la
desviación estándar para estandarizar los datos. Esto nos da lo que se conoce como puntuación
Z:
Nos queda una distribución normalizada con una media de 0 y una desviación estándar (y
varianza) de 1. La puntuación Z nos dice cuántas desviaciones estándar de la media tiene cada
observación; la media tiene una puntuación Z de 0, mientras que una observación de 0,5
desviaciones estándar por debajo de la media tendrá una puntuación Z de -0,5.
Por supuesto, existen formas adicionales de escalar nuestros datos, y la que terminemos
eligiendo dependerá de nuestros datos y de lo que intentemos hacer con ellos. Si tiene en cuenta
las medidas de tendencia central y las medidas de dispersión, podrá identificar cómo se realiza el
escalado de datos con cualquier otro método que encuentre.
Cuantificar relaciones entre variables.

En las secciones anteriores, tratamos con estadísticas univariadas y solo pudimos decir algo
sobre la variable que estábamos analizando. Con la estadística multivariada buscamos cuantificar
las relaciones entre variables e intentamos hacer predicciones para el comportamiento futuro.
La covarianza es una estadística para cuantificar la relación entre variables mostrando cómo una
variable cambia con respecto a otra (también conocida como su varianza conjunta):
Nota IMPORTANTE
E[X] es una notación nueva para nosotros. Se lee como el valor esperado de X o la expectativa
de X, y se calcula sumando todos los valores posibles de X multiplicados por su probabilidad: es
el promedio a largo plazo de X.
La magnitud de la covarianza no es fácil de interpretar, pero su signo nos dice si las variables
están correlacionadas positiva o negativamente. Sin embargo, también nos gustaría cuantificar
qué tan fuerte es la relación entre las variables, lo que nos lleva a la correlación. La correlación
nos dice cómo las variables cambian juntas tanto en dirección (igual u opuesta) como en
magnitud (fuerza de la relación). Para encontrar la correlación, calculamos el coeficiente de
correlación de Pearson, simbolizado por ρ (la letra griega rho), dividiendo la covarianza por el
producto de las desviaciones estándar de las variables:
Esto normaliza la covarianza y da como resultado una estadística limitada entre -1 y 1, lo que
facilita describir tanto la dirección de la correlación (signo) como su fuerza (magnitud). Se dice que
las correlaciones de 1 son correlaciones positivas (lineales) perfectas, mientras que las de -1 son
correlaciones negativas perfectas. Los valores cercanos a 0 no están correlacionados. Si los
coeficientes de correlación están cerca de 1 en valor absoluto, entonces se dice que las variables
están fuertemente correlacionadas; se dice que aquellos más cercanos a 0,5 están débilmente
correlacionados.
Veamos algunos ejemplos que utilizan diagramas de dispersión. En el subgráfico situado más a la
izquierda de la Figura 1.12 (ρ = 0,11), vemos que no hay correlación entre las variables: parecen
ser ruido aleatorio sin patrón. El siguiente gráfico con ρ = -0,52 tiene una correlación negativa
débil: podemos ver que las variables parecen moverse junto con la variable x aumentando,
mientras que la variable y disminuye, pero todavía hay un poco de aleatoriedad. En el tercer
gráfico desde la izquierda (ρ = 0,87), hay una fuerte correlación positiva: x e y aumentan juntos. El
gráfico de la derecha con ρ = -0,99 tiene una correlación negativa casi perfecta: a medida que x
aumenta, y disminuye. También podemos ver como los puntos forman una recta:
Figura 1.12 – Comparación de coeficientes de correlación
Para observar rápidamente la fuerza y la dirección de la relación entre dos variables (y ver si
parece haber una), a menudo usamos diagramas de dispersión en lugar de calcular el coeficiente
de correlación exacto. Esto se debe a un par de razones:
• Es más fácil encontrar patrones en las visualizaciones, pero cuesta más llegar a la misma
conclusión mirando números y tablas.
• Podríamos ver que las variables parecen relacionadas, pero es posible que no lo estén
linealmente. Observar una representación visual facilitará ver si nuestros datos son en
realidad una función cuadrática, exponencial, logarítmica o alguna otra función no lineal.
Los dos gráficos siguientes representan datos con fuertes correlaciones positivas, pero es
bastante obvio al observar los diagramas de dispersión que no son lineales. El de la izquierda
es logarítmico, mientras que el de la derecha es exponencial:
Figura 1.13 – El coeficiente de correlación puede ser engañoso
Es muy importante recordar que si bien podemos encontrar una correlación entre X e Y, eso
no significa que X cause Y o que Y cause X. Podría haber algo de Z que en realidad cause
ambos; tal vez X cause algún evento intermedio que cause Y, o en realidad sea solo una
coincidencia. Tenga en cuenta que a menudo no tenemos suficiente información para
informar la causalidad; la correlación no implica causalidad.
Consejo
Asegúrese de consultar el blog Spurious Correlations de Tyler Vigen (https://
www.tylervigen.com/spurious-correlations) para ver algunas correlaciones interesantes.
Errores de las estadísticas resumidas

Hay un conjunto de datos muy interesante que ilustra cuán cuidadosos debemos ser al utilizar
únicamente estadísticas resumidas y coeficientes de correlación para describir nuestros
datos. También nos muestra que trazar no es opcional. El cuarteto de Anscombe es una
colección de cuatro conjuntos de datos diferentes que tienen estadísticas resumidas y
coeficientes de correlación idénticos, pero cuando se representan gráficamente, es obvio que
no son similares:
Figura 1.14 – Las estadísticas resumidas pueden ser engañosas
Observe que cada una de las gráficas de la figura 1.14 tiene una línea de mejor ajuste idéntica
definida por la ecuación y = 0,50x + 3,00. En la siguiente sección, discutiremos, a alto nivel, cómo
se crea esta línea y qué significa.
Nota IMPORTANTE
Las estadísticas resumidas son muy útiles cuando conocemos los datos, pero tenga cuidado de
no confiar exclusivamente en ellas. Recuerde, las estadísticas pueden ser engañosas;
asegúrese también de trazar los datos antes de sacar conclusiones o continuar con el análisis.
Puede leer más sobre el cuarteto de Anscombe en https://en.wikipedia.org/wiki/Anscombe%
27s_quartet. Además, asegúrese de consultar Datasaurus Dozen, que son 13 conjuntos de
datos que también tienen las mismas estadísticas resumidas, en https://www.autodeskresearch.
com/publicaciones/samestats.
Predicción y pronóstico
Digamos que nuestra heladería favorita nos ha pedido que le ayudemos a predecir cuántos
helados puede esperar vender en un día determinado. Están convencidos de que la
temperatura exterior influye mucho en sus ventas, por lo que han recopilado datos sobre el
número de helados vendidos a una temperatura determinada. Aceptamos ayudarlos y lo
primero que hacemos es hacer un diagrama de dispersión de los datos que recopilaron:
Figura 1.15 – Observaciones de ventas de helados a distintas temperaturas
Podemos observar una tendencia ascendente en el diagrama de dispersión: se venden más

helados a temperaturas más altas. Sin embargo, para ayudar a la heladería, necesitamos
encontrar una manera de hacer predicciones a partir de estos datos. Podemos utilizar una
técnica llamada regresión para modelar la relación entre la temperatura y las ventas de helado
con una ecuación. Usando esta ecuación, podremos predecir las ventas de helado a una
temperatura determinada.
Nota IMPORTANTE
Recuerde que correlación no implica causalidad. La gente puede comprar helado cuando hace
más calor, pero las temperaturas más cálidas no necesariamente hacen que la gente compre
helado.
En el Capítulo 9, Introducción al aprendizaje automático en Python, analizaremos la regresión

en profundidad, por lo que esta discusión será una descripción general de alto nivel. Hay
muchos tipos de regresión que producirán un tipo diferente de ecuación, como la lineal (que
usaremos para este ejemplo) y la logística. Nuestro primer paso será identificar la variable
dependiente, que es la cantidad que queremos predecir (ventas de helado), y las variables
que utilizaremos para predecirla, que se denominan variables independientes. Si bien
podemos tener muchas variables independientes, nuestro ejemplo de ventas de helado solo
tiene una: la temperatura. Por lo tanto, usaremos regresión lineal simple para modelar la
relación como una línea:
Figura 1.16 – Ajuste de una línea a los datos de ventas de helados
La línea de regresión en el diagrama de dispersión anterior produce la siguiente ecuación para

la relación:
Supongamos que hoy la temperatura es de 35°C; lo sustituiríamos como temperatura en la

ecuación. El resultado predice que la heladería venderá 24,54 helados. Esta predicción está a
lo largo de la línea roja en el gráfico anterior. Tenga en cuenta que la heladería en realidad no
puede vender fracciones de helado.
Antes de dejar el modelo en manos de la heladería, es importante discutir la diferencia entre las porciones
punteadas y sólidas de la recta de regresión que obtuvimos. Cuando hacemos predicciones usando la parte
sólida de la línea, usamos interpolación, lo que significa que predeciremos las ventas de helado para las
temperaturas en las que se creó la regresión. Por otro lado, si intentamos predecir cuántos helados se
venderán a 45°C, se llama extrapolación (la parte punteada de la línea), ya que no teníamos temperaturas
tan altas cuando ejecutamos la regresión. . La extrapolación puede ser muy peligrosa ya que muchas
tendencias no continúan indefinidamente. La gente puede decidir no salir de casa porque hace mucho calor.
Esto significa que en lugar de vender los 39,54 helados previstos, venderían cero.
Cuando trabajamos con series temporales, nuestra terminología es un poco diferente: a menudo buscamos
pronosticar valores futuros basándonos en valores pasados. La previsión es un tipo de predicción de series
de tiempo. Sin embargo, antes de intentar modelar la serie temporal, a menudo usaremos un proceso
llamado descomposición de series temporales para dividir la serie temporal en componentes, que pueden
combinarse de forma aditiva o multiplicativa y pueden usarse como partes de un modelo.
El componente tendencial describe el comportamiento de la serie temporal en el largo plazo sin tener en
cuenta efectos estacionales o cíclicos. Utilizando la tendencia, podemos hacer afirmaciones amplias sobre
las series temporales a largo plazo, como por ejemplo que la población de la Tierra está aumentando o el
valor de una acción se está estancando. El componente de estacionalidad explica los movimientos
sistemáticos y relacionados con el calendario de una serie temporal. Por ejemplo, el número de camiones de
helados en las calles de la ciudad de Nueva York es elevado en verano y disminuye a cero en invierno; este
patrón se repite todos los años, independientemente de si la cantidad real cada verano es la misma. Por
último, el componente cíclico da cuenta de todo lo demás que no se explica o es irregular en la serie
temporal; Esto podría ser algo como un huracán que reducirá el número de camiones de helados en el corto
plazo porque no es seguro estar afuera. Este componente es difícil de anticipar con un pronóstico debido a
su carácter inesperado.
Podemos usar Python para descomponer la serie temporal en tendencia, estacionalidad y ruido o residuos.
El componente cíclico se capta en el ruido (datos aleatorios e impredecibles); Después de eliminar la
tendencia y la estacionalidad de la serie temporal, lo que nos queda es el residual:
Figura 1.17 – Un ejemplo de descomposición de series temporales
Al crear modelos para pronosticar series temporales, algunos métodos comunes incluyen el suavizado
exponencial y los modelos de la familia ARIMA. ARIMA significa autorregresivo (AR), integrado (I),
promedio móvil (MA). Los modelos autorregresivos aprovechan el hecho de que una observación en el
momento t está correlacionada con una observación anterior, por ejemplo, en el momento t - 1. En el
Capítulo 5, Visualización de datos con Pandas y Matplotlib, veremos algunas técnicas para determinar si
un la serie temporal es autorregresiva; tenga en cuenta que no todas las series temporales lo son. El
componente integrado se refiere a los datos diferenciados, o al cambio de los datos de un momento a otro.
Por ejemplo, si nos preocupara un desfase (distancia entre tiempos) de 1, los datos diferenciados serían el
valor en el tiempo t restado por el valor en el tiempo t - 1. Por último, el componente de media móvil utiliza
una ventana deslizante para promediar las últimas x observaciones, donde x es la longitud de la ventana
corrediza. Si, por ejemplo, tenemos un promedio móvil de 3 períodos, cuando tengamos todos los datos
hasta el momento 5, nuestro cálculo de promedio móvil solo utilizará los períodos de tiempo 3, 4 y 5 para
pronosticar el tiempo 6. Construiremos un modelo ARIMA en el Capítulo 7, Análisis financiero: Bitcoin y el
mercado de valores.
La media móvil otorga el mismo peso a cada período del pasado involucrado en el cálculo. En la práctica,
esta no siempre es una expectativa realista de nuestros datos. A veces, todos los valores pasados son
importantes, pero varían en su influencia en los puntos de datos futuros. Para estos casos, podemos
utilizar el suavizado exponencial, que nos permite poner más peso en los valores más recientes y menos
peso en los valores más alejados de lo que estamos prediciendo.
Tenga en cuenta que no estamos limitados a predecir números; de hecho, dependiendo de los datos,
nuestras predicciones podrían ser de naturaleza categórica: cosas como determinar qué sabor de
helado se venderá más en un día determinado o si un correo electrónico es spam o no. Este tipo de
predicción se presentará en el Capítulo 9, Introducción al aprendizaje automático en Python.
Estadística inferencial
Como se mencionó anteriormente, la estadística inferencial se ocupa de inferir o deducir cosas a

partir de los datos de muestra que tenemos para hacer afirmaciones sobre la población en su
conjunto. Cuando queremos expresar nuestras conclusiones, debemos tener en cuenta si realizamos
un estudio observacional o un experimento. En un estudio observacional, la variable independiente no
está bajo el control de los investigadores, por lo que observamos a quienes participan en nuestro
estudio (pensemos en los estudios sobre el tabaquismo: no podemos obligar a las personas a fumar).
El hecho de que no podamos controlar la variable independiente significa que no podemos concluir
causalidad.
Con un experimento, podemos influir directamente en la variable independiente y asignar

aleatoriamente sujetos a los grupos de control y de prueba, como las pruebas A/B (para cualquier
cosa, desde rediseños de sitios web hasta textos de anuncios). Tenga en cuenta que el grupo de
control no recibe tratamiento; se les puede dar un placebo (dependiendo de cuál sea el estudio). La
configuración ideal para esto es el doble ciego, donde los investigadores que administran el
tratamiento no saben qué tratamiento es el placebo y tampoco saben qué sujeto pertenece a qué
grupo.
Nota IMPORTANTE
A menudo podemos encontrar referencias a la inferencia bayesiana y a la inferencia frecuentista.

Estos se basan en dos formas diferentes de abordar la probabilidad. La estadística frecuentista se
centra en la frecuencia de un evento, mientras que la estadística bayesiana utiliza un grado de
creencia para determinar la probabilidad de un evento. Veremos un ejemplo de estadística bayesiana
en el Capítulo 11, Detección de anomalías del aprendizaje automático. Puede leer más sobre en qué
se diferencian estos métodos en https://www.probabilisticworld.com/frequentist-bayesianapproaches-
Estadística inferencial/.
La estadística inferencial nos brinda herramientas para traducir nuestra comprensión de los
datos de la muestra en una afirmación sobre la población. Recuerde que las estadísticas
muestrales que analizamos anteriormente son estimadores de los parámetros poblacionales.
Nuestros estimadores necesitan intervalos de confianza, que proporcionen una estimación
puntual y un margen de error a su alrededor. Este es el rango en el que estará el verdadero
parámetro de población en un cierto nivel de confianza. Con un nivel de confianza del 95%, el
95% de los intervalos de confianza que se calculan a partir de muestras aleatorias de la
población contienen el parámetro poblacional verdadero. Con frecuencia, se elige el 95% para el
nivel de confianza y otros fines en las estadísticas, aunque el 90% y el 99% también son
comunes; cuanto mayor sea el nivel de confianza, más amplio será el intervalo.
Las pruebas de hipótesis nos permiten probar si el verdadero parámetro poblacional es menor,
mayor o no igual a algún valor en un cierto nivel de significancia (llamado alfa). El proceso de
realizar una prueba de hipótesis comienza estableciendo nuestra suposición inicial o hipótesis
nula: por ejemplo, la media poblacional verdadera es 0. Elegimos un nivel de significancia
estadística, generalmente 5%, que es la probabilidad de rechazar la hipótesis nula cuando es
verdad. Luego, calculamos el valor crítico de la estadística de prueba, que dependerá de la
cantidad de datos que tengamos y del tipo de estadística (como la media de una población o la
proporción de votos de un candidato) que estemos probando. El valor crítico se compara con el
estadístico de prueba de nuestros datos y, según el resultado, rechazamos o no rechazamos la
hipótesis nula. Las pruebas de hipótesis están estrechamente relacionadas con los intervalos de
confianza. El nivel de significancia equivale a 1 menos el nivel de confianza. Esto significa que
un resultado es estadísticamente significativo si el valor de la hipótesis nula no está en el
intervalo de confianza.
Nota IMPORTANTE
Hay muchas cosas que debemos tener en cuenta al elegir el método para calcular un intervalo
de confianza o el estadístico de prueba adecuado para una prueba de hipótesis. Esto está más
allá del alcance de este libro, pero consulte el enlace en la sección Lectura adicional al final de
este capítulo para obtener más información. Además, asegúrese de observar algunos de los
contratiempos con los valores p utilizados en las pruebas de hipótesis, como p-hacking, en
https://en.wikipedia.org/wiki/Misuse_of_p-values.
Ahora que tenemos una descripción general de las estadísticas y el análisis de datos, estamos
listos para comenzar con la parte de Python de este libro. Comencemos configurando un entorno
virtual.
Configurar un entorno virtual
Este libro fue escrito usando Python 3.7.3, pero el código debería funcionar para Python
3.7.1+, que está disponible en todos los principales sistemas operativos. En esta sección,
repasaremos cómo configurar el entorno virtual para poder seguir adelante con este libro. Si
Python aún no está instalado en su computadora, lea primero las siguientes secciones sobre
entornos virtuales y luego decida si desea instalar Anaconda, ya que también instalará
Python. Para instalar Python sin Anaconda, descárguelo desde https://www. python.org/
downloads/ y luego siga la sección venv en lugar de la sección conda.
Nota IMPORTANTE
Para verificar si Python ya está instalado, ejecute donde python3 desde la línea de comando
en Windows o what python3 desde la línea de comando en Linux/macOS. Si esto no
devuelve nada, intente ejecutarlo solo con Python (en lugar de Python3). Si Python está
instalado, verifique la versión ejecutando python3 --version. Tenga en cuenta que si python3
funciona, entonces debería usarlo a lo largo del libro (y a la inversa, usar python si python3
no funciona).
Entornos virtuales
La mayoría de las veces, cuando queremos instalar software en nuestra computadora,

simplemente lo descargamos, pero la naturaleza de los lenguajes de programación donde
los paquetes se actualizan constantemente y dependen de versiones específicas de otros
significa que esto puede causar problemas. Podríamos estar trabajando en un proyecto un
día en el que necesitemos una determinada versión de un paquete de Python (digamos
0.9.1), pero al día siguiente estar trabajando en un análisis en el que necesitemos la versión
más reciente de ese mismo paquete para acceder a algunas versiones más nuevas.
funcionalidad (1.1.0). Parece que no habría ningún problema, ¿verdad? Bueno, ¿qué sucede
si esta actualización provoca un cambio importante en el primer proyecto o en otro paquete
de nuestro proyecto que depende de este? Este es un problema bastante común y ya existe
una solución para evitar que se convierta en un problema: los entornos virtuales.
Un entorno virtual nos permite crear entornos separados para cada uno de nuestros
proyectos. Cada uno de nuestros entornos sólo tendrá instalados los paquetes que necesite.
Esto hace que sea fácil compartir nuestro entorno con otros, tener múltiples versiones del
mismo paquete instaladas en nuestra máquina para diferentes proyectos sin interferir entre
sí y evitar efectos secundarios inesperados al instalar paquetes que se actualizan o
dependen de otros. Es una buena práctica crear un entorno virtual dedicado para cualquier
proyecto en el que trabajemos.
Configurar un entorno virtual 35
Analizaremos dos formas comunes de lograr esta configuración y usted podrá decidir cuál se
adapta mejor. Tenga en cuenta que todo el código de esta sección se ejecutará en la línea
de comando.
venv
Python 3 viene con el módulo venv, que creará un entorno virtual en la ubicación que
elijamos. El proceso de configuración y uso de un entorno de desarrollo es el siguiente
(después de instalar Python):
1. Cree una carpeta para el proyecto.
2. Utilice venv para crear un entorno en esta carpeta.
3. Activa el entorno.
4. Instale paquetes de Python en el entorno con pip.
5. Desactiva el entorno cuando termines.
En la práctica, crearemos entornos para cada proyecto en el que trabajemos, por lo que
nuestro primer paso será crear un directorio para todos los archivos de nuestro proyecto.
Para ello podemos utilizar el comando mkdir. Una vez creado esto, cambiaremos nuestro
directorio actual al recién creado usando el comando cd. Dado que ya obtuvimos los archivos
del proyecto (de las instrucciones en la sección de materiales del capítulo), lo siguiente es
solo como referencia. Para crear un nuevo directorio y movernos a ese directorio, podemos
usar el siguiente comando:
$ mkdir mi_proyecto && cd mi_proyecto
Consejo
cd <ruta> cambia el directorio actual a la ruta especificada en <ruta>, que puede ser una ruta
absoluta (completa) o relativa (cómo llegar desde el directorio actual).
Antes de continuar, use cd para navegar hasta el directorio que contiene el repositorio de
este libro. Tenga en cuenta que la ruta dependerá de dónde se clonó/descargó:
$ ruta del cd/a/Análisis-práctico-de-datos-con-Pandas-segunda-edición
Dado que existen ligeras diferencias en los sistemas operativos para los pasos restantes,
repasaremos Windows y Linux/macOS por separado. Tenga en cuenta que si tiene Python 2
y Python 3, asegúrese de usar python3 y no python en los siguientes comandos.
Ventanas
Para crear nuestro entorno para este libro, usaremos el módulo venv de la biblioteca estándar.
Tenga en cuenta que debemos proporcionar un nombre para nuestro entorno (book_env).
Recuerde, si su configuración de Windows tiene Python asociado con Python 3, utilice Python en
lugar de Python3 en el siguiente comando:
C:\...> python3 -m venv libro_env
Ahora, tenemos una carpeta para nuestro entorno virtual llamada book_env dentro de la carpeta
del repositorio que clonamos/descargamos anteriormente. Para utilizar el entorno, necesitamos
activarlo:
C:\...> %cd%\book_env\Scripts\activate.bat
Consejo
Windows reemplaza %cd% con la ruta al directorio actual. Esto nos evita tener que escribir la ruta
completa hasta la parte book_env.
Tenga en cuenta que después de activar el entorno virtual, podemos ver (book_env) delante de
nuestro mensaje en la línea de comando; esto nos permite saber que estamos en el entorno:
(book_env) C:\...>
Cuando terminemos de utilizar el entorno simplemente lo desactivamos:
(book_env) C:\...> desactivar
Cualquier paquete que esté instalado en el entorno no existe fuera del entorno. Tenga en cuenta
que ya no tenemos (book_env) delante de nuestro mensaje en la línea de comando. Puede leer
más sobre venv en la documentación de Python en https://docs. python.org/3/library/venv.html.
Ahora que se creó el entorno virtual, actívelo y luego diríjase a la sección Instalación de los
paquetes de Python necesarios para el siguiente paso.
Linux/macOS
Para crear nuestro entorno para este libro, usaremos el módulo venv de la biblioteca estándar.
Tenga en cuenta que debemos proporcionar un nombre para nuestro entorno (book_env):
$ python3 -m venv libro_env

Ahora, tenemos una carpeta para nuestro entorno virtual llamada book_env dentro de
la carpeta del repositorio que clonamos/descargamos anteriormente. Para utilizar el
entorno, necesitamos activarlo:
$ fuente book_env/bin/activate
Tenga en cuenta que después de activar el entorno virtual, podemos ver (book_env)
delante de nuestro mensaje en la línea de comando; esto nos permite saber que
estamos en el entorno:
(book_env) $
Cuando terminemos de utilizar el entorno simplemente lo desactivamos:
(book_env) $ desactivar
Cualquier paquete que esté instalado en el entorno no existe fuera del entorno. Tenga
en cuenta que ya no tenemos (book_env) delante de nuestro mensaje en la línea de
comando. Puede leer más sobre venv en la documentación de Python en https://docs.
python.org/3/library/venv.html.
Ahora que se creó el entorno virtual, actívelo y luego diríjase a la sección Instalación de
los paquetes de Python necesarios para el siguiente paso.
Conda
Anaconda proporciona una forma de configurar un entorno Python específicamente

para la ciencia de datos. Incluye algunos de los paquetes que usaremos en este libro,
junto con varios otros que pueden ser necesarios para tareas que no están cubiertas en
este libro (y también trata dependencias fuera de Python que de otro modo podrían ser
difíciles de instalar). Anaconda usa conda como entorno y administrador de paquetes
en lugar de pip, aunque los paquetes aún se pueden instalar con pip (siempre que se
llame al pip instalado por Anaconda). Tenga en cuenta que es posible que algunos
paquetes no estén disponibles con conda, en cuyo caso tendremos que usar pip.
Consulte esta página en la documentación de conda para obtener una comparación de
los comandos utilizados con conda, pip y venv: https://conda.io/projects/conda/en/latest/
commands.html#conda-vs-pip-vs-virtualenv -comandos.
Nota IMPORTANTE
Tenga en cuenta que Anaconda es una instalación muy grande (aunque la versión
Miniconda es mucho más ligera). Aquellos que usan Python para fines distintos a la
ciencia de datos pueden preferir el método venv que discutimos anteriormente para
tener más control sobre lo que se instala.
Anaconda también se puede empaquetar con el entorno de desarrollo integrado (IDE) de

Spyder y Jupyter Notebooks, que analizaremos más adelante. Tenga en cuenta que también
podemos usar Jupyter con la opción venv.
Puede leer más sobre Anaconda y cómo instalarlo en las siguientes páginas de su
documentación oficial:
• Windows: https://docs.anaconda.com/anaconda/install/
• ventanas/
• MacOS: https://docs.anaconda.com/anaconda/install/mac-os/
• Linux: https://docs.anaconda.com/anaconda/install/linux/
• Guía del usuario: https://docs.anaconda.com/anaconda/user-guide/
Una vez que haya instalado Anaconda o Miniconda, confirme que esté instalado correctamente
ejecutando conda -V en la línea de comando para mostrar la versión. Tenga en cuenta que en
Windows, todos los comandos conda deben ejecutarse en el símbolo del sistema Anaconda (a
diferencia del símbolo del sistema).
Para crear un nuevo entorno conda para este libro, llamado book_env, ejecute lo siguiente:
(base) $ conda crear --name book_env
La ejecución de conda env list mostrará todos los entornos conda en el sistema, que ahora
incluirán book_env. El entorno activo actual tendrá un asterisco (*) al lado; de forma
predeterminada, la base estará activa hasta que activemos otro entorno:
(base) $ conda lista de entornos

# entornos conda:
#
base * /miniconda3
book_env /miniconda3/envs/book_env
Para activar el entorno book_env, ejecutamos el siguiente comando:
(base) $ conda activar book_env
Tenga en cuenta que después de activar el entorno virtual, podemos ver (book_env) delante de
nuestro mensaje en la línea de comando; esto nos permite saber que estamos en el entorno:
(book_env) $
Cuando terminemos de utilizar el entorno, lo desactivamos:

(book_env) $ conda desactivar
Cualquier paquete que esté instalado en el entorno no existe fuera del entorno. Tenga en
cuenta que ya no tenemos (book_env) delante de nuestro mensaje en la línea de comando.
Puede leer más sobre cómo usar conda para administrar entornos virtuales en https://
www.freecodecamp.org/news/why-you-need-pythonenvironments-and-how-to-manage-them-
with-conda-85f155f4353c/ .
En la siguiente sección, instalaremos los paquetes de Python necesarios para seguir este
libro, así que asegúrese de activar el entorno virtual ahora.
Instalación de los paquetes de Python necesarios

Podemos hacer mucho con la biblioteca estándar de Python; sin embargo, a menudo
encontraremos la necesidad de instalar y utilizar un paquete externo para ampliar la
funcionalidad. El archivo requisitos.txt en el repositorio contiene todos los paquetes que
necesitamos instalar para trabajar con este libro. Estará en nuestro directorio actual, pero
también se puede encontrar en https://github.com/stefmolin/Hands-On-Data-Analysis-with-
Pandas-2nd-edition/blob/master/requirements.txt. Este archivo se puede utilizar para instalar
varios paquetes a la vez con el indicador -r en la llamada a pip3 install y tiene la ventaja de ser
fácil de compartir.
Antes de instalar cualquier cosa, asegúrese de activar el entorno virtual que creó con venv o
conda. Tenga en cuenta que si el entorno no se activa antes de ejecutar el siguiente
comando, los paquetes se instalarán fuera del entorno:
(book_env) $ pip3 instalar -r requisitos.txt
Consejo
Si encuentra algún problema, infórmelo en https://github.com/stefmolin/Hands-On-Data-
Analysis-with-Pandas-2ndedition/issues.
¿Por qué pandas?
Cuando se trata de ciencia de datos en Python, la biblioteca pandas es bastante

omnipresente. Está construido sobre la biblioteca NumPy, lo que nos permite realizar
operaciones matemáticas en matrices de datos de un solo tipo de manera eficiente. Pandas
expande esto a marcos de datos, que pueden considerarse como tablas de datos.
Obtendremos una introducción más formal a los marcos de datos en el Capítulo 2, Trabajar
con Pandas DataFrames.
Además de operaciones eficientes, pandas también proporciona contenedores para la

biblioteca de trazado matplotlib, lo que hace que sea muy fácil crear una variedad de gráficos
sin necesidad de escribir muchas líneas de código matplotlib. Siempre podemos modificar
nuestros gráficos usando matplotlib, pero para visualizar rápidamente nuestros datos, solo
necesitamos una línea de código en pandas. Exploraremos esta funcionalidad en el Capítulo
5, Visualización de datos con Pandas y Matplotlib, y en el Capítulo 6, Trazado con Seaborn y
técnicas de personalización.
Nota IMPORTANTE
Las funciones contenedoras envuelven el código de otra biblioteca, oscureciendo parte de su

complejidad y dejándonos con una interfaz más simple para repetir esa funcionalidad. Este es
un principio básico de la programación orientada a objetos (POO) llamado abstracción, que
reduce la complejidad y la duplicación de código. Crearemos nuestras propias funciones
contenedoras a lo largo de este libro.
Además de los pandas, este libro utiliza Jupyter Notebooks. Si bien usted es libre de elegir no
usarlos, es importante estar familiarizado con los Jupyter Notebooks, ya que son muy
comunes en el mundo de los datos. Como introducción, usaremos un Jupyter Notebook para
validar nuestra configuración en la siguiente sección.
Cuadernos Jupyter
Cada capítulo de este libro incluye Jupyter Notebooks para seguirlo. Los Jupyter Notebooks
están omnipresentes en la ciencia de datos de Python porque hacen que sea muy fácil escribir
y probar código en un entorno más de descubrimiento en comparación con escribir un
programa. Podemos ejecutar un bloque de código a la vez e imprimir los resultados en el
cuaderno, directamente debajo del código que lo generó. Además, podemos usar Markdown
para agregar explicaciones de texto a nuestro trabajo. Los Jupyter Notebooks se pueden
empaquetar y compartir fácilmente; se pueden enviar a GitHub (donde se procesarán),
convertir a HTML o PDF, enviar a otra persona o presentar.
Lanzando JupyterLab
JupyterLab es un IDE que nos permite crear Jupyter Notebooks y scripts Python, interactuar con
la terminal, crear documentos de texto, documentación de referencia y mucho más desde una
interfaz web limpia en nuestra máquina local. Hay muchos atajos de teclado que debes dominar
antes de convertirte realmente en un usuario avanzado, pero la interfaz es bastante intuitiva.
Cuando creamos nuestro entorno, instalamos todo lo que necesitábamos para ejecutar
JupyterLab, así que hagamos un recorrido rápido por el IDE y asegurémonos de que nuestro
entorno esté configurado correctamente. Primero activamos nuestro entorno y luego lanzamos
JupyterLab:
(book_env) $ laboratorio jupyter
Luego, se abrirá una ventana en el navegador predeterminado con JupyterLab. Seremos

recibidos con la pestaña Iniciador y el panel Explorador de archivos a la izquierda:
Figura 1.18 – Lanzamiento de JupyterLab
Usando el panel del Explorador de archivos, haga doble clic en la carpeta ch_01, que contiene el
Jupyter Notebook que usaremos para validar nuestra configuración.
Validando el entorno virtual
Abra el cuaderno check_your_setup.ipynb en la carpeta ch_01, como se muestra en la

siguiente captura de pantalla:
Figura 1.19 – Validación de la configuración del entorno virtual
Nota IMPORTANTE
El kernel es el proceso que ejecuta e introspecciona nuestro código en un Jupyter
Notebook. Tenga en cuenta que no estamos limitados a ejecutar Python: también
podemos ejecutar kernels para R, Julia, Scala y otros lenguajes. De forma
predeterminada, ejecutaremos Python usando el kernel IPython. Aprenderemos un poco
más sobre IPython a lo largo del libro.
Haga clic en la celda de código indicada en la captura de pantalla anterior y ejecútela

haciendo clic en el botón de reproducción (▶). Si todo aparece en verde, el entorno está
configurado. Sin embargo, si este no es el caso, ejecute el siguiente comando desde el
entorno virtual para crear un kernel especial con el entorno virtual book_env para usar con
Jupyter:
(book_env) $ instalación del kernel ipython --usuario --name=book_env

Esto agrega una opción adicional en la pestaña Iniciador, y ahora también podemos cambiar al
kernel book_env desde un Jupyter Notebook:
Figura 1.20 – Seleccionar un kernel diferente
Es importante tener en cuenta que Jupyter Notebooks conservará los valores que asignamos a las
variables mientras se ejecuta el kernel, y los resultados en las celdas Out[#] se guardarán cuando
guardemos el archivo. Cerrar el archivo no detiene el kernel y tampoco cerrar la pestaña
JupyterLab en el navegador.
Cerrando JupyterLab
Cerrar el navegador con JupyterLab no detiene JupyterLab ni los kernels que está ejecutando
(tampoco recuperaremos la interfaz de línea de comandos). Para cerrar JupyterLab por completo,
debemos presionar Ctrl + C (que es una señal de interrupción del teclado que le permite a
JupyterLab saber que queremos cerrarlo) un par de veces en la terminal hasta que recibamos el
mensaje:
...
[I 17:36:53.166 LabApp] Interrumpido...
[I 17:36:53.168 LabApp] Cerrando 1 kernel
[I 17:36:53.770 LabApp] Apagado del kernel: a38e1[...]b44f
(libro_env) $
Para obtener más información sobre Jupyter, incluido un tutorial, consulte http://jupyter. org/.
Obtenga más información sobre JupyterLab en https://jupyterlab.readthedocs.io/en/stable/.
Resumen
En este capítulo, aprendimos sobre los principales procesos al realizar el análisis de datos:
recopilación de datos, discusión de datos, EDA y extracción de conclusiones. Seguimos con una
descripción general de las estadísticas descriptivas y aprendimos cómo describir la tendencia
central y la dispersión de nuestros datos; cómo resumirlo tanto numérica como visualmente
usando el resumen de 5 números, diagramas de caja, histogramas y estimaciones de densidad
del núcleo; cómo escalar nuestros datos; y cómo cuantificar las relaciones entre variables en
nuestro conjunto de datos.
Recibimos una introducción a la predicción y al análisis de series de tiempo. Luego, tuvimos una
descripción general muy breve de algunos temas centrales de la estadística inferencial que
pueden explorarse después de dominar el contenido de este libro. Tenga en cuenta que, si bien
todos los ejemplos de este capítulo corresponden a una o dos variables, los datos de la vida real
suelen tener grandes dimensiones. El Capítulo 10, Mejores predicciones: optimización de
modelos, abordará algunas formas de abordar este problema. Por último, configuramos nuestro
entorno virtual para este libro y aprendimos a trabajar con Jupyter Notebooks.
Ahora que hemos construido una base sólida, comenzaremos a trabajar con datos en Python en
el próximo capítulo.
Ejercicios
Ejecute el cuaderno de introducción_to_data_analysis.ipynb para revisar el contenido de este

capítulo, revise el cuaderno python_101.ipynb (si es necesario) y luego complete los siguientes
ejercicios para practicar el trabajo con JupyterLab y el cálculo de estadísticas resumidas en
Python:
1. Explore la interfaz de JupyterLab y observe algunos de los accesos directos que están
disponibles. No se preocupe por memorizarlos por ahora (con el tiempo, se convertirán en
algo natural y le ahorrarán mucho tiempo); simplemente siéntase cómodo usando Jupyter
Notebooks.
2. ¿Están todos los datos distribuidos normalmente? Explica por qué o por qué no.
3. ¿Cuándo tendría más sentido utilizar la mediana en lugar de la media para la medida del
centro?
4. Ejecute el código en la primera celda del cuaderno de ejercicios.ipynb. Le dará una lista de
100 valores con los que trabajar en el resto de los ejercicios de este capítulo. Asegúrese de
tratar estos valores como una muestra de la población.
Ejercicios 45
5. Utilizando los datos del ejercicio 4, calcule las siguientes estadísticas sin importar nada del
módulo de estadísticas en la biblioteca estándar (https://docs.python.org/3/library/
statistics.html) y luego confirme que sus resultados coincidan. hasta los que se obtienen al
utilizar el módulo de estadísticas (cuando sea posible):
a) Media
b) Mediana
c) Modo (sugerencia: consulte la clase Contador en el módulo de colecciones de la
biblioteca estándar en https://docs.python.org/3/library/
collections.html#collections.Counter)
d) Varianza muestral
e) Desviación estándar muestral
6. Utilizando los datos del ejercicio 4, calcule las siguientes estadísticas utilizando las funciones
del módulo de estadísticas cuando corresponda:
a) rango
b) Coeficiente de variación
c) rango intercuartil
d) Coeficiente de dispersión cuartil
7. Escale los datos creados en el ejercicio 4 utilizando las siguientes estrategias:

a) Escalado mínimo-máximo (normalización)
b) Estandarización
8. Utilizando los datos escalados del ejercicio 7, calcule lo siguiente:

a) La covarianza entre los datos estandarizados y normalizados.
b) El coeficiente de correlación de Pearson entre los datos estandarizados y normalizados
(en realidad es 1, pero debido al redondeo a lo largo del camino, el resultado será
ligeramente menor)
Otraslecturas
Los siguientes son algunos recursos que puede utilizar para familiarizarse más con
Jupyter:
• Jupyter Notebook Basics: https://nbviewer.jupyter.org/github/jupyter/notebook/blob/

master/docs/source/examples/Notebook/Notebook%20Basics.ipynb
• JupyterLab introduction: https://blog.jupyter.org/jupyterlab-isready-for-

users-5a6f039b8906
• Learning Markdown to make your Jupyter Notebooks presentation-ready: https://

medium.com/ibm-data-science-experience/markdown-forjupyter-notebooks-
cheatsheet-386c05aeebed
• 28 Jupyter Notebook Tips, Tricks, and Shortcuts: https://www.dataquest.io/blog/

jupyter-notebook-tips-tricks-shortcuts/
Algunos recursos para aprender conceptos más avanzados de estadística (que no

cubriremos aquí) y aplicarlos cuidadosamente son los siguientes:
• A Gentle Introduction to Normality Tests in Python: https://

machinelearningmastery.com/a-gentle-introduction-tonormality-tests-in-python/
• How Hypothesis Tests Work: Confidence Intervals and Confidence Levels: https://
statisticsbyjim.com/hypothesis-testing/hypothesis-testsconfidence-intervals-levels/
• Intro to Inferential Statistics (Making Predictions with Data) on Udacity: https://

www.udacity.com/course/intro-to-inferential-statistics--ud201
• Lesson 4: Confidence Intervals (Penn State Elementary Statistics): https://

online.stat.psu.edu/stat200/lesson/4
• Seeing Theory: A visual introduction to probability and statistics: https://seeing-

theory.brown.edu/index.html
• Statistics Done Wrong: The Woefully Complete Guide by Alex Reinhart: https://
www.statisticsdonewrong.com/
• Survey Sampling Methods: https://stattrek.com/survey-research/sampling-

methods.aspx
2
Trabajando con
Marcos de datos de Pandas
Ha llegado el momento de comenzar nuestro viaje hacia el universo de los pandas. Este capítulo nos
hará sentir cómodos trabajando con algunas de las operaciones básicas, pero poderosas, que
realizaremos al realizar nuestros análisis de datos con pandas.
Comenzaremos con una introducción a las principales estructuras de datos que encontraremos al
trabajar con pandas. Las estructuras de datos nos proporcionan un formato para organizar, gestionar
y almacenar datos. El conocimiento de las estructuras de datos de Pandas resultará infinitamente útil
cuando se trata de solucionar problemas o buscar cómo realizar una operación con los datos. Tenga
en cuenta que estas estructuras de datos son diferentes de las estructuras de datos estándar de
Python por una razón: fueron creadas para tareas de análisis específicas. Debemos recordar que un
método determinado solo puede funcionar en una determinada estructura de datos, por lo que
debemos poder identificar la mejor estructura para el problema que buscamos resolver.
A continuación, incorporaremos nuestro primer conjunto de datos a Python. Aprenderemos cómo

recopilar datos de una API, crear objetos DataFrame a partir de otras estructuras de datos en
Python, leer archivos e interactuar con bases de datos. Inicialmente, quizás se pregunte por qué
necesitaríamos crear un objeto DataFrame a partir de otras estructuras de datos de Python; sin
embargo, si alguna vez queremos probar algo rápidamente, crear nuestros propios datos, extraer
datos de una API o reutilizar el código Python de otro proyecto, este conocimiento nos resultará
indispensable. Finalmente, dominaremos formas de inspeccionar, describir, filtrar y resumir nuestros
datos.
48 Trabajar con marcos de datos de Pandas
Los siguientes temas se cubrirán en este capítulo:
• Estructuras de datos de pandas

• Crear objetos DataFrame a partir de archivos, solicitudes API, consultas SQL y otros objetos
Python
• Inspeccionar objetos DataFrame y calcular estadísticas resumidas
• Captar subconjuntos de datos mediante selección, división, indexación y filtrado
• Agregar y eliminar datos
Materiales del capítulo
Los archivos con los que trabajaremos en este capítulo se pueden encontrar en el repositorio de
GitHub en https://github.com/stefmolin/Hands-On-Data-Analysis-with-Pandas-2nd-edition/tree/
master/ch_02. Trabajaremos con datos de terremotos del Servicio Geológico de EE. UU. (USGS)
utilizando la API del USGS y los archivos CSV, que se pueden encontrar en el directorio data/.
Hay cuatro archivos CSV y un archivo de base de datos SQLite, los cuales se utilizarán en
diferentes puntos a lo largo de este capítulo. El archivo terremotos.csv contiene datos extraídos
de la API de USGS del 18 de septiembre de 2018 al 13 de octubre de 2018. Para nuestra
discusión sobre estructuras de datos, trabajaremos con el archivo example_data.csv, que
contiene cinco filas y un subconjunto de las columnas del archivo terremotos.csv.
El archivo tsunamis.csv es un subconjunto de los datos del archivo terremotos.csv para todos los
terremotos que estuvieron acompañados de tsunamis durante el rango de fechas mencionado
anteriormente.
El archivo quakes.db contiene una base de datos SQLite con una única tabla para los datos de
tsunamis. Usaremos esto para aprender a leer y escribir en una base de datos con pandas. Por
último, el archivo parsed.csv se utilizará para los ejercicios de final de capítulo y también
explicaremos cómo crearlo durante este capítulo.
El código adjunto a este capítulo se ha dividido en seis Jupyter Notebooks, que están numerados
en el orden en que deben usarse. Contienen los fragmentos de código que ejecutaremos a lo
largo de este capítulo, junto con el resultado completo de cualquier comando que deba recortarse
para este texto. Cada vez que vayamos a cambiar de libreta el texto nos lo indicará.
Estructuras de datos de Pandas 49
En el cuaderno 1-pandas_data_structures.ipynb, comenzaremos a aprender sobre las principales

estructuras de datos de pandas. Luego, discutiremos las diversas formas de crear objetos
DataFrame en el cuaderno 2-creating_dataframes.ipynb. Nuestra discusión sobre este tema
continuará en el cuaderno 3-making_dataframes_from_api_requests.ipynb, donde exploraremos la
API del USGS para recopilar datos para usar con pandas. Después de aprender cómo podemos
recopilar nuestros datos, comenzaremos a aprender cómo realizar un análisis de datos
exploratorios (EDA) en el cuaderno 4-inspecting_dataframes.ipynb. Luego, en el cuaderno 5-
subsetting_data.ipynb, analizaremos varias formas de seleccionar y filtrar datos. Finalmente,
aprenderemos cómo agregar y eliminar datos en el cuaderno 6-adding_and_removing_data.ipynb.
Empecemos.
Estructuras de datos de pandas
Python ya tiene varias estructuras de datos, como tuplas, listas y diccionarios. Pandas proporciona
dos estructuras principales para facilitar el trabajo con datos: Series y DataFrame. Las estructuras
de datos Series y DataFrame contienen cada una otra estructura de datos de pandas, Index, que
también debemos tener en cuenta. Sin embargo, para comprender estas estructuras de
datos, primero debemos echar un vistazo a NumPy (https://numpy.org/doc/stable/), que
proporciona las matrices de n dimensiones sobre las que construyen los pandas.
Las estructuras de datos antes mencionadas se implementan como clases de Python; cuando
realmente creamos uno, se los denomina objetos o instancias. Esta es una distinción importante,
ya que, como veremos, algunas acciones se pueden realizar usando el objeto mismo (un método),
mientras que otras requerirán que pasemos nuestro objeto como argumento a alguna función.
Tenga en cuenta que, en Python, los nombres de las clases se escriben tradicionalmente en
CapWords, mientras que los objetos se escriben en Snake_case. (Puede encontrar más pautas de
estilo de Python en https://www.python.org/dev/peps/pep-0008/).
Usamos una función pandas para leer un archivo CSV en un objeto de la clase DataFrame, pero
usamos métodos en nuestros objetos DataFrame para realizar acciones en ellos, como eliminar
columnas o calcular estadísticas resumidas. Con pandas, a menudo querremos acceder a los
atributos del objeto con el que estamos trabajando. Esto no generará una acción como lo haría un
método o función; más bien, se nos dará información sobre nuestro objeto pandas, como
dimensiones, nombres de columnas, tipos de datos y si está vacío.
Nota IMPORTANTE
Durante el resto de este libro, nos referiremos a los objetos DataFrame
como marcos de datos, a los objetos Series como series y a los objetos
Index como índices/índices, a menos que nos refiramos a la clase misma.
Para esta sección, trabajaremos en el cuaderno 1-pandas_data_structures.ipynb. Para

comenzar, importaremos numpy y lo usaremos para leer el contenido del archivo
example_data.csv en un objeto numpy.array. Los datos provienen de la API del USGS para
terremotos (fuente: https://earthquake.usgs.gov/fdsnws/event/1/). Tenga en cuenta que esta
es la única vez que usaremos NumPy para leer un archivo y que esto se hace sólo con fines
ilustrativos; La parte importante es observar la forma en que se representan los datos con
NumPy:
Ahora tenemos nuestros datos en una matriz NumPy. Usando los atributos de forma y tipo d,
podemos recopilar información sobre las dimensiones de la matriz y los tipos de datos que
contiene, respectivamente:
CCada una de las entradas de la matriz es una fila del archivo CSV. Las matrices NumPy contienen un
único tipo de datos (a diferencia de las listas, que permiten tipos mixtos); esto permite operaciones
rápidas y vectorizadas. Cuando leemos los datos, obtenemos una matriz de objetos numpy.void, que se
utilizan para almacenar tipos flexibles. Esto se debe a que NumPy tuvo que almacenar varios tipos de
datos diferentes por fila: cuatro cadenas, un flotante y un número entero. Desafortunadamente, esto
significa que no podemos aprovechar las mejoras de rendimiento que NumPy proporciona para objetos
de un solo tipo de datos.
Digamos que queremos encontrar la magnitud máxima; podemos usar una lista de
comprensión (https://www.python.org/dev/peps/pep-0202/) para seleccionar el tercer índice de
cada fila, que se representa como un número .objeto vacío. Esto crea una lista, lo que significa que
podemos tomar el máximo usando la función max(). Podemos usar el comando mágico %%timeit de
IPython (un comando especial precedido por %) para ver cuánto tiempo lleva esta implementación (los
tiempos variarán):
Tenga en cuenta que debemos usar una lista por comprensión siempre que escribamos un bucle
for con una sola línea debajo o queramos ejecutar una operación contra los miembros de alguna
lista inicial. Esta es una comprensión de lista bastante simple, pero podemos hacerla más
compleja agregando declaraciones if...else. Las listas por comprensión son una herramienta
extremadamente poderosa que podemos tener en nuestro arsenal. Puede encontrar
más información en la documentación de Python en https://docs.python.org/3/
tutorial/datastructures.html#listcomprehensions.
Consejo
IPython (https://ipython.readthedocs.io/en/stable/index.html) proporciona un
shell interactivo para Python. Los Jupyter Notebooks están construidos sobre
IPython. Si bien no es necesario tener conocimientos de IPython para este
libro, puede resultar útil estar familiarizado con algunas de sus funciones.
IPython incluye un tutorial en su documentación en https://
ipython.readthedocs.io/en/stable/interactive/.
Si, en cambio, creamos una matriz NumPy para cada columna, esta operación es mucho más
fácil (y más eficiente) de realizar. Para hacerlo, usaremos un diccionario de
comprensión (https://www.python.org/dev/peps/pep-0274/) para crear un diccionario
donde las claves son los nombres de las columnas y los valores son matrices NumPy de los
datos. . Nuevamente, la parte importante aquí es cómo se representan ahora los datos usando
NumPy:
Obtener la magnitud máxima ahora es simplemente una cuestión de seleccionar la tecla mag y
llamar al método max() en la matriz NumPy. Esto es casi el doble de rápido que la
implementación de comprensión de listas, cuando se trata de solo cinco entradas; imagine
cuánto peor funcionará el primer intento en conjuntos de datos grandes:
Sin embargo, esta representación tiene otros problemas. Digamos que queremos obtener
toda la información del terremoto de máxima magnitud; ¿Cómo haríamos eso? Necesitamos
encontrar el índice del máximo y luego, para cada una de las claves del diccionario, tomar
ese índice. El resultado ahora es una matriz NumPy de cadenas (nuestros valores numéricos
fueron convertidos), y ahora estamos en el formato que vimos anteriormente:
Considere cómo ordenaríamos los datos por magnitud, de menor a mayor. En la primera
representación, tendríamos que ordenar las filas examinando el tercer índice. Con la segunda
representación, tendríamos que determinar el orden de los índices de la columna mag y luego
ordenar todas las demás matrices con esos mismos índices. Claramente, trabajar con varias
matrices NumPy que contienen diferentes tipos de datos a la vez es un poco engorroso; sin
embargo, pandas se basa en matrices NumPy para facilitar esto. Comencemos nuestra
exploración de los pandas con una descripción general de la estructura de datos de la serie.
Serie
La clase Series proporciona una estructura de datos para matrices de un solo tipo, al igual que la
matriz NumPy. Sin embargo, viene con algunas funciones adicionales. Esta representación
unidimensional se puede considerar como una columna en una hoja de cálculo. Tenemos un
nombre para nuestra columna y los datos que contiene son del mismo tipo (ya que estamos
midiendo la misma variable):
Tenga en cuenta los números a la izquierda del resultado; estos corresponden al número de fila
en el conjunto de datos original (compensado en 1 ya que, en Python, comenzamos a contar en
0). Estos números de fila forman el índice, que analizaremos en la siguiente sección. Junto a los
números de fila, tenemos el valor real de la fila, que, en este ejemplo, es una cadena que indica
dónde ocurrió el terremoto. Observe que tenemos dtype: objeto al lado del nombre del objeto
Serie; esto nos dice que el tipo de datos del lugar es objeto. Una cadena se clasificará como
objeto en pandas. Para acceder a los atributos del objeto Serie, utilizamos notación de atributos
del formato <objeto>.<nombre_atributo>. Los siguientes son algunos atributos comunes a los que
accederemos. Observe que dtype y shape están disponibles, tal como vimos con la matriz
NumPy:
Figura 2.1 – Atributos de series comúnmente utilizados
Nota IMPORTANTE
En su mayor parte, los objetos pandas utilizan matrices NumPy para sus
representaciones de datos internos. Sin embargo, para algunos tipos de
datos, pandas se basa en NumPy para crear sus propios arreglos
(https://pandas.pydata.org/pandasdocs/stable/reference/arrays.html). Por
este motivo, según el tipo de datos, los valores pueden devolver un objeto
pandas.array o numpy.array. Por lo tanto, si necesitamos asegurarnos de
recuperar un tipo específico, se recomienda utilizar el atributo de matriz o el
método to_numpy(), respectivamente, en lugar de valores.
Asegúrese de marcar la documentación de pandas.Series (https://pandas.pydata.org/pandas-docs/

stable/reference/api/pandas.Series.html) para consultarla más adelante. Contiene más información
sobre cómo crear un objeto Serie, la lista completa de atributos y métodos disponibles, así
como un enlace al código fuente. Con esta introducción de alto nivel a la clase Serie, estamos
listos para pasar a la clase Índice.
Índice
La adición de la clase Index hace que la clase Series sea significativamente más poderosa que
una matriz NumPy. La clase Index nos proporciona etiquetas de fila, que permiten la selección por
fila. Dependiendo del tipo, podemos proporcionar un número de fila, una fecha o incluso una
cadena para seleccionar nuestra fila. Desempeña un papel clave en la identificación de entradas
en los datos y se utiliza para multitud de operaciones en pandas, como veremos a lo largo de este
libro. Podemos acceder al índice a través del atributo de índice:
Tenga en cuenta que este es un objeto RangeIndex. Sus valores comienzan en 0 y terminan en 4.
El paso de 1 indica que los índices están separados por 1, lo que significa que tenemos todos los
números enteros en ese rango. La clase de índice predeterminada es RangeIndex; sin embargo,
podemos cambiar el índice, como veremos en el Capítulo 3, Gestión de datos con Pandas. A
menudo, trabajaremos con un objeto Índice de números de fila o fechas (horas).
Al igual que con los objetos Serie, podemos acceder a los datos subyacentes a través del atributo
de valores. Tenga en cuenta que este objeto Index está construido sobre una matriz NumPy:
Algunos de los atributos útiles de los objetos Index incluyen los siguientes:
Figura 2.2 – Atributos de índice comúnmente utilizados
Tanto NumPy como pandas admiten operaciones aritméticas, que se realizarán por elementos.
NumPy usará la posición en la matriz para esto:
Con pandas, esta aritmética de elementos se realiza al hacer coincidir valores de índice. Si
agregamos un objeto Serie con un índice de 0 a 4 (almacenado en x) y otro, y, de 1 a 5, solo
obtendremos resultados donde los índices se alineen (1 a 4). En el Capítulo 3, Gestión de datos
con Pandas, analizaremos algunas formas de cambiar y alinear el índice para que podamos
realizar este tipo de operaciones sin perder datos:
Ahora que hemos tenido una introducción a las clases Serie e Índice, estamos listos para
aprender sobre la clase DataFrame. Tenga en cuenta que puede encontrar más información
sobre la clase Index en la documentación respectiva en https://pandas.pydata.org/
pandasdocs/stable/reference/api/pandas.Index.html.
DATA FRAME
Con la clase Serie, básicamente teníamos columnas de una hoja de cálculo, y todos los datos
eran del mismo tipo. La clase DataFrame se basa en la clase Series y puede tener muchas
columnas, cada una con su propio tipo de datos; podemos considerarlo como una representación
de la hoja de cálculo en su conjunto. Podemos convertir cualquiera de las representaciones
NumPy que construimos a partir de los datos de ejemplo en un objeto DataFrame:
Esto nos da un marco de datos de seis series. Tenga en cuenta la columna anterior a la columna
de tiempo; este es el objeto Índice para las filas. Al crear un objeto DataFrame, pandas alinea
todas las series con el mismo índice. En este caso, es solo el número de fila, pero podríamos
usar fácilmente la columna de tiempo para esto, lo que habilitaría algunas características
adicionales de Pandas, como veremos en el Capítulo 4, Agregación de marcos de datos de
Pandas:
Figura 2.3 – Nuestro primer marco de datos
Cada una de nuestras columnas tiene un único tipo de datos, pero no todas comparten el mismo tipo de datos:
>>> df.dtipos
tiempo objeto
colocar objeto
magTipo objeto
revista flotador64
alerta objeto
tsunami int64
tipo de objeto: objeto
Los valores del marco de datos se ven muy similares a la representación NumPy inicial que teníamos:
>>> df.valores
matriz([['20181013 11:10:23.560',
'262 km al NO de Ozernovskiy, Rusia',
'mww', 6.7, 'verde', 1],
['20181013 04:34:15.580',
'25 km al este de Bitung, Indonesia', 'mww', 5.2, 'verde', 0],
['20181013 00:13:46.220', '42 km al ONO de Sola, Vanuatu',
'mww', 5.7, 'verde', 0],
['20181012 21:09:49.240',
'13km al E de Nueva Concepción, Guatemala',
'mww', 5.7, 'verde', 0],
['20181012 02:52:03.620','128 km al SE de Kimbe,
Papúa Nueva Guinea', 'mww', 5.6, 'verde', 1]], dtype=object)
Podemos acceder a los nombres de las columnas a través del atributo de columnas. Tenga en
cuenta que en realidad también se almacenan en un objeto Index:
Los siguientes son algunos atributos de marco de datos de uso común:
Figura 2.4 – Atributos de marco de datos de uso común
Tenga en cuenta que también podemos realizar aritmética en marcos de datos. Por ejemplo,
podemos agregar df a sí mismo, lo que sumará las columnas numéricas y concatenará las
columnas de cadena:
Pandas solo realizará la operación cuando tanto el índice como la columna coincidan. Aquí,
pandas concatenó las columnas de cadena (hora, lugar, tipo magnético y alerta) en marcos de
datos. Se sumaron las columnas numéricas (mag y tsunami):
Figura 2.5 – Agregar marcos de datos

Creando un DataFrame de pandas 59
Más información sobre los objetos DataFrame y todas las operaciones que se pueden realizar
directamente sobre ellos está disponible en la documentación oficial en https://
pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.HTML; asegúrese
de marcarlo como favorito para referencia futura. Ahora estamos listos para comenzar a
aprender cómo crear objetos DataFrame a partir de una variedad de fuentes.
Creando un marco de datos de pandas

Ahora que entendemos las estructuras de datos con las que trabajaremos, podemos analizar las
diferentes formas en que podemos crearlas. Sin embargo, antes de profundizar en el código, es
importante saber cómo obtener ayuda directamente desde Python. Si alguna vez nos
encontramos inseguros de cómo usar algo en Python, podemos utilizar la función help()
incorporada. Simplemente ejecutamos help(), pasando el paquete, módulo, clase, objeto, método
o función sobre la que queremos leer la documentación. Por supuesto, podemos buscar la
documentación en línea; sin embargo, en la mayoría de los casos, las cadenas de documentación
(el texto de la documentación escrito en el código) que se devuelven con ayuda() serán
equivalentes a esto, ya que se utilizan para generar la documentación.
Suponiendo que primero ejecutamos import pandas como pd, podemos ejecutar help(pd) para
mostrar información sobre el paquete pandas; help(pd.DataFrame) para todos los métodos y
atributos de los objetos DataFrame (tenga en cuenta que también podemos pasar un objeto
DataFrame); y ayuda (pd.read_csv) para obtener más información sobre la función pandas para
leer archivos CSV en Python y cómo usarla. También podemos intentar usar la función dir() y el
atributo __dict__, que nos dará una lista o diccionario de lo que está disponible, respectivamente;
Sin embargo, es posible que estos no sean tan útiles como la función help().
Además, podemos utilizar ? y ?? para obtener ayuda, gracias a IPython, que es parte de lo que
hace que Jupyter Notebooks sea tan poderoso. A diferencia de la función help(), podemos usar
signos de interrogación colocándolos después de cualquier cosa sobre la que queramos saber
más, como si le estuviéramos haciendo una pregunta a Python; por ejemplo, pd.read_csv? y
pd.read_csv??. Estos tres producirán resultados ligeramente diferentes: help() nos dará la cadena
de documentación; ? proporcionará la cadena de documentación, además de información
adicional, dependiendo de lo que estemos preguntando; y ?? nos dará aún más información y, si
es posible, el código fuente detrás de esto.
Pasemos ahora al siguiente cuaderno, 2-creating_dataframes.ipynb, e importemos los paquetes

que necesitaremos para los próximos ejemplos. Usaremos datetime de la biblioteca estándar de
Python, junto con los paquetes de terceros numpy y pandas:
Nota IMPORTANTE
Hemos asignado un alias a cada una de nuestras importaciones. Esto nos permite usar
el paquete pandas refiriéndonos a él con el alias que le asignamos como pd, que es la
forma más común de importarlo. De hecho, sólo podemos referirnos a él como pd, ya
que eso es lo que importamos al espacio de nombres. Los paquetes deben importarse
antes de que podamos usarlos; La instalación coloca los archivos que necesitamos en
nuestra computadora, pero, en aras de la memoria, Python no cargará todos los
paquetes instalados cuando lo iniciemos, solo los que le indiquemos.
Ahora estamos listos para comenzar a usar pandas. Primero, aprenderemos cómo crear objetos
pandas a partir de otros objetos de Python. Luego, aprenderemos cómo hacerlo con archivos
planos, tablas en una base de datos y respuestas de solicitudes API.
Desde un objeto Python
Antes de cubrir todas las formas en que podemos crear un objeto DataFrame a partir de un objeto
Python, debemos aprender cómo crear un objeto Series. Recuerde que un objeto Serie es
esencialmente una columna en un objeto DataFrame, por lo que, una vez que sepamos esto,
debería ser fácil entender cómo crear un objeto DataFrame. Digamos que queremos crear una
serie de cinco números aleatorios entre 0 y 1. Podríamos usar NumPy para generar los números
aleatorios como una matriz y crear la serie a partir de eso.
Consejo
NumPy hace que sea muy fácil generar datos numéricos. Además de generar
números aleatorios, podemos usarlo para obtener números espaciados
uniformemente en un rango determinado con la función np.linspace(); obtener un
rango de números enteros con la función np.arange(); muestra de la normal
estándar con la función np.random.normal(); y cree fácilmente matrices de todos
ceros con la función np.zeros() y todos unos con la función np.ones(). Usaremos
NumPy a lo largo de este libro.
Para garantizar que el resultado sea reproducible, estableceremos la semilla aquí. La semilla
proporciona un punto de partida para la generación de números pseudoaleatorios. Ningún
algoritmo para la generación de números aleatorios es verdaderamente aleatorio; son
deterministas, por lo que al establecer este punto de partida, los números que se generan serán
los mismos cada vez que se ejecute el código. Esto es bueno para probar cosas, pero no para
simulación (donde queremos aleatoriedad), que veremos en el Capítulo 8, Detección de
anomalías basada en reglas. De esta manera, podemos crear un objeto Serie con cualquier
estructura similar a una lista (como matrices NumPy):
Crear un objeto DataFrame es una extensión de crear un objeto Series; estará compuesto de una
o más series, y cada una tendrá un nombre distinto. Esto debería recordarnos las estructuras
similares a diccionarios en Python: las claves son los nombres de las columnas y los valores son
el contenido de las columnas. Tenga en cuenta que si queremos convertir un único objeto Series
en un objeto DataFrame, podemos usar su método to_frame().
Consejo
En informática, un constructor es un fragmento de código que inicializa nuevas
instancias de una clase y las prepara para su uso. Las clases de Python
implementan esto con el método __init__(). Cuando ejecutamos pd.Series(),
Python llama a pd.Series.__init__(), que contiene instrucciones para crear
instancias de un nuevo objeto Serie. Aprenderemos más sobre el método __init__()
en el Capítulo 7, Análisis financiero: Bitcoin y el mercado de valores.
Dado que todas las columnas pueden ser de diferentes tipos de datos, vamos a complicarnos un
poco con este ejemplo. Vamos a crear un objeto DataFrame que contiene tres columnas, con
cinco observaciones cada una:
• aleatorio: cinco números aleatorios entre 0 y 1 como una matriz NumPy
• texto: una lista de cinco cadenas o ninguna
• verdad: una lista de cinco booleanos aleatorios
También crearemos un objeto DatetimeIndex con la función pd.date_range(). El índice contendrá

cinco fechas (períodos=5), todas con un día de diferencia (freq='1D'), terminando con el 21 de
abril de 2019 (fin), y se llamará fecha. Tenga en cuenta que puede encontrar más información
sobre los valores que acepta la función pd.date_range() para las frecuencias en
https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases.
Todo lo que tenemos que hacer es empaquetar las columnas en un diccionario usando los
nombres de columna deseados como claves y pasar esto cuando llamamos al constructor
pd.DataFrame(). El índice se pasa como argumento del índice:
Nota IMPORTANTE
Por convención, usamos _ para mantener variables en un bucle que no nos

interesan. Aquí usamos range() como contador y sus valores no son importantes.
Puede encontrar más información sobre los roles que juega _ en Python en https://
hackernoon.com/understanding-the-underscore-ofpython-309d1a029edc.
Tener fechas en el índice facilita la selección de entradas por fecha (o incluso en un rango de
fechas), como veremos en el Capítulo 3, Gestión de datos con Pandas:
Figura 2.6 – Creación de un marco de datos a partir de un diccionario

En los casos en que los datos no sean un diccionario, sino una lista de diccionarios, aún podemos
usar pd.DataFrame(). Los datos en este formato son lo que esperaríamos al consumirlos desde
una API. Cada entrada de la lista será un diccionario, donde las claves del diccionario son los
nombres de las columnas y los valores del diccionario son los valores de esa columna en ese
índice:
Esto nos da un marco de datos de tres filas (una para cada entrada de la lista) con dos columnas
(una para cada clave en los diccionarios):
Figura 2.7 – Creación de un marco de datos a partir de una lista de diccionarios
De hecho, pd.DataFrame() también funciona para listas de tuplas. Tenga en cuenta que también
podemos pasar los nombres de las columnas como una lista a través del argumento de columnas:
Cada tupla se trata como un registro y se convierte en una fila en el marco de datos:
Figura 2.8 – Creación de un marco de datos a partir de una lista de tuplas
También tenemos la opción de usar pd.DataFrame() con matrices NumPy:
>>> pd.DataFrame(
... np.matriz([
... [0, 0, 0],
... [1, 1, 1],
... [2, 4, 8],
... [3, 9, 27],
... [4, 16, 64]
... ]), columnas=['n', 'n_cuadrado', 'n_cubido']
Esto tendrá el efecto de apilar cada entrada en la matriz como filas en un marco de datos, lo que
nos dará un resultado idéntico a la Figura 2.8.
De un archivo
Los datos que queremos analizar generalmente provendrán de fuera de Python. En muchos casos,
podemos obtener un volcado de datos de una base de datos o un sitio web y llevarlo a Python para
examinarlo. Un volcado de datos recibe su nombre porque contiene una gran cantidad de datos
(posiblemente a un nivel muy granular) y, a menudo, no discrimina ninguno de ellos inicialmente;
por esta razón, pueden resultar difíciles de manejar.
A menudo, estos volcados de datos vendrán en forma de un archivo de texto (.txt) o un archivo
CSV (.csv). Pandas proporciona muchos métodos para leer diferentes tipos de archivos, por lo que
simplemente es cuestión de buscar el que coincida con nuestro formato de archivo. Nuestros datos
de terremotos son un archivo CSV; por lo tanto, usamos la función pd.read_csv() para leerlo. Sin
embargo, siempre debemos hacer una inspección inicial del archivo antes de intentar leerlo; esto
nos informará si necesitamos pasar argumentos adicionales, como sep para especificar el
delimitador o nombres para proporcionar nosotros mismos los nombres de las columnas en
ausencia de una fila de encabezado en el archivo.
Nota IMPORTANTE
Usuarios de Windows: dependiendo de su configuración, es posible que los
comandos de los siguientes bloques de código no funcionen. El cuaderno contiene
alternativas si tiene problemas.
Podemos realizar nuestra debida diligencia directamente en nuestro Jupyter Notebook gracias a
IPython, siempre que antepongamos nuestros comandos con ! para indicar que deben ejecutarse
como comandos de shell. En primer lugar, debemos comprobar el tamaño del archivo, tanto en
términos de líneas como de bytes. Para verificar el número de líneas, usamos la utilidad wc
(recuento de palabras) con el indicador –l para contar el número de líneas. Tenemos 9.333 filas en
el archivo:
Ahora, verifiquemos el tamaño del archivo. Para esta tarea, usaremos ls en el directorio de datos.
Esto nos mostrará la lista de archivos en ese directorio. Podemos agregar el indicador -lh para
obtener información sobre los archivos en un formato legible por humanos. Finalmente, enviamos
este resultado a la utilidad grep, que nos ayudará a aislar los archivos que queremos. Esto nos
dice que el archivo terremotos.csv tiene un tamaño de 3,4 MB:
Tenga en cuenta que IPython también nos permite capturar el resultado del comando en una
variable de Python, por lo que si no nos sentimos cómodos con las canalizaciones (|) o grep,
podemos hacer lo siguiente:
Ahora, echemos un vistazo a las filas superiores para ver si el archivo viene con encabezados.
Usaremos la utilidad head y especificaremos el número de filas con el indicador -n. Esto nos dice
que la primera fila contiene los encabezados de los datos y que los datos están delimitados por
comas (solo porque el archivo tenga la extensión .csv no significa que esté delimitado por comas):
Tenga en cuenta que también debemos verificar las filas inferiores para asegurarnos de que no
haya datos superfluos que debamos ignorar mediante la utilidad tail. Este archivo está bien, por
lo que el resultado no se reproducirá aquí; sin embargo, el cuaderno contiene el resultado.
Por último, es posible que nos interese ver el recuento de columnas en nuestros datos. Si bien
podemos contar los campos en la primera fila del resultado de head, tenemos la opción de usar
la utilidad awk (para escaneo y procesamiento de patrones) para contar nuestras columnas. El
indicador -F nos permite especificar el delimitador (una coma, en este caso). Luego,
especificamos qué hacer con cada registro del archivo. Elegimos imprimir NF, que es una
variable predefinida cuyo valor es el número de campos del registro actual. Aquí decimos salir
inmediatamente después de imprimir para imprimir el número de campos en la primera fila del
archivo; entonces, paramos. Esto parecerá un poco complicado, pero de ninguna manera es algo
que debamos memorizar:
Como sabemos que la primera línea del archivo contiene encabezados y que el archivo está
separado por comas, también podemos contar las columnas usando head para obtener los
encabezados y Python para analizarlos:
Nota IMPORTANTE
La capacidad de ejecutar comandos de shell directamente desde nuestro Jupyter

Notebook optimiza drásticamente nuestro flujo de trabajo. Sin embargo, si no
tenemos experiencia previa con la línea de comandos, puede resultar complicado
aprender estos comandos inicialmente. IPython tiene información útil sobre
cómo ejecutar comandos de shell en su documentación en https://
ipython.readthedocs.io/en/stable/interactive/reference.html#system-shell-access.
Para resumir, ahora sabemos que el archivo tiene 3,4 MB y está delimitado por comas con 26
columnas y 9333 filas, siendo la primera el encabezado. Esto significa que podemos usar la
función pd.read_csv() con los valores predeterminados:
Tenga en cuenta que no estamos limitados a leer datos de archivos en nuestras máquinas
locales; Las rutas de los archivos también pueden ser URL. Como ejemplo, leamos el mismo
archivo CSV de GitHub:
Pandas suele ser muy bueno para determinar qué opciones usar en función de los datos de
entrada, por lo que a menudo no necesitaremos agregar argumentos a esta llamada; sin
embargo, hay muchas opciones disponibles en caso de que las necesitemos, algunas de las
cuales incluyen las siguientes:
Figura 2.9 – Parámetros útiles al leer datos de un archivo
A lo largo de este libro, trabajaremos con archivos CSV; sin embargo, tenga en cuenta que
podemos usar la función read_excel() para leer archivos de Excel, la función read_json() para
archivos JSON (JavaScript Object Notation) y para otros archivos delimitados, como tab (\t),
podemos usar la Función read_csv() con el argumento sep igual al delimitador.
Sería negligente si no aprendiéramos también cómo guardar nuestro marco de datos en un archivo para
poder compartirlo con otros. Para escribir nuestro marco de datos en un archivo CSV, llamamos a su
método to_csv(). Tenemos que tener cuidado aquí; Si el índice de nuestro marco de datos son solo
números de fila, probablemente no queramos escribir eso en nuestro archivo (no tendrá significado para
los consumidores de los datos), pero es el valor predeterminado. Podemos escribir nuestros datos sin el
índice pasando index=False:
Al igual que con la lectura de archivos, los objetos Series y DataFrame tienen métodos para escribir
datos en archivos Excel (to_excel()) y JSON (to_json()). Tenga en cuenta que, si bien usamos funciones
de pandas para leer nuestros datos, debemos usar métodos para escribir nuestros datos; las funciones
de lectura crean los objetos pandas con los que queremos trabajar, pero los métodos de escritura son
acciones que realizamos utilizando el objeto pandas.
Consejo
Las rutas de archivo anteriores para leer y escribir eran relativas a nuestro
directorio actual. El directorio actual es desde donde ejecutamos nuestro código.
Una ruta absoluta será la ruta completa al archivo. Por ejemplo, si el archivo con
el que queremos trabajar tiene una ruta absoluta de /home/myuser/learning/
hands_on_pandas/data.csv y nuestro directorio actual es /home/myuser/learning/
hands_on_pandas, entonces simplemente podemos usar la ruta relativa de
data.csv como ruta del archivo.
Pandas nos proporciona capacidades para leer y escribir desde muchas otras fuentes de datos,
incluidas bases de datos, de las que hablaremos a continuación; archivos pickle (que contienen objetos
Python serializados; consulte la sección Lectura adicional para obtener más información); y páginas
HTML. Asegúrese de consultar el siguiente recurso en la documentación de pandas para obtener
la lista completa de capacidades: https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html.
De una base de datos
Pandas puede interactuar con bases de datos SQLite sin necesidad de que instalemos ningún paquete
adicional; sin embargo, es necesario instalar el paquete SQLAlchemy para poder interactuar con otros
tipos de bases de datos. La interacción con una base de datos SQLite se puede lograr abriendo
una conexión a la base de datos usando el módulo sqlite3 en la biblioteca estándar de Python y
luego usando la función pd.read_sql() para consultar la base de datos o el método to_sql() en un
objeto DataFrame para escríbalo en la base de datos.
Antes de leer de una base de datos, escribamos en una. Simplemente llamamos a to_sql() en
nuestro marco de datos, diciéndole en qué tabla escribir, qué conexión de base de datos usar y
cómo manejar si la tabla ya existe. Ya existe una base de datos SQLite en la carpeta de este
capítulo en el repositorio GitHub de este libro: data/quakes.db. Tenga en cuenta que, para crear
una nueva base de datos, podemos cambiar 'data/quakes.db' por la ruta del nuevo archivo de
base de datos. Escribamos los datos del tsunami del archivo data/tsunamis.csv en una tabla en la
base de datos llamada tsunamis, reemplazando la tabla si ya existe:
>>> importar sqlite3
>>> con sqlite3.connect('data/quakes.db') como conexión:

... pd.read_csv('datos/tsunamis.csv').to_sql(
... 'tsunamis', conexión, índice = Falso,
... if_exists='reemplazar'
... )
Consultar la base de datos es tan fácil como escribir en ella. Tenga en cuenta que esto requerirá
conocimientos de lenguaje de consulta estructurado (SQL). Si bien no es necesario para este libro,
usaremos algunas declaraciones SQL simples para ilustrar ciertos conceptos. Consulte la sección de
lecturas adicionales para obtener un recurso sobre cómo se compara Pandas con SQL y el Capítulo 4,
Agregación de marcos de datos de Pandas, para ver algunos ejemplos de cómo las acciones de Pandas
se relacionan con las declaraciones SQL.
Consultemos nuestra base de datos para obtener la tabla completa de tsunamis. Cuando escribimos
una consulta SQL, primero indicamos las columnas que queremos seleccionar, que en nuestro caso son
todas, por lo que escribimos "SELECT *". A continuación indicamos la tabla para seleccionar los datos,
que para nosotros son tsunamis, entonces agregamos "DE tsunamis". Esta es nuestra consulta
completa ahora (por supuesto, puede volverse mucho más complicada que esto). Para consultar
realmente la base de datos, usamos pd.read_sql(), pasando nuestra consulta y la conexión de la base
de datos:
>>> importar sqlite3
>>> con sqlite3.connect('data/quakes.db') como conexión:

... tsunamis = \
... pd.read_sql('SELECCIONAR * DE tsunamis', conexión)
>>> tsunamis.cabeza()
Ahora tenemos los datos de los tsunamis en un marco de datos:
Figura 2.10 – Lectura de datos de una base de datos
Nota IMPORTANTE
El objeto de conexión que creamos en ambos bloques de código es un ejemplo de un
administrador de contexto que, cuando se usa con la instrucción with, maneja
automáticamente la limpieza después de que se ejecuta el código en el bloque
(cerrando la conexión, en este caso). Esto facilita la limpieza y asegura que no
dejemos cabos sueltos. Asegúrese de consultar contextlib de la biblioteca estándar
para conocer las utilidades que utilizan la instrucción with y los administradores de
contexto. La documentación está en https://docs.python.org/3/library/contextlib.html.
Desde una API
Ahora podemos crear fácilmente objetos Series y DataFrame a partir de datos que tenemos en
Python o de archivos que obtenemos, pero ¿cómo podemos obtener datos de recursos en línea,
como las API? No hay garantía de que cada fuente de datos nos proporcione datos en el mismo
formato, por lo que debemos ser flexibles en nuestro enfoque y sentirnos cómodos examinando
la fuente de datos para encontrar el método de importación adecuado. En esta sección,
solicitaremos algunos datos de terremotos de la API del USGS y veremos cómo podemos crear
un marco de datos a partir del resultado. En el Capítulo 3, Gestión de datos con Pandas,
trabajaremos con otra API para recopilar datos meteorológicos.
Para esta sección, trabajaremos en el cuaderno 3-making_dataframes_from_api_requests.ipynb, por

lo que tenemos que importar los paquetes que necesitamos una vez más. Al igual que en el
cuaderno anterior, necesitamos pandas y datetime, pero también necesitamos el paquete de
solicitudes para realizar solicitudes de API:
A continuación, realizaremos una solicitud GET a la API de USGS para una carga útil JSON (una
respuesta similar a un diccionario que contiene los datos que se envían con una solicitud o
respuesta) especificando el formato de geojson. Solicitaremos datos de terremotos de los últimos 30
días (podemos usar dt.timedelta para realizar aritmética en objetos de fecha y hora). Tenga en
cuenta que utilizamos ayer como final de nuestro rango de fechas, ya que la API aún no tendrá
información completa para hoy:
Nota IMPORTANTE
GET es un método HTTP. Esta acción le dice al servidor que queremos leer
algunos datos. Diferentes API pueden requerir que utilicemos diferentes métodos
para obtener los datos; algunos requerirán una solicitud POST, donde nos
autenticamos con el servidor. Puede leer más sobre las solicitudes API y
los métodos HTTP en https://nordicapis.com/ultimate-guide-to-all-9-
standardhttp-methods/.
Antes de intentar crear un marco de datos a partir de esto, debemos asegurarnos de que nuestra
solicitud se haya realizado correctamente. Podemos hacer esto verificando el atributo status_code
del objeto de respuesta. Puede encontrar una lista de códigos de estado y sus significados
en https://en.wikipedia.org/wiki/List_of_HTTP_status_codes. Una respuesta 200 indicará que
todo está bien:
Nuestra solicitud fue exitosa, así que veamos cómo se ven los datos que obtuvimos. Le
solicitamos a la API una carga útil JSON, que es esencialmente un diccionario, por lo que
podemos usar métodos de diccionario para obtener más información sobre su estructura. Se trata
de una gran cantidad de datos; por lo tanto, no queremos imprimirlo en la pantalla solo para
inspeccionarlo. Necesitamos aislar la carga útil JSON de la respuesta HTTP (almacenada en la
variable de respuesta) y luego mirar las claves para ver las secciones principales de los datos
resultantes:
Podemos inspeccionar qué tipo de datos tenemos como valores para cada una de estas claves;
uno de ellos serán los datos que buscamos. La parte de metadatos nos brinda información sobre
nuestra solicitud. Si bien esto ciertamente puede ser útil, no es lo que buscamos en este
momento:
La clave de características parece prometedora; Si esto efectivamente contiene todos nuestros

datos, deberíamos verificar de qué tipo es para no terminar intentando imprimir todo en la
pantalla:
Esta clave contiene una lista, así que echemos un vistazo a la primera entrada para ver si estos
son los datos que queremos. Tenga en cuenta que los datos del USGS pueden modificarse o
agregarse para fechas pasadas a medida que sale a la luz más información sobre los terremotos,
lo que significa que consultar el mismo rango de fechas puede arrojar una cantidad diferente de
resultados más adelante. Por este motivo, el siguiente es un ejemplo de cómo se ve una entrada:
Estos son definitivamente los datos que buscamos, pero ¿los necesitamos todos? Tras una
inspección más cercana, realmente solo nos importa lo que hay dentro del diccionario de
propiedades. Ahora tenemos un problema porque tenemos una lista de diccionarios donde solo
queremos una clave específica dentro de ellos. ¿Cómo podemos extraer esta información para poder
crear nuestro marco de datos? Podemos usar una lista por comprensión para aislar la sección de
propiedades de cada uno de los diccionarios en la lista de características:
Finalmente, estamos listos para crear nuestro marco de datos. Pandas ya sabe cómo manejar datos
en este formato (una lista de diccionarios), por lo que todo lo que tenemos que hacer es pasar los
datos cuando llamamos a pd.DataFrame():
Ahora que sabemos cómo crear marcos de datos a partir de una variedad de fuentes, podemos
comenzar a aprender a trabajar con ellos.
Inspeccionar un objeto DataFrame

Lo primero que debemos hacer cuando leemos nuestros datos es inspeccionarlos; queremos
asegurarnos de que nuestro marco de datos no esté vacío y que las filas se vean como
esperábamos. Nuestro principal objetivo es verificar que se leyó correctamente y que todos los datos
están ahí; sin embargo, esta inspección inicial también nos dará ideas con respecto a hacia dónde
debemos dirigir nuestros esfuerzos de manipulación de datos. En esta sección, exploraremos formas
en las que podemos inspeccionar nuestros marcos de datos en el cuaderno 4-
inspecting_dataframes.ipynb.
Como se trata de un portátil nuevo, debemos volver a encargarnos de nuestra configuración. Esta
vez, necesitamos importar pandas y numpy, así como leer el archivo CSV con los datos del
terremoto:
Examinando los datos
Primero, queremos asegurarnos de que realmente tengamos datos en nuestro marco de datos.
Podemos comprobar el atributo vacío para averiguarlo:
Hasta ahora, todo bien; tenemos datos. A continuación, debemos comprobar cuántos datos
leemos; queremos saber el número de observaciones (filas) y el número de variables (columnas)
que tenemos. Para esta tarea, utilizamos el atributo de forma. Nuestros datos contienen 9.332
observaciones de 26 variables, lo que coincide con nuestra inspección inicial del archivo:
Ahora, usemos el atributo de columnas para ver los nombres de las columnas en nuestro
conjunto de datos:
Inspeccionar un objeto DataFrame 75
Nota IMPORTANTE
Tener una lista de columnas no significa necesariamente que sepamos lo que
significan todas ellas. Especialmente en los casos en los que nuestros datos
provienen de Internet, asegúrese de leer lo que significan las columnas antes de
sacar conclusiones. La información sobre los campos en el formato geojson, incluido
lo que significa cada campo en la carga útil JSON (junto con algunos valores
de ejemplo), se puede encontrar en el sitio web del USGS en
https://earthquake.usgs.gov/earthquakes/feed/v1. 0/geojson.php.
Conocemos las dimensiones de nuestros datos, pero ¿cómo son realmente? Para esta tarea,
podemos usar los métodos head() y tail() para mirar las filas superior e inferior, respectivamente. El
valor predeterminado será cinco filas, pero podemos cambiar esto pasando un número diferente al
método. Echemos un vistazo a las primeras filas:
>>> df.cabeza()
Las siguientes son las primeras cinco filas que obtenemos usando head():
Figura 2.11 – Examinando las cinco filas superiores de un marco de datos
Para obtener las dos últimas filas, usamos el método tail() y pasamos 2 como número de filas:
>>> df.tail(2)
El siguiente es el resultado:
Figura 2.12 – Examinando las dos filas inferiores de un marco de datos

Consejo
De forma predeterminada, cuando imprimimos marcos de datos con
muchas columnas en un Jupyter Notebook, solo se mostrará un subconjunto de
ellos. Esto se debe a que pandas tiene un límite en la cantidad de columnas
que mostrará. Podemos modificar este comportamiento
usando pd.set_option('display.max_columns', <new_value>). Consulte la
documentación en https://pandas.pydata.org/pandas-ocs/stable/user_guide/
options.html para obtener información adicional. El cuaderno también contiene
algunos comandos de ejemplo.
Podemos usar el atributo dtypes para ver los tipos de datos de las columnas, lo que facilita ver
cuando las columnas se almacenan como del tipo incorrecto. (Recuerde que las cadenas se
almacenarán como objetos). Aquí, la columna de tiempo se almacena como un número
entero, que es algo que aprenderemos a solucionar en el Capítulo 3, Gestión de datos con
Pandas:
Por último, podemos usar el método info() para ver cuántas entradas no nulas de cada columna
tenemos y obtener información sobre nuestro índice. Los valores nulos son valores faltantes
que, en pandas, normalmente se representarán como Ninguno para objetos y NaN (no es un
número) para valores no numéricos en una columna flotante o de enteros:
Después de esta inspección inicial, sabemos mucho sobre la estructura de nuestros datos y
ahora podemos comenzar a intentar darles sentido.
Describir y resumir los datos.
Hasta ahora, hemos examinado la estructura del objeto DataFrame que creamos a partir de los
datos del terremoto, pero no sabemos nada sobre los datos más que cómo se ven un par de filas.
El siguiente paso es calcular estadísticas resumidas, que nos ayudarán a conocer mejor nuestros
datos. Pandas proporciona varios métodos para hacerlo fácilmente; Uno de esos métodos es
describe(), que también funciona en objetos Series si solo estamos interesados en una columna
en particular. Obtengamos un resumen de las columnas numéricas de nuestros datos:
>>> df.describe()
Esto nos da el resumen de 5 números, junto con el recuento, la media y la desviación

estándar de las columnas numéricas:
Figura 2.13 – Cálculo de estadísticas resumidas
Consejo
Si queremos percentiles diferentes, podemos pasarlos con el argumento de los
percentiles. Por ejemplo, si quisiéramos solo los percentiles 5 y 95,
ejecutaríamos df.describe(percentiles=[0,05, 0,95]). Tenga en cuenta que aún
obtendremos el percentil 50 porque esa es la mediana.
De forma predeterminada, describe() no nos dará ninguna información sobre las columnas de tipo
objeto, pero podemos proporcionar include='all' como argumento o ejecutarlo por separado para
los datos de tipo np.object:
>>> df.describe(incluye=np.objeto)
Al describir datos no numéricos, aún obtenemos el recuento de ocurrencias no nulas (recuento);

sin embargo, en lugar de las otras estadísticas resumidas, obtenemos la cantidad de valores
únicos (unique), el modo (arriba) y el número de veces que se observó el modo (freq):
Figura 2.14 – Estadísticas resumidas para columnas categóricas

Nota IMPORTANTE
El método describe() solo nos brinda estadísticas resumidas para valores no

nulos. Esto significa que, si tuviéramos 100 filas y la mitad de nuestros datos
fueran nulos, entonces el promedio se calcularía como la suma de las 50 filas no
nulas dividida por 50.
Es fácil obtener una instantánea de nuestros datos usando el método describe(), pero a veces
solo queremos una estadística particular, ya sea para una columna específica o para todas
las columnas. Pandas también hace que esto sea muy fácil. La siguiente tabla incluye
métodos que funcionarán tanto para objetos Series como DataFrame:
Figura 2.15 – Métodos de cálculo útiles para series y marcos de datos

Consejo
Python facilita contar cuántas veces algo es Verdadero. Debajo del capó, True se
evalúa como 1 y False se evalúa como 0. Por lo tanto, podemos ejecutar el
método sum() en una serie de booleanos y obtener el recuento de resultados True.
Con los objetos Series , tenemos algunos métodos adicionales para describir nuestros datos:
• único(): Devuelve los valores distintos de la columna.
• value_counts(): Devuelve una tabla de frecuencia del número de veces que aparece cada
valor único en una columna determinada o, alternativamente, el porcentaje de veces que
aparece cada valor único cuando se pasa normalize=True.
• mode(): Devuelve el valor más común de la columna.
Consultar la documentación API del USGS para el campo de alerta (que se puede encontrar en
https://earthquake.usgs.gov/data/comcat/data-eventterms. php#alert) nos dice que puede
ser 'verde', 'amarillo' , 'naranja' o 'rojo' (cuando esté poblado), y que es el nivel de alerta de la
escala de impacto de terremotos de Evaluación Rápida de Terremotos Globales para
Respuesta (PAGER). Según el USGS (https://earthquake.usgs.gov/data/pager/), "el
sistema PAGER proporciona estimaciones de impacto de pérdidas económicas y
fatalidades después de terremotos importantes en todo el mundo". A partir de nuestra
inspección inicial de los datos, sabemos que la columna de alerta es una cadena de dos
valores únicos y que el valor más común es "verde", con muchos valores nulos. ¿Cuál es el
otro valor único?
Ahora que entendemos lo que significa este campo y los valores que tenemos en nuestros datos,
esperamos que haya mucho más "verde" que "rojo"; Podemos verificar nuestra intuición con una
tabla de frecuencia usando value_counts(). Observe que solo obtenemos recuentos de las
entradas no nulas:
Tomando subconjuntos de datos 81
Tenga en cuenta que los objetos Index también tienen varios métodos que pueden
ayudarnos a describir y resumir nuestros datos:
Figura 2.16 – Métodos útiles para el índice

Cuando usamos Unique() y value_counts(), obtuvimos una vista previa de cómo seleccionar
subconjuntos de nuestros datos. Ahora, entremos en más detalles y cubrimos la selección, el
corte, la indexación y el filtrado.
Tomando subconjuntos de datos.
Hasta ahora, hemos aprendido cómo trabajar y resumir los datos en su conjunto; sin embargo, a
menudo estaremos interesados en realizar operaciones y/o análisis en subconjuntos de nuestros
datos. Hay muchos tipos de subconjuntos que podemos intentar aislar de nuestros datos, como
seleccionar solo columnas o filas específicas en su conjunto o cuando se cumple un criterio
específico. Para obtener subconjuntos de datos, debemos estar familiarizados con la selección, el
corte, la indexación y el filtrado.
Para esta sección, trabajaremos en el cuaderno 5-subsetting_data.ipynb. Nuestra configuración

es la siguiente:
Seleccionar columnas
En la sección anterior, vimos un ejemplo de selección de columnas cuando miramos los valores
únicos en la columna de alerta; Accedimos a la columna como un atributo del marco de datos.
Recuerde que una columna es un objeto de Serie, entonces, por ejemplo, seleccionar la columna
mag en los datos del terremoto nos da las magnitudes de los terremotos como un objeto de Serie:
Pandas nos proporciona algunas formas de seleccionar columnas. Una alternativa al uso de
notación de atributos para seleccionar una columna es acceder a ella con una notación similar a
un diccionario:
Consejo
También podemos seleccionar columnas usando el método get(). Esto tiene la

ventaja de no generar un error si la columna no existe y nos permite proporcionar
un valor de respaldo; el valor predeterminado es Ninguno. Por ejemplo, si
llamamos a df.get('event', False), devolverá False ya que no tenemos una columna
de evento.
Tenga en cuenta que no estamos limitados a seleccionar una columna a la vez. Al pasar una lista a
la búsqueda en el diccionario, podemos seleccionar muchas columnas, lo que nos da un objeto
DataFrame que es un subconjunto de nuestro marco de datos original:
>>> df[['mag', 'título']]
Esto nos proporciona las columnas completas de revista y título del marco de datos original:
Figura 2.17 – Seleccionar múltiples columnas de un marco de datos
Los métodos de cadena son una forma muy poderosa de seleccionar columnas. Por ejemplo, si
quisiéramos seleccionar todas las columnas que comienzan con mag, junto con las columnas de
título y hora, haríamos lo siguiente:
Recibimos un marco de datos compuesto por las cuatro columnas que coincidieron con nuestros
criterios. Observe cómo las columnas se devolvieron en el orden que solicitamos, que no es el
orden en el que aparecieron originalmente. Esto significa que si queremos reordenar nuestras
columnas, todo lo que tenemos que hacer es seleccionarlas en el orden en que queremos que
aparezcan:
Figura 2.18 – Seleccionar columnas según los nombres
Analicemos este ejemplo. Usamos una lista de comprensión para revisar cada una de las
columnas en el marco de datos y conservar solo aquellas cuyos nombres comenzaban con mag:
Luego, agregamos este resultado a las otras dos columnas que queríamos conservar (título y hora):
Finalmente, pudimos usar esta lista para ejecutar la selección de columnas real en el marco de
datos, lo que resultó en el marco de datos de la Figura 2.18:
Consejo
Puede encontrar una lista completa de métodos de cadena en la documentación
de Python 3 en https://docs.python.org/3/library/stdtypes.html#string-
methods.
rebanar (Slicing)
Cuando queremos extraer ciertas filas (porciones) de nuestro marco de datos, utilizamos el corte.
La división de DataFrame funciona de manera similar a la división con otros objetos de Python,
como listas y tuplas, siendo el primer índice inclusivo y el último índice exclusivo:
>>> df[100:103]
Al especificar un segmento de 100:103, obtenemos las filas 100, 101 y 102:
Figura 2.19: Cortar un marco de datos para extraer filas específicas

Podemos combinar nuestras selecciones de filas y columnas usando lo que se conoce
como encadenamiento:
>>> df[['título', 'hora']][100:103]

Primero, seleccionamos las columnas de título y hora para todas las filas, y luego sacamos las
filas con índices 100, 101 y 102:
Figura 2.20 – Selección de filas y columnas específicas con encadenamiento

En el ejemplo anterior, seleccionamos las columnas y luego dividimos las filas, pero el orden no
importa:
Consejo
Tenga en cuenta que podemos dividir lo que esté en nuestro índice; sin embargo, sería
difícil determinar la cadena o fecha posterior a la última que queremos, por lo que con
pandas, dividir fechas y cadenas es diferente de dividir números enteros e incluye ambos
puntos finales. La división de fechas funcionará siempre que las cadenas que
proporcionamos se puedan analizar en un objeto de fecha y hora. En el Capítulo 3, Gestión
de datos con Pandas, veremos algunos ejemplos de esto y también aprenderemos cómo
cambiar lo que usamos como índice, haciendo posible este tipo de división.
Si decidimos utilizar el encadenamiento para actualizar los valores de nuestros datos,

encontraremos pandas quejándose de que no lo estamos haciendo correctamente (incluso si
funciona). Esto es para advertirnos que configurar datos con una selección secuencial puede
no darnos el resultado que anticipamos. (Puede encontrar más información en
https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-
copy).
Activemos esta advertencia para comprenderla mejor. Intentaremos actualizar las entradas en la
columna de título de algunos terremotos para que estén en minúsculas:
Como lo indica la advertencia, para ser un usuario eficaz de pandas, no basta con saber seleccionar
y dividir: también debemos dominar la indexación. Dado que esto es solo una advertencia, nuestros
valores se han actualizado, pero es posible que este no sea siempre el caso:
Ahora, analicemos cómo utilizar la indexación para establecer valores correctamente.
Indexación
Las operaciones de indexación de Pandas nos brindan un método único para seleccionar tanto las
filas como las columnas que queremos. Podemos usar loc[] e iloc[] para crear subconjuntos de
nuestro marco de datos mediante búsquedas basadas en etiquetas o en números enteros,
respectivamente. Una buena manera de recordar la diferencia es pensar en ellos como ubicación
versus ubicación entera. Para todos los métodos de indexación, proporcionamos primero el
indexador de filas y luego el indexador de columnas, con una coma separándolos:
df.loc[fila_indexador, columna_indexador]
Tenga en cuenta que al usar loc[], como se indica en el mensaje de advertencia, ya no activamos
ninguna advertencia de pandas para esta operación. También cambiamos el índice final de 113 a
112 porque loc[] incluye puntos finales:
Podemos seleccionar todas las filas (columnas) si usamos : como indexador de filas (columnas), al
igual que con el corte normal de Python. Tomemos todas las filas de la columna de título con loc[]:
Podemos seleccionar varias filas y columnas al mismo tiempo con loc[]:
>>> df.loc[10:15, ['título', 'revista']]
Esto nos deja con las filas 10 a 15 solo para las columnas de título y revista :
Figura 2.21 – Selección de filas y columnas específicas con indexación

Como hemos visto, cuando usamos loc[], nuestro índice final es inclusivo. Este no es el caso con
iloc[]:
>>> df.iloc[10:15, [19, 8]]
Observe cómo tuvimos que proporcionar una lista de números enteros para seleccionar las
mismas columnas; estos son los números de columna (comenzando desde 0). Usando iloc[],
perdimos la fila en el índice 15; esto se debe a que el corte de enteros que emplea iloc[] excluye el
índice final, como ocurre con la sintaxis de corte de Python:
Figura 2.22 – Selección de filas y columnas específicas por posición
Sin embargo, no estamos limitados a utilizar la sintaxis de división para las filas; Las columnas
también funcionan:
>>> df.iloc[10:15, 6:10]
Al utilizar el corte, podemos capturar fácilmente filas y columnas adyacentes:
Figura 2.23 – Selección de rangos de filas y columnas adyacentes por posición

Cuando se usa loc[], esta división también se puede realizar en los nombres de las columnas.
Esto nos brinda muchas formas de lograr el mismo resultado:
>>> df.iloc[10:15, 6:10].equals(df.loc[10:14, 'gap':'magType'])

True
Para buscar valores escalares, usamos at[] e iat[], que son más rápidos. Seleccionemos
la magnitud (la columna mag) del terremoto que se registró en la fila del índice 10:
>>> df.at[10, 'mag']

0,5
La columna de magnitud tiene un índice de columna de 8; por lo tanto, también

podemos buscar la magnitud con i at []:
>>> df.iat[10, 8]
0,5
Hasta ahora, hemos visto cómo obtener subconjuntos de nuestros datos usando nombres y
rangos de filas/columnas, pero ¿cómo tomamos solo los datos que cumplen con algunos
criterios? Para ello, necesitamos aprender a filtrar nuestros datos.
Filtración
Pandas nos brinda algunas opciones para filtrar nuestros datos, incluidas máscaras booleanas y
algunos métodos especiales. Con máscaras booleanas, probamos nuestros datos con algún valor
y obtenemos una estructura de la misma forma, excepto que está llena de valores Verdadero/
Falso; Los pandas pueden usar esto para seleccionar las filas/columnas apropiadas para
nosotros. Hay infinitas posibilidades para crear máscaras booleanas; todo lo que necesitamos es
algún código que devuelva un valor booleano para cada fila. Por ejemplo, podemos ver qué
entradas en la columna mag tuvieron una magnitud mayor que dos:
>>> df.mag > 2

0 FALSO
1 FALSO
2 Verdadero
3 FALSO
...
9328 FALSO
9329 Verdadero
9330 FALSO
9331 FALSO
Nombre: mag, Longitud: 9332, tipo d: bool
Si bien podemos ejecutar esto en todo el marco de datos, no sería muy útil con nuestros
datos de terremotos, ya que tenemos columnas de varios tipos de datos. Sin embargo,
podemos usar esta estrategia para obtener el subconjunto de datos donde la magnitud del
terremoto fue mayor o igual a 7,0:
>>> df[df.mag>= 7.0]
Nuestro marco de datos resultante tiene solo dos filas:
Figura 2.24 – Filtrado con máscaras booleanas
Sin embargo, recuperamos muchas columnas que no necesitábamos. Podríamos haber

encadenado una selección de columnas al final del último fragmento de código; sin
embargo, loc[] también puede manejar máscaras booleanas:
>>> df.loc[
... df.mag >= 7.0, ['alerta',
... 'mag', 'magType', 'título', 'tsunami', 'tipo']
... ]
El siguiente marco de datos se ha filtrado para que solo contenga columnas relevantes:
Figura 2.25 – Indexación con máscaras booleanas
Tampoco estamos limitados a un solo criterio. Agarremos los terremotos con alerta roja y
tsunami. Para combinar máscaras, debemos rodear cada una de nuestras condiciones entre
paréntesis y usar el operador AND bit a bit (&) para exigir que ambas sean verdaderas:
...
...
... ]
Solo hubo un terremoto en los datos que cumplió con nuestros criterios:
Figura 2.26 – Combinación de filtros con AND
Si, en cambio, queremos que al menos una de nuestras condiciones sea verdadera, podemos
usar el operador OR bit a bit (|):
>>> df.loc[
... (df.tsunami == 1) | (df.alert == 'rojo'), ['alerta', 'mag',
... 'magType', 'título', 'tsunami', 'tipo']
... ]
Observe que este filtro es mucho menos restrictivo ya que, si bien ambas condiciones pueden
ser verdaderas, solo requerimos que una de ellas sea:
Figura 2.27 – Combinación de filtros con OR

Nota IMPORTANTE
Al crear máscaras booleanas, debemos utilizar operadores bit a bit (&, |, ~) en
lugar de operadores lógicos (y, o, no). Una buena forma de recordar esto es que
queremos un booleano para cada elemento de la serie que estamos probando en
lugar de un solo booleano. Por ejemplo, con los datos del terremoto, si queremos
seleccionar las filas donde la magnitud es mayor que 1,5, entonces queremos un
valor booleano para cada fila, que indique si se debe seleccionar la fila. En los
casos en los que queramos un valor único para los datos, tal vez para resumirlos,
podemos usar any() / all() para condensar una serie booleana en un único valor
booleano que se puede usar con operadores lógicos. Trabajaremos con los
métodos any() y all() en el Capítulo 4, Agregación de marcos de datos de Pandas.
En los dos ejemplos anteriores, nuestras condiciones implicaban igualdad; sin embargo, de
ninguna manera estamos limitados a esto. Seleccionemos todos los terremotos en Alaska donde
tenemos un valor no nulo para la columna de alerta:
>>> df.loc[
... (df.place.str.contains('Alaska')) & (df.alert.notnull()),
... ['alert', 'mag', 'magType', 'title',
... 'tsunami', 'type']
Todos los terremotos en Alaska que tienen valor de alerta son verdes, y algunos estuvieron
acompañados de tsunamis, siendo la magnitud más alta de 5,1:
Figura 2.28 – Creación de máscaras booleanas con columnas no numéricas

Analicemos cómo llegamos a esto. Los objetos de la serie tienen algunos métodos de cadena a
los que se puede acceder mediante el atributo str. Usando esto, podemos crear una máscara
booleana de todas las filas donde la columna de lugar contenía la palabra Alaska:
df.place.str.contains('Alaska')
Para obtener todas las filas donde la columna de alerta no era nula, utilizamos el método notnull()
del objeto Serie (esto también funciona para objetos DataFrame) para crear una máscara
booleana de todas las filas donde la columna de alerta no era nula:
df.alert.notnull()
Consejo
Podemos usar el operador de negación bit a bit (~), también llamado NOT, para
negar todos los valores booleanos, lo que hace que todos los valores verdaderos
sean falsos y viceversa. Entonces, df.alert.notnull() y ~df.alert.isnull() son
equivalentes.
Luego, como hicimos anteriormente, combinamos las dos condiciones con el operador & para
completar nuestra máscara:
(df.place.str.contains('Alaska')) & (df.alert.notnull())
Tenga en cuenta que no estamos limitados a comprobar si cada fila contiene texto; También
podemos usar expresiones regulares. Las expresiones regulares (a menudo llamadas expresiones
regulares, para abreviar) son muy poderosas porque nos permiten definir un patrón de búsqueda
en lugar del contenido exacto que queremos encontrar. Esto significa que podemos hacer cosas
como encontrar todas las palabras o dígitos en una cadena sin tener que saber de antemano
cuáles son todas las palabras o dígitos (o revisar un carácter a la vez). Para hacerlo, simplemente
pasamos una cadena precedida por un carácter r fuera de las comillas; esto le permite a Python
saber que es una cadena sin formato, lo que significa que podemos incluir caracteres de barra
invertida (\) en la cadena sin que Python piense que estamos tratando de escapar del carácter que
le sigue inmediatamente (como cuando usamos \n para indicar una nueva línea). carácter en lugar
de la letra n). Esto lo hace perfecto para usar con expresiones regulares. El módulo re en la
biblioteca estándar de Python (https://docs.python.org/3/library/re.html) maneja operaciones de
expresiones regulares; sin embargo, pandas nos permite usar expresiones regulares directamente.
Agarrando subconjuntos de datos 95
Usando una expresión regular, seleccionemos todos los terremotos en California que tengan
magnitudes de al menos 3,8. Necesitamos seleccionar entradas en la columna de lugar que
terminen en CA o California porque los datos no son consistentes (veremos cómo solucionar este
problema en la siguiente sección). El carácter $ significa fin y 'CA$' nos da entradas que terminan
en CA, por lo que podemos usar 'CA|California$' para obtener entradas que terminan en:
>>> df.loc[
...
...
...
... ]
Solo hubo dos terremotos en California con magnitudes superiores a 3,8 durante el
período que estamos estudiando:
Figura 2.29 – Filtrado con expresiones regulares
Consejo
Las expresiones regulares son extremadamente poderosas, pero
desafortunadamente también difíciles de hacer bien. A menudo resulta útil tomar
algunas líneas de muestra para analizarlas y utilizar un sitio web para probarlas.
Tenga en cuenta que las expresiones regulares vienen en muchos tipos, así que
asegúrese de seleccionar Python. Este sitio web admite expresiones regulares de
tipo Python y también proporciona una bonita hoja de referencia al costado:
https://regex101.com/.
¿Qué pasa si queremos obtener todos los terremotos con magnitudes entre 6,5 y 7,5?
Podríamos usar dos máscaras booleanas (una para verificar magnitudes mayores o iguales
a 6,5 y otra para verificar magnitudes menores o iguales a 7,5) y luego combinarlas con el
operador &. Afortunadamente, pandas hace que este tipo de máscara sea mucho más fácil
de crear proporcionándonos el método Between():
...
...
... ]
El resultado contiene todos los terremotos con magnitudes en el rango [6.5, 7.5]; incluye ambos
extremos de forma predeterminada, pero podemos pasar inclusive=False para cambiar esto:
Figura 2.30 – Filtrado utilizando un rango de valores

Podemos usar el método isin() para crear una máscara booleana para valores que coincidan con
uno de una lista de valores. Esto significa que no tenemos que escribir una máscara para cada
uno de los valores que podamos hacer coincidir y luego usar | unirse a ellos. Utilicemos esto para
filtrar la columna magType, que indica la técnica de medición que se utilizó para cuantificar la
magnitud del terremoto. Echaremos un vistazo a los terremotos medidos con el tipo de magnitud
mw o mwb:
...
...
Tenemos dos terremotos que fueron medidos con el tipo de magnitud mwb y cuatro que fueron
medidos con el tipo de magnitud mw :
Figura 2.31 – Filtrado usando membresía en una lista

Hasta ahora, hemos estado filtrando valores específicos, pero supongamos que queremos ver
todos los datos de los terremotos de menor y mayor magnitud. En lugar de encontrar primero el
mínimo y el máximo de la columna mag y luego crear una máscara booleana, podemos pedirle
a pandas que nos proporcione el índice donde ocurren estos valores y filtrar fácilmente para
capturar las filas completas. Podemos usar idxmin() e idxmax() para los índices mínimo y
máximo, respectivamente. Tomemos los números de fila de los terremotos de menor y mayor
magnitud:
Podemos usar estos índices para capturar las filas mismas:
...
...
... ]
El terremoto de mínima magnitud ocurrió en Alaska y el de mayor magnitud ocurrió en

Indonesia, acompañado de un tsunami. Discutiremos el terremoto en Indonesia en el
Capítulo 5, Visualización de datos con Pandas y Matplotlib, y en el Capítulo 6, Trazado
con Seaborn y técnicas de personalización:
Figura 2.32 – Filtrado para aislar las filas que contienen el mínimo y el máximo de una columna
Nota IMPORTANTE
Tenga en cuenta que el método filter() no filtra los datos según sus valores, como
hicimos en esta sección; más bien, se puede utilizar para subconjuntos de filas o
columnas según sus nombres. En el cuaderno se pueden encontrar ejemplos con
objetos DataFrame y Series.
Agregar y eliminar datos
En las secciones anteriores, frecuentemente seleccionamos un subconjunto de las columnas,

pero si las columnas/filas no nos son útiles, simplemente deberíamos deshacernos de ellas.
También seleccionamos frecuentemente datos basados en el valor de la columna mag; sin
embargo, si hubiéramos creado una nueva columna que contuviera los valores booleanos para
una selección posterior, solo habríamos necesitado calcular la máscara una vez. Muy raramente
obtendremos datos en los que no queramos agregar ni eliminar algo.
Antes de comenzar a agregar y eliminar datos, es importante comprender que, si bien la mayoría
de los métodos devolverán un nuevo objeto DataFrame, algunos estarán vigentes y cambiarán
nuestros datos. Si escribimos una función en la que pasamos un marco de datos y lo cambiamos,
también cambiará nuestro marco de datos original. Si nos encontramos en una situación en la que
no queremos cambiar los datos originales, sino que queremos devolver una nueva copia de los
datos que han sido modificados, debemos asegurarnos de copiar nuestro marco de datos antes
de realizar cualquier cambio:
df_to_modify = df.copy()
Nota IMPORTANTE
De forma predeterminada, df.copy() realiza una copia profunda del marco de datos,
lo que nos permite realizar cambios en la copia o en el original sin repercusiones.
Si pasamos deep=False, podemos obtener una copia superficial; los cambios en la
copia superficial afectan al original y viceversa. Casi siempre querremos la copia
profunda, ya que podemos cambiarla sin afectar al original. Puede encontrar más
información en la documentación en https://pandas.pydata.org/pandas-docs/stable/
reference/api/pandas.DataFrame.copy.html.
Ahora, pasemos al cuaderno final, 6-adding_and_removing_data.ipynb, y preparémonos para

el resto de este capítulo. Una vez más trabajaremos con los datos del terremoto, pero esta vez
solo leeremos en un subconjunto de las columnas:
...
...
...
...
... ]
... )
Agregar y eliminar datos 99
Creando nuevos datos
La creación de nuevas columnas se puede lograr de la misma manera que la asignación de

variables. Por ejemplo, podemos crear una columna para indicar la fuente de nuestros datos;
Dado que todos nuestros datos provienen de la misma fuente, podemos aprovechar la transmisión
para establecer cada fila de esta columna con el mismo valor:
La nueva columna se crea a la derecha de las columnas originales, con un valor de API de
USGS. para cada fila:
Figura 2.33 – Agregar una nueva columna
Nota IMPORTANTE
No podemos crear la columna con notación de atributos (df.source) porque el

marco de datos aún no tiene ese atributo, por lo que debemos usar notación de
diccionario (df['source']).
No estamos limitados a transmitir un valor a toda la columna; podemos hacer que la columna
contenga el resultado de la lógica booleana o una ecuación matemática. Por ejemplo, si
tuviéramos datos de distancia y tiempo, podríamos crear una columna de velocidad que sea el
resultado de dividir la columna de distancia por la columna de tiempo. Con nuestros datos del
terremoto, creemos una columna que nos diga si la magnitud del terremoto fue negativa:
100 Trabajando con Pandas DataFrames
Tenga en cuenta que la nueva columna se ha agregado a la derecha:
En la sección anterior, vimos que la columna de lugar tiene algunos problemas de coherencia de
datos: tenemos varios nombres para la misma entidad. En algunos casos, los terremotos que
ocurren en California se marcan como CA y como California en otros. No hace falta decir que esto
es confuso y puede causarnos problemas fácilmente si no inspeccionamos cuidadosamente
nuestros datos de antemano. Por ejemplo, con solo seleccionar CA, nos perdemos 124
terremotos marcados como California. Este tampoco es el único lugar con un problema (Nevada y
NV también están presentes). Al usar una expresión regular para extraer todo lo que está en la
columna de lugar después de la coma, podemos ver algunos de los problemas de primera mano:
Si queremos tratar a los países y a todo lo cercano a ellos como una sola entidad, tenemos
trabajo adicional por hacer (ver Ecuador y la región de Ecuador). Además, nuestro ingenuo
intento de analizar la ubicación mirando la información después de la coma parece haber
fallado; esto se debe a que, en algunos casos, no tenemos coma. Tendremos que cambiar
nuestro enfoque de análisis.
Este es un problema de reconocimiento de entidades y su solución no es trivial. Con una lista

relativamente pequeña de valores únicos (que podemos ver con df.place.unique()), podemos
simplemente mirar e inferir cómo hacer coincidir correctamente estos nombres. Luego, podemos
usar el método reemplazar() para reemplazar patrones en la columna de lugar como mejor nos
parezca:
Ahora podemos comprobar los lugares analizados que nos quedan. Tenga en cuenta que podría
decirse que todavía hay más cosas que arreglar aquí con las Islas Georgias del Sur y Sandwich
del Sur y las Islas Sandwich del Sur. Podríamos solucionar esto con otra llamada a replace(); sin
embargo, esto demuestra que el reconocimiento de entidades puede ser todo un desafío:
Nota IMPORTANTE
En la práctica, el reconocimiento de entidades puede ser un problema

extremadamente difícil, en el que podemos recurrir a algoritmos de procesamiento
del lenguaje natural (PLN) para ayudarnos. Si bien esto está más allá del alcance
de este libro, se puede encontrar más información en https://
www.kdnuggets.com/2018/12/introduction-named-entity-recognition.html.
Pandas también nos proporciona una manera de crear muchas columnas nuevas a la vez en
una llamada a un método. Con el método asignar(), los argumentos son los nombres de las
columnas que queremos crear (o sobrescribir) y los valores son los datos de las columnas.
Creemos dos nuevas columnas; uno nos dirá si el terremoto ocurrió en California y el otro nos
dirá si ocurrió en Alaska. En lugar de mostrar simplemente las primeras cinco entradas (todas
en California), usaremos sample() para seleccionar cinco filas al azar:
...
...
Tenga en cuenta que asignar() no cambia nuestro marco de datos original; en su lugar, devuelve
un nuevo objeto DataFrame con estas columnas agregadas. Si queremos reemplazar nuestro
marco de datos original con esto, simplemente usamos la asignación de variables para almacenar
el resultado de asignar() en df (por ejemplo, df = df.assign(...)):
Figura 2.35 – Creación de varias columnas nuevas a la vez

El método asignar() también acepta funciones lambda (funciones anónimas generalmente

definidas en una línea y para un solo uso); asignar() pasará el marco de datos a la función
lambda como x, y podremos trabajar desde allí. Esto nos permite usar las columnas que estamos
creando en asignar() para calcular otras. Por ejemplo, creemos una vez más las columnas in_ca
e in_alaska, pero esta vez también creemos una nueva columna, ninguna de las dos, que es
Verdadera si tanto in_ca como in_alaska son Falso:
Recuerde que ~ es el operador de negación bit a bit, por lo que esto nos permite crear una
columna con el resultado de NOT in_ca AND NOT in_alaska por fila:
Figura 2.36 – Creación de varias columnas nuevas a la vez con funciones lambda
Consejo
Cuando se trabaja con pandas, es fundamental sentirse cómodo con las funciones
lambda, ya que se pueden usar con gran parte de la funcionalidad disponible y
mejorarán drásticamente la calidad y legibilidad del código. A lo largo de este
libro, veremos varios lugares donde se pueden utilizar las funciones lambda.
Ahora que hemos visto cómo agregar nuevas columnas, veamos cómo agregar nuevas filas.
Digamos que estábamos trabajando con dos marcos de datos separados; uno con terremotos
acompañados de tsunamis y el otro con terremotos sin tsunamis:
Si quisiéramos ver los terremotos en su conjunto, querríamos concatenar los marcos de datos en
uno solo. Para agregar filas al final de nuestro marco de datos, podemos usar pd.concat() o el
método append() del propio marco de datos. La función concat() nos permite especificar el eje en
el que se realizará la operación: 0 para agregar filas en la parte inferior del marco de datos y 1
para agregar a la derecha de la última columna con respecto al objeto pandas más a la izquierda
en el lista de concatenación. Usemos pd.concat() con el eje predeterminado de 0 para las filas:
Tenga en cuenta que el resultado anterior es equivalente a ejecutar el método append() en el

marco de datos. Esto todavía devuelve un nuevo objeto DataFrame, pero nos evita tener que
recordar qué eje es cuál, ya que append() es en realidad un contenedor alrededor de la función
concat():
Hasta ahora, hemos estado trabajando con un subconjunto de columnas del archivo CSV, pero
supongamos que ahora queremos trabajar con algunas de las columnas que ignoramos cuando
leímos los datos. Como hemos agregado nuevas columnas en este cuaderno, no querremos leer
el archivo y realizar esas operaciones nuevamente. En su lugar, concatenaremos a lo largo de las
columnas (eje=1) para volver a agregar lo que nos falta:
Dado que los índices de los marcos de datos se alinean, las columnas adicionales se colocan a la
derecha de nuestras columnas originales:
Figura 2.37 – Concatenación de columnas con índices coincidentes
La función concat() utiliza el índice para determinar cómo concatenar los valores. Si no se alinean,
se generarán filas adicionales porque los pandas no sabrán cómo alinearlas. Digamos que
olvidamos que nuestro marco de datos original tenía los números de fila como índice, y leemos las
columnas adicionales configurando la columna de tiempo como índice:
..
..
.
A pesar de las columnas adicionales que contienen datos para las dos primeras filas, pandas crea
una nueva fila para ellas porque el índice no coincide. En el Capítulo 3, Gestión de datos con
Pandas, veremos cómo restablecer el índice y configurarlo, los cuales podrían resolver este
problema:
Figura 2.38 – Concatenación de columnas con índices que no coinciden
Nota IMPORTANTE
En el Capítulo 4, Agregar marcos de datos de Pandas, analizaremos la fusión, que

también solucionará algunos de estos problemas cuando aumentemos las
columnas en el marco de datos. A menudo, usaremos concat() o append() para
agregar filas, pero merge() o join() para agregar columnas.
Digamos que queremos concatenar los marcos de datos tsunami y no_tsunami, pero el marco de
datos no_tsunami tiene una columna adicional (supongamos que le agregamos una nueva
columna llamada tipo). El parámetro de unión especifica cómo manejar cualquier superposición en
los nombres de las columnas (cuando se agregan en la parte inferior) o en los nombres de las
filas (cuando se concatenan a la derecha). Por defecto, esto es externo, por lo que conservamos
todo; sin embargo, si usamos internal, sólo conservaremos lo que tienen en común:
Observe que la columna de tipo del marco de datos no_tsunami no aparece porque no estaba
presente en el marco de datos del tsunami. Sin embargo, eche un vistazo al índice; estos fueron
los números de fila del marco de datos original antes de que lo dividiéramos en tsunami y
no_tsunami:
Figura 2.39 – Agregar filas y mantener solo columnas compartidas
Si el índice no es significativo, también podemos pasar ignore_index para obtener valores

secuenciales en el índice:
El índice ahora es secuencial y los números de fila ya no coinciden con el marco de datos original:
Figura 2.40 – Agregar filas y restablecer el índice

Asegúrese de consultar la documentación de pandas para obtener más información sobre la
función concat() y otras operaciones para combinar datos, que discutiremos en el Capítulo 4,
Agregación de marcos de datos de Pandas: http://pandas.pydata.org/pandas-docs/stable /
user_guide/merging.html#concatenar-objetos.
Eliminar datos no deseados
Después de agregar esos datos a nuestro marco de datos, podemos ver la necesidad de eliminar
datos no deseados. Necesitamos una forma de deshacer nuestros errores y deshacernos de los
datos que no vamos a utilizar. Al igual que agregar datos, podemos usar la sintaxis del diccionario
para eliminar columnas no deseadas, tal como lo haríamos al eliminar claves de un diccionario.
Tanto del df['<column_name>'] como df.pop('<column_name>') funcionarán, siempre que exista
efectivamente una columna con ese nombre; de lo contrario, obtendremos un KeyError. La
diferencia aquí es que mientras del lo elimina de inmediato, pop() devolverá la columna que
estamos eliminando. Recuerde que ambas operaciones cambiarán nuestro marco de datos
original, así que úselas con cuidado.
Usemos la notación de diccionario para eliminar la columna de origen. Observe que ya no aparece
en el resultado de df.columns:
Tenga en cuenta que si no estamos seguros de si la columna existe, debemos poner nuestro
código de eliminación de columna en un bloque try...except::
Anteriormente, creamos la columna mag_negative para filtrar nuestro marco de datos; sin
embargo, ya no queremos esta columna como parte de nuestro marco de datos. Podemos usar
pop() para tomar la serie para la columna mag_negative, que podemos usar como máscara
booleana más adelante sin tenerla en nuestro marco de datos:
Ahora tenemos una máscara booleana en la variable mag_negative que solía ser una columna.
en df:
Dado que usamos pop() para eliminar la serie mag_negative en lugar de eliminarla, aún
podemos usarlo para filtrar nuestro marco de datos:
Esto nos deja con los terremotos que tuvieron magnitudes negativas. Como también
llamamos a head(), obtenemos los primeros cinco terremotos de este tipo:
Figura 2.41 – Uso de una columna emergente como máscara booleana

Los objetos DataFrame tienen un método drop() para eliminar varias filas o columnas, ya sea en
el lugar (sobrescribiendo el marco de datos original sin tener que reasignarlo) o devolver un nuevo
objeto DataFrame. Para eliminar filas, pasamos la lista de índices. Eliminemos las dos primeras
filas:
Observe que el índice comienza en 2 porque eliminamos 0 y 1:
Figura 2.42 – Eliminación de filas específicas

De forma predeterminada, drop() supone que queremos eliminar filas (eje=0). Si queremos
eliminar columnas, podemos pasar eje = 1 o especificar nuestra lista de nombres de columnas
usando el argumento columnas. Eliminemos algunas columnas más:
...
...
...
...
Esto elimina todas las columnas que no están en la lista que queríamos conservar:
Figura 2.43 – Eliminación de columnas específicas

Ya sea que decidamos pasar axis=1 a drop() o usar el argumento columnas, nuestro resultado
será equivalente:
...
... )
De forma predeterminada, drop() devolverá un nuevo objeto DataFrame; sin embargo, si

realmente queremos eliminar los datos de nuestro marco de datos original, podemos pasar
inplace=True, lo que nos evitará tener que reasignar el resultado nuevamente a nuestro marco
de datos. El resultado es el mismo que en la Figura 2.43:
Tenga siempre cuidado con las operaciones in situ. En algunos casos, es posible deshacerlos; sin
embargo, en otros, puede ser necesario empezar desde el principio y recrear el marco de datos.
Resumen
En este capítulo, aprendimos cómo usar pandas para la parte de recopilación de datos del análisis
de datos y a describir nuestros datos con estadísticas, lo que será útil cuando lleguemos a la fase
de sacar conclusiones. Aprendimos las principales estructuras de datos de la biblioteca de pandas,
junto con algunas de las operaciones que podemos realizar sobre ellas. A continuación,
aprendimos cómo crear objetos DataFrame a partir de una variedad de fuentes, incluidos archivos
planos y solicitudes API. Utilizando datos de terremotos, discutimos cómo resumir nuestros datos y
calcular estadísticas a partir de ellos. Posteriormente, abordamos cómo tomar subconjuntos de
datos mediante selección, división, indexación y filtrado. Finalmente, practicamos cómo agregar y
eliminar columnas y filas de nuestro marco de datos.
Estas tareas también forman la columna vertebral de nuestro flujo de trabajo de Pandas y la base
de los nuevos temas que cubriremos en los próximos capítulos sobre manipulación, agregación y
visualización de datos. Asegúrese de completar los ejercicios proporcionados en la siguiente
sección antes de continuar.
Ejercicios 111
Ejercicios
Utilizando el archivo data/parsed.csv y el material de este capítulo, complete los siguientes
ejercicios para practicar sus habilidades con los pandas:
1. Encuentre el percentil 95 de la magnitud del terremoto en Japón usando el tipo de magnitud

mb.
2. Calcula el porcentaje de terremotos en Indonesia que estuvieron acompañados de tsunamis.
3. Calcule estadísticas resumidas de terremotos en Nevada.
4. Agregue una columna que indique si el terremoto ocurrió en un país o estado de EE. UU.
que se encuentra en el Anillo de Fuego. Utilice Alaska, Antártida (busque Antártida), Bolivia,
California, Canadá, Chile, Costa Rica, Ecuador, Fiji, Guatemala, Indonesia, Japón, Islas
Kermadec, México (tenga cuidado de no seleccionar Nuevo México), Nueva Zelanda, Perú,
Filipinas, Rusia, Taiwán, Tonga y Washington.
5. Calcula el número de terremotos en las ubicaciones del Anillo de Fuego y el número fuera de
ellos.
6. Calcula el recuento de tsunamis a lo largo del Anillo de Fuego.
Otras lecturas
Aquellos con experiencia en R y/o SQL pueden encontrar útil ver cómo se compara la sintaxis de
pandas:
• Comparison with R / R Libraries: https://pandas.pydata.org/pandasdocs/stable/

getting_started/comparison/comparison_with_r.html
• Comparison with SQL: https://pandas.pydata.org/pandas-docs/stable/

comparison_with_sql.html
• SQL Queries: https://pandas.pydata.org/pandas-docs/stable/getting_started/comparison/

comparison_with_sql.html
A continuación se muestran algunos recursos sobre cómo trabajar con datos serializados:
• Pickle in Python: Object Serialization: https://www.datacamp.com/community/tutorials/

pickle-python-tutorial
• Read RData/RDS files into pandas.DataFrame objects (pyreader): https://github.com/

ofajardo/pyreadr
Los recursos adicionales para trabajar con API son los siguientes:
• Documentation for the requests package: https://requests.readthedocs.io/en/

master/
• HTTP Methods: https://restfulapi.net/http-methods/
• HTTP Status Codes: https://restfulapi.net/http-status-codes/
Para obtener más información sobre las expresiones regulares, consulte los siguientes recursos:
• Mastering Python Regular Expressions by Félix López, Víctor Romero: https://

www.packtpub.com/application-development/mastering-pythonregular-expressions
• Regular Expression Tutorial — Learn How to Use Regular Expressions: https://

www.regular-expressions.info/tutorial.html

Sección 1 - Getting Started With Panda

Cargado por

Copyright:

Formatos disponibles

Sección 1 - Getting Started With Panda

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Sección 1 - Getting Started With Panda

Cargado por

Copyright:

Formatos disponibles

Machine Translated by Google

para quien es este libro

• Tiene experiencia previa en ciencia de datos en otro idioma, como R, SAS o

• Tienes algo de experiencia en Python y buscas aprender sobre ciencia de datos.

Qué cubre este libro

El Capítulo 3, Gestión de datos con Pandas, analiza el proceso de manipulación de datos, le

El Capítulo 4, Agregación de Pandas DataFrames, le enseña cómo consultar y fusionar

El Capítulo 9, Introducción al aprendizaje automático en Python, le presenta el aprendizaje automático y la construcción de

Para aprovechar al máximo este libro

El código adjunto a este libro se puede encontrar en GitHub en https://github.

Descarga las imágenes en color

Los resultados se mostrarán sin nada antes de las líneas:

>>> pd.Series(np.random.rand(2), nombre='aleatorio')

Nombre: aleatorio, tipo d: float64

Cualquier entrada o salida de la línea de comandos se escribe de la siguiente manera:

C:\ruta\de\su\elección> mkdir pandas_exercises

# Linux, Mac y taquigrafía:

Piratería: si encuentra copias ilegales de nuestros trabajos en cualquier forma en Internet, le

Para obtener más información sobre Packt, visite packt.com.

Esta sección comprende los siguientes capítulos:

• Capítulo 1, Introducción al análisis de datos

• Capítulo 2, Trabajar con Pandas DataFrames

4 Introducción al análisis de datos

Los siguientes temas se cubrirán en este capítulo:

• Los fundamentos del análisis de datos.

• Configurar un entorno virtual

Materiales del capítulo

• Descargue el archivo ZIP y extraiga los archivos localmente.

• Clonar el repositorio sin bifurcarlo.

• Bifurcar el repositorio y luego clonarlo.

Materiales del capítulo 5

6 Introducción al análisis de datos

Los fundamentos del análisis de datos.

Figura 1.2 – El flujo de trabajo del análisis de datos

Los fundamentos del análisis de datos 7

8 Introducción al análisis de datos

• Configuraciones erróneas en el proceso de registro de datos: datos provenientes de fuentes como

Los fundamentos del análisis de datos 9

Análisis exploratorio de datos

Las visualizaciones de datos son muy poderosas; desafortunadamente, a menudo pueden

• Los datos deben prepararse antes de la EDA.

• Las visualizaciones que se crean durante la EDA pueden indicar la necesidad de

10 Introducción al análisis de datos

• ¿Notamos algún patrón o relación al visualizar los datos?

Las estadísticas muestrales se utilizan como estimadores de los parámetros poblacionales, lo

"Hay tres tipos de mentiras: mentiras, malditas mentiras y estadísticas".

12 Introducción al análisis de datos

Medidas de tendencia central

Usamos xi para representar la iésima observación de la variable X. Observe cómo la variable en su

14 Introducción al análisis de datos

Figura 1.3 – Visualizando el modo con datos continuos

16 Introducción al análisis de datos

La desviación estándar es simplemente la raíz cuadrada de la varianza. Al realizar esta

Tenga en cuenta que la desviación estándar de la población se representa como σ y la

Usaremos esta métrica en el Capítulo 7, Análisis financiero: Bitcoin y el mercado de valores;

Coeficiente de dispersión cuartil

Veremos esta métrica nuevamente en el Capítulo 7, Análisis financiero: Bitcoin y el

Figura 1.5 – El resumen de 5 números

Figura 1.6 – Diagrama de caja de Tukey