Organizar datos con pandas I¶

import pandas as pd
import numpy as np

Multi-índice en dataframe¶

Crear un dataframe con multi-índice¶

Los dataframes pueden tener varios índices y varios nombres de columna, para esto se usa la clase de pandas MultiIndex. Estos se pueden crear a partir de una lista de tuplas, con el método drom_tuples, donde cada tupla contiene los nombres de cada columna o a partir de una combinación entre varias tuplas con el método from_product

columns = pd.MultiIndex.from_tuples([('A', 'positivo'), ('B', 'positivo'), 
                                     ('A', 'negativo'), ('B', 'negativo'), 
                                     ('O', 'positivo')], 
                                     names=['tipo', 'Rh'])
index = pd.MultiIndex.from_product([('menor', 'adulto'),('hombre', 'mujer')], 
                                   names=['edad', 'sexo'])
df = pd.DataFrame(np.random.randn(4,5), columns=columns, index=index)
df

Obtener información de un dataframe multi-índex¶

Columnas¶

Para obtener la información de una columna se usa el formato corriente, dataframe[nombre_col], siempre y cuando el nombre de la columna pertenezca a una columna de primer nivel, es decir, la primera fila de nombres de columnas.

df['A']

Para obtener información de las columnas de otros niveles, se debe referir primero la columna de primer nivel y luego a las de los niveles siguientes, en órden jerárquico.

df['B', 'positivo']

edad    sexo  
menor   hombre   -1.048591
        mujer    -0.541011
adulto  hombre    0.346534
        mujer     0.254588
Name: (B, positivo), dtype: float64

Filas¶

Las filas se obtienen usando los métodos loc, iloc y ix. De igual forma que las columnas, se acata el orden jerárquico hasta llegar a los datos deseados.

df.loc['adulto']

df.loc['adulto', 'mujer']

tipo  Rh      
A     positivo   -1.183561
B     positivo    0.254588
A     negativo    0.546878
B     negativo    1.816080
O     positivo    1.309236
Name: (adulto, mujer), dtype: float64

Por posición:

df.iloc[0]

tipo  Rh      
A     positivo   -1.807191
B     positivo   -1.048591
A     negativo    0.458959
B     negativo    0.349050
O     positivo    0.682837
Name: (menor, hombre), dtype: float64

df.iloc[0, 1]

-1.0485906955417377

Slice (seleccionar secciones del dataframe)¶

df

df.iloc[1:3]

General¶

Para obtener información sea de filas o columnas de cualquier nivel se usa el método xs. Se especifica el nombre de la columna y el nombre del nivel al que pertenece, para buscar por columna se agrega axis=1.

df.xs('mujer', level='sexo')

df.xs('negativo', level='Rh', axis=1)

Si se quiere mantener la información de los otros niveles a los que pertenece esta información se usa el argumento drop_level=False

df.xs('negativo', level='Rh', axis=1 , drop_level=False)

Stack¶

El método stack permite reordenar los datos que tienen iguales atributos con igual nombre de columna en el dataframe. Por ejemplo si se tienen algún tipo de resultados para varios tipos de sangre, los tipos pueden ser diferentes pero pueden compartir el Rh, ese sería un atributo en común. También es uno de los métodos para manipular dataframe con varios nombres de columna.

# Si no se le indica los nombres de columna que convertirá en índice este 
# toma el último nivel de columna en este caso "tipo" es el primer nivel 
# y "Rh" el segundo.
df.stack()

df.stack('tipo')

# Se convierten los dos nombres de columna a índice tomando como principal a "tipo" y 
# "Rh" como una clasificación interna de este.
df_st = df.stack(level=['tipo','Rh'])
df_st

edad    sexo    tipo  Rh      
menor   hombre  A     negativo    0.458959
                      positivo   -1.807191
                B     negativo    0.349050
                      positivo   -1.048591
                O     positivo    0.682837
        mujer   A     negativo   -0.628476
                      positivo   -0.769500
                B     negativo   -0.847258
                      positivo   -0.541011
                O     positivo   -0.576029
adulto  hombre  A     negativo    1.641367
                      positivo    0.083071
                B     negativo    0.563324
                      positivo    0.346534
                O     positivo    0.806927
        mujer   A     negativo    0.546878
                      positivo   -1.183561
                B     negativo    1.816080
                      positivo    0.254588
                O     positivo    1.309236
dtype: float64

# Ahora "tipo" como una clasificación interna de "Rh"
df.stack(level=['Rh','tipo'])

edad    sexo    Rh        tipo
menor   hombre  negativo  A       0.458959
                          B       0.349050
                positivo  A      -1.807191
                          B      -1.048591
                          O       0.682837
        mujer   negativo  A      -0.628476
                          B      -0.847258
                positivo  A      -0.769500
                          B      -0.541011
                          O      -0.576029
adulto  hombre  negativo  A       1.641367
                          B       0.563324
                positivo  A       0.083071
                          B       0.346534
                          O       0.806927
        mujer   negativo  A       0.546878
                          B       1.816080
                positivo  A      -1.183561
                          B       0.254588
                          O       1.309236
dtype: float64

Obtener y filtrar datos de un dataframe¶

Existen varios métodos para seleccionar los datos requeridos de un dataframe. Cuando se maneja gran cantidad de datos es importante el método que se usa, puesto que algunos son mas eficientes que otros. Se usará un dataframe creado a partir de datos creados al azar para mostrar las diferencias entre los métodos.

import pandas as pd
import random
import numpy as np
import datetime as dt

# Se generan datos de ejemplo, un dataframe de 4 columnas y 1000 filas
rnd_1 = [random.randrange(1,20) for x in xrange(1000)]
rnd_2 = [random.randrange(1,20) for x in xrange(1000)]
rnd_3 = [random.randrange(1,20) for x in xrange(1000)]
fecha = pd.date_range('2012-4-10', '2015-1-4')

data = pd.DataFrame({'fecha':fecha, 'rnd_1': rnd_1, 'rnd_2': rnd_2, 'rnd_3': rnd_3})

Alguna información general sobre el dataframe creado

data.describe()

Filtro booleano¶

Es posible filtrar cualquier columna a partir de la comparación con un dato de referencia, por ejemplo, se filtran las filas para valores de la columna rnd_1 menores o iguales a 5.

data_filter = data[data['rnd_1'] <= 5]

# Se visualizan los primeros diez datos resultantes del filtro
data_filter.head(10)

Se pueden realizar dos filtros simultáneos: Se seleccionan las filas cuyos valores de la columna 'rnd_2' son iguales a 2 y los valores de la columna 'rnd_3' son mayores que 15

data[(data['rnd_2'] == 2) & (data['rnd_3'] > 15)]

Los siguientes métodos usan el índice para seleccionar los datos, por lo que en ocasiones se requiere tomar la columna sobre la que se quiere filtrar la información y convertirla en el índice del dataframe. Para esto se usará el método set_index.

set_index
Argumentos:
keys: Nombre de la columna que se convertirá en índice. string
drop: Elimina la columna que se usará como índice. False por defecto.
append: Sirve para conservar el índice que tiene el dataframe y agregarle uno nuevo. False por defecto.
inplace: Modifica el dataframe sobre el que se trabaja, no crea copia. False por defecto.

Método loc¶

Se seleccionan los datos del 2 al 4 en el índice y las columnas 'rnd_2' y fecha

data.loc[2:4, ['rnd_2', 'fecha']]

Para seleccionar los datos entre dos fechas determinadas

data_fecha = data.set_index('fecha')
data_fecha.head()

Se seleccionan los datos desde el 2013-04-14 a 2013-04-18

# Se crean las fechas con la librería datetime
fecha_1 = dt.datetime(2013, 4, 14)
fecha_2 = dt.datetime(2013, 4, 18)

# Filtro por fecha
data_fecha.loc[fecha_1: fecha_2]

Para usar este método los valores del filtro, en este caso fecha_1 y fecha_2, deben estar en el índice del dataframe

Para seleccionar un valor del dataframe

data_fecha.loc[fecha_1,'rnd_1']

6

Método at¶

Funciona de la misma forma que el método loc, siendo at un método de acceso rápido a un dato

data_fecha.at[fecha_1,'rnd_1']

6

timeit data_fecha.at[fecha_1,'rnd_1']

The slowest run took 9.44 times longer than the fastest. This could mean that an intermediate result is being cached 
100000 loops, best of 3: 4.02 µs per loop

timeit data_fecha.loc[fecha_1,'rnd_1']

10000 loops, best of 3: 82.9 µs per loop

Método iloc¶

Con el método iloc no importan cuales sean los valores del índice, este selecciona por la posición. Por ejemplo para seleccionar los datos de la posición 10 a 15:

data_fecha[10: 15]

Las columnas también son referidas por posición con números enteros comenzando desde el 0

# Se seleccionan las columnas rnd_2 y rnd_3 y se imprimen los primeros 5 datos
# En este caso los dos puntos quiere decir que se seleccionan todas las filas
data_fecha.iloc[:,[1,2]].head()

Se seleccionan las filas 1, 12, 34 y las columnas 0 y 2

data_fecha.iloc[[1,12,34],[0,2]]

Se usa la misma notación si se quiere seleccionar un solo valor y no un dataframe

data_fecha.iloc[1,0]

1

Método iat¶

Funciona de la misma forma que el método iloc, siendo iat un método de acceso rápido a un dato

data_fecha.iat[1,0]

1

timeit data_fecha.iat[1,0]

The slowest run took 6.74 times longer than the fastest. This could mean that an intermediate result is being cached 
100000 loops, best of 3: 10.8 µs per loop

timeit data_fecha.iloc[1,0]

10000 loops, best of 3: 66 µs per loop

Método ix¶

Este método facilita la selección de datos, puesto que permite filtrar con valores que no se encuentran en el dataframe. Los datos de la columna fecha fueron creados desde '2012-4-10' hasta '2015-1-4' con el formato aaaa-mm-dd. Si se necesita hacer un filtro con dos fechas que tienen la hora, los métodos anteriores no son de utilidad puesto que estos valores no se encuentran en el índice.

fecha_1 = dt.datetime(2013, 1, 10, 8, 30)
fecha_2 = dt.datetime(2013, 1, 13, 4, 20)

# Filtro por fecha
data_fecha.ix[fecha_1: fecha_2]

Como se ve en el dataframe resultante el dato de la fecha 2013-01-10 no se toma porque se considera previo al rango de fechas dado.

Trabajar con datos NaN en dataframe¶

Se crea un dataframe con datos vacíos para generar los NaN, en este caso se agregan datos tipo None a la lista, que es el equivalente a leer un archivo de Excel o de un csv en los que faltan valores.

import pandas as pd

df = pd.DataFrame({'a':[None, 3, None, 5, 6], 'b':[1, 3, 4, 6, None], 'c':[54, None, None, 32, 21]})
print df

    a   b   c
0 NaN   1  54
1   3   3 NaN
2 NaN   4 NaN
3   5   6  32
4   6 NaN  21

[5 rows x 3 columns]

Reconocer los valores NaN¶

Con este comando devuelve una tabla booleana con True si el valor es un NaN o False si no lo es.

df_bool = pd.isnull(df)
print df_bool

       a      b      c
0   True  False  False
1  False  False   True
2   True  False   True
3  False  False  False
4  False   True  False

[5 rows x 3 columns]

Eliminar todos los NaN del dataframe¶

Este comando elimina todas las filas que contengan un valor NaN

df_sin_nan = df.dropna(how='any')
print df_sin_nan

   a  b   c
3  5  6  32

[1 rows x 3 columns]

Rellenar NaN del dataframe¶

Asignando un valor¶

Es posible dar un valor específico a los NaN. En la siguiente línea se reemplazan todos los NaN por 3

df_nuevo = df.fillna(value=3)
print df_nuevo

   a  b   c
0  3  1  54
1  3  3   3
2  3  4   3
3  5  6  32
4  6  3  21

[5 rows x 3 columns]

Reemplazar los NaN con el valor promedio de cada columna:

df_nuevo = df.fillna(df.mean())
print df_nuevo

          a    b          c
0  4.666667  1.0  54.000000
1  3.000000  3.0  35.666667
2  4.666667  4.0  35.666667
3  5.000000  6.0  32.000000
4  6.000000  3.5  21.000000

[5 rows x 3 columns]

Con los valores vecinos¶

Reemplazar los NaN con el valor anterior o posterior del NaN: 'pad' para reemplazarlo con el valor anterior y 'bfill' con el posterior. Se reemplazan todos los NaN, pero se puede establecer un límite según la distancia de este con el último dato del dataframe. Esta distancia se especifica en limit:

df_nuevo = df.fillna(method='bfill', limit=1)
print df_nuevo

   a   b   c
0  3   1  54
1  3   3 NaN
2  5   4  32
3  5   6  32
4  6 NaN  21

[5 rows x 3 columns]

Sin el límite:

df_nuevo = df.fillna(method='pad')
print df, '\n'
print df_nuevo

    a   b   c
0 NaN   1  54
1   3   3 NaN
2 NaN   4 NaN
3   5   6  32
4   6 NaN  21

[5 rows x 3 columns] 

    a  b   c
0 NaN  1  54
1   3  3  54
2   3  4  54
3   5  6  32
4   6  6  21

[5 rows x 3 columns]

Interpolando¶

Para reemplazar los NaN interpolando con el resto de datos conocidos se usa la función interpolate:

df_inter = df.interpolate(method='linear')
print df_inter

    a  b          c
0 NaN  1  54.000000
1   3  3  46.666667
2   4  4  39.333333
3   5  6  32.000000
4   6  6  21.000000

[5 rows x 3 columns]

Otros métodos de interpolación
method : ‘linear’, ‘time’, ‘index’, ‘values’, ‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’, ‘barycentric’, ‘krogh’, ‘polynomial’, ‘spline’ ‘piecewise_polynomial’, ‘pchip’.

Operaciones sobre groupby¶

Agrupar datos de un dataframe¶

import pandas as pd

# se crea el dataframe a partir de un diccionario
df = pd.DataFrame({'a':[2,2,3,3,4,4,4], 'b':[4,3,6,5,4,3,2], 'c':[7,6,5,7,3,8,6]})

print df

   a  b  c
0  2  4  7
1  2  3  6
2  3  6  5
3  3  5  7
4  4  4  3
5  4  3  8
6  4  2  6

[7 rows x 3 columns]

Se agrupan los datos con los elementos de la columna a

group_a = df.groupby('a')

Ahora en group_a se tiene un nombre y un dataframe por cada elemento, sin repetir, de la columna a. El nombre equivale a los valores en a.

Iterar sobre un groupby¶

Los datos en group_a se encuentran como una tupla (nombre, datos), por lo que se itera sobre dos variables:

for nombre, datos in group_a:
    print nombre
    print datos

2
   a  b  c
0  2  4  7
1  2  3  6

[2 rows x 3 columns]
3
   a  b  c
2  3  6  5
3  3  5  7

[2 rows x 3 columns]
4
   a  b  c
4  4  4  3
5  4  3  8
6  4  2  6

[3 rows x 3 columns]

Obtener datos por el nombre¶

Se sabe que los nombres de cada grupo son los valores de la columna a sin repetir: 2, 3 y 4. Se puede obtener los datos con el nombre con el método get_group.

data_2 = group_a.get_group(2)
print data_2

   a  b  c
0  2  4  7
1  2  3  6

[2 rows x 3 columns]

Funciones sobre groupby¶

Usando el método apply se puede aplicar una función sobre un groupby y optener nuevamente un dataframe. Por ejemplo si se requiere calcular la suma de los valores de cada grupo:

data_sum = df.groupby('a').apply(sum)

print data_sum

    a   b   c
a            
2   4   7  13
3   6  11  12
4  12   9  17

[3 rows x 3 columns]

Se puede aplicar sobre los grupos una función previamente creada. Se aplica una función llamada suma_rara que suma las columnas b y c de cada grupo y de ese resultado toma el menor valor a cada grupo.

def suma_rara(dataframe):
    return min(dataframe['c'] + dataframe['b'])

data = df.groupby('a').apply(suma_rara)

print data

a
2     9
3    11
4     7
dtype: int64

Método agg¶

Se usa cuando se requiere un dataframe con valores específicos del grupo, por ejemplo para cada grupo de a se toma el primer valor de b y el último de c

data_esp = df.groupby('a').agg({'b':'first', 'c':'last'})

print data_esp

   c  b
a      
2  6  4
3  7  6
4  6  4

[3 rows x 2 columns]

Se pueden tomar en cada grupo mas de un valor por cada columna, en este caso se toma el promedio de los valores de b, el máximo de los valores de b y el mínimo de los valores de c de cada grupo:

data_esp = df.groupby('a').agg({'b':['mean', 'max'], 'c':'min'})

print data_esp

     c     b     
   min  mean  max
a                
2    6   3.5    4
3    5   5.5    6
4    3   3.0    4

[3 rows x 3 columns]

	rnd_1	rnd_2	rnd_3
count	1000.000000	1000.00000	1000.000000
mean	9.904000	10.04800	10.031000
std	5.466321	5.48797	5.478691
min	1.000000	1.00000	1.000000
25%	5.000000	5.00000	5.000000
50%	10.000000	10.00000	10.000000
75%	15.000000	15.00000	15.000000
max	19.000000	19.00000	19.000000