3 - DataFrame

A classe pandas.DataFrame é uma estrutura de dados tabulares bidimensional com rótulos de eixos (linhas e colunas), mutáveis ​​em tamanho e potencialmente heterogêneos, sendo amplamente utilizada para manipulação e análise de dados em Python.

class pandas.DataFrame(data=None, index=None, dtype=None, name=None, copy=None, fastpath=False)

onde:

• data: valor semelhante a uma matriz, iterável, ditado ou escalar. Contém dados armazenados em série. Se os dados são um ditado, a ordem dos argumentos é mantido.
• index: tipo matriz ou índice (1d). Os valores devem ser hashable e ter o mesmo comprimento dos dados. Valores de índice não exclusivos são permitidos. O padrão será RangeIndex(0, 1, 2,..., n), se não for fornecido. Se os dados são ditados e o index é None, então as chaves nos dados são usadas como índice. Se o index não é None, a série resultante é reindexada com os valores do índice.
• dtype: str, numpy.dtype ou ExtensionDtype, opcional. Tipo de dados para a série de saída. Se não especificado, isso será inferido dos dados. Veja o guia do usuário para mais usos.
• name: Hashable, valor-padrão None, opcional. Nome para a série.
• copy: bool, valor-padrão False. Se True, a série será copiada. Se False, a série será modificada.

data

Pode ser um ndarray (estruturado ou homogêneo), um iterável, um dicionário ou outro DataFrame. Se for um dicionário, pode conter séries, matrizes, constantes, classes de dados ou objetos semelhantes a listas. Quando um dicionário contém Series com um índice definido, o alinhamento é feito pelo índice.

3.1.0.1 - Exemplo de Código

import pandas as pd

# Criando um DataFrame a partir de um dicionário
data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12]
}

df = pd.DataFrame(data)
print("DataFrame criado a partir de um dicionário:")
print(df)

# Criando um DataFrame a partir de uma lista de dicionários
data_list = [
    {'A': 1, 'B': 5, 'C': 9},
    {'A': 2, 'B': 6, 'C': 10},
    {'A': 3, 'B': 7, 'C': 11},
    {'A': 4, 'B': 8, 'C': 12}
]

df_list = pd.DataFrame(data_list)
print("\nDataFrame criado a partir de uma lista de dicionários:")
print(df_list)

# Especificando índices e nomes das colunas
df_custom = pd.DataFrame(data, index=['a', 'b', 'c', 'd'], columns=['A', 'B', 'C'])
print("\nDataFrame com índice e colunas personalizados:")
print(df_custom)

# Forçando o dtype e copiando os dados
df_dtype = pd.DataFrame(data, dtype=float, copy=True)
print("\nDataFrame com dtype forçado para float:")
print(df_dtype)

DataFrame criado a partir de um dicionário:
   A  B   C
0  1  5   9
1  2  6  10
2  3  7  11
3  4  8  12

DataFrame criado a partir de uma lista de dicionários:
   A  B   C
0  1  5   9
1  2  6  10
2  3  7  11
3  4  8  12

DataFrame com índice e colunas personalizados:
   A  B   C
a  1  5   9
b  2  6  10
c  3  7  11
d  4  8  12

DataFrame com dtype forçado para float:
     A    B     C
0  1.0  5.0   9.0
1  2.0  6.0  10.0
2  3.0  7.0  11.0
3  4.0  8.0  12.0

Neste exemplo:

1. Criamos um DataFrame a partir de um dicionário.

2. Criamos um DataFrame a partir de uma lista de dicionários.

3. Personalizamos os índices e nomes das colunas do DataFrame.

4. Forçamos o dtype para `float` e copiamos os dados.

Essas funcionalidades demonstram a flexibilidade e a versatilidade da classe `pandas.DataFrame` para manipulação de dados em Python.

index

Índice a ser usado para o DataFrame resultante. O padrão é `RangeIndex` se nenhuma informação de indexação estiver presente nos dados de entrada e nenhum índice for fornecido.

Claro, aqui está um exemplo usando o parâmetro `index` ao criar um DataFrame:

import pandas as pd

# Criando um DataFrame a partir de um dicionário
data = {
    'Nome': ['Ana', 'Bruno', 'Carla', 'Daniel'],
    'Idade': [23, 35, 30, 28],
    'Cidade': ['São Paulo', 'Rio de Janeiro', 'Belo Horizonte', 'Curitiba']
}

# Especificando um índice personalizado
indices_personalizados = ['ID1', 'ID2', 'ID3', 'ID4']

# Criando o DataFrame com o índice personalizado
df = pd.DataFrame(data, index=indices_personalizados)

print("DataFrame com índice personalizado:")
print(df)

DataFrame com índice personalizado:
       Nome  Idade          Cidade
ID1     Ana     23       São Paulo
ID2   Bruno     35  Rio de Janeiro
ID3   Carla     30  Belo Horizonte
ID4  Daniel     28        Curitiba

Neste exemplo, criamos um DataFrame com informações sobre pessoas, incluindo seus nomes, idades e cidades.

Em vez de usar o índice padrão `RangeIndex` (0, 1, 2, 3), especificamos um índice personalizado usando o parâmetro `index`.

O DataFrame resultante tem os índices `ID1`, `ID2`, `ID3` e `ID4`.

columns

Nomes das colunas, opcionais. Se `None`, o padrão será usar `RangeIndex` (0, 1, 2, ..., n). Se os dados contiverem rótulos de colunas, esses rótulos serão utilizados.

Claro! Aqui está um exemplo de como usar o parâmetro `dtype` ao criar um DataFrame:

import pandas as pd

# Criando um DataFrame a partir de um dicionário
data = {
    'Nome': ['Ana', 'Bruno', 'Carla', 'Daniel'],
    'Idade': [23, 35, 30, 28],
    'Altura': [1.65, 1.80, 1.75, 1.68]
}

# Especificando o dtype para forçar todas as colunas para o tipo string
df = pd.DataFrame(data, dtype=str)

print("DataFrame com dtype forçado para string:")
print(df)

# Verificando os tipos das colunas
print("\nTipos das colunas:")
print(df.dtypes)

DataFrame com dtype forçado para string:
     Nome Idade Altura
0     Ana    23   1.65
1   Bruno    35    1.8
2   Carla    30   1.75
3  Daniel    28   1.68

Tipos das colunas:
Nome      object
Idade     object
Altura    object
dtype: object

Neste exemplo, criamos um DataFrame com informações sobre pessoas, incluindo seus nomes, idades e alturas.

Utilizamos o parâmetro `dtype` para forçar todas as colunas a serem do tipo str.

Neste DataFrame, todas as colunas são forçadas a serem do tipo `string` (`object` em termos de pandas), independentemente dos tipos de dados originais fornecidos no dicionário.

dtype

Tipo de dados a ser forçado para todas as colunas. Apenas um único dtype é permitido. Se `None`, o tipo de dado será inferido.

Claro! Aqui está um exemplo de como usar o parâmetro `dtype` ao criar um DataFrame:

import pandas as pd

# Criando um DataFrame a partir de um dicionário
data = {
    'Nome': ['Ana', 'Bruno', 'Carla', 'Daniel'],
    'Idade': [23, 35, 30, 28],
    'Altura': [1.65, 1.80, 1.75, 1.68]
}

# Especificando o dtype para forçar todas as colunas para o tipo string
df = pd.DataFrame(data, dtype=str)

print("DataFrame com dtype forçado para string:")
print(df)

# Verificando os tipos das colunas
print("\nTipos das colunas:")
print(df.dtypes)

DataFrame com dtype forçado para string:
     Nome Idade Altura
0     Ana    23   1.65
1   Bruno    35    1.8
2   Carla    30   1.75
3  Daniel    28   1.68

Tipos das colunas:
Nome      object
Idade     object
Altura    object
dtype: object

Neste exemplo, criamos um DataFrame com informações sobre pessoas, incluindo seus nomes, idades e alturas. Utilizamos o parâmetro `dtype` para forçar todas as colunas a serem do tipo `string`.

Neste DataFrame, todas as colunas são forçadas a serem do tipo `string` (`object` em termos de pandas), independentemente dos tipos de dados originais fornecidos no dicionário.

copy

Indica se os dados devem ser copiados. Para dados de dicionário, o padrão `None` se comporta como `copy=True`. Para entrada de DataFrame ou ndarray 2D, o padrão `None` se comporta como `copy=False`.

Claro! Aqui está um exemplo de como usar o parâmetro `copy` ao criar um DataFrame:

import pandas as pd

# Criando um DataFrame a partir de um dicionário
data = {
    'Nome': ['Ana', 'Bruno', 'Carla', 'Daniel'],
    'Idade': [23, 35, 30, 28],
    'Cidade': ['São Paulo', 'Rio de Janeiro', 'Belo Horizonte', 'Curitiba']
}

# Criando um DataFrame original
df_original = pd.DataFrame(data)

# Criando um DataFrame com copy=False
df_no_copy = pd.DataFrame(data, copy=False)

# Modificando o DataFrame original
df_original['Idade'][0] = 99

print("DataFrame original modificado:")
print(df_original)

print("\nDataFrame com copy=False (sem cópia dos dados):")
print(df_no_copy)

# Criando um DataFrame com copy=True
df_with_copy = pd.DataFrame(data, copy=True)

# Modificando o DataFrame original novamente
df_original['Idade'][0] = 23

print("\nDataFrame com copy=True (dados copiados):")
print(df_with_copy)

DataFrame original modificado:
     Nome  Idade          Cidade
0     Ana     99       São Paulo
1   Bruno     35  Rio de Janeiro
2   Carla     30  Belo Horizonte
3  Daniel     28        Curitiba

DataFrame com copy=False (sem cópia dos dados):
     Nome  Idade          Cidade
0     Ana     23       São Paulo
1   Bruno     35  Rio de Janeiro
2   Carla     30  Belo Horizonte
3  Daniel     28        Curitiba

DataFrame com copy=True (dados copiados):
     Nome  Idade          Cidade
0     Ana     23       São Paulo
1   Bruno     35  Rio de Janeiro
2   Carla     30  Belo Horizonte
3  Daniel     28        Curitiba

Neste exemplo, criamos três DataFrames:

1. `df_original`: O DataFrame original criado a partir do dicionário de dados.

2. `df_no_copy`: Um DataFrame criado com `copy=False`, significando que os dados não são copiados.

3. `df_with_copy`: Um DataFrame criado com `copy=True`, significando que os dados são copiados.

Quando `copy=False`, o DataFrame `df_no_copy` compartilha os mesmos dados subjacentes que `df_original`, portanto, modificações em um afetam o outro.

Quando `copy=True`, o DataFrame `df_with_copy` tem uma cópia independente dos dados, então modificações em `df_original` não afetam `df_with_copy`.

Dataframe df_pessoas

Dataframe original df_pessoas para comparação.

print(df_pessoas)

      Nome  Idade  Altura Sexo  Peso   IMC  Salario
0  Roberto     25     165    M    65  22.2     2500
1   Rosana     30     180    F    70  23.4     3000
2    Pedro     35     175    M    75  25.6     3500
3     Dora     40     185    F    80  27.8     4000

Atributo index

Retorna o índice (rótulos de linha) do dataframe

DataFrame.index

O índice (rótulos de linha) do DataFrame.

O índice de um DataFrame é uma série de rótulos que identificam cada linha.

Os rótulos podem ser inteiros, textos ou qualquer outro tipo hash.

O índice é usado para acesso e alinhamento baseado em rótulo e pode ser acessado ou modificado usando este atributo.

print(df_pessoas.index)

RangeIndex(start=0, stop=4, step=1)

Atributo values

Valores do DataFrame.

DataFrame.values

Retorna uma representação Numpy somente com os valores do DataFrame, os rótulos dos eixos são removidos.

print(df_pessoas.values)

[['Roberto' 25 165 'M' 65 22.2 2500]
 ['Rosana' 30 180 'F' 70 23.4 3000]
 ['Pedro' 35 175 'M' 75 25.6 3500]
 ['Dora' 40 185 'F' 80 27.8 4000]]

Atributo columns

Rótulos das colunas do DataFrame.

DataFrame.columns

Retorna os nomes das colunas do DataFrame.

print(df_pessoas.columns)

Index(['Nome', 'Idade', 'Altura', 'Sexo', 'Peso', 'IMC', 'Salario'], dtype='object')

Atributo dtypes

Retorne os dtypes no DataFrame.

DataFrame.dtypes

Isso retorna uma série com o tipo de dados de cada coluna.

O índice do resultado são as colunas do DataFrame original.

Colunas com tipos mistos são armazenadas com o dtype object .

print(df_pessoas.dtypes)

Nome        object
Idade        int64
Altura       int64
Sexo        object
Peso         int64
IMC        float64
Salario      int64
dtype: object

Método info()

Resumo conciso de um DataFrame

DataFrame.info(verbose=None, buf=None, max_cols=None, memory_usage=None, show_counts=None)

Este método imprime informações sobre um DataFrame, incluindo o tipo de índice e colunas, valores não nulos e uso de memória.

print(df_pessoas.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 7 columns):
 #   Column   Non-Null Count  Dtype  
---  ------   --------------  -----  
 0   Nome     4 non-null      object 
 1   Idade    4 non-null      int64  
 2   Altura   4 non-null      int64  
 3   Sexo     4 non-null      object 
 4   Peso     4 non-null      int64  
 5   IMC      4 non-null      float64
 6   Salario  4 non-null      int64  
dtypes: float64(1), int64(4), object(2)
memory usage: 352.0+ bytes
None

Método select_dtypes()

Subconjunto de colunas de um tipo.

DataFrame.select_dtypes(include=None, exclude=None)

Retorna um subconjunto de colunas do DataFrame com base nos dtypes da coluna.

print(df_pessoas.select_dtypes(include=[np.number]))

   Idade  Altura  Peso   IMC  Salario
0     25     165    65  22.2     2500
1     30     180    70  23.4     3000
2     35     175    75  25.6     3500
3     40     185    80  27.8     4000

Atributo axes

Eixos do DataFrame

DataFrame.axes

Retorna uma lista representando os eixos do DataFrame, contendo os rótulos dos eixos das linhas e dos eixos das colunas como os únicos membros, nessa ordem.

print(df_pessoas.axes)

[RangeIndex(start=0, stop=4, step=1), Index(['Nome', 'Idade', 'Altura', 'Sexo', 'Peso', 'IMC', 'Salario'], dtype='object')]

Atributo ndim

Número de Dimensões.

DataFrame.ndim

Retorna um int representando o número de eixos/dimensões da matriz: 1 para Series, 2 para DataFrame.

print(df_pessoas.ndim)

2

Atributo size

Número de Elementos.

DataFrame.size

Retorna um int representando o número de elementos neste objeto.

print(df_pessoas.size)

28

Atributo shape

Dimensões (linhas,colunas).

DataFrame.shape

Retorna uma tupla que representa a dimensionalidade do dataframe

print(df_pessoas.shape)

(4, 7)

Atributo empty

Retorna se o DataFrame está vazio.

DataFrame.empty

Verdadeiro se Series/DataFrame estiver totalmente vazio (sem itens), o que significa que qualquer um dos eixos tem comprimento 0.

print(df_pessoas.empty)

False

Atributo flags

Sinalizadores.

class pandas.Flags(obj, *, allows_duplicate_labels)

Retorna um novo objeto com sinalizadores atualizados.

df_aux = pd.DataFrame({
  'A': [1, 1, 1, 2, 3 , 3, 3],
  'B': [4, 5, 4, 6, 6 , 2, 6],
})
print(df_aux.flags)
df_aux.flags.allows_duplicate_labels = False
print(df_aux.flags)

<Flags(allows_duplicate_labels=True)>
<Flags(allows_duplicate_labels=False)>

Método set_flags():

Sinalizadores.

DataFrame.set_flags(allows_duplicate_labels=None)

Método memory_usage()

Retorna o uso em bytes de memória de cada coluna.

DataFrame.memory_usage(index=True, deep=False)

O uso de memória pode incluir opcionalmente a contribuição do índice e elementos do tipo de objeto.

print(df_pessoas.memory_usage())

Index      128
Nome        32
Idade       32
Altura      32
Sexo        32
Peso        32
IMC         32
Salario     32
dtype: int64

Este valor é exibido em DataFrame.info() por padrão. Isso pode ser suprimido definindo pandas.options.display.memory_usage como False.

Método astype()

Converter para tipo especificado.

DataFrame.astype(dtype, copy=None, errors='raise')

Converte um objeto pandas para um dtype especificado.

df_aux = df_pessoas.copy()
df_aux['Idade'] = df_aux['Idade'].astype(float)
print(df_aux)

      Nome  Idade  Altura Sexo  Peso   IMC  Salario
0  Roberto   25.0     165    M    65  22.2     2500
1   Rosana   30.0     180    F    70  23.4     3000
2    Pedro   35.0     175    M    75  25.6     3500
3     Dora   40.0     185    F    80  27.8     4000

Método convert_dtypes()

Conversão de tipos.

DataFrame.convert_dtypes(infer_objects=True, convert_string=True, convert_integer=True, convert_boolean=True, convert_floating=True, dtype_backend='numpy_nullable')

Converte colunas nos melhores dtypes possíveis usando dtypes que suportam pd.NA.

print(df_pessoas.convert_dtypes())

      Nome  Idade  Altura Sexo  Peso   IMC  Salario
0  Roberto     25     165    M    65  22.2     2500
1   Rosana     30     180    F    70  23.4     3000
2    Pedro     35     175    M    75  25.6     3500
3     Dora     40     185    F    80  27.8     4000

Método infer_objects()

Inferência de tipo.

DataFrame.infer_objects(copy=None)

Tenta inferir melhores dtypes para colunas de objetos, com a conversão suave de colunas de tipos de objetos conversíveis, deixando inalteradas colunas não-objeto e não conversíveis.

As regras de inferência são as mesmas da construção normal de Série/DataFrame.

df_aux = df_pessoas.copy()
print("*** antes")
print(df_aux.info())
print()
df_aux['Salario'] = df_aux['Salario'].infer_objects()
print("*** depois")
print(df_aux.info())

*** antes
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 7 columns):
 #   Column   Non-Null Count  Dtype  
---  ------   --------------  -----  
 0   Nome     4 non-null      object 
 1   Idade    4 non-null      int64  
 2   Altura   4 non-null      int64  
 3   Sexo     4 non-null      object 
 4   Peso     4 non-null      int64  
 5   IMC      4 non-null      float64
 6   Salario  4 non-null      int64  
dtypes: float64(1), int64(4), object(2)
memory usage: 352.0+ bytes
None

*** depois
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 7 columns):
 #   Column   Non-Null Count  Dtype  
---  ------   --------------  -----  
 0   Nome     4 non-null      object 
 1   Idade    4 non-null      int64  
 2   Altura   4 non-null      int64  
 3   Sexo     4 non-null      object 
 4   Peso     4 non-null      int64  
 5   IMC      4 non-null      float64
 6   Salario  4 non-null      int64  
dtypes: float64(1), int64(4), object(2)
memory usage: 352.0+ bytes
None

Método copy()

Cópia de Dataframe.

DataFrame.copy(deep=None)

Faça uma cópia dos índices e dados do DataFrame.

Quando deep=True(padrão), um novo objeto será criado com uma cópia dos dados e índices do objeto chamador. Modificações nos dados ou índices da cópia não serão refletidas no objeto original.

Quando deep=False, um novo objeto será criado sem copiar os dados ou índice do objeto chamador (somente as referências aos dados e ao índice são copiadas). Quaisquer alterações nos dados do original serão refletidas na cópia superficial (e vice-versa).

df_copia = df_pessoas.copy()
df_copia['Idade'] = 50
print(df_copia)

      Nome  Idade  Altura Sexo  Peso   IMC  Salario
0  Roberto     50     165    M    65  22.2     2500
1   Rosana     50     180    F    70  23.4     3000
2    Pedro     50     175    M    75  25.6     3500
3     Dora     50     185    F    80  27.8     4000

Método head()

Retorne as primeiras n linhas.

DataFrame.head(n=5)

Esta função retorna as primeiras n linhas do objeto com base na posição. É útil para testar rapidamente se o seu objeto contém o tipo certo de dados.

Para valores negativos de n , esta função retorna todas as linhas, exceto a última |n| linhas, equivalente a df[:n].

Se n for maior que o número de linhas, esta função retornará todas as linhas.

print(df_pessoas.head(2))

      Nome  Idade  Altura Sexo  Peso   IMC  Salario
0  Roberto     25     165    M    65  22.2     2500
1   Rosana     30     180    F    70  23.4     3000

Método tail()

Retornar as últimas n linhas.

DataFrame.tail(n=5)

Esta função retorna as últimas n linhas do objeto com base na posição. É útil para verificar dados rapidamente, por exemplo, após classificar ou anexar linhas.

Para valores negativos de n , esta função retorna todas as linhas, exceto as primeiras |n| linhas, equivalente a df[|n|:].

Se n for maior que o número de linhas, esta função retornará todas as linhas.

print(df_pessoas.tail(2))

    Nome  Idade  Altura Sexo  Peso   IMC  Salario
2  Pedro     35     175    M    75  25.6     3500
3   Dora     40     185    F    80  27.8     4000

Propriedade loc[]

Localização por rótulo.

DataFrame.loc[rótulo]

Acesse um grupo de linhas e colunas por rótulo(s) ou uma matriz booleana.

.loc[] é principalmente baseado em rótulo, mas também pode ser usado com uma matriz booleana.

As entradas permitidas são:

• Um único rótulo, por exemplo, 5ou 'a', (observe que 5é interpretado como um rótulo do índice e nunca como uma posição inteira ao longo do índice).
• Uma lista ou matriz de rótulos, por exemplo .['a', 'b', 'c']
• Um objeto de fatia com rótulos, por exemplo 'a':'f'. Aviso: Observe que, ao contrário das fatias normais do python, tanto o início quanto o fim estão incluídos
• Uma matriz booleana do mesmo comprimento do eixo que está sendo fatiado, por exemplo .[True, False, True]
• Uma série booleana alinhável. O índice da chave será alinhado antes do mascaramento.
• Um índice alinhável. O índice da seleção retornada será a entrada.
• Uma função chamável com um argumento (a série de chamada ou DataFrame) e que retorna uma saída válida para indexação (uma das opções acima)

print(df_pessoas.loc[1:2,['Nome','Idade']])

     Nome  Idade
1  Rosana     30
2   Pedro     35

Propriedade at()

Acessar um único valor para um par de rótulos de linha/coluna

DataFrame.at[rótulo]

Semelhante a loc, pois ambos fornecem pesquisas baseadas em rótulos. Use at() se você precisar apenas obter ou definir um único valor em um DataFrame ou Série.

print(df_pessoas.at[1, 'Nome'])

Rosana

Propriedade iloc()

Localização por posição.

DataFrame.iloc[pos]

Indexação puramente baseada em localização inteira para seleção por posição.

.iloc[] é principalmente baseado em posição inteira (de 0 a tamanho-1 do eixo), mas também pode ser usado com uma matriz booleana.

As entradas permitidas são:

• Um número inteiro, por exemplo 5.
• Uma lista ou matriz de números inteiros, por exemplo .[4, 3, 0]
• Um objeto de fatia com ints, por exemplo 1:7.
• Uma matriz booleana.
• Uma função chamável com um argumento (a série de chamada ou DataFrame) e que retorna uma saída válida para indexação (uma das opções acima). Isto é útil em cadeias de métodos, quando você não tem uma referência ao objeto chamador, mas gostaria de basear sua seleção em algum valor.
• Uma tupla de índices de linha e coluna. Os elementos da tupla consistem em uma das entradas acima, por exemplo .(0, 1)

.iloc aumentará IndexError se um indexador solicitado estiver fora dos limites, exceto indexadores de fatia que permitem indexação fora dos limites (isso está em conformidade com a semântica de fatia python/numpy).

Valor na posição (2, 0).

print(df_pessoas.iloc[2,0])

Pedro

Propriedade iat()

Retorna valor de linha/coluna.

DataFrame.iat[linha, coluna]

Acesse um único valor para um par de linha/coluna por posição inteira.

Semelhante a iloc, pois ambos fornecem pesquisas baseadas em números inteiros. Use iat se você precisar apenas obter ou definir um único valor em um DataFrame ou Série.

print(df_pessoas.iat[2, 2])

175

Método query()

Consulta as colunas de um DataFrame com uma expressão booleana.

DataFrame.query(expr, *, inplace = False, ** kwargs)

Seleção usando query para Idade > 30 com o DataFrame df_pessoas.

print(df_pessoas.query("Idade > 30"))

    Nome  Idade  Altura Sexo  Peso   IMC  Salario
2  Pedro     35     175    M    75  25.6     3500
3   Dora     40     185    F    80  27.8     4000

Os operadores aritméticos (+ , - , * , / , // , % , **) equivalem às funções binárias (add , sub , mul , div , floordiv , mod , pow).

Os operadores de comparação (== , != , <= , < , >= , >) equivalem às funções binárias (eq , ne , le , lt , ge , gt).

DataFrames df1() e df2 de exemplo

import pandas as pd

# Criar dois DataFrames de exemplo
df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'A': [7, 8, 9], 'B': [10, 11, 12]})
print("df1", df1)
print()
print("df2", df2)

Método add()

Adição de dataframes.

DataFrame.add(DataFrame.add(outro, axis='columns', level=None, fill_value=None))

Obtenha adição de dataframe e outros elementos (operador binário add ).

Equivalente a DataFrame + outro, mas com suporte para substituir um fill_value por dados faltantes em uma das entradas.

A função radd() é a versão reversa.

print(df1.add(df2))

    A   B
0   8  14
1  10  16
2  12  18

Método sub()

Subtração de dataframes.

DataFrame.sub(DataFrame.sub(outro, axis='columns', level=None, fill_value=None))

Obtenha subtração de dataframe e outros, elemento a elemento (operador binário sub).

print(df1.sub(df2))

   A  B
0 -6 -6
1 -6 -6
2 -6 -6

Equivalente a DataFrame - outro, mas com suporte para substituir um fill_value por dados faltantes em uma das entradas.

A função rsub() é a versão reversa.

Método mul()

Multiplicação de dataframes.

DataFrame.mul(DataFrame.mul(outro, axis='columns', level=None, fill_value=None))

Obtenha a multiplicação de dataframe e outros elementos (operador binário mul ).

print(df1.mul(df2))

    A   B
0   7  40
1  16  55
2  27  72

Equivalente a DataFrame * outro, mas com suporte para substituir um fill_value por dados faltantes em uma das entradas.

A função rmul() é a versão reversa.

Método div()

Divisão de dataframes.

DataFrame.div(DataFrame.div(outro, axis='columns', level=None, fill_value=None))

Obtenha a divisão flutuante do dataframe e outros elementos (operador binário truediv ).

print(df1.div(df2))

          A         B
0  0.142857  0.400000
1  0.250000  0.454545
2  0.333333  0.500000

Equivalente a DataFrame / outro, mas com suporte para substituir um fill_value por dados faltantes em uma das entradas.

A função rtruediv() é a versão reversa.

Método floordiv()

Divisão flutuante de dataframes.

DataFrame.floordiv(DataFrame.floordiv(outro, axis='columns', level=None, fill_value=None))

Obtenha a divisão inteira do dataframe e outros elementos (operador binário floordiv ).

print(df1.floordiv(df2))

   A  B
0  0  0
1  0  0
2  0  0

Equivalente a DataFrame // outro, mas com suporte para substituir um fill_value por dados faltantes em uma das entradas.

A função rfloordiv() é a versão reversa.

Método mod()

Módulo de dataframes.

DataFrame.mod(DataFrame.mod(outro, axis='columns', level=None, fill_value=None))

Obtenha o módulo do dataframe e outros elementos (operador binário mod ).

print(df1.mod(df2))

   A  B
0  1  4
1  2  5
2  3  6

Equivalente a DataFrame % outro, mas com suporte para substituir um fill_value por dados faltantes em uma das entradas.

A função rmod() é a versão reversa.

Método pow()

Potência de dataframes.

DataFrame.pow(DataFrame.pow(outro, axis='columns', level=None, fill_value=None))

Obtenha o poder exponencial do dataframe e outros elementos (operador binário pow).

print(df1.pow(df2))

       A           B
0      1     1048576
1    256    48828125
2  19683  2176782336

Equivalente a DataFrame ** outro, mas com suporte para substituir um fill_value por dados faltantes em uma das entradas.

A função rpow() é a versão reversa.

Método eq()

Verificação de Igualdade.

Obtenha igual a dataframe e outro, elemento a elemento (operador binário eq).

print(df1.eq(df2))

       A      B
0  False  False
1  False  False
2  False  False

Equivalente a DataFrame == outro, mas com suporte para substituir um fill_value por dados faltantes em uma das entradas.

Método combine()

Combinação de DataFrames.

DataFrame.combine(outro, func, fill_value=None, overwrite=True)

Execute a combinação em colunas com outro DataFrame.

df3 = pd.DataFrame({'A': [10, 20, 30], 'B': [40, 50, 60]})
print(df1.combine(df3, lambda x, y: x if x[0] > y[0] else y))

    A   B
0  10  40
1  20  50
2  30  60

Combina um DataFrame com outro DataFrame usando func para combinar colunas elemento a elemento. Os índices de linha e coluna do DataFrame resultante serão a união dos dois.

Método combine_first()

Combinação de índices.

DataFrame.combine_first(outro)

Atualize elementos nulos com valor no mesmo local em other .

df4 = pd.DataFrame({'A': [5, 6, 7], 'B': [11, 12, 13]})
combinado_primeiro = df1.combine_first(df4)
print(combinado_primeiro)

   A  B
0  1  4
1  2  5
2  3  6

Combine dois objetos DataFrame preenchendo valores nulos em um DataFrame com valores não nulos de outro DataFrame.

Os índices de linha e coluna do DataFrame resultante serão a união dos dois.

O dataframe resultante contém os 'primeiros' valores do dataframe e substitui os valores do segundo, onde first.loc[index, col] e second.loc[index, col] não são valores ausentes, ao chamar first.combine_first(second).

Método apply()

Aplique uma função ao longo de um eixo do DataFrame.

DataFrame.apply(func, axis=0, raw=False, result_type=None, args=(), by_row='compat', **kwargs)

Os objetos passados ​​para a função são objetos Series cujo índice é o índice do DataFrame ( axis=0) ou as colunas do DataFrame ( axis=1).

Por padrão (result_type=None), o tipo de retorno final é inferido do tipo de retorno da função aplicada. Caso contrário, depende do argumento result_type.

O exemplo a seguir cria um DataFrame de exemplo e aplica uma função para cada elemento.

def duplicar_idade(x):
    return x * 2
#
df_pessoas['Idade_Duplicada'] = df_pessoas['Idade'].apply(duplicar_idade)
print(df_pessoas)

      Nome  Idade  Altura Sexo  Peso   IMC  Salario  Idade_Duplicada
0  Roberto     25     165    M    65  22.2     2500               50
1   Rosana     30     180    F    70  23.4     3000               60
2    Pedro     35     175    M    75  25.6     3500               70
3     Dora     40     185    F    80  27.8     4000               80

Método map()

Aplicar uma função a um Dataframe elemento a elemento.

DataFrame.map(func, na_action=None, **kwargs)

Este método aplica uma função que aceita e retorna um escalar para cada elemento de um DataFrame.

def saudacao(nome):
    return f"Olá, {nome}"

df_pessoas['Saudacao'] = df_pessoas['Nome'].map(saudacao)
print(df_pessoas)

      Nome  Idade  Altura Sexo  Peso   IMC  Salario  Idade_Duplicada      Saudacao
0  Roberto     25     165    M    65  22.2     2500               50  Olá, Roberto
1   Rosana     30     180    F    70  23.4     3000               60   Olá, Rosana
2    Pedro     35     175    M    75  25.6     3500               70    Olá, Pedro
3     Dora     40     185    F    80  27.8     4000               80     Olá, Dora

Método agg()

Agregue usando uma ou mais operações no eixo especificado.

DataFrame.agg(func, axis=0, *args, **kwargs)

Agregação da média da Idade e soma do Salário.

print(df_pessoas.agg({'Idade': 'mean', 'Salario': 'sum'}))

Idade         32.5
Salario    13000.0
dtype: float64

Método transform()

Transformação, com DataFrame após normalização da Idade por Salário.

DataFrame.transform(func, axis=0, *args, **kwargs)

Passe uma funcão como argumento para retornar um DataFrame com o mesmo formato de eixo que o DataFrame de origem.

def normalizar_idade(x):
    return (x - x.mean()) / x.std()

df_pessoas['Idade_Normalizada'] = df_pessoas.groupby('Salario')['Idade'].transform(normalizar_idade)
print(df_pessoas)

      Nome  Idade  Altura Sexo  Peso   IMC  Salario  Idade_Duplicada      Saudacao  Idade_Normalizada
0  Roberto     25     165    M    65  22.2     2500               50  Olá, Roberto                NaN
1   Rosana     30     180    F    70  23.4     3000               60   Olá, Rosana                NaN
2    Pedro     35     175    M    75  25.6     3500               70    Olá, Pedro                NaN
3     Dora     40     185    F    80  27.8     4000               80     Olá, Dora                NaN

Método rolling()

Fornece cálculos de janela rolante.

DataFrame.rolling(janela, min_periods=None, center=False, win_type=None, on=None, axis=_NoDefault.no_default, closed=None, step=None, method='single')

Janelas rolantes genéricas suportam a especificação de janelas como um número fixo de observações ou um número variável de observações com base em um deslocamento.

Se um deslocamento baseado em tempo for fornecido, o índice baseado em tempo correspondente deverá ser monotônico.

print(df_pessoas['Salario'].rolling(window=2).mean())

0       NaN
1    2750.0
2    3250.0
3    3750.0
Name: Salario, dtype: float64

Método ewm()

Média Ponderada Exponencial.

DataFrame.ewm(com=None, span=None, halflife=None, alpha=None, min_periods=0, Adjust=True, ignore_na=False, axis=_NoDefault.no_default, times=None, method='single')

Fornece cálculos ponderados exponencialmente (EW).

media_ponderada = df_pessoas['Idade'].ewm(span=2).mean()
print(media_ponderada)

0    25.000000
1    28.750000
2    33.076923
3    37.750000
Name: Idade, dtype: float64

O exemplo a seguir cria um DataFrame de exemplo e aplica uma função para cada elemento.

Criar um DataFrame de exemplo:

Método abs()

Valores numéricos absolutos.

DataFrame.abs()

Retorna uma Série/DataFrame com o valor numérico absoluto de cada elemento.

Esta função se aplica apenas a elementos numéricos.

print(df_pessoas[['Idade', 'Salario']].abs())

   Idade  Salario
0     25     2500
1     30     3000
2     35     3500
3     40     4000

Método all()

Testa se todos valores são verdadeiros.

DataFrame.all(axis=0, bool_only=False, skipna=True, **kwargs)

Retorna se todos os elementos são Verdadeiros, potencialmente sobre um eixo.

Retorna True, a menos que haja pelo menos um elemento dentro de uma série ou ao longo de um eixo do Dataframe que seja False ou equivalente (por exemplo, zero ou vazio).

print(df_pessoas.all())

Nome                 True
Idade                True
Altura               True
Sexo                 True
Peso                 True
IMC                  True
Salario              True
Idade_Duplicada      True
Saudacao             True
Idade_Normalizada    True
dtype: bool

Método any()

Qualquer valor booleano.

print(df_pessoas.any())

Nome                  True
Idade                 True
Altura                True
Sexo                  True
Peso                  True
IMC                   True
Salario               True
Idade_Duplicada       True
Saudacao              True
Idade_Normalizada    False
dtype: bool

Método corr()

Correlação de Pares entre Colunas.

print(df_pessoas.corr())

                      Idade    Altura      Peso       IMC   Salario  Idade_Duplicada  Idade_Normalizada
Idade              1.000000  0.831522  1.000000  0.991792  1.000000         1.000000                NaN
Altura             0.831522  1.000000  0.831522  0.777346  0.831522         0.831522                NaN
Peso               1.000000  0.831522  1.000000  0.991792  1.000000         1.000000                NaN
IMC                0.991792  0.777346  0.991792  1.000000  0.991792         0.991792                NaN
Salario            1.000000  0.831522  1.000000  0.991792  1.000000         1.000000                NaN
Idade_Duplicada    1.000000  0.831522  1.000000  0.991792  1.000000         1.000000                NaN
Idade_Normalizada       NaN       NaN       NaN       NaN       NaN              NaN                NaN

Dados estatísticos dos salários do dataframe de pessoas df_pessoas.

salarios = df_pessoas['Salario']
print(f"Média....................: {salarios.mean()}")
print(f"Máximo...................: {salarios.max()}")
print(f"Mínimo...................: {salarios.min()}")
print(f"Módulo...................:\n{salarios.mode()}")
print(f"Mediana..................: {salarios.median()}")
print(f"Moda.....................:\n{salarios.mode()}")
print(f"Variação.................: {salarios.var()}")
print(f"Desvio Padrão............: {salarios.std()}")
print(f"Inclinação...............: {salarios.skew()}")
print(f"Curtose..................: {salarios.kurt()}")
print(f"Curtose..................: {salarios.kurtosis()}")
print(f"Quartis..................: {salarios.quantile()}")
print(f"Classificações...........:\n{salarios.rank()}")
print(f"Arredondamento...........:\n{salarios.round()}")
print(f"Arredondamento 2 casas...:\n{salarios.round(2)}")
print(f"Soma.....................: {salarios.sum()}")
print(f"Distintos................: {salarios.nunique()}")
print(f"Contagem de Distintos ...:\n{salarios.value_counts()}")

Média....................: 3250.0
Máximo...................: 4000
Mínimo...................: 2500
Módulo...................:
0    2500
1    3000
2    3500
3    4000
Name: Salario, dtype: int64
Mediana..................: 3250.0
Moda.....................:
0    2500
1    3000
2    3500
3    4000
Name: Salario, dtype: int64
Variação.................: 416666.6666666667
Desvio Padrão............: 645.4972243679028
Inclinação...............: 0.0
Curtose..................: -1.1999999999999993
Curtose..................: -1.1999999999999993
Quartis..................: 3250.0
Classificações...........:
0    1.0
1    2.0
2    3.0
3    4.0
Name: Salario, dtype: float64
Arredondamento...........:
0    2500
1    3000
2    3500
3    4000
Name: Salario, dtype: int64
Arredondamento 2 casas...:
0    2500
1    3000
2    3500
3    4000
Name: Salario, dtype: int64
Soma.....................: 13000
Distintos................: 4
Contagem de Distintos ...:
2500    1
3000    1
3500    1
4000    1
Name: Salario, dtype: int64

Método add_prefix()

DataFrame com prefixo nos rótulos das colunas.

print(df_pessoas.add_prefix('Pref_'))

  Pref_Nome  Pref_Idade  Pref_Altura Pref_Sexo  Pref_Peso  Pref_IMC  Pref_Salario  Pref_Idade_Duplicada Pref_Saudacao  Pref_Idade_Normalizada
0   Roberto          25          165         M         65      22.2          2500                    50  Olá, Roberto                     NaN
1    Rosana          30          180         F         70      23.4          3000                    60   Olá, Rosana                     NaN
2     Pedro          35          175         M         75      25.6          3500                    70    Olá, Pedro                     NaN
3      Dora          40          185         F         80      27.8          4000                    80     Olá, Dora                     NaN

Método add_suffix()

DataFrame com sufixo nos rótulos das colunas

print(df_pessoas.add_suffix('_Suff'))

  Nome_Suff  Idade_Suff  Altura_Suff Sexo_Suff  Peso_Suff  IMC_Suff  Salario_Suff  Idade_Duplicada_Suff Saudacao_Suff  Idade_Normalizada_Suff
0   Roberto          25          165         M         65      22.2          2500                    50  Olá, Roberto                     NaN
1    Rosana          30          180         F         70      23.4          3000                    60   Olá, Rosana                     NaN
2     Pedro          35          175         M         75      25.6          3500                    70    Olá, Pedro                     NaN
3      Dora          40          185         F         80      27.8          4000                    80     Olá, Dora                     NaN

Método filter()

DataFrame com colunas 'Nome' e 'Idade' mantidas

print(df_pessoas.filter(items=['Nome', 'Idade'], axis=1))

      Nome  Idade
0  Roberto     25
1   Rosana     30
2    Pedro     35
3     Dora     40

Método rename()

DataFrame com a coluna 'Nome' renomeada para 'Nome Completo'

print(df_pessoas.rename(columns={'Nome': 'Nome Completo'}))

  Nome Completo  Idade  Altura Sexo  Peso   IMC  Salario  Idade_Duplicada      Saudacao  Idade_Normalizada
0       Roberto     25     165    M    65  22.2     2500               50  Olá, Roberto                NaN
1        Rosana     30     180    F    70  23.4     3000               60   Olá, Rosana                NaN
2         Pedro     35     175    M    75  25.6     3500               70    Olá, Pedro                NaN
3          Dora     40     185    F    80  27.8     4000               80     Olá, Dora                NaN

Método reindex()

DataFrame com novo índice.

print(df_pessoas.reindex(['a', 'b', 'c', 'd']))

  Nome  Idade  Altura Sexo  Peso  IMC  Salario  Idade_Duplicada Saudacao  Idade_Normalizada
a  NaN    NaN     NaN  NaN   NaN  NaN      NaN              NaN      NaN                NaN
b  NaN    NaN     NaN  NaN   NaN  NaN      NaN              NaN      NaN                NaN
c  NaN    NaN     NaN  NaN   NaN  NaN      NaN              NaN      NaN                NaN
d  NaN    NaN     NaN  NaN   NaN  NaN      NaN              NaN      NaN                NaN

Método sample()

Amostra aleatória de 2 linhas do DataFrame

print(df_pessoas.sample(n=2))

     Nome  Idade  Altura Sexo  Peso   IMC  Salario  Idade_Duplicada     Saudacao  Idade_Normalizada
1  Rosana     30     180    F    70  23.4     3000               60  Olá, Rosana                NaN
3    Dora     40     185    F    80  27.8     4000               80    Olá, Dora                NaN

Criação do DataFrame

import pandas as pd
import numpy as np

# Criar um DataFrame de exemplo com valores ausentes
data = {'A': [1, 2, np.nan, 4, 5],
        'B': [np.nan, 2, 3, 4, np.nan]}

df_limpar = pd.DataFrame(data)

print(df_limpar)

     A    B
0  1.0  NaN
1  2.0  2.0
2  NaN  3.0
3  4.0  4.0
4  5.0  NaN

Método isna()

Retorna True para existência de valores ausentes e False para todos valores existentes.

print(df_limpar.isna())

       A      B
0  False   True
1  False  False
2   True  False
3  False  False
4  False   True

Método isnull

Retorna True para valores ausentes, isnull é um alias para isna.

print(df_limpar.isnull())

       A      B
0  False   True
1  False  False
2   True  False
3  False  False
4  False   True

Método notna()

Retorna True para todos valores existentes e False para valores ausentes.

print(df_limpar.notna())

       A      B
0   True  False
1   True   True
2  False   True
3   True   True
4   True  False

Método notnull()

Retorna True para todos valores existentes, notnull é um alias para notna.

print(df_limpar.notnull())

       A      B
0   True  False
1   True   True
2  False   True
3   True   True
4   True  False

Método dropna()

Retorna a série com os valores ausentes removidos.

print(df_limpar.dropna())

     A    B
1  2.0  2.0
3  4.0  4.0

Método fillna()

Retorna a série com os valores NA/NaN preenchidos usando o método especificado.

print(df_limpar.fillna(0))

     A    B
0  1.0  0.0
1  2.0  2.0
2  0.0  3.0
3  4.0  4.0
4  5.0  0.0

Método bfill()

Retorna a série com os valores NA/NaN preenchidos usando a último observação válida para preencher a lacuna.

print(df_limpar.bfill())

     A    B
0  1.0  2.0
1  2.0  2.0
2  4.0  3.0
3  4.0  4.0
4  5.0  NaN

Método ffill()

Retorna a série com os valores NA/NaN preenchidos propagando a último observação válida para a último

print(df_limpar.ffill())

     A    B
0  1.0  NaN
1  2.0  2.0
2  2.0  3.0
3  4.0  4.0
4  5.0  4.0

Método replace()

Retorna a série com os valores NA/NaN substituidos com os valores fornecidos.

print(df_limpar.replace(0))

     A    B
0  1.0  NaN
1  2.0  2.0
2  NaN  3.0
3  4.0  4.0
4  5.0  NaN

Método interpolate()

Retorna a serie com os valores NaN preenchidos usando um método de interpolação.

print(df_limpar.interpolate())

     A    B
0  1.0  NaN
1  2.0  2.0
2  3.0  3.0
3  4.0  4.0
4  5.0  4.0

Método Pad()

(Obsoleto) Retorna a série com os valores NA/NaN propagando a última observação válida para a último

print(df_limpar.pad())

     A    B
0  1.0  NaN
1  2.0  2.0
2  2.0  3.0
3  4.0  4.0
4  5.0  4.0

sort_values(): Ordenação

Retorna o dataframe ordenado pelo valor em cada coluna.

print(df_cidades.sort_values(by='Cidade'))

           Cidade                  Bairros        Mês  Vendas
0  Belo Horizonte         [Sion, Pampulha]    Janeiro     100
2  Rio de Janeiro     [Leblon, Copacabana]    Janeiro      90
3        Salvador  [Pelourinho, Liberdade]  Fevereiro     120
1       São Paulo     [Morumbi, Liberdade]  Fevereiro     150

sort_index(): Classificação

Retorna o objeto ordenado por rótulos ao longo de um eixo.

print(df_cidades.sort_index())

           Cidade                  Bairros        Mês  Vendas
0  Belo Horizonte         [Sion, Pampulha]    Janeiro     100
1       São Paulo     [Morumbi, Liberdade]  Fevereiro     150
2  Rio de Janeiro     [Leblon, Copacabana]    Janeiro      90
3        Salvador  [Pelourinho, Liberdade]  Fevereiro     120

pivot(): Remodelamento

Retorna o dataframe remodelado organizado por determinados valores de índice/coluna.

print(df_cidades.pivot(index='Cidade', columns='Mês', values='Vendas'))

Mês             Fevereiro  Janeiro
Cidade                            
Belo Horizonte        NaN    100.0
Rio de Janeiro        NaN     90.0
Salvador            120.0      NaN
São Paulo           150.0      NaN

pivot_table(): Tabela dinâmica

Retorna uma tabela dinâmica em estilo de planilha como um dataframe.

tb_pivot = df_cidades.pivot_table(index='Cidade', columns='Mês', values='Vendas', aggfunc='sum')
print(tb_pivot)

Mês             Fevereiro  Janeiro
Cidade                            
Belo Horizonte        NaN    100.0
Rio de Janeiro        NaN     90.0
Salvador            120.0      NaN
São Paulo           150.0      NaN

melt(): Fundir

Retorna o dataframe distorcido do formato largo para o formato longo, deixando opcionalmente os identificadores definidos.

print(df_cidades.melt(id_vars=['Cidade', 'Mês'], value_vars=['Vendas'], var_name='Variável', value_name='Valor')) 

           Cidade        Mês Variável  Valor
0  Belo Horizonte    Janeiro   Vendas    100
1       São Paulo  Fevereiro   Vendas    150
2  Rio de Janeiro    Janeiro   Vendas     90
3        Salvador  Fevereiro   Vendas    120

explode(): Explodir

Retorna o dataframe transformado com cada elemento de uma lista em uma linha, replicando os valores do índice.

print(df_cidades.explode('Bairros', ignore_index=True))

           Cidade     Bairros        Mês  Vendas
0  Belo Horizonte        Sion    Janeiro     100
1  Belo Horizonte    Pampulha    Janeiro     100
2       São Paulo     Morumbi  Fevereiro     150
3       São Paulo   Liberdade  Fevereiro     150
4  Rio de Janeiro      Leblon    Janeiro      90
5  Rio de Janeiro  Copacabana    Janeiro      90
6        Salvador  Pelourinho  Fevereiro     120
7        Salvador   Liberdade  Fevereiro     120

explode():

Explodir série:

s_lista = pd.Series({'A': [1, 2, 3], 'B': [4, 5], 'C': [6]})
print(s_lista.explode())

A    1
A    2
A    3
B    4
B    5
C    6
dtype: object

squeeze(): Comprimir, espremer

Retorna a série com os níveis unidimensionais em escalares dos objetos comprimidos.

print(df_cidades['Vendas'].squeeze())

0    100
1    150
2     90
3    120
Name: Vendas, dtype: int64

stack(): Empilhar

Retorna os níveis empilhados prescritos das colunas ao índice.

df_empilhado = df_cidades.stack()
print(df_empilhado)

0  Cidade              Belo Horizonte
   Bairros           [Sion, Pampulha]
   Mês                        Janeiro
   Vendas                         100
1  Cidade                   São Paulo
   Bairros       [Morumbi, Liberdade]
   Mês                      Fevereiro
   Vendas                         150
2  Cidade              Rio de Janeiro
   Bairros       [Leblon, Copacabana]
   Mês                        Janeiro
   Vendas                          90
3  Cidade                    Salvador
   Bairros    [Pelourinho, Liberdade]
   Mês                      Fevereiro
   Vendas                         120
dtype: object

unstack(): Desempilhar

Retorna os níveis desempilhados prescritos das colunas ao índice, dinamizando um nível dos rótulos de índice (necessariamente hierárquicos).

print(df_empilhado.unstack())

           Cidade                  Bairros        Mês Vendas
0  Belo Horizonte         [Sion, Pampulha]    Janeiro    100
1       São Paulo     [Morumbi, Liberdade]  Fevereiro    150
2  Rio de Janeiro     [Leblon, Copacabana]    Janeiro     90
3        Salvador  [Pelourinho, Liberdade]  Fevereiro    120

Desempilhamento multindexado (MultiIndex):

s_multindex = df_pessoas.set_index(['Nome', 'Idade'])
print(s_multindex.unstack())

        Altura                      Sexo                 Peso                     IMC        ... Salario         Idade_Duplicada                        Saudacao                                     Idade_Normalizada            
Idade       25     30     35     40   25   30   35   40    25    30    35    40    25    30  ...      35      40              25    30    35    40            25           30          35         40                25  30  35  40
Nome                                                                                         ...                                                                                                                                  
Dora       NaN    NaN    NaN  185.0  NaN  NaN  NaN    F   NaN   NaN   NaN  80.0   NaN   NaN  ...     NaN  4000.0             NaN   NaN   NaN  80.0           NaN          NaN         NaN  Olá, Dora               NaN NaN NaN NaN
Pedro      NaN    NaN  175.0    NaN  NaN  NaN    M  NaN   NaN   NaN  75.0   NaN   NaN   NaN  ...  3500.0     NaN             NaN   NaN  70.0   NaN           NaN          NaN  Olá, Pedro        NaN               NaN NaN NaN NaN
Roberto  165.0    NaN    NaN    NaN    M  NaN  NaN  NaN  65.0   NaN   NaN   NaN  22.2   NaN  ...     NaN     NaN            50.0   NaN   NaN   NaN  Olá, Roberto          NaN         NaN        NaN               NaN NaN NaN NaN
Rosana     NaN  180.0    NaN    NaN  NaN    F  NaN  NaN   NaN  70.0   NaN   NaN   NaN  23.4  ...     NaN     NaN             NaN  60.0   NaN   NaN           NaN  Olá, Rosana         NaN        NaN               NaN NaN NaN NaN

[4 rows x 32 columns]

droplevel(): Retirar o nível

Retorna a série/dataframe com níveis de índice/coluna solicitados removidos.

print(df_cidades.droplevel('Mês'))

KeyError: 'Requested level (Mês) does not match index name (None)' <traceback object at 0x0000018D2F6472C0>

stacklevel(): Nível de empilhamento

Retorna o nível de empilhamento do dataframe.

print(df_cidades.stacklevel())

AttributeError: 'DataFrame' object has no attribute 'stacklevel' <traceback object at 0x0000018D2F644A40>

unstacklevel(): Nível de desempilhamento

Retorna o nível de desempilhamento do dataframe.

print(df_cidades.unstacklevel())

AttributeError: 'DataFrame' object has no attribute 'unstacklevel' <traceback object at 0x0000018D2F646240>

swaplevel(): Trocar o nível

Troca os níveis i e j em a MultiIndex.

print(df_cidades.swaplevel('Cidade', 'Mês'))

TypeError: Can only swap levels on a hierarchical axis. <traceback object at 0x0000018D280B6F40>

reorder_levels(): Reordenar os níveis

Retorna os níveis reorganizados do índice usando a ordem de entrada.

print(df_cidades.reorder_levels(['Mês', 'Cidade']))

TypeError: Can only reorder levels on a hierarchical axis. <traceback object at 0x0000018D2F646500>

nlargest(): Retornar as primeiras n linhas ordenadas por colunas em ordem decrescente

Retorna as primeiras n linhas ordenadas por colunas em ordem decrescente.

print(df_cidades.nlargest(3, 'Vendas'))

           Cidade                  Bairros        Mês  Vendas
1       São Paulo     [Morumbi, Liberdade]  Fevereiro     150
3        Salvador  [Pelourinho, Liberdade]  Fevereiro     120
0  Belo Horizonte         [Sion, Pampulha]    Janeiro     100

nsmallest(): Retornar as primeiras n linhas ordenadas por colunas em ordem crescente

Retorna as primeiras n linhas ordenadas por colunas em ordem decrescente.

print(df_cidades.nsmallest(3, 'Vendas'))

           Cidade                  Bairros        Mês  Vendas
2  Rio de Janeiro     [Leblon, Copacabana]    Janeiro      90
0  Belo Horizonte         [Sion, Pampulha]    Janeiro     100
3        Salvador  [Pelourinho, Liberdade]  Fevereiro     120

to_xarray(): Conversão para xarray

Retorna o dataframe como um xarray.

print(df_cidades.to_xarray())

<xarray.Dataset>
Dimensions:  (index: 4)
Coordinates:
  * index    (index) int64 0 1 2 3
Data variables:
    Cidade   (index) object 'Belo Horizonte' 'São Paulo' ... 'Salvador'
    Bairros  (index) object ['Sion', 'Pampulha'] ... ['Pelourinho', 'Liberdade']
    Mês      (index) object 'Janeiro' 'Fevereiro' 'Janeiro' 'Fevereiro'
    Vendas   (index) int64 100 150 90 120

Atributo T

Retorna o dataframe transposto usando o atributo 'T'.

print(df_pessoas.T)

                              0            1           2          3
Nome                    Roberto       Rosana       Pedro       Dora
Idade                        25           30          35         40
Altura                      165          180         175        185
Sexo                          M            F           M          F
Peso                         65           70          75         80
IMC                        22.2         23.4        25.6       27.8
Salario                    2500         3000        3500       4000
Idade_Duplicada              50           60          70         80
Saudacao           Olá, Roberto  Olá, Rosana  Olá, Pedro  Olá, Dora
Idade_Normalizada           NaN          NaN         NaN        NaN

Método transpose()

Retorna o dataframe transposto usando o índice e colunas.

print(df_pessoas.transpose())

                              0            1           2          3
Nome                    Roberto       Rosana       Pedro       Dora
Idade                        25           30          35         40
Altura                      165          180         175        185
Sexo                          M            F           M          F
Peso                         65           70          75         80
IMC                        22.2         23.4        25.6       27.8
Salario                    2500         3000        3500       4000
Idade_Duplicada              50           60          70         80
Saudacao           Olá, Roberto  Olá, Rosana  Olá, Pedro  Olá, Dora
Idade_Normalizada           NaN          NaN         NaN        NaN

DataFrame df_id_nome exemplo

Criamos o dataframe df_id_nome com as colunas ID e Nome, usado nos exemplos.

df_id_nome = pd.DataFrame({
  'ID'   : [1, 2, 3, 4],
  'Nome' : ['Roberto', 'Rosana', 'Pedro', 'Dora']
})
print(df_id_nome)

   ID     Nome
0   1  Roberto
1   2   Rosana
2   3    Pedro
3   4     Dora

Retornamos em df_id_nome_salario o novo dataframe incluindo a coluna 'Salario'.

Método assign(): Atribuição de novas colunas.

Retorna um novo dataframe com novas colunas.

df_id_nome_salario = df_id_nome.assign(Salario=[2000, 4000, 3000, 5000])
print(df_id_nome_salario)

   ID     Nome  Salario
0   1  Roberto     2000
1   2   Rosana     4000
2   3    Pedro     3000
3   4     Dora     5000

O comando join junta as colunas do dataframe com as de outro dataframe usando o índice ou colunas-chave.

Vários dataframes podem ser ajuntados de forma eficiente por índice de uma só vez usando-se uma lista.

Retornamos em df_id_nome o dataframe com as colunas ID e Nome e em df_id_salario, o dataframe df_id_salario com as colunas ID e Salario e o dataframe df_id_idade com as colunas ID e Idade.:

Método compare()

df_id_nome = pd.DataFrame({
  'ID'  : [1, 2, 3, 4],
  'Nome': ['Roberto', 'Rosana', 'Pedro', 'Dora']
})

df_id_salario = pd.DataFrame({
  'ID'     : [1, 2, 3, 4],
  'Salario': [3000, 2000, 5000, 4000]
})

df_id_idade = pd.DataFrame({
  'ID'   : [1, 2, 3, 4],
  'Idade': [61, 60, 29, 93]
})

df_id_nome_salario = df_id_nome.set_index('ID').compare(df_id_salario.set_index('ID'))
print(df_id_nome_salario)

print()

df_id_nome_idade = df_id_nome.set_index('ID').compare(df_id_idade.set_index('ID'))
print(df_id_nome_idade)

ValueError: Can only compare identically-labeled DataFrame objects <traceback object at 0x0000018D2FB33F80>

Método compare()

Diferenças.

print(df1.compare(df2, keep_shape=True))

     A          B      
  self other self other
0    1     7    4    10
1    2     8    5    11
2    3     9    6    12

Método join()

Retorna a junção de dois dataframes.

df_id_nome_salario_idade = df_id_nome.set_index('ID').join([
    df_id_salario.set_index('ID'),
    df_id_idade.set_index('ID')])
print(df_id_nome_salario_idade)

       Nome  Salario  Idade
ID                         
1   Roberto     3000     61
2    Rosana     2000     60
3     Pedro     5000     29
4      Dora     4000     93

data1 = {
  'ID': [1, 2, 3, 4],
  'Nome': ['Roberto', 'Rosana', 'Pedro', 'Dora'],
  'Salario': [50000, 60000, 75000, 80000]
}
df1 = pd.DataFrame(data1)

data2 = {
  'ID': [3, 4, 5, 6],
  'Nome': ['Pedro', 'Dora', 'Lúcia', 'Renato'],
  'Salario': [75000, 80000, 65000, 50000]
}
df2 = pd.DataFrame(data2)

Método merge()

Retorna a junção de dois dataframes.

print(df1.merge(df2, on='ID', how='inner'))

   ID Nome_x  Salario_x Nome_y  Salario_y
0   3  Pedro      75000  Pedro      75000
1   4   Dora      80000   Dora      80000

Método update()

Retorna o dataframe com as colunas atualizadas.

print(df1.update(df2, overwrite=True))

None

Exemplo:

# Criar uma série temporal de exemplo
data_vendas = {
  'Data'   : pd.date_range(start='2023-01-01', periods=14, freq='D'),
  'Vendas' : [100, 120, 140, 160, np.nan, 150, 110, 180, np.nan, 170, 200, np.nan, 140, 120]
}
df_vendas = pd.DataFrame(data_vendas)
df_vendas.set_index('Data', inplace=True)

asfreq(): Conversão para frequêcia especificada

Retorna as séries temporais convertidas com a frequência especificada.

DataFrame.asfreq(freq, method=None, how=None, normalize=False, fill_value=None)

O método asfreq() converte séries temporais em frequência especificada, retornando os dados originais conformados a um novo índice com a frequência especificada.

Se o índice dasérie/dataframe for a PeriodIndex, o novo índice será o resultado da transformação do índice original com PeriodIndex.asfreq(portanto, o índice original será mapeado um a um para o novo índice).

Caso contrário, o novo índice será equivalente a where sendo, respectivamente, a primeira e a última entrada no índice original. Os valores correspondentes a quaisquer intervalos de tempo no novo índice que não estavam presentes no índice original serão nulos, a menos que seja fornecido um método para preencher tais incógnitas.

print(df_vendas.asfreq(freq='W', method='pad'))

            Vendas
Data              
2023-01-01   100.0
2023-01-08   180.0

asof(): Primeiras linhas sem NaN

Retorna as primeiras linhas sem nenhum NaN.

DataFrame.asof(where, subset=None)

Se houver alguma coluna com NaN nas linhas seguintes, será retornada a última linha anterior sem nenhum NaN, senão será retornado NaN.

date_to_asof = pd.to_datetime('2023-01-03')
asof_result = df_vendas.asof(date_to_asof)
print(asof_result)

Vendas    140.0
Name: 2023-01-03 00:00:00, dtype: float64

shift(): Indice de deslocamento

Retorna o índice de deslocamento pelo número desejado de períodos com uma frequência de tempo opcional.

DataFrame.shift(periods=1, freq=None, axis=0, fill_value=_NoDefault.no_default, suffix=None)

Índice de deslocamento pelo número desejado de períodos com uma frequência de tempo opcional como argumento.

Quando freq não for passado, mude o índice sem realinhar os dados.

Se freq for passado (nesse caso, o índice deve ser date ou datetime, ou gerará um NotImplementedError), o índice será aumentado usando os pontos e o freq.

O argumento freq pode ser inferido quando especificado como “inferir”, desde que o atributo freq ou inferred_freq esteja definido no índice.

print(df_vendas.shift(periods=2, freq='D'))

            Vendas
Data              
2023-01-03   100.0
2023-01-04   120.0
2023-01-05   140.0
2023-01-06   160.0
2023-01-07     NaN
2023-01-08   150.0
2023-01-09   110.0
2023-01-10   180.0
2023-01-11     NaN
2023-01-12   170.0
2023-01-13   200.0
2023-01-14     NaN
2023-01-15   140.0
2023-01-16   120.0

first_valid_index(): Primeiro valor não-NA

Retorna o índice para o primeiro valor não-NA ou None, se nenhum valor não-NA for encontrado.

DataFrame.first_valid_index()

O método retorna o índice do primeiro valor não-NA ou None se nenhum valor não-NA for encontrado.

print(df_vendas['Vendas'].first_valid_index())

2023-01-01 00:00:00

last_valid_index(): Ultimo valor não-NA

Retorna o índice para o último valor não-NA ou Nenhum, se nenhum valor não-NA for encontrado.

DataFrame.last_valid_index()

Último valor não-NA.

Índice de retorno para o último valor não-NA ou Nenhum, se nenhum valor não-NA for encontrado.

Se todos os elementos forem não-NA/nulos, retornará None. Também retorna None para Series/DataFrame vazio.

print(df_vendas['Vendas'].last_valid_index())

2023-01-14 00:00:00

resample(): Reamostragem

Retorna a reamostragem dos dados de série temporal.

DataFrame.resample(rule, axis=_NoDefault.no_default, closed=None, label=None, convention='start', kind=None, on=None, level=None, origin='start_day', offset=None, group_keys=False)

Método de conveniência para conversão de frequência e reamostragem de séries temporais.

O objeto deve ter um índice semelhante a data e hora (DatetimeIndex, PeriodIndex ou TimedeltaIndex) ou o chamador deve passar o rótulo de uma série/índice semelhante a data e hora para o parâmetro de palavra-chave on/ level.

print(df_vendas.resample('M').sum())

            Vendas
Data              
2023-01-31  1590.0

to_period(): Converter em PeriodIndex

Retorna o objeto convertido em PeriodIndex.

DataFrame.to_period(freq=None, axis=0, copy=None)

print(df_vendas.to_period('M'))

         Vendas
Data           
2023-01   100.0
2023-01   120.0
2023-01   140.0
2023-01   160.0
2023-01     NaN
2023-01   150.0
2023-01   110.0
2023-01   180.0
2023-01     NaN
2023-01   170.0
2023-01   200.0
2023-01     NaN
2023-01   140.0
2023-01   120.0

to_timestamp(): Converter em DatetimeIndex

Retorna o objeto convertido em DatetimeIndex.

DataFrame.to_timestamp(freq=None, how='start', axis=0, copy=None)

Converter carimbos de data/hora em DatetimeIndex, a partir do início do período.

tz_convert(): Conversão de zona de tempo

Retorna o objeto convertido para o fuso horário de destino.

DataFrame.tz_convert(tz, axis=0, level=None, copy=True)

Converta o eixo com Localização de zona de tempo e econhecimento de tz para o fuso horário de destino.

ts_tz = df_vendas.tz_localize('UTC')
ts_tz_converted = ts_tz.tz_convert('US/Eastern')
print(ts_tz_converted)

                           Vendas
Data                             
2022-12-31 19:00:00-05:00   100.0
2023-01-01 19:00:00-05:00   120.0
2023-01-02 19:00:00-05:00   140.0
2023-01-03 19:00:00-05:00   160.0
2023-01-04 19:00:00-05:00     NaN
2023-01-05 19:00:00-05:00   150.0
2023-01-06 19:00:00-05:00   110.0
2023-01-07 19:00:00-05:00   180.0
2023-01-08 19:00:00-05:00     NaN
2023-01-09 19:00:00-05:00   170.0
2023-01-10 19:00:00-05:00   200.0
2023-01-11 19:00:00-05:00     NaN
2023-01-12 19:00:00-05:00   140.0
2023-01-13 19:00:00-05:00   120.0

tz_localize(): Localização de zona de tempo

Retorna o objeto convertido para o fuso horário de destino.

DataFrame.tz_localize(tz, axis=0, level=None, copy=True, ambiguous='raise', nonexistent='raise')

Sinalizadores referem-se a atributos do objeto pandas. As propriedades do conjunto de dados (como a data em que foi registrado, o URL de onde foi acessado, etc.) devem ser armazenadas no arquivo dataframe attrs.

O atributo attrs é um dicionário para armazenar metadados globais para o dataframe, considerado experimental e que pode mudar sem aviso prévio.

plot é um método que pode ser chamado e um atributo de namespace para métodos de plotagem específicos do formulário dataframeplot..

Métodos e atributos específicos do tipo esparso são fornecidos no acessador sparse do dataframe.

Dataframe Exemplo

df_exemplo = pd.DataFrame({
  'Nome'  : ['Roberto', 'Rosana', 'Pedro'],
  'Idade' : [60, 61, 29]
})

Métodos to_dict() e from_dict()

DataFrame como dicionário.

dicionario = df_exemplo.to_dict()
print(dicionario)
print("Tipo:", type(dicionario))
print()
print(pd.DataFrame.from_dict(dicionario))

{'Nome': {0: 'Roberto', 1: 'Rosana', 2: 'Pedro'}, 'Idade': {0: 60, 1: 61, 2: 29}}
Tipo: <class 'dict'>

      Nome  Idade
0  Roberto     60
1   Rosana     61
2    Pedro     29

Métodos to_records() e from_records()

Criar DataFrame a partir de uma lista de registros.

Métodos to_json() e read_json()

O método to_json() retorna um texto JSON com o conteúdo do DataFrame.

O método read_json() retorna o DataFrame a partir de um texto JSON.

json = df_exemplo.to_json(orient='records')
print(json)
print("Tipo:", type(json))
print()
print(pd.read_json(json, orient='records'))

[{"Nome":"Roberto","Idade":60},{"Nome":"Rosana","Idade":61},{"Nome":"Pedro","Idade":29}]
Tipo: <class 'str'>

      Nome  Idade
0  Roberto     60
1   Rosana     61
2    Pedro     29

Métodos to_html() e read_html()

Salvar o DataFrame como uma tabela HTML.

html = df_exemplo.to_html()
print(html)
print("Tipo:", type(html))
print()
print(pd.read_html(html))

<table border="1" class="dataframe">
  <thead>
    <tr style="text-align: right;">
      <th></th>
      <th>Nome</th>
      <th>Idade</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>0</th>
      <td>Roberto</td>
      <td>60</td>
    </tr>
    <tr>
      <th>1</th>
      <td>Rosana</td>
      <td>61</td>
    </tr>
    <tr>
      <th>2</th>
      <td>Pedro</td>
      <td>29</td>
    </tr>
  </tbody>
</table>
Tipo: <class 'str'>

[   Unnamed: 0     Nome  Idade
0           0  Roberto     60
1           1   Rosana     61
2           2    Pedro     29]

Métodos to_csv() e read_csv()

Salvar e ler o DataFrame como arquivo CSV.

df_exemplo.to_csv('exemplo.csv', index=False)
print(pd.read_csv('exemplo.csv'))

      Nome  Idade
0  Roberto     60
1   Rosana     61
2    Pedro     29

Métodos to_excel() e read_excel()

Salvar e ler o DataFrame como arquivo de planilha Excel

df_exemplo.to_excel('exemplo.xlsx', index=False)
print(pd.read_excel('exemplo.xlsx'))

      Nome  Idade
0  Roberto     60
1   Rosana     61
2    Pedro     29

Métodos to_sql() e read_sql()

Salvar o DataFrame em um banco de dados SQL (SQLite)

Lendo dados do banco de dados SQL de volta para um DataFrame

from sqlalchemy import create_engine
engine = create_engine('exemplo.db')
df_exemplo.to_sql('tabela_exemplo', con=engine, if_exists='replace')
df_from_sql = pd.read_sql('tabela_exemplo', con=engine)

Métodos to_orc() e read_orc()

Salvar e ler o DataFrame com arquivo no formato ORC.

df_exemplo.to_orc('exemplo.orc')
print(pd.read_orc('exemplo.orc'))

AttributeError: 'DataFrame' object has no attribute 'to_orc' <traceback object at 0x0000018D2F610080>

Métodos to_parquet() e read_parquet()

Salvar e ler o DataFrame como arquivo no formato parquet.

df_exemplo.to_parquet('exemplo.parquet')
print(pd.read_parquet('exemplo.parquet'))

      Nome  Idade
0  Roberto     60
1   Rosana     61
2    Pedro     29

Métodos to_pickle() e read_pickle()

Salvar e ler o DataFrame como arquivo no formato pickle.

df_exemplo.to_pickle('exemplo.pkl')
print(pd.read_pickle('exemplo.pkl'))

      Nome  Idade
0  Roberto     60
1   Rosana     61
2    Pedro     29

Métodos to_hdf() e read_hdf()

Salvar e ler o DataFrame como arquivo no formato HDF5.

df_exemplo.to_hdf('exemplo.h5', key='mydata', mode='w')
print(pd.read_hdf('exemplo.h5', key='mydata'))

ImportError: Missing optional dependency 'pytables'.  Use pip or conda to install pytables. <traceback object at 0x0000018D353CCBC0>

Métodos to_feather() e read_feather()

Salvar o DataFrame em formato Feather.

df_exemplo.to_feather('exemplo.feather')
print(pd.read_feather('exemplo.feather'))

      Nome  Idade
0  Roberto     60
1   Rosana     61
2    Pedro     29

Métodos to_latex() e read_latex()

Salvar e ler o DataFrame como arquivo no formato LaTeX

print(df_exemplo.to_latex())

\begin{tabular}{llr}
\toprule
{} &     Nome &  Idade \\
\midrule
0 &  Roberto &     60 \\
1 &   Rosana &     61 \\
2 &    Pedro &     29 \\
\bottomrule
\end{tabular}

Métodos () e read_stata()

Salvar e ler o DataFrame como arquivo no formato Stata.

df_exemplo.to_stata('exemplo.dta', write_index=False)
print(pd.read_stata('exemplo.dta'))

      Nome  Idade
0  Roberto     60
1   Rosana     61
2    Pedro     29

Método to_gbq()

Salvar o DataFrame no Google BigQuery (requer autenticação e configuração prévia)

from google.oauth2 import service_account
from pandas_gbq import to_gbq
credentials = service_account.Credentials.from_service_account_file('path-to-credentials.json')
to_gbq(df_exemplo, destination_table='project_id.dataset_id.table_id', if_exists='replace', credentials=credentials)