Pandas DataFrame: como manipular tabelas em Python de maneira simples

Um DataFrame do Pandas é uma estrutura de dados com a qual você pode criar e manipular tabelas em Python. A seguir, ex­pli­ca­mos sua estrutura, métodos e prin­ci­pais pro­pri­e­da­des.

Como funcionam os Da­ta­Fra­mes do Pandas?

Os Da­ta­Fra­mes são o eixo central da bi­bli­o­teca Pandas do Python e permitem uma análise de dados eficaz e flexível no Python. Um DataFrame é uma estrutura de dados tabular bi­di­men­si­o­nal com linhas numeradas e colunas eti­que­ta­das. Esta estrutura permite organizar e manipular os dados de forma se­me­lhante aos programas de folhas de cálculo con­ven­ci­o­nais, como o Excel ou o Li­bre­Of­fice. Cada coluna de um DataFrame pode conter di­fe­ren­tes tipos de dados do Python. Em outras palavras, um DataFrame permite incluir dados he­te­ro­gé­neos (como valores numéricos, cadeias de ca­rac­te­res ou booleanos) na mesma tabela.

Estrutura dos Da­ta­Fra­mes do Pandas

Um DataFrame é composto por três elementos prin­ci­pais: os dados pro­pri­a­mente ditos, os índices das linhas e os nomes das colunas. Os índices das linhas (ou sim­ples­mente «índices») são os iden­ti­fi­ca­do­res únicos de cada linha. As linhas são indexadas com valores numéricos por pre­de­fi­ni­ção, mas também pode substituí-los por cadeias. Tenha em conta que os Da­ta­Fra­mes do Pandas são indexados a partir do zero, ou seja, a numeração dos índices começa a partir de 0.

Close

Como utilizar os Da­ta­Fra­mes do Pandas

Os Da­ta­Fra­mes do Pandas oferecem uma grande variedade de técnicas e métodos para processar, analisar e vi­su­a­li­zar dados. A seguir, apre­sen­ta­mos alguns dos conceitos e métodos mais im­por­tan­tes para a ma­ni­pu­la­ção de dados com os Da­ta­Fra­mes do Pandas:

Criar um DataFrame do Pandas

Se os dados que pretende utilizar já estiverem guardados numa lista Python ou num di­ci­o­ná­rio Python, será muito simples criar um DataFrame. Basta passar a estrutura de dados existente para o cons­tru­tor do DataFrame pandas.DataFrame([Datos]) como argumento. A forma como o Pandas in­ter­preta os dados varia de­pen­dendo da estrutura de dados que passar para o cons­tru­tor. Por exemplo, pode criar um DataFrame do Pandas a partir de uma lista 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 pode ver no exemplo anterior, com listas simples só é possível criar Da­ta­Fra­mes com uma única coluna sem etiqueta. Por isso, é mais útil criar Da­ta­Fra­mes a partir de di­ci­o­ná­rios que contenham listas. Nesse caso, as chaves são in­ter­pre­ta­das como os nomes das colunas e as listas como os dados cor­res­pon­den­tes. Pode ver isso no exemplo a seguir:

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

Com este método, o DataFrame tem o formato e os ca­be­ça­lhos desejados. Se os dados não estiverem car­re­ga­dos no Python, pode carregá-los a partir de uma fonte externa, como um ficheiro CVS ou uma base de dados SQL. Para isso, deve chamar a função cor­res­pon­dente do 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)

Os Da­ta­Fra­mes csv e sql do exemplo anterior contêm todos os dados do ficheiro datos.csv e da tabela SQL tabla, res­pe­ti­va­mente. Ao criar um DataFrame a partir de uma fonte externa, também pode es­pe­ci­fi­car alguns detalhes adi­ci­o­nais, como se os índices numéricos devem ser incluídos no DataFrame ou não. Para obter mais in­for­ma­ções sobre os ar­gu­men­tos adi­ci­o­nais das duas funções, visite a página oficial de do­cu­men­ta­ção sobre Da­ta­Fra­mes do Pandas.

Mostrar di­fe­ren­tes dados nos Da­ta­Fra­mes do Pandas

Além da tabela completa, os Da­ta­Fra­mes do Pandas também podem mostrar linhas e colunas in­di­vi­du­ais. Ou seja, pode escolher quais linhas e colunas deseja ver. Por exemplo:

# 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 pode ver no exemplo anterior, para re­fe­ren­ciar uma coluna, basta usar o nome da coluna entre colchetes, como nos di­ci­o­ná­rios Python. No entanto, ao re­fe­ren­ciar uma linha, é ne­ces­sá­rio adicionar o atributo loc. Com loc, também é possível aplicar condições lógicas para filtrar os dados. Por exemplo, no código a seguir, serão exibidas apenas as linhas em que o valor de «Idade» for maior que 30:

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

Também é possível utilizar o atributo iloc para se­le­ci­o­nar as linhas e colunas com base na sua posição dentro do DataFrame. Desta forma, pode mostrar a célula que se encontra na terceira linha e na quarta coluna, por exemplo:

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

Iterar entre linhas nos Da­ta­Fra­mes do Pandas

Ao processar dados em Python, muitas vezes é ne­ces­sá­rio iterar entre as linhas dos Da­ta­Fra­mes do Pandas, por exemplo, se quiser aplicar a mesma operação a todos os dados. Para isso, o Pandas oferece dois métodos di­fe­ren­tes: itertuples() e iterrows(). Ambos os métodos apre­sen­tam certas vantagens e des­van­ta­gens em termos de de­sem­pe­nho e fa­ci­li­dade de uso.

O método iterrows() retorna uma tupla composta pelo índice e uma Série para cada linha do DataFrame. Uma Série é uma estrutura de dados do Pandas ou NumPy muito se­me­lhante a uma lista do Python em muitos aspetos, mas que oferece um melhor de­sem­pe­nho. Para aceder aos elementos in­di­vi­du­ais da Série, utiliza-se o nome da coluna, o que facilita con­si­de­ra­vel­mente o ma­nu­se­a­mento dos dados.

Embora as séries Pandas sejam muito mais efi­ci­en­tes do que as listas Python, o uso dessas es­tru­tu­ras de dados acarreta um certo custo adicional de de­sem­pe­nho. Portanto, é melhor usar o método itertuples() ao trabalhar com Da­ta­Fra­mes muito grandes. Ao contrário do iterrows(), itertuples() retorna a linha completa, incluindo o índice, como uma tupla, muito mais eficiente do que as séries. Nas tuplas, os elementos in­di­vi­du­ais são acedidos com um ponto, como quando se acede aos atributos de um objeto.

Outra diferença a ter em conta entre as séries e as tuplas é que as tuplas não são mutáveis (não podem ser mo­di­fi­ca­das). Portanto, se quiser iterar sobre um DataFrame uti­li­zando o método itertuples() e desejar alterar valores, deverá re­fe­ren­ciar o DataFrame com o atributo at e o índice da tupla. Este atributo funciona de forma muito se­me­lhante ao atributo loc. Com a ajuda do exemplo a seguir, com­pre­en­derá melhor as di­fe­ren­ças entre iterrows() e 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