R vs. Python: um guia abrangente de tradução de código

Introdução

A transição entre R e Python é um desafio comum para cientistas de dados e programadores. Ambas as linguagens oferecem ferramentas poderosas para análise de dados, mas diferem em sintaxe, expressões idiomáticas e paradigmas subjacentes. Este guia fornece uma referência lado a lado para traduzir código R comum para Python. Cobrimos operações gerais, manipulações de dataframes, tipos de objetos e outras diferenças importantes. Além disso, incluímos comparações detalhadas de bibliotecas equivalentes e cenários do mundo real para ilustrar como essas traduções funcionam em projetos práticos.

1. Sintaxe geral e operações

Abaixo está uma tabela resumida que apresenta expressões comuns do R junto com seus equivalentes em Python:

Código R	Código Python
`new_function <- function(a, b=5) { return(a+b) }`	`def new_function(a, b=5): return a+b`
`for (val in c(1,3,5)) { print(val) }`	`for val in [1,3,5]: print(val)`
`a <- c(1,3,5,7)`	`a = [1,3,5,7]`
`a <- c(3:9)`	`a = list(range(3,9))`
`class(a)`	`type(a)`
`a <- 5`	`a = 5`
`a^2`	`a**2`
`a%%5`	`a % 5`
`a & b`	`a and b`
`a \| b`	`a or b`
`rev(a)`	`a[::-1]`
`a %*% b`	`a @ b`
`paste("one", "two", "three", sep="")`	`'one' + 'two' + 'three'`
`substr("hello", 1, 4)`	`'hello'[:4]`
`strsplit('foo,bar,baz', ',')`	`'foo,bar,baz'.split(',')`
`paste(c('foo', 'bar', 'baz'), collapse=',')`	`','.join(['foo', 'bar', 'baz'])`
`gsub("(^[\\n\\t ]+\|[\\n\\t ]+$)", "", " foo ")`	`' foo '.strip()`
`sprintf("%10s", "lorem")`	`'lorem'.rjust(10)`
`paste("value: ", toString("8"))`	`'value: ' + str(8)`
`toupper("foo")`	`'foo'.upper()`
`nchar("hello")`	`len("hello")`
`substr("hello", 1, 1)`	`"hello"[0]`
`a = rbind(c(1,2,3), c('a','b','c'))`	`list(zip([1,2,3], ['a','b','c']))`
`d = list(n=10, avg=3.7, sd=0.4)`	`{'n': 10, 'avg': 3.7, 'sd': 0.4}`
`quit()`	`exit()`

2. Operações com dataframes

Abaixo está uma tabela comparando operações comuns de dataframe em R e Python:

Código R	Código Python
`head(df)`	`df.head()`
`tail(df)`	`df.tail()`
`nrow(df)`	`df.shape[0]` or `len(df)`
`ncol(df)`	`df.shape[1]` or `len(df.columns)`
`df$col_name`	`df['col_name']` or `df.col_name`
`summary(df)`	`df.describe()`
`df %>% arrange(c1, desc(c2))`	`df.sort_values(by=['c1','c2'], ascending=[True, False])`
`df %>% rename(new_col = old_col)`	`df.rename(columns={'old_col': 'new_col'})`
`df$smoker <- mapvalues(df$smoker, from=c('yes','no'), to=c(0,1))`	`df['smoker'] = df['smoker'].map({'yes': 0, 'no': 1})`
`df$c1 <- as.character(df$c1)`	`df['c1'] = df['c1'].astype(str)`
`unique(df$c1)`	`df['col_name'].unique()`
`length(unique(df$c1))`	`len(df['col_name'].unique())`
`max(df$c1, na.rm=TRUE)`	`df['col_name'].max()`
`df$c1[is.na(df$c1)] <- 0`	`df['col_name'] = df['col_name'].fillna(0)`
`df <- data.frame(col_a=c('a','b','c'), col_b=c(1,2,3))`	`df = pd.DataFrame({'col_a': ['a','b','c'], 'col_b': [1,2,3]})`
`df <- read.csv("input.csv", header=TRUE, na.strings=c("","NA"), sep=",")`	`df = pd.read_csv("input.csv")`
`write.csv(df, "output.csv", row.names=FALSE)`	`df.to_csv("output.csv", index=False)`
`df[c(4:6)]`	`df.iloc[:, 3:6]`
`mutate(df, c=a-b)`	`df.assign(c=df['a']-df['b'])`
`distinct(select(df, col1))`	`df[['col1']].drop_duplicates()`

3. Tipos de objetos

Uma referência rápida para tipos de objetos em R e Python:

Objeto R	Objeto Python
`character`	`string` (`str`)
`integer`	`integer` (`int`)
`logical`	`boolean` (`bool`)
`numeric`	`float` (`float`)
`complex`	`complex` (`complex`)
Vetor de elemento único	`Scalar`
Vetor de múltiplos elementos	Lista (`list`)
Lista (tipos mistos)	Tupla (`tuple`)
Lista com itens nomeados	Dicionário (`dict`)
`Matrix/Array`	`numpy ndarray` (`numpy.ndarray`)
`NULL`, `TRUE`, `FALSE`	`None`, `True`, `False`
`Inf`	`inf`
`NaN`	`nan`

4. Outras diferenças importantes

Operadores de atribuição:
R usa <-, enquanto Python usa =.
Indexação de uma variável: Os índices R começam em 1; os índices Python começam em 0.
Tratamento de erros:
R usa tryCatch(), Python usa try...except.
Operações em cadeia (ou Piping):
O R usa %>% para encadear operações; o Python depende do encadeamento de métodos ou de bibliotecas adicionais.
Convenções de nomenclatura:
O R costuma usar pontos nos nomes das variáveis (por exemplo, var.name), enquanto o Python usa sublinhados (por exemplo, var_name).

5. Comparações de bibliotecas

Para aqueles que estão fazendo a transição do R para o Python, é importante saber quais bibliotecas no Python oferecem funcionalidades semelhantes aos seus pacotes R favoritos. Aqui está uma comparação rápida:

Manipulação de dados:
- R: dplyr
- Python: pandas (com alternativas como polars, tidypolars, datar, siuba e pyjanitor)
Visualização de dados:
- R: ggplot2
- Python: lets-plot, plotnine, matplotlib, Seaborn
Modelagem estatística:
- R: tidymodels, caret
- Python: scikit-learn, statsmodels
Criação de relatórios:
- R: knitr, r markdown
- Python: Quarto, Jupyter Notebooks
Web scraping:
- R: rvest
- Python: BeautifulSoup
Teste de unidade:
- R: testthat
- Python: pytest

6. Cenários do mundo real

Estudo de caso: Pipeline de análise de dados

Imagine que você tem um conjunto de dados para avaliações de clientes. Em R, você pode usar o tidyverse para limpar e visualizar os dados, enquanto em Python você usaria pandas e matplotlib/Seaborn. Considere o seguinte cenário:

Fluxo de trabalho do R:
- Importar dados usando readr.
- Limpe e transforme os dados usando dplyr.
- Visualize tendências de revisão usando ggplot2.
- Construa um modelo preditivo usando tidymodels.
Fluxo de trabalho Python:
- Importar dados com pandas.
- Limpe e transforme usando pandas (ou bibliotecas semelhantes a dplyr, como siuba).
- Visualize tendências com matplotlib/Seaborn ou lets-plot.
- Construa um modelo preditivo usando scikit-learn.

Em ambos os casos, as etapas são semelhantes. Este cenário demonstra como as tarefas essenciais da ciência de dados podem ser realizadas em qualquer uma das linguagens, destacando a facilidade de alternar contextos enquanto aproveita métodos familiares.

Exemplo prático

Por exemplo, se você estiver analisando a opinião dos clientes, você pode:

R: Use dplyr para filtrar avaliações positivas e ggplot2 para criar um gráfico de barras com pontuações de sentimento.
Python: Use pandas para filtrar os dados e Seaborn para criar um gráfico de barras semelhante.

Esses exemplos ajudam a ilustrar que as principais diferenças geralmente estão na sintaxe, e não nos conceitos subjacentes.

Conclusão

Este guia serve como uma referência abrangente para traduzir código entre R e Python. Ao abordar sintaxe geral, operações de dataframe, tipos de objetos, comparações de bibliotecas e cenários do mundo real, você obtém uma visão holística das diferenças e semelhanças entre essas duas linguagens poderosas. Esteja você fazendo a transição do R para o Python ou trabalhando em um ambiente multilíngue, este guia o ajudará a navegar nessa jornada com confiança.

Leitura adicional

Boa programação e aproveite para preencher a lacuna entre R e Python!

Referências

Vindo do R

Explore mais artigos

Nota

Aqui estão mais artigos da mesma categoria para ajudá-lo a se aprofundar no tópico.

Fluxos de trabalho de aprendizado de máquina: tidymodels vs. scikit-learn

Comparando o treinamento, a avaliação e a previsão de modelos de ML em R e Python