Relatório de Aula Prática 02 - Introdução ao R

Estatística e Probabilidade
Prof. Ben Dêivide (DEFIM/CAP/UFSJ)

Autor

João Delpasso e Maria Eduarda Motta

Data de Publicação

16/04/2026, 21:49

1 Introdução

O R é uma linguagem de programação e ambiente de software de código aberto, e tem foco na computação estatística e análise de dados. Foi consolidada como uma das ferramentas padrão padrão na ciência de dados moderna, permitindo desde análises financeiras complexas até bioinformática. Assim o R, é uma linguagem que possui uma grande comunidade ativa, que possui uma grande comunidade ativa, que sempre está contribuindo para o desenvolvimento de recursos e pacotes, e por esse motivo é muito adotado o R é uma linguagem amplamente adotada por diversas áreas, como estatística e ciência de dados.

Seu diferencial é a sua capacidade de promover pesquisas reprodutíveis, e para isso integra o código, a análise e a visualização em um fluxo coeso. Este relatório, com base no livro de Batista e Oliveira (2022), apresentará como realizar a configuração inicial para programar em R, além de apresentar os conceitos básicos da linguagem e como ela pode ser útil para análises estatísticas e manipulação de dados.

2 Objetivo

Realizar a instalação do R e do RStudio e aprender o básico da linguagem R.

2.1 Objetivos específicos

Instalação do R e RStudio.
Primeiras impressões de sintaxe da linguagem R.
Aprender conceitos básicos da linguagem R.
Introdução ao uso de pacotes em R.
Breve introdução ao pacote leem.

3 Instalação do R e do RStudio

O primeiro passo para programar em uma linguagem é a configuração do ambiente de desenvolvimento.

Para este relatório será utilizado o ambiente do RStudio, uma interface gráfica que facilita a programação em R, mas é importante destacar que o R pode ser utilizado em outros ambientes, como o VS Code, Jupyter Notebook, ou mesmo diretamente no terminal do sistema operacional.

O R em si é a linguagem de programação, enquanto o RStudio é um ambiente de desenvolvimento integrado (IDE) que oferece uma interface amigável para escrever código, visualizar gráficos e gerenciar projetos em R.

Para configuração do ambiente:

Instale a versão apropriada do R ao seu sistema operacional (Windows, Linux ou macOS).
Instale o RStudio.

4 Interface do R

R é uma linguagem interpretada, ou seja, não requer que o codigo passe por um compilador, mas sim um interpretador. Ao instalar o R, o usuários está apenas instalando o programa que irá interpretar o codigo, para opera-lo é nescessario uma interface:

Nota

Diferente de um compilador, um interpretador não gera um arquivo executável, ele avalia o programa em tempo real.

4.1 Console

O método mais simples de executar algum comando em R, é utilizando um terminal com o console do R, onde cada ‘enter’, irá mandar a linha para o interpretador que avaliará e retornará o produto do comando, para então aguardar por novos comandos.

4.2 R Studio

O RStudio opera apenas como uma interface, com objetivo de facilitar ao usuário de criar programas de múltiplas linhas e arquivos, alem de ferramentas para melhor visualizar partes internas do ambiente, como variaáeis já declaradas, objetos e funções.

5 Sintaxe

Nesta parte será apresentada a sintaxe básica da linguagem R, incluindo a estrutura de comandos, a forma de escrever código e as convenções de nomenclatura. A sintaxe é a base para a escrita de qualquer linguagem de programação, é fundamental a compreensão dela para a construção de códigos em R.

Para chamar variaveis e funções em R, basta escrever o nome da variável ou função, seguido de parênteses para funções, por exemplo:

# Exemplo de sintaxe:
idade <- 25
nome <- "Giovana"

idade

[1] 25

nome

[1] "Giovana"

round(10.2) # arredonda o numero para o valor inteiro

[1] 10

Nota

Veja as seções de Operadores básicos, Estruturas de dados e Funções básicas para entender melhor a sintaxe da linguagem R e o código acima.

5.1 Estruturas de dados:

Linguagens de programação possuem diferentes jeitos de definir dados e armazenar informações, em R os dados são organizados em objetos, e cada objeto tem um tipo específico, que determina como os dados são armazenados e manipulados.

5.1.1 Tipos básicos:

Numéricos: para armazenar números, como 1, 2.5, etc.

Nota

Em R todos os números são armazenados como numéricos do tipo double (mesmo que pareça inteiro o R trata assim para garantir que qualquer operação futura seja precisa), mesmo que sejam inteiros (é um prduto flutuante, esse termo se refere a maneira como o computador armazana números que podem ter casas decimais), floats ou outros tipos, a linguagem lida por trás dos panos com a conversão de tipos, então não é necessário se preocupar com isso.
```
numero1 <- 10
numero2 <- 3.14

numero1
```
```
[1] 10
```
```
numero2
```
```
[1] 3.14
```
Inteiros: para armazenar números inteiros, como 1L, 2L, etc.

Nota

Mesmo com o tipo Numérico, é possível armazenar números inteiros usando o sufixo “L”, por exemplo, 10L, isso é útil para garantir que um número seja tratado como inteiro em operações específicas.
```
inteiro1 <- 10L
inteiro2 <- 20L

inteiro1
```
```
[1] 10
```
```
inteiro2
```
```
[1] 20
```

Complexos: para armazenar números complexos, como 1 + 2i, etc.

complexo1 <- 1 + 2i
complexo2 <- 3 - 4i

complexo1

[1] 1+2i

complexo2

[1] 3-4i

Caracteres: para armazenar texto, como “Olá”, “Mundo”, etc.

texto1 <- "Olá"
texto2 <- "Mundo"

texto1

[1] "Olá"

texto2

[1] "Mundo"

Lógicos: para armazenar valores booleanos, como TRUE ou FALSE.

logico1 <- TRUE
logico2 <- FALSE

logico1

[1] TRUE

logico2

[1] FALSE

Função class() e typeof(): A primeira mostra a identidade do objeto, retorna o atributo da classe do objeto, diz como as outras funções devem tratar esse objeto. Já a segunda tem uma natureza interna, revela como o R armazena o objeto na memória do computador, retorna a natureza do dado.

Nota

No R é comum encontrarmos funções que parecem fazer a mesma coisa, mas extraem informações diferentes dos dados, as duas principais para investigação de objetos.

Código

nome <- "Giovana"
idade <- 25
# Verificando o nome
typeof(nome)

[1] "character"

Código

class(nome)

[1] "character"

Código

dados <- data.frame(nome, idade)
# Aqui aparece a diferença
typeof(dados)

[1] "list"

Código

class(dados)

[1] "data.frame"

Nota

Acredito que é importante de mencionar já que funções falham por esperar um objeto, e isso é bom para ter uma ideia de qual é o problema, mas não vamos nos aprofundar muito nisso por serem conceitos mais complexos

5.1.2 Tipos de dados estruturados:

Vetores: para armazenar uma sequência de elementos do mesmo tipo(homogêneos). Como os vetores são homogêneos, todos os elementos dentro deles precisam ser do mesmo tipo, se tentar misturar dados diferentes ocorre a coerção automática, que segue uma hierarquia, para evitar a perda de informações transforma o tipo mais simples no mais flexível (Logical se torna Integer; Integer se torna Double; Double se torna Character)

Nota

Nos vetores muitos usam a função c() sem saber que é uma abreviação de combine, essa função serve para agrupar elementos individuais em uma estrutura de dados unidimensional.
```
vetor_numerico <- c(1, 2, 3, 4, 5)
vetor_texto <- c("A", "B", "C", "D", "E")

vetor_numerico
```
```
[1] 1 2 3 4 5
```
```
vetor_texto
```
```
[1] "A" "B" "C" "D" "E"
```
Listas: para armazenar uma coleção de elementos de diferentes tipos(heterogêneos). Assim, uma lista pode armazenar números, textos, valores, vetores e outras listas (e por esse último, são chamados de recursivos)
```
lista1 <- list(a = 1, b = 2, c = 3)
lista2 <- list(d = "A", e = "B", f = "C")

lista1
```
```
$a
[1] 1

$b
[1] 2

$c
[1] 3
```
```
lista2
```
```
$d
[1] "A"

$e
[1] "B"

$f
[1] "C"
```

Matrizes: para armazenar dados homogêneos em uma estrutura bidimensional.

matriz1 <- matrix(1:6, nrow = 2, ncol = 3)
matriz2 <- matrix(c("A", "B", "C", "D", "E", "F"), nrow = 2, ncol = 3)

matriz1

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

matriz2

     [,1] [,2] [,3]
[1,] "A"  "C"  "E" 
[2,] "B"  "D"  "F"

Data Frames: são a base para a maioria das análises estatísticas e armazenam dados heterogêneos em uma estrutura bidimensional (cada coluna pode ter um tipo de dado diferente, contando que todas as colunas tenham o mesmo comprimento).
```
dataframe1 <- data.frame(col1 = c(1, 2, 3), col2 = c("A", "B", "C"))

dataframe1
```
```
  col1 col2
1    1    A
2    2    B
3    3    C
```

Arrays: para armazenar dados homogêneos em uma estrutura multidimensional.

array1 <- array(1:8, dim = c(2, 2, 2))

array1

, , 1

     [,1] [,2]
[1,]    1    3
[2,]    2    4

, , 2

     [,1] [,2]
[1,]    5    7
[2,]    6    8

Fatores: para armazenar dados categóricos.

fator1 <- factor(c("A", "B", "C", "A", "B"))

fator1

[1] A B C A B
Levels: A B C

5.2 Operadores básicos:

Como toda linguagem de programação, R possui operadores básicos para realizar operações matemáticas, lógicas e de comparação. Esses operadores são essenciais para a construção de códigos em R e permitem manipular dados de forma eficiente.

5.2.1 Operadores de Atribuição: `<-` ou `=`

Atribuição é o processo de armazenar um valor em uma variável. Em R, a atribuição pode ser feita usando o operador <- ou =, a diferença dos operadores está no escopo, <- é o operador de atribuição tradicional em R e é recomendado para a maioria dos casos, enquanto = é mais comumente usado em argumentos de funções. Por exemplo:

# Usando <- para atribuição
var1 <- 10
# Usando = para atribuição
var2 = 20

# Uso de = em argumentos de função
var3 <- mean(x = c(1, 2, 3, 4, 5))

Nota

O <- pode ser usado em qualquer lugar do código, enquanto o = é restrito geralmente para a definição de argumentos dentro de funções.

5.2.2 Operadores aritméticos: `+`, `-`, `*`, `/`, `^ ou **`, `%%`

Esses operadores são usados para realizar operações matemáticas básicas, como adição, subtração, multiplicação, divisão, exponenciação e resto de divisão. Por exemplo:

a <- 5
b <- 3

soma <- a + b       # Adição
diferenca <- a - b   # Subtração
produto <- a * b    # Multiplicação
quociente <- a / b   # Divisão
potencia <- a ^ b    # Exponenciação
resto_div <- a %% b #Resto de divisão

5.2.3 Operadores de comparação: `==`, `!=`, `<`, `>`, `<=`, `>=`

Esses operadores são usados para comparar valores e retornar um resultado lógico (TRUE ou FALSE). Por exemplo:

x <- 10
y <- 20

comparacao1 <- x == y   # Igual a
comparacao2 <- x != y   # Diferente de
comparacao3 <- x < y    # Menor que
comparacao4 <- x > y    # Maior que
comparacao5 <- x <= y   # Menor ou igual a
comparacao6 <- x >= y   # Maior ou igual a

5.2.4 Operadores lógicos: `&`, `|`, `!`

Esses operadores são usados para combinar condições lógicas. O operador & representa a conjunção (AND/E), o operador | representa a disjunção (OR/Ou) e o operador ! representa a negação (NOT/Não). Por exemplo:

a <- TRUE
b <- FALSE

resultado1 <- a & b   # AND E
resultado2 <- a | b   # OR Ou
resultado3 <- !a      # NOT Não

5.2.5 Operadores de indexação: `[ ]`, `[[ ]]`, `$`

Esses operadores são usados para acessar elementos específicos de vetores, listas ou data frames. O operador [ ] é usado para acessar elementos por posição, o operador [[ ]] é usado para acessar elementos por nome e o operador $ é usado para acessar colunas em data frames. Por exemplo:

vetor <- c(10, 20, 30, 40, 50)
lista <- list(a = 1, b = 2, c = 3)
dataframe <- data.frame(col1 = c(1, 2, 3), col2 = c("A", "B", "C"))

elemento_vetor <- vetor[2]         # Acessa o segundo elemento do vetor
elemento_lista <- lista[["b"]]     # Acessa o elemento "b" da lista
coluna_dataf <- dataframe$col1 # Acessa a coluna "col1" do data frame

Nota

Veja a seção tipos de dados para melhor entendimento do código acima.

5.3 Funções básicas:

Funções são blocos de código que realizam uma tarefa específica e podem ser reutilizados em diferentes partes do código. Em R, existem muitas funções pré-definidas para realizar operações comuns, como calcular a média, a variância, o desvio padrão, entre outras.

5.3.1 Funções Matemáticas Básicas:

Soma: sum(), calcula a soma de um conjunto de números.
```
sum(x = c(1, 2, 3, 4, 5))
```
```
[1] 15
```
Valor Absoluto: abs(), calcula o valor absoluto de um número.
```
abs(x = -10)
```
```
[1] 10
```
Raiz Quadrada: sqrt(), calcula a raiz quadrada de um número.
```
sqrt(x = 16)
```
```
[1] 4
```

Logaritmo: log(), calcula o logaritmo de um número.

log(x = 100, base = 10) # Calcula o logaritmo de 100 na base 10

[1] 2

Arredondamento: round(), arredonda um número para um número específico de casas decimais.
```
round(x = 3.14159, digits = 2) # Arredonda para 2 casas decimais
```
```
[1] 3.14
```
Exponencial: exp(), calcula o valor exponencial de um número.
```
exp(x = 1) # Calcula e elevado a 1
```
```
[1] 2.718282
```

5.3.2 Funções Estatísticas Básicas:

Média: mean(), calcula a média aritmética de um conjunto de números.
```
mean(x = c(1, 2, 3, 4, 5))
```
```
[1] 3
```
Variância: var(), calcula a variância de um conjunto de números.
```
var(x = c(1, 2, 3, 4, 5))
```
```
[1] 2.5
```
Desvio Padrão: sd(), calcula o desvio padrão de um conjunto de números.
```
sd(x = c(1, 2, 3, 4, 5))
```
```
[1] 1.581139
```
Mediana: median(), calcula a mediana de um conjunto de números.
```
median(x = c(1, 2, 3, 4, 5))
```
```
[1] 3
```
Máximo e Mínimo: max() e min(), calculam o valor máximo e mínimo de um conjunto de números, respectivamente.
```
max(x = c(1, 2, 3, 4, 5))
```
```
[1] 5
```
```
min(x = c(1, 2, 3, 4, 5))
```
```
[1] 1
```

5.3.3 Funções de Manipulação de Dados:

Tamanho: length(), calcula o número de elementos em um vetor ou lista.
```
length(x = c(1, 2, 3, 4, 5))
```
```
[1] 5
```
Nomes: names(), retorna os nomes dos elementos em uma lista ou data frame.
```
names(x = list(a = 1, b = 2, c = 3))
```
```
[1] "a" "b" "c"
```
Dimensão: dim(), calcula as dimensões de uma matriz ou data frame.
```
dim(x = matrix(1:6, nrow = 2, ncol = 3))
```
```
[1] 2 3
```
Número de Linhas e Colunas: nrow() e ncol(), calculam o número de linhas e colunas em uma matriz ou data frame, respectivamente.
```
nrow(x = matrix(1:6, nrow = 2, ncol = 3))
```
```
[1] 2
```
```
ncol(x = matrix(1:6, nrow = 2, ncol = 3))
```
```
[1] 3
```
Classe: class(), retorna a classe de um objeto em R.
```
class(x = c(1, 2, 3, 4, 5))
```
```
[1] "numeric"
```

6 Pacotes

O Uso de pacotes em R é fundamental para expandir as funcionalidades da linguagem e facilitar a realização de tarefas específicas. Pacotes são coleções de funções, dados e documentação que podem ser facilmente instalados e carregados em R. Existem milhares de pacotes disponíveis para diversas áreas, como estatística, ciência de dados, visualização, entre outras. Importante mencionar que, pacotes são criados por membros da comunidade e podem ser encontrados no repositório oficial do CRAN ou em outros repositórios, como o GitHub.

6.1 Instalação e Carregamento de Pacotes

Para instalar e carregar um pacote em R, basta usar a função install.packages() e library(), passando o nome do pacote como argumento. Por exemplo, o pacote ggplot2, que é amplamente utilizado para visualização de dados, basta executar:

install.packages("ggplot2") #Instala o pacote ggplot2
library(ggplot2) #Carrega o pacote ggplot2 para uso

6.2 Pacotes populares em R

Alguns pacotes possuem uma grande popularidade e são amplamente utilizados pela comunidade, como:

ggplot2: para visualização de dados.
dplyr: para manipulação de dados.
tidyr: para organização de dados.
readr: para leitura de arquivos.
stringr: para manipulação de strings.
lubridate: para manipulação de datas.
caret: para machine learning.
tidyverse: para um conjunto de pacotes importantes

6.3 Pacote `leem`

Na disciplina de Estatística e Probabilidade, o pacote leem é uma ferramenta útil para realizar análises estatísticas e manipulação de dados. Ele oferece uma variedade de funções para calcular medidas de tendência central, variabilidade, gráficos, entre outras funcionalidades.

O pacote leem é mantido pelo professor Ben Dêivide e pode ser instalado e carregado da seguinte forma:

install.packages("leem") #Instala o pacote leem
library(leem) #Carrega o pacote leem para uso

6.3.1 Funções do pacote `leem`

Alguns exemplos de funções que serão utilizadas durante a disciplina são:

new_leem(): para criar um objeto do tipo leem.

library(leem)

dados <- c(1, 2, 3, 4, 5)
leem_obj <- new_leem(x = dados, variable = 2)
leem_obj

[1] 1 2 3 4 5

tabfreq(): para criar uma tabela de frequências.

tabf <- tabfreq(leem_obj)
tabf


Table of frequency 
Type of variable: continuous

     Classes Fi PM  Fr Fac1 Fac2 Fp Fac1p Fac2p
1 -1 |---  3  2  1 0.4    2    5 40    40   100
2  3 |---  7  3  5 0.6    5    3 60   100    60

============================================== 
Classes: Grouping of classes 
Fi: Absolute frequency 
PM: Midpoint 
Fr: Relative frequency 
Fac1: Cumulative frequency (below) 
Fac2: Cumulative frequency (above) 
Fp: Percentage frequency 
Fac1p: Cumulative percentage frequency (below) 
Fac2p: Cumulative percentage frequency (above)

barplot(): para criar um gráfico de barras a partir de uma tabela de frequências.

barplot(tabf, main = "Frequência dos dados", xlab = "Valores", ylab = "Frequência", barcol = "steelblue")

Nota

Para descobrir mais funções do pacote leem e suas aplicações, consulte a documentação oficial.

7 Considerações finais

O R é uma ótima ferramenta para analisar dados estatísticos, de primeiro pode demorar para ser aprendida devido a sintaxe, mas depois ela recompensa com a velocidade e eficiência para resolver problemas complexos e inclusive se integrar com outras linguagens

7.1 COMENTÁRIOS

Agora acho interessante responder algumas perguntas

Porque usar R?
Quais outros locais posso programar em R, fora o RStudio?
Como aprendi a interpretar as mensagens de erro do R?
Quais comunidades/sites ajudam nesse processo de aprendizado?
Como garantir que minha análise seja reprodutível para outros?
Como o uso de projetos (.Rproj) ajudam na organização das pastas e arquivos?

Respondendo as questões acima

O R foi desenvolvido por e para estatísticos e cientistas de dados, diferente de ferramentas de planilhas, ele permite manipular vários dados com uma grande precisão e garantir que qualquer análise possa ser repetida exatamente da mesma forma, fora que tem pacotes que podem ser instalados que cobrem quase todos os métodos estatísticos existentes, se não todos.
Mesmo o RStudio sendo o padrão para programar em R, você pode usar o VS Code, o Jupyter Notebook (diretamente no terminal do sistema operacional) ou mesmo em plataformas na nuvem, como Posit Cloud e Google Colab.
Interpretar erros em R é um processo de tradução, geralmente na mensagem de erro é indicado onde no código está o erro e porque está errado, logo acredito que no início, e mesmo depois, o segredo é copiar o código e jogar no ChatGPT e pergutar como arrumar e entender a causa da raiz.
As fontes de apoio que acho interessantes são:

Site do Ben Deivide;
Vídeos no youtube;

A reprodutibilidade garantida vem por meio de:

Scripts bem comentados (explicando o que e porque foi feito);
R Markdown ou Quarto (unem o código, resultados e texto em um documento final, PDF ou HTML);
Controle de versões (pode ser feito através do GitHub, site muito usado junto ao R que rastreia mudanças no código; local onde inclusive pode ser achado mais projetos semelhantes ao seu);

O .Rproj é fundamental, já que ele quem define o seu diretório de trabalho, ao abrir um projeto, o R já sabe onde estão os dados e onde deve salvar os gráficos. Ele isola o seu ambiente de trabalho, permitindo que você altere entre diferentes análises sem que esses dados interfiram um no outro.

8 Referências

BATISTA, B. D. O.; OLIVEIRA, D. A. B. J. R básico. 1. ed. Ouro Branco, MG: [s.n.], 2022. p. 321

--- # Só mude aqui!!!! author: "João Delpasso e Maria Eduarda Motta" title: "Relatório de Aula Prática 02 - Introdução ao R" bibliography: referencias.bib # A partir daqui nao faca alteracoes!!!!! link-citations: true csl: associacao-brasileira-de-normas-tecnicas-ipea.csl subtitle: "<a href='https://bendeivide.github.io/courses/epaec/' target='_blank'>Estatística e Probabilidade</a> </br> <a href='https://bendeivide.github.io' target='_blank'>Prof. Ben Dêivide (DEFIM/CAP/UFSJ)</a>" include-before-body: header.html date: now date-format: "DD/MM/YYYY, HH:mm" lang: pt-BR format: html: toc: true number-sections: true theme: bootstrap css: styles.css code-fold: true code-tools: true execute: echo: true warning: false message: false --- {{< include _links.md >}} ## Introdução O [R] é uma linguagem de programação e ambiente de software de código aberto, e tem foco na computação estatística e análise de dados. Foi consolidada como uma das ferramentas padrão padrão na ciência de dados moderna, permitindo desde análises financeiras complexas até bioinformática. Assim o R, é uma linguagem que possui uma grande comunidade ativa, que possui uma grande comunidade ativa, que sempre está contribuindo para o desenvolvimento de recursos e pacotes, e por esse motivo é muito adotado o [R] é uma linguagem amplamente adotada por diversas áreas, como estatística e ciência de dados. Seu diferencial é a sua capacidade de promover pesquisas reprodutíveis, e para isso integra o código, a análise e a visualização em um fluxo coeso. Este relatório, com base no livro de @Rbasico2022, apresentará como realizar a configuração inicial para programar em [R], além de apresentar os conceitos básicos da linguagem e como ela pode ser útil para análises estatísticas e manipulação de dados. ## Objetivo Realizar a instalação do R e do RStudio e aprender o básico da linguagem R. ### Objetivos específicos - [Instalação](#sec-setup) do [R] e [RStudio]. - Primeiras impressões de [sintaxe](#sec-sintaxe) da linguagem [R]. - Aprender conceitos básicos da linguagem [R]. - Introdução ao uso de [pacotes](#sec-pacotes) em [R]. - Breve introdução ao [pacote](#sec-pacote-leem) `leem`. ## Instalação do R e do RStudio {#sec-setup} O primeiro passo para programar em uma linguagem é a configuração do ambiente de desenvolvimento. Para este relatório será utilizado o ambiente do [RStudio], uma interface gráfica que facilita a programação em [R], mas é importante destacar que o [R] pode ser utilizado em outros ambientes, como o [VS Code], [Jupyter Notebook], ou mesmo diretamente no terminal do sistema operacional. O [R] em si é a linguagem de programação, enquanto o [RStudio] é um ambiente de desenvolvimento integrado (IDE) que oferece uma interface amigável para escrever código, visualizar gráficos e gerenciar projetos em [R]. Para configuração do ambiente: - Instale a versão apropriada do [R] ao seu sistema operacional (Windows, Linux ou macOS). - Instale o [RStudio]. ## Interface do R [R] é uma linguagem interpretada, ou seja, não requer que o codigo passe por um compilador, mas sim um interpretador. Ao instalar o [R], o usuários está apenas instalando o programa que irá interpretar o codigo, para opera-lo é nescessario uma interface: ::: {.callout-note} Diferente de um compilador, um interpretador não gera um arquivo executável, ele avalia o programa em tempo real. ::: ### Console O método mais simples de executar algum comando em [R], é utilizando um terminal com o console do [R], onde cada 'enter', irá mandar a linha para o interpretador que avaliará e retornará o produto do comando, para então aguardar por novos comandos. ### R Studio O [RStudio] opera apenas como uma interface, com objetivo de facilitar ao usuário de criar programas de múltiplas linhas e arquivos, alem de ferramentas para melhor visualizar partes internas do ambiente, como variaáeis já declaradas, objetos e funções. ## Sintaxe {#sec-sintaxe} Nesta parte será apresentada a sintaxe básica da linguagem [R], incluindo a estrutura de comandos, a forma de escrever código e as convenções de nomenclatura. A sintaxe é a base para a escrita de qualquer linguagem de programação, é fundamental a compreensão dela para a construção de códigos em [R]. Para chamar variaveis e funções em [R], basta escrever o nome da variável ou função, seguido de parênteses para funções, por exemplo: ```{r} #| code-fold: false #| code-line-numbers: true # Exemplo de sintaxe: idade <- 25 nome <- "Giovana" idade nome round(10.2) # arredonda o numero para o valor inteiro ``` ::: {.callout-note} Veja as seções de [Operadores básicos](#sec-operadores), [Estruturas de dados](#sec-tipos-dados) e [Funções básicas](#sec-funcoes) para entender melhor a sintaxe da linguagem [R] e o código acima. ::: ### Estruturas de dados: {#sec-tipos-dados} Linguagens de programação possuem diferentes jeitos de definir dados e armazenar informações, em [R] os dados são organizados em objetos, e cada objeto tem um tipo específico, que determina como os dados são armazenados e manipulados. #### Tipos básicos: {#subsec-tipos-dados-basicos} - Numéricos: para armazenar números, como 1, 2.5, etc. ::: {.callout-note} Em [R] todos os números são armazenados como numéricos do tipo double (mesmo que pareça inteiro o R trata assim para garantir que qualquer operação futura seja precisa), mesmo que sejam inteiros (é um prduto flutuante, esse termo se refere a maneira como o computador armazana números que podem ter casas decimais), floats ou outros tipos, a linguagem lida por trás dos panos com a conversão de tipos, então não é necessário se preocupar com isso. ::: ```{r} #| code-fold: false numero1 <- 10 numero2 <- 3.14 numero1 numero2 ``` - Inteiros: para armazenar números inteiros, como 1L, 2L, etc. ::: {.callout-note} Mesmo com o tipo Numérico, é possível armazenar números inteiros usando o sufixo "L", por exemplo, 10L, isso é útil para garantir que um número seja tratado como inteiro em operações específicas. ::: ```{r} #| code-fold: false inteiro1 <- 10L inteiro2 <- 20L inteiro1 inteiro2 ``` - Complexos: para armazenar números complexos, como 1 + 2i, etc. ```{r} #| code-fold: false complexo1 <- 1 + 2i complexo2 <- 3 - 4i complexo1 complexo2 ``` - Caracteres: para armazenar texto, como "Olá", "Mundo", etc. ```{r} #| code-fold: false texto1 <- "Olá" texto2 <- "Mundo" texto1 texto2 ``` - Lógicos: para armazenar valores booleanos, como TRUE ou FALSE. ```{r} #| code-fold: false logico1 <- TRUE logico2 <- FALSE logico1 logico2 ``` - Função class() e typeof(): A primeira mostra a identidade do objeto, retorna o atributo da classe do objeto, diz como as outras funções devem tratar esse objeto. Já a segunda tem uma natureza interna, revela como o R armazena o objeto na memória do computador, retorna a natureza do dado. ::: {.callout-note} No [R] é comum encontrarmos funções que parecem fazer a mesma coisa, mas extraem informações diferentes dos dados, as duas principais para investigação de objetos. ::: ```{r} nome <- "Giovana" idade <- 25 # Verificando o nome typeof(nome) class(nome) dados <- data.frame(nome, idade) # Aqui aparece a diferença typeof(dados) class(dados) ``` ::: {.callout-note} Acredito que é importante de mencionar já que funções falham por esperar um objeto, e isso é bom para ter uma ideia de qual é o problema, mas não vamos nos aprofundar muito nisso por serem conceitos mais complexos ::: #### Tipos de dados estruturados: {#subsec-tipos-dados-estruturados} - Vetores: para armazenar uma sequência de elementos do mesmo tipo(homogêneos). Como os vetores são homogêneos, todos os elementos dentro deles precisam ser do mesmo tipo, se tentar misturar dados diferentes ocorre a coerção automática, que segue uma hierarquia, para evitar a perda de informações transforma o tipo mais simples no mais flexível (Logical se torna Integer; Integer se torna Double; Double se torna Character) ::: {.callout-note} Nos vetores muitos usam a função c() sem saber que é uma abreviação de combine, essa função serve para agrupar elementos individuais em uma estrutura de dados unidimensional. ::: ```{r} #| code-fold: false vetor_numerico <- c(1, 2, 3, 4, 5) vetor_texto <- c("A", "B", "C", "D", "E") vetor_numerico vetor_texto ``` - Listas: para armazenar uma coleção de elementos de diferentes tipos(heterogêneos). Assim, uma lista pode armazenar números, textos, valores, vetores e outras listas (e por esse último, são chamados de recursivos) ```{r} #| code-fold: false lista1 <- list(a = 1, b = 2, c = 3) lista2 <- list(d = "A", e = "B", f = "C") lista1 lista2 ``` - Matrizes: para armazenar dados homogêneos em uma estrutura bidimensional. ```{r} #| code-fold: false matriz1 <- matrix(1:6, nrow = 2, ncol = 3) matriz2 <- matrix(c("A", "B", "C", "D", "E", "F"), nrow = 2, ncol = 3) matriz1 matriz2 ``` - Data Frames: são a base para a maioria das análises estatísticas e armazenam dados heterogêneos em uma estrutura bidimensional (cada coluna pode ter um tipo de dado diferente, contando que todas as colunas tenham o mesmo comprimento). ```{r} #| code-fold: false dataframe1 <- data.frame(col1 = c(1, 2, 3), col2 = c("A", "B", "C")) dataframe1 ``` - Arrays: para armazenar dados homogêneos em uma estrutura multidimensional. ```{r} #| code-fold: false array1 <- array(1:8, dim = c(2, 2, 2)) array1 ``` - Fatores: para armazenar dados categóricos. ```{r} #| code-fold: false fator1 <- factor(c("A", "B", "C", "A", "B")) fator1 ``` ### Operadores básicos: {#sec-operadores} Como toda linguagem de programação, [R] possui operadores básicos para realizar operações matemáticas, lógicas e de comparação. Esses operadores são essenciais para a construção de códigos em [R] e permitem manipular dados de forma eficiente. #### Operadores de Atribuição: `<-` ou `=` {#subsec-operadores-atribuicao} Atribuição é o processo de armazenar um valor em uma variável. Em [R], a atribuição pode ser feita usando o operador `<-` ou `=`, a diferença dos operadores está no escopo, `<-` é o operador de atribuição tradicional em [R] e é recomendado para a maioria dos casos, enquanto `=` é mais comumente usado em argumentos de funções. Por exemplo: ```{r} #| code-fold: false #| code-line-numbers: true # Usando <- para atribuição var1 <- 10 # Usando = para atribuição var2 = 20 # Uso de = em argumentos de função var3 <- mean(x = c(1, 2, 3, 4, 5)) ``` ::: {.callout-note} O <- pode ser usado em qualquer lugar do código, enquanto o = é restrito geralmente para a definição de argumentos dentro de funções. ::: #### Operadores aritméticos: `+`, `-`, `*`, `/`, `^ ou **`, `%%` {#subsec-operadores-aritmeticos} Esses operadores são usados para realizar operações matemáticas básicas, como adição, subtração, multiplicação, divisão, exponenciação e resto de divisão. Por exemplo: ```{r} #| code-fold: false #| code-line-numbers: true a <- 5 b <- 3 soma <- a + b # Adição diferenca <- a - b # Subtração produto <- a * b # Multiplicação quociente <- a / b # Divisão potencia <- a ^ b # Exponenciação resto_div <- a %% b #Resto de divisão ``` #### Operadores de comparação: `==`, `!=`, `<`, `>`, `<=`, `>=` {#subsec-operadores-comparacao} Esses operadores são usados para comparar valores e retornar um resultado lógico (TRUE ou FALSE). Por exemplo: ```{r} #| code-fold: false #| code-line-numbers: true x <- 10 y <- 20 comparacao1 <- x == y # Igual a comparacao2 <- x != y # Diferente de comparacao3 <- x < y # Menor que comparacao4 <- x > y # Maior que comparacao5 <- x <= y # Menor ou igual a comparacao6 <- x >= y # Maior ou igual a ``` #### Operadores lógicos: `&`, `|`, `!` {#subsec-operadores-logicos} Esses operadores são usados para combinar condições lógicas. O operador `&` representa a conjunção (AND/E), o operador `|` representa a disjunção (OR/Ou) e o operador `!` representa a negação (NOT/Não). Por exemplo: ```{r} #| code-fold: false #| code-line-numbers: true a <- TRUE b <- FALSE resultado1 <- a & b # AND E resultado2 <- a | b # OR Ou resultado3 <- !a # NOT Não ``` #### Operadores de indexação: `[ ]`, `[[ ]]`, `$` {#subsec-operadores-indexacao} Esses operadores são usados para acessar elementos específicos de vetores, listas ou data frames. O operador `[ ]` é usado para acessar elementos por posição, o operador `[[ ]]` é usado para acessar elementos por nome e o operador `$` é usado para acessar colunas em data frames. Por exemplo: ```{r} #| code-fold: false #| code-line-numbers: true vetor <- c(10, 20, 30, 40, 50) lista <- list(a = 1, b = 2, c = 3) dataframe <- data.frame(col1 = c(1, 2, 3), col2 = c("A", "B", "C")) elemento_vetor <- vetor[2] # Acessa o segundo elemento do vetor elemento_lista <- lista[["b"]] # Acessa o elemento "b" da lista coluna_dataf <- dataframe$col1 # Acessa a coluna "col1" do data frame ``` ::: {.callout-note} Veja a seção [tipos de dados](#sec-tipos-dados) para melhor entendimento do código acima. ::: ### Funções básicas: {#sec-funcoes} Funções são blocos de código que realizam uma tarefa específica e podem ser reutilizados em diferentes partes do código. Em [R], existem muitas funções pré-definidas para realizar operações comuns, como calcular a média, a variância, o desvio padrão, entre outras. #### Funções Matemáticas Básicas: {#subsec-funcoes-matematicas} - Soma: `sum()`, calcula a soma de um conjunto de números. ```{r} #| code-fold: false sum(x = c(1, 2, 3, 4, 5)) ``` - Valor Absoluto: `abs()`, calcula o valor absoluto de um número. ```{r} #| code-fold: false abs(x = -10) ``` - Raiz Quadrada: `sqrt()`, calcula a raiz quadrada de um número. ```{r} #| code-fold: false sqrt(x = 16) ``` - Logaritmo: `log()`, calcula o logaritmo de um número. ```{r} #| code-fold: false log(x = 100, base = 10) # Calcula o logaritmo de 100 na base 10 ``` - Arredondamento: `round()`, arredonda um número para um número específico de casas decimais. ```{r} #| code-fold: false round(x = 3.14159, digits = 2) # Arredonda para 2 casas decimais ``` - Exponencial: `exp()`, calcula o valor exponencial de um número. ```{r} #| code-fold: false exp(x = 1) # Calcula e elevado a 1 ``` #### Funções Estatísticas Básicas: {#subsec-funcoes-estatisticas} - Média: `mean()`, calcula a média aritmética de um conjunto de números. ```{r} #| code-fold: false mean(x = c(1, 2, 3, 4, 5)) ``` - Variância: `var()`, calcula a variância de um conjunto de números. ```{r} #| code-fold: false var(x = c(1, 2, 3, 4, 5)) ``` - Desvio Padrão: `sd()`, calcula o desvio padrão de um conjunto de números. ```{r} #| code-fold: false sd(x = c(1, 2, 3, 4, 5)) ``` - Mediana: `median()`, calcula a mediana de um conjunto de números. ```{r} #| code-fold: false median(x = c(1, 2, 3, 4, 5)) ``` - Máximo e Mínimo: `max()` e `min()`, calculam o valor máximo e mínimo de um conjunto de números, respectivamente. ```{r} #| code-fold: false max(x = c(1, 2, 3, 4, 5)) min(x = c(1, 2, 3, 4, 5)) ``` #### Funções de Manipulação de Dados: {#subsec-funcoes-manipulacao-dados} - Tamanho: `length()`, calcula o número de elementos em um vetor ou lista. ```{r} #| code-fold: false length(x = c(1, 2, 3, 4, 5)) ``` - Nomes: `names()`, retorna os nomes dos elementos em uma lista ou data frame. ```{r} #| code-fold: false names(x = list(a = 1, b = 2, c = 3)) ``` - Dimensão: `dim()`, calcula as dimensões de uma matriz ou data frame. ```{r} #| code-fold: false dim(x = matrix(1:6, nrow = 2, ncol = 3)) ``` - Número de Linhas e Colunas: `nrow()` e `ncol()`, calculam o número de linhas e colunas em uma matriz ou data frame, respectivamente. ```{r} #| code-fold: false nrow(x = matrix(1:6, nrow = 2, ncol = 3)) ncol(x = matrix(1:6, nrow = 2, ncol = 3)) ``` - Classe: `class()`, retorna a classe de um objeto em [R]. ```{r} #| code-fold: false class(x = c(1, 2, 3, 4, 5)) ``` ## Pacotes {#sec-pacotes} O Uso de pacotes em [R] é fundamental para expandir as funcionalidades da linguagem e facilitar a realização de tarefas específicas. Pacotes são coleções de funções, dados e documentação que podem ser facilmente instalados e carregados em [R]. Existem milhares de pacotes disponíveis para diversas áreas, como estatística, ciência de dados, visualização, entre outras. Importante mencionar que, pacotes são criados por membros da comunidade e podem ser encontrados no repositório oficial do [CRAN] ou em outros repositórios, como o [GitHub]. ### Instalação e Carregamento de Pacotes Para instalar e carregar um pacote em [R], basta usar a função `install.packages()` e `library()`, passando o nome do pacote como argumento. Por exemplo, o pacote `ggplot2`, que é amplamente utilizado para visualização de dados, basta executar: ```{r} #| code-fold: false #| eval: false install.packages("ggplot2") #Instala o pacote ggplot2 library(ggplot2) #Carrega o pacote ggplot2 para uso ``` ### Pacotes populares em [R] Alguns pacotes possuem uma grande popularidade e são amplamente utilizados pela comunidade, como: - `ggplot2`: para visualização de dados. - `dplyr`: para manipulação de dados. - `tidyr`: para organização de dados. - `readr`: para leitura de arquivos. - `stringr`: para manipulação de strings. - `lubridate`: para manipulação de datas. - `caret`: para machine learning. - `tidyverse`: para um conjunto de pacotes importantes  ### Pacote `leem` {#sec-pacote-leem} Na disciplina de Estatística e Probabilidade, o pacote `leem` é uma ferramenta útil para realizar análises estatísticas e manipulação de dados. Ele oferece uma variedade de funções para calcular medidas de tendência central, variabilidade, gráficos, entre outras funcionalidades. O pacote `leem` é mantido pelo professor [Ben Dêivide](https://bendeivide.github.io) e pode ser instalado e carregado da seguinte forma: ```{r} #| code-fold: false #| eval: false install.packages("leem") #Instala o pacote leem library(leem) #Carrega o pacote leem para uso ``` #### Funções do pacote `leem` Alguns exemplos de funções que serão utilizadas durante a disciplina são: - `new_leem()`: para criar um objeto do tipo `leem`. ```{r} #| code-fold: false library(leem) dados <- c(1, 2, 3, 4, 5) leem_obj <- new_leem(x = dados, variable = 2) leem_obj ``` - `tabfreq()`: para criar uma tabela de frequências. ```{r} #| code-fold: false tabf <- tabfreq(leem_obj) tabf ``` - `barplot()`: para criar um gráfico de barras a partir de uma tabela de frequências. ```{r} #| code-fold: false barplot(tabf, main = "Frequência dos dados", xlab = "Valores", ylab = "Frequência", barcol = "steelblue") ``` ::: {.callout-note} Para descobrir mais funções do pacote `leem` e suas aplicações, consulte a [documentação oficial](https://bendeivide.github.io/leem/). ::: ## Considerações finais O R é uma ótima ferramenta para analisar dados estatísticos, de primeiro pode demorar para ser aprendida devido a sintaxe, mas depois ela recompensa com a velocidade e eficiência para resolver problemas complexos e inclusive se integrar com outras linguagens ### COMENTÁRIOS Agora acho interessante responder algumas perguntas 1) Porque usar R? 2) Quais outros locais posso programar em R, fora o RStudio? 3) Como aprendi a interpretar as mensagens de erro do R? 4) Quais comunidades/sites ajudam nesse processo de aprendizado? 5) Como garantir que minha análise seja reprodutível para outros? 6) Como o uso de projetos (.Rproj) ajudam na organização das pastas e arquivos? Respondendo as questões acima 1) O R foi desenvolvido por e para estatísticos e cientistas de dados, diferente de ferramentas de planilhas, ele permite manipular vários dados com uma grande precisão e garantir que qualquer análise possa ser repetida exatamente da mesma forma, fora que tem pacotes que podem ser instalados que cobrem quase todos os métodos estatísticos existentes, se não todos. 2) Mesmo o RStudio sendo o padrão para programar em R, você pode usar o VS Code, o Jupyter Notebook (diretamente no terminal do sistema operacional) ou mesmo em plataformas na nuvem, como Posit Cloud e Google Colab. 3) Interpretar erros em R é um processo de tradução, geralmente na mensagem de erro é indicado onde no código está o erro e porque está errado, logo acredito que no início, e mesmo depois, o segredo é copiar o código e jogar no ChatGPT e pergutar como arrumar e entender a causa da raiz. 4) As fontes de apoio que acho interessantes são: - Site do Ben Deivide; - Vídeos no youtube; 5) A reprodutibilidade garantida vem por meio de: - Scripts bem comentados (explicando o que e porque foi feito); - R Markdown ou Quarto (unem o código, resultados e texto em um documento final, PDF ou HTML); - Controle de versões (pode ser feito através do GitHub, site muito usado junto ao R que rastreia mudanças no código; local onde inclusive pode ser achado mais projetos semelhantes ao seu); 6) O .Rproj é fundamental, já que ele quem define o seu diretório de trabalho, ao abrir um projeto, o R já sabe onde estão os dados e onde deve salvar os gráficos. Ele isola o seu ambiente de trabalho, permitindo que você altere entre diferentes análises sem que esses dados interfiram um no outro. ## Referências

1 Introdução

2 Objetivo

2.1 Objetivos específicos

3 Instalação do R e do RStudio

4 Interface do R

4.1 Console

4.2 R Studio

5 Sintaxe

5.1 Estruturas de dados:

5.1.1 Tipos básicos:

5.1.2 Tipos de dados estruturados:

5.2 Operadores básicos:

5.2.1 Operadores de Atribuição: <- ou =

5.2.2 Operadores aritméticos: +, -, *, /, ^ ou **, %%

5.2.3 Operadores de comparação: ==, !=, <, >, <=, >=

5.2.4 Operadores lógicos: &, |, !

5.2.5 Operadores de indexação: [ ], [[ ]], $

5.3 Funções básicas:

5.3.1 Funções Matemáticas Básicas:

5.3.2 Funções Estatísticas Básicas:

5.3.3 Funções de Manipulação de Dados:

6 Pacotes

6.1 Instalação e Carregamento de Pacotes

6.2 Pacotes populares em R

6.3 Pacote leem

6.3.1 Funções do pacote leem

7 Considerações finais

7.1 COMENTÁRIOS

8 Referências

5.2.1 Operadores de Atribuição: `<-` ou `=`

5.2.2 Operadores aritméticos: `+`, `-`, `*`, `/`, `^ ou **`, `%%`

5.2.3 Operadores de comparação: `==`, `!=`, `<`, `>`, `<=`, `>=`

5.2.4 Operadores lógicos: `&`, `|`, `!`

5.2.5 Operadores de indexação: `[ ]`, `[[ ]]`, `$`

6.3 Pacote `leem`

6.3.1 Funções do pacote `leem`