Los datos están presentes en todas las áreas del mundo digital moderno, y toma diferente formas.

Uno de los formatos más comunes es PDF. Facturas, reportes y otras formas frecuentemente almacenados en archivo Formato de Documento Portátil (PDF) por organizaciones e instituciones.

Puede ser laborioso y lleva mucho tiempo extraer datos archivos PDF. Afortunadamente, para fácil extracción de datos de archivos PDF, Python brinda una variedad de librerías.

Este tutorial explicará como extraer datos de archivos PDF usando Python. Aprenderás a instalar las librerías necesarias y te proporcionaré ejemplos de como hacerlo.

Hay muchas librerías de Python que puedes usar para leer y extraer texto de archivos PDF. Estos incluyen PDFMiner, PyPDF2, PDFQuery y PyMuPDF. Aquí, usaremos PDFQuery para leer y extraer datos de múltiples archivos PDF.

Cómo usar PDFQuery

PDFQuery es una biblioteca de Python que proporciona una manera fácil de extraer datos de archivos PDF mediante el uso de selectores similares a CSS para ubicar elementos en el documento.

Lee un archivo PDF como un objeto, convierte el objeto PDF a un archivo XML, y accede a la información deseada por su ubicación especifica dentro del documento PDF.

Consideremos un ejemplo corto para ver como funciona.

from pdfquery import PDFQuery

pdf = PDFQuery('example.pdf')
pdf.load()

# Use CSS-like selectors to locate the elements
text_elements = pdf.pq('LTTextLineHorizontal')

# Extract the text from the elements
text = [t.text for t in text_elements]

print(text)

En este código, primero creamos un objeto PDFQuery pasando el nombre del archivo del documento PDF al cual queremos extraer el texto. Luego cargamos el documento en el objeto llamando al método load().

A continuación, utilizamos selectores similares a CSS para localizar los elementos de texto en el documento PDF. El método pq() es usado para localizar los elementos, el cual regresa un objeto PyQuery que representa los elementos seleccionados.

Por último, extraemos el texto de los elementos accediendo al atributo text de cada elemento y almacenamos el texto extraído en una lista llamada texto.

Consideremos otro método que podemos usar para leer archivos PDF, extraer algunos elementos de los datos y crear un set de datos estructurados usando PDFQuery. Seguiremos los siguientes pasos:

• Instalación del paquete.
• Importar las librerías.
• Leer y convertir archivos PDF.
• Acceder y extraer los datos.

Instalación del Paquete

Primero, necesitamos instalar PDFQuery y también Pandas para un poco de análisis y presentación de datos.

pip install pdfquery
pip install pandas

Importar las librerías

import pandas as pd
import pdfquery

Importamos dos librerías para poder usarlas en nuestro proyecto.

Leer y convertir los archivos PDF

#read the PDF
pdf = pdfquery.PDFQuery('customers.pdf')
pdf.load()


#convert the pdf to XML
pdf.tree.write('customers.xml', pretty_print = True)
pdf

Leeremos el archivo PDF en nuestro proyecto como un objeto de elemento y lo cargamos. Convertir el objeto pdf en un archivo de Lenguage de Marcado Extensible (XML). Este archivo contiene los datos y los metadatos del archivo PDF anteriormente brindado.

El XML define un grupo de reglas para codificar archivos PDF en un formato que es leíble por humanos y máquinas. Mirando al archivo XML usando un editor de texto, podemos ver dónde están los datos que queremos extraer.

Acceder y extraer los Datos

Podemos obtener la información que estamos tratando de extraer dentro de LTTextBoxHorizontal, y podemos ver la metadata asociada con el archivo.

Los valores adentro de la caja de texto, [68.0, 231.57, 101.990, 234.893] en el fragmento de XML hace referencia a las coordenadas Izquierda, Fondo, Derecha, Arriba de la caja de texto. Puedes pensar  en esto como los límites alrededor de los datos que queremos extraer.

Accedamos y extraigamos el nombre del cliente usando las coordenadas de la caja de texto:

# access the data using coordinates
customer_name = pdf.pq('LTTextLineHorizontal:in_bbox("68.0, 231.57, 101.990, 234.893")').text()

print(customer_name)

#output: Brandon James

Y eso es todo, ¡hemos terminado!

Nota: a veces el dato que queremos extraer no está exactamente en la misma ubicación en cada archivo, podemos causar problemas. Afortunadamente, PDFQuery también puede consultar etiquetas que contengan una cadena determinada.

Conclusión

La extracción de datos de archivos PDF es una tarea crucial porque estos archivos se utilizan con frecuencia para el almacenamiento y el uso compartido de documentos.

La librería PDFQuery de Python es una herramienta potente para extraer datos de archivos PDF. Cualquier persona buscando extraer datos de archivos PDF encontrará PDFQuery  una gran opción gracias a su fácil sintaxis y documentación comprensible. Es también código abierto y puede ser modificado para adaptarse a casos de uso específicos.

Conectémonos en Twitter y en LinkedIn. También puedes suscribirte a mí canal de YouTube.

¡Feliz codificación!

¡Hola y bienvenidos al mundo del Análisis de Datos! Si estás pensando en una carrera dentro de este campo, estás en buenas manos. El Análisis de Datos es un campo emocionante y en constante crecimiento, que últimamente está cobrando importancia en nuestro mundo actual impulsado por datos.

Seamos sinceros,  actualmente nos estamos ahogando en información. Desde publicaciones de redes sociales a transacciones financieras, pasando hasta por historias clínicas, no hay nada que nos permita hacer un filtro.

Aquí es donde aparecen los analistas de datos. Ellos son quienes nos ayudan a entender los datos y convertirlos en conocimiento valioso.

Y ese conocimiento puede ser innovador. Puede ayudar a las empresas a mejorar sus productos y servicios, a los Estados a tomar decisiones informadas sobre políticas, y a las personas a hacer mejores elecciones para su vida personal y profesional.

Pero no es solamente sobre el impacto. El Análisis de Datos también puede ser bastante lucrativo. De acuerdo con estudios recientes, el sueldo promedio en E.E.U.U es de alrededor de USD 70.000 al año. Y puede ser aún mayor de acuerdo si tenemos en cuenta la experiencia de la persona.

Por supuesto, como cualquier profesión, el Análisis de Datos tiene sus desafíos. Existe ese conjunto de datos que nos produce dolor de cabeza, la amenaza siempre latente del síndrome del impostor, y los debates infinitos sobre cuál es el mejor lenguaje de programación o herramienta de visualización de datos. Pero, si te gustan los desafíos, este podría ser campo para tí.

Entonces, si estás tratando de convertirte en un analista de datos, este artículo es para tí. Con suerte, te ahorrará mucho tiempo y esfuerzo para que no desperdicies tu tiempo en aprender cosas irrelevantes como me pasó a mí.

Paso 1: Investiga el rol de Analista de Datos

¿Estás pensando en convertirte en analista de datos? ¡Fantástico! Empecemos por comprender de qué se trata el rol antes de continuar.

Verás, el trabajo de un analista es mucho más que hacer cuentas y crear cuadros (aunque eso también puede ser bastante interesante). El trabajo implica aprovechar la información para encontrar ideas y resolver problemas. Esto significa hacer las preguntas correctas, organizar y evaluar la información y explicar tus conclusiones a otros.

Algunas de las habilidades básicas y actividades que un analista de datos realiza incluyen:

• Recolectar y analizar grandes grupos de datos para identificar patrones, tendencias, o cualquier otro conocimiento que pueda ayudar a tomar decisiones de negocios informadas.
• Usar herramientas y técnicas de estadística para obtener conocimiento de los datos.
• Desarrollar e implementar de sistemas de recolección de datos y otras estrategias para optimizar la eficiencia y la calidad de los datos.
• Colaborar con otros equipos para identificar necesidades de negocios y desarrollar soluciones usando datos para resolverlas.
• Comunicar las conclusiones a las partes interesadas, de una manera clara y accionable.

Así que si no eres un prodigio de la matemática o un genio de la computación, no te preocupes. La estadística, la informática y los negocios son sólo algunas de las numerosas disciplinas que se incorporan al tema multidisciplinar del análisis de datos. A quien le guste aprender, resolver problemas y hacer una diferencia puede disfrutar de esta disciplina.

Entonces, ¿dónde puedes encontrar información adicional sobre lo que hace un analista de datos? Puede empezar por consultar los numerosos recursos gratuitos disponibles en internet.

Muchos blogs, podcasts y canales de YouTube ofrecen contenido informativo y entretenido sobre el análisis de datos. Voy a dejar abajo algunos canales de YouTube que me han ayudado a lo largo de los años.

Para obtener una idea de las habilidades y cualidades que requiere el rol, puedes conectar con otros analistas de datos, ir a reuniones o seminarios, y hasta mirar descripciones del puesto.

No te olvides de tener cuenta si trabajar con datos es algo que disfrutas. ¿Te gusta encontrar patrones y resolver acertijos? ¿Quieres hacer del mundo un lugar mejor? Si la respuesta es sí, entonces el análisis de datos puede ser tu carrera ideal.

El primer paso en tu camino es entender lo que hace un analista de datos. Disfruta el camino, tomate tu tiempo y no dudes preguntar.

Paso 2: Explora los requisitos para el rol de Analista de Datos

Ahora que ya sabes de qué se trata el rol de analista de datos, es momento de empezar a mirar qué es lo que buscan los empleadores. Al fin y al cabo, querrás asegurarte de que tus habilidades y conocimientos son lo que se necesita en el mercado laboral.

Pero antes de que empieces a asustarte por no tener demasiada experiencia, tienes que saber que cada empresa es distinta. Algunas priorizan las habilidades de programación, mientras que otras valoran la comunicación y la perspicacia empresarial. Por eso es importante que hagas tu propia investigación para saber qué habilidades y conocimientos específicos están en demanda dentro de tu industria o empresa soñada.

¿Cómo puedes encontrar esta información? Por ejemplo, un buen lugar es mirar ofertas de empleo y descripciones de puesto en sitios como LinkedIn, Indeed, o Glassdoor. Esto puede ayudarte a darte una idea de los requisitos y conocimientos para distintos roles de analista de datos.

Algunos ejemplos de lo que una oferta laboral puede incluir son:

• Conocimiento en SQL y experiencia  trabajando con grandes conjunto de datos.
• Experiencia en Python y herramientas de visualización de datos como Tableau o Power BI.
• Fuertes habilidades analíticas y capacidad de sacar conclusiones a partir de datos complejos.
• Experiencia en análisis estadístico y técnicas de modelado de datos.
• Excelente habilidad para comunicar conclusiones complejas a audiencias técnicas y no técnicas.

¡Pero no te detengas ahí! También puedes contactar a personas que estén trabajando en el sector o que tengan puestos que te interesen. Pregúntales sobre su experiencia y qué habilidades, ellos consideran que son las más importantes para ser exitoso en su rol. Quizás hasta quieras tener alguna entrevista para informarte más sobre la industria u obtener consejos sobre cómo empezar.

Y hablando de empezar, es importante recordar que no hay ningún sustituto para la experiencia práctica. Si bien es tentador pasar horas mirando tutoriales, aprenderás mucho más rápido y de forma efectiva creando cosas y trabajando con proyectos de análisis de datos reales.

Por eso, tomate tu tiempo para analizar los requisitos de un puesto, pero no te olvides de seguir perfeccionando tus habilidades y obtener experiencia práctica. Con poco esfuerzo, pero mucha curiosidad, estarás en camino de convertirte un analista de datos exitoso.

Paso 3: Sentirse cómodo con las matemáticas y las estadísticas

Ok, sé lo que estás pensando ¿Matemática y Estadística? ¡Oh, no!

Pero escúchame antes de que te vayas corriendo. Para que un analista de datos pueda entender los datos y obtener conclusiones valiosas de ellos, es esencial que tenga un conocimiento básico de estos conceptos.

¿Qué conceptos básicos y fórmulas estadísticas debes saber?

Para empezar, hay medidas de tendencia central conocidas como media, mediana y moda, que pueden darte una idea del valor típico en un conjunto de datos. Debes saber cómo calcularlas.

La desviación típica es una medida que se utiliza para saber cuánto difiere la distribución de los datos de la media, y debes saber cómo calcularla.

Para poder encontrar relaciones entre variables y generar predicciones basadas en esas asociaciones, también debes estar familiarizado con correlación y regresión.

Pero no es solamente saber sobre números. También debes tener un conocimiento básico de álgebra lineal, ya que se utiliza en distintas formas de análisis de datos. Aquí tiene un curso para estudiar a fondo y su libro de texto ,en inglés, para que puedas empezar.

Quizás necesites matrices para modificar y manipular datos o quizás necesites usar regresión lineal (en inglés) para predecir valores futuros basados en tendencias históricas.

Si no tienes un conocimiento sólido en Matemática, esto puede parecer difícil. ¡Pero no te preocupes! Hay muchos recursos disponibles para ayudarte a aprender.

Por ejemplo, la Academia Khan ofrece lecciones y ejercicios de práctica de Matemática y Estadística. Si prefieres libros, "Ciencia de Datos para principiantes" ("Data Science for Beginners", en inglés) de Andrew Park es un recurso excelente que explica principios matemáticos y estadísticos de manera accesible.

freeCodeCamp está desarrollando un programa de Matemática sobre el cual puedes leer aquí ,en inglés.

Y aquí tienes una guía ,en inglés, sobre los conocimientos de Estadística que necesitas saber para entrar al campo de la ciencia de datos y desarrollarte en disciplinas como Machine Learning.

La clave es empezar de a poco y gradualmente ir ampliando tus conocimientos. No tengas miedo de hacer preguntas o de buscar ayuda cuando lo necesites. Con un poco de práctica y perseverancia, descubrirás que la Matemática y la Estadística son realmente divertidas (¡de en serio!).

Paso 4:  Domina Excel para analizar datos

Excel es una herramienta esencial dentro del arsenal de un analista de datos. Es prácticamente usado por todas las empresas que existen y dominarlo te ayudará a limpiar, manipular y analizar datos fácilmente.

Con Excel puedes crear fórmulas y funciones que hagan cálculos, tablas dinámicas y cuadros para visualizar datos, y usar herramientas de análisis de datos para hacer predicciones e identificar patrones. Excel es bastante útil para hacer análisis de regresión, predicciones y análisis de escenarios.

Si realmente quieres convertirte en un analista de datos, es esencial que domines Excel. Por suerte, hay muchos recursos disponibles en línea, en inglés, para que aprendas: ExcelIsFun, Excel Chandoo, Tutorials Point, Ashutosh Kumar , y MyOnlineTrainingHub en YouTube.

También estos cursos, en inglés, te ayudarán a sacarle provecho a Excel.

1. Introducción al Análisis de Datos usando Excel , por Coursera
2. Análisis de Datos con Python para usuarios de Excel, en el canal de YouTube de freeCodeCamp
3. Desarrollo de habilidades en Excel para especialización en negocios ,por Coursera
4. Analizando y mostrando datos con Excel por EdX

Recuerda, Excel es solo una herramienta dentro de tu caja de herramientas para el análisis de datos. Pero es la más importante y la cual usaras diariamente como analista de datos. Al dominar Excel, estarás más que preparado para realizar cualquier tarea relacionada con datos que llegue a tus manos.

Pasemos a la siguiente habilidad, que también es la más importante que necesitarás como analista de datos.

Paso 5: Domina SQL para extracción de datos

SQL (por sus siglas en inglés Structured Query Language) es una herramienta importante en el análisis de datos. Como analista de datos, una de tus principales tareas será la de extraer datos de bases de datos y SQL es el lenguaje que se utiliza para hacerlo.

SQL es más que hacer queries básicas como SELECT, FROM y WHERE.
Es un lenguaje complejo que te permite manipular y transformar datos en numerosas maneras. SQL se usa para juntar datos de varias tables, filtrado y agregado de información, además de para crear nuevas tablas y visualizaciones.

Para ser un analista de datos eficaz, es esencial que domines SQL. Debes poder escribir queries, crear tablas y entender cómo optimizar el desempeño de tus queries.

Por suerte, hay muchos recursos disponibles para que aprendas SQL. Algunos de los mejores recursos para empezar son Khan Academy SQL, W3Schools, SQLZoo, SQLbolt, Luke Barousse, Alex the Analyst, Microsoft Power Tools y juegos basados en SQL como SQL Island (en alemán, pero está traducido al inglés) y SQL Murder (en inglés)

Además, hay muchos cursos en línea, en inglés, y libros disponibles para que puedas aprender SQL en detalle. Aquí tienes algunos para que empieces:

1. Aprende SQL y Bases de Datos- Curso completo para principiantes
2. Plan de Estudios sobre Base de Datos Relacionales de freeCodeCamp
3. Colección de cursos gratuitos sobre base de datos relacionales

Al dominar SQL, podrás obtener conocimientos valiosos de bases de datos y manipular datos de manera que ofrezcan valiosos conocimientos de negocio.

Paso 6: Aprende Python para Análisis de Datos

Es sabido que hay mucha especulación sobre si es necesario que un analista de datos necesita Python -algunos dicen que si mientras otros dicen que no.

En mi opinión, me gustaría decir que depende de la empresa en la que trabajes - pero saber Python es una ventaja ya que es uno de los lenguajes de programación más usado en el mundo de la ciencia de datos. Python es conocido por su simplicidad, facilidad para leerse y versatilidad, convirtiéndolo en una elección popular entre los analistas de datos.

Python tiene una gran cantidad de librerías y herramientas que hacen que el Análisis de Datos sea más fácil, como Panda para manipulación de datos y análisis, NumPy para trabajar con arrays, y Matplotlib para visualización de datos. También permite la automatización de tareas, lo que hace al análisis de datos más eficiente y eficaz.Aprender Python para Análisis de Datos es una gran inversión para tu carrera como analista de datos. No solo te permitirá trabajar con librerías poderosas, sino que también te abrirá muchas más oportunidades para trabajar con grandes conjuntos de datos y análisis más complejos.

Hay muchos recursos disponibles para que aprendas Python, desde cursos gratuitos hasta programas en línea pagos y libros. Algunos recursos disponibles en inglés son freeCodeCamp, DataCamp, CodeBasis, Programming with Mosh and Microsoft Learn.

Al aprender Python, podrás realizar análisis de datos más complejos, automatizar tareas y trabajar con un mayor rango de conjuntos de datos, convirtiéndote en un recurso valioso dentro de cualquier empresa orientada a datos.

Paso 7: Domina una herramienta de visualización de datos

Como analista de datos, es esencial que puedas comunicar tus conclusiones de manera clara y concisa. Una forma de hacer esto es a través de la visualización de datos. Herramientas de visualización de datos como PowerBI y Tableau pueden ayudarte a crear cuadros interactivos, gráficos y tableros de control para que otros entiendan tus conclusiones de manera fácil. Hablaremos sobre ellas dentro de un momento.

Aquí tienes un curso, en inglés, de Tableau para análisis de datos y visualización de datos para darle un vistazo.

Mientras que SQL es bueno para peticionar y manipular datos, no sirve para mostrar completamente tus datos. Y aquí es donde una herramienta de visualización de datos entra en juego. Estas herramientas permiten transformar tus datos en visualizaciones valiosas y fácil de entender que puedes compartir con aquellos interesados.

Puedes aprender lo básico de la visualización de datos en detalle con este curso gratuito y en inglés, disponible en el canal de YouTube de freeCodeCamp.

PowerBI es una gran elección para visualización de datos ya que es fácil de aprender e integrar con otros productos de Microsoft. Esto la convierte en una herramienta ideal para aquellas empresas que usan Microsoft Office. Tableau también es otra elección popular que tiene una gran comunidad de usuarios y con un gran abanico de opciones.

Aprender un herramienta de visualización de datos como PowerBI o Tableau te permitirá crear visualizaciones atrapantes que te ayudarán a entender mejor tus datos y comunicar las conclusiones a otros. Hay muchos cursos en línea y tutoriales disponibles que te ayudarán a aprender estas herramientas, como el curso de capacitación oficial de Microsoft PowerBI y los cursos de capacitación de Tableau

Al dominar una herramienta de visualización de datos, podrás aprender a crear visualizaciones atrapante e interactivas que te permitan entender mejor tus datos y comunicar las conclusiones a otros, convirtiéndote en un recurso valioso para cualquier empresa orientada a datos.

También puedes sumergirte en aprender otras herramientas de visualización de datos como D3.js- Aquí tienes un curso para empezar, en inglés.

Paso 8: Conecta con otros Analistas de Datos y Desarrolladores.

Relacionarse con otros es una parte esencial de cualquier profesión y el campo del Análisis de Datos no es la excepción. Al conectar con otros analistas de datos y desarrolladores, podrás aprender de sus experiencias, obtener información clave sobre las últimas tecnologías y tendencias dentro de la industria y hasta quizás encontrar oportunidades de trabajo.

Aquí tienes distintas formas de conectar con otros dentro de este campo:

1. Asiste a eventos de la industria: Busca conferencias, encuentros y cualquier otro evento relacionado con el análisis de datos y asiste a ellos. Es una gran forma de conocer a otras personas dentro del campo y aprender sobre nuevos avances y tecnologías.

2. Únete a comunidades online: Existen muchas comunidades online para analista de datos y desarrolladores como foros, grupos de LinkedIn y en redes sociales. Únete a ellos y participa en las conversaciones para conectar con otros profesionales.

3. Habla con otros profesionales: No temas contactar a otros analistas de datos y desarrolladores a través de sus redes sociales, correo electrónico o en persona si los ves en algún evento. Preséntate, pide consejos y construye amistades.

Recuerda que al conectar con otros, tú también debes estar abierto a ofrecer ayuda o dar consejos. Al crear una red de contactos fuerte dentro del campo del Análisis de Datos, puedes potenciar tus oportunidades laborales, además de estar al día con las últimas tecnologías y tendencias dentro de la industria.

Paso 9: No te olvides de las "habilidades blandas"

Una habilidad final que creo que debes trabajar antes de convertirte en un gran analista de datos son tus habilidades blandas. Esto incluye tus habilidades para comunicarte, resolver problemas, etc.

Una vez que lo hagas, haz proyectos y no dejes de practicar.

Conclusión.

Convertirte en un analista de datos, requiere dedicación, trabajo duro y ser apasionado por el Análisis de Datos. Si sigues los pasos que fui detallando en esta guía, conseguirás el conocimiento y las habilidades necesarias para convertirte en un analista de datos exitoso.

Desde entender el rol de analista de datos, hasta dominar SQL y Python, pasando por conectar con otros desarrolladores, cada paso es esencial para alcanzar el éxito en este campo.

Recuerda ser curioso, no dejar de aprender y siempre ser flexible para adaptarse a nuevas tecnologías y metodologías. Con determinación y persistencia, podrás convertirte en un analista de datos competente y desbloquear un mundo de excitantes oportunidades laborales.

Excel es una herramienta sorprendentemente común para el análisis de datos.

Los analistas de datos pueden modificar, examinar y mostrar grandes cantidades de datos con facilidad utilizando Excel, lo que facilita la obtención de perspectivas y la toma de decisiones acertadas.

La versatilidad de Excel permite a los usuarios llevar a cabo una variedad de actividades de análisis de datos, desde operaciones matemáticas sencillas hasta análisis estadísticos complejos. Además, Excel ofrece automatización mediante el uso de programas de terceros como Python o el lenguaje de programación integrado VBA.

Excel se utiliza con frecuencia para el análisis de datos en una variedad de industrias, incluyendo la banca, la atención médica y el marketing, gracias a su versatilidad y facilidad de uso.

Pero como analista de datos, es posible que te encuentres repitiendo tareas mundanas a diario cuando trabajas con Excel.

Estas tareas pueden incluir copiar y pegar datos, dar formato a celdas y crear gráficos, entre otras. Con el tiempo, esto puede volverse monótono y consumir mucho tiempo, dejándote con menos tiempo para concentrarte en aspectos más importantes del análisis de datos, como identificar tendencias, valores atípicos y perspectivas.

Por eso, automatizar Excel utilizando Python puede cambiar el juego, ayudándote a optimizar tus flujos de trabajo y liberar tiempo para un análisis más significativo.

En este tutorial, te mostraré algunas formas útiles de crear, actualizar y analizar hojas de cálculo de Excel utilizando programación en Python. ¡Vamos a sumergirnos!

¿Cómo fusionar dos hojas de cálculo separadas con Python?

Los analistas de datos a menudo tienen que trabajar con muchas hojas de cálculo, lo que puede volverse agobiante cuando tienes que fusionar esos archivos juntos.

El código a continuación te ayuda a fusionar dos archivos separados juntos.

import pandas as pd

# Read in the two Excel files

file1 = pd.read_excel('file1.xlsx')file2 = pd.read_excel('file2.xlsx')

# Merge the two files using the concat() method
merged_file = pd.concat([file1, file2], ignore_index=True)

# Write the merged file to a new Excel file
merged_file.to_excel('merged_file.xlsx', index=False)

En este código, primero importamos la biblioteca Pandas, que utilizaremos para leer y manipular los archivos de Excel.

Primero usamos el método read_excel() para leer tanto en file1.xlsx como en file2.xlsx.

Luego, empleamos el método concat() para unir los dos archivos juntos. El argumentoignore_index=True garantiza que los valores de índice de ambos archivos se reinicien, de modo que no terminemos con valores de índice duplicados en el archivo fusionado.

Finalmente recurrimos al método to_excel() para escribir el archivo fusionado en un nuevo archivo de Excel llamado merged_file.xlsx. También establecemos index=False para asegurarnos de que la columna de índice no se incluya en el archivo de salida.

Cómo Importar y Exportar Datos con Python

Esta tarea implica el uso de bibliotecas de Python como Pandas para leer archivos de Excel en un objeto DataFrame. Luego puedes manipularlo y analizarlo utilizando Python.

También puedes exportar datos desde Python de vuelta a un archivo de Excel utilizando las mismas bibliotecas.

import pandas as pd
# Import Excel file

df = pd.read_excel('filename.xlsx', sheet_name='Sheet1')

# Export to Excel file
df.to_excel('new_filename.xlsx', index=False)

El código dado importa la biblioteca Pandas y lee un archivo de Excel llamado "filename.xlsx" desde la Hoja1 del libro de trabajo, almacenando los datos en un marco de datos de Pandas llamado "df". Luego, el marco de datos se exporta a un nuevo archivo de Excel llamado "new_filename.xlsx" utilizando el método "to_excel". El parámetro "index=False" se utiliza para excluir la indexación de filas en el archivo de salida.

Esencialmente, el código copia el contenido del archivo de Excel original a un nuevo archivo utilizando Pandas.

Cómo Limpiar y Transformar Datos usando Python

Esta tarea implica el uso de bibliotecas de Python como Pandas para limpiar y transformar datos en Excel.

Esto puede incluir la eliminación de duplicados, filtrado de datos según criterios específicos y realización de cálculos sobre los datos.

import pandas as pd

# Remove duplicates
df = df.drop_duplicates()

# Filter data
df = df[df['column_name'] > 10]

# Perform calculations
df['new_column'] = df['column1'] + df['column2']

El fragmento de código anterior realiza tareas de limpieza y manipulación de datos en un marco de datos de Pandas llamado 'df' utilizando la biblioteca Pandas.

En primer lugar, elimina filas duplicadas de 'df' utilizando el método "drop_duplicates". En segundo lugar, filtra el marco de datos 'df' seleccionando las filas donde el valor en la columna 'column_name' es mayor que 10 y asigna el resultado filtrado a un nuevo marco de datos llamado 'data_df'.

Por último, se añade una nueva columna llamada 'new_column' a 'df' que contiene la suma de los valores de 'column1' y 'column2'.

En general, el código limpia y manipula eficazmente los datos eliminando duplicados, filtrando filas específicas y añadiendo una nueva columna calculada al marco de datos original.

Cómo Realizar Análisis de Datos con Python

Este proceso implica utilizar bibliotecas de Python como Pandas y NumPy para llevar a cabo análisis de datos en datos de Excel.

Esto podría abarcar desde calcular estadísticas resumidas, como la media y la desviación estándar, hasta crear informes personalizados mediante la agrupación de datos según criterios específicos.

import pandas as pd
import numpy as np

# Calculate summary statistics
df.describe()
# Create custom reports
df.pivot_table(values='column_name', index='category_name', columns='date')

El código utiliza las bibliotecas Pandas y NumPy y realiza tareas de análisis de datos e informes en un marco de datos de Pandas llamado "df".

En primer lugar, calcula estadísticas resumidas para los datos numéricos en el marco de datos utilizando el método "describe". Este método genera información valiosa sobre la distribución, tendencia central y dispersión de los datos.

En segundo lugar, el código utiliza el método "pivot_table" para crear informes personalizados a partir del marco de datos. Este método resume y agrega los datos en el dataframe y puede producir tablas en varios formatos.

En este código, genera un nuevo marco de datos donde los valores de 'column_name' están agrupados por las columnas 'category_name' y 'date'.

En resumen, el código realiza tareas de análisis estadístico e informes en el marco de datos para obtener información de los datos.

Cómo Crear Gráficos con Python

Esta tarea implica utilizar bibliotecas de Python como matplotlib o seaborn para crear gráficos y diagramas a partir de datos de Excel.

Puedes personalizar estos gráficos para mostrar datos específicos y darles formato para cumplir con requisitos particulares.

import pandas as pd
import matplotlib.pyplot as plt
# Create a bar chart
df.plot(kind='bar', x='category_name', y='sales')
plt.show()
# Create a scatter plot
df.plot(kind='scatter', x='column1', y='column2')plt.show()

El código importa dos bibliotecas, Pandas y matplotlib.pyplot, utilizando los alias 'pd' y 'plt', respectivamente.

Luego, se utiliza el método "plot" de Pandas para crear dos tipos de gráficos. El primer tipo de gráfico es un gráfico de barras que muestra la relación entre las columnas 'category_name' y 'sales' en el dataframe "df".

El segundo tipo de gráfico es un gráfico de dispersión que muestra la relación entre las columnas 'column1' y 'column2' en el mismo marco de datos. El código utiliza los parámetros "kind='bar'" para el gráfico de barras y "kind='scatter'" para el gráfico de dispersión para crear los respectivos gráficos.

Por último, se llama al método "show" para mostrar los gráficos en la pantalla. En resumen, el código utiliza Pandas y matplotlib para crear un gráfico de barras y un gráfico de dispersión para visualizar los datos en el marco de datos "df".

Cómo Realizar Visualización de Datos en Python

Esta tarea implica utilizar bibliotecas de Python como Plotly y Bokeh para crear visualizaciones de datos interactivas a partir de datos de Excel.

Estas visualizaciones permiten a los usuarios explorar los datos de nuevas formas, como mediante el zoom en puntos de datos específicos o el filtrado de datos según criterios específicos.

import pandas as pd
import plotly.express as px
# Create a heatmap
fig = px.imshow(df.corr())
fig.show()
# Create a line chart
fig = px.line(df, x='date', y='sales', color='category')
fig.show()

El código utiliza las bibliotecas Pandas y plotly.express para crear dos tipos de visualizaciones. Primero, se crea un gráfico de mapa de calor utilizando el método "imshow" de plotly.express que visualiza la correlación entre las columnas en el marco de datos "df".

En segundo lugar, se crea un gráfico de líneas utilizando el método "line" de plotly.express que muestra la relación entre las columnas 'date' y 'sales' mientras diferencia entre las categorías basadas en la columna 'category' del dataframe. Ambos gráficos se muestran utilizando el método "show".

Cómo Automatizar la Generación de Informes con Python

Esta tarea implica utilizar scripts de Python para automatizar el proceso de generación de informes a partir de datos de Excel.

Puedes configurar estos scripts para que se ejecuten según un horario regular, como diario o semanal. También pueden actualizarse automáticamente a medida que haya nuevos datos disponibles.

import pandas as pd
# Create daily report
df_daily = df[df['date'] == '2022-01-01']
df_daily.to_excel('daily_report.xlsx', index=False)
# Create weekly report
df_weekly = df.groupby('category').sum()
df_weekly.to_excel('weekly_report.xlsx', index=False)

El código crea un informe diario mediante la creación de un nuevo marco de datos "df_daily" que incluye solo las filas donde la columna 'date' es igual a '2022-01-01'. Esto se logra utilizando la función de indexación booleana de Pandas.

Posteriormente, se utiliza el método "to_excel" para exportar los datos filtrados a un archivo de Excel llamado "daily_report.xlsx", sin incluir la columna de índice.

A continuación, el código crea un informe semanal agrupando el marco de datos "df" por la columna 'category' y sumando los valores de todas las demás columnas. Esto se logra utilizando los métodos "groupby" y "sum" de Pandas.

El resultado se guarda en un nuevo marco de datos llamado "df_weekly". Por último, se utiliza el método "to_excel" para exportar los datos agregados a un archivo de Excel llamado "weekly_report.xlsx", sin incluir la columna de índice.

En resumen, el código crea dos informes utilizando la biblioteca Pandas. El primer informe es un informe diario que incluye solo datos de una fecha específica, y el segundo informe es un informe semanal que agrupa los datos por categoría. Ambos informes se exportan a archivos de Excel utilizando el método "to_excel".

Cómo Automatizar Tareas Repetitivas con Macros y Scripts en Python

Esta tarea implica utilizar Python para automatizar tareas repetitivas en Excel, como la entrada de datos o el formato.

Puedes hacer esto creando macros o scripts que se ejecuten automáticamente, o utilizando Python para interactuar directamente con la aplicación de Excel.

import win32com.client as win32
# Open Excel file
excel = win32.gencache.EnsureDispatch('Excel.Application')
workbook = excel.Workbooks.Open(r'filename.xlsx')
# Run macro
excel.Application.Run('macro_name')
# Save and close Excel
 fileworkbook.Save()workbook.Close()excel.Quit()

El código utiliza el módulo win32com.client para interactuar con Microsoft Excel a través de la API de Windows.

Primero, se abre una instancia de la aplicación Excel utilizando el método EnsureDispatch(), y el archivo de Excel especificado se abre utilizando el método Workbooks.Open().

A continuación, se ejecuta una macro utilizando el método Application.Run(), pasando el nombre de la macro como argumento.

Finalmente, los cambios realizados en el archivo de Excel se guardan utilizando el método Save(), el libro de trabajo se cierra utilizando el método Close(), y la aplicación de Excel se termina utilizando el método Quit().

Cómo Extraer Datos con Python

Esta tarea implica utilizar bibliotecas de Python como requests y Beautiful Soup para extraer datos de páginas web u otras fuentes e importarlos a Excel.

Luego, puedes analizar y manipular estos datos utilizando bibliotecas de Python como Pandas.

import pandas as pd
import requests
from bs4 import BeautifulSoup
# Scrape data from web page
url = 'https://www.website.com/data'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
table = soup.find('table')
df = pd.read_html(str(table))[0]
# Export to Excel file
df.to_excel('scraped_data.xlsx', index=False)

Este código utiliza la biblioteca requests para enviar una solicitud GET HTTP a la URL 'https://www.example.com'. Luego utiliza la biblioteca BeautifulSoup para analizar el contenido HTML de la respuesta en un objeto BeautifulSoup nombrado 'soup'.

Puedes luego utilizar métodos de BeautifulSoup como find_all() para extraer datos específicos del HTML:

links = []for link in soup.find_all('a'):    href = link.get('href')    links.append(href)

Este código encuentra todas las etiquetas de anclaje en el HTML y extrae el valor del atributo 'href' para cada una, agregándolos a una lista nombrada 'links'.

Cómo Utilizar Python para Integrar Excel con Otras Aplicaciones

Esta tarea implica utilizar Python para integrar Excel con otras aplicaciones, como bases de datos o servicios web.

Puedes hacer esto utilizando bibliotecas de Python como pyodbc para conectarte a bases de datos o mediante el uso de APIs para conectarte a servicios web. Esto permite una transferencia y análisis de datos sin problemas entre diferentes aplicaciones.

import pandas as pd
import pyodbc
# Connect to database
cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER=server_name;DATABASE=db_name;UID=user_id;PWD=password')
# Read data from database
query = 'SELECT * FROM table_name'
df = pd.read_sql(query, cnxn)
# Export to Excel file
df.to_excel('database_data.xlsx', index=False)

El código establece una conexión a una base de datos SQL Server utilizando el método pyodbc.connect(), donde el controlador, el nombre del servidor, el nombre de la base de datos, el ID de usuario y la contraseña se proporcionan como argumentos.

Luego, se define y ejecuta una consulta SQL para recuperar datos de una tabla en la base de datos utilizando el método pd.read_sql(), donde la consulta SQL y el objeto de conexión se proporcionan como argumentos. Los datos recuperados se almacenan en un marco de datos de pandas.

Finalmente, los datos en el Marco de Datos se exportan a un archivo de Excel llamado "database_data.xlsx" utilizando el método to_excel(), excluyendo la columna de índice de la exportación al establecer el parámetro index en False.

Conclusión

Python es un lenguaje versátil que puedes utilizar para automatizar muchas tareas de Excel. También puedes utilizar diversas bibliotecas como Pandas, openpyxl, xlwings y pyautogui para manipular datos, extraer información, generar informes y automatizar tareas repetitivas.

La automatización puede ahorrar tiempo y esfuerzo, reducir errores y aumentar la productividad. La competencia en Python puede ser una habilidad valiosa para cualquier profesional que trabaje con Excel, ya sea un analista de datos o financiero. Al aprender Python, puedes llevar tu trabajo a nuevos niveles.

¡Conéctate en Twitter y LinkedIn. ¡Gracias por leer!

Un DataFrame (marco de datos) de pandas es una estructura de datos bidimensional que permite almacenar información en forma de filas y columnas. Es una estructura muy útil para realizar análisis de datos.

Dependiendo del modelo o del objetivo de tu estudio, es posible que necesites eliminar un grupo específico de filas del DataFrame.

En este tutorial veremos como eliminar una lista de filas de un DataFrame de pandas.

Como eliminar una fila o una columna de un DataFrame de pandas

Para eliminar una fila o una columna de un DataFrame, necesitas el método drop() del DataFrame. Puedes leer más acerca del método drop() en la  documentación.

Ejes del DataFrame

• Las filas se denotan mediante axis=0
• Las columnas se denotan mediante axis=1

Etiquetas del DataFrame

• Las filas se etiquetan, por defecto, mediante un índice numérico, comenzando por el 0.
• Las columnas se etiquetan por nombre.

Parámetros del método drop()

• index - la lista de filas a eliminar
• axis=0 - indica que son filas, y no columnas, lo que hay que eliminar
• inplace=True - realiza la operación sobre el mismo DataFrame, en lugar de crear y devolver uno nuevo.

DataFrame de muestra

Nuestro DataFrame de muestra contiene las columnas, nombre_producto, precio_unitario, num_de_unidades, cantidad_disponible y disponible_desde_fecha. El valor NaN se usa para denotar valores nulos.

import pandas as pd

data = {"nombre_producto":["Teclado","Raton", "Monitor", "CPU","CPU", "Altavoces",pd.NaT],
        "precio_unitario":[500, 200, 5000.235, 10000.550, 10000.550, 250.50,None],
        "num_de_unidades":[5, 5, 10, 20, 20, 8, pd.NaT],
        "cantidad disponible":[5, 6, 10, "no disponible", "no disponible", pd.NaT, pd.NaT],
        "disponible_desde_fecha":['5/11/2021', '23/4/2021', '21/08/2021', '18/09/2021', '18/09/2021', '05/01/2021', pd.NaT]
       }

df = pd.DataFrame(data)

df

El DataFrame tendrá el siguiente aspecto:

Después de cada operación de eliminación, imprimiremos el DataFrame médiate df con el formato de tabla de HTML.

A continuación veremos distintas formas de seleccionar las filas a eliminar.

Como eliminar una lista de filas mediante índice

Se puede eliminar una serie de filas pasándole al métododrop() una lista con los índices.

df.drop([5,6], axis=0, inplace=True)

df

En este fragmento,

• [5,6] son los índices de las filas a eliminar.
• axis=0 denota que son filas lo que hay que eliminar
• inplace=True realiza la operación sobre el mismo DataFrame

Tras eliminar las filas con índices 5 y 6, los datos en el DataFrame serán:

Como eliminar filas mediante un intervalo de índices

También se puede eliminar una serie de filas en un intervalo específico.

Esto puede ser útil para crear una muestra de nuestro conjunto de datos excluyendo intervalos específicos de datos.

Se puede crear un intervalo de filas en un DataFrame mediante el método df.index(), pasándolo luego al método drop() para eliminar esas filas, como se muestra a continuación:

df.drop(df.index[2:4], inplace=True)

df

Qué está haciendo este código:

• df.index[2:4] genera un intervalo de filas desde la 2ª hasta la 3ª. El límite inferior es inclusivo, mientras que el superior es exclusivo. Es decir, que serán eliminadas las filas 2 y 3, mientras que la 4ª no será eliminada.
• inplace=True realiza la operación de eliminación sobre el mismo DataFrame.

Después de eliminar filas en el intervalo 2-4, el DataFrame queda de la siguiente manera:

Como eliminar todas las filas después de un índice

Es posible eliminar todas las filas posteriores a un índice determinado mediante iloc[].

Con el método iloc[] se seleccionan las filas mediante índices, especificando las posiciones inicial y final separadas por :. Por ejemplo, ya hemos usado 2:4 para seleccionar las filas 2 y 3. Si las queremos seleccionar todas, simplemente pasamos : a iloc[].

Esto resulta útil en los casos en los que se quiera dividir el conjunto de datos con propósitos de prueba.

El siguiente fragmento selecciona las filas con índices 0 y 1 y lo asigna a la misma variable. El resultado final es la eliminación de todas las filas a partir del índice 2.

df = df.iloc[:2]

df

Con :2 se seleccionan las filas hasta el índice 2 (exclusivo).

Después de esta operación, nuestro DataFrame tendrá el siguiente aspecto:

Com eliminar filas usando múltiples condiciones

En lugar de especificar unas filas concretas mediante índices, es posible seleccionar las filas que cumplan unas determinadas condiciones.

Por ejemplo, podrías eliminar filas cuyo valor en alguna de las columnas fuera mayor que X y menor que Y.

Esto puede ser útil en el caso de que quieras crear un conjunto de datos que ignore unos valores específicos en ciertas columnas.

Para eliminar filas condicionalmente, selecciona los índices de las filas que cumplan la condición, pasándolos luego al método drop().

df.drop(df[(df['precio_unitario'] >400) & (df['precio_unitario'] < 600)].index, inplace=True)

df

En el código anterior,

• (df['Unit_Price'] >400) & (df['Unit_Price'] < 600) es la condición para eliminar las filas.
• df[].index selecciona los índices de las filas que cumplen la condición.
• inplace=True realiza la operación de eliminado sobre el mismo DataFrame, en lugar de crear y devolver uno nuevo.

Después de eliminar las filas que cumplen la condición de tener precio_unitario mayor que 400 y menor que 600, nuestro DataFrame quedará con los siguientes datos:

Conclusión

En resumen, en este artículo nos hemos familiarizado con el método drop() de los DataFrame de pandas. También hemos visto como se etiquetan las filas y columnas de los DataFrame. Y finalmente hemos aprendido a eliminar filas mediante índices, un intervalo de índices y basándose en condiciones.

Si te ha gustado este artículo, no dudes en compartirlo.

El análisis de datos es el proceso de explorar, investigar y recopilar información de los datos utilizando medidas y visualizaciones estadísticas.

El objetivo del análisis de datos es desarrollar una comprensión de los datos al descubrir tendencias, relaciones y patrones. El análisis de datos es tanto una ciencia como un arte. Por un lado, requiere el conocimiento de estadística, técnicas de visualización y paquetes de Python como Numpy, Pandas y Seaborn.

Por otro lado, requiere que hagas preguntas interesantes para guiar la investigación y luego interpretes los números y cifras para generar ideas útiles. En este tutorial sobre análisis de datos se cubren los siguientes temas:

1.¿Qué es el cálculo numérico? Python y Numpy para principiantes    

2. Cómo analizar datos tabulares usando Python y Pandas    

3. Visualización de datos usando Python, Matplotlib y Seaborn

¿Qué es el cálculo numérico? Python y Numpy para principiantes

Puedes seguir el tutorial y ejecutar el código aquí: https://jovian.ai/aakashns/python-numerical-computing-with-numpy

Esta sección cubre los siguientes temas:  

1. Cómo trabajar con datos numéricos en Python    

2. Cómo convertir listas de Python en arreglos Numpy    

3. Arreglos Numpy multidimensionales y sus beneficios    

4. Operaciones con arreglos; transmisión, indexación y división    

5. Cómo trabajar con archivos de datos CSV usando Numpy

Cómo trabajar con datos numéricos en Python

Los "datos" en el análisis de datos, generalmente se refieren a datos numéricos; como precios de acciones, cifras de ventas, mediciones de sensores, puntajes deportivos, tablas de bases de datos, etc.

La biblioteca Numpy proporciona estructuras de datos especializadas, funciones y otras herramientas para la computación numérica en Python. Analicemos un ejemplo para ver por qué y cómo usar Numpy para trabajar con datos numéricos.

Supongamos que queremos usar datos climáticos como la temperatura, la lluvia y la humedad para determinar si una región es adecuada para el cultivo de manzanas.

Un enfoque simple para hacer esto sería formular la relación entre el rendimiento anual de manzanas (toneladas por hectárea) y las condiciones climáticas como la temperatura promedio (en grados Fahrenheit), la lluvia (en milímetros) y la humedad relativa promedio (en porcentaje) como una ecuación lineal.

Rendimiento_manzanas = w1 * temperatura + w2 * lluvia + w3 * humedad

Estamos expresando el rendimiento de las manzanas como una suma ponderada de la temperatura, la lluvia y la humedad. Esta ecuación es una aproximación, ya que la relación real puede no ser necesariamente lineal y puede haber otros factores involucrados.

Pero un modelo lineal simple como este suele funcionar bien en la práctica. Con base en algunos análisis estadísticos de datos históricos, podríamos encontrar valores razonables para los pesos w1, w2 y w3. He aquí un ejemplo de conjunto de valores:

w1, w2, w3 = 0.3, 0.2, 0.5

Dados algunos datos climáticos para una región, ahora podemos predecir el rendimiento de las manzanas. Aquí hay algunos datos de muestra:

Para comenzar, podemos definir algunas variables para registrar los datos climáticos de la región de Kanto.

kanto_temperatura = 73
kanto_lluvia = 67
kanto_humedad = 43

Ahora podemos sustituir los valores de estas variables en la ecuación para obtener el rendimiento de las manzanas:

kanto_yield_apples = kanto_temp * w1 + kanto_rainfall * w2 + kanto_humidity * w3
kanto_yield_apples
print("The expected yield of apples in Kanto region is {} tons per hectare.".format(kanto_yield_apples))

Para que sea un poco más fácil realizar el cálculo anterior para varias regiones, podemos representar los datos climáticos de cada región como un vector, es decir, una lista de números.

kanto = [73, 67, 43]
johto = [91, 88, 64]
hoenn = [87, 134, 58]
sinnoh = [102, 43, 37]
unova = [69, 96, 70]

Los tres números en cada vector representan los datos de temperatura, lluvia y humedad, respectivamente. También podemos representar el conjunto de pesos utilizados en la fórmula como un vector.

pesos=[w1,w2,w3]

Ahora podemos escribir una función crop_yield para calcular el rendimiento de las manzanas (o cualquier otro cultivo) dados los datos climáticos y los respectivos pesos.

def crop_yield(region, weights):
    result = 0
    for x, w in zip(region, weights):
        result += x * w
    return result
    
crop_yield(kanto, weights)
*# 56.8

crop_yield(johto, weights)
*# 76.9

crop_yield(unova, weights)
*# 74.9

Cómo convertir listas de Python en arreglos Numpy

El cálculo realizado en la variable crop_yield, implica la multiplicación por elementos de dos vectores y la suma de los resultados. A este proceso matemático se le denomina producto escalar. Puedes obtener mayor información sobre los productos punto aquí.

La biblioteca Numpy proporciona una función integrada para calcular el producto escalar de dos vectores. Sin embargo, primero debemos convertir las listas en arreglos Numpy.

Instalemos la biblioteca Numpy usando el administrador de paquetes pip.

!pip install numpy --upgrade --quiet

Ahora, importemos el módulo numpy. Es una práctica común importar numpy con el alias np.

import numpy as np

Ahora podemos usar la función np.array para crear arreglos en Numpy.

kanto = np.array([73, 67, 43])

kanto
# array([73, 67, 43])

weights = np.array([w1, w2, w3])

weights
# array([0.3, 0.2, 0.5])

Los arreglos de Numpy poseen la clase ndarray.

type(kanto)
# numpy.ndarray

type(weights)
# numpy.ndarray

Al igual que las listas, los arrelgos Numpy admiten la notación de indexación [].

weights[0]
# 0.3

kanto[2]
#43

Operaciones con Arreglos de Numpy

Ahora podemos calcular el producto de dos vectores usando la función np.dot.

np.dot(kanto, weights)
# 56.8

El operador * realiza una multiplicación por elementos de dos arreglos si tienen el mismo tamaño. El método sum calcula la suma de números en una matriz.

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

arr1 * arr2
# array([ 4, 10, 18])

arr2.sum()
# 15

Los beneficios de usar arreglos en Numpy

Los arreglos en Numpy ofrecen los siguientes beneficios sobre las listas simples de Python. Esto sobre todo en cuanto a operaciones con datos numéricos:

• Son fáciles de usar: Puedes escribir operaciones matemáticas, simples, concisas e intuitivas, como la sumatoria del producto de dos variables(kanto * weights).sum() en lugar de usar un complejo bucle con la variable crop_yield.
• Rendimiento: Las operaciones y funciones de Numpy son implementadas internamente en C++,  lo que las vuelve mucho más rápidas que las declaraciones en Python, y por supuesto, que el tiempo de ejecución de sus bucles.

He aquí una comparación del producto de vectores, realizado en un bucle de Python, vs la ejecución en un arreglo de Numpy. Lo interesante de este experimento, es que, cada vector posee un millón de elementos. Muestra más que suficiente para comparar la velocidad entre las dos operaciones.

# Python lists
arr1 = list(range(1000000))
arr2 = list(range(1000000, 2000000))

# Numpy arrays
arr1_np = np.array(arr1)
arr2_np = np.array(arr2)

%%time
result = 0
for x1, x2 in zip(arr1, arr2):
    result += x1*x2
result

# CPU times: user 300 ms, sys: 3.26 ms, total: 303 ms
# Wall time: 302 ms
# 833332333333500000

%%time
np.dot(arr1_np, arr2_np)

# CPU times: user 2.11 ms, sys: 951 µs, total: 3.07 ms
# Wall time: 1.58 ms
# 833332333333500000

Como puedes ver; al usar np.dot obtenemos una velocidad 100 veces mayor a emplear el bucle for . Esto hace a Numpy muy útil cuando se trabaja con bases de datos de gran tamaño; es decir, de miles o incluso millones de unidades de datos.

Arreglos multidimensionales con Numpy

Ahora podemos ir un paso más allá y representar los datos climáticos de todas las regiones utilizando una sola matriz Numpy bidimensional.

climate_data = np.array([[73, 67, 43],
                         [91, 88, 64],
                         [87, 134, 58],
                         [102, 43, 37],
                         [69, 96, 70]])
                         
climate_data
# array([[ 73,  67,  43],
#        [ 91,  88,  64],
#        [ 87, 134,  58],
#        [102,  43,  37],
#        [ 69,  96,  70]])

Si tienes alguna familiaridad con el álgebra lineal, puedes comprobar el proceso reconociendo la matriz bidimensional anterior como una matriz con cinco filas y tres columnas. Cada fila representa una región y las columnas representan temperatura, lluvia y humedad, respectivamente.

Las arreglos Numpy pueden tener cualquier número de dimensiones y diferentes longitudes a lo largo de cada dimensión. Podemos inspeccionar la longitud a lo largo de cada dimensión. Para esto usamos la propiedad .shape de un arreglo.

# 2D array (matrix)
climate_data.shape
# (5, 3)

weights
# array([0.3, 0.2, 0.5])

# 1D array (vector)
weights.shape
# (3,)

# 3D array 
arr3 = np.array([
    [[11, 12, 13], 
     [13, 14, 15]], 
    [[15, 16, 17], 
     [17, 18, 19.5]]])

arr3.shape
# (2, 2, 3)

Todos los elementos en un arreglo de Numpy poseen el mismo tipo de datos. Puedes verificar el tipo de datos, usando la propiedad .dtype.

weights.dtype
# dtype('float64')

climate_data.dtype
# dtype('int64')

Si una matriz contiene incluso un solo número en formato flotante (float), todos los demás elementos también se convierten en flotantes.

arr3.dtype
# dtype('float64')

Ahora podemos calcular una predicción con las manzanas en todas las regiones. Esto mediante una simple multiplicación matricial entre climate_data (una matriz 5x3) y weights (un vector de 3 elementos). Observemos este proceso de una forma visual:

Puede aprender sobre arreglos y multiplicación de arreglos mirando los primeros 3 o 4 videos de esta lista de reproducción de YouTube.

Para efectuar la operación en Numpy, simplemente empleamos la función np.matmul . También puede usarse el operador @ para realizar la multiplicación de arreglos.

np.matmul(climate_data, weights)
# array([56.8, 76.9, 81.9, 57.7, 74.9])

climate_data @ weights
# array([56.8, 76.9, 81.9, 57.7, 74.9])

Cómo trabajar con archivos CSV

Numpy también nos provee de funciones auxiliares para a lectura de archivos de texto. En este ejemplo, descarguemos un archivo climate.txt, el cual contiene 10,000 mediciones del clima con tres variables (temperatura, lluvia y humedad) en el siguiente formato:

temperature,rainfall,humidity
25.00,76.00,99.00
39.00,65.00,70.00
59.00,45.00,77.00
84.00,63.00,38.00
66.00,50.00,52.00
41.00,94.00,77.00
91.00,57.00,96.00
49.00,96.00,99.00
67.00,20.00,28.00
...

Este formato de almacenamiento de datos se conoce como valores separados por comas o CSV.

CSV: un archivo de valores separados por comas (CSV) es un archivo de texto delimitado que utiliza una coma para separar los valores. Cada línea del archivo es un registro de datos. Cada registro consta de uno o más campos, separados por comas. Un archivo CSV generalmente almacena datos tabulares (números y texto) en texto sin formato, en cuyo caso cada línea tendrá la misma cantidad de campos. (Wikipedia)

Para leer este archivo en un arreglo de Numpy, podemos usar la función genfromtxt .

import urllib.request

urllib.request.urlretrieve(
    'https://hub.jovian.ml/wp-content/uploads/2020/08/climate.csv', 
    'climate.txt')
    
climate_data = np.genfromtxt('climate.txt', delimiter=',', skip_header=1)

climate_data
# array([[25., 76., 99.],
#        [39., 65., 70.],
#        [59., 45., 77.],
#        ...,
#        [99., 62., 58.],
#        [70., 71., 91.],
#        [92., 39., 76.]])

climate_data.shape
# (10000, 3)

Ahora podemos realizar una multiplicación de arreglos usando el operador @ para predecir el rendimiento de las manzanas para todo el conjunto de datos usando un conjunto de pesos asignados a las variables.

weights = np.array([0.3, 0.2, 0.5])

yields = climate_data @ weights
yields
# array([72.2, 59.7, 65.2, ..., 71.1, 80.7, 73.4])

yields.shape
# (10000,)

Añadamos yields a climate_data como una cuarta columna (después de las 3 columnas de temperatura, lluvia y humedad) usando la función np.concatenate .

climate_results = np.concatenate((climate_data, yields.reshape(10000, 1)), axis=1)

climate_results
# array([[25. , 76. , 99. , 72.2],
#        [39. , 65. , 70. , 59.7],
#        [59. , 45. , 77. , 65.2],
#        ...,
#        [99. , 62. , 58. , 71.1],
#        [70. , 71. , 91. , 80.7],
#        [92. , 39. , 76. , 73.4]])

Aquí se presentan un par de sutilezas:

• Ya que deseamos añadir una nueva columna, usamos el argumento axis=1 para np.concatenate. El argumento axis especifica la dimensión de la concatenación.
• Los arreglos deben tener el mismo número de dimensiones, a la vez que la misma extensión. La única excepción es la dimensión empleada para la concatenación. Usamos la función np.reshape para cambiar la forma de yields de (10000,) a (10000,1).

He aquí una explicación visual de la forma en que funciona np.concatenate junto con axis=1 (A propósito: ¿Puedes adivinar que resultado traería axis=0?):

La mejor manera de comprender lo que hace una función Numpy es experimentar con ella y leer la documentación para conocer sus argumentos y valores devueltos. Usa las celdas de arriba para experimentar con np.concatenate y np.reshape.

Escribamos los resultados finales de nuestro calco realizado  usando la función np.savetxt.

np.savetxt('climate_results.txt', 
           climate_results, 
           fmt='%.2f', 
           delimiter=',',
           header='temperature,rainfall,humidity,yeild_apples', 
           comments='')

Los resultados están escritos de vuelta en el formato CSV en la fila climate_results.txt.

temperature,rainfall,humidity,yeild_apples
25.00,76.00,99.00,72.20
39.00,65.00,70.00,59.70
59.00,45.00,77.00,65.20
84.00,63.00,38.00,56.80
...

Numpy provee cientos de funciones para ejecutar operaciones en arreglos, he aquí algunas de las funciones más utilizadas:

• Matemáticas: np.sum, np.exp, np.round, operadores aritméticos.
• Manipulación de Arreglos: np.reshape, np.stack, np.concatenate, np.split
• Álgebra Lineal: np.matmul, np.dot, np.transpose, np.eigvals
• Estadística: np.mean, np.median, np.std, np.max

Entonces, ¿cómo encuentras la función que necesitas? La forma más fácil de encontrar la función correcta para una operación o caso de uso específico es realizar una búsqueda en la web. Por ejemplo, la búsqueda de "Cómo unir arreglos numpy" lleva a este tutorial de concatenation.

También puedes encontrar una lista completa de arreglos en la documentación de Numpy.

Operaciones aritméticas numéricas, transmisión y comparación

Los arreglos en Numpy soportan operadores aritméticos como  +, -, *, etc. Lo mejor de todos es que puedes realizar una operación con un simple número (también llamado escalar) o con otro arreglo del mismo tipo.

Estos operadores facilitan la escritura de expresiones matemáticas con arrglos multidimensionales.

arr2 = np.array([[1, 2, 3, 4], 
                 [5, 6, 7, 8], 
                 [9, 1, 2, 3]])
                 
arr3 = np.array([[11, 12, 13, 14], 
                 [15, 16, 17, 18], 
                 [19, 11, 12, 13]])
                 
# Adding a scalar
arr2 + 3

# array([[ 4,  5,  6,  7],
#        [ 8,  9, 10, 11],
#        [12,  4,  5,  6]])

# Element-wise subtraction
arr3 - arr2

# array([[10, 10, 10, 10],
#        [10, 10, 10, 10],
#        [10, 10, 10, 10]])

# Division by scalar
arr2 / 2

# array([[0.5, 1. , 1.5, 2. ],
#        [2.5, 3. , 3.5, 4. ],
#        [4.5, 0.5, 1. , 1.5]])

# Element-wise multiplication
arr2 * arr3

# array([[ 11,  24,  39,  56],
#        [ 75,  96, 119, 144],
#        [171,  11,  24,  39]])

# Modulus with scalar
arr2 % 4

# array([[1, 2, 3, 0],
#        [1, 2, 3, 0],
#        [1, 1, 2, 3]])

Broadcasting en un array de Numpy

Las arreglos Numpy también admiten una acción llamada broadcasting, lo que permite operaciones aritméticas entre dos arreglos con diferentes números de dimensiones pero formas compatibles. Veamos un ejemplo para ver cómo funciona.

arr2 = np.array([[1, 2, 3, 4], 
                 [5, 6, 7, 8], 
                 [9, 1, 2, 3]])               
arr2.shape
# (3, 4)

arr4 = np.array([4, 5, 6, 7])
arr4.shape
# (4,)

arr2 + arr4
# array([[ 5,  7,  9, 11],
#        [ 9, 11, 13, 15],
#        [13,  6,  8, 10]])

Cuando la expresión arr2 + arr4 es evaluada, arr4 (que tiene dimensiones (4,)) es replicada tres veces para lograr las dimensiones (3, 4) de arr2. Numpy ejecuta la replicación sin crear tres copias de la dimensión más pequeña del arreglo. Lo que facilita la eficiencia y usa mucha menos memoria.

Esto solo funciona si solo funciona si una de los arrelgos se puede replicar para que coincida con la forma de la otra matriz.

arr5 = np.array([7, 8])
arr5.shape
# (2,)

arr2 + arr5
# ValueError: operands could not be broadcast together with shapes (3,4) (2,) 

En el ejemplo precedente, incluso si arr5 es replicado tres veces, no logrará tener las dimensiones de arr2. Por lo tanto arr2 + arr5 no puede ser evaluado exitosamente. Puedes aprender más aquí acerca de broadcasting.

Comparación de arreglos en Numpy

Numpy también soporta operadores como ==, !=, > . El resultado será un arreglo de booleanos.

arr1 = np.array([[1, 2, 3], [3, 4, 5]])
arr2 = np.array([[2, 2, 3], [1, 2, 5]])

arr1 == arr2
# array([[False,  True,  True],
#        [False, False,  True]])

arr1 != arr2
# array([[ True, False, False],
#        [ True,  True, False]])

arr1 >= arr2
# array([[False,  True,  True],
#        [ True,  True,  True]])

arr1 < arr2
# array([[ True, False, False],
#        [False, False, False]])

Las comparaciones de arreglos son generalmente utilizadas para contar el número de elementos iguales en dos arreglos, mediante el método sum . Recuerda que True evalúa en 1 y False evalúa en 0. Esto es así por convención, siempre y cuando trabajes con booleanos.

(arr1 == arr2).sum()
# 3

Indexing y slicing en Numpy

Numpy extiende la notación de indexación de listas de Python usando corchetes en múltiples dimensiones de una manera intuitiva. Puede proporcionar una lista de índices o rangos separados por comas para seleccionar un elemento específico o un subarreglo (también llamado segmento) de un arreglo Numpy.

arr3 = np.array([
    [[11, 12, 13, 14], 
     [13, 14, 15, 19]], 
    
    [[15, 16, 17, 21], 
     [63, 92, 36, 18]], 
    
    [[98, 32, 81, 23],      
     [17, 18, 19.5, 43]]])
     
arr3.shape
# (3, 2, 4)

# Single element
arr3[1, 1, 2]

# 36.0

# Subarray using ranges
arr3[1:, 0:1, :2]

# array([[[15., 16.]],
# 
#        [[98., 32.]]])

# Mixing indices and ranges
arr3[1:, 1, 3]

# array([18., 43.])

arr3[1:, 1, :3]
# array([[63. , 92. , 36. ],
#        [17. , 18. , 19.5]])

# Using fewer indices
arr3[1]

# array([[15., 16., 17., 21.],
#        [63., 92., 36., 18.]])

arr3[:2, 1]
# array([[13., 14., 15., 19.],
#        [63., 92., 36., 18.]])

# Using too many indices
arr3[1,3,2,1]

# IndexError: too many indices for array: array is 3-dimensional, but 4 were indexed

La notación y sus resultados pueden parecer confusos al principio, así que reserva un tiempo para experimentar y familiarizarse con ella.

Usa las celdas a continuación para probar algunos ejemplos de indexación y división de arreglos, con diferentes combinaciones de índices y rangos. Aquí hay algunos ejemplos más demostrados visualmente:

Otros métodos para crear arreglos en Numpy
Numpy también proporciona algunas funciones útiles para crear arreglos de formas deseadas con valores fijos o aleatorios. Consulta la documentación oficial o utiliza la función de ayuda help para obtener más información.

# All zeros
np.zeros((3, 2))

# array([[0., 0.],
#        [0., 0.],
#        [0., 0.]])

# All ones
np.ones([2, 2, 3])

# array([[[1., 1., 1.],
#         [1., 1., 1.]],
#
#        [[1., 1., 1.],
#         [1., 1., 1.]]])

# Identity matrix
np.eye(3)

# array([[1., 0., 0.],
#        [0., 1., 0.],
#        [0., 0., 1.]])

# Random vector
np.random.rand(5)

# array([0.92929562, 0.11301864, 0.64213555, 0.8600434 , 0.53738656])

# Random matrix
np.random.randn(2, 3) # rand vs. randn - what's the difference?

# array([[ 0.09906435, -1.64668094,  0.08073528],
#        [ 0.1437016 ,  0.80715712,  1.27285476]])

# Fixed value
np.full([2, 3], 42)

# array([[42, 42, 42],
#        [42, 42, 42]])

# Range with start, end and step
np.arange(10, 90, 3)

# array([10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58,
#        61, 64, 67, 70, 73, 76, 79, 82, 85, 88])

# Equally spaced numbers in a range
np.linspace(3, 27, 9)

# array([ 3.,  6.,  9., 12., 15., 18., 21., 24., 27.])

Ejercicios
Prueba los siguientes ejercicios para familiarizarse con los arreglos Numpy y practicar sus habilidades:

Asignación de funciones de matriz Numpy: https://jovian.ml/aakashns/numpy-array-operations
(Opcional) 100 ejercicios numpy: https://jovian.ml/aakashns/100-numpy-exercises

Resumen y lecturas adicionales
Con esto, completamos nuestra discusión sobre computación numérica con Numpy. Hemos cubierto los siguientes temas en esta parte del tutorial:

1.Cómo pasar de listas de Python a arreglos Numpy
2.Cómo operar en arreglos Numpy
3.Los beneficios de usar arreglos Numpy sobre listas
4.Arrelgtos Numpy multidimensionales
5.Cómo trabajar con archivos de datos CSV
6.Operaciones aritméticas y radiodifusión
7.Arreglos de indexación y rebanado
8.Otras formas de crear arrelgos Numpy

Consulta los siguientes recursos para obtener más información sobre Numpy:

• Tutorial oficial
• Numpy curso en freeCodeCamp
• Numpy avanzado (explorando los detalles)

Preguntas de revisión para verificar su comprensión

Trata de responder las siguientes preguntas para evaluar su comprensión de los temas tratados en este cuaderno:

1. ¿Qué es un vector?
2. ¿Cómo representas vectores usando una lista de Python? Dar un ejemplo.
3. ¿Qué es un producto escalar de dos vectores?
4. Escribe una función para calcular el producto escalar de dos vectores.
5. ¿Qué es Numpy?
6. ¿Cómo se instala Numpy?
7. ¿Cómo se importa el módulo numpy?
8. ¿Qué significa importar un módulo con un alias? Dar un ejemplo.
9. ¿Cuál es el alias de uso común para numpy?
10. ¿Qué es una matriz Numpy?
11. ¿Cómo se crea una matriz Numpy? Dar un ejemplo.
12. ¿Cuál es el tipo de arreglos Numpy?
13. ¿Cómo se accede a los elementos de una matriz Numpy?
14. ¿Cómo calculas el producto escalar de dos vectores usando Numpy?
15. ¿Qué sucede si tratas de calcular el producto escalar de dos vectores que tienen diferentes tamaños?
16. ¿Cómo se calcula el producto de elementos de dos arreglos Numpy?
17. ¿Cómo se calcula la suma de todos los elementos en una matriz Numpy?
18. ¿Cuáles son los beneficios de usar arreglos Numpy sobre listas de Python para operar con datos numéricos?
19. ¿Por qué las operaciones de matriz de Numpy tienen un mejor rendimiento en comparación con las funciones y los bucles de Python?
20. Ilustre la diferencia de rendimiento entre las operaciones de arreglos de Numpy y los bucles de Python mediante un ejemplo.
21. ¿Qué son los arreglos Numpy multidimensionales?
22. Ilustre cómo crearía arreglos Numpy con 2, 3 y 4 dimensiones.
23. ¿Cómo inspecciona la cantidad de dimensiones y la longitud a lo largo de cada dimensión en una arreglo Numpy?
24. ¿Pueden los elementos de una matriz Numpy tener diferentes tipos de datos?
25. ¿Cómo verifica los tipos de datos de los elementos de un arreglo Numpy?
26. ¿Cuál es el tipo de datos de una matriz Numpy?
27. ¿Cuál es la diferencia entre una matriz y una matriz Numpy 2D?
28. ¿Cómo se realiza la multiplicación de arreglos usando Numpy?
29. ¿Para qué se usa el operador @ en Numpy?
30. ¿Qué es el formato de archivo CSV?
31. ¿Cómo se leen los datos de un archivo CSV usando Numpy?
32. ¿Cómo se concatenan dos arreglos Numpy?
33. ¿Cuál es el propósito del argumento del eje de np.concatenate?
34. ¿Cuándo son compatibles dos arreglos Numpy para la concatenación?
35. Dé un ejemplo de dos arreglos Numpy que se pueden concatenar.
36. Dé un ejemplo de dos arreglos Numpy que no se pueden concatenar.
37. ¿Cuál es el propósito de la función np.reshape?
38. ¿Qué significa "remodelar" una matriz Numpy?
39. ¿Cómo se escribe una arreglo numpy en un archivo CSV?
40. Dé algunos ejemplos de funciones Numpy para realizar operaciones matemáticas.
41. Proporcione algunos ejemplos de funciones Numpy para realizar la manipulación de arreglos.
42. Dé algunos ejemplos de funciones Numpy para realizar álgebra lineal.
43. Dé algunos ejemplos de funciones Numpy para realizar operaciones estadísticas.
44. ¿Cómo encuentra la función Numpy correcta para una operación o caso de uso específico?
45. ¿Dónde puede ver una lista de todas las funciones y operaciones de la matriz Numpy?
46. ¿Cuáles son los operadores aritméticos compatibles con las arreglos Numpy? Ilustrar con ejemplos.
47. ¿Qué es la radiodifusión de matriz? ¿Cómo es útil? Ilustre con un ejemplo.
48. Proporciona algunos ejemplos de arreglos que sean compatibles para la transmisión.
49. Dé algunos ejemplos de arreglos que no son compatibles para la transmisión.
50. ¿Cuáles son los operadores de comparación admitidos por las arreglos Numpy? Ilustrar con ejemplos.
51. ¿Cómo accede a un subarreglo o segmento específico de un arreglo Numpy?
52. Ilustra la indexación y el corte de arreglos en arreglos Numpy multidimensionales con algunos ejemplos.
53. ¿Cómo se crea una matriz Numpy con una forma dada que contiene todos los ceros?
54. ¿Cómo se crea una matriz Numpy con una forma dada que contiene todos unos?
55. ¿Cómo se crea una matriz de identidad de una forma dada?
56. ¿Cómo se crea un vector aleatorio de una longitud dada?
57. ¿Cómo se crea una matriz Numpy con una forma dada con un valor fijo para cada elemento?
58. ¿Cómo se crea una matriz Numpy con una forma dada que contiene elementos inicializados aleatoriamente?
59. ¿Cuál es la diferencia entre np.random.rand y np.random.randn? Ilustrar con ejemplos.
60. ¿Cuál es la diferencia entre np.arange y np.linspace? Ilustrar con ejemplos.

Está listo para pasar a la siguiente sección de este tutorial.

Cómo analizar datos tabulares usando Python y Pandas

Sigue y ejecuta el código aquí: https://jovian.ai/aakashns/python-pandas-data-analysis.

Esta sección cubre los siguientes temas:

1. Cómo leer un archivo CSV en un marco de datos de Pandas
2. Cómo recuperar datos de marcos de datos de Pandas
3. Cómo consultar, clasificar y analizar datos
4. Cómo fusionar, agrupar y agregar datos
5. Cómo extraer información útil de las fechas
6. Trazado básico usando gráficos de líneas y barras
7. Cómo escribir marcos de datos en archivos CSV

Cómo leer un archivo CSV usando Pandas

Pandas es una biblioteca popular de Python que se utiliza para trabajar con datos tabulares (similares a los datos almacenados en una hoja de cálculo). Proporciona funciones auxiliares para leer datos de varios formatos de archivo como CSV, hojas de cálculo de Excel, tablas HTML, JSON, SQL y más.

Descarguemos el archivo italy-covid-daywise.txt que contiene una gama de datos sobre el Covid-19 en Italia en el siguiente formato:

date,new_cases,new_deaths,new_tests
2020-04-21,2256.0,454.0,28095.0
2020-04-22,2729.0,534.0,44248.0
2020-04-23,3370.0,437.0,37083.0
2020-04-24,2646.0,464.0,95273.0
2020-04-25,3021.0,420.0,38676.0
2020-04-26,2357.0,415.0,24113.0
2020-04-27,2324.0,260.0,26678.0
2020-04-28,1739.0,333.0,37554.0
...

Este formato de almacenamiento de datos se conoce como valores separados por comas o CSV. Aquí hay un recordatorio en caso de que necesites una definición de lo que es el formato CSV:

CSV: un archivo de valores separados por comas (CSV) es un archivo de texto delimitado que utiliza una coma para separar los valores. Cada línea del archivo es un registro de datos. Cada registro consta de uno o más campos, separados por comas. Un archivo CSV generalmente almacena datos tabulares (números y texto) en texto sin formato, en cuyo caso cada línea tendrá la misma cantidad de campos. (Wikipedia)

Descargaremos este archivo usando la función urlretrieve que proviene del módulo urllib.request.

from urllib.request import urlretrieve

urlretrieve('https://hub.jovian.ml/wp-content/uploads/2020/09/italy-covid-daywise.csv', 'italy-covid-daywise.csv')

Para leer el archivo, podemos usar el método de Pandas read_csv . Pero primero, instalemos la librería de Pandas.

!pip install pandas --upgrade --quiet

Ahora podemos importar nuestro módulo pandas, el cual por convención es importado como pd.

import pandas as pd

covid_df = pd.read_csv('italy-covid-daywise.csv')

Los datos del archivos se almacenan en un objeto DataFrame – una de las estructuras principales en Pandas para almacenar y trabajar con datos tabulares. En el particular caso de los DataFrames; típicamente empleamos el sufijo _df en el nombre de las variables.

type(covid_df)
# pandas.core.frame.DataFrame

covid_df

Esto es lo que podemos decir al mirar el marco de datos:

El archivo proporciona recuentos de cuatro días para COVID-19 en Italia
Las métricas reportadas son casos nuevos, muertes y pruebas.

Los datos se proporcionan durante 248 días: del 12 de diciembre de 2019 al 3 de septiembre de 2020
Ten en cuenta que estos son números informados oficialmente. El número real de casos y muertes puede ser mayor, ya que no todos los casos se diagnostican.

Podemos observar alguna información básica usando el método .info.

covid_df.info()

Parece que cada columna contiene valores de un tipo de datos específico. Puedes ver información estadística para columnas numéricas (media, desviación estándar, valores mínimos/máximos y el número de valores no vacíos) usando el método .describe.

covid_df.describe()

La propiedad columns contiene la lista de las columnas dentro del DataFrame.

covid_df.columns
# Index(['date', 'new_cases', 'new_deaths', 'new_tests'], dtype='object')

También puedes obtener el número de filas y columnas en el DataFrame usando el método .shape.

covid_df.shape
# (248, 4)

He aquí un resumen de las funciones y métodos que hemos visto hasta ahora:

• pd.read_csv – Lee (y transforma) los datos de un archivo CSV a un objeto de Pandas DataFrame.
• .info() – Visualiza información básica acerca de filas columnas y tipo de datos.
• .describe() – Visualiza información estadística acerca de los datos almacenados en las columnas.
• .columns – Retorna la lista de los nombres de las columnas.
• .shape – Obtiene el número de filas y columnas en forma de Tupla.

Recuperar datos de un DataFrame en Pandas

La primera cosa que querrás hacer será recuperar datos almacenados en un DataFrame, como el conteo de días específicos, o la lista de valores en una columna particular.

Para hacer esto, debes comprender la representación interna de los datos en un marco de datos. Conceptualmente, puedes pensar en un marco de datos como un diccionario de listas: las claves son nombres de columna y los valores son listas/arreglos que contienen datos para las columnas respectivas.

# El formato de Pandas SÍ es similar a esto:
covid_data_dict = {
    'date':       ['2020-08-30', '2020-08-31', '2020-09-01', '2020-09-02', '2020-09-03'],
    'new_cases':  [1444, 1365, 996, 975, 1326],
    'new_deaths': [1, 4, 6, 8, 6],
    'new_tests': [53541, 42583, 54395, None, None]
}

Representar los datos en el formato de arriba tiene varios beneficios:

• Todos los valores de una columna suelen tener el mismo tipo de valor, por lo que es más eficiente almacenarlos en un único arreglo.
• Recuperar los valores de una fila en particular simplemente requiere extraer los elementos en un índice determinado de columnas.
• La representación es más compacta (los nombres de las columnas se registran solo una vez) en comparación con otros formatos que usan un diccionario para cada fila de datos (por favor mirar el ejemplo a continuación).

# El formato de Pandas NO es similar a esto
covid_data_list = [
    {'date': '2020-08-30', 'new_cases': 1444, 'new_deaths': 1, 'new_tests': 53541},
    {'date': '2020-08-31', 'new_cases': 1365, 'new_deaths': 4, 'new_tests': 42583},
    {'date': '2020-09-01', 'new_cases': 996, 'new_deaths': 6, 'new_tests': 54395},
    {'date': '2020-09-02', 'new_cases': 975, 'new_deaths': 8 },
    {'date': '2020-09-03', 'new_cases': 1326, 'new_deaths': 6},
]

Con la analogía del diccionario de listas en mente, ahora puedes adivinar cómo recuperar datos de un DataFrame. Por ejemplo, podemos obtener una lista de valores de una columna específica utilizando la notación de indexación [].

covid_data_dict['new_cases']
# [1444, 1365, 996, 975, 1326]

covid_df['new_cases']
# 0         0.0
# 1         0.0
# 2         0.0
# 3         0.0
# 4         0.0
#         ...  
# 243    1444.0
# 244    1365.0
# 245     996.0
# 246     975.0
# 247    1326.0
# Name: new_cases, Length: 248, dtype: float64

Cada columna está representada por una estructura de datos llamada  Series, la cual es esencialmente un arreglo de Numpy con algunos métodos y propiedades adicionales.

type(covid_df['new_cases'])
# pandas.core.series.Series

Como en los arreglos; puedes recuperar un valor específico con una Series, usando la notación index [].

covid_df['new_cases'][246]
# 975.0

covid_df['new_tests'][240]
57640.0

Pandas también nos provee del método .at para recuperar el elemento en una fila y columna específica de forma directa.

covid_df.at[246, 'new_cases']
# 975.0

covid_df.at[240, 'new_tests']
# 57640.0

En vez de usar la notación de [], Pandas también nos permite acceder a las columnas como propiedades del DataFrame, usando otro tipo de notación, la notación . . Sin embargo, este método solo funciona para columnas cuyos nombres no contienen espacios o carácteres especiales.

covid_df.new_cases
# 0         0.0
# 1         0.0
# 2         0.0
# 3         0.0
# 4         0.0
#         ...  
# 243    1444.0
# 244    1365.0
# 245     996.0
# 246     975.0
# 247    1326.0
# Name: new_cases, Length: 248, dtype: float64

Además,  también puedes pasar una lista de columnas dentro de la notación index  [] para acceder a un subconjunto del DataFrame con solo las columnas ya presentes.

cases_df = covid_df[['date', 'new_cases']]
cases_df

El nuevo DataFrame cases_df es simplemente un "primer acercamiento" del DataFrame original covid_df. Ambos apuntan a los mismos datos en la memoria de la computadora. Cambiar cualquier valor dentro de uno de ellos también cambiará los valores respectivos en el otro.

Compartir datos entre DataFrames hace que la manipulación de datos en Pandas sea increíblemente rápida. No necesitas preocuparte por la sobrecarga de copiar miles o millones de filas cada vez que desee crear un nuevo marco de datos al operar en uno existente.

A veces, puede que necesites una copia completa del DataFrame, en este caso puedes usar el método copy.

covid_df_copy = covid_df.copy()

Los datos dentro de covid_df_copy están ahora completamente separados covid_df, por lo que a partir de ahora, el cambiar los valores al interior de uno, no afectará los valores del otro.

Para acceder a esta lista específica de datos, Pandas nos brinda el método .loc.

covid_df

covid_df.loc[243]
# date          2020-08-30
# new_cases         1444.0
# new_deaths           1.0
# new_tests        53541.0
# Name: 243, dtype: object

Cada columna recuperada es un objeto de una Series.

type(covid_df.loc[243])
# pandas.core.series.Series

Podemos emplear los métodos .head y .tail para ver los primeros o últimos datos, respectivamente.

covid_df.head(5)

covid_df.tail(4)

Nótese que en los resultados de arriba, que pese a que los primeros valores en  new_cases y new_deaths sus columnas son 0, los valores correspondientes dentro de las columnas new_tests son NaN. Esto es debido a que el archivo CSV no contiene ningún dato en la columa new_tests respecto a fechas específicas (puedes verificar esto mirando al interior del archivo CSV). Estos valores constituyen Missing Data.

covid_df.at[0, 'new_tests']
# nan

type(covid_df.at[0, 'new_tests'])
# numpy.float64

La diferencia entre 0 y NaN es sutil pero importante. En este conjunto de datos, representa que los números de prueba diarios no se informaron en fechas específicas. Italia comenzó a informar pruebas diarias el 19 de abril de 2020. Ya habían realizado 935,310 pruebas antes del 19 de abril.

Podemos confirmar que el primer índice (Index) no contiene un valor NaN usando el métodofirst_valid_index.

covid_df.new_tests.first_valid_index()
# 111

Ahora echemos un vistazo a unas cuantas filas antes y después del índice para verificar que los valores NaN han sido cambiados a números reales. Podemos hacer esto definiendo un rango luego de aplicar loc.

covid_df.loc[108:113]

Podemos usar el método .sample para recuperar una muestra aleatoria de filas, provenientes de nuestro DataFrame.

covid_df.sample(10)

Ten en cuenta que aunque hemos tomado una muestra aleatoria, se conserva el índice original de cada fila. Esta es una propiedad útil de los DataFrame.

He aquí un resumen de las funciones y métodos vistos en esta sección:

• covid_df['new_cases'] – Recupera las columnas como Series usando el nombre de la columna.
• new_cases[243] – Recupera valores de una Series usando la notación index
• covid_df.at[243, 'new_cases'] – Recupera un solo valor de un DataFrame específico.
• covid_df.copy() – Crea una copia de un DataFrame.
• covid_df.loc[243] - Recupera una fila o rango de filas de datos, provenientes de un DataFrame específico.
• head, tail, and sample – Recupera múltiples filas de datos de un DataFrame.
• covid_df.new_tests.first_valid_index – Encuentra el primer índice no nulo en una Series.

Análisis de Datos de un DataFrame en Pandas.

Let's try to answer some questions about our data.

Q: Cuál es el número total de casos y muertes reportadas por Covid-19 en Italia?

Similar a los arreglos de Numpy, una Series de Pandas soporta el método sum para dar respuesta a estas preguntas.

total_cases = covid_df.new_cases.sum()
total_deaths = covid_df.new_deaths.sum()

print('The number of reported cases is {} and the number of reported deaths is {}.'.format(int(total_cases), int(total_deaths)))
# The number of reported cases is 271515 and the number of reported deaths is 35497.

Q: ¿Cuál es la tasa de mortalidad general (proporción de muertes notificadas a casos notificados)

death_rate = covid_df.new_deaths.sum() / covid_df.new_cases.sum()

print("The overall reported death rate in Italy is {:.2f} %.".format(death_rate*100))
# The overall reported death rate in Italy is 13.07 %.

Q: ¿Cuál es el número total de pruebas realizadas? Se realizaron un total de 935,310 pruebas antes de que se informaran los números de pruebas diarias.

initial_tests = 935310
total_tests = initial_tests + covid_df.new_tests.sum()

total_tests
# 5214766.0

Q: Qué proporción de los test nos dió un resultado positivo?

positive_rate = total_cases / total_tests

print('{:.2f}% of tests in Italy led to a positive diagnosis.'.format(positive_rate*100))
# 5.21% of tests in Italy led to a positive diagnosis.

Estas preguntas son solo una muestra; puedes continuar realizando preguntas y respondiéndolas con el código.

Cómo consultar y ordenar filas en Pandas

Supongamos que solo queremos dar un vistazo a los días en los que hubieron más de 1000 casos reportados. Podemos emplear una expresión booleana para averiguar cuales filas satisfacen este criterio.

high_new_cases = covid_df.new_cases > 1000

high_new_cases
# 0      False
# 1      False
# 2      False
# 3      False
# 4      False
#        ...  
# 243     True
# 244     True
# 245    False
# 246    False
# 247     True
# Name: new_cases, Length: 248, dtype: bool

La expresión booleana retorna valores enmarcados en los criterios "verdadero" y "falso" True y False , estos representan valores booleanos. Puedes usar esta series para seleccionar un subconjunto de filas del DataFrame original, correspondientes al valor True en las Series.

covid_df[high_new_cases]

El DataFrame contiene 72 filas, pero solo la primera y las últimas cinco filas se muestran de forma predeterminada con Jupyter por razones de brevedad. Podemos cambiar algunas opciones de visualización para ver todas las filas.

high_cases_df = covid_df[covid_df.new_cases > 1000]

high_cases_df

from IPython.display import display
with pd.option_context('display.max_rows', 100):
    display(covid_df[covid_df.new_cases > 1000])

También podemos formular consultas más complejas que involucren varias columnas. Como ejemplo, tratemos de determinar los días en que la proporción de casos informados a las pruebas realizadas es más alta que el total. positive_rate.

positive_rate
# 0.05206657403227681

high_ratio_df = covid_df[covid_df.new_cases / covid_df.new_tests > positive_rate]

high_ratio_df

El resultado de realizar una operación en dos columnas es una nueva serie.

covid_df.new_cases / covid_df.new_tests
# 0           NaN
# 1           NaN
# 2           NaN
# 3           NaN
# 4           NaN
#          ...   
# 243    0.026970
# 244    0.032055
# 245    0.018311
# 246         NaN
# 247         NaN
# Length: 248, dtype: float64

Podemos usar esta nueva series en el DataFrame

covid_df['positive_rate'] = covid_df.new_cases / covid_df.new_tests

covid_df

Sin embargo, ten en cuenta que a veces puede tomar unos días obtener los resultados de una prueba, por lo que no podemos comparar la cantidad de casos nuevos con la cantidad de pruebas realizadas el mismo día. Cualquier inferencia basada en la columna positive_rate sería probablemente incorrecta.

Es esencial tener cuidado con estas relaciones sutiles que a menudo no se transmiten dentro del archivo CSV y requieren algún contexto externo. Siempre es una buena idea leer la documentación provista con el conjunto de datos o solicitar más información.

Por ahora removamos la columna positive_rate usando el método drop.

covid_df.drop(columns=['positive_rate'], inplace=True)

Puedes deducir el significado del argumento inplace?

Cómo ordenar filas usando valores de columnas en Pandas

También puedes ordenar las filas por una columna específica usando .sort_values. Ordenemos para identificar los días con el mayor número de casos, luego encadenémoslo con el método head para presentar los primeros 10 resultados.

covid_df.sort_values('new_cases', ascending=False).head(10)

Parece que las últimas dos semanas de marzo tuvieron el mayor número de casos diarios. Comparemos esto con los días en los que se registró el mayor número de muertes.

covid_df.sort_values('new_deaths', ascending=False).head(10)

Parece que las muertes diarias alcanzan un pico casi una semana después del pico de nuevos casos diarios.
Veamos también los días con el menor número de casos. Podríamos esperar ver los primeros días del año en esta lista.

covid_df.sort_values('new_cases').head(10)

Parece que el recuento de casos nuevos el 20 de junio de 2020 fue -148, ¡un número negativo! No es algo que podríamos haber esperado, pero esa es la naturaleza de los datos del mundo real. Podría ser un error de ingreso de datos, o el gobierno puede haber emitido una corrección para dar cuenta de errores de conteo en el pasado.

¿Puedes buscar artículos de noticias en línea y averiguar por qué el número fue negativo?

Veamos algunos días antes y después del 20 de junio de 2020.

covid_df.loc[169:175]

Por ahora, supongamos que esto fue realmente un error de entrada de datos. Podemos usar uno de los siguientes enfoques para tratar con el valor faltante o defectuoso:

1. Reemplazarlo con 0.
2. Reemplazarlo con el promedio de la columna entera.
3. Reemplazarlo con el promedio de los dos valores de la fecha previa y la siguiente (el punto medio entre su diferencia).
4. Descartar la columna entera.

Cada enfoque requiere cierto contexto acerca del origen de los datos y la naturaleza del problema.  En este caso, dado que estamos tratando con datos ordenados por fecha; podemos usar el tercer enfoque.

Puedes usar el método .at para modificar un valor específico dentro del DataFrame.

covid_df.at[172, 'new_cases'] = (covid_df.at[171, 'new_cases'] + covid_df.at[173, 'new_cases'])/2

He aquí un resumen de las funciones y métodos que utilizamos en esta sección:

• covid_df.new_cases.sum() – Calcula la suma de todos los valores en una columna o series.
• covid_df[covid_df.new_cases > 1000] – Realiza una consulta que filtra un subconjunto de filas. Todas estas filas tienen en común el que satisfacen la condición establecida en las expresiones booleanas (> 1000) en este caso.
• df['pos_rate'] = df.new_cases/df.new_tests – Añade nuevas columnas mediante la combinación de datos de columnas ya existentes. (como el ratio entre casos y test presentado en este ejemplo).
• covid_df.drop('positive_rate') – Remueve una o más columnas del DataFrame.
• sort_values – Ordena las filas de un DataFrame usando valores de columnas.
• covid_df.at[172, 'new_cases'] = ... – Reemplaza un valor dentro de un DataFrame.

Cómo trabajar con fechas en Pandas

Si bien hemos analizado los números generales de los casos, las pruebas, la tasa positiva y más, también sería útil estudiar estos números mes a mes.

date  en Pandas provee varias facilidades a la hora de trabajar con fechas.

covid_df.date
# 0      2019-12-31
# 1      2020-01-01
# 2      2020-01-02
# 3      2020-01-03
# 4      2020-01-04
#           ...    
# 243    2020-08-30
# 244    2020-08-31
# 245    2020-09-01
# 246    2020-09-02
# 247    2020-09-03
# Name: date, Length: 248, dtype: object

El tipo de datos es actualmente un objeto, object, por lo que Pandas "no sabe" que esta columna es una fecha. Hay que convertirlo a una columna datetime usando el método pd.to_datetime.

covid_df['date'] = pd.to_datetime(covid_df.date)

covid_df['date']
# 0     2019-12-31
# 1     2020-01-01
# 2     2020-01-02
# 3     2020-01-03
# 4     2020-01-04
#          ...    
# 243   2020-08-30
# 244   2020-08-31
# 245   2020-09-01
# 246   2020-09-02
# 247   2020-09-03
# Name: date, Length: 248, dtype: datetime64[ns]

Puedes confirmar que ahora tiene el tipo de dato datetime64. Ahora podemos extraer diferentes partes de los datos en columnas separadas, usando la claseWe can now extract different parts of the data into separate columns, using the DatetimeIndex (ver doc).

covid_df['year'] = pd.DatetimeIndex(covid_df.date).year
covid_df['month'] = pd.DatetimeIndex(covid_df.date).month
covid_df['day'] = pd.DatetimeIndex(covid_df.date).day
covid_df['weekday'] = pd.DatetimeIndex(covid_df.date).weekday

covid_df

Revisemos las métricas generales de mayo. Podemos consultar las filas de mayo, elegir un subconjunto de columnas y usar el método sum para agregar cada uno de los valores de columna seleccionados.

# Query the rows for May
covid_df_may = covid_df[covid_df.month == 5]

# Extract the subset of columns to be aggregated
covid_df_may_metrics = covid_df_may[['new_cases', 'new_deaths', 'new_tests']]

# Get the column-wise sum
covid_may_totals = covid_df_may_metrics.sum()

covid_may_totals
# new_cases       29073.0
# new_deaths       5658.0
# new_tests     1078720.0
# dtype: float64

type(covid_may_totals)
# pandas.core.series.Series

También podemos combinar las operaciones antes mencionadas en una declaración simple:

covid_df[covid_df.month == 5][['new_cases', 'new_deaths', 'new_tests']].sum()
# new_cases       29073.0
# new_deaths       5658.0
# new_tests     1078720.0
# dtype: float64

Como otro ejemplo, comprobemos si el número de casos notificados los domingos es superior a la media de casos notificados todos los días. Esta vez, podríamos querer agregar columnas usando el método .mean

# Overall average
covid_df.new_cases.mean()

# 1096.6149193548388

# Average for Sundays
covid_df[covid_df.weekday == 6].new_cases.mean()

# 1247.2571428571428

Parece que se informaron más casos los domingos en comparación con otros días.
Intenta hacer y responder algunas preguntas adicionales relacionadas datos y fechas.

Cómo Agrupar y Agregar Datos en Pandas

Como siguiente paso, es posible que deseemos resumir los datos diarios y crear un nuevo DataFrame con datos mensuales. Podemos usar la función groupby para agrupar por mes, seleccionando las columnas que deseamos agrupar (en este caso new_cases, new_deaths y new_tests).

Esto sería la agrupación. Finalmente agregamos todos estos datos usando el método sum .

covid_month_df = covid_df.groupby('month')[['new_cases', 'new_deaths', 'new_tests']].sum()

covid_month_df

El resultado es un nuevo DataFrame que contiene valores únicos de las columnas seleccionadas con groupby nótese que este último también ha funcionado como index. La agrupación y agregación son métodos poderosos para resumir progresivamente los datos en DataFrames más pequeños.

En lugar de agregar por suma, también podemos agregar por otras medidas como la media (mean). Calculemos el número promedio de casos nuevos diarios, muertes y pruebas para cada mes.

covid_month_mean_df = covid_df.groupby('month')[['new_cases', 'new_deaths', 'new_tests']].mean()

covid_month_mean_df

Además de la agrupación, otra forma de agregación es la suma acumulada. En este caso; la suma acumulada de casos, pruebas o muertes hasta la fecha de cada fila. Podemos usar el método cumsum para calcular la suma acumulada de una columna.

Añadamos tres columnas: total_cases, total_deaths, and total_tests.

covid_df['total_cases'] = covid_df.new_cases.cumsum()
covid_df['total_deaths'] = covid_df.new_deaths.cumsum()
covid_df['total_tests'] = covid_df.new_tests.cumsum() + initial_tests

También hemos incluído el el conteo inicial en  total_test para contar los test realizados antes de que empezara el reporte diario por parte de las autoridades.

covid_df

Nótese como los valores NaN en la columna total_tests permanecen inafectados.

Cómo unir datos desde diferentes fuentes en Pandas

Para determinar otras métricas como pruebas por millón, casos por millón, etc., necesitamos más información sobre el país, es decir, su población.

Descarguemos otro archivo locations.csv que contiene información relacionada con la salud de muchos países, incluida Italia.

urlretrieve('https://gist.githubusercontent.com/aakashns/8684589ef4f266116cdce023377fc9c8/raw/99ce3826b2a9d1e6d0bde7e9e559fc8b6e9ac88b/locations.csv', 'locations.csv')

locations_df = pd.read_csv('locations.csv')
locations_df

locations_df[locations_df.location == "Italy"]

Podemos fusionar estos datos en nuestro marco de datos existente agregando más columnas. Sin embargo, para fusionar dos DataFrames, necesitamos al menos una columna común. Insertemos una columna location en el DataFrame covid_df seleccionando únicamente los valores de Italia, "Italy".

covid_df['location'] = "Italy"

covid_df

Ahora podemos añadir las columnas de locations_df en covid_df usando el método .merge .

merged_df = covid_df.merge(locations_df, on="location")

merged_df

Los datos de ubicación de Italia se adjuntan a cada fila dentro de covid_df. Si el DataFrame covid_df contenía datos para varias ubicaciones, entonces se agregarían los datos de ubicación del país respectivo para cada fila.

Ahora podemos calcular métricas como casos por millón, muertes por millón y pruebas por millón.

merged_df['cases_per_million'] = merged_df.total_cases * 1e6 / merged_df.population
merged_df['deaths_per_million'] = merged_df.total_deaths * 1e6 / merged_df.population
merged_df['tests_per_million'] = merged_df.total_tests * 1e6 / merged_df.population

merged_df

Cómo volver a escribir datos en archivos de Pandas

Después de completar el análisis y agregar nuevas columnas, debes volver a escribir los resultados en un archivo. De lo contrario, los datos se perderán cuando el portátil Jupyter se apague.
Antes de escribir en el archivo, primero creemos un DataFrame que contenga solo las columnas que deseamos registrar.

result_df = merged_df[['date',
                       'new_cases', 
                       'total_cases', 
                       'new_deaths', 
                       'total_deaths', 
                       'new_tests', 
                       'total_tests', 
                       'cases_per_million', 
                       'deaths_per_million', 
                       'tests_per_million']]
                       
result_df

Para escribir los datos del DataFrame en un archivo, podemos usar la función to_csv .

result_df.to_csv('results.csv', index=None)

La función to_csv también incluye una columna adicional para guardar el Index del DataFrame. Esta columna está por defecto. Si pasamos el código index=None eliminaremos esta columna por defecto.Puedes verificar que  results.csv ha sido creada con los datos del DataFrame en el formato CSV:

date,new_cases,total_cases,new_deaths,total_deaths,new_tests,total_tests,cases_per_million,deaths_per_million,tests_per_million
2020-02-27,78.0,400.0,1.0,12.0,,,6.61574439992122,0.1984723319976366,
2020-02-28,250.0,650.0,5.0,17.0,,,10.750584649871982,0.28116913699665186,
2020-02-29,238.0,888.0,4.0,21.0,,,14.686952567825108,0.34732658099586405,
2020-03-01,240.0,1128.0,8.0,29.0,,,18.656399207777838,0.47964146899428844,
2020-03-02,561.0,1689.0,6.0,35.0,,,27.93498072866735,0.5788776349931067,
2020-03-03,347.0,2036.0,17.0,52.0,,,33.67413899559901,0.8600467719897585,
...

Bonus: Visualización de Datos básica con Pandas

Generalmente usamos bibliotecas como matplotlib o seaborn para graficar en un notebook de Jupyter. Sin embargo, pandas también provee un método sencillo,.plot para graficar de forma rápida y conveniente.

Hagamos un gráfico lineal que muestre cómo varía el número de casos diarios con el tiempo.

result_df.new_cases.plot();

Si bien este gráfico muestra la tendencia general, es difícil saber dónde se produjo el pico, ya que no hay fechas en el eje X. Podemos usar la columna date como el index para el DataFrame.

result_df.set_index('date', inplace=True)

result_df

Ten en cuenta que el índice de un DataFrame no tiene que ser numérico. Usar la fecha como índice también nos permite obtener los dato usando .loc.

result_df.loc['2020-09-01']
# new_cases             9.960000e+02
# total_cases           2.696595e+05
# new_deaths            6.000000e+00
# total_deaths          3.548300e+04
# new_tests             5.439500e+04
# total_tests           5.214766e+06
# cases_per_million     4.459996e+03
# deaths_per_million    5.868661e+02
# tests_per_million     8.624890e+04
# Name: 2020-09-01 00:00:00, dtype: float64

Tracemos los nuevos casos y las nuevas muertes por día como gráficos de líneas.

result_df.new_cases.plot()
result_df.new_deaths.plot();

También podemos comparar el total de casos vs. el total de muertes.

result_df.total_cases.plot()
result_df.total_deaths.plot();

Veamos cómo la tasa de mortalidad y las tasas de pruebas positivas varían con el tiempo.

death_rate = result_df.total_deaths / result_df.total_cases

death_rate.plot(title='Death Rate');

positive_rates = result_df.total_cases / result_df.total_tests

positive_rates.plot(title='Positive Rate');

Finalmente, tracemos algunos datos mensuales usando un gráfico de barras para visualizar la tendencia a un nivel superior.

covid_month_df.new_cases.plot(kind='bar');

covid_month_df.new_tests.plot(kind='bar')

Ejercicios en Pandas

Prueba los siguientes ejercicios para familiarizarse con los marcos de datos de Pandas y practicar sus habilidades:

• Evaluación sobre DataFrames
• Ejercicios adicionales en Pandas
• Kaggle

Resumen y lecturas adicionales

Hemos cubierto los siguientes temas en este tutorial:

• Cómo leer un archivo CSV en un marco de datos de Pandas
• Cómo recuperar datos de marcos de datos de Pandas
• Cómo consultar, clasificar y analizar datos
• Cómo fusionar, agrupar y agregar datos
• Cómo extraer información útil de las fechas
• Trazado básico usando gráficos de líneas y barras
• Cómo escribir marcos de datos en archivos CSV

Consulta los siguientes recursos para obtener más información sobre Pandas:

• Guía de Pandas
• Python for Data Analysis (Libro del creator of Pandas)

Preguntas para evaluar tu comprensión

Intenta responder las siguientes preguntas para evaluar tu comprensión de los temas tratados en este capítulo:

1.¿Qué es Pandas? ¿Qué lo hace útil?
2.¿Cómo se instala la biblioteca Pandas?
3.¿Cómo se importa el módulo pandas?
4.¿Cuál es el alias común que se usa al importar el módulo pandas?
5.¿Cómo se lee un archivo CSV usando Pandas? Dar un ejemplo.
6.¿Cuáles son otros formatos de archivo que puede leer con Pandas? Ilustrar con ejemplos.
7.¿Qué son los marcos de datos de Pandas?
8.¿En qué se diferencian los marcos de datos de Pandas de los arreglos de Numpy?
9.¿Cómo encuentra el número de filas y columnas en un marco de datos?
10.¿Cómo se obtiene la lista de columnas en un marco de datos?
11.¿Cuál es el propósito del método de descripción de un marco de datos?
12.¿En qué se diferencian la información y los métodos de marco de datos descritos?
13.¿Es un dataframe de Pandas conceptualmente similar a una lista de diccionarios oa un diccionario de listas? Explique con un ejemplo.
14.¿Qué es una Serie Pandas? ¿En qué se diferencia de una matriz Numpy?
15.¿Cómo accede a una columna desde un marco de datos?
16. ¿Cómo accede a una fila desde un marco de datos?
17. ¿Cómo accede a un elemento en una fila y columna específicas de un marco de datos?
18.¿Cómo se crea un subconjunto de un marco de datos con un conjunto específico de columnas?
19.¿Cómo se crea un subconjunto de un marco de datos con un rango específico de filas?
20. ¿El cambio de un valor dentro de un DataFrame afecta a otros DataFrames creados usando un subconjunto de filas o columnas? ¿Por que es esto entonces?
21.¿Cómo se crea una copia de un DataFrame?
22.¿Por qué debería evitar crear demasiadas copias de un DataFrame?
23.¿Cómo ve las primeras filas de un DataFrame?
24.¿Cómo ve las últimas filas de un DataFrame?
25.¿Cómo ve una selección aleatoria de filas de un DataFrame?
26.¿Qué es el "índice" en un DataFrame? ¿Cómo es útil?
27.¿Qué representa un valor de NaN en un dataframe de Pandas?
28.¿En qué se diferencia Nan de 0?
29.¿Cómo identifica la primera fila no vacía en una serie o columna de Pandas?
30.¿Cuál es la diferencia entre df.loc y df.at?
31.¿Dónde puede encontrar una lista completa de los métodos compatibles con los objetos Pandas DataFrame y Series?
32. ¿Cómo encuentra la suma de números en una columna de un DataFrame?
33. ¿Cómo encuentra la media de los números en una columna de un marco de datos?
34. ¿Cómo encuentra la cantidad de números que no están vacíos en una columna de un DataFrame?
35.¿Cuál es el resultado obtenido al usar una columna Pandas en una expresión booleana? Ilustre con un ejemplo.
36.¿Cómo selecciona un subconjunto de filas donde el valor de una columna específica cumple una condición dada? Ilustre con un ejemplo.
37.¿Cuál es el resultado de la expresión df[df.new_cases > 100]?
38. ¿Cómo se muestran todas las filas de un marco de datos de pandas en una salida de celda Jupyter?
39.¿Cuál es el resultado que se obtiene al realizar una operación aritmética entre dos columnas de un dataframe? Ilustre con un ejemplo.
40. ¿Cómo agrega una nueva columna a un marco de datos combinando valores de dos columnas existentes? Ilustre con un ejemplo.
41.¿Cómo se elimina una columna de un marco de datos? Ilustre con un ejemplo.
42. ¿Cuál es el propósito del argumento in situ en los métodos de marco de datos?
43. ¿Cómo se ordenan las filas de un marco de datos en función de los valores de una columna en particular?
44. ¿Cómo se ordena un marco de datos de pandas utilizando valores de varias columnas?
45. ¿Cómo se especifica si se ordena de forma ascendente o descendente al ordenar un marco de datos de Pandas?
46. ​​¿Cómo cambia un valor específico dentro de un marco de datos?
47.¿Cómo se convierte una columna de marco de datos al tipo de datos de fecha y hora?
48.¿Cuáles son los beneficios de usar el tipo de datos de fecha y hora en lugar del tipo de objeto?
49.¿Cómo se extraen diferentes partes de una columna de fecha como el mes, año, mes, día de la semana, etc. en columnas separadas? Ilustre con un ejemplo.
50. ¿Cómo se agregan varias columnas de un marco de datos?
51.¿Cuál es el propósito del método groupby de un marco de datos? Ilustre con un ejemplo.
52.¿Cuáles son las diferentes formas en que puede agregar los grupos creados por groupby?
53.¿Qué quiere decir con una suma continua o acumulada?
54.¿Cómo se crea una nueva columna que contiene la suma acumulada o acumulada de otra columna?
55.¿Qué otras medidas acumulativas admiten los marcos de datos de Pandas?
56.¿Qué significa fusionar dos marcos de datos? Dar un ejemplo.
57. ¿Cómo especificas las columnas que deben usarse para fusionar dos marcos de datos?
58.¿Cómo se escriben datos de un marco de datos de Pandas en un archivo CSV? Dar un ejemplo.
59. ¿Cuáles son algunos otros formatos de archivo en los que puede escribir desde un marco de datos de Pandas? Ilustrar con ejemplos.
60. ¿Cómo se crea un gráfico de líneas que muestra los valores dentro de una columna de un marco de datos?
61.¿Cómo se convierte una columna de un marco de datos en su índice?
62. ¿Puede el índice de un marco de datos no ser numérico?
63.¿Cuáles son los beneficios de usar un marco de datos no numérico? Ilustre con un ejemplo.
64. ¿Cómo se crea un gráfico de barras que muestra los valores dentro de una columna de un marco de datos?
65. ¿Cuáles son algunos otros tipos de gráficos compatibles con los marcos de datos y las series de Pandas?

¡Tienes lo necesario para la siguiente sección del tutorial!

Data Visualization using Python, Matplotlib, and Seaborn

Notebook link: https://jovian.ai/aakashns/python-matplotlib-data-visualization

La visualización de datos es la representación gráfica de los datos. Implica producir imágenes que comuniquen las relaciones entre los datos representados a los espectadores.

La visualización de datos es una parte esencial del análisis de datos y el aprendizaje automático. Usaremos bibliotecas de Python como Matplotlib y Seaborn para aprender y aplicar algunas técnicas populares de visualización de datos.

Para empezar, installemos las bibliotecas en cuestión. Usaremos el módulo matplotlib.pyplot para gáficos sencillos. A menudo se importa con el alias plt.También usaremos el módulo seaborn para gráficos más avanzados. Este a menudo se importa mediante el alias sns.

!pip install matplotlib seaborn --upgrade --quiet

import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

Nótese el comando especial %matplotlib inline para garantizar que nuestros gráficos se muestren e incrusten en el propio cuaderno de Jupyter. Sin este comando, a veces pueden aparecer gráficos en ventanas emergentes.

Cómo crear una gráfica lineal en Python

El gráfico de líneas es una de las técnicas de visualización de datos más simples y más utilizadas. Un gráfico de líneas muestra información como una serie de puntos de datos o marcadores conectados por líneas rectas.
Puede personalizar la forma, el tamaño, el color y otros elementos estéticos de las líneas y los marcadores para una mejor claridad visual.
Aquí hay una lista de Python que muestra el rendimiento de las manzanas (toneladas por hectárea) durante seis años en un país imaginario llamado Kanto.

yield_apples = [0.895, 0.91, 0.919, 0.926, 0.929, 0.931]

Podemos visualizar cómo cambia el rendimiento de las manzanas con el tiempo usando un gráfico de líneas. Para dibujar un gráfico de líneas, podemos usar la función plt.plot .

plt.plot(yield_apples)

Al llamar la función plt.plot  se traza la línea como se esperaba. también incluye la especificación de la línea [<matplotlib.lines.Line2D at 0x7ff70aa20760>]. podemos añadir (;) al final de la declaración en la celda para evitar mostrar eso último y así solo representar la gráfica.

plt.plot(yield_apples);

Mejoremos esta trama paso a paso para que sea más informativa y hermosa.

Cómo personalizar el eje X en MatPlotLib

El eje X de la gráfica actualmente muestra los índices de los elementos de la lista de 0 a 5. La gráfica sería más informativa si pudiéramos mostrar el año para el cual estamos trazando los datos. Podemos hacer esto con dos argumentos plt.plot.

years = [2010, 2011, 2012, 2013, 2014, 2015]
yield_apples = [0.895, 0.91, 0.919, 0.926, 0.929, 0.931]

plt.plot(years, yield_apples)

Axis Labels in MatPlotLib

Podemos agregar etiquetas a los ejes para mostrar lo que representa cada eje usando los métodos plt.xlabel yplt.ylabel.

plt.plot(years, yield_apples)
plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)');

Cómo trazar líneas múltiples en MatPlotLib

Pueden invocar la funciónplt.plot en cada variable, para graficar múltiples líneas en la misma gráfica; cómo se muestra a continuación en el ejemplo de manzanas y naranjas en Kanto.

years = range(2000, 2012)
apples = [0.895, 0.91, 0.919, 0.926, 0.929, 0.931, 0.934, 0.936, 0.937, 0.9375, 0.9372, 0.939]
oranges = [0.962, 0.941, 0.930, 0.923, 0.918, 0.908, 0.907, 0.904, 0.901, 0.898, 0.9, 0.896, ]

plt.plot(years, apples)
plt.plot(years, oranges)
plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)');

Título de gráfica y leyenda en MatPlotLib

Para diferenciar entre múltiples líneas, podemos incluir una leyenda dentro del gráfico usando la función plt.legend también podemos ajustar el título mediante la función plt.title.

plt.plot(years, apples)
plt.plot(years, oranges)

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

Cómo usar marcadores de línea en MatPlotLib

También podemos mostrar marcadores para los puntos de datos en cada línea usando el argumento marcador de  plt.plot.

Matplotlib proporciona muchos marcadores diferentes, como un círculo, una cruz, un cuadrado, un diamante y más. Puedes encontrar la lista completa de tipos de marcadores aquí: https://matplotlib.org/3.1.1/api/markers_api.html .

plt.plot(years, apples, marker='o')
plt.plot(years, oranges, marker='x')

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

Cómo diseñar líneas y marcadores en MatPlotLib

La función plt.plot soporta varios argumentos para dar estilo a las líneas y marcadores:

• color o c – Ajusta el color de la línea (supported colors)
• linestyle o ls – Elije entre una línea sólida o discontinua
• linewidth o lw – Establece el ancho de una línea
• markersize o ms – Fija el tamaño de los marcadores
• markeredgecolor o mec – Establecer el color del borde para los marcadores
• markeredgewidth o mew – Establecer el ancho del borde para los marcadores
• markerfacecolor o mfc – Establecer el color de relleno para los marcadores
• alpha – Opacidad de la gráfica

Puedes ver mayor documentación acerca de Matplotlip y plt.plot aquí: https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html#matplotlib.pyplot.plot .

plt.plot(years, apples, marker='s', c='b', ls='-', lw=2, ms=8, mew=2, mec='navy')
plt.plot(years, oranges, marker='o', c='r', ls='--', lw=3, ms=10, alpha=.5)

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

fmt = '[marker][line][color]'

plt.plot(years, apples, 's-b')
plt.plot(years, oranges, 'o--r')

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

El argumento fmt proporciona una abreviatura para especificar la forma del marcador, el estilo de línea y el color de línea. Puede proporcionarlo como tercer argumento para plt.plot.

Puedes usar la función plt.figure para cambiar el tamaño de la figura.

plt.plot(years, oranges, 'or')
plt.title("Yield of Oranges (tons per hectare)");

Cómo cambiar el tamaño en las gráficas de MatPlotLib

Usa la función plt.figure

plt.figure(figsize=(12, 6))

plt.plot(years, oranges, 'or')
plt.title("Yield of Oranges (tons per hectare)");

Cómo mejorar los estilos predeterminados usando Seaborn

Una manera fácil de hacer que tus gráficos se vean hermosos es usar algunos estilos predeterminados de la biblioteca Seaborn. Puede aplicarlos globalmente usando la función sns.set_style. Puede ver una lista completa de estilos predefinidos aquí: https://seaborn.pydata.org/generated/seaborn.set_style.html .

sns.set_style("whitegrid")
plt.plot(years, apples, 's-b')
plt.plot(years, oranges, 'o--r')

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

sns.set_style("darkgrid")

plt.plot(years, apples, 's-b')
plt.plot(years, oranges, 'o--r')

plt.xlabel('Year')
plt.ylabel('Yield (tons per hectare)')

plt.title("Crop Yields in Kanto")
plt.legend(['Apples', 'Oranges']);

plt.plot(years, oranges, 'or')
plt.title("Yield of Oranges (tons per hectare)");

También puedes editar estilos predeterminados directamente modificando el diccionario matplotlib.rcParams. Aprende más: https://matplotlib.org/3.2.1/tutorials/introductory/customizing.html#matplotlib-rcparams .

import matplotlib

matplotlib.rcParams['font.size'] = 14
matplotlib.rcParams['figure.figsize'] = (9, 5)
matplotlib.rcParams['figure.facecolor'] = '#00000000'

Gráficos de Dispersión en MatPlotLib

En un diagrama de dispersión, los valores de 2 variables se representan como puntos en una cuadrícula bidimensional. Además, también puede utilizar una tercera variable para determinar el tamaño o el color de los puntos. Probemos un ejemplo.

Usando información de la Iris flower dataset obtenermos  medidas de muestra de sépalos y pétalos para tres especies de flores. El conjunto de datos de Iris se incluye con la biblioteca de Seaborn y puedes cargarlo como un DataFrame de Pandas.

# Load data into a Pandas dataframe
flowers_df = sns.load_dataset("iris")

flowers_df

flowers_df.species.unique()
# array(['setosa', 'versicolor', 'virginica'], dtype=object)

Tratemos de visualizar la relación entre la longitud del sépalo y el ancho del sépalo. Nuestro primer instinto podría ser crear un gráfico de líneas usando plt.plot.

plt.plot(flowers_df.sepal_length, flowers_df.sepal_width);

El resultado no es muy informativo ya que hay demasiadas combinaciones de las dos propiedades dentro del conjunto de datos. No parece haber una relación simple entre ellos.

Podemos usar un diagrama de dispersión para visualizar cómo varía la longitud y el ancho del sépalo usando la función scatterplot de seaborn ( sns).

sns.scatterplot(x=flowers_df.sepal_length, y=flowers_df.sepal_width);

Cómo agregar tonos en MatPlotLib

Observa cómo los puntos en el gráfico anterior parecen formar grupos distintos con algunos valores atípicos. Podemos colorear los puntos usando la especie de flor como matiz. También podemos agrandar los puntos usando el argumento s .

sns.scatterplot(x=flowers_df.sepal_length, y=flowers_df.sepal_width, hue=flowers_df.species, s=100);

Agregar matices hace que la trama sea más informativa. Inmediatamente podemos decir que los iris de Setosa tienen una longitud de sépalo más pequeña pero un ancho de sépalo más alto. Por el contrario, lo contrario es cierto para los lirios Virginica.

Cómo personalizar las gráficas de Seaborn

Dado que Seaborn usa internamente las funciones de trazado de Matplotlib, podemos usar funciones como plt.figure y plt.title para modificar la gráfica.

plt.figure(figsize=(12, 6))
plt.title('Sepal Dimensions')

sns.scatterplot(x=flowers_df.sepal_length, 
                y=flowers_df.sepal_width, 
                hue=flowers_df.species,
                s=100);

Cómo trazar datos usando marcos de datos de Pandas con Seaborn

Seaborn tiene soporte integrado para marcos de datos de Pandas. En lugar de pasar cada columna como una serie, puede proporcionar nombres de columna y usar el argumento data para especificar un DataFrame.

plt.title('Sepal Dimensions')
sns.scatterplot(x='sepal_length', 
                y='sepal_width', 
                hue='species',
                s=100,
                data=flowers_df);

Histogramas en MatPlotLib

Un histograma representa la distribución de una variable creando contenedores (intervalos) a lo largo del rango de valores y mostrando barras verticales para indicar el número de observaciones en cada contenedor (bin).

Por ejemplo, visualicemos la distribución de valores de ancho de sépalo en el conjunto de datos Iris.Podemos usar la función plt.hist para crear un histograma.

# Load data into a Pandas dataframe
flowers_df = sns.load_dataset("iris")

flowers_df.sepal_width
# 0      3.5
# 1      3.0
# 2      3.2
# 3      3.1
# 4      3.6
#       ... 
# 145    3.0
# 146    2.5
# 147    3.0
# 148    3.4
# 149    3.0
# Name: sepal_width, Length: 150, dtype: float64

plt.title("Distribution of Sepal Width")
plt.hist(flowers_df.sepal_width);

Inmediatamente podemos ver que los anchos de los sépalos se encuentran en el rango de 2,0 a 4,5, y alrededor de 35 valores están en el rango de 2,9 a 3,1, que parece ser el contenedor más poblado.

Cómo controlar el tamaño y la cantidad de contenedores

Podemos controlar el número de contenedores (bins), así como el tamaño de cada uno usando el argumento bins.

# Specifying the number of bins
plt.hist(flowers_df.sepal_width, bins=5);

import numpy as np

# Specifying the boundaries of each bin
plt.hist(flowers_df.sepal_width, bins=np.arange(2, 5, 0.25));

# Bins of unequal sizes
plt.hist(flowers_df.sepal_width, bins=[1, 3, 4, 4.5]);

Cómo gestionar múltiples Histogramas en MatPlotLib

Similar a los gráficos de líneas, podemos dibujar varios histogramas en un solo gráfico. Podemos reducir la opacidad de cada histograma para que las barras de un histograma no oculten las de los demás.
Dibujemos histogramas separados para cada especie de flores.

setosa_df = flowers_df[flowers_df.species == 'setosa']
versicolor_df = flowers_df[flowers_df.species == 'versicolor']
virginica_df = flowers_df[flowers_df.species == 'virginica']

plt.hist(setosa_df.sepal_width, alpha=0.4, bins=np.arange(2, 5, 0.25));
plt.hist(versicolor_df.sepal_width, alpha=0.4, bins=np.arange(2, 5, 0.25));

También podemos apilar varios histogramas uno encima del otro.

plt.title('Distribution of Sepal Width')

plt.hist([setosa_df.sepal_width, versicolor_df.sepal_width, virginica_df.sepal_width], 
         bins=np.arange(2, 5, 0.25), 
         stacked=True);

plt.legend(['Setosa', 'Versicolor', 'Virginica']);

Gráficos de Barra en MatPlotLib

Los gráficos de barras son bastante similares a los gráficos de líneas, es decir, muestran una secuencia de valores. Sin embargo, se muestra una barra para cada valor, en lugar de puntos conectados por líneas. Podemos usar la función plt.bar para graficarlos.

years = range(2000, 2006)
apples = [0.35, 0.6, 0.9, 0.8, 0.65, 0.8]
oranges = [0.4, 0.8, 0.9, 0.7, 0.6, 0.8]

plt.bar(years, oranges);

Al igual que en los histogramas; si queremos los resultados de las variables uno encima de otro (color anaranjado y azul). Usamos el argumento bottom de plt.bar para lograrlo.

plt.bar(years, apples)
plt.bar(years, oranges, bottom=apples);

Gráficos de Barra con promedios en Seaborn

Veamos otro conjunto de datos de muestra incluido con Seaborn llamado tips. El conjunto de datos contiene información sobre el sexo, la hora del día, la factura total y el monto de la propina para los clientes que visitan un restaurante durante una semana.

tips_df = sns.load_dataset("tips");

tips_df

Es posible que deseemos dibujar un gráfico de barras para visualizar cómo varía el monto promedio de la factura en los diferentes días de la semana. Una forma de hacer esto sería calcular los promedios diarios y luego usar  plt.bar (puedes intentarlo como ejercicio).

Sin embargo, dado que este es un caso de uso muy común, la biblioteca Seaborn proporciona una función barplot que calcula los promedios automáticamente.

sns.barplot(x='day', y='total_bill', data=tips_df);

Las líneas que cortan cada barra representan la cantidad de variación en los valores. Por ejemplo, parece que la variación en la factura total es relativamente alta los viernes y baja los sábados.

Podemos también especificar mediante el argumento hue a fin de realizar comparaciones con una tercera categoría, por ejemplo, por género.

sns.barplot(x='day', y='total_bill', hue='sex', data=tips_df);

Puede hacer que las barras sean horizontales simplemente cambiando los ejes.

sns.barplot(x='total_bill', y='day', hue='sex', data=tips_df);

Heatmaps en Seaborn

Un mapa de calor se usa para visualizar datos bidimensionales como una matriz o una tabla usando colores. La mejor manera de entenderlo es mirando un ejemplo.

Usaremos otro conjunto de datos de muestra de Seaborn, llamado flights, para visualizar el paso mensual de pasajeros en un aeropuerto durante 12 años.

flights_df = sns.load_dataset("flights").pivot("month", "year", "passengers")

flights_df

flights_df es una matriz con una fila para cada mes y una columna para cada año. Los valores muestran el número de pasajeros (en miles) que visitaron el aeropuerto en un mes específico del año. Podemos usar la función sns.heatmap para visualizar esto.

plt.title("No. of Passengers (1000s)")
sns.heatmap(flights_df);

Los colores más brillantes indican una pisada más alta en el aeropuerto. Mirando el gráfico, podemos inferir dos cosas:

1.La afluencia en el aeropuerto en un año determinado tiende a ser más alta alrededor de julio y agosto.
2.La afluencia en el aeropuerto en un mes determinado tiende a crecer año tras año.

También podemos mostrar los valores actuales especificando annot=True y usando el argumentocmap para cambiar el color.

plt.title("No. of Passengers (1000s)")
sns.heatmap(flights_df, fmt="d", annot=True, cmap='Blues');

Imágenes in MatPlotLib

También podemos usar Matplotlib para mostrar imágenes. Descarguemos una imagen de internet.

from urllib.request import urlretrieve

urlretrieve('https://i.imgur.com/SkPbq.jpg', 'chart.jpg');

Antes de mostrar una imagen, debe leerse en la memoria usando el módulo PIL.

from PIL import Image

img = Image.open('chart.jpg')

Una imagen cargada con PIL es simplemente una matriz numpy tridimensional que contiene intensidades de píxeles para los canales rojo, verde y azul (RGB) de la imagen. Podemos convertir la imagen en una matriz usando np.array.

img_array = np.array(img)

img_array.shape
# (481, 640, 3)

Por último, presentamos la imagen usando plt.imshow.

plt.imshow(img);

Podemos desactivar los ejes y las líneas de cuadrícula y mostrar un título usando las funciones relevantes.

plt.grid(False)
plt.title('A data science meme')
plt.axis('off')
plt.imshow(img);

Para mostrar una parte de la imagen, simplemente podemos seleccionar un segmento de la matriz numpy.

plt.grid(False)
plt.axis('off')
plt.imshow(img_array[125:325,105:305]);

Cómo trazar gráficos múltiples en una cuadrícula en MatPlotLib y Seaborn

Matplotlib y Seaborn también admiten el trazado de múltiples gráficos en una cuadrícula, usando plt.subplots, que devuelve un conjunto de ejes para trazar.

Aquí hay una cuadrícula unificada que muestra los diferentes tipos de gráficos que hemos cubierto en este tutorial.

fig, axes = plt.subplots(2, 3, figsize=(16, 8))

# Use the axes for plotting
axes[0,0].plot(years, apples, 's-b')
axes[0,0].plot(years, oranges, 'o--r')
axes[0,0].set_xlabel('Year')
axes[0,0].set_ylabel('Yield (tons per hectare)')
axes[0,0].legend(['Apples', 'Oranges']);
axes[0,0].set_title('Crop Yields in Kanto')


# Pass the axes into seaborn
axes[0,1].set_title('Sepal Length vs. Sepal Width')
sns.scatterplot(x=flowers_df.sepal_length, 
                y=flowers_df.sepal_width, 
                hue=flowers_df.species, 
                s=100, 
                ax=axes[0,1]);

# Use the axes for plotting
axes[0,2].set_title('Distribution of Sepal Width')
axes[0,2].hist([setosa_df.sepal_width, versicolor_df.sepal_width, virginica_df.sepal_width], 
         bins=np.arange(2, 5, 0.25), 
         stacked=True);

axes[0,2].legend(['Setosa', 'Versicolor', 'Virginica']);

# Pass the axes into seaborn
axes[1,0].set_title('Restaurant bills')
sns.barplot(x='day', y='total_bill', hue='sex', data=tips_df, ax=axes[1,0]);

# Pass the axes into seaborn
axes[1,1].set_title('Flight traffic')
sns.heatmap(flights_df, cmap='Blues', ax=axes[1,1]);

# Plot an image using the axes
axes[1,2].set_title('Data Science Meme')
axes[1,2].imshow(img)
axes[1,2].grid(False)
axes[1,2].set_xticks([])
axes[1,2].set_yticks([])

plt.tight_layout(pad=2);

Para saber más: https://matplotlib.org/3.3.1/api/axes_api.html#the-axes-class .

Gráficas por pares de características con Seaborn

Seaborn usa una función de ayuda sns.pairplot para representar múltiples gráficas por pares de características dentro de un DataFrame.

sns.pairplot(flowers_df, hue='species');

sns.pairplot(tips_df, hue='sex');

Resumen y lectura adicional

Hemos cubierto los siguientes temas en este tutorial:

• Cómo crear y personalizar gráficos de líneas usando Matplotlib
• Cómo visualizar relaciones entre dos o más variables usando diagramas de dispersión
• Cómo estudiar distribuciones de variables utilizando histogramas y gráficos de barras
• Cómo visualizar datos bidimensionales usando heatmaps
• Cómo mostrar imágenes en Matplotlib mediante plt.imshow
• Cómo graficar múltiples gráficas en Matplotlib y Seaborn.

En este tutorial, cubrimos algunos de los conceptos fundamentales y técnicas populares para la visualización de datos usando Matplotlib y Seaborn. La visualización de datos es un campo muy amplio y apenas hemos arañado la superficie aquí. Consulta estas referencias para aprender y descubrir más:

• Visualización de Datos: https://jovian.ml/aakashns/dataviz-cheatsheet
• Seaborn: https://seaborn.pydata.org/examples/index.html
• Matplotlib: https://matplotlib.org/3.1.1/gallery/index.html
• Matplotlib tutorial: https://github.com/rougier/matplotlib-tutorial

Preguntas de revisión para verificar tu comprensión

Intente responder las siguientes preguntas para evaluar su comprensión de los temas tratados en este cuaderno.:

1. ¿Qué es la visualización de datos?
2. ¿Qué es Matplotlib?
3. ¿Qué es Seaborn?
4. ¿Cómo se instala Matplotlib y Seaborn?
5. ¿Cómo importas Matplotlib y Seaborn? ¿Cuáles son los alias comunes que se utilizan al importar estos módulos?
6. ¿Cuál es el propósito de %matplotlib inline?
7. ¿Qué es un gráfico de líneas?
8. ¿Cómo se traza un gráfico de líneas en Python? Ilustre con un ejemplo.
9. ¿Cómo se especifican los valores para el eje X de un gráfico de líneas?
10. ¿Cómo se especifican las etiquetas para los ejes de un gráfico?
11. ¿Cómo se trazan gráficos de líneas múltiples en los mismos ejes?
12. ¿Cómo se muestra una leyenda para un gráfico de líneas con varias líneas
13. ¿Cómo se establece un título para un gráfico?
14. ¿Cómo se muestran los marcadores en un gráfico de líneas?
15. ¿Cuáles son las diferentes opciones para diseñar líneas y marcadores en gráficos de líneas? Ilustrar con ejemplos.
16. ¿Cuál es el propósito del argumento fmt para plt.plot?
17. ¿Donde puedes ver una lista de argumentos que se pueden utilizar en plt.plot?
18. ¿Cómo cambias el tamaño de una figura en Matplotlib?
19. ¿Cómo aplica los estilos predeterminados de Seaborn globalmente para todos los gráficos?
20. ¿Cuáles son los estilos predefinidos disponibles en Seaborn? Ilustrar con ejemplos.
21. ¿Qué es un diagrama de dispersión?
22. ¿En qué se diferencia un diagrama de dispersión de un gráfico de líneas?
23. ¿Cómo dibujas un diagrama de dispersión usando Seaborn? Ilustre con un ejemplo.
24. ¿Cómo decide cuándo usar un gráfico de dispersión frente a un gráfico de líneas?
25. ¿Cómo se especifican los colores de los puntos en un diagrama de dispersión usando una variable categórica?
26. ¿Cómo se personaliza el título, el tamaño de la figura, la leyenda y el hijo de las tramas de Seaborn?
27. ¿Cómo usas sns.scatterplot en un DataFrame de Pandas?
28. ¿Qué es un Histograma?
29. ¿Cuándo debes usar un histograma vs un gráfico lineal?
30. ¿Cómo se dibuja un histograma usando Matplotlib? Ilustre con un ejemplo.
31. ¿Qué son los "contenedores" en un histograma?
32. ¿Cómo se cambian los tamaños de los contenedores en un histograma?
33. ¿Cómo se cambia el número de contenedores en un histograma?
34. ¿Cómo se muestran varios histogramas en los mismos ejes?
35. ¿Cómo se apilan varios histogramas uno encima del otro?
36. ¿Qué es un gráfico de barras?
37. ¿Cómo se dibuja un gráfico de barras usando Matplotlib? Ilustre con un ejemplo.
38. ¿Cuál es la diferencia entre un gráfico de barras y un histograma?
39. ¿Cuál es la diferencia entre un gráfico de barras y un gráfico de líneas?
40. ¿Cómo se apilan las barras una encima de la otra?
41. ¿Cuál es la diferencia entre plt.bar y sns.barplot?
42. ¿Qué representan las líneas en las barras de un gráfico de Seaborn?
43. ¿Cómo se muestran gráficos de barras uno al lado del otro?
44. ¿Cómo se dibuja un gráfico de barras horizontales?
45. ¿Qué es un mapa de calor?
46. ¿Qué tipo de datos se visualiza mejor con un mapa de calor?
47. ¿Qué hace el método de pivote de un marco de datos de Pandas?
48. ¿Cómo se dibuja un mapa de calor usando Seaborn? Ilustre con un ejemplo.
49. ¿Cómo se cambia el esquema de color de un mapa de calor?
50. ¿Cómo se muestran los valores originales del conjunto de datos en un mapa de calor?
51. ¿Cómo se descargan imágenes de una URL en Python?
52. ¿Cómo abres una imagen para procesarla en Python?
53. ¿Cuál es el propósito del módulo PIL en Python?
54. ¿Cómo convierte una imagen cargada usando PIL en una matriz Numpy?
55. ¿Cuántas dimensiones tiene una matriz Numpy para una imagen? ¿Qué representa cada dimensión?
56. ¿Qué son los "canales de color" en una imagen?
57. ¿Qué es RGB?
58. ¿Cómo se muestra una imagen usando Matplotlib?
59. ¿Cómo se desactivan los ejes y las líneas de cuadrícula en un gráfico?
60. ¿Cómo se muestra una parte de una imagen usando Matplotlib?
61. ¿Cómo traza múltiples gráficos en una cuadrícula usando Matplotlib y Seaborn? Ilustrar con ejemplos.
62. ¿Cuál es el propósito de la función plt.subplots?
63. ¿Qué son las parcelas de pares en Seaborn? Ilustra con un ejemplo.
64. ¿Cómo se exporta un gráfico a un archivo de imagen PNG usando Matplotlib?
65. ¿Dónde puede obtener información sobre los diferentes tipos de gráficos que puede crear con Matplotlib y Seaborn?

¡Felicitaciones por llegar al final de este tutorial! Ahora puedes aplicar estas habilidades para analizar conjuntos de datos del mundo real de fuentes como Kaggle.