Transform es método del objeto dataframe de pandas que permite aplicar funciones sobre filas o columnas, tal como un apply, o sobre secciones de dataframe (grupos) y agregar los resultados en el dataframe original, por lo que representa una opción muy poderosa además de los métodos aggregate, filter y apply.

Creado: Julio 5 de 2020
Testeado en:

Python 3.6.4
pandas 0.24.2

Descargar código: https://github.com/vilmauricio/pyciencia/tree/master/pandas

import pandas as pd
import numpy as np

datos¶

Se crea un dataframe de ejemplo con la lista de compras de los clientes, el valor de la compra y el número de artículos llevados en esta

datos = {
    'nombre': ['Carlos', 'María', 'Carlos', 'María', 'María', 'Miguel', 'Miguel', 'Miguel'],
    'compra': [10000, 23000, 32000, 43000, 12000, 45000, 43000, 12000],
    'num_articulos': [2, 3, 1, 4, 3, 2, 4, 2]
}

df = pd.DataFrame(datos)
df

transform vs apply¶

El transform puede aplicar funciones sobre las columnas como un apply

df['num_articulos'].transform(func=['sqrt', 'exp'])

De igual manera se puede obtener este resultado usando apply

df['num_articulos'].apply(['sqrt', 'exp'])

Para este uso no representa una diferencia relevante en tiempo de ejecución respecto al apply

%%timeit
df['num_articulos'].transform(func=['sqrt', 'exp'])

1.36 ms ± 40.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%%timeit
df['num_articulos'].apply(['sqrt', 'exp'])

1.4 ms ± 125 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Pero al realizar una prueba con un dataframe de 10 millones de registros se observa que el apply se ejecuta mas rápido

df_long = pd.DataFrame(np.random.randint(0, 100, size=(10000000, 4)), columns=list('ABCD'))

%%timeit
df_long['A'].transform(func=['sqrt', 'exp'])

496 ms ± 95.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit
df_long['A'].apply(['sqrt', 'exp'])

646 ms ± 201 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Transform posterior a un groupby¶

El uso mas interesante del transform es precisamente aplicar funciones sobre los grupos generados por un groupby y agregar la información resultante en el dataframe original, a diferencia de los métodos aggregate, filter y apply que generan un dataframe diferente en donde cada fila proviene de cada uno de los grupos formados.
Tomando el dataframe

df

Por ejemplo si tomamos este dataframe y agrupamos los datos por el nombre del cliente y estimamos el total de la compra con un aggregation se genera un nuevo dataframe con tres filas, los nombres de los clientes: Carlos, María y Miguel.

df.groupby('nombre').agg({'compra': sum})

Por otro lado, al usar transform se le agrega la columna compra_total con los valores con el total comprado por cada persona al dataframe original. Por ejemplo Carlos realizó 2 compras por un valor total de $10000+320000 = 42000$, por lo que cada fila en donde en la columna nombre esté Carlos tendrá el valor de $42000$ en la columna total_compra.

%time df['total_compra'] = df.groupby('nombre')['compra'].transform(sum)
df

Wall time: 3.5 ms

Esta operación se puede realizar sin usar el transform, por ejemplo:

%time total_compra = df.groupby('nombre')['compra'].sum().rename('total_compra_merge').reset_index()
%time df_1 = df.merge(total_compra)
df_1

Wall time: 3.5 ms
Wall time: 4.5 ms

Otra forma usando agg

%time total_compra = df.groupby('nombre').agg({'compra': sum}).rename(columns={'compra':'total_compra'})
%time df_1 = df.merge(total_compra.reset_index())
df_1

Wall time: 4 ms
Wall time: 6.51 ms

El transform permite realizar las estimaciones de forma mas limpia.
Otro ejemplo para calcular esta vez los porcentajes de cada compra para cada persona:

total_compra = df.groupby('nombre')['compra'].transform(sum)
df['porcentaje'] = df['compra']/total_compra * 100
df

Filtrar las compras de los usuarios con compras superiores a 80000 en total

df[df.groupby('nombre')['compra'].transform(sum) <= 80000]

Pandas cuenta con métodos que permiten unir dataframes usando columnas, índices o la posición de los datos como referencia. Se presentan los métodos concat, join y merge.

Creado: Julio 10 de 2019
Modificado: Julio 10 de 2019
Testeado en:

- Python 3.6.4
- pandas 0.24.2

Descargar código: https://github.com/vilmauricio/pyciencia/tree/master/pandas

import pandas as pd
from IPython.display import display_html

def display_inline(*dataframes):
    df_html = [df.to_html() for df in dataframes]
    html = ''.join(df_html)
    html = html.replace('table','table style="display:inline; padding:10px"')
    display_html(html, raw=True)

pd.concat( )¶

Función de pandas que permite unir DataFrames o Series contenidos en una lista en un solo Dataframe o Serie.

df_1 = pd.DataFrame([[1, 2, 3], [2, 5, 4],[4, 2, 3]], columns=['a', 'b', 'c'])
df_2 = pd.DataFrame([[3, 5, 1], [1, 1, 4],[2, 6, 3]], columns=['a', 'd', 'e'])
df_3 = pd.DataFrame([[6, 5, 3], [3, 4, 3],[1, 7, 5]], columns=['a', 'd', 'e'])

dataframes = [df_1, df_2, df_3]
result = pd.concat(dataframes, sort='False', ignore_index='True')
result

La función concat genera una copia de los DataFrame de origen, por lo que cualquier modificación sobre result no afecta a df_1, df_2, df_3.

Los NaN del nuevo Dataframe se deben a que estas columnas no existen en el dataframe del cual proviene la fila, por ejemplo el elemento result.loc[0, d] es NaN porque en el DataFrame df_1 no existe la columna d.

El argumento ignore_index=True genera un índice nuevo para el DataFrame resultante en lugar de conservar los índices de los DataFrames de origen df_1, df_2, df_3.

dataframes = [df_1, df_2, df_3]
result = pd.concat(dataframes, sort='False', keys=['A', 'B', 'C'])
result

Al usar el argumento keys el DataFrame resultante genera como índice las claves dadas a cada grupo de datos y otro para cada file (multi index), lo que permite acceder rápidamente a la información proveniente de cada DataFrame de origen

result.loc['A']

Dataframe.join( )¶

Método de un DataFrame que permite combinar las columnas de dos dataframe usando una columna y el índice del dataframe a unir.

df_1 = pd.DataFrame([[1, 2, 3], [2, 5, 4],[4, 2, 3]], columns=['a', 'b', 'c'])
df_2 = pd.DataFrame([[1, 5, 1], [7, 1, 4],[2, 6, 3]], columns=['m', 'd', 'e'])

En el siguiente ejemplo se mezclará el dataframe df_2, por su índice, en el dataframe df_1, tomando como referencia la columna a. la columna a tiene en común con el índice de df_2 los números 1 y 2, por tanto los elementos que estén en la misma fila que estos números estarán en el dataframe resultante.

df_join = df_1.join(df_2, on='a')

display_inline(df_1, df_2)
print('Join:')
df_join

Join:

El mismo resultado puede lograrse usando la función merge con las siguientes especificaciones:

pd.merge(df_1, df_2, left_on='a', right_index=True, how='left', sort=False)

pd.merge( )¶

Método que permite seleccionar una columna de forma independiente para cada dataframe, el índice o un conjunto de columnas de referencia para unir dos dataframes.

df_1 = pd.DataFrame([[1, 2, 3], [2, 5, 4],[4, 2, 3]], columns=['a', 'b', 'c'])
df_2 = pd.DataFrame([[1, 5, 1], [7, 1, 4],[2, 6, 3]], columns=['a', 'd', 'e'])

Combinación de los dataframe df_1y df_2 tomando como referencia la columna 'a'

df_merge = pd.merge(df_1, df_2, on='a')

display_inline(df_1, df_2)
print('Merge:')
df_merge

Merge:

Este merge toma solo las filas cuyos valores de la columna 'a' se encuentran en ambos DataFrame.

Si se quiere considerar todos los valores de la columna 'a' que no están en los dos dataframe, como el $3$ y $4$, usa el argumento how = 'outer'.

df_merge = pd.merge(df_1, df_2, on='a', how='outer')

display_inline(df_1, df_2)
print('Merge:')
df_merge

Merge:

Para tomar todos los valores de la columna en común de uno de los dataframe, se usan en el argumento how los métodos 'left' o 'right', para tomar todos los valores del primer o del segundo dataframe respectivamente.

df_merge = pd.merge(df_1, df_2, on='a', how='left')

display_inline(df_1, df_2)
print('Merge:')
df_merge

Merge:

df_merge = pd.merge(df_1, df_2, on='a', how='right')

display_inline(df_1, df_2)
print('Merge:')
df_merge

Merge:

Al realizar un merge de dos dataframe con varias columnas en común, que no son usadas como columna de merge, estas se renombran automáticamente, de forma que en el dataframe resultante no hay columnas con igual nombre.

df_1 = pd.DataFrame([[1,2,3], [2,5,4],[4,2,3]], columns=['a', 'b', 'c'])
df_2 = pd.DataFrame([[3,5,1], [1,1,4],[2,6,3]], columns=['a', 'd', 'c'])

df_merge = pd.merge(df_1, df_2, on='c')

display_inline(df_1, df_2)
print('Merge:')
df_merge

Merge:

Merge de dos dataframe por dos columnas¶

Para realizar un merge con dos columnas basta agregar en el argumento on una lista con los nombres de las columnas en común.

df_1 = pd.DataFrame([[1,2,5], [2,5,4],[4,2,3]], columns=['a', 'b', 'c'])
df_2 = pd.DataFrame([[3,5,1], [2,1,4],[2,6,3]], columns=['a', 'd', 'c'])

df_merge = pd.merge(df_1, df_2, on=['c', 'a'])

display_inline(df_1, df_2)
print('Merge:')
df_merge

Merge:

Por defecto el merge utiliza el argumento how='inner' por lo que las filas que no tienen los elementos en común son expluídas, para mantener estas filas en el dataframe resultante se utiliza how='outer'. Los valores que no que no son comunes se mostrarán como NaN.

df_merge = pd.merge(df_1, df_2, on=['c', 'a'], how='outer')

display_inline(df_1, df_2)
print('Merge:')
df_merge

Merge:

Las filas completas se deben a que ciumplen la condición dada en el merge: El valor de la columna a y c sean iguales. Por ejemplo la fila 1 del dataframe df_mergeestá completa puesto que el valor 2 en a y el valor 4 en c está en los dos dataframe en la misma fila.

El valor de df_merge.loc[0, d] es NaN por que el valor 1 en a y el valor 5 en c no están en los dos dataframe en la misma fila, entonces se agrega la columna d sin un valor.

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

	sqrt	exp
0	1.414214	7.389056
1	1.732051	20.085537
2	1.000000	2.718282
3	2.000000	54.598150
4	1.732051	20.085537
5	1.414214	7.389056
6	2.000000	54.598150
7	1.414214	7.389056

	sqrt	exp
0	1.414214	7.389056
1	1.732051	20.085537
2	1.000000	2.718282
3	2.000000	54.598150
4	1.732051	20.085537
5	1.414214	7.389056
6	2.000000	54.598150
7	1.414214	7.389056

	a	b	c	m	d	e
0	1	2	3	7.0	1.0	4.0
1	2	5	4	2.0	6.0	3.0
2	4	2	3	NaN	NaN	NaN

	a	b	c	m	d	e
0	1	2	3	7.0	1.0	4.0
1	2	5	4	2.0	6.0	3.0
2	4	2	3	NaN	NaN	NaN

	a	b	c	d	e
0	1	2.0	3.0	5.0	1.0
1	2	5.0	4.0	6.0	3.0
2	4	2.0	3.0	NaN	NaN
3	7	NaN	NaN	1.0	4.0

Transform en pandas

datos¶

transform vs apply¶

Transform posterior a un groupby¶

Combinar dataframes usando pandas

pd.concat( )¶

Dataframe.join( )¶

pd.merge( )¶

Merge de dos dataframe por dos columnas¶

Organizar datos con pandas I

Organizar datos con pandas I¶

Multi-índice en dataframe¶

Crear un dataframe con multi-índice¶

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

Columnas¶

Filas¶

Slice (seleccionar secciones del dataframe)¶

General¶

Stack¶

Sobre Pyciencia

Entradas populares

Labels

Datos personales

Blog Archive

Seguidores

DELTA LAB

	nombre	compra	num_articulos
0	Carlos	10000	2
1	María	23000	3
2	Carlos	32000	1
3	María	43000	4
4	María	12000	3
5	Miguel	45000	2
6	Miguel	43000	4
7	Miguel	12000	2

	nombre	compra	num_articulos	total_compra
0	Carlos	10000	2	42000
1	María	23000	3	78000
2	Carlos	32000	1	42000
3	María	43000	4	78000
4	María	12000	3	78000
5	Miguel	45000	2	100000
6	Miguel	43000	4	100000
7	Miguel	12000	2	100000

	a	b	c	d	e
0	1	2.0	3.0	NaN	NaN
1	2	5.0	4.0	NaN	NaN
2	4	2.0	3.0	NaN	NaN
3	3	NaN	NaN	5.0	1.0
4	1	NaN	NaN	1.0	4.0
5	2	NaN	NaN	6.0	3.0
6	6	NaN	NaN	5.0	3.0
7	3	NaN	NaN	4.0	3.0
8	1	NaN	NaN	7.0	5.0

		a	b	c	d	e
A	0	1	2.0	3.0	NaN	NaN
	1	2	5.0	4.0	NaN	NaN
	2	4	2.0	3.0	NaN	NaN
B	0	3	NaN	NaN	5.0	1.0
	1	1	NaN	NaN	1.0	4.0
	2	2	NaN	NaN	6.0	3.0
C	0	6	NaN	NaN	5.0	3.0
	1	3	NaN	NaN	4.0	3.0
	2	1	NaN	NaN	7.0	5.0

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

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

	a_x	b	c	a_y	d
0	1	2	3	2	6
1	4	2	3	2	6
2	2	5	4	1	1

	a	b	c	d	e
0	1	2.0	3.0	NaN	NaN
1	2	5.0	4.0	NaN	NaN
2	4	2.0	3.0	NaN	NaN
3	3	NaN	NaN	5.0	1.0
4	1	NaN	NaN	1.0	4.0
5	2	NaN	NaN	6.0	3.0
6	6	NaN	NaN	5.0	3.0
7	3	NaN	NaN	4.0	3.0
8	1	NaN	NaN	7.0	5.0

		a	b	c	d	e
A	0	1	2.0	3.0	NaN	NaN
	1	2	5.0	4.0	NaN	NaN
	2	4	2.0	3.0	NaN	NaN
B	0	3	NaN	NaN	5.0	1.0
	1	1	NaN	NaN	1.0	4.0
	2	2	NaN	NaN	6.0	3.0
C	0	6	NaN	NaN	5.0	3.0
	1	3	NaN	NaN	4.0	3.0
	2	1	NaN	NaN	7.0	5.0

	a	b	c	d	e
0	1	2.0	3.0	NaN	NaN
1	2	5.0	4.0	NaN	NaN
2	4	2.0	3.0	NaN	NaN
3	3	NaN	NaN	5.0	1.0
4	1	NaN	NaN	1.0	4.0
5	2	NaN	NaN	6.0	3.0
6	6	NaN	NaN	5.0	3.0
7	3	NaN	NaN	4.0	3.0
8	1	NaN	NaN	7.0	5.0

		a	b	c	d	e
A	0	1	2.0	3.0	NaN	NaN
	1	2	5.0	4.0	NaN	NaN
	2	4	2.0	3.0	NaN	NaN
B	0	3	NaN	NaN	5.0	1.0
	1	1	NaN	NaN	1.0	4.0
	2	2	NaN	NaN	6.0	3.0
C	0	6	NaN	NaN	5.0	3.0
	1	3	NaN	NaN	4.0	3.0
	2	1	NaN	NaN	7.0	5.0