Noções básicas de programação em R

Operações básicas

Aritmética

As operações aritméticas básicas na linguagem R são:
Adição (+)
Subtração (-)
Multiplicação (*)
Divisão (/)
Exponenciação (^) Aqui estão alguns exemplos de scripts que demonstram essas operações:

# Adição
a <- 5
b <- 10
c <- a + b
print(c) 
## [1] 15
# Subtração
a <- 5
b <- 10
c <- b - a
print(c) 
## [1] 5
# multiplicação
a <- 3
b <- 4
c <- a * b
print(c) 
## [1] 12
# Divisão
a <- 5
b <- 10
c <- b / a
print(c) 
## [1] 2
# potenciação
a <- 2
b <- 3
c <- a^b
print(c) 
## [1] 8
# Raiz Quadrada
a <- 16
b <- sqrt(a)
print(b) 
## [1] 4
# Logaritmo
a <- 10
b <- log10(a)
print(b) 
## [1] 1

Comparação

As operações de comparação básicas na linguagem R são:
Maior que (>)
Menor que (<)
Igualdade (==)
Desigualdade (!=)
Maior ou igual a (>=)
Menor ou igual a (<=)
Aqui estão alguns exemplos de scripts que demonstram essas operações:

# Maior que
a <- 10
b <- 5
resultado <- a > b
print(resultado) 
## [1] TRUE
# Menor que
a <- 10
b <- 5
resultado <- a < b
print(resultado) 
## [1] FALSE
# Igualdade (==)
a <- 10
b <- 10
resultado <- a == b
print(resultado) 
## [1] TRUE
#Desigualdade (!=)
a <- 5
b <- 10
c <- a != b
print(c) 
## [1] TRUE
#Maior ou igual a (>=)
a <- 5
b <- 10
c <- b >= a
print(c) 
## [1] TRUE
#Menor ou igual a (<=)
a <- 5
b <- 10
c <- a <= b
print(c) 
## [1] TRUE

Tipos de dados

Existem vários tipos de dados em R, alguns dos principais são:

Numeric

O tipo de dados “numeric” em R é usado para representar números com decimais. É o tipo de dados padrão em R para números reais. Um número pode ser atribuído a uma variável simplesmente digitando o valor.

x <- 3.14
y <- 2.71828
z <- x + y
print(z)
## [1] 5.85828

Neste exemplo, as variáveis “x” e “y” são atribuídas a valores numéricos diretamente. O operador “+” é usado para somar esses números e armazenar o resultado na variável “z”. Em seguida, as variáveis são impressas na tela usando a função “print()”.

Integer

O tipo de dados “integer” em R é usado para representar números inteiros. Diferentemente do tipo “numeric”, que pode representar números com decimais, o tipo “integer” é limitado a números inteiros.

# Integer
a <- 5
b <- 10
c <- a + b
print(c)
## [1] 15

Neste exemplo, as variáveis “a” e “b” são declaradas como números inteiros. O operador “+” é usado para somar esses números e armazenar o resultado na variável “c”. Em seguida, as variáveis são impressas na tela usando a função “print()”.

É importante lembrar que, em R, as operações matemáticas com números inteiros são truncadas, ou seja, o resultado de uma operação com inteiros pode ser truncado para um número inteiro, mesmo que o resultado matemático não seja um inteiro. Por exemplo, se você dividir 5 por 2, o resultado será truncado para 2 em vez de 2.5. Se você deseja manter a precisão decimal em uma operação, é necessário usar o tipo “numeric” em vez do tipo “integer”.

Logical

O tipo de dados “logical” em R é usado para representar valores booleanos, ou seja, verdadeiro ou falso. Este tipo de dados é muito importante em programação, pois permite que sejam tomadas decisões com base em uma condição, usando operadores lógicos, como & (e lógico), | (ou lógico) e ! (negação lógica).

Uma variável lógica pode ser criada atribuindo-se um valor TRUE ou FALSE diretamente a ela, ou usando operadores de comparação, como <, >, <=, >=, == (igual a) e != (diferente de).

# Criando variáveis lógicas diretamente
a <- TRUE
b <- FALSE

# Criando variáveis lógicas com operadores de comparação
x <- 5
y <- 7
z <- x < y
print(z)
## [1] TRUE

Além disso, o tipo “logical” pode ser usado em condições if/else, onde o bloco de código dentro da condição if é executado apenas se a condição for verdadeira (TRUE). Caso contrário, o bloco de código dentro da condição else é executado.

x <- 5
y <- 10

maior_que_7 <- (x + y) > 7

if (maior_que_7) {
  print("A soma de x e y é maior do que 7!")
} else {
  print("A soma de x e y é menor ou igual a 7.")
}
## [1] "A soma de x e y é maior do que 7!"

Neste exemplo, as variáveis “x” e “y” são inicializadas com os valores 5 e 10, respectivamente. Em seguida, uma variável lógica “maior_que_7” é definida como a expressão (x + y) > 7, que verifica se a soma de “x” e “y” é maior do que 7. Em seguida, uma estrutura condicional if/else é usada para imprimir uma mensagem diferente, dependendo do valor da variável “maior_que_7”. Se essa variável for verdadeira, a mensagem “A soma de x e y é maior do que 7!” será impressa. Caso contrário, a mensagem “A soma de x e y é menor ou igual a 7.” será impressa.

Character

O tipo de dados character é usado para representar cadeias de caracteres (ou strings) em R. Uma cadeia de caracteres é uma sequência de caracteres alfanuméricos, incluindo letras, números, símbolos e espaços. Em R, as cadeias de caracteres são colocadas entre aspas duplas ou simples.

# Criando variáveis do tipo character
nome <- "João"
sobrenome <- 'Silva'

# Concatenando strings
nome_completo <- paste(nome, sobrenome)
print(nome_completo)
## [1] "João Silva"

Neste exemplo, a variável nome é definida como uma string com o valor “João”, e a variável sobrenome é definida como uma string com o valor “Silva”. Em seguida, as duas strings são concatenadas usando a função paste(), e o resultado é armazenado na variável nome_completo.

Date

O tipo de dados date em R é usado para representar datas. Ele é implementado como um número inteiro que representa o número de dias desde a data base de R, que é 1 de janeiro de 1970. Os objetos date em R são representados como uma sequência de caracteres no formato “aaaa-mm-dd”, onde “aaaa” representa o ano com quatro dígitos, “mm” representa o mês com dois dígitos e “dd” representa o dia com dois dígitos.

Você pode criar um objeto date em R usando a função as.Date(), passando uma sequência de caracteres no formato “aaaa-mm-dd”.

# Criando um objeto date
x <- as.Date("2023-03-25")
print(x)
## [1] "2023-03-25"

Neste exemplo, a função as.Date() é usada para criar um objeto date chamado x. O objeto representa a data 25 de março de 2023. Quando o objeto é impresso na tela, ele é exibido no formato “aaaa-mm-dd”.

Os objetos date em R podem ser manipulados como qualquer outro objeto em R. Por exemplo, você pode adicionar ou subtrair dias de um objeto date, comparar duas datas ou extrair informações específicas de uma data. Veja alguns exemplos:

# Adicionando dias a um objeto date
x <- as.Date("2022-03-25")
y <- x + 7
print(y)
## [1] "2022-04-01"
# Comparando duas datas
x <- as.Date("2022-03-25")
y <- as.Date("2022-03-26")
print(x < y)
## [1] TRUE

Nestes exemplos, a adição de dias é feita usando a operação +, comparando duas datas é feito usando os operadores de comparação padrão em R, respectivamente.

Factor

O tipo de dados factor em R é usado para representar variáveis categóricas ou fatores. Ele é usado para armazenar valores discretos, como níveis de categorias ou fatores que podem ser ordenados. Por exemplo, o sexo de uma pessoa pode ser codificado como “Masculino” ou “Feminino”, enquanto a escolaridade pode ser codificada como “Ensino Fundamental”, “Ensino Médio” ou “Ensino Superior”.

Os objetos factor em R são vetores de inteiros que são mapeados para níveis ou categorias. Os níveis são armazenados como uma lista de caracteres em ordem alfabética ou na ordem especificada pelo usuário. Por padrão, R ordena os níveis alfabeticamente, mas você pode definir a ordem dos níveis usando a função levels().

Você pode criar um objeto factor em R usando a função factor().

# Criando um objeto factor
x <- factor(c("Masculino", "Feminino", "Feminino", "Masculino"))
print(x)
## [1] Masculino Feminino  Feminino  Masculino
## Levels: Feminino Masculino

Neste exemplo, a função factor() é usada para criar um objeto factor chamado x. O objeto contém quatro valores categóricos, dois “Masculino” e dois “Feminino”. Quando o objeto é impresso na tela, os valores são exibidos junto com os níveis do fator. Note que os níveis são exibidos em ordem alfabética.

Os objetos factor em R podem ser manipulados como qualquer outro objeto em R. Por exemplo, você pode verificar os níveis de um objeto factor, alterar os níveis, adicionar ou remover níveis, entre outras operações. Veja alguns exemplos:

# Verificando os níveis de um objeto factor
x <- factor(c("Masculino", "Feminino", "Feminino", "Masculino"))
print(levels(x))
## [1] "Feminino"  "Masculino"
# Alterando os níveis de um objeto factor
x <- factor(c("Masculino", "Feminino", "Feminino", "Masculino"), levels = c("Masculino", "Feminino"))
print(x)
## [1] Masculino Feminino  Feminino  Masculino
## Levels: Masculino Feminino
# Adicionando novos níveis a um objeto factor
x <- factor(c("Masculino", "Feminino", "Feminino", "Masculino"), levels = c("Masculino", "Feminino", "Outro"))
print(x)
## [1] Masculino Feminino  Feminino  Masculino
## Levels: Masculino Feminino Outro

Nestes exemplos, a função levels() é usada para verificar os níveis de um objeto factor, a opção levels é usada para alterar ou adicionar níveis a um objeto factor.

Conversão dos tipos de dados

# Criando um vetor numérico
numeric_vector <- c(1.2, 2.7, 3.5, 4.3, 5.0)

# Convertendo o vetor numérico em um vetor de inteiros
integer_vector <- as.integer(numeric_vector)

# Convertendo o vetor numérico em um vetor de fatores
factor_vector <- as.factor(numeric_vector)

# Convertendo o vetor numérico em um vetor de caracteres
character_vector <- as.character(numeric_vector)
# Verificando os tipos de dados dos novos vetores
print(integer_vector)
## [1] 1 2 3 4 5
print(factor_vector)
## [1] 1.2 2.7 3.5 4.3 5  
## Levels: 1.2 2.7 3.5 4.3 5
print(character_vector)
## [1] "1.2" "2.7" "3.5" "4.3" "5"

Estrutura dos dados

Vetores

Um vetor é uma sequência de elementos de um mesmo tipo. Podemos criar um vetor utilizando a função c(): 

vetor1 <- c(1, 2, 3, 4, 5)
vetor1
## [1] 1 2 3 4 5
vetor2 <- c("a", "b", "c", "d", "e")
vetor2
## [1] "a" "b" "c" "d" "e"
vetor3 <- c(TRUE, FALSE, TRUE, TRUE, FALSE)
vetor3
## [1]  TRUE FALSE  TRUE  TRUE FALSE

Podemos acessar elementos do vetor utilizando colchetes:

vetor1[3] # Retorna o terceiro elemento do vetor1
## [1] 3

Matrizes

Uma matriz é uma estrutura de dados bidimensional, ou seja, possui linhas e colunas. Podemos criar uma matriz utilizando a função matrix(): 

matriz1 <- matrix(1:9, nrow=3, ncol=3)
matriz1
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9

Podemos acessar elementos da matriz utilizando colchetes com dois índices:

matriz1[1,2] # Retorna o elemento na primeira linha e segunda coluna
## [1] 4

Dataframe

Um data frame é uma estrutura de dados bidimensional, como uma matriz, mas com colunas de tipos diferentes. Podemos criar um data frame utilizando a função data.frame(): 

dados <- data.frame(Nome=c("João", "Maria", "José"), Idade=c(20, 25, 30), Sexo=c("M", "F", "M"))
dados
##    Nome Idade Sexo
## 1  João    20    M
## 2 Maria    25    F
## 3  José    30    M

Podemos acessar colunas do data frame utilizando o nome da coluna ou o operador $:

dados$Nome # Retorna a coluna "nome"
## [1] "João"  "Maria" "José"
dados[2,] # Retorna a segunda linha do data frame
##    Nome Idade Sexo
## 2 Maria    25    F

Lista

Uma lista é uma estrutura de dados que pode conter elementos de tipos diferentes. Podemos criar uma lista utilizando a função list(): 

lista1 <- list(vetor1, matriz1, dados)
lista1
## [[1]]
## [1] 1 2 3 4 5
## 
## [[2]]
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
## 
## [[3]]
##    Nome Idade Sexo
## 1  João    20    M
## 2 Maria    25    F
## 3  José    30    M

Podemos acessar elementos da lista utilizando colchetes:

lista1[[2]] # Retorna o segundo elemento da lista (a matriz1)
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9

Funções

Em R, podemos criar nossas próprias funções para executar tarefas específicas. Podemos criar uma função utilizando a palavra-chave function: 

minha_funcao <- function(parametro1, parametro2){
resultado <- parametro1 + parametro2
return(resultado)
}

Podemos chamar a função passando os parâmetros necessários:

minha_funcao(2, 3) # Retorna 5
## [1] 5
minha_funcao(4, 7) # Retorna 11
## [1] 11

Essas são apenas algumas noções básicas de programação em R. Com esses conceitos, podemos já fazer muitas análises de dados simples e explorar diversas possibilidades de análise de dados.