Tutorial de Pandas: DataFrames en Python

• También sabes que .iloc[] irá a ver las posiciones del índice. Cuando pases 2, volverás:

48    7
49    8
50    9

• Como el índice no sólo contiene números enteros, .ix[] tendrá el mismo comportamiento que iloc y mirará las posiciones del índice. Obtendrás el mismo resultado que en .iloc[].

Ahora que la diferencia entre .iloc[], .loc[] y .ix[] está clara, ¡estás preparado para añadir filas a tu DataFrame!

Consejo: como consecuencia de lo que acabas de leer, ahora también entiendes que la recomendación general es que utilices .loc para insertar filas en tu DataFrame. Esto se debe a que si utilizaras df.ix[], podrías intentar hacer referencia a un índice de valor numérico con el valor del índice y sobrescribir accidentalmente una fila existente de tu DataFrame. ¡Deberías evitarlo!

Comprueba la diferencia una vez más en el DataFrame que aparece a continuación:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), index= [2.5, 12.6, 4.8], columns=[48, 49, 50])

# This will make an index labeled `2` and add the new values
df.loc[2] = [11, 12, 13]
print(df)

     48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

2.0   11  12  13

Ya ves por qué todo esto puede resultar confuso, ¿verdad?

Añadir una columna a tu DataFrame

En algunos casos, querrás que el índice forme parte del DataFrame. Puedes hacerlo fácilmente tomando una columna del DataFrame o haciendo referencia a una columna que aún no hayas creado y asignándola a la propiedad .index, tal y como se indica a continuación:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])
​
# Use `.index`
df['D'] = df.index
​
# Print `df`
print(df)

  A  B  C  D

0  1  2  3  0

1  4  5  6  1

2  7  8  9  2

En otras palabras, le dices al DataFrame que debe tomar la columna A como índice.

Sin embargo, si quieres añadir columnas al DataFrame, también puedes seguir el mismo método que cuando añades un índice a tu DataFrame: utilizas .loc[] o .iloc[]. En este caso, añades una Serie a un DataFrame existente con la ayuda de .loc[]:

# Study the DataFrame `df`
print(df)

# Append a column to `df`
df.loc[:, 4] = pd.Series(['5', '6', '7'], index=df.index)

# Print out `df` again to see the changes
print(df)

  A  B  C  D

0  1  2  3  0

1  4  5  6  1

2  7  8  9  2

   A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7

Recuerda que un objeto Serie es muy parecido a una columna de un DataFrame. Eso explica por qué puedes añadir fácilmente una Serie a un DataFrame existente. Ten en cuenta también que la observación que hicimos antes sobre .loc[] sigue siendo válida, ¡incluso cuando añades columnas al DataFrame!

Restablecer el índice del DataFrame

Cuando el índice no tenga el aspecto que deseas, puedes optar por restablecerlo. Puedes hacerlo fácilmente con .reset_index(). Sin embargo, debes tener cuidado, ya que puedes pasar varios argumentos que pueden hacer o deshacer el éxito del reinicio:

# Check out the weird index of your dataframe
print(df)

# Use `reset_index()` to reset the values. 
df_reset = df.reset_index(level=0, drop=True)

# Print `df_reset`
print(df_reset)

  A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7

   A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7

Puedes probar a sustituir el argumento drop por inplace en el ejemplo anterior ¡y ver qué pasa!

Observa cómo utilizas el argumento drop para indicar que quieres deshacerte del índice que había. Si hubieras utilizado inplace, el índice original con flotantes se añade como una columna más al DataFrame.

Borrar un Índice del DataFrame

Si quieres eliminar el índice del DataFrame, deberías reconsiderarlo, porque los Marcos de datos y las Series siempre tienen un índice.

Sin embargo, lo que *puedes* hacer es, por ejemplo:

• restablecer el índice del DataFrame (vuelve a la sección anterior para ver cómo se hace) o
• eliminar el nombre del índice, si lo hay, ejecutando del df.index.name,
• eliminar los valores duplicados del índice restableciendo el índice, eliminando los duplicados de la columna del índice que se ha añadido al DataFrame y restableciendo de nuevo esa columna sin duplicados como índice
• y por último, eliminar un índice, y con él una fila. Esto se explica más adelante en este tutorial.

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [40, 50, 60], [23, 35, 37]]), 
                  index= [2.5, 12.6, 4.8, 4.8, 2.5], 
                  columns=[48, 49, 50])
                  
df.reset_index().drop_duplicates(subset='index', keep='last').set_index('index')

Ahora que ya sabes cómo eliminar un índice del DataFrame, ¡puedes pasar a eliminar columnas y filas!

Borrar una columna del DataFrame

Para deshacerte de (una selección de) columnas del DataFrame, puedes utilizar el método drop():

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])

# Check out the DataFrame `df`
print(df)

# Drop the column with label 'A'                  
df.drop('A', axis=1, inplace=True)

# Drop the column at position 1
df.drop(df.columns[[1]], axis=1)

  A  B  C

0  1  2  3

1  4  5  6

2  7  8  9

Puede que ahora pienses: bueno, esto no es tan sencillo; ¡hay algunos argumentos extra que se pasan al método drop()!

• El argumento axis es 0 cuando indica filas y 1 cuando se utiliza para soltar columnas.
• Puedes establecer inplace en True para eliminar la columna sin tener que reasignar el DataFrame.

Eliminar una Fila del DataFrame

Puedes eliminar las filas duplicadas del DataFrame ejecutando df.drop_duplicates(). También puedes eliminar filas del DataFrame, teniendo en cuenta sólo los valores duplicados que existan en una columna.

Mira este ejemplo:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [40, 50, 60], [23, 35, 37]]), 
                  index= [2.5, 12.6, 4.8, 4.8, 2.5], 
                  columns=[48, 49, 50])

# Check out your DataFrame `df`
print(df)

# Drop the duplicates in `df`
df.drop_duplicates([48], keep='last')

      48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

4.8   40  50  60

2.5   23  35  37

Si no existe un criterio de unicidad para el borrado que quieres realizar, puedes utilizar el método drop(), en el que utilizas la propiedad index para especificar el índice de las filas que quieres eliminar del DataFrame:

# Check out the DataFrame `df`
print(df)

# Drop the index at position 1
df.drop(df.index[1])

     48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

4.8   40  50  60

2.5   23  35  37

Después de este comando, puede que quieras restablecer el índice de nuevo.

Consejo: ¡prueba tú mismo a restablecer el índice del DataFrame resultante! No olvides utilizar el argumento drop si lo consideras necesario.

Reemplazar todas las apariciones de una cadena en un DataFrame

Para sustituir determinadas cadenas en el DataFrame, puedes utilizar fácilmente replace(): pasa los valores que quieres cambiar, seguidos de los valores por los que quieres sustituirlos.

Así:

df = pd.DataFrame({"Student1":['OK','Awful','Acceptable'], 
                   "Student2":['Perfect','Awful','OK'], 
                   "Student3":['Acceptable','Perfect','Poor']})

# Study the DataFrame `df` first
print(df)

# Replace the strings by numerical values (0-4)
df.replace(['Awful', 'Poor', 'OK', 'Acceptable', 'Perfect'], [0, 1, 2, 3, 4]) 

     Student1 Student2    Student3

0          OK  Perfect  Acceptable

1       Awful    Awful     Perfect

2  Acceptable       OK        Poor

Ten en cuenta que también existe un argumento regex que puede ayudarte enormemente cuando te enfrentes a combinaciones de cadenas extrañas:

df =  pd.DataFrame([["1\n", 2, "3\n"], [4, 5, "6\n"] ,[7, "8\n", 9]])

# Check out your DataFrame `df`
print(df)

# Replace strings by others with `regex`
df.replace({'\n': ''}, regex=True)

    0    1    2

0  1\n    2  3\n

1    4    5  6\n

2    7  8\n    9

¡En resumen, replace() es sobre todo con lo que tienes que tratar cuando quieras sustituir valores o cadenas del DataFrame por otros!

Eliminar partes de cadenas en las celdas del DataFrame

Eliminar las partes no deseadas de las cadenas es un trabajo engorroso. Por suerte, ¡este problema tiene fácil solución!

df =  pd.DataFrame([["+-1aAbBcC", "2", "+-3aAbBcC"], ["4", "5", "+-6aAbBcC"] ,["7", "+-8aAbBcC", "9"]])

# Check out your DataFrame
print(df)

# Delete unwanted parts from the strings in the first column
df[0] = df[0].map(lambda x: x.lstrip('+-').rstrip('aAbBcC'))

# Check out the result again
df

          0          1          2

0  +-1aAbBcC          2  +-3aAbBcC

1          4          5  +-6aAbBcC

2          7  +-8aAbBcC          9

Utiliza map() en la columna result para aplicar la función lambda sobre cada elemento o elemento de la columna. La función en sí toma el valor de la cadena y le quita el + o - que se encuentra a la izquierda, y también le quita cualquiera de los seis aAbBcC de la derecha.

Dividir el texto de una columna en varias filas de un DataFrame

Esta es una tarea de formato algo más difícil. Sin embargo, el siguiente fragmento de código te guiará por los pasos:

df = pd.DataFrame({"Age": [34, 22, 19], 
                   "PlusOne":[0,0,1], 
                   "Ticket":["23:44:55", "66:77:88", "43:68:05 56:34:12"]})

# Inspect your DataFrame `df`
print(df)

# Split out the two values in the third row
# Make it a Series
# Stack the values
ticket_series = df['Ticket'].str.split(' ').apply(pd.Series, 1).stack()

# Get rid of the stack:
# Drop the level to line up with the DataFrame
ticket_series.index = ticket_series.index.droplevel(-1)

print(ticket_series)

  Age  PlusOne             Ticket

0   34        0           23:44:55

1   22        0           66:77:88

2   19        1  43:68:05 56:34:12

0    23:44:55

1    66:77:88

2    43:68:05

2    56:34:12

dtype: object

          0

0  23:44:55

1  66:77:88

2  43:68:05

2  56:34:12

En resumen, lo que haces es:

• En primer lugar, inspecciona el DataFrame que tienes a mano. Ves que los valores de la última fila y de la última columna son demasiado largos. Parece que hay dos entradas porque un invitado ha llevado un acompañante al concierto.
• Tomas la columna Ticket del DataFrame df y la encadenas en un espacio. Así te asegurarás de que al final los dos billetes acaben en dos filas separadas. A continuación, coge estos cuatro valores (los cuatro números del ticket) y ponlos en un objeto Serie:

      0         1
0  23:44:55       NaN
1  66:77:88       NaN
2  43:68:05  56:34:12

• Eso sigue sin parecerme del todo correcto. ¡Ahí tienes los valores de NaN! Tienes que apilar las Series para asegurarte de que no tienes ningún valor NaN en la Serie resultante.
• A continuación, ves que la Serie está apilada.

0  0    23:44:55
1  0    66:77:88
2  0    43:68:05
   1    56:34:12

• Eso tampoco es lo ideal. Por eso bajas el nivel para alinearlo con el DataFrame:

0    23:44:55
1    66:77:88
2    43:68:05
2    56:34:12
dtype: object

• Eso es lo que buscas.
• Transforma la Serie en un DataFrame para asegurarte de que puedes volver a unirla al DataFrame inicial. Sin embargo, para evitar tener duplicados en el DataFrame, puedes eliminar la columna original Ticket.

Aplicar una función a las columnas o filas del DataFrame de Pandas

Puede que quieras ajustar los datos del DataFrame aplicándoles una función. Empecemos a responder a esta pregunta creando tu propia función lambda:

doubler = lambda x: x*2

Consejo: si quieres saber más sobre las funciones en Python, considera seguir este tutorial sobre funciones en Python.

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])

# Study the `df` DataFrame
print(df)

# Apply the `doubler` function to the `A` DataFrame column
df['A'].apply(doubler)
 A  B  C

0  1  2  3

1  4  5  6

2  7  8  9

0     2

1     8

2    14

Name: A, dtype: int64

Ten en cuenta que también puedes seleccionar la fila del DataFrame y aplicarle la función lambda doubler. Recuerda que puedes seleccionar fácilmente una fila del DataFrame utilizando .loc[] o .iloc[].

Entonces, ejecutarías algo así, dependiendo de si quieres seleccionar el índice en función de su posición o en función de su etiqueta:

df.loc[0].apply(doubler)

Ten en cuenta que la función apply() sólo aplica la función doubler a lo largo del eje del DataFrame. Eso significa que te diriges al índice o a las columnas. O, en otras palabras, una fila o una columna.

Sin embargo, si quieres aplicarlo a cada elemento o elemento por elemento, puedes utilizar la función map(). Puedes sustituir la función apply() del fragmento de código anterior por map(). No olvides pasarle aún la función doubler para asegurarte de que multiplicas los valores por 2.

Supongamos que quieres aplicar esta función de duplicación no sólo a la columna A del DataFrame, sino a toda ella. En este caso, puedes utilizar applymap() para aplicar la función doubler a cada uno de los elementos de todo el DataFrame:

doubled_df = df.applymap(doubler)
print(doubled_df)

   A   B   C

0   2   4   6

1   8  10  12

2  14  16  18

Ten en cuenta que, en estos casos, hemos estado trabajando con funciones lambda o funciones anónimas que se crean en tiempo de ejecución. Sin embargo, también puedes escribir tu propia función. Por ejemplo:

def doubler(x):
    if x % 2 == 0:
        return x
    else:
        return x * 2

# Use `applymap()` to apply `doubler()` to your DataFrame
doubled_df = df.applymap(doubler)

# Check the DataFrame
print(doubled_df)

   A   B   C

0   2   2   6

1   4  10   6

2  14   8  18

Si quieres más información sobre el flujo de control en Pythonsiempre puedes consultar nuestros otros recursos.

Dinamización de tu DataFrame

Puedes utilizar la función pivot() para crear una nueva tabla derivada a partir de la original. Cuando utilices la función, puedes pasar tres argumentos:

1. values: este argumento te permite especificar qué valores de tu DataFrame original quieres ver en tu tabla dinámica.
2. columns: lo que pases a este argumento se convertirá en una columna de la tabla resultante.
3. index: lo que pases a este argumento se convertirá en un índice en la tabla resultante.

# Import pandas
import pandas as pd

# Create your DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
        'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
        'price':[11.42, 23.50, 19.99, 15.95, 55.75, 111.55],
        'testscore': [4, 3, 5, 7, 5, 8]})

# Use `pivot()` to pivot the DataFrame
pivot_products = products.pivot(index='category', columns='store', values='price')

# Check out the result
print(pivot_products)

store            Dia   Fnac  Walmart

category                            

Cleaning       23.50    NaN    11.42

Entertainment    NaN  15.95    19.99

Tech           55.75    NaN   111.55

Cuando no rellenas específicamente qué valores esperas que estén presentes en tu tabla resultante, dinamizarás por varias columnas:

# Import the Pandas library
import pandas as pd
​
# Construct the DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
                       'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
                       'price':[11.42, 23.50, 19.99, 15.95, 55.75, 111.55],
                       'testscore': [4, 3, 5, 7, 5, 8]})
​
# Use `pivot()` to pivot your DataFrame
pivot_products = products.pivot(index='category', columns='store')
​
# Check out the results
print(pivot_products)

             price                testscore             

store            Dia   Fnac Walmart       Dia Fnac Walmart

category                                                  

Cleaning       23.50    NaN   11.42       3.0  NaN     4.0

Entertainment    NaN  15.95   19.99       NaN  7.0     5.0

Tech           55.75    NaN  111.55       5.0  NaN     8.0

Ten en cuenta que tus datos no pueden tener filas con valores duplicados para las columnas que especifiques. Si no es así, aparecerá un mensaje de error. Si no puedes garantizar la unicidad de tus datos, te conviene utilizar en su lugar el método pivot_table:

# Import the Pandas library
import pandas as pd

# Your DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
                        'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
                        'price':[11.42, 23.50, 19.99, 15.95, 19.99, 111.55],
                        'testscore': [4, 3, 5, 7, 5, 8]})

# Pivot your `products` DataFrame with `pivot_table()`
pivot_products = products.pivot_table(index='category', columns='store', values='price', aggfunc='mean')

# Check out the results
print(pivot_products)

store            Dia   Fnac  Walmart

category                            

Cleaning       23.50    NaN    11.42

Entertainment    NaN  15.95    19.99

Tech           19.99    NaN   111.55

Observa el argumento adicional aggfunc que se pasa al método pivot_table. Este argumento indica que utilizas una función de agregación que sirve para combinar varios valores. En este ejemplo, puedes ver claramente que se utiliza la función mean.

Utilizar stack() y unstack() para remodelar el DataFrame Pandas

Ya has visto un ejemplo de apilamiento en el apartado 5. En esencia, puede que aún recuerdes que cuando apilas un DataFrame, lo haces más alto. Mueves el índice de la columna más interior para que sea el índice de la fila más interior. Devuelve un DataFrame con un índice con un nuevo nivel más interno de etiquetas de fila.

La inversa del apilamiento se llama desapilamiento. De forma parecida a stack(), utilizas unstack() para desplazar el índice de la fila más interna y convertirlo en el índice de la columna más interna.

Para una explicación de la dinamización, el apilamiento y en desapilamiento en pandas, consulta nuestro curso Dar forma a los datos con pandas.

Remodela el DataFrame con melt()

La fusión se considera útil en los casos en que tienes datos que tienen una o más columnas que son variables identificadoras, mientras que todas las demás columnas se consideran variables medidas.

Estas variables medidas están todas "unpivoted" del eje de filas. Es decir, mientras que las variables medidas que estaban repartidas por la anchura del DataFrame, el fundido se encargará de colocarlas en la altura del mismo. O, dicho de otro modo, el DataFrame ahora será más largo en lugar de más ancho.

Como resultado, tienes dos columnas no identificadoras, a saber, ‘variable’ y ‘value’.

Vamos a ilustrarlo con un ejemplo:

# The `people` DataFrame
people = pd.DataFrame({'FirstName' : ['John', 'Jane'],
                       'LastName' : ['Doe', 'Austen'],
                       'BloodType' : ['A-', 'B+'],
                       'Weight' : [90, 64]})

# Use `melt()` on the `people` DataFrame
print(pd.melt(people, id_vars=['FirstName', 'LastName'], var_name='measurements'))

 FirstName LastName measurements value

0      John      Doe    BloodType    A-

1      Jane   Austen    BloodType    B+

2      John      Doe       Weight    90

3      Jane   Austen       Weight    64

Si buscas más formas de remodelar tus datos, consulta la documentación.

Pasar un DataFrame a CSV

Para escribir un DataFrame como un archivo CSV, puedes utilizar to_csv():

import pandas as pd
df.to_csv('myDataFrame.csv')

Ese fragmento de código parece bastante sencillo, pero aquí es donde empiezan las dificultades para la mayoría de la gente, porque tendrás requisitos específicos para la salida de tus datos. Quizá no quieras una coma como delimitador, o quieras especificar una codificación concreta.

No te preocupes. Puedes pasar algunos argumentos adicionales a to_csv() para asegurarte de que tus datos salen como tú quieres.

• Para delimitar mediante una tabulación, utiliza el argumento sep:

import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t')

• Para utilizar una codificación de caracteres específica, puedes utilizar el argumento encoding:

import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t', encoding='utf-8')

• Además, puedes especificar cómo quieres que se representen tus NaN o los valores que faltan, si quieres que salga o no la cabecera, si quieres escribir o no los nombres de las filas, si quieres compresión, puedes leer las opciones.

Escribir un DataFrame en Excel

De forma similar a lo que hiciste para pasar el DataFrame a CSV, puedes utilizar to_excel() para escribir la tabla en Excel. Sin embargo, es un poco más complicado:

import pandas as pd
writer = pd.ExcelWriter('myDataFrame.xlsx')
df.to_excel(writer, 'DataFrame')
writer.save()

Sin embargo, ten en cuenta que, al igual que con to_csv(), tienes un montón de argumentos extra como startcol, startrow, etc., para asegurarte de que das salida a tus datos correctamente. Puedes obtener más información sobre cómo importar datos desde y exportar datos a archivos CSV utilizando pandas en nuestro tutorial. 

Sin embargo, si quieres más información sobre las herramientas IO en Pandas, consulta la documentación de Pandas de DataFrames a Excel.