Tutorial para principiantes sobre la biblioteca Python de Pandas

Pandas es un paquete Python de código abierto que proporciona numerosas herramientas para el análisis de datos. El paquete viene con varias estructuras de datos que pueden usarse para muchos...

Pandas es un paquete Python de código abierto que proporciona numerosas herramientas para el análisis de datos. El paquete viene con varias estructuras de datos que se pueden usar para muchas tareas diferentes de manipulación de datos. También tiene una variedad de métodos que se pueden invocar para el análisis de datos, lo que resulta útil cuando se trabaja en problemas de ciencia de datos y aprendizaje automático en Python.

Ventajas de usar pandas

Las siguientes son algunas de las ventajas de la biblioteca de pandas:

  1. Puede presentar datos de una manera adecuada para el análisis de datos a través de sus estructuras de datos ‘Series’ y ‘DataFrame’.
  2. El paquete contiene múltiples métodos para un filtrado de datos conveniente.
  3. Pandas tiene una variedad de utilidades para realizar operaciones de Entrada/Salida de manera transparente. Puede leer datos de una variedad de formatos como CSV, TSV, MS Excel, etc.

Instalación de pandas {#instalación de pandas}

La distribución estándar de Python no viene con el módulo Pandas. Para utilizar este módulo de terceros, debe instalarlo.

Lo bueno de Python es que viene con una herramienta llamada pip que se puede usar para la instalación de Pandas. Para realizar la instalación, debe ejecutar el siguiente comando:

1
$ pip install pandas

Si ha instalado Anaconda en su sistema, simplemente ejecute el siguiente comando para instalar Pandas:

1
$ conda install pandas

Se recomienda encarecidamente que instale la última versión del paquete Pandas. Sin embargo, si desea instalar una versión anterior, puede especificarla ejecutando el comando conda install de la siguiente manera:

1
$ conda install pandas=0.23.4

Estructuras de datos de pandas

Pandas tiene dos estructuras de datos principales para el almacenamiento de datos:

  1. Serie
  2. Marco de datos

Serie

Una serie es similar a un arreglo unidimensional. Puede almacenar datos de cualquier tipo. Los valores de una ‘Serie’ de Pandas son mutables, pero el tamaño de una ‘Serie’ es inmutable y no se puede cambiar.

Al primer elemento de la serie se le asigna el índice 0, mientras que el último elemento está en el índice N-1, donde N es el número total de elementos de la serie.

Para crear una ‘Serie’ de Pandas, primero debemos importar el paquete de Pandas a través del comando ‘importar’ de Python:

1
import pandas as pd

Para crear la Serie, invocamos el método pd.Series() y pasamos una matriz, como se muestra a continuación:

1
series1 = pd.Series([1,2,3,4])

A continuación, ejecute la declaración imprimir para mostrar el contenido de la Serie:

1
print(series1)

Producción:

1
2
3
4
5
0    1
1    2
2    3
3    4
dtype: int64

Puedes ver que tenemos dos columnas, la primera con números a partir del índice 0 y la segunda con los elementos que se agregaron a la serie.

La primera columna indica los índices de los elementos.

Sin embargo, es posible que obtenga un error cuando intente mostrar la Serie. La causa principal de este error es que Pandas busca la cantidad de información para mostrar, por lo tanto, debe proporcionar información de salida del sistema.

Puede resolver el error ejecutando el código de la siguiente manera:

1
2
3
4
5
6
7
import pandas as pd
import sys

sys.__stdout__ = sys.stdout

series1 = pd.Series([1,2,3,4])
print(series1)

También se puede crear una Serie a partir de una matriz entumecido. Vamos a crear una matriz numpy y luego convertirla en una ‘Serie’ de Pandas:

1
2
3
4
5
6
7
8
9
import pandas as pd
import numpy as np
import sys

sys.__stdout__ = sys.stdout

fruits = np.array(['apple','orange','mango','pear'])
series2 = pd.Series(fruits)
print(series2)

Producción:

1
2
3
4
5
0     apple
1    orange
2     mango
3      pear
dtype: object

Comenzamos importando las bibliotecas necesarias, incluida numpy. A continuación, llamamos a la función array() de numpy's para crear una matriz de frutas. Luego usamos la función Series() de Pandas y le pasamos la matriz que queremos convertir en una serie. Finalmente, llamamos a la función print() para mostrar la Serie.

Marco de datos

El DataFrame de Pandas se puede ver como una tabla. Organiza los datos en filas y columnas, lo que los convierte en una estructura de datos bidimensional. Potencialmente, las columnas son de un tipo diferente y el tamaño del DataFrame es mutable y, por lo tanto, se puede modificar.

Para crear un DataFrame, puede elegir comenzar desde cero o convertir otras estructuras de datos como matrices Numpy en un DataFrame. Así es como puede crear un DataFrame desde cero:

1
2
3
4
5
6
7
8
import pandas as pd
df = pd.DataFrame({
    "Column1": [1, 4, 8, 7, 9],
    "Column2": ['a', 'column', 'with', 'a', 'string'],
    "Column3": [1.23, 23.5, 45.6, 32.1234, 89.453],
    "Column4": [True, False, True, False, True]
})
print(df)

Producción:

1
2
3
4
5
6
   Column1 Column2  Column3  Column4
0        1       a   1.2300     True
1        4  column  23.5000    False
2        8    with  45.6000     True
3        7       a  32.1234    False
4        9  string  89.4530     True

En este ejemplo, hemos creado un DataFrame llamado df. La primera columna del DataFrame tiene valores enteros. La segunda columna tiene una cadena, la tercera columna tiene valores de punto flotante, mientras que la cuarta columna tiene valores booleanos.

La instrucción print(df) nos mostrará el contenido del DataFrame a través de la consola, permitiéndonos inspeccionar y verificar su contenido.

Sin embargo, al desplegar el DataFrame, habrás notado que hay una columna adicional al inicio de la tabla, cuyos elementos comienzan en 0. Esta columna se crea automáticamente y marca los índices de las filas.

Para crear un DataFrame, debemos invocar el método pd.DataFrame() como se muestra en el ejemplo anterior.

Es posible para nosotros crear un DataFrame a partir de una lista o incluso de un conjunto de listas. Solo tenemos que llamar al método pd.DataFrame() y luego pasarle la variable de lista como su único argumento.

Considere el siguiente ejemplo:

1
2
3
4
import pandas as pd
mylist = [4, 8, 12, 16, 20]
df = pd.DataFrame(mylist)
print(df)

Producción:

1
2
3
4
5
6
  0
0   4
1   8
2  12
3  16
4  20

En este ejemplo creamos una lista llamada mylist con una secuencia de 5 enteros. Luego llamamos al método DataFrame() y le pasamos el nombre de la lista como argumento. Aquí es donde ocurrió la conversión de la lista a un DataFrame.

Luego hemos impreso el contenido del DataFrame. El DataFrame tiene una columna predeterminada que muestra índices, con el primer elemento en el índice 0 y el último en el índice N-1, donde N es el número total de elementos en el DataFrame.

Aquí hay otro ejemplo:

1
2
3
4
import pandas as pd
items = [['Phone', 2000], ['TV', 1500], ['Radio', 800]]
df = pd.DataFrame(items, columns=['Item', 'Price'], dtype=float)
print(df)

Producción:

1
2
3
4
  Item   Price
0  Phone  2000.0
1     TV  1500.0
2  Radio   800.0

Aquí hemos creado una lista llamada elementos con un conjunto de 3 elementos. Para cada artículo, tenemos un nombre y un precio. Luego, la lista se pasa al método DataFrame() para convertirla en un objeto DataFrame.

En este ejemplo, también se han especificado los nombres de las columnas para el DataFrame. Los valores numéricos también se han convertido en valores de punto flotante desde que especificamos el argumento dtype como "float".

Para obtener un resumen de los datos de este elemento, podemos llamar a la función describe() en la variable DataFrame, es decir, df:

1
df.describe()

Producción:

1
2
3
4
5
6
7
8
9
      Price
count     3.000000
mean   1433.333333
std     602.771377
min     800.000000
25%    1150.000000
50%    1500.000000
75%    1750.000000
max    2000.000000

La función describe() devuelve algunos detalles estadísticos comunes de los datos, incluida la media, la desviación estándar, el elemento mínimo, el elemento máximo y algunos otros detalles. Esta es una excelente manera de obtener una instantánea de los datos con los que está trabajando si el conjunto de datos es relativamente desconocido para usted. También podría ser una buena manera de comparar rápidamente dos conjuntos de datos separados de datos similares.

Importación de datos

Muchas veces necesitará usar Pandas para analizar datos almacenados en un archivo de Excel o en un archivo CSV. Esto requiere que abra e importe los datos de dichas fuentes a Pandas.

Afortunadamente, Pandas nos brinda numerosos métodos que podemos usar para cargar los datos de dichas fuentes en un DataFrame de Pandas.

Importación de datos CSV

Un archivo CSV, que significa valor separado por comas, es simplemente un archivo de texto con valores separados por una coma (,). Dado que este es un estándar muy conocido y de uso frecuente, podemos usar Pandas para leer archivos CSV en su totalidad o en parte.

Para este ejemplo, crearemos un archivo CSV llamado cars.csv. El archivo debe tener los siguientes datos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Number,Type,Capacity
SSD,Premio,1800
KCN,Fielder,1500
USG,Benz,2200
TCH,BMW,2000
KBQ,Range,3500
TBD,Premio,1800
KCP,Benz,2200
USD,Fielder,1500
UGB,BMW,2000
TBG,Range,3200

Puede copiar los datos y pegarlos en un editor de texto como el Bloc de notas y luego guardarlos con el nombre cars.csv en el mismo directorio que sus scripts de Python.

Pandas nos proporciona un método llamado read_csv que se puede usar para leer valores CSV en un DataFrame de Pandas. El método toma la ruta al archivo CSV como argumento.

El siguiente código es lo que usaremos para ayudarnos a leer el archivo cars.csv:

1
2
3
import pandas as pd
data = pd.read_csv('cars.csv')
print(data)

Producción:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
 Number     Type  Capacity
0    SSD   Premio      1800
1    KCN  Fielder      1500
2    USG     Benz      2200
3    TCH      BMW      2000
4    KBQ    Range      3500
5    TBD   Premio      1800
6    KCP     Benz      2200
7    USD  Fielder      1500
8    UGB      BMW      2000
9    TBG    Range      3200

En mi caso, guardé el archivo CSV en el mismo directorio que el script de Python, por lo tanto, simplemente pasé el nombre del archivo al método read_csv y supo verificar el directorio de trabajo actual.

Si ha guardado su archivo en una ruta diferente, asegúrese de pasar la ruta correcta como argumento al método. Puede ser una ruta relativa, como "../cars.csv", o una ruta absoluta como "/Users/nicholas/data/cars.csv".

En algunos casos, puede tener miles de filas en su conjunto de datos. En tal caso, sería más útil imprimir solo las primeras filas en la consola en lugar de imprimir todas las filas.

Esto se puede hacer llamando al método head() en el DataFrame como se muestra a continuación:

1
data.head()

Para nuestros datos anteriores, el comando anterior devuelve solo las primeras 5 filas del conjunto de datos, lo que le permite inspeccionar una pequeña muestra de los datos. Esto se muestra a continuación:

Producción:

1
2
3
4
5
6
  Number     Type  Capacity
0    SSD   Premio      1800
1    KCN  Fielder      1500
2    USG     Benz      2200
3    TCH      BMW      2000
4    KBQ    Range      3500

El método loc() es una buena utilidad que nos ayuda a leer solo ciertas filas de una columna específica en el conjunto de datos, como se demuestra en el siguiente ejemplo:

1
2
3
4
import pandas as pd
data = pd.read_csv('cars.csv')

print (data.loc[[0, 4, 7], ['Type']])

Producción:

1
2
3
4
 Type
0   Premio
4    Range
7  Fielder

Aquí usamos el método loc() para leer solo los elementos en los índices 0, 4 y 7 de la columna Tipo.

A veces, Wwe puede necesitar leer solo ciertas columnas y no otras. Esto también se puede hacer usando el método loc(), que se muestra a continuación en este ejemplo:

1
2
3
4
import pandas as pd
data = pd.read_csv('cars.csv')

print (data.loc[:, ['Type', 'Capacity']])

Producción:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
Type  Capacity
0   Premio      1800
1  Fielder      1500
2     Benz      2200
3      BMW      2000
4    Range      3500
5   Premio      1800
6     Benz      2200
7  Fielder      1500
8      BMW      2000
9    Range      3200

Aquí usamos el método loc() para leer todas las filas (la parte :) de solo dos de nuestras columnas del conjunto de datos, es decir, las columnas Tipo y Capacidad, como se especifica en el argumento.

Importación de datos de Excel

Además del método read_csv, Pandas también tiene la función read_excel que se puede usar para leer datos de Excel en un DataFrame de Pandas. En este ejemplo, usaremos un archivo de Excel llamado workers.xlsx con detalles de los trabajadores de una empresa.

El siguiente código se puede usar para cargar el contenido del archivo de Excel en un DataFrame de Pandas:

1
2
3
import pandas as pd
data = pd.read_excel('workers.xlsx')
print (data)

Producción:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
  ID    Name      Dept  Salary
0   1    John       ICT    3000
1   2    Kate   Finance    2500
2   3  Joseph        HR    3500
3   4  George       ICT    2500
4   5    Lucy     Legal    3200
5   6   David   Library    2000
6   7   James        HR    2000
7   8   Alice  Security    1500
8   9   Bosco   Kitchen    1000
9  10    Mike       ICT    3300

Después de llamar a la función read_excel, pasamos el nombre del archivo como argumento, que read_excel usó para abrir/cargar el archivo y luego analizar los datos. La función print() luego nos ayuda a mostrar el contenido del DataFrame, como lo hemos hecho en ejemplos anteriores.

Y al igual que con nuestro ejemplo de CSV, esta función se puede combinar con el método loc() para ayudarnos a leer filas y columnas específicas del archivo de Excel.

Por ejemplo:

1
2
3
4
import pandas as pd
data = pd.read_excel('workers.xlsx')

print (data.loc[[1,4,7],['Name','Salary']])

Producción:

1
2
3
4
Name  Salary
1   Kate    2500
4   Lucy    3200
7  Alice    1500

Hemos usado el método loc() para recuperar los valores Nombre y Salario de los elementos en los índices 1, 4 y 7.

Pandas también nos permite leer de dos hojas de Excel simultáneamente. Supongamos que nuestros datos anteriores están en la Hoja1 y tenemos otros datos en la Hoja2 del mismo archivo de Excel. El siguiente código muestra cómo podemos leer de las dos hojas simultáneamente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import pandas as pd
with pd.ExcelFile('workers.xlsx') as x:
    s1 = pd.read_excel(x, 'Sheet1')
    s2 = pd.read_excel(x, 'Sheet2')

print("Sheet 1:")
print (s1)
print("")
print("Sheet 2:")
print (s2)

Producción:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Sheet 1:
   ID    Name      Dept  Salary
0   1    John       ICT    3000
1   2    Kate   Finance    2500
2   3  Joseph        HR    3500
3   4  George       ICT    2500
4   5    Lucy     Legal    3200
5   6   David   Library    2000
6   7   James        HR    2000
7   8   Alice  Security    1500
8   9   Bosco   Kitchen    1000
9  10    Mike       ICT    3300

Sheet 2:
   ID    Name  Age  Retire
0   1    John   55    2023
1   2    Kate   45    2033
2   3  Joseph   55    2023
3   4  George   35    2043
4   5    Lucy   42    2036
5   6   David   50    2028
6   7   James   30    2048
7   8   Alice   24    2054
8   9   Bosco   33    2045
9  10    Mike   35    2043

Lo que sucedió es que combinamos la función read_excel() con la clase contenedora ExcelFile. La variable x se creó al llamar a la clase contenedora y la palabra clave with de Python, que usamos para abrir temporalmente el archivo.

A partir de la variable x de ExcelFile, hemos creado dos variables más, s1 y s2 para representar los contenidos que se leyeron de las diferentes hojas.

Luego usamos declaraciones print para ver el contenido de las dos hojas en la consola. La instrucción print en blanco, print(""), solo se usa para imprimir una línea en blanco entre los datos de nuestra hoja.

Gestión de datos {#gestión de datos}

La disputa de datos es el proceso de procesamiento de datos para prepararlos para su uso en el siguiente paso. Los ejemplos de procesos de disputa de datos incluyen fusión, agrupación y concatenación. Este tipo de manipulación a menudo se necesita en la ciencia de datos para obtener sus datos en una forma que funcione bien con cualquier análisis o algoritmo a los que los vaya a someter.

Fusión

La biblioteca Pandas nos permite unir objetos DataFrame a través de la función merge(). Vamos a crear dos DataFrames y demostrar cómo fusionarlos.

Aquí está el primer DataFrame, df1:

1
2
3
4
5
6
7
8
import pandas as pd

d = {
    'subject_id': ['1', '2', '3', '4', '5'],
    'student_name': ['John', 'Emily', 'Kate', 'Joseph', 'Dennis']
}
df1 = pd.DataFrame(d, columns=['subject_id', 'student_name'])
print(df1)

Producción:

1
2
3
4
5
6
subject_id student_name
0          1         John
1          2        Emily
2          3         Kate
3          4       Joseph
4          5       Dennis

Aquí está el código para crear el segundo DataFrame, df2:

1
2
3
4
5
6
7
8
import pandas as pd

data = {
    'subject_id': ['4', '5', '6', '7', '8'],
    'student_name': ['Brian', 'William', 'Lilian', 'Grace', 'Caleb']
}
df2 = pd.DataFrame(data, columns=['subject_id', 'student_name'])
print(df2)

Producción:

1
2
3
4
5
6
subject_id student_name
0          4        Brian
1          5      William
2          6       Lilian
3          7        Grace
4          8        Caleb

Ahora necesitamos fusionar los dos DataFrames, es decir, df1 y df2 junto con los valores de subject_id. Simplemente llamamos a la función merge() como se muestra a continuación:

1
pd.merge(df1, df2, on='subject_id')

Producción:

1
2
3
subject_id student_name_x student_name_y
0          4         Joseph          Brian
1          5         Dennis        William

Lo que hace la fusión es que devuelve las filas de ambos DataFrames con el mismo valor para la columna que está utilizando para la fusión.

Hay muchas otras formas de usar la función pd.merge que no cubriremos en este artículo, como qué datos deben fusionarse, cómo deben fusionarse, si deben ordenarse, etc. Para obtener más información información, consulta la documentación oficial sobre la función de fusión.

Agrupación

La agrupación es el proceso de poner los datos en varias categorías. Aquí hay un ejemplo simple:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
# import pandas library
import pandas as pd

raw = {
    'Name': ['John', 'John', 'Grace', 'Grace', 'Benjamin', 'Benjamin', 'Benjamin',
        'Benjamin', 'John', 'Alex', 'Alex', 'Alex'],
    'Position': [2, 1, 1, 4, 2, 4, 3, 1, 3, 2, 4, 3],
    'Year': [2009, 2010, 2009, 2010, 2010, 2010, 2011, 2012, 2011, 2013, 2013, 2012],
    'Marks':[408, 398, 422, 376, 401, 380, 396, 388, 356, 402, 368, 378]
}
df = pd.DataFrame(raw)

group = df.groupby('Year')
print(group.get_group(2010))

Producción:

1
2
3
4
   Marks      Name  Position  Year
1    398      John         1  2010
3    376     Grace         4  2010
5    380  Benjamin         4  2010

En este sencillo ejemplo, hemos agrupado los datos por año, que en este caso fue 2010. También podríamos haberlos agrupado por cualquiera de las otras columnas, como "Nombre", "Cargo", etc.

Concatenación

La concatenación de datos, que básicamente significa agregar un conjunto de datos a otro, se puede realizar llamando a la función concat().

Demostremos cómo concatenar tramas de datos usando nuestras dos tramas de datos anteriores, es decir, df1 y df2, cada una con dos columnas, "subject_id" y "student_name":

1
print(pd.concat([df1, df2]))

Producción:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
subject_id student_name
0          1         John
1          2        Emily
2          3         Kate
3          4       Joseph
4          5       Dennis
0          4        Brian
1          5      William
2          6       Lilian
3          7        Grace
4          8        Caleb

Estadísticas descriptivas

Como mostré brevemente antes, cuando usamos la función describe() obtenemos las estadísticas descriptivas para las columnas numéricas, pero las columnas de caracteres están excluidas.

Primero creemos un DataFrame que muestre los nombres de los estudiantes y sus puntajes en Matemáticas e Inglés:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import pandas as pd
 
data = {
    'Name': ['John', 'Alice', 'Joseph', 'Alex'],
    'English': [64, 78, 68, 58],
    'Maths': [76, 54, 72, 64]
}

df = pd.DataFrame(data)
print(df)

Producción:

1
2
3
4
5
 English  Maths    Name
0       64     76    John
1       78     54   Alice
2       68     72  Joseph
3       58     64    Alex

Solo tenemos que llamar a la función describe() en el DataFrame y obtener las diversas medidas como la media, la desviación estándar, la mediana, el elemento máximo, el elemento mínimo, etc.:

1
df.describe()

Producción:

1
2
3
4
5
6
7
8
9
   English      Maths
count   4.000000   4.000000
mean   67.000000  66.500000
std     8.406347   9.712535
min    58.000000  54.000000
25%    62.500000  61.500000
50%    66.000000  68.000000
75%    70.500000  73.000000
max    78.000000  76.000000

Como puede ver, el método describe() ignoró por completo la columna "Nombre" ya que no es numérica, que es lo que queremos. Esto simplifica las cosas para la persona que llama, ya que no necesita preocuparse por eliminar columnas no numéricas antes de calcular las estadísticas numéricas que desea.

Conclusión

Pandas es una biblioteca de Python extremadamente útil, especialmente para la ciencia de datos. Varias funcionalidades de Pandas hacen que el preprocesamiento de datos sea extremadamente simple. Este artículo proporciona una breve introducción a las principales funcionalidades de la biblioteca. En este artículo, vimos ejemplos prácticos de todas las principales utilidades de la biblioteca de Pandas. Para aprovechar al máximo Pandas, le sugiero que practique los ejemplos de este artículo y también pruebe la biblioteca con sus propios conjuntos de datos. ¡Feliz codificación!