(tradução adaptada do blog de Rebecca Barter)

Tenho uma confissão a fazer: agora estou virando também usuário de Python. Para ser justo, usei Python aqui e ali ao longo dos anos, mas nunca foi minha linguagem principal (sempre foi R). Este ano foi a primeira vez que tive que realmente me sentar e usar Python para projetos reais. Na verdade, não só tive que usar Python, mas também tive que ensinar Python. Para aqueles que ensinam, vocês sabem que a melhor maneira de garantir que conhecem algo muito bem é ensiná-lo. O resultado final é que agora me considero também um usuário de Python.

Por que decidi aprender Python? Usei R toda minha vida de ciência de dados, e embora ainda pense que R (com o tidyverse) ainda é a melhor linguagem para manipulação de dados e visualização de dados, não há como negar que, como cientista de dados hoje, Python é uma habilidade obrigatória. Se você está fazendo machine learning, Python ainda está anos-luz à frente de R. Se você está trabalhando com engenheiros de software, eles ficarão muito mais felizes em trabalhar com você se usar Python. Se você está procurando um emprego, estará muito mais empregável se já estiver confortável com Python.

Embora certamente existam semelhanças entre R e Python, não presuma que saber usar um automaticamente significará que sabe usar o outro. Dito isso, já conhecer R significa que a curva de aprendizado para aprender Python não será muito íngreme (mas ainda levará alguns meses de uso regular para alcançar competência).

Neste post, vou apresentá-lo ao mundo da análise de dados com Python a partir de uma perspectiva R. Obviamente, este post não será exaustivo, mas se você é um usuário R do tidyverse que está procurando aprender Python, espero que este post possa servir como um ponto de partida útil e fornecer um contexto relacionável em sua jornada Python.

Note que este post de blog se concentrará em trabalhar com dados em Python usando pandas. Não vou falar muito sobre coisas como SciPy, arrays ou scikit-learn aqui.

Recursos úteis

Existem muitos recursos por aí para aprender Python. O que achei mais útil foi o livro “Python for Data Analysis” de Wes McKinney (Wes é o criador do pandas). Há muita informação lá, e para ser justo, você pode pular muita coisa quando está começando (como coisas sobre conjuntos, tuplas e arrays). Estas são coisas importantes para saber para ser um programador Python bem-arredondado, mas para fazer análises de dados simples com data frames pandas, não precisam ser o foco.

Instalando Python e JupyterLab

Gerenciar instalações de Python no meu computador costumava me dar dor de cabeça. Embora eu costumasse usar Python em notebooks Jupyter através do IDE Jupyter notebook instalado usando anaconda, descobri que a abordagem mais simples para colocar Python para funcionar agora é instalar a versão mais recente do Python diretamente do site python e instalar o IDE JupyterLab. Então você pode selecionar sua instalação python preferida dentro do JupyterLab e está pronto para começar. (Você pode querer assistir alguns vídeos no YouTube para começar com JupyterLab se nunca viu antes. Com certeza me levou um minuto para me orientar.)

Notebooks Jupyter

Embora, atualmente, você possa usar Python junto com quarto dentro do RStudio, isso não é realmente o que os usuários de Python fazem (ainda…). Então, se você quer se encaixar com os garotos legais de Python, recomendo trabalhar com notebooks Jupyter (.ipynb files) no IDE JupyterLab. Você pode instalar uma extensão de notebook jupyter dentro do IDE JupyterLab (felizmente, não há necessidade de instalar notebooks jupyter ou anaconda separadamente).

Bibliotecas

Como R, Python é principalmente útil para ciência de dados por causa das bibliotecas adicionais que algumas pessoas muito inteligentes escreveram para nos ajudar a trabalhar com dados. As principais bibliotecas Python que você precisará para começar são NumPy e pandas.

Instalando bibliotecas

Como em R, você precisa instalar uma biblioteca antes de usá-la.

Existem muitas maneiras de instalar bibliotecas Python, mas se você instalou Python da mesma maneira que fiz acima, a maneira como geralmente instalo bibliotecas é no terminal do meu computador, onde escrevo:

python3 -m pip install pandas

que instalará a biblioteca pandas, por exemplo. Você pode ter uma maneira preferida diferente de instalar bibliotecas Python. Tudo bem. Sua maneira provavelmente é melhor que a minha.

Carregando bibliotecas

Uma diferença entre R e Python é que uma vez que você carregou um pacote em R, pode usar as funções do pacote sem ter que especificar de qual biblioteca o pacote vem toda vez que o usa assim:

library(dplyr)

# Posso usar `filter()` do dplyr sem ter que especificar que vem do dplyr
filter(iris, Species == "virginica")

Eu poderia escolher especificar explicitamente que filter() vem do dplyr usando :: assim:

# Posso especificar explicitamente que `filter()` vem do dplyr usando `::`
dplyr::filter(iris, Species == "virginica")

Mas não preciso.

Em Python, no entanto, você precisa especificar de qual biblioteca vêm as funções que está usando, mesmo depois de importá-las. É por isso que toda vez que você importa uma biblioteca Python, deve dar a ela um apelido para não ter que digitar o nome completo da biblioteca toda vez que quiser usar uma função dela. Felizmente, existem alguns apelidos geralmente acordados que todos usam. Por exemplo, o apelido do pandas é “pd”, e o apelido do NumPy é “np”. (Em Python as pessoas geralmente dizem ‘biblioteca’ em vez de ‘pacote’.)

import pandas as pd
import numpy as np
import matplotlib as plt

Então, para usar uma função da biblioteca NumPy, como log(), você precisa primeiro especificar o apelido da biblioteca e depois o nome da função, separados por um ponto: np.log(). O seguinte código calculará o logaritmo de 7 usando a função log() da biblioteca NumPy cujo apelido é np:

np.log(7)

Isso é outra coisa sobre Python: funções matemáticas comuns como log(), sqrt() e exp() todas precisam ser importadas da biblioteca NumPy (ao contrário de R, onde existem versões “nativas” dessas funções).

Data frames pandas

Em R, o bloco de construção da ciência de dados é o data frame. Em Python, o bloco de construção da ciência de dados também é o DataFrame (mas eles escrevem como uma palavra com camel case). Embora R contenha um data frame nativo, o DataFrame do Python vem da biblioteca “pandas” (cujo apelido é “pd”).

Em R, podemos criar um data frame de brinquedo assim:

r_df <- data.frame(a = c(1, 2, 3, 4),
                   b = c(5, 6, 7, 8))
r_df

E em Python, podemos criar um DataFrame de brinquedo assim:

pandas_df = pd.DataFrame({'a': [1,2,3,4], 
                          'b': [5,6,7,8]})
pandas_df

Na versão R acima, fornecemos dois argumentos para a função data.frame(), cada um contendo um vetor R (c(1, 2, 3, 4) e c(5, 6, 7, 8)) dos valores que formarão uma coluna. A sintaxe para a versão python, no entanto, envolve um único argumento correspondente a um tipo de objeto chamado dicionário (um dicionário é definido com chaves) cujas entradas nomeadas contêm cada uma uma lista Python ([1,2,3,4] e [5,6,7,8]) dos valores que formarão uma coluna.

Listas em Python

Uma lista em Python é muito parecida com uma lista em R, pois pode conter uma variedade de tipos de objetos. Listas em Python são criadas usando colchetes:

my_py_list = [1,'a',[3,4]]
my_py_list

Note que, em geral, usuários Python tendem a usar menos espaços que usuários R, atribuição é sempre feita com = (não há operador <- em Python), e há uma preferência geral por aspas simples ' sobre aspas duplas " (embora eu possa ter imaginado essa).

Você pode alterar a primeira entrada de uma lista Python de forma semelhante a como faria em R, exceto que Python usa indexação zero, o que significa que a primeira entrada está na posição 0, a segunda entrada está na posição 1, e assim por diante:

my_py_list[0]

my_py_list[0] = "one"
my_py_list

Dicionários

Um dicionário é tipo como uma lista nomeada. No exemplo abaixo, ambas as entradas no dicionário são elas mesmas listas:

my_py_dict = {'name': ['Jane', 'Joe', 'Jerry'],
              'age': [13, 15, 12]}
my_py_dict

Mas enquanto você não pode extrair entradas posicionais dele (my_py_dict[0] não funcionará), você pode extrair entradas nomeadas:

my_py_dict['name']

Posso extrair a primeira entrada (posição 0) da entrada de dicionário name de my_py_dict como esperado:

my_py_dict['name'][0]

Isso é tudo super emocionante, tenho certeza, mas provavelmente devo apontar que praticamente a única vez que realmente uso dicionários é quando estou definindo DataFrames pandas na mosca como fiz acima.

Indexação de colunas e linhas

Embora tanto o data frame R quanto o data frame python/pandas tenham nomes de colunas, a maneira de extraí-los é diferente.

Para extrair os nomes das colunas do data frame R, usaríamos:

# imprimir os nomes das colunas R
colnames(r_df)

No entanto, para extrair os nomes das colunas (ou índice de colunas) do data frame pandas, usamos:

# imprimir os nomes das colunas pandas
pandas_df.columns

A saída é um objeto do tipo “índice”.

Existem dois usos principais da sintaxe objeto.xyz. O primeiro, que está sendo usado aqui, é usado para extrair um “atributo” xyz de um objeto (por exemplo, aqui estamos extraindo o atributo columns do objeto DataFrame pandas_df).

Outro “atributo” que você pode extrair de um DataFrame é o shape (que é equivalente a dim() em R):

pandas_df.shape

A saída de shape aqui tem um tipo “tupla” (não vou entrar em tuplas aqui porque tenho medo delas).

Outro atributo importante de um DataFrame é seu índice de linhas:

pandas_df.index

Isso é um objeto “RangeIndex” que vai de 0 a 4 (não inclusivo) com tamanho de passo 1 e corresponde ao índice de linhas do DataFrame.

Tanto os índices de coluna quanto de linha de DataFrames pandas são objetos de índice especiais que podem ser convertidos para uma lista Python usando list() (que é uma função em Python para criar listas).

list(pandas_df.index)

list(pandas_df.columns)

Sempre que objetos Python exibem de forma estranha, tento convertê-los para algo mais simples, como uma lista, para ver o que realmente contêm. Às vezes até consigo.

Métodos

Extrair atributos não é o único uso da sintaxe de ponto objeto.xyz. Sintaxe semelhante também permite aplicar funções específicas do objeto ao objeto usando a sintaxe de ponto objeto.fun().

Note que funções que são aplicadas usando objeto.fun() (sintaxe onde o nome da função vem depois do ponto) são chamadas de métodos. Estas são funções que são específicas para o tipo de objeto ao qual está sendo aplicada.

Por exemplo, podemos aplicar os métodos DataFrame mean() e sum() ao nosso objeto DataFrame pandas_df para calcular a média e soma de cada coluna no data frame:

pandas_df.mean()

pandas_df.sum()

Note que a saída dessas funções são objetos pandas “Series”, que é como uma única coluna de um data frame. Mais sobre objetos Series abaixo.

É importante notar que estes métodos mean() e sum() não são funções independentes. Se tentarmos aplicá-los ao nosso DataFrame como faríamos para funções regulares, obtemos erros:

mean(pandas_df)

sum(pandas_df)

Como são “métodos”, estas funções de método mean() e sum() são específicas para o tipo de objeto DataFrame e devem ser aplicadas usando a sintaxe de ponto pandas_df.fun().

Além disso, como estas funções de método são específicas para objetos DataFrame, também não funcionarão em objetos não-DataFrame, incluindo listas:

py_list = [1, 3, 4]
py_list.mean()

Às vezes os erros em Python são até úteis! Obrigado Python!

Vindo de R onde uma função é sempre apenas uma função, esta coisa de método vs função foi bastante confusa no início. Não tenha medo. Você se acostumará. Espero.

Extraindo colunas

Embora você possa criar um DataFrame pandas usando um dicionário contendo entradas de lista (como fizemos anteriormente), as colunas de um DataFrame, quando extraídas, são um objeto do tipo “Series” (em vez de uma lista).

Por exemplo, a coluna 'a' pode ser extraída usando []:

pandas_df['a']

que é o mesmo que em R:

r_df["a"]

Note que as colunas de um DataFrame também são “atributos” do data frame e podem ser extraídas usando a sintaxe de ponto df.col:

pandas_df.a

A saída acima é a mesma da sintaxe pandas_df['a']: ambas as saídas são um objeto pandas Series.

Podemos verificar o tipo de um objeto em Python usando a função type():

type(pandas_df['a'])

que nos diz que esta coluna é um objeto pandas “Series”.

Series

Uma pandas Series é como um DataFrame unidimensional, e você pode reconhecer que seu objeto é uma Series porque há dois atributos impressos na parte inferior: o Name (se de fato houver um nome) e dtype (tipo).

pandas_df['a']

Um objeto Series tem um índice de linhas mas não colunas:

pandas_df['a'].index

pandas_df['a'].columns

Adicionando colunas a um DataFrame

Você pode adicionar uma coluna a um DataFrame pandas assim como faria em R base:

pandas_df['c'] = [9,10,11,12]
pandas_df

No entanto, se você definir um novo DataFrame usando um data frame existente e depois modificá-lo, por exemplo, adicionando uma nova coluna:

# definir um novo data frame usando o original
pandas_df_new = pandas_df
# adicionar uma nova coluna ao novo data frame
pandas_df_new['d'] = [13,14,15,16]
# imprimir o novo data frame
pandas_df_new

Note que o DataFrame original também mudará:

pandas_df

Isso é muito diferente do que aconteceria em R, onde o objeto pandas_df_new seria um objeto separado do pandas_df original, e fazer modificações no novo objeto não se refletiria no original.

Não se esqueça de .copy()

Isso ocorre porque em Python quando você define um novo objeto para ser um objeto existente (pandas_df_new = pandas_df), você está realmente criando um novo “ponteiro” para o mesmo objeto subjacente sendo apontado pelo nome original pandas_df. pandas_df_new se torna como um “apelido” para pandas_df, em vez de um objeto inteiramente novo.

Para evitar este problema, ao definir um novo DataFrame baseado em um DataFrame existente, você precisa criar explicitamente um novo objeto usando o método copy():

# redefinir o DataFrame pandas original:
pandas_df = pd.DataFrame({'a': [1,2,3,4],
                          'b': [5,6,7,8]})
pandas_df

# definir pandas_df_new como uma "cópia" de pandas_df:
pandas_df_new = pandas_df.copy()
pandas_df_new['c'] = [9,10,11,12]
pandas_df_new

# verificar que pandas_df não mudou desta vez
pandas_df

Esta questão de criar inadvertidamente um alias ou uma “visão” de um objeto, em vez de um novo objeto em si, é outra coisa confusa sobre Python. Você sem dúvida encontrará problemas com isso quando estiver começando (certamente encontrei). Na dúvida, apenas copie().

Filtragem

Objetos pandas Series atuam como vetores em R pois você pode fazer perguntas lógicas a eles (nota lateral: isso não funciona com listas Python, mas funciona com objetos pandas Series):

# perguntar quais entradas na coluna "a" são maiores que 1
pandas_df['a'] > 1

O que é muito semelhante à versão R:

# perguntar quais entradas na coluna "a" são maiores que 1
r_df["a"] > 1

Em R base, podemos usar isso para “filtrar” nosso data frame para as linhas onde a condição acima é verdadeira (a primeira linha):

r_df[r_df["a"] > 1, ]

Esta sintaxe não funciona para o DataFrame pandas, no entanto, mas se fizermos algumas modificações de sintaxe onde:

• empregamos o método .loc e
• fornecemos : para a dimensão da coluna (que diz para “retornar todas as colunas”), então obtemos o resultado esperado:

pandas_df.loc[pandas_df.a > 1,:]

Note que loc não é uma função normal por si só pois não é seguido por parênteses redondos (), mas é seguido pelos parênteses de indexação quadrados [].

Se quiséssemos apenas retornar a segunda coluna, forneceríamos o nome da segunda coluna (‘b’) na segunda dimensão dos parênteses quadrados .loc[,].

pandas_df.loc[pandas_df.a > 1,'b']

No entanto, loc espera ou uma Series Booleana ou um nome em seu índice. O método iloc, por outro lado, toma posições de índice inteiro. O seguinte código extrairá a segunda, terceira e quarta linhas da segunda coluna (lembre-se da indexação zero!).

pandas_df.iloc[[1,2,3],1]

Novamente, a saída é uma pandas Series (como é quase sempre o caso quando a saída do seu código envolve uma única coluna).

É um pouco chato que você não possa usar a mesma sintaxe para fazer indexação nomeada (.loc) e inteira (.iloc) para DataFrames pandas, mas tal é a vida.

O método query()

Como este tipo de sintaxe de colchete para indexação parece desajeitado tanto em R quanto Python, você pode alternativamente usar o método query() de um DataFrame pandas semelhante à função filter() do dplyr no tidyverse.

Lembre-se que com o pipe, a sintaxe filter() em R parece:

r_df |> filter(a > 1)

Para DataFrame pandas, a sintaxe query() parece:

pandas_df.query('a > 1')

Note que não há “tidy eval” em Python, então você precisa fornecer um argumento de string entre aspas (“string” é a palavra Python para “character”) ao método query().

Se você quiser usar uma variável externa, precisa acessá-la usando @ dentro do argumento de query:

thresh = 1
pandas_df.query('a > @thresh')

Agrupando data frames

Uma das partes mais poderosas do tidyverse é a capacidade de realizar operações agrupadas em data frames. Por exemplo, se quiséssemos adicionar uma coluna categórica ao nosso data frame R:

# adicionar uma nova coluna categórica a r_df
r_df["cat"] = c("red", "red", "yellow", "yellow")
r_df

Então poderíamos agrupar por esta nova coluna cat e calcular a média dos valores na coluna a em R da seguinte forma:

r_df |> group_by(cat) |> summarize(mean_a = mean(a))

Podemos fazer algo muito semelhante em Python com DataFrames pandas usando o método groupby(). Primeiro, vamos adicionar uma coluna de categorias de cores ao nosso DataFrame pandas:

# adicionar uma nova coluna categórica a pandas_df
pandas_df["cat"] = ["red","red","yellow","yellow"]
pandas_df

e então vamos agrupar o data frame pela nova coluna categórica, extrair a coluna “a”, e então aplicar o método mean à coluna agrupada:

pandas_df.groupby('cat')["a"].mean()

A saída é um objeto Series com os valores da variável de agrupamento como índice de linhas.

Note que se não extraíssemos a coluna “a”, estaríamos aplicando média agrupada a todas as colunas:

pandas_df.groupby('cat').mean()

A saída agora é um DataFrame com os valores da variável de agrupamento como índice de linhas.

Encadeando funções juntas

Note que métodos Python podem ser encadeados juntos usando . de forma semelhante a como encadeamos métodos juntos em R usando o pipe |>.

Por exemplo, se quiséssemos filtrar para linhas onde a era maior que 1, então agrupar pela coluna ‘cat’, e então calcular a média da coluna b, faríamos isso em R da seguinte forma:

r_df |> filter(a > 1) |> group_by(cat) |> summarize(mean_b = mean(b))

Em Python, fazemos algo semelhante, mas usando . em vez de |>:

pandas_df.query('a > 1').groupby('cat')['b'].mean()

Note que o código até a parte mean() resulta em uma “Series agrupada”. Ao contrário de R, muitos objetos em Python nem sempre exibem bem quando chamados:

pandas_df.query('a > 1').groupby('cat')['b']

Podemos usar a função pd.Series() para forçar o objeto Series agrupado de volta para uma Series regular não agrupada (pd.Series() é usado para definir objetos Series na mosca assim como pd.DataFrame() é usado para definir DataFrames na mosca - é o que usei no início deste tutorial).

Vamos tentar forçar o objeto Series agrupado de volta para um objeto pandas Series regular:

pd.Series(pandas_df.query('a > 1').groupby('cat')['b'])

Esta Series contém tuplas (posso dizer pelos parênteses redondos ()), e não vou mentir, tenho medo. Mas pelo menos posso ver quais valores a Series agrupada contém.

Visualização de dados

Ao contrário de R, onde ggplot é a clara “melhor” maneira de criar visualizações de dados (pelo menos na minha opinião), em Python existem muitas bibliotecas diferentes para fazer visualização de dados. As duas que você mais provavelmente ouviu falar incluem matplotlib e seaborn.

Seaborn é um pouco mais bonito que matplotlib, mas tudo que vou mostrar neste tutorial são os métodos de visualização de dados embutidos para objetos pandas Series e DataFrame que são construídos sobre matplotlib.

Para fazer algumas visualizações mais interessantes, vamos carregar o conjunto de dados gapminder (de uma URL) em um DataFrame pandas usando a função pandas pd.read_csv(). Esta função pd.read_csv() também pode ser usada para carregar um arquivo .csv local.

gapminder = pd.read_csv("https://raw.githubusercontent.com/rlbarter/gapminder-data/main/gapminder.csv")

Vamos usar o método DataFrame head() para olhar as primeiras 6 linhas:

gapminder.head()

Vamos praticar algumas de nossas novas habilidades Python. O seguinte código filtrará os dados da Austrália e calculará a expectativa de vida média:

gapminder.query('country == "Australia"')['lifeExp'].mean()

E o seguinte calculará o gdpPercap médio por continente:

gdp_by_continent = gapminder.groupby('continent')['gdpPercap'].mean()
gdp_by_continent

Note que a saída deste último código é um objeto Series. Note também que o índice (de linhas) é o continente:

gdp_by_continent.index

O que acontecerá se aplicarmos o método plot() a este objeto Series?

gdp_by_continent.plot()

Por padrão, um gráfico de linhas é criado e o índice de linhas é usado como rótulos do eixo x por padrão. O método plot() do DataFrame aqui atua como um wrapper para a função de plotagem da biblioteca matplotlib.

Se eu quisesse um gráfico de barras em vez de um gráfico de linhas, poderia criar um usando o método plot.bar() (em vez de apenas o método plot()):

gdp_by_continent.plot.bar()

Novamente, o índice de linhas do objeto Series é usado como rótulos do eixo x por padrão.

Poderíamos criar de forma semelhante um gráfico de dispersão das colunas gdpPercap e lifeExp do gapminder usando o método plot.scatter():

gapminder.plot.scatter(x='gdpPercap', y='lifeExp')

Embora estes plots pandas embutidos sejam bons, pessoalmente prefiro a aparência da biblioteca seaborn e o workflow da biblioteca plotly express, nenhum dos quais cobri neste post (e nenhum dos quais é tão bom quanto ggplot2 na minha opinião). Recomendo que você investigue ambas estas bibliotecas (e mais!) para descobrir o workflow de visualização de dados que prefere!

Concluindo

Obviamente, há muito mais para aprender sobre Python, mas vou parar por aqui. Espero que este post tenha ajudado alguns de vocês usuários R a começar sua jornada Python!

Referências

BARTER, Rebecca. An introduction to Python for R Users. 2023. Disponível em: https://rebeccabarter.com/blog/2023-09-11-from_r_to_python

MCKINNEY, Wes. Python for Data Analysis: Data Wrangling with pandas, NumPy, and Jupyter. 3rd ed. O’Reilly Media, 2022.