Pandas DataFrame: Manipular tabelas em Python

O Pandas DataFrame é uma estrutura de dados do Python que permite criar e manipular tabelas. Conheça o formato dos dados e suas prin­ci­pais pro­pri­e­da­des e métodos.

Como funciona o Pandas DataFrame?

O Pandas DataFrame é o coração da bi­bli­o­teca Python Pandas, per­mi­tindo uma análise de dados eficiente e flexível. Um DataFrame no Pandas é uma estrutura de dados tabular bi­di­men­si­o­nal com linhas numeradas e colunas rotuladas. Essa estrutura facilita a or­ga­ni­za­ção de dados de uma maneira com­pre­en­sí­vel e ma­ni­pu­lá­vel, como fazem programas de planilhas como o Excel ou Li­bre­Of­fice. Cada coluna em um DataFrame pode conter di­fe­ren­tes tipos de dados em Python, o que significa que um DataFrame pode armazenar dados he­te­ro­gê­neos, como valores numéricos, strings e booleanos em uma única tabela.

Estrutura do Pandas DataFrame

Um DataFrame é composto por três elementos prin­ci­pais: dados, índices das linhas e nomes das colunas. O índice das linhas (ou sim­ples­mente índice) serve como um iden­ti­fi­ca­dor exclusivo para cada linha. Por padrão, as linhas são indexadas por valores numéricos, embora esses possam ser subs­ti­tuí­dos por strings. É im­por­tante observar que Pandas Da­ta­Fra­mes são indexados a começar do zero.

Close

Ma­ni­pu­la­ção com Pandas Da­ta­Fra­mes

Pandas Da­ta­Fra­mes oferecem diversas técnicas e métodos que permitem manipular, analisar e vi­su­a­li­zar dados de forma eficiente. A seguir, você aprenderá alguns dos conceitos e métodos mais im­por­tan­tes para a ma­ni­pu­la­ção de dados com o DataFrame.

Criar Pandas DataFrame

Se você já tem dados ar­ma­ze­na­dos em uma lista Python ou em um di­ci­o­ná­rio Python, fica fácil criar um DataFrame a partir deles: basta passar a estrutura de dados existente como argumento para o cons­tru­tor pandas.DataFrame([dados]). A in­ter­pre­ta­ção dos seus dados pelo Pandas dependerá da estrutura que você fornecer. Veja como criar um Pandas DataFrame a partir de uma lista Python:

import pandas
lista = ["Ahmed", "Beatrice", "Candice", "Donovan", "Elisabeth", "Frank"]
df = pandas.DataFrame(lista)
print(df)
# Saída:
#            0
# 0     Ahmed
# 1      Beatrice
# 2     Candice
# 3    Donovan
# 4    Elisabeth
# 5  Frank

Como você pode ver no exemplo acima, listas simples permitem a criação de Da­ta­Fra­mes com apenas uma coluna sem rótulo. Por isso, é re­co­men­dado criar Da­ta­Fra­mes a partir de di­ci­o­ná­rios que contenham listas. No nosso caso, as chaves do di­ci­o­ná­rio serão in­ter­pre­ta­das como os nomes das colunas e as listas cor­res­pon­den­tes serão os dados dessas colunas. O exemplo a seguir ilustra a abordagem:

import pandas
dados = {
    'Nome': ['Arthur', 'Bruno', 'Christoph'],
    'Idade': [34, 30, 55],
    'Salário': [75000.0, 60000.5, 90000.3],
}
df = pandas.DataFrame(dados)
print(df)
# Saída:
#         Nome  Idade   Salário
# 0     Arthur     34  75000.0
# 1      Bruno     30  60000.5
# 2  Christoph     55  90000.3

Com essa abordagem, o DataFrame já assume o formato e os títulos desejados. No entanto, se você não quiser depender apenas das es­tru­tu­ras de dados internas do Python, é possível carregar seus dados a partir de uma fonte externa, como um arquivo CSV ou um banco de dados SQL. Para isso, basta utilizar a função apro­pri­ada do Pandas:

import pandas
import sqlalchemy
# DataFrame do CSV:
csv = pandas.read_csv("csv-arquivos/dados.csv")
# DataFrame do SQL:
engine = create_engine('postgresql://nomedeusuario:senha@localhost:5432/meu_banco_de_dados')
sql = pandas.read_sql_query('SELECT * FROM tabela', engine)

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

Exibir dados com Pandas DataFrame

Com Pandas Da­ta­Fra­mes, você pode não apenas exibir toda a tabela, mas também se­le­ci­o­nar linhas e colunas in­di­vi­du­ais. Além disso, você pode escolher quais linhas e colunas deseja vi­su­a­li­zar. O exemplo a seguir mostra como você pode exibir linhas ou colunas in­di­vi­du­ais ou múltiplas:

# Exibir a linha 0
print(df.loc[0])
# Exibir as linhas de 3 a 6
print(df.loc[3:6])
# Exibir as linhas 3 e 6
print(df.loc[[3, 6]])
# Exibir a coluna "Profissão"
print(df["Profissão"])
# Exibir as colunas "Profissão" e "Idade"
print(df[["Profissão", "Idade"]])
# Seleção de várias linhas e colunas
print(df.loc[[3, 6], ['Profissão', 'Idade']])

Como mostrado no exemplo, ao re­fe­ren­ciar uma coluna, utiliza-se apenas o nome da coluna entre pa­rên­te­ses, assim como em di­ci­o­ná­rios do Python. Por outro lado, ao re­fe­ren­ciar uma linha, sempre se utiliza o atributo loc. Com loc, também é possível usar condições lógicas para filtrar dados. Isso pode ser visto no bloco de código a seguir, onde apenas as linhas em que o valor da coluna “Idade” é maior que 30 são exibidas:

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

Mas também é possível usar o atributo iloc para se­le­ci­o­nar linhas e colunas com base na posição no DataFrame. Por exemplo, você pode exibir a célula que está na terceira linha e na quarta coluna:

print(df.iloc[3, 4])
# Saída:
# Palmas
print(df.iloc[[3, 4, 6], 4])
# Saída:
# 3    Palmas
# 4    Fortaleza
# 6    Aparecida

Iterar sobre as linhas com Pandas DataFrame

Ao trabalhar com dados em Python, é comum precisar iterar sobre as linhas de um Pandas DataFrame para aplicar a mesma operação em todos os dados. O Pandas oferece dois métodos di­fe­ren­tes para esse propósito: itertuples() e iterrows(). Ambas as abor­da­gens têm suas 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 um tupla de índice e Series para cada linha no DataFrame. Uma Series é outra estrutura de dados do Pandas (ou NumPy) que é bastante se­me­lhante a uma lista do Python, mas oferece de­sem­pe­nho superior. O acesso a elementos in­di­vi­du­ais na Series é feito pelo nome da coluna, o que facilita o trabalho com os dados.

Embora as Series do Pandas sejam muito mais efi­ci­en­tes do que listas do Python, essa estrutura de dados ainda tem um certo overhead de de­sem­pe­nho. Por isso, o método itertuples() é es­pe­ci­al­mente re­co­men­dado para Da­ta­Fra­mes muito grandes. Ao contrário de iterrows(), o itertuples() retorna a linha inteira, incluindo o índice, como uma tupla, que é sig­ni­fi­ca­ti­va­mente mais eficiente que o Series. Nas tuplas, o acesso aos elementos in­di­vi­du­ais é feito uti­li­zando um ponto, como se fossem atributos de um objeto.

Outro aspecto im­por­tante a con­si­de­rar é que tuplas não são mutáveis. Portanto, se você quiser iterar sobre um DataFrame usando itertuples() e modificar valores, precisará re­fe­ren­ciar o DataFrame usando o atributo at e o índice da tupla. Esse atributo funciona de maneira muito se­me­lhante ao loc. O exemplo a seguir ilustra as di­fe­ren­ças entre iterrows() e itertuples():

import pandas
df = pandas.DataFrame({
    'Nome': ['Alice', 'Bob', 'Charlie'],
    'Idade': [25, 30, 35],
    'Salário': [70000.0, 80000.5, 90000.3]
})
for index, row in df.iterrows():
        row['Salário'] += 1000
        print(f"Índice: {index}, Idade: {row['Idade']}, Salário: {row['Salário']}")
for tup in df.itertuples():
        df.at[tup.Index, 'Salário'] += 1000 # Altera o valor diretamente no DataFrame usando at[]
        print(f"Índice: {tup.Index}, Idade: {tup.Idade}, Salário: {df.loc[tup.Index, 'Salário']}")
# Ambos os loops têm a mesma saída