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

Un DataFrame de Pandas es una es­tru­c­tu­ra de datos con la que puedes crear y manipular tablas en Python. A co­n­ti­nua­ción, te ex­pli­ca­mos su es­tru­c­tu­ra, métodos y pro­pie­da­des pri­n­ci­pa­les.

¿Cómo funcionan los Da­ta­Fra­mes de Pandas?

Los Da­ta­Fra­mes son el eje central de la bi­blio­te­ca Pandas de Python y permiten un análisis de datos eficaz y flexible en Python. Un DataFrame es una es­tru­c­tu­ra de datos tabular bi­di­me­n­sio­nal con filas numeradas y columnas eti­que­ta­das. Esta es­tru­c­tu­ra te permite organizar y manipular los datos de una forma similar a los programas de hojas de cálculo co­n­ve­n­cio­na­les, como Excel o Li­breO­f­fi­ce. Cada columna de un DataFrame puede contener di­fe­re­n­tes tipos de datos de Python. Dicho de otra forma, un DataFrame te permite incluir datos he­te­ro­gé­neos (como valores numéricos, cadenas de ca­ra­c­te­res o booleanos) en una misma tabla.

Es­tru­c­tu­ra de los Da­ta­Fra­mes de Pandas

Un DataFrame está compuesto de tres elementos pri­n­ci­pa­les: los datos pro­pia­me­n­te dichos, los índices de las filas y los nombres de las columnas. Los índices de las filas (o si­m­ple­me­n­te “índices”) son los ide­n­ti­fi­ca­do­res únicos de cada fila. Las filas se indexan con valores numéricos por defecto, pero también puedes su­s­ti­tui­r­los por cadenas. Ten en cuenta que los Da­ta­Fra­mes de Pandas están indexados desde cero, es decir, la nu­me­ra­ción de los índices empieza a partir de 0.

Close

Cómo utilizar los Da­ta­Fra­mes de Pandas

Los Da­ta­Fra­mes de Pandas ofrecen una gran variedad de técnicas y métodos para procesar, analizar y vi­sua­li­zar datos. A co­n­ti­nua­ción, te pre­se­n­ta­mos algunos de los conceptos y métodos más im­po­r­ta­n­tes para la ma­ni­pu­la­ción de datos con los Da­ta­Fra­mes 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 di­c­cio­na­rio de Python, será muy sencillo crear un DataFrame. Solo tendrás que pasar la es­tru­c­tu­ra de datos existente al co­n­s­tru­c­tor de DataFrame pandas.DataFrame([Datos]) como argumento. La forma en la que Pandas in­te­r­pre­ta los datos varía de­pe­n­die­n­do de la es­tru­c­tu­ra de datos que pases al co­n­s­tru­c­tor. 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 Da­ta­Fra­mes con una única columna sin etiquetar. Por eso, resulta más útil crear Da­ta­Fra­mes a partir de di­c­cio­na­rios que contengan listas. En ese caso, las claves se in­te­r­pre­tan como los nombres de las columnas y las listas como los datos co­rre­s­po­n­die­n­tes. 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 en­ca­be­za­dos 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 co­rre­s­po­n­die­n­te 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 Da­ta­Fra­mes csv y sql del ejemplo anterior contienen todos los datos del archivo datos.csv y de la tabla de SQL tabla, re­s­pe­c­ti­va­me­n­te. Al crear un DataFrame a partir de una fuente externa, también puedes es­pe­ci­fi­car algunos detalles adi­cio­na­les, como si los índices numéricos deben incluirse en el DataFrame o no. Para más in­fo­r­ma­ción sobre los ar­gu­me­n­tos adi­cio­na­les de las dos funciones, visita la página oficial de do­cu­me­n­ta­ción sobre Da­ta­Fra­mes de Pandas.

Mostrar di­fe­re­n­tes datos en los Da­ta­Fra­mes de Pandas

Además de la tabla completa, los Da­ta­Fra­mes de Pandas también pueden mostrar filas y columnas in­di­vi­dua­les. 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 re­fe­re­n­ciar una columna solo se usa el nombre de la columna entre corchetes, como en los di­c­cio­na­rios de Python. Sin embargo, al re­fe­re­n­ciar una fila, hay que añadir el atributo loc. Con loc, también pueden aplicarse co­n­di­cio­nes 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 se­le­c­cio­nar 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 Da­ta­Fra­mes de Pandas

Cuando se procesan datos en Python, a menudo es necesario iterar entre las filas de los Da­ta­Fra­mes de Pandas, por ejemplo, si se quiere aplicar la misma operación a todos los datos. Para ello, Pandas ofrece dos métodos di­fe­re­n­tes: itertuples() y iterrows(). Tanto un método como el otro presentan ciertas ventajas y de­s­ve­n­ta­jas en cuanto a re­n­di­mie­n­to 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 es­tru­c­tu­ra de datos de Pandas o NumPy muy similar a una lista de Python en muchos aspectos, pero que ofrece un mayor re­n­di­mie­n­to. Para acceder a los elementos in­di­vi­dua­les de la Series se utiliza el nombre de la columna, lo que facilita de una forma co­n­si­de­ra­ble el manejo de los datos.

Aunque las Series de Pandas son mucho más efi­cie­n­tes que las listas de Python, el uso de estas es­tru­c­tu­ras de datos supone un cierto so­bre­co­s­te de re­n­di­mie­n­to. Por lo tanto, es mejor utilizar el método itertuples() cuando se trabaja con Da­ta­Fra­mes muy grandes. A di­fe­re­n­cia 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 in­di­vi­dua­les con un punto, como cuando se accede a los atributos de un objeto.

Otra di­fe­re­n­cia 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 uti­li­za­n­do el método itertuples() y deseas cambiar valores, deberás re­fe­re­n­ciar 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 co­m­pre­n­de­rás mejor las di­fe­re­n­cias 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