- Minicurso de Introdução ao R
- Familiarização com a interface do RStudio
- Operações básicas
- Criando objetos
- Exportando e importando dados
- Estruturas condicionais
- Estruturas de repetição
- Elaboração de gráficos simples
- Planilha com dados reais
- Elaboração de funções
- Algumas ferramentas básicas de análise de dados
- Instalação e aplicações de pacotes
- Pratique gerando relatórios no RStudio
Minicurso de Introdução ao R
Este material foi elaborado para o minicurso do XII Workshop de Férias em Genética e Melhoramento de Plantas pelos alunos de pós-graduação Cristiane Taniguti, Fernando Correr, Lorena Batista e Ana Letycia dos laboratórios de Genética Estatística e Laboratório de Bioinformática aplicada à Bioenergia da ESALQ-USP
Você pode encontrar os materiais de cursos de R já realizados pela mesma equipe neste site. O curso realizado junto com o grupo gvenck teve maior duração que os apresentados nos Workshops, por isso contém um material mais completo, caso queira maiores aprofundamentos no que será aqui tratado, recomendamos que dê uma olhada no material.
Recomendamos também outros materiais disponíveis online, encontre uma lista aqui.
Sugerimos que, antes de iniciar a prática aqui descrita, siga este tutorial para instalação do R e do RStudio.
Familiarização com a interface do RStudio
Abrindo o RStudio você verá:
A interface é separada em quatro janelas com principais funções:
- Edição de código
- Ambiente de trabalho e histórico
- Console
- Arquivos, gráficos, pacotes e ajuda
Explore cada uma das janelas. São inúmeras funcionalidades para cada uma delas, veremos algumas delas ao decorrer do curso.
Um primeiro script
A janela de edição de código (provavelmente a localizada no canto superior esquerdo) você irá utilizar para escrever o seu código. Abra um novo script clicando no +
no canto superior esquerdo e selecionando R script
.
Vamos então iniciar os trabalhos com o tradicional Hello World
. Digite no seu script:
cat("Hello world")
## Hello world
Agora selecione a linha e aperte o botão Run
ou utilize Ctrl + enter
.
Ao fazer isso o seu código será processado na janela Console
, onde aparecerá em azul (se você estiver com as cores padrão do R) o código escrito e logo em seguida o resultado desejado. A linha somente não será processada no console se houver o símbolo #
na frente. Agora, experimente colocar #
na frente do código escrito. E, novamente, selecione a linha e aperte Run
.
# cat("Hello world")
O símbolo #
é muito 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ê mesmo/a estava pensando quando o escreveu ou para que outras pessoas possam entendê-lo. Como no exemplo:
# Iniciando os trabalhos no R
cat("Hello world")
## Hello world
Importante: sempre que quiser realizar alguma alteração, edite o seu script e não diretamente no console, pois tudo o que neste é escrito, não terá como ser salvo!
Para salvar seu script, você pode utilizar a aba Files
localizada (no padrão) no canto esquerdo inferior procurar uma localização de sua preferência, criar uma nova pasta com o nome CursoR
. 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
.
Estabelecendo diretório de trabalho
Outra boa prática no R é deixar o script no mesmo diretório onde estão seus dados brutos (arquivos de entrada no script) e 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 la que também irá soltar resultados.
Você pode fazer isso utilizando as facilidades do RStudio, basta localizar o diretório CursoR
pela aba Files
, clique em More
e depois “Set as Working Directory”. Repare que irá aparecer no console algo como:
setwd("~/Documents/CursoR")
Ou seja, você pode utilizar este mesmo comando para realizar esta ação. Esta então será nossa pasta de trabalho. Quando estiver perdido/a ou se tiver 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/mestrado/semestre1/disciplina_tal/aula_tal/dados_28174/analise_276182/resultados_161/
. 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.
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
fará com que reduza significativamente esses erros.
Operações básicas
Vamos então à linguagem!
O R pode funcionar como uma simples calculadora, que utiliza a mesma sintaxe que outros programas (como o excel):
#########################
# Script Curso R
# Data: 24/07/2018
##########################
1+1.3 #Decimal definido com "."
2*3
2^3
4/2
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
Os comandos log
e sqrt
são duas de muitas outras funções básicas que o R possui. Para todas elas o R possui 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.
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
Utilizamos o simbolo :
para criar sequencias 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 sequencias, 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
## [18] 85 90 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
## [18] 85 90 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 sequencias com números repetidos:
rep(3:5, 2)
## [1] 3 4 5 3 4 5
rep(3:5, each = 2)
## [1] 3 3 4 4 5 5
Podemos realizar operações utilizando esses vetores:
c(1,4,3,2,5,8)*2
c(4,2,1,5,3,2)+c(5,2,6,1,3,5)
c(4,2,1,5,3,2)*c(5,2,6,1,3,5)
Repare que já esta ficando cansativo digitar os mesmos números repetidamente, vamos resolver isso criando objetos para armazenar nossos vetores e muito mais.
Criando objetos
O armazenamento de informações em objetos e a possível manipulação desses faz do R uma linguagem orientada por objetos. Para criar um objeto basta atribuir valores para variáveis como a seguir:
x = c(30.1,30.4,40,30.2,30.6,40.1)
# ou
x <- c(30.1,30.4,40,30.2,30.6,40.1)
y = c(0.26,0.3,0.36,0.24,0.27,0.35)
Os mais antigos costumam usar o sinal <-
, mas tem a mesma função de =
. Escolha usar o qual preferir.
Para acessar os valores dentro do objeto basta:
x
## [1] 30.1 30.4 40.0 30.2 30.6 40.1
A linguagem é sensível à letras maiúsculas e minúsculas, portanto x
é diferente de X
:
X
O objeto X
não foi criado.
Podemos então realizar as operações com o objeto criado:
x*2
x + y
x*y
E podemos 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
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 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
Encontre mais sobre outros operadores lógicos, como o >
utilizado, neste link.
Warning
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.
Matrizes
As matrizes são outra classe de objetos muito utilizadas no R, com elas podemos realizar operações de maior escala de forma automatizada.
Por serem usadas em operações, nelas somente armazenamos elementos numéricos. Para criar uma matriz, determinamos uma sequência de números e indicamos o número de linhas e colunas da matriz:
X <- matrix(1:12, nrow = 6, ncol = 2)
X
## [,1] [,2]
## [1,] 1 7
## [2,] 2 8
## [3,] 3 9
## [4,] 4 10
## [5,] 5 11
## [6,] 6 12
Podemos também utilizar sequencias já armazenadas em vetores para gerar uma matriz, desde que eles sejam numéricos:
W <- matrix(c(x,y), nrow = 6, ncol =2)
W
## [,1] [,2]
## [1,] 30.1 0.26
## [2,] 30.4 0.30
## [3,] 40.0 0.36
## [4,] 30.2 0.24
## [5,] 30.6 0.27
## [6,] 40.1 0.35
W2 <- matrix(c(x,y), nrow = 6, ncol =2, byrow = T)
W2
## [,1] [,2]
## [1,] 30.10 30.40
## [2,] 40.00 30.20
## [3,] 30.60 40.10
## [4,] 0.26 0.30
## [5,] 0.36 0.24
## [6,] 0.27 0.35
Com elas podemos realizar operações matriciais:
X*2
## [,1] [,2]
## [1,] 2 14
## [2,] 4 16
## [3,] 6 18
## [4,] 8 20
## [5,] 10 22
## [6,] 12 24
X*X
## [,1] [,2]
## [1,] 1 49
## [2,] 4 64
## [3,] 9 81
## [4,] 16 100
## [5,] 25 121
## [6,] 36 144
X%*%t(X) # Multiplicação matricial
## [,1] [,2] [,3] [,4] [,5] [,6]
## [1,] 50 58 66 74 82 90
## [2,] 58 68 78 88 98 108
## [3,] 66 78 90 102 114 126
## [4,] 74 88 102 116 130 144
## [5,] 82 98 114 130 146 162
## [6,] 90 108 126 144 162 180
Utilizar essas operações exige conhecimento de álgebra de matrizes, se quiser se aprofundar a respeito, o livro Linear Models in Statistics, Rencher (2008) possui um boa revisão à respeito. Você também pode explorar a sintaxe do R para essas operações neste link.
Acessamos os números internos à matriz dando as coordenadas [linha,coluna], como no exemplo:
W[4,2] # Número posicionado na linha 4 e coluna 2
## [1] 0.24
As vezes pode ser informativo dar nomes às colunas e às linhas da matriz, fazemos isso com:
colnames(W) <- c("altura", "diametro")
rownames(W) <- clone
W
## altura diametro
## GRA02 30.1 0.26
## URO01 30.4 0.30
## URO03 40.0 0.36
## GRA02 30.2 0.24
## GRA01 30.6 0.27
## URO01 40.1 0.35
Essas funções colnames
e rownames
também funcionam nos data.frames.
Data.frames
Diferente das matrizes, não realizamos operações com os data.frames, mas eles permitem a união de vetores com classes diferentes. Os data.frames são semelhantes à tabelas geradas em outros programas, como o excel.
Os data.frames são combinação de vetores de mesmo comprimento. Todos os que criamos até agora tem tamanho 6, verifique.
Podemos assim combiná-los em colunas de um único data.frame:
campo1 <- data.frame("hibrido" = c("DKB390", "SHS7990", "SYN", "BM3063", "SHS7930"), # Antes do sinal de "="
"AlturaPlantas" = c(1.5,2.0,1.6,1.8,1.3), # estabelecemos os nomes
"AlturaEspiga" = c(0.3,0.4,0.2,0.1,0.25), # das coluna
"NumeroFolhas" = c(rep(51:52, 2),53),
"NotaEstande"= c(1.5,2.0,1.6,1.8,1.3) > 1.5)
campo1
## hibrido AlturaPlantas AlturaEspiga NumeroFolhas NotaEstande
## 1 DKB390 1.5 0.30 51 FALSE
## 2 SHS7990 2.0 0.40 52 TRUE
## 3 SYN 1.6 0.20 51 TRUE
## 4 BM3063 1.8 0.10 52 TRUE
## 5 SHS7930 1.3 0.25 53 FALSE
Podemos acessar cada uma das colunas com:
campo1$NumeroFolhas
## [1] 51 52 51 52 53
Ou também com:
campo1[,4]
## [1] 51 52 51 52 53
Aqui, o número dentro dos colchetes se refere à coluna, por ser o segundo elemento (separado por vírgula). O primeiro elemento se refere à linha. Como deixamos o primeiro elemento vazio, estaremos nos referindo a todas as linhas para aquela coluna.
Dessa forma, se quisermos obter um conteúdo específico podemos dar as coordenadas com [linha,coluna]:
campo1[1,2]
## [1] 1.5
- Obtenha altura da primeira espiga do hibrido “SYN”.
## [1] 0.2
Mesmo se tratando de um data.frame, podemos realizar operações com os vetores numéricos que a compõe.
Exportando e importando dados
Os objetos criados dentro do R podem ser exportados em arquivos de diversos formatos. Lembre-se que, se não definir todo o caminho que deseja depositar o arquivo, ele irá ser salvo no seu diretório de trabalho.
Para exportar o objeto no formato .RData:
save(campo1, file = "campo1.RData")
Essa é uma forma de salvar o objeto trabalhado, se removermos ele com:
rm(campo1) # Certifique-se que salvou o objeto antes de removê-lo
Podemos facilmente obtê-lo novamente com:
load("campo1.RData")
Para salvar todos os objetos do seu workspace use:
save.image()
O R irá criar um arquivo .Rdata
contendo todos os seus objetos.
Podemos exportar nossos objetos em outros formatos, como, por exemplo, .txt
ou .csv
. Para isso utilizamos:
write.table(campo1, file = "campo1.txt", sep = ";", dec = ".", row.names = FALSE)
write.csv(campo1, file = "campo1.csv", row.names = TRUE)
Obs: Você pode adquirir pacotes para exportar e importar dados com outros fomatos, como exemplo o pacote xlsx
exporta e importa dados com formato do excel.
Ao exportar há diversas opções para a formatação do arquivo, é importante considerá-las se o arquivo for ser trabalhado em outro sofware posteriormente.
Abra os arquivos gerados para visualizar sua formatação.
Esses arquivos podem ser lidos novamente pelo R, utilizando as funções e suas especificações:
campo1_txt <- read.table(file = "campo1.txt", sep=";", dec=".", header = TRUE)
campo1_csv <- read.csv(file = "campo1.csv")
head(campo1_txt)
head(campo1_csv)
Agora que aprendemos a importar dados, vamos trabalhar com o conjunto gerado a partir do dados que vocês coletaram em campo.
Nos disponibilizamos neste link dados simulados para esse experimento, mas é bem mais legal se cada um digitar o seu! Use qualquer programa para digitar os dados, faça isso no formato de tabela, você pode exportar em qualquer formato que o R da um jeito, mas se nao quiser ter muito trabalho, expore em .csv.
Envie para nos seus dados no e-mail cursogmp@gmail.com
Adicione o seu arquivo ao seu diretório de trabalho ou indique o caminho da pasta ao importá-lo para dentro do R, como a seguir.
Aqui usaremos o argumento stringAsFactors
que impede que o R transforme os vetores da tabela em fatores, os quais são mais difíceis de trabalhar. O argumento na.strings
irá indicar como foram nomeados os dados perdidos. O argumento header
indica que existe na planilha o nome das colunas.
dados <- read.csv(file = "dados.csv", stringsAsFactors = FALSE, na.strings="-", header = T)
Vamos explorar a estrutura dos dados coletados:
str(dados)
## 'data.frame': 200 obs. of 8 variables:
## $ Tempo : chr "T1" "T1" "T1" "T1" ...
## $ Bloco : int 1 1 1 1 1 1 1 1 1 1 ...
## $ Parcela : int 1 1 1 1 1 2 2 2 2 2 ...
## $ Hibrido : chr "DKB390" "DKB390" "DKB390" "DKB390" ...
## $ AlturaPlantas: num 0.513 1.486 1.36 1.096 2.175 ...
## $ AlturaEspiga : num 0.512 0.733 0.868 0.959 1.4 ...
## $ NumeroFolhas : int 17 10 9 24 21 14 16 20 12 15 ...
## $ Estande : int 9 9 9 9 9 5 5 5 5 5 ...
# também
dim(dados)
## [1] 200 8
Vamos alterar os nomes das colunas para nomes mais fáceis de trabalhar:
colnames(dados) = c("Tempo","Bloco", "Parcela", "Hibrido", "AlturaPlantas",
"AlturaEspiga", "NumeroFolhas", "Estande")
str(dados)
## 'data.frame': 200 obs. of 8 variables:
## $ Tempo : chr "T1" "T1" "T1" "T1" ...
## $ Bloco : int 1 1 1 1 1 1 1 1 1 1 ...
## $ Parcela : int 1 1 1 1 1 2 2 2 2 2 ...
## $ Hibrido : chr "DKB390" "DKB390" "DKB390" "DKB390" ...
## $ AlturaPlantas: num 0.513 1.486 1.36 1.096 2.175 ...
## $ AlturaEspiga : num 0.512 0.733 0.868 0.959 1.4 ...
## $ NumeroFolhas : int 17 10 9 24 21 14 16 20 12 15 ...
## $ Estande : int 9 9 9 9 9 5 5 5 5 5 ...
Estruturas condicionais
if e else
Para nossa próxima atividade com os dados, vamos primeiro entender como funcionam as estruturas if
e else
.
Nas funções condicionais if
e else
, estabelecemos uma condição para if, se ela for verdade a atividade será realizada, caso contrário (else) outra tarefa será. Como no exemplo:
if(2 >3){
print("dois é maior que três")
} else {
print("dois não é maior que três")
}
## [1] "dois não é maior que três"
- Teste o nível de conhecimento em R obtidos no formulaŕio (9ª coluna) pela terceira pessoa que o respondeu (linha 3). Envie uma mensagem motivacional se ela não possuir qualquer conhecimento (nota 0), outra se possuir algum conhecimento (restante das notas). (dica: o sinal
==
se refere a “exatamente igual a”)
if(dados[3,4] < 1.5){
print("Híbrido pequeno demais")
} else {
print("Tamanho provavelmente adequado")
}
## [1] "Tamanho provavelmente adequado"
Podemos espeficiar mais do que uma condição repetindo a estrutura if
else
:
if(dados[7,4] < 1.5){
print("Híbrido pequeno demais")
} else if (dados[7,3] > 1.5 && dados[7,1] < 2.0){
print("Tamanho OK")
} else {
print("Cresceu demais")
}
## [1] "Cresceu demais"
Mas repare que só é possível utilizar essas estruturas para um elemento individual do vetor, se quisermos percorrer o vetor inteiro precisamos recorrer a outro recurso.
Estruturas de repetição
For
Esse recurso pode ser a função for
, uma função muito utilizada e poderosa. Ela constitui uma estrutura de loop, pois irá aplicar a mesma atividade repetidamente até atingir uma determinada condição. Veja exemplos:
for(i in 1:10){
print(i)
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10
test <- vector()
for(i in 1:10){
test[i] <- i+4
}
test
## [1] 5 6 7 8 9 10 11 12 13 14
Nos casos acima, i
funciona como um index que irá variar de 1 até 10 a operação determinada entre chaves.
Para exemplificar melhor a estrutura de um for
:
for(aguas in c("pau", "pedra", "o fim do caminho", "não sei cantar mais")){
cat("É", aguas, "\n")
}
## É pau
## É pedra
## É o fim do caminho
## É não sei cantar mais
Com essa estrutura, podemos repetir a operação realizada com as estruturas if
e else
para um vetor:
molejo = c("amor", "cilada")
for(dilema in molejo){
if(dilema == "amor"){
cat("Não era", dilema)
}else{
cat(" era", dilema)
}
}
## Não era amor era cilada
Aplicando ao nosso conjunto de dados
for(i in 1:nrow(dados)){
if(dados[i,5] < 1.5){
print("Híbrido pequeno demais")
} else if (dados[i,5] > 1.5 && dados[i,5] < 2.0){
print("Tamanho OK")
} else {
print("Cresceu demais")
}
}
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Cresceu demais"
## [1] "Cresceu demais"
## [1] "Cresceu demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Cresceu demais"
## [1] "Cresceu demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Cresceu demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Tamanho OK"
## [1] "Cresceu demais"
## [1] "Tamanho OK"
## [1] "Híbrido pequeno demais"
## [1] "Cresceu demais"
## [1] "Híbrido pequeno demais"
## [1] "Híbrido pequeno demais"
While
Nesse tipo de estrutura de repetição a tarefa será realizada até que seja atingida determinada condição.
x <- 1
while(x < 5){
x <- x + 1
print(x)
}
## [1] 2
## [1] 3
## [1] 4
## [1] 5
É muito importante que nessa estrutura a condição seja possível de ser atingida, caso contrário o loop irá funcionar infinitamente e você terá que interrompê-lo por meios externos, como, se este utilizando RStudio, clicar no simbolo em vermelho no canto direito superior da janela do console, ou apertar Ctrl+C no console.
Não é muito difícil disso acontecer, basta um pequeno erro como:
x <- 1
while(x < 5){
x + 1
print(x)
}
Aqui podemos utilizar os comandos break
e next
para atender a outras condições, como:
x <- 1
while(x < 5){
x <- x + 1
if(x==4) break
print(x)
}
## [1] 2
## [1] 3
x <- 1
while(x < 5){
x <- x + 1
if(x==4) next
print(x)
}
## [1] 2
## [1] 3
## [1] 5
Repeat
Esta estrutura também exige uma condição de parada, mas esta condição é necessariamente colocada dentro do bloco de código com o uso do break
. Ela então repete o bloco de código até a condição o interrompa.
x <- 1
repeat{
x <- x+1
print(x)
if(x==4) break
}
## [1] 2
## [1] 3
## [1] 4
Loops dentro de loops
É possível também utilizarmos estruturas de repetição dentro de estruturas de repetição. Por exemplo, se quisermos trabalhar tanto nas colunas como nas linhas de uma matrix.
# Criando uma matrix vazia
ex_mat <- matrix(nrow=10, ncol=10)
# cada número dentro da matrix será o produto no índice da coluna pelo índice da linha
for(i in 1:dim(ex_mat)[1]) {
for(j in 1:dim(ex_mat)[2]) {
ex_mat[i,j] = i*j
}
}
Fizemos um vídeo com mais detalhes sobre loops no R, aumentem nossa quantidade de views e likes por la.
# Criando uma matrix vazia
ex_mat <- matrix(nrow=10, ncol=10)
# cada número dentro da matrix será o produto no índice da coluna pelo índice da linha
for(i in 1:dim(ex_mat)[1]) { # Primeiro nível, não tem espaço
for(j in 1:dim(ex_mat)[2]) { # Segundo nível tem um espaço (tab)
ex_mat[i,j] = i*j # Terceiro nível tem dois espaços
} # Fechei o segundo nível
} # Fechei o primeiro nível
Elaboração de gráficos simples
Para outros dados coletados, vamos gerar alguns gráficos simples utilizando as funções básicas do R. Existem pacotes como o ggplot2
, plotly
e shiny
que possuem ferramentas muito poderosas para construção de gráficos, mas exigem um pouco mais de tempo para aprendizagem de sua sintaxe.
Os tipos mais comuns já possuem funções próprias, mas outros gráficos podem ser customizados de acordo com a necessidade do usuário. Vamos iniciar com um simples gráfico de frequências (ou histograma) para os dados de Altura de Plantas
.
hist(dados$AlturaPlantas)
Vamos adicionar alguns argumentos para dar uma personalizada:
breaks
para definir os intervalos para cada barra;
#### Histograma ####
#Utiliza um vetor de valores para obter as frequências
hist(dados$AlturaPlantas)
hist(dados$AlturaPlantas, breaks = 2)
hist(dados$AlturaPlantas, breaks = 15)
Agora tente fazer o histograma para o número de folhas, aproveite para tentar alterar alguns parâmetros. Em seguida, serão apresentados outros gráficos que poderão ser utilizados.
#### Bar plot ####
#É um gráfico interessante quando possuímos resultados da função table
estande <- table(dados$Estande)
barplot(estande)
#Alterando o eixo
barplot(estande, horiz = TRUE)
#Mais informações podem ser combinadas
nota_temp <- table(dados$Estande, dados$Tempo)
barplot(nota_temp)
#Crie um objeto que corresponda ao data.frame 'dados' ordenado de acordo com a Altura (ou peso, como desejar!)
#Em seguida, tente criar o dot plot.
#### Curve ####
#Utiliza uma expressão/função
curve(x^2 + 3*x)
curve(2*x, add = TRUE, col="red")
#### Boxplot ####
#Necessita de um vetor de valores ou uma expressão
boxplot(dados$AlturaPlantas)
boxplot(dados$AlturaPlantas~dados$Tempo)
#Explore o bloxplot de outros atributos, podendo combiná-los
#Desafio: faça o boxplot da altura pela combinação de Hibridos e Blocos
boxplot(AlturaPlantas~Tempo*Hibrido, data = dados)
#### Scatter plot ####
#Utilizaremos coordenadas de pontos.
plot(x = dados$AlturaPlantas, y= dados$AlturaEspiga)
Parâmetros gráficos
É possível customizar os gráficos alterando seus eixos, cores, fontes, etc. Começaremos através do gráfico de pontos.
col
para adicionar cor;xlab
alterar título do eixo x;ylab
alterar título do eixo y;main
alterar título geral;
hist(dados$NumeroFolhas, breaks=6, col="blue", xlab="Número de folhas",
ylab="Frequencia", main="Histograma do número de Folhas (Curso 2018)")
Se preferir, podemos usar um gráfico de densidades de Kernel como:
d <- density(dados$NumeroFolhas, na.rm = TRUE)
plot(d, col="blue", xlab="Número de Folhas",
ylab="Densidade", main="Densidade do número de Folhas (Curso 2018)")
Vamos explorar um pouco mais o gráfico de pontos. Vamos verificar se existe uma correlação entre o a altura de plantas e a altura da primeira espiga:
#Busque explorar mais parâmetros no gráfico a seguir:
##Dica: tente alterar o nome dos eixos
plot(x = dados$AlturaPlantas, y= dados$AlturaEspiga)
#Linha de ajuste
abline(lm(AlturaEspiga ~ AlturaPlantas, data = dados), col="red")
#Verificar a correlação:
cor(dados$AlturaPlantas, dados$AlturaEspiga)
## [1] 0.7678205
Alguns argumentos são específicos para cada função, busque mais informações sobre cada uma delas para entender sobre seus argumentos. Outros parâmetros gráficos mais recorrentes são os relacionados com:
- O tamanho de texto e símbolos, chamados de
cex
; - Os símbolos de plotagem (25 ao todo), através do parâmetro
pch
; - Há os relacionados com a fonte (
font
efamily
); - Cores (
col
,bg
,fg
);
#Tamanho, pontos e cores
plot(x = dados$AlturaPlantas, y= dados$AlturaEspiga,
main = "Altura da prim. espiga x Altura da planta", #Título principal
xlab = "Altura de plantas", #Eixo x
ylab = "Alturada prim. espiga", #Eixo y
cex=2,
cex.axis=1.5)
#Agora, busque alterar o nome dos rótulos (lab) e do título (main)
#Utilize o parâmetro 'pch=' e coloque um número de 0 a 25
#De maneira similar ao tamanho, trabalhe com as cores (utilize o color() para ver todas as cores disponíveis)
# Fontes e linhas #
plot(x = dados$AlturaPlantas, y= dados$AlturaEspiga,
main = "Altura da prim. espiga x Altura da planta", #Título principal
xlab = "Altura de plantas", #Eixo x
ylab = "Alturada prim. espiga", #Eixo y
font=3,
family="serif", #Fonte do seu computador (Windows: "TT Courier New")
col="blue")
abline(lm(AlturaEspiga ~ AlturaPlantas, data = dados), col="red", lty=3)
Planilha com dados reais
- Acesse aqui a planilha completa com dados reais coletados no campo dia 23/07/2018.
Leia a planilha para o seu ambiente R com:
dados_compl <- read.csv("dados_completos.csv", stringsAsFactors = FALSE)
str(dados_compl) # Verifique se deu certo, são 200 obs e 8 variáveis
## 'data.frame': 200 obs. of 8 variables:
## $ Tempo : int 1 1 1 1 1 1 1 1 1 1 ...
## $ Bloco : int 1 1 1 1 1 1 1 1 1 1 ...
## $ Parcela : int 1 1 1 1 1 2 2 2 2 2 ...
## $ Hibrido : chr "DKB390" "DKB390" "DKB390" "DKB390" ...
## $ AlturaPlantas: num 1.67 1.65 1.8 1.9 1.77 1.9 2.15 2.05 1.95 1.95 ...
## $ AlturaEspiga : num 1.05 1 1.15 1.05 1.05 0.93 1.13 0.95 0.8 0.96 ...
## $ NumeroFolhas : int 11 12 12 11 12 13 14 14 13 13 ...
## $ Estande : int 25 25 25 25 25 24 24 24 24 24 ...
Elaboração de funções
Normalmente é uma boa prática criar um bloco de código se vai realizar aquela ação poucas vezes. Se for realizar várias vezes a ação e de uma vez só, vale a pena fazer um loop. Mas, se for realizar diversas vezes e o objeto de entrada for modificado vale a pena fazer uma função. E, na hierarquia, quando tiver acumulado muitas funções para realizar uma tarefa mais complexa, vale a pena construir um pacote.
Aqui não vamos nos aprofundar muito nesse assunto, talvez ele renda um outro módulo inteiro, vamos apenas passar noções básicas.
A função também é considerada um objeto no R, portanto você a atribui à uma variável, nesse caso à quadra
. Então estabelecemos os argumentos da função, nesse caso x
. Entre as chaves fica todo o corpo da função. Se você quer que a função retorne algum valor, é necessário utilizar o return
.
quadra <- function(x){
z <- x*x
return(z)
}
quadra(3)
## [1] 9
quadra(4)
## [1] 16
qualquer_nome <- 4
quadra(qualquer_nome)
## [1] 16
Vamos complicar um pouco e também dar mais sentido para construir uma função. Vamos definir no seu corpo várias ações antes de retornar o valor, algo que não poderia ser feito usando uma única função já pronta do R. Vamos aproveitar para explorar os dados coletados.
# Número total de dados coletados
tot <- dim(dados_compl)[1]
# Média do número de folhas
mfolhas <- mean(dados_compl[,7])
# Máxima altura
max.alt <- max(dados_compl[,5])
# Outras características da árvore mais alta
ca.alt.max <- dados_compl[which(dados_compl[,5] == max(dados_compl[,5])),]
# Características da árvore mais baixa
ca.alt.min <- dados_compl[which(dados_compl[,5] == min(dados_compl[,5])),]
# Gráfico com correlação entre Altura da Planta com a Altura da Espiga
png(filename = "corr.alt.png")
plot(dados_compl[,5], dados_compl[,6], xlab = "Altura da Planta", ylab = "Altura da primeira espiga")
dev.off()
## png
## 2
Em forma de função:
extrair_info <- function(dados_compl){
tot <- dim(dados_compl)[1]
# Média do número de folhas
mfolhas <- mean(dados_compl[,7])
# Máxima altura
max.alt <- max(dados_compl[,5])
# Outras características da árvore mais alta
ca.alt.max <- dados_compl[which(dados_compl[,5] == max(dados_compl[,5])),]
# Características da árvore mais baixa
ca.alt.min <- dados_compl[which(dados_compl[,5] == min(dados_compl[,5])),]
# Gráfico com correlação entre Altura da Planta com a Altura da Espiga
png(filename = "corr.alt.png")
plot(dados_compl[,5], dados_compl[,6], xlab = "Altura da Planta", ylab = "Altura da primeira espiga")
dev.off()
return(list(tot, mfolhas, max.alt, ca.alt.max, ca.alt.min))
}
lista_info <- extrair_info(dados_compl)
# Indexação de lista
lista_info[[2]]
## [1] 12.645
# Posso fazer com outro conjunto de dados
lista_info2 <- extrair_info(dados)
Posso adicionar outros argumentos na função:
extrair_info <- function(dados_compl, file.name){
tot <- dim(dados_compl)[1]
# Média do número de folhas
mfolhas <- mean(dados_compl[,7])
# Máxima altura
max.alt <- max(dados_compl[,5])
# Outras características da árvore mais alta
ca.alt.max <- dados_compl[which(dados_compl[,5] == max(dados_compl[,5])),]
# Características da árvore mais baixa
ca.alt.min <- dados_compl[which(dados_compl[,5] == min(dados_compl[,5])),]
# Gráfico com correlação entre Altura da Planta com a Altura da Espiga
png(filename = file.name)
plot(dados_compl[,5], dados_compl[,6], xlab = "Altura da Planta", ylab = "Altura da primeira espiga")
dev.off()
return(list(tot, mfolhas, max.alt, ca.alt.max, ca.alt.min))
}
lista_info <- extrair_info(dados_compl, "outronome.png")
Algumas ferramentas básicas de análise de dados
Claramente a análise de dados é algo muito específico de cada conjunto de dados e interesses. Vamos aqui mostrar alguns recursos básicos como análise de variância, regressão e teste de médias.
Algumas avaliações descritivas podem ser feitas pelo uso do tapply
e de gráficos, como já mostrado anteriormente. A função summary
também da informações gerais do conjunto. É possível usá-la em conjunto com o tapply
.
str(dados)
## 'data.frame': 200 obs. of 8 variables:
## $ Tempo : chr "T1" "T1" "T1" "T1" ...
## $ Bloco : int 1 1 1 1 1 1 1 1 1 1 ...
## $ Parcela : int 1 1 1 1 1 2 2 2 2 2 ...
## $ Hibrido : chr "DKB390" "DKB390" "DKB390" "DKB390" ...
## $ AlturaPlantas: num 0.513 1.486 1.36 1.096 2.175 ...
## $ AlturaEspiga : num 0.512 0.733 0.868 0.959 1.4 ...
## $ NumeroFolhas : int 17 10 9 24 21 14 16 20 12 15 ...
## $ Estande : int 9 9 9 9 9 5 5 5 5 5 ...
# Certifique-se que esta lidando com variável categórica (fator)
dados$Hibrido <- as.factor(dados$Hibrido)
dados$Parcela <- as.factor(dados$Parcela)
dados$Bloco <- as.factor(dados$Bloco)
tapply(dados$AlturaPlantas, dados$Hibrido, summary)
## $BM3063
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.4929 0.9329 1.4040 1.3996 1.8430 2.3419
##
## $DKB390
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.5132 1.1119 1.5433 1.4890 1.8617 2.4237
##
## $SHS7930
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.3809 0.9758 1.2814 1.2729 1.5612 2.4457
##
## $SHS7990
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.5456 0.8821 1.6916 1.5421 2.0092 2.4624
##
## $SYN
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.5543 0.8783 1.3395 1.4064 1.9231 2.4238
tapply(dados$AlturaEspiga, dados$Hibrido, summary)
## $BM3063
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.3215 0.6278 0.7787 0.8694 1.2127 1.4000
##
## $DKB390
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.3025 0.5228 0.7581 0.8311 1.0788 1.4000
##
## $SHS7930
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.3089 0.5024 0.6988 0.7513 0.9179 1.4000
##
## $SHS7990
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.3515 0.6034 0.7495 0.8787 1.1905 1.4000
##
## $SYN
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 0.3003 0.5240 0.7447 0.7685 0.9184 1.4000
Qual a relaçao linear entre altura de plantas e altura da primeira espiga?
mod1 <- lm(AlturaPlantas ~ AlturaEspiga, data = dados)
summary(mod1)
##
## Call:
## lm(formula = AlturaPlantas ~ AlturaEspiga, data = dados)
##
## Residuals:
## Min 1Q Median 3Q Max
## -0.64267 -0.29175 -0.02413 0.23616 1.03856
##
## Coefficients:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 0.39565 0.06585 6.009 8.83e-09 ***
## AlturaEspiga 1.25196 0.07424 16.864 < 2e-16 ***
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## Residual standard error: 0.3554 on 198 degrees of freedom
## Multiple R-squared: 0.5895, Adjusted R-squared: 0.5875
## F-statistic: 284.4 on 1 and 198 DF, p-value: < 2.2e-16
Podemos falar que a altura de plantas é significativamente diferente entre hibridos?
mod1 <- aov(AlturaPlantas ~ Hibrido + Tempo:Bloco + Tempo:Bloco:Parcela, data = dados)
summary(mod1)
## Df Sum Sq Mean Sq F value Pr(>F)
## Hibrido 4 1.68 0.4190 1.414 0.232
## Tempo:Bloco 7 2.33 0.3333 1.125 0.350
## Tempo:Bloco:Parcela 28 9.52 0.3400 1.147 0.292
## Residuals 160 47.41 0.2963
O p-valor nos indica se podemos considerar diferenças de altura conforme o híbrido.
Podemos também fazer um teste de médias para diferenciar a altura de plantas de cada híbrido. Aqui utilizaremos o método de Tukey:
modaov <- aov(AlturaPlantas ~ Hibrido + Tempo:Bloco + Tempo:Bloco:Parcela, data = dados)
tukey.test <- TukeyHSD(x=modaov, 'Hibrido', conf.level=0.95)
tukey.test
## Tukey multiple comparisons of means
## 95% family-wise confidence level
##
## Fit: aov(formula = AlturaPlantas ~ Hibrido + Tempo:Bloco + Tempo:Bloco:Parcela, data = dados)
##
## $Hibrido
## diff lwr upr p adj
## DKB390-BM3063 0.089393187 -0.24645617 0.4252425 0.9481522
## SHS7930-BM3063 -0.126766566 -0.46261592 0.2090828 0.8356790
## SHS7990-BM3063 0.142456832 -0.19339252 0.4783062 0.7682548
## SYN-BM3063 0.006779435 -0.32906992 0.3426288 0.9999978
## SHS7930-DKB390 -0.216159754 -0.55200911 0.1196896 0.3912733
## SHS7990-DKB390 0.053063645 -0.28278571 0.3889130 0.9924298
## SYN-DKB390 -0.082613752 -0.41846311 0.2532356 0.9607890
## SHS7990-SHS7930 0.269223398 -0.06662596 0.6050728 0.1806541
## SYN-SHS7930 0.133546002 -0.20230335 0.4693954 0.8078109
## SYN-SHS7990 -0.135677397 -0.47152675 0.2001720 0.7986372
Instalação e aplicações de pacotes
O que deixa o R ainda mais poderoso é a capacidade de incorporármos à ele novas funções chamando pacotes. Existem milhares de pacotes disponíveis no CRAN (repositorio oficial), e outros repositórios. Para cada área de estudo existem diversos pacotes disponíveis. Aqui usaremos o pacote desplot
.
Como ele esta disponível no CRAN, para instalá-lo basta:
install.packages("desplot")
Depois disso é necessário recrutá-lo com:
library(desplot) # Este comando será necessário toda vez que for utilizar o pacote
Este pacote é um conjunto de funções elaboradas para gerar gráficos de campo. Você pode obter mais informações sobre ele no manual disponível no CRAN.
Com esse pacote podemos desenhar o experimento de campo (assim como esta no papel que recebeu, mas um pouco mais bonito).
Para isso vamos adicionar duas outras colunas no nossa data.frame, com informações da posição de cada indivíduo no campo.
row <- rep(rep(1:10, each=5),4)
col <- c(rep(1:5,10),rep(6:10,10), rep(11:15,10), rep(16:20,10))
dados.up <- cbind(col, row, dados_compl)
Para usar a função do pacote, buscamos no google por tutoriais, aqui esta aquele no qual nos baseamos para elaborarmos o código abaixo.
desplot(Bloco ~ col+row, dados.up,
text=Hibrido, cex=1, out1=Bloco,
out2=Hibrido, out2.gpar=list(col = "gray50", lwd = 1, lty = 1))
Saindo um pouco do nosso conjunto de dados. Vamos agora utilizar um outro pacote chamado “ggmap”.
Ele esta disponível no repositório oficial do R, o CRAN, portanto para instalá-lo basta:
install.packages("ggmap")
Depois disso é necessário recrutá-lo com:
library(ggmap) # Este comando será necessário toda vez que for utilizar o pacote
## Loading required package: ggplot2
É um pacote que utiliza recursos online para gerar mapas conforme um conjunto de dados. Você pode obter mais informações sobre ele no manual disponível no CRAN.
Vamos então montar um vetor com o nome da cidade dos participantes do curso. Segue um exemplo:
cidades <- c("Piracicaba - SP", "São Paulo - SP", "Pindamonhangaba - SP")
Vamos utilizar a função geocode
para obter dados de longitude e latitude das cidades dos participantes do curso:
part1 <- geocode(cidades[1])
## Information from URL : http://maps.googleapis.com/maps/api/geocode/json?address=Piracicaba%20-%20SP&sensor=false
Podemos aplicar a mesma função para todos os participantes utilizando o for
.
coord <- data.frame()
for(i in 1:length(cidades)){
coord <- rbind(coord,geocode(cidades[i]))
}
## Information from URL : http://maps.googleapis.com/maps/api/geocode/json?address=Piracicaba%20-%20SP&sensor=false
## Information from URL : http://maps.googleapis.com/maps/api/geocode/json?address=S%C3%A3o%20Paulo%20-%20SP&sensor=false
## Information from URL : http://maps.googleapis.com/maps/api/geocode/json?address=Pindamonhangaba%20-%20SP&sensor=false
coord
Pode ser que algumas coordenadas não puderam ser encontradas, é um problema de conexão com o google, mas não tem problema, vamos em frente.
Agora estabelecemos um mapa de fundo com a média das longitudes e latitudes:
mapcurso <- get_map(location =
c(lon = mean(coord$lon, na.rm = TRUE),
lat = mean(coord$lat, na.rm = TRUE)),
zoom = 5,
maptype = "roadmap", scale = 2)
## Map from URL : http://maps.googleapis.com/maps/api/staticmap?center=-23.071079,-46.580317&zoom=5&size=640x640&scale=2&maptype=roadmap&language=en-EN&sensor=false
Para mais informações sobre as funções do pacote utilize ?get_map
.
Agora vamos adicionar as localizações no mapa:
ggmap(mapcurso) +
geom_point(data = coord,
aes(x = lon, y = lat, fill = "red"),
size = 2, shape = 21)
Aqui os argumentos de aes
definem características dos pontos no mapa, fill
indica a coloração, size
o tamanho e shape
o formato. Acesse outras codificações de formato aqui.
Pratique gerando relatórios no RStudio
Utilize o R no seu dia-a-dia para ir praticando a linguagem. Além das recomendações contidas na primeira apresentação, recomendamos também dar uma olhada em como gerar documentos em pdf e html usando a Markdown. Utilizamos essa metodologia para gerar este tutorial e outras apresentações do curso. Pode ser muito prático no dia-a-dia!
Para utilizar, será necessário a instalação de outros pacotes. Um deles é o próprio rmarkdown
:
install.packages("rmarkdown")
library(rmarkdown)
Agora crie um arquivo .Rmd utilizando as facilidades do RStudio, clique no ícone com símbolo +
no canto superior esquerdo. Escolha o opção R Markdown
. Dê um título ao seu arquivo e escolha a opção html
. Ao fazer isso, o RStudio já coloca um template inicial, ja com um cabeçalho:
---
title: "Teste"
author: "Eu"
date: "June 5, 2018"
output: html_document
---
Este é o mais simples possível, você pode otimizá-lo de diversas maneiras. Saiba mais aqui.
O template inicial também traz alguns exemplos de sintaxe do markdown. Observe que utilizando #
para títulos de sessões, ##
para um nível inferior (subtitulos) e assim por diante. Palavras em negrito são escritas em meia a dois *
e existem diversas outras especificações para essa sintaxe. Veja mais sobre ela aqui.
Para compilar o código, basta clicar em Knit
. Ele irá pedir para que o arquivo .Rmd seja salvo com algum nome em algum lugar.
O markdown também é capaz de entender diretamente a linguagem html, também a css e latex. Para essa última, o latex precisa estar instalado e todas suas dependências.
Existem alguns pacotes que fornecem templates mais robustos para produção de htmls. Para esse tutorial utilizando o pacote rmdformats
e personalizamos suas cores. Experimente:
install.packages("rmdformats")
Agora faça o mesmo procedimento, clique no +
, escolha R Markdown
e, antes de escolher um título, mude para From Template
, escolha o HTML readthedown template
. Copie e cole o seguinte texto e aperte Knit
.
# Teste1
Isso aqui é um teste só para dar uma olhada no template
## Testinho
Subsessão
* Item
**negrito**
*itálico*
fiz um [link](https://gvenck.github.io/)!
Saiba mais no tutorial sobre isso no R-bloggers, que acreditamos ser um bom começo! Acesse aqui.
Acesse também outros materiais em português produzidos por Cristiane Taniguti, Fernando Correr e Rodrigo Amadeu aqui.
Também recomendamos diversos materiais em inglês aqui.