GUIA DO MOCHILEIRO DO UNIVERSO R

Nosso primeiro script

A janela de edição de código você irá utilizar para escrever o seu código, lembra?

Abra um novo script clicando no + no canto superior esquerdo e selecionando, por enquanto, R script.

Vamos então iniciar os trabalhos com o tradicional Hello World. Digite no seu script:

print("Hello world")

Após, selecione a linha e aperte o botão Run ou utilize Ctrl + enter.

LEMBRE-SE: Tudo na linha a partir do símbolo # na frente não será executado. Agora, experimente colocar # na frente do código escrito. E, novamente, selecione a linha e aperte Run.

# print("Hello world")

O símbolo # é utilizado para realizar comentários ao decorrer do código. Esta é uma ótima prática para deixar o código organizado e para que você possa lembrar mais tarde o que você estava pensando quando o escreveu ou para que outras pessoas possam entendê-lo. Como no exemplo:

# Agora uso isso para comentários
cat("Hello world") #cat tem função semelhante ao print mas só é válido para tipos atômicos e nomes
# Você consegue concatenar e imprimir
cat("Hello World", "with R")
# Isso é mais fácil do que utilizar uma outra função em print para fazer o mesmo
print(paste("Hello World", "with R"))

####################################################
## ESSE É UM EXEMPLO DE CABEÇALHO PARA SEU SCRIPT ##
####################################################

Se tiver dúvidas sobre uma função, pode utilizar:

?cat

#OU

help(cat)

Isso fará abrir uma aba chamada Help no canto inferior direito, claro que estará em inglês (a língua oficial da ciência). Mas isso não será um problema pra você ;)

Importante: sempre que quiser realizar alguma alteração, edite o seu script,evite fazer isso diretamente no console, pois tudo o que neste é escrito, não terá como ser salvo! Faça isso no seu arquivo .Rou .Rmd (se for RMarkdown).

Para salvar seu script, você pode utilizar a aba File localizada (como padrão) no canto direito inferior para procurar uma pasta de sua preferência. Vamos criar uma nova pasta com o nome CursoR.

SUPER DICA DO TIO CHICO!!!:

Evite colocar espaços e pontuações no nome das pastas e arquivos, isso pode dificultar o acesso via linha de comando no R. Por exemplo, ao invés de Curso R, optamos por CursoR ou Curso_R.

Depois, basta clicar no disquete localizado no cabeçalho do RStudio ou com Ctrl + s e selecionar o diretório CursoR criado. Scripts em R são salvos com a extensão .R. Os RMarkdown são salvos com a extensão .Rmd

Diretório de trabalho

Um bom negócio no R é deixar o script no mesmo diretório onde estão seus dados (arquivos de entrada no script), assim como salvar os dados processados (gráficos, tabelas, etc).Para isso, vamos fazer com que o R identifique o mesmo diretório em que você salvou o script como diretório de trabalho, assim ele entenderá que é dali que precisa obter os dados e para lá que também irão os resultados.

Vamos fazer isso utilizando as facilidades do RStudio, basta localizar o diretório CursoR pela aba Files (canto inferior direito), clicar em More e depois “Set as Working Directory”. Repare que irá aparecer no console algo como:

# Coloque aonde você quiser!!! Sugestão:
setwd("~/Documents/CursoR")

Ou seja, você pode utilizar este mesmo comando para realizar esta ação. Uma vez escolhido, será sua pasta de trabalho. Quando estiver perdido/a ou para ter certeza que o diretório de trabalho foi alterado utilize:

getwd()

Facilitando a vida com Tab

Agora, imagine que você tem um diretório como ~/Documentos/posgraduacao/semestre1/disciplina_tal/aula_tal/dados_tal/analise_seila/resultados_bons/. Não é fácil lembrar todo este caminho para escrever num comando setwd().

Além da facilidade da janela do RStudio, você pode utilizar a tecla Tab para completar o caminho para você. Experimente buscando alguma pasta no seu computador. Basta começar a digitar o caminho e apertar Tab, ele irá completar o nome para você! Se você tiver mais do que um arquivo com aquele início de nome, aperte duas vezes o Tab, ele mostrará todas as opções.

Vamos tentar?

O Tab funciona não só para indicar caminhos, mas também para comandos e nomes de objetos. É muito comum errarmos no código por erros de digitação. Utilizar o Tab reduzirá significativamente esses erros.

PARTIU!!!!

O R pode funcionar como uma simples calculadora, que utiliza a mesma sintaxe que outros programas (como o excel):

1.3                   #Decimal definido com ".", dá para trocar pra "," mas não é recomendado
1+3
1-3
2*3                   #Multiplicação
2^3                   #Potenciação
4/2                   #Divisão
sqrt(4)               #raíz quadrada
log(100, base = 10)   #logarítmo na base 10
log(100)              #logarítmo com base neperiana

Agora, utilize as operações básicas para solucionar expressão abaixo. Lembre-se de utilizar parênteses () para estabelecer prioridades nas operações.

\((\frac{13+2+1.5}{3})+ log_{4}96\)

Resultado esperado:

## [1] 8.792481

((13+2+1.5)/3) + log(96, base = 4)

Repare que, se posicionar o parênteses de forma incorreta, o código não resultará em nenhuma mensagem de erro, pois este é um erro que chamamos de erro lógico, ou seja, o código roda, mas não faz o que você gostaria que ele fizesse. Esse é o tipo de erro mais difícil de ser consertado. Os erros que produzem uma mensagem, seja um aviso (warning) ou um erro (error) são chamados de erros de sintaxe. Nesses casos, o R retornará uma mensagem para te ajudar a corrigí-los. Os warnings não comprometem o funcionamento do código, mas chamam a atenção para algum ponto, já os errors precisam necessariamente ser corrigidos para que o código rode.

Exemplo de error:

((13+2+1,5)/3) + log(96, base = 4)

Você pode também esquecer de fechar algum parênteses, ou aspas, ou colchetes, ou chaves, nesses casos, o R ficará aguardando o comando para fechar o bloco de código sinalizando com um +:

((13+2+1.5)/3 + log(96, base = 4)

Se acontecer, vá até o console e aperte ESC, que o bloco será finalizado para que você possa corrigí-lo.

Os comandos log e sqrt são duas de muitas outras funções básicas que o R possui. Funções são conjuntos de instruções organizadas para realizar uma tarefa.

LEMBRA-SE: Para todas as funções há um documento com uma descrição para auxiliar no seu uso, para acessar essa ajuda use:

?log

E será aberta a descrição da função na janela Help do RStudio.

Se a descrição do próprio R não for suficiente para você entender como funciona a função, busque no google (de preferência em inglês). Existem diversos sites e fóruns com informações didáticas das funções do R.

Vamos visitar um deles agora!!

Operações com vetores

Os vetores são as estruturas mais simples trabalhadas no R. Construímos um vetor com uma sequencia numérica usando:

c(1,3,2,5,2)

## [1] 1 3 2 5 2

MUITA ATENÇÃO: O c é a função do R (Combine Values into a Vector or List), é assim que construímos um vetor!

Utilizamos o simbolo : para criar sequências de números inteiros, como:

1:10

##  [1]  1  2  3  4  5  6  7  8  9 10

Podemos utilizar outras funções para gerar sequências, como:

seq(from=0, to=100, by=5)

##  [1]   0   5  10  15  20  25  30  35  40  45  50  55  60  65  70  75  80  85  90
## [20]  95 100

# ou
seq(0,100,5) # Se você já souber a ordem dos argumentos da função

##  [1]   0   5  10  15  20  25  30  35  40  45  50  55  60  65  70  75  80  85  90
## [20]  95 100

• Crie uma sequencia utilizando a função seq que varie de 4 a 30, com intervalos de 3 em 3.

## [1]  4  7 10 13 16 19 22 25 28

A função rep gera sequências com números repetidos:

rep(3:5, 2) #argumento 1:sequencia, argumento 2: vezes a ser repetido

## [1] 3 4 5 3 4 5

Podemos realizar operações utilizando esses vetores:

c(1,4,3,2)*2
c(4,2,1,5)+c(5,2,6,1)
c(4,2,1,5)*c(5,2,6,1)

Repare que já esta ficando cansativo digitar os mesmos números repetidamente, vamos resolver isso criando objetos para armazenar nossos vetores e muito mais.

CUIDADO: A linguagem é sensível à letras maiúsculas e minúsculas, portanto x é diferente de X:

#Se você é teimoso, pode tentar!
X

O objeto X não foi criado.

O nome dos objetos é uma escolha pessoal, a sugestão é tentar manter um padrão para melhor organização. Alguns nomes não podem ser usados por estabelecerem papéis fixos no R, são eles:

• NA - Not available, simboliza dados faltantes
• NaN - Not a number, simboliza indefinições matemáticas
• Inf - Infinite, conceito matemático
• NULL - Null object, simboliza ausência de informação

Podemos então realizar as operações com o objeto criado:

Para realizar a operação o R alinha os dois vetores e realiza a operação elemento à elemento. Observe:

x + y

## [1] 30.36 30.70 40.36 30.44 30.87 40.45

x*y

## [1]  7.826  9.120 14.400  7.248  8.262 14.035

x - x

## [1] 0 0 0 0 0 0

Se os vetores tiverem tamanhos diferentes, ele irá repetir o menor para realizar a operação elemento à elemento com todos do maior.

x*2
x*c(1,2)

Se caso o menor vetor não for múltiplo do maior, obteremos um aviso:

x

## [1] 30.1 30.4 40.0 30.2 30.6 40.1

x*c(1,2,3,4)

## Warning in x * c(1, 2, 3, 4): comprimento do objeto maior não é múltiplo do
## comprimento do objeto menor

## [1]  30.1  60.8 120.0 120.8  30.6  80.2

Repare que o warning não compromente o funcionamento do código, ele só dá uma dica de que algo pode não estar da forma como você gostaria.

Podemos também armazenar a operação em outro objeto:

z <- (x+y)/2
z

Podemos também aplicar algumas funções, como exemplo:

sum(z)  # soma dos valores de z

## [1] 101.59

mean(z) # média 

## [1] 16.93167

var(z)  # variância

## [1] 6.427507

Indexação

Acessamos somente o 3º valor do vetor criado com []:

z[3]

Também podemos acessar o número da posição 2 a 4 com:

z[2:4]

## [1] 15.35 20.18 15.22

Para obter informações do vetor criado utilize:

str(z)

##  num [1:6] 15.2 15.3 20.2 15.2 15.4 ...

A função str nos diz sobre a estrutura do vetor, que se trata de um vetor numérico com 6 elementos.

Os vetores também podem receber outras categorias como caracteres:

clone <- c("GRA02", "URO01", "URO03", "GRA02", "GRA01", "URO01")

Outra classe são os fatores, esses podem ser um pouco complexos de lidar.

De forma geral, fatores são valores categorizados por levels, como exemplo, se transformarmos nosso vetor de caracteres clone em fator, serão atribuidos níveis para cada uma das palavras:

clone_fator <- as.factor(clone)
str(clone_fator)

##  Factor w/ 4 levels "GRA01","GRA02",..: 2 3 4 2 1 3

levels(clone_fator)

## [1] "GRA01" "GRA02" "URO01" "URO03"

Dessa forma, teremos apenas 4 níveis para um vetor com 6 elementos, já que as palavras “GRA02” e “URO01” se repetem. Podemos obter o número de elementos do vetor ou o seu comprimento com:

length(clone_fator)

## [1] 6

Também há vetores lógicos, que recebem valores de verdadeiro ou falso:

logico <- x > 40
logico   # Os elementos são maiores que 40?

## [1] FALSE FALSE FALSE FALSE FALSE  TRUE

Com ele podemos, por exemplo, identificar quais são as posições dos elementos maiores que 40:

which(logico)  # Obtendo as posiçoes dos elementos TRUE

## [1] 6

x[which(logico)] # Obtendo os números maiores que 40 do vetor x pela posição

## [1] 40.1

# ou
x[which(x > 40)]

## [1] 40.1

Também podemos localizar elementos específicos com:

clone %in% c("URO03", "GRA02")

## [1]  TRUE FALSE  TRUE  TRUE FALSE FALSE

Também podem ser úteis as funções any e all. Procure sobre elas.

Encontre mais sobre outros operadores lógicos, como o > utilizado, neste link.

**Warning1**

Faça uma sequência numérica, contendo 10 valores inteiros, e salve em um objeto chamado “a”.

(a <- 1:10)

##  [1]  1  2  3  4  5  6  7  8  9 10

Crie outra sequência, utilizando números decimais e qualquer operação matemática, de tal forma que seus valores sejam idênticos ao objeto “a”.

b <- seq(from = 0.1, to = 1, 0.1)
(b <- b*10)

##  [1]  1  2  3  4  5  6  7  8  9 10

Os dois vetores parecem iguais, não?

Então, utilizando um operador lógico, vamos verificar o objeto “b” é igual ao objeto “a”.

a==b

##  [1]  TRUE  TRUE FALSE  TRUE  TRUE  TRUE FALSE  TRUE  TRUE  TRUE

Alguns valores não são iguais. Como isso é possivel?

a==round(b)

##  [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

**Warning2**

Não é possível misturar diferentes classes dentro de um mesmo vetor, ao tentar fazer isso repare que o R irá tentar igualar para uma única classe:

errado <- c(TRUE, "vish", 1)
errado

## [1] "TRUE" "vish" "1"

No caso, todos os elementos foram transformados em caracter.