Pandas DataFrame: cómo manipular tablas en Python de manera sencilla

Un DataFrame de Pandas es una estructura de datos con la que puedes crear y manipular tablas en Python. A continuación, te explicamos su estructura, métodos y propiedades principales.

¿Cómo funcionan los DataFrames de Pandas?

Los DataFrames son el eje central de la biblioteca Pandas de Python y permiten un análisis de datos eficaz y flexible en Python. Un DataFrame es una estructura de datos tabular bidimensional con filas numeradas y columnas etiquetadas. Esta estructura te permite organizar y manipular los datos de una forma similar a los programas de hojas de cálculo convencionales, como Excel o LibreOffice. Cada columna de un DataFrame puede contener diferentes tipos de datos de Python. Dicho de otra forma, un DataFrame te permite incluir datos heterogéneos (como valores numéricos, cadenas de caracteres o booleanos) en una misma tabla.

Estructura de los DataFrames de Pandas

Un DataFrame está compuesto de tres elementos principales: los datos propiamente dichos, los índices de las filas y los nombres de las columnas. Los índices de las filas (o simplemente “índices”) son los identificadores únicos de cada fila. Las filas se indexan con valores numéricos por defecto, pero también puedes sustituirlos por cadenas. Ten en cuenta que los DataFrames de Pandas están indexados desde cero, es decir, la numeración de los índices empieza a partir de 0.

Close

Cómo utilizar los DataFrames de Pandas

Los DataFrames de Pandas ofrecen una gran variedad de técnicas y métodos para procesar, analizar y visualizar datos. A continuación, te presentamos algunos de los conceptos y métodos más importantes para la manipulación de datos con los DataFrames de Pandas:

Crear un DataFrame de Pandas

Si los datos que deseas usar ya están guardados en una lista de Python o en un diccionario de Python, será muy sencillo crear un DataFrame. Solo tendrás que pasar la estructura de datos existente al constructor de DataFrame pandas.DataFrame([Datos]) como argumento. La forma en la que Pandas interpreta los datos varía dependiendo de la estructura de datos que pases al constructor. Por ejemplo, puedes crear un DataFrame de Pandas a partir de una lista de Python:

import pandas
liste = ["Ahmed", "Beatriz", "Candela", "David", "Isabel", "Francisco"]
df = pandas.DataFrame(liste)
print(df)
# Salida:
#            0
# 0     Ahmed
# 1     Beatriz
# 2     Candela
# 3     David
# 4     Isabel
# 5     Francisco

Como ves en el ejemplo anterior, con listas simples solo puedes crear DataFrames con una única columna sin etiquetar. Por eso, resulta más útil crear DataFrames a partir de diccionarios que contengan listas. En ese caso, las claves se interpretan como los nombres de las columnas y las listas como los datos correspondientes. Puedes verlo en el siguiente ejemplo:

import pandas
datos = {
    'Nombre': ['Arturo', 'Bruno', 'Cristian'],
    'Edad': [34, 30, 55],
    'Sueldo': [75000, 60000, 90000],
}
df = pandas.DataFrame(datos)
print(df)
# Salida:
#       Nombre     Edad    Sueldo
# 0     Arturo     34      75000
# 1     Bruno      30      60000
# 2     Cristian   55      90000

Con este método, el DataFrame tiene el formato y los encabezados deseados. Si los datos no están cargados en Python, puedes cargarlos desde una fuente externa, como un archivo CVS o una base de datos de SQL. Para ello, deberás llamar a la función correspondiente de Pandas:

import pandas
import sqlalchemy
# DataFrame de un CSV:
csv = pandas.read_csv("archivos csv/datos.csv")
# DataFrame de SQL:
engine = create_engine('postgresql://usuario:contraseña@localhost:5432/mi_base_de_datos')
sql = pandas.read_sql_query('SELECT * FROM tabla', motor)

Los DataFrames csv y sql del ejemplo anterior contienen todos los datos del archivo datos.csv y de la tabla de SQL tabla, respectivamente. Al crear un DataFrame a partir de una fuente externa, también puedes especificar algunos detalles adicionales, como si los índices numéricos deben incluirse en el DataFrame o no. Para más información sobre los argumentos adicionales de las dos funciones, visita la página oficial de documentación sobre DataFrames de Pandas.

Mostrar diferentes datos en los DataFrames de Pandas

Además de la tabla completa, los DataFrames de Pandas también pueden mostrar filas y columnas individuales. Es decir, puedes elegir qué filas y columnas deseas ver. Por ejemplo:

# mostrar fila 0
print(df.loc[0])
# mostrar filas 3-6
print(df.loc[3:6])
# mostrar filas 3 y 6
print(df.loc[[3, 6]])
# mostrar columna “Profesión”
print(df["profesión"])
# mostrar columnas “Profesión” y “Edad”
print(df[["Profesión", "Edad"]])
# seleccionar múltiples filas y columnas
print(df.loc[[3, 6], ['Profesión', 'Edad']])

Como puedes ver en el ejemplo anterior, para referenciar una columna solo se usa el nombre de la columna entre corchetes, como en los diccionarios de Python. Sin embargo, al referenciar una fila, hay que añadir el atributo loc. Con loc, también pueden aplicarse condiciones lógicas para filtrar los datos. Por ejemplo, en el siguiente código solo se mostrarán las filas en las que el valor de “Edad” sea mayor que 30:

print(df.loc[df['Edad'] > 30])

También se puede utilizar el atributo iloc para seleccionar las filas y columnas basándose en su posición dentro del DataFrame. De esta forma, puedes mostrar la celda que se encuentra en la tercera fila y la cuarta columna, por ejemplo:

print(df.iloc[3, 4])
# Salida:
# Valencia
print(df.iloc[[3, 4, 6], 4])
# Salida:
# 3    Valencia
# 4    Madrid
# 6    Sevilla

Iterar entre filas en los DataFrames de Pandas

Cuando se procesan datos en Python, a menudo es necesario iterar entre las filas de los DataFrames de Pandas, por ejemplo, si se quiere aplicar la misma operación a todos los datos. Para ello, Pandas ofrece dos métodos diferentes: itertuples() y iterrows(). Tanto un método como el otro presentan ciertas ventajas y desventajas en cuanto a rendimiento y facilidad de uso.

El método iterrows() devuelve una tupla compuesta por el índice y una Series para cada fila del DataFrame. Una Series es una estructura de datos de Pandas o NumPy muy similar a una lista de Python en muchos aspectos, pero que ofrece un mayor rendimiento. Para acceder a los elementos individuales de la Series se utiliza el nombre de la columna, lo que facilita de una forma considerable el manejo de los datos.

Aunque las Series de Pandas son mucho más eficientes que las listas de Python, el uso de estas estructuras de datos supone un cierto sobrecoste de rendimiento. Por lo tanto, es mejor utilizar el método itertuples() cuando se trabaja con DataFrames muy grandes. A diferencia de iterrows(), itertuples() devuelve la fila completa, incluido el índice, como una tupla, mucho más eficiente que las Series. En las tuplas, se accede a los elementos individuales con un punto, como cuando se accede a los atributos de un objeto.

Otra diferencia a tener en cuenta entre las Series y las tuplas es que las tuplas no son mutables (no se pueden modificar). Por lo tanto, si quieres iterar sobre un DataFrame utilizando el método itertuples() y deseas cambiar valores, deberás referenciar el DataFrame con el atributo at y el índice de la tupla. Este atributo funciona de una forma muy similar al atributo loc. Con la ayuda del siguiente ejemplo comprenderás mejor las diferencias entre iterrows() y itertuples():

import pandas
df = pandas.DataFrame({
    'Nombre': ['Alicia', 'Bernardo', 'Carlos'],
    'Edad': [25, 30, 35],
    'Sueldo': [70000, 80000, 900000]
})
for index, row in df.iterrows():
        row['Sueldo'] += 1000
        print(f"Índice: {index}, Edad: {row['Edad']}, Sueldo: {row['Sueldo']}")
for tup in df.itertuples():
        df.at[tup.Índice, 'Sueldo'] += 1000 # Valor modificado directamente en el DataFrame usando at[]
        print(f"Index: {tup.Índice}, Edad: {tup.Edad}, Sueldo: {df.loc[tup.Índice, 'Edad']}")
# Ambos bucles tienen la misma salida