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 principais propriedades e métodos.

Como funciona o Pandas DataFrame?

O Pandas DataFrame é o coração da biblioteca Python Pandas, permitindo uma análise de dados eficiente e flexível. Um DataFrame no Pandas é uma estrutura de dados tabular bidimensional com linhas numeradas e colunas rotuladas. Essa estrutura facilita a organização de dados de uma maneira compreensível e manipulável, como fazem programas de planilhas como o Excel ou LibreOffice. Cada coluna em um DataFrame pode conter diferentes tipos de dados em Python, o que significa que um DataFrame pode armazenar dados heterogêneos, como valores numéricos, strings e booleanos em uma única tabela.

Estrutura do Pandas DataFrame

Um DataFrame é composto por três elementos principais: dados, índices das linhas e nomes das colunas. O índice das linhas (ou simplesmente índice) serve como um identificador exclusivo para cada linha. Por padrão, as linhas são indexadas por valores numéricos, embora esses possam ser substituídos por strings. É importante observar que Pandas DataFrames são indexados a começar do zero.

Close

Manipulação com Pandas DataFrames

Pandas DataFrames oferecem diversas técnicas e métodos que permitem manipular, analisar e visualizar dados de forma eficiente. A seguir, você aprenderá alguns dos conceitos e métodos mais importantes para a manipulação de dados com o DataFrame.

Criar Pandas DataFrame

Se você já tem dados armazenados em uma lista Python ou em um dicionário Python, fica fácil criar um DataFrame a partir deles: basta passar a estrutura de dados existente como argumento para o construtor pandas.DataFrame([dados]). A interpretaçã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 DataFrames com apenas uma coluna sem rótulo. Por isso, é recomendado criar DataFrames a partir de dicionários que contenham listas. No nosso caso, as chaves do dicionário serão interpretadas como os nomes das colunas e as listas correspondentes 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 estruturas 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 apropriada 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 DataFrames csv e sql do exemplo acima contêm agora todos os dados do arquivo dados.csv e da tabela SQL tabela, respectivamente. Ao criar um DataFrame a partir de uma fonte externa, você também pode especificar detalhes adicionais, como se os índices numéricos devem ser incluídos no DataFrame ou não. Mais informações sobre os argumentos adicionais das duas funções podem ser encontradas na página de documentação oficial do Pandas DataFrame.

Exibir dados com Pandas DataFrame

Com Pandas DataFrames, você pode não apenas exibir toda a tabela, mas também selecionar linhas e colunas individuais. Além disso, você pode escolher quais linhas e colunas deseja visualizar. O exemplo a seguir mostra como você pode exibir linhas ou colunas individuais 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 referenciar uma coluna, utiliza-se apenas o nome da coluna entre parênteses, assim como em dicionários do Python. Por outro lado, ao referenciar 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 selecionar 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 diferentes para esse propósito: itertuples() e iterrows(). Ambas as abordagens têm suas vantagens e desvantagens em termos de desempenho e facilidade 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 semelhante a uma lista do Python, mas oferece desempenho superior. O acesso a elementos individuais na Series é feito pelo nome da coluna, o que facilita o trabalho com os dados.

Embora as Series do Pandas sejam muito mais eficientes do que listas do Python, essa estrutura de dados ainda tem um certo overhead de desempenho. Por isso, o método itertuples() é especialmente recomendado para DataFrames muito grandes. Ao contrário de iterrows(), o itertuples() retorna a linha inteira, incluindo o índice, como uma tupla, que é significativamente mais eficiente que o Series. Nas tuplas, o acesso aos elementos individuais é feito utilizando um ponto, como se fossem atributos de um objeto.

Outro aspecto importante a considerar é que tuplas não são mutáveis. Portanto, se você quiser iterar sobre um DataFrame usando itertuples() e modificar valores, precisará referenciar o DataFrame usando o atributo at e o índice da tupla. Esse atributo funciona de maneira muito semelhante ao loc. O exemplo a seguir ilustra as diferenç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