5 Tips to Write Idiomatic Pandas Code

Claro, este tutorial não é exaustivo; O pacote Pandas é muito rico e certamente existem outras formas de deixar seu código mais idiomático.

Bora começar!

# If you're working with a notebook, don't forget to use Matplotlib magic! 
%matplotlib inline

# Import pandas under the alias pd import pandas as pd # Import seaborn under the alias sns import seaborn as sns # Set the Seaborn theme if desired sns.set_style('darkgrid')

# Import Times Higher Education World University Rankings data
times_df = pd.read_csv('data/timesData.csv', thousands=",")

# Import Academic Ranking of World Universities data
shanghai_df = pd.read_csv('data/shanghaiData.csv')

Nossas dicas para código Pandas idiomático

1. Indexação

Para começar, escrever código Pandas mais idiomático significa aproveitar o poder da indexação. Indexar é selecionar subconjuntos do seu DataFrame.

Quando você está começando no Pandas, pode levar um tempo até se acostumar com índices. Na verdade, se você já trabalhou com listas em Python, deve conhecer os colchetes [] combinados com os dois-pontos : para selecionar elementos. Esse método também funciona com DataFrames.

Além disso, há duas outras formas, mais idiomáticas, de selecionar um subconjunto de DataFrame: iloc e loc:

• loc é baseada em rótulos. Isso significa que, se você escrever loc[2], estará buscando os valores cujo índice possui o rótulo 2.
• iloc é baseada em posição. Isso significa que, se você escrever iloc[2], estará buscando os valores que estão na posição de índice 2.

Teste abaixo no bloco do DataCamp Light digitando times_df.loc[2] e times_df.iloc[2] no console IPython para ver a diferença. Depois, tente resolver o exercício com a ajuda de loc, iloc e os tradicionais colchetes!

Claro, a exploração pode ir muito além de simplesmente selecionar linhas e colunas. As coisas ficam interessantes quando você combina loc e iloc com, por exemplo, arrays booleanos.

Isso vai um pouco além de selecionar por coluna ou índice; é quase como consultar seu dado!

loc e iloc são ótimos para indexar, mas cuidado quando usar dois pares de colchetes em sequência! O Pandas pode retornar uma cópia de uma view e, nesses casos, você pode não saber com o que ainda está trabalhando. Pense duas vezes ao combinar dois pares de colchetes com loc ou iloc.

Observação: para consultar seus dados, o Pandas também oferece a função query(), que você pode usar para inspecionar rapidamente os dados (disponível desde a versão 0.13). Por exemplo, você pode montar uma consulta para ver quais universidades têm total_score um pouco abaixo de 50:

Claro, existem muitas outras possibilidades para consultar seus dados! Que tal criar algumas consultas e testá-las no console IPython do bloco acima?

Sem ideias? Tente consultas que retornem universidades com primeiro lugar nacional e com primeiro lugar mundial. Além disso, você pode consultar os números de ex-alunos das universidades.

Ficou na dúvida de como montar as consultas? Veja alguns exemplos:

shanghai_df.query("national_rank == 1 and world_rank == 1")
shanghai_df.query("alumni < 20")

2. Encadeamento de métodos

O encadeamento de métodos é algo típico do Pandas, mas, quando você está começando com esse pacote de manipulação de dados em Python, pode não ser óbvio como funciona. Basicamente, é chamar métodos em um objeto, um após o outro.

Nesta seção, vamos aprofundar o encadeamento criando pipelines de dados com pipe().

Como você já deve ter notado, os datasets são bem diferentes. Eis algumas diferenças:

• O dataset Times tem 14 colunas, enquanto o Shanghai tem 11
• O Times tem 2603 linhas, enquanto o Shanghai tem 4897
• Uma coluna importante ausente no Shanghai é o país da universidade. Se necessário, você pode obter essa informação a partir do Times mais tarde.

Assim, para usar ambos os DataFrames, precisamos selecionar apenas as colunas em comum. Com sorte, essas colunas têm conteúdo semelhante.

As colunas em comum são:

• total_score: pontuação usada para determinar o ranking. Segundo a página do Kaggle, pode conter faixas (entre dois valores) e empates (com sinal = antes)
• university_name: nome da universidade
• world_rank: posição da universidade
• year: ano do ranking

Para concatenar os dois dados, precisamos limpar algumas coisas antes. Aplique agora o pipeline completo para limpar os dados:

Como você deve ter percebido, uso bastante o método .pipe neste tutorial. Se você vem do mundo R, provavelmente já está (de certa forma) familiarizado.

É um método útil do Pandas (desde a versão 0,16,2) que permite encadear operações e eliminar a necessidade de DataFrames intermediários. Seu código fica mais legível.

Sem esse operador, em vez de escrever df.pipe(f).pipe(g).pipe(h) você escreveria: h(g(f(df))). Isso fica difícil de acompanhar conforme o número de funções aninhadas cresce.

Para se aprofundar no tema, recomendo muito este post.

Agora que os dois DataFrames estão limpos, podemos concatená-los em um único DataFrame. E não se esqueça de limpar os dados ausentes:

Como cerca de 38% dos dados estão ausentes na coluna total_score, é melhor remover essa coluna com o método .drop.

3. Otimização de memória

Uma terceira forma de deixar seu código Pandas mais “idiomático” —neste caso, mais “performático”— é otimizando o uso de memória. Especialmente ao criar pipelines com encadeamento de métodos, a memória pode ter um grande impacto na velocidade. Veja mais sobre isso aqui.

Provavelmente é exagero para este dataset pequeno, mas costuma ser boa prática converter algumas colunas para tipos específicos e otimizar o consumo de memória. Para começar, vamos ver quanta memória ranking_df está usando com o método .info.

O resultado da primeira linha indica 144 KB. Porém, inspecionando os argumentos de .info, vemos o opcional memory_usage, que é None por padrão. O que acontece ao definir memory_usage como deep?

A nova pegada de memória fica 6 —5,6, mais precisamente— vezes maior que a estimativa inicial.

O que rolou aqui?

A diferença vem do fato de que, sem o modo “deep”, o Pandas não estima o consumo de memória para colunas do tipo object. Esse tipo (Python) ocupa mais espaço do que dtypes otimizados do numpy. Por isso, recomenda-se converter object para tipos mais apropriados (por exemplo, category quando os dados são categóricos).

Vamos fazer isso!

def memory_change(input_df, column, dtype):
    df = input_df.copy()
    old = round(df[column].memory_usage(deep=True) / 1024, 2) # In KB
    new = round(df[column].astype(dtype).memory_usage(deep=True) / 1024, 2)# In KB
    change = round(100 * (old - new) / (old), 2)
    report = ("The inital memory footprint for {column} is: {old}KB.\n" 
              "The casted {column} now takes: {new}KB.\n"
              "A change of {change} %.").format(**locals())
    return report

print(memory_change(ranking_df,'world_rank', 'int16'))
print(memory_change(ranking_df,'university_name', 'category'))
print(memory_change(ranking_df,'name', 'category'))

Agora que você sabe que, ao mudar world_rank para int16, por exemplo, a memória é usada de forma mais eficiente, é hora de aplicar as mudanças com astype(). Finalize conferindo novamente o consumo de memória:

Bem melhor. Você ainda pode otimizar convertendo a coluna year para int32.

4. GroupBy

Agora que temos um conjunto de dados bem formado (isto é, em estado tidy) e com memória otimizada, a análise pode começar.

Algumas perguntas que podem interessar:

• Quais são as 5 melhores universidades dadas por cada sistema de ranking ao longo dos anos?
• Quão diferentes são esses rankings a cada ano?

Vamos responder à primeira usando as técnicas idiomáticas vistas nas seções anteriores!

Antes de começar, repare que ‘Massachusetts Institute of Technology (MIT)’ e ‘Massachusetts Institute of Technology’ são dois registros diferentes da mesma universidade. Altere o primeiro nome para o segundo.

Nesses casos, a função loc, vista anteriormente, é especialmente útil!

Para encontrar as 5 (no geral, n) melhores universidades ao longo dos anos, para cada sistema de ranking, o pseudo-código é:

• Para cada ano (coluna year) e para cada sistema (coluna name):
• Selecione o subconjunto referente a esse ano e sistema
• Selecione as 5 melhores universidades e guarde em uma lista
• Armazene o resultado em um dicionário com (year, name) como chave e a lista de universidades (em ordem decrescente) como valor

Vamos aplicar.

Agora que temos esse dicionário de rankings, vamos medir o quanto (em %) os dois métodos diferem ao longo dos anos: eles são 100% semelhantes em conjunto se as 5 universidades selecionadas forem as mesmas, mesmo que em ordens diferentes.

Deu trabalho, né? Tem um jeito melhor —e mais idiomático— com Pandas?

Claro! Primeiro, filtre o DataFrame para manter apenas as 5 melhores universidades por ano e método de ranking. Confira o resultado com head():

Com o DataFrame correto em mãos, vamos usar .groupby para comparar os dois métodos de ranking usando a similaridade de conjuntos definida acima.

Você obtém o mesmo resultado de antes com menos esforço.

5. Visualização

Agora que você já fez uma análise inicial, é hora de explorar visualmente. Código Pandas idiomático também significa aproveitar a integração de gráficos com Matplotlib. Assim, você cria ótimos gráficos em pouco tempo!

Nesta seção, vamos voltar aos datasets times_df e shanghai_df para criar algumas visualizações básicas com Matplotlib e Seaborn.

O gráfico acima deixa claro imediatamente que existem alguns valores 0 na coluna alumni. Isso é algo para ficar de olho ao explorar seus dados: com perfilamento de dados, você consegue ver esses zeros e tratá-los. Para saber mais, veja o tutorial de Data Profiling da DataCamp.

Ou, se houver valores que não fazem sentido no seu conjunto de dados, você pode simplesmente substituí-los por NaN e, em seguida, remover todos os NaN das colunas que dificultariam os gráficos. Note que isso é só um ajuste rápido e que provavelmente você vai precisar de um passo de data profiling mais completo para garantir a qualidade dos dados, pois ainda aparecem zeros na coluna num_students no gráfico abaixo:

Claro, você não precisa se limitar ao Matplotlib. Existem outras bibliotecas para visualizar seus dados rapidamente, como o Seaborn.

Segundo o site oficial, o Seaborn é usado principalmente para criar gráficos estatísticos visualmente atraentes. De fato, antes da versão 2.0 do Matplotlib, era trabalhoso (embora possível) criar gráficos bonitos.

A combinação de Pandas com Seaborn também permite iterar rapidamente sobre seus dados por meio de visualizações.

Vamos ver alguns exemplos!

Confira o gráfico a seguir, em que contamos quantas vezes um país aparece nos dados, pegamos as dez primeiras ocorrências e garantimos que a ordenação do barplot vai do maior para o menor:

Depois, você pode plotar esses países e suas pontuações médias:

Seus gráficos também podem ficar bem complexos. Veja o pairplot a seguir, feito para mostrar com clareza as relações par-a-par em um dataset:

import numpy as np

np.seterr(invalid='ignore')

sns.pairplot(times_df, hue='country')

plt.show()

Da mesma forma, você pode testar esta combinação de FacetGrid e regplot, que mostra a evolução do total_score ao longo dos anos para os 5 principais países:

Por fim, um gráfico de correlação também ajuda bastante na exploração. Use a função heatmap() do Seaborn para isso:

Daria para seguir com mais e mais visualizações, então melhor parar por aqui :)