Pandas Tutorial: DataFrames em Python

• Você também sabe que o site .iloc[] examinará as posições no índice. Quando você passar pelo site 2, você receberá o retorno:

48    7
49    8
50    9

• Como o índice não contém apenas números inteiros, o site .ix[] terá o mesmo comportamento que o site iloc e examinará as posições no índice. Você obterá o mesmo resultado de .iloc[].

Agora que a diferença entre .iloc[], .loc[] e .ix[] está clara, você está pronto para tentar adicionar linhas ao seu DataFrame!

Dica: como consequência do que acabou de ler, agora você também entende que a recomendação geral é usar o site .loc para inserir linhas no DataFrame. Isso ocorre porque, se você usasse df.ix[], poderia tentar fazer referência a um índice de valor numérico com o valor do índice e acidentalmente sobrescrever uma linha existente do DataFrame. Você deve evitar isso!

Confira a diferença mais uma vez no DataFrame abaixo:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), index= [2.5, 12.6, 4.8], columns=[48, 49, 50])

# This will make an index labeled `2` and add the new values
df.loc[2] = [11, 12, 13]
print(df)

     48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

2.0   11  12  13

Você pode ver por que tudo isso pode ser confuso, certo?

Adição de uma coluna ao DataFrame

Em alguns casos, você deseja que o índice faça parte do DataFrame. Você pode fazer isso facilmente pegando uma coluna do seu DataFrame ou fazendo referência a uma coluna que ainda não foi criada e atribuindo-a à propriedade .index, da seguinte forma:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])
​
# Use `.index`
df['D'] = df.index
​
# Print `df`
print(df)

  A  B  C  D

0  1  2  3  0

1  4  5  6  1

2  7  8  9  2

Em outras palavras, você diz ao seu DataFrame que ele deve usar a coluna A como seu índice.

No entanto, se quiser acrescentar colunas ao DataFrame, você também pode seguir a mesma abordagem de quando adiciona um índice ao DataFrame: use .loc[] ou .iloc[]. Nesse caso, você adiciona uma série a um DataFrame existente com a ajuda do site .loc[]:

# Study the DataFrame `df`
print(df)

# Append a column to `df`
df.loc[:, 4] = pd.Series(['5', '6', '7'], index=df.index)

# Print out `df` again to see the changes
print(df)

  A  B  C  D

0  1  2  3  0

1  4  5  6  1

2  7  8  9  2

   A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7

Lembre-se de que um objeto Series é muito parecido com uma coluna de um DataFrame. Isso explica por que você pode adicionar facilmente uma série a um DataFrame existente. Observe também que a observação feita anteriormente sobre .loc[] continua válida, mesmo quando você está adicionando colunas ao seu DataFrame!

Redefinição do índice de seu DataFrame

Quando o índice não tiver a aparência que você deseja, você pode optar por redefini-lo. Você pode fazer isso facilmente com o site .reset_index(). No entanto, você ainda deve ficar atento, pois pode passar vários argumentos que podem aumentar ou diminuir o sucesso de sua redefinição:

# Check out the weird index of your dataframe
print(df)

# Use `reset_index()` to reset the values. 
df_reset = df.reset_index(level=0, drop=True)

# Print `df_reset`
print(df_reset)

  A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7

   A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7

Você pode tentar substituir o argumento drop por inplace no exemplo acima e ver o que acontece!

Observe como você usa o argumento drop para indicar que deseja se livrar do índice que estava lá. Se você tivesse usado inplace, o índice original com floats seria adicionado como uma coluna extra ao seu DataFrame.

Exclusão de um índice de seu DataFrame

Se você quiser remover o índice do seu DataFrame, deve reconsiderar, pois os DataFrames e as Series sempre têm um índice.

No entanto, o que você *pode* fazer é, por exemplo:

• redefinindo o índice do seu DataFrame (volte à seção anterior para ver como isso é feito) ou
• remova o nome do índice, se houver algum, executando del df.index.name,
• remover valores de índice duplicados redefinindo o índice, eliminando as duplicatas da coluna de índice que foi adicionada ao DataFrame e reinserindo essa coluna sem duplicatas novamente como o índice
• e, por fim, remover um índice e, com ele, uma linha. Isso é explicado mais detalhadamente neste tutorial.

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [40, 50, 60], [23, 35, 37]]), 
                  index= [2.5, 12.6, 4.8, 4.8, 2.5], 
                  columns=[48, 49, 50])
                  
df.reset_index().drop_duplicates(subset='index', keep='last').set_index('index')

Agora que você já sabe como remover um índice do DataFrame, pode prosseguir com a remoção de colunas e linhas!

Exclusão de uma coluna de seu DataFrame

Para se livrar de (uma seleção de) colunas do seu DataFrame, você pode usar o método drop():

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])

# Check out the DataFrame `df`
print(df)

# Drop the column with label 'A'                  
df.drop('A', axis=1, inplace=True)

# Drop the column at position 1
df.drop(df.columns[[1]], axis=1)

  A  B  C

0  1  2  3

1  4  5  6

2  7  8  9

Você pode pensar agora: bem, isso não é tão simples; há alguns argumentos extras que são passados para o método drop()!

• O argumento axis é 0 quando indica linhas e 1 quando é usado para eliminar colunas.
• Você pode definir inplace como True para excluir a coluna sem precisar reatribuir o DataFrame.

Remoção de uma linha de seu DataFrame

Você pode remover linhas duplicadas de seu DataFrame executando df.drop_duplicates(). Também é possível remover linhas do DataFrame, levando em conta apenas os valores duplicados que existem em uma coluna.

Dê uma olhada neste exemplo:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [40, 50, 60], [23, 35, 37]]), 
                  index= [2.5, 12.6, 4.8, 4.8, 2.5], 
                  columns=[48, 49, 50])

# Check out your DataFrame `df`
print(df)

# Drop the duplicates in `df`
df.drop_duplicates([48], keep='last')

      48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

4.8   40  50  60

2.5   23  35  37

Se não houver um critério de exclusividade para a exclusão que deseja realizar, você pode usar o método drop(), no qual usa a propriedade index para especificar o índice das linhas que deseja remover do DataFrame:

# Check out the DataFrame `df`
print(df)

# Drop the index at position 1
df.drop(df.index[1])

     48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

4.8   40  50  60

2.5   23  35  37

Após esse comando, talvez você queira redefinir o índice novamente.

Dica: tente redefinir o índice do DataFrame resultante por conta própria! Não se esqueça de usar o argumento drop se achar necessário.

Substituição de todas as ocorrências de uma cadeia de caracteres em um DataFrame

Para substituir determinadas cadeias de caracteres em seu DataFrame, você pode usar facilmente o site replace(): passe os valores que deseja alterar, seguidos dos valores pelos quais deseja substituí-los.

Assim mesmo:

df = pd.DataFrame({"Student1":['OK','Awful','Acceptable'], 
                   "Student2":['Perfect','Awful','OK'], 
                   "Student3":['Acceptable','Perfect','Poor']})

# Study the DataFrame `df` first
print(df)

# Replace the strings by numerical values (0-4)
df.replace(['Awful', 'Poor', 'OK', 'Acceptable', 'Perfect'], [0, 1, 2, 3, 4]) 

     Student1 Student2    Student3

0          OK  Perfect  Acceptable

1       Awful    Awful     Perfect

2  Acceptable       OK        Poor

Observe que há também um argumento regex que pode ajudá-lo muito quando você se depara com combinações estranhas de strings:

df =  pd.DataFrame([["1\n", 2, "3\n"], [4, 5, "6\n"] ,[7, "8\n", 9]])

# Check out your DataFrame `df`
print(df)

# Replace strings by others with `regex`
df.replace({'\n': ''}, regex=True)

    0    1    2

0  1\n    2  3\n

1    4    5  6\n

2    7  8\n    9

Resumindo, replace() é o que você precisa fazer quando quiser substituir valores ou cadeias de caracteres em seu DataFrame por outros!

Remoção de partes de strings nas células de seu DataFrame

A remoção de partes indesejadas das cordas é um trabalho complicado. Felizmente, há uma solução fácil para esse problema!

df =  pd.DataFrame([["+-1aAbBcC", "2", "+-3aAbBcC"], ["4", "5", "+-6aAbBcC"] ,["7", "+-8aAbBcC", "9"]])

# Check out your DataFrame
print(df)

# Delete unwanted parts from the strings in the first column
df[0] = df[0].map(lambda x: x.lstrip('+-').rstrip('aAbBcC'))

# Check out the result again
df

          0          1          2

0  +-1aAbBcC          2  +-3aAbBcC

1          4          5  +-6aAbBcC

2          7  +-8aAbBcC          9

Você usa map() na coluna result para aplicar a função lambda em cada elemento ou em todos os elementos da coluna. A função em si pega o valor da cadeia de caracteres e remove o + ou - que está localizado à esquerda e também remove qualquer um dos seis aAbBcC à direita.

Divisão do texto de uma coluna em várias linhas em um DataFrame

Essa é uma tarefa de formatação um pouco mais difícil. No entanto, o próximo trecho de código o guiará pelas etapas:

df = pd.DataFrame({"Age": [34, 22, 19], 
                   "PlusOne":[0,0,1], 
                   "Ticket":["23:44:55", "66:77:88", "43:68:05 56:34:12"]})

# Inspect your DataFrame `df`
print(df)

# Split out the two values in the third row
# Make it a Series
# Stack the values
ticket_series = df['Ticket'].str.split(' ').apply(pd.Series, 1).stack()

# Get rid of the stack:
# Drop the level to line up with the DataFrame
ticket_series.index = ticket_series.index.droplevel(-1)

print(ticket_series)

  Age  PlusOne             Ticket

0   34        0           23:44:55

1   22        0           66:77:88

2   19        1  43:68:05 56:34:12

0    23:44:55

1    66:77:88

2    43:68:05

2    56:34:12

dtype: object

          0

0  23:44:55

1  66:77:88

2  43:68:05

2  56:34:12

Em resumo, o que você faz é:

• Primeiro, você inspeciona o DataFrame em questão. Você vê que os valores na última linha e na última coluna são um pouco longos demais. Parece que há dois ingressos porque um convidado levou um acompanhante para o show.
• Você pega a coluna Ticket do DataFrame df e a encadeia em um espaço. Isso garantirá que os dois tíquetes fiquem em duas filas separadas no final. Em seguida, você pega esses quatro valores (os quatro números de tíquetes) e os coloca em um objeto Series:

      0         1
0  23:44:55       NaN
1  66:77:88       NaN
2  43:68:05  56:34:12

• Isso ainda não parece muito correto. Você tem o site NaN values in there! Você precisa empilhar a série para garantir que não haja nenhum valor NaN na série resultante.
• Em seguida, você vê que sua série está empilhada.

0  0    23:44:55
1  0    66:77:88
2  0    43:68:05
   1    56:34:12

• Isso também não é o ideal. É por isso que você diminui o nível para que fique alinhado com o DataFrame:

0    23:44:55
1    66:77:88
2    43:68:05
2    56:34:12
dtype: object

• É isso que você está procurando.
• Transforme sua série em um DataFrame para garantir que você possa uni-la novamente ao DataFrame inicial. No entanto, para evitar duplicatas em seu DataFrame, você pode excluir a coluna Ticket original.

Aplicação de uma função às colunas ou linhas do seu Pandas DataFrame

Talvez você queira ajustar os dados em seu DataFrame aplicando uma função a ele. Vamos começar a responder a essa pergunta criando sua própria função lambda:

doubler = lambda x: x*2

Dica: se você quiser saber mais sobre funções em Python, considere fazer este tutorial sobre funções em Python.

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])

# Study the `df` DataFrame
print(df)

# Apply the `doubler` function to the `A` DataFrame column
df['A'].apply(doubler)
 A  B  C

0  1  2  3

1  4  5  6

2  7  8  9

0     2

1     8

2    14

Name: A, dtype: int64

Observe que você também pode selecionar a linha do DataFrame e aplicar a função lambda doubler a ela. Lembre-se de que você pode selecionar facilmente uma linha de seu DataFrame usando .loc[] ou .iloc[].

Em seguida, você executaria algo parecido com isso, dependendo se deseja selecionar o índice com base na posição ou no rótulo:

df.loc[0].apply(doubler)

Observe que a função apply() só aplica a função doubler ao longo do eixo do DataFrame. Isso significa que você tem como alvo o índice ou as colunas. Ou, em outras palavras, uma linha ou uma coluna.

No entanto, se quiser aplicá-la a cada elemento ou a cada elemento, você pode usar a função map(). Você pode simplesmente substituir a função apply() no trecho de código acima por map(). Não se esqueça de passar a função doubler para ele para garantir que você multiplique os valores por 2.

Digamos que você queira aplicar essa função de duplicação não apenas à coluna A do DataFrame, mas a todo o DataFrame. Nesse caso, você pode usar applymap() para aplicar a função doubler a cada elemento do DataFrame inteiro:

doubled_df = df.applymap(doubler)
print(doubled_df)

   A   B   C

0   2   4   6

1   8  10  12

2  14  16  18

Observe que, nesses casos, trabalhamos com funções lambda ou funções anônimas que são criadas em tempo de execução. No entanto, você também pode escrever sua própria função. Por exemplo:

def doubler(x):
    if x % 2 == 0:
        return x
    else:
        return x * 2

# Use `applymap()` to apply `doubler()` to your DataFrame
doubled_df = df.applymap(doubler)

# Check the DataFrame
print(doubled_df)

   A   B   C

0   2   2   6

1   4  10   6

2  14   8  18

Se você quiser obter mais informações sobre o fluxo de controle em Pythonpode sempre dar uma olhada em nossos outros recursos.

Dinamização de seu DataFrame

Você pode usar a função pivot() para criar uma nova tabela derivada a partir da tabela original. Ao usar a função, você pode passar três argumentos:

1. values: esse argumento permite especificar quais valores do DataFrame original você deseja ver na tabela dinâmica.
2. columns: tudo o que você passar para esse argumento se tornará uma coluna na tabela resultante.
3. indexO que quer que você passe para esse argumento se tornará um índice na tabela resultante.

# Import pandas
import pandas as pd

# Create your DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
        'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
        'price':[11.42, 23.50, 19.99, 15.95, 55.75, 111.55],
        'testscore': [4, 3, 5, 7, 5, 8]})

# Use `pivot()` to pivot the DataFrame
pivot_products = products.pivot(index='category', columns='store', values='price')

# Check out the result
print(pivot_products)

store            Dia   Fnac  Walmart

category                            

Cleaning       23.50    NaN    11.42

Entertainment    NaN  15.95    19.99

Tech           55.75    NaN   111.55

Quando você não preenche especificamente quais valores espera que estejam presentes na tabela resultante, você dinamizará por várias colunas:

# Import the Pandas library
import pandas as pd
​
# Construct the DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
                       'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
                       'price':[11.42, 23.50, 19.99, 15.95, 55.75, 111.55],
                       'testscore': [4, 3, 5, 7, 5, 8]})
​
# Use `pivot()` to pivot your DataFrame
pivot_products = products.pivot(index='category', columns='store')
​
# Check out the results
print(pivot_products)

             price                testscore             

store            Dia   Fnac Walmart       Dia Fnac Walmart

category                                                  

Cleaning       23.50    NaN   11.42       3.0  NaN     4.0

Entertainment    NaN  15.95   19.99       NaN  7.0     5.0

Tech           55.75    NaN  111.55       5.0  NaN     8.0

Observe que seus dados não podem ter linhas com valores duplicados para as colunas que você especificar. Se esse não for o caso, você receberá uma mensagem de erro. Se não for possível garantir a exclusividade dos dados, use o método pivot_table:

# Import the Pandas library
import pandas as pd

# Your DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
                        'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
                        'price':[11.42, 23.50, 19.99, 15.95, 19.99, 111.55],
                        'testscore': [4, 3, 5, 7, 5, 8]})

# Pivot your `products` DataFrame with `pivot_table()`
pivot_products = products.pivot_table(index='category', columns='store', values='price', aggfunc='mean')

# Check out the results
print(pivot_products)

store            Dia   Fnac  Walmart

category                            

Cleaning       23.50    NaN    11.42

Entertainment    NaN  15.95    19.99

Tech           19.99    NaN   111.55

Observe o argumento adicional aggfunc que é passado para o método pivot_table. Esse argumento indica que você usa uma função de agregação usada para combinar vários valores. Neste exemplo, você pode ver claramente que a função mean é usada.

Usando stack() e unstack() para remodelar seu DataFrame do Pandas

Você já viu um exemplo de empilhamento na seção 5. Basicamente, talvez você ainda se lembre de que, ao empilhar um DataFrame, ele fica mais alto. Você move o índice da coluna mais interna para se tornar o índice da linha mais interna. Você retorna um DataFrame com um índice com um novo nível mais interno de rótulos de linha.

O inverso do empilhamento é chamado de desempilhamento. Assim como em stack(), você usa unstack() para mover o índice de linha mais interno para se tornar o índice de coluna mais interno.

Para obter uma explicação sobre o pivotamento, empilhamento e desempilhamento de pandas, confira nosso artigo Reformulando dados com pandas curso.

Remodele seu DataFrame com melt()

A fusão é considerada útil nos casos em que você tem dados com uma ou mais colunas que são variáveis identificadoras, enquanto todas as outras colunas são consideradas variáveis medidas.

Essas variáveis medidas são todas "não pivotadas" para o eixo da linha. Ou seja, enquanto as variáveis medidas que estavam espalhadas pela largura do DataFrame, a fusão garantirá que elas sejam colocadas na altura dele. Ou, em outras palavras, seu DataFrame se tornará mais longo em vez de mais largo.

Como resultado, você tem duas colunas sem identificador, a saber, 'variable' e 'value'.

Vamos ilustrar isso com um exemplo:

# The `people` DataFrame
people = pd.DataFrame({'FirstName' : ['John', 'Jane'],
                       'LastName' : ['Doe', 'Austen'],
                       'BloodType' : ['A-', 'B+'],
                       'Weight' : [90, 64]})

# Use `melt()` on the `people` DataFrame
print(pd.melt(people, id_vars=['FirstName', 'LastName'], var_name='measurements'))

 FirstName LastName measurements value

0      John      Doe    BloodType    A-

1      Jane   Austen    BloodType    B+

2      John      Doe       Weight    90

3      Jane   Austen       Weight    64

Se estiver procurando mais maneiras de remodelar seus dados, consulte a documentação.

Saída de um DataFrame para CSV

Para gravar um DataFrame como um arquivo CSV, você pode usar to_csv():

import pandas as pd
df.to_csv('myDataFrame.csv')

Esse trecho de código parece bastante simples, mas é justamente aí que começam as dificuldades para a maioria das pessoas, pois você terá requisitos específicos para a saída dos seus dados. Talvez você não queira uma vírgula como delimitador ou queira especificar uma codificação específica.

Não se preocupe! Você pode passar alguns argumentos adicionais para to_csv() para garantir que seus dados sejam gerados da maneira que você deseja!

• Para delimitar por uma guia, use o argumento sep:

import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t')

• Para usar uma codificação de caracteres específica, você pode usar o argumento encoding:

import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t', encoding='utf-8')

• Além disso, você pode especificar como deseja que seus valores NaN ou ausentes sejam representados, se deseja ou não gerar o cabeçalho, se deseja ou não gravar os nomes das linhas, se deseja compactação, etc. Você pode ler sobre as opções.

Gravação de um DataFrame no Excel

Da mesma forma que você fez para enviar seu DataFrame para CSV, você pode usar o site to_excel() para gravar sua tabela no Excel. No entanto, é um pouco mais complicado:

import pandas as pd
writer = pd.ExcelWriter('myDataFrame.xlsx')
df.to_excel(writer, 'DataFrame')
writer.save()

Observe, no entanto, que, assim como em to_csv(), você tem vários argumentos extras, como startcol, startrow, e assim por diante, para garantir que os dados sejam gerados corretamente. Você pode saber mais sobre como importar e exportar dados para arquivos CSV usando o pandas em nosso tutorial. 

Se, no entanto, você quiser obter mais informações sobre as ferramentas de IO no Pandas, consulte a documentação do pandas DataFrames to excel.