INTRODUÇÃO A PACOTES ESTATÍSTICOS: INTRODUÇÃO

AO AMBIENTE R

Professores:
Jayme Augusto Prevedello e Vinicius Neres de Lima

Rio de Janeiro
2020

Nota: o conteúdo desta apostila foi elaborado com base principalmente na apostila de Landeiro, VL,
Zucco, CA e Menezes, JFS, “Introdução ao uso do programa R”, versão de 14 de março de 2011, e
destina-se exclusivamente para uso em sala-de-aula no contexto da disciplina “Introdução a pacotes
estatísticos: Introdução ao Ambiente R”, do PPGEE/UERJ.
 AULA 1

1.1. BAIXANDO, INSTALANDO E ABRINDO O R E O RSTUDIO

1) Baixe e instale o R (https://cran.r-project.org/bin/windows/base/) e depois o RStudio

(https://rstudio.com/products/rstudio/download/). O R é o software principal; usaremos ele através do
RStudio, que fornece uma interface mais amigável.

2) Abra o RStudio e crie um novo projeto:

- Clique em File > New Project > New Directory > New Project (ou “Empty Project”, dependendo
da versão do seu RStudio). Em “Directory name:”, coloque “Aula1”. Selecione em “Brownse” a pasta do
seu computador onde deseja salvar. Pronto! Agora já podemos trabalhar dentro do RStudio.
IMPORTANTE: Repita estes passos no início de cada aula, criando sempre uma pasta separada para
cada aula (Aula2, Aula3...Aula5).

O RStudio possui três janelas principais, que conheceremos aos poucos. Por enquanto, vamos
focar na janela principal, à esquerda (“Console”). Essa janela, irá receber todos os comandos que iremos
digitar. O símbolo “>” indica que o console está pronto para receber comandos.

1.2. PRIMEIROS COMANDOS: USANDO O R COMO UMA CALCULADORA

Digite no console o seguinte comando, e depois aperte Enter:

2+2

Digite no console os comandos abaixo, um de cada vez (lembre-se de apertar o Enter), e observe o
resultado:
2+2
2-2
2*2
2/2
2^2

Para realizar contas mais complexas, é importante utilizar parênteses, para separar as etapas do cálculo
adequadamente (assim como fazemos no Excel). Por exemplo, compare os resultados das duas contas
a seguir:
2+2*3
(2+2)*3

Você pode adicionar comentários aos seus comandos, com o símbolo “#”. Esses comentários são muito
úteis para organizar seus comandos e relembrar mais tarde o que eles estão fazendo:
(2^2)*3 # dois elevado a dois; o resultado é multiplicado por 3

Repare que o R ignora (não considera no cálculo) o que vem depois do #.

1.3. FUNÇÕES MATEMÁTICAS DO R

O R tem várias funções prontas, que permitem fazer cálculos (e muitas outras coisas, como
veremos). Os nomes dessas funções prontas são palavras ou abreviações em inglês. Por exemplo, sum
é a função para calcular a soma. Digite e compare os dois comandos abaixo:
sum(1,2)
1+2 # mesmo resultado, certo?

Outras funções úteis:

prod(2,3) # o mesmo que 2*3
sqrt(9) # raiz quadrada de 9 (do inglês “square root”)

A função para calcular logaritmos é log(x,base). Como default, a base do logaritmo é o algarismo
neperiano “e” (2,718282), portanto:

2
log(5) # log neperiano (natural) de 5
log(5,10) # log de 5 na base 10

Para obter valores em módulo, podemos usar a função abs():

abs(3-9) # módulo de 3-9 ou |3-9|; do inglês “absolut”

1.4. CRIANDO OBJETOS, PARTE 1: VETORES

Até agora, apenas fizemos contas básicas, mas ainda não criamos nenhum objeto para guardar
os valores ou os resultados. Para criar um objeto, usamos a seguinte sintaxe: nome <- valor. O símbolo
<- é chamado de atribuir, e é obtido digitando o sinal de menor (<) seguido do sinal de hífen (-). Esse
símbolo forma uma seta, indicando que o elemento à direita (valor) será guardado dentro do objeto à
esquerda (nome). Como exemplo, digite os comandos abaixo (sempre um de cada vez, seguido de Enter)
e veja o que eles fazem:
va <- 2
va
vb <- 3
vb
va*vb # mesmo que 2*3. O R entende que “va” é o mesmo que “2”, e que “vb” é o mesmo
que “3”

No exemplo anterior, criamos dois objetos do tipo vetor (va e vb); o vetor é o tipo mais simples de objeto
do R. Um vetor pode guardar mais de um valor:
vc <- c(1,5,8)
vc

Neste caso, como temos mais de um elemento, precisamos da função c() para combiná-los (chamada
de “concatenar” ou combinar). Veja o que acontece se você esquecer das vírgulas ou do c:
vc <- (1,5,8) # erro! faltou o c
vc <- c(1 5 8) # erro! faltou colocar as vírgulas

Por definição, um vetor é “uma sequência de valores do mesmo tipo”; esses valores podem ser
numéricos (1,2,3...), caracteres (“joao”, “maria”, “jose”) ou lógicos (TRUE, FALSE). Exemplos:
valores <- c(1,2,3,4,5)
valores
respostas <- c(TRUE, FALSE) # OBS: c(T, F) dá o mesmo resultado que c(TRUE, FALSE)
respostas

nomes <- c("joao", "maria", "jose")

nomes

IMPORTANTE: observe que, no caso de caracteres, precisamos colocar aspas entre os nomes dos
elementos. Veja o que ocorre quando esquecemos das aspas:
nomes <- c(joao, maria, jose) # tente entender a mensagem de erro...o que ela quer
dizer, exatamente??

Veja o que acontece se incluirmos números e caracteres num mesmo vetor:

meu_vetor <- c(1, 2, "maria")
meu_vetor

Nesse caso, o R converte os números para caracteres, já que é impossível fazer o contrário (converter
caracteres em números). Para confirmar isso, use o comando class:

class(meu_vetor)

Para praticar, vamos criar alguns vetores. Primeiro, vamos criar um vetor para guardar os valores de
riqueza de aves coletadas em 10 fragmentos florestais:

3
aves <- c(22,28,37,34,13,24,39,5,33,32)
aves

A função length() (do Inglês “comprimento”) retorna o número de observações dentro do objeto:

length(aves) # um erro comum é digitar lenght(aves) – teste para ver o que acontece!

A seguir, vamos criar um vetor para guardar os nomes dos 10 fragmentos:

fragmentos <- c("A", "B", "Rio", "Pedro", "Grande", "C", "D", "E", "F", "G")
fragmentos

1.5. EXERCÍCIO 1: JOGO DOS SETE ERROS

Vamos criar um objeto chamado dados, para guardar os números 1 e 2:
dados <- c(1,2)
Os sete comandos a seguir contém erros de sintaxe (escrita). ANTES de digitá-los no R, tente identificar
qual o erro de cada um. Depois, digite-os no R e observe as mensagens de erro correspondentes:
dados <- (1,2)
dados <- c(1,2 # aparecerá um sinal de +, indicando que falta digitar algo...
dados(1)
Dados[1]
dados[1)
dados[3]
dado[1]

1.6. OPERAÇÕES COM VETORES

Vamos fazer operações matemáticas com o objeto aves, criado acima:
max(aves) # valor máximo
min(aves) # valor mínimo
sum(aves) # soma dos valores
aves+2 # adiciona 2 a cada elemento
aves/2 # divide cada elemento por 2
log(aves) # log natural de cada elemento
sqrt(aves) # raiz quadrada de cada elemento

Lembre-se que para salvar os dados é preciso atribuí-los à um novo objeto:

aves.log <- log(aves) # salva um objeto com os valores de aves em log
aves.log # retorna o novo objeto com valores transformados

Vamos usar nosso conhecimento sobre vetores, e sobre algumas funções, para calcular a média dos
dados das aves. Lembre-se que, para calcular uma média, basta dividir a soma dos valores pelo número
de observações (n):
soma.aves <- sum(aves) # soma dos valores
n.aves <- length(aves) # número de observações (n)
media.aves <- soma.aves/n.aves # cálculo da média

Para ver os resultados basta digitar o nome dos objetos que você criou:
n.aves # para ver o número de observações (n)
soma.aves # para ver a soma
media.aves # para ver a média

Compare o resultado com a função do R para calcular média, mean():

mean(aves)

4
1.7. UMA PAUSA – PEDINDO AJUDA NO R: HELP
Vimos até aqui várias funções: mean, sum, length, log etc. Toda função do R possui uma página
de ajuda (help) associada. Você pode acessar essa página com a função help:
help(sum)

Invista um tempo para olhar com calma a página de ajuda. A parte final dessa página contém exemplos,
que você pode copiar e colar no console do R. Daqui pra frente, sempre que ficar em dúvida sobre como
usar uma função, consulte o help dela.

1.8. ACESSAR VALORES DE ELEMENTOS DE UM OBJETO

Caso queira acessar apenas um valor do conjunto de dados, use colchetes [ ]:

aves
aves[5] # retorna o quinto valor de aves
fragmentos
fragmentos[3] # retorna o terceiro elemento de fragmentos

Para acessar mais de um valor, use c() dentro dos colchetes:

aves[c(5,8,10)] # acessa o quinto, oitavo e décimo valores

Para excluir um valor, use o sinal de subtração antes do elemento:

aves
aves[-1] # note que o valor 22, o primeiro do objeto aves, foi excluído

Caso tenha digitado um valor errado e queira corrigir o valor, especifique a posição do valor e o novo
valor. Por exemplo, o primeiro valor de aves é 22. Caso tivesse sido digitado errado (ex: deveria ser 100),
basta alterarmos o valor da seguinte maneira.
aves[1] <- 100 # coloca 100 na primeira posição, substituindo o 22
aves
aves[1] <- 22 # para voltar ao valor antigo

1.9. GERAR DADOS

1.9.1. Sequências
Para gerar sequências simples, de um em um, podemos usar dois pontos:
1:10
4:13

Também é possível fazer sequências simples em ordem decrescente:

7:1
Podemos usar também a função seq(from,to,by):
seq(1,10,2) # sequência de 1 até 10, de 2 em 2
seq(1,100,5) # sequência de 1 até 100, de 5 em 5

Tente deduzir o resultado do comando abaixo, antes de digitá-lo:

seq(0.01,1,0.02)

1.9.2. Repetições
A função rep(x,vezes=n) gera repetições do valor x, n vezes. Por exemplo, se quiser gerar um ve
tor contendo o número 5, 20 vezes, sem ter que digitar tudo:
rep(5,20) # repete o número 5, vinte vezes

Tente adivinhar o resultado dos comandos abaixo, antes de digitá-los:

rep(3,5)

5
rep("a",5)
rep(1:4,3)

Você pode usar o argumento each, dentro dessa função – digite o comando abaixo, e compare com o
anterior:
rep(1:4, each=3)
rep(c("A","B"),5) # repete AB cinco vezes.
rep(c("A","B"), each=5) # repete A cinco vezes, depois B cinco vezes.

1.9.3. Dados aleatórios

Para criar uma sequência de n valores aleatórios, podemos usar a função runif(n, min, max).
Os valores são amostrados ao acaso pelo R, com base numa distribuição uniforme (por isso “runif”),
variando de min a max:
runif(10,80,100) # 10 valores com mínimo de 80 e máximo 100
temp <- runif(200,80,100) # Gera novamente, mas agora são 200 valores e salva no
objeto temp
hist(temp) # Faz um histograma de frequências dos valores

Para gerar valores aleatórios com uma distribuição normal, é necessário indicar a média e o desvio
padrão, ou seja, rnorm(n, mean, sd):
rnorm(10,0,1) # 10 valores com média 0 e desvio padrão 1 (o default da função é mean=0
e sd=1)
temp2 <- rnorm(200,8,10) # 200 valores com média 8 e desvio 10
hist(temp2) # Faz um histograma de frequência dos valores
hist(rnorm(200,8,10)) # Os dois comandos acima, reunidos em apenas um. Repita este
comando algumas vezes, e veja se os gráficos parecem com uma distribuição normal. Por
que os valores mudam cada vez que você repete o mesmo comando?

1.9.4. Amostragem
Para obter amostras aleatórias de um conjunto de valores, podemos usar a função sample(x, size=y,
replace = FALSE):
sample(1:10,5) # tira 5 amostras do conjunto de valores entre 1 e 10
sample(1:10,20) # erro! O que aconteceu aqui?

Como o replace, por default, é falso (replace=FALSE), é impossível tirar 20 amostras sem reposição
de um conjunto com 10 valores. A solução é amostrar com reposição (replace=TRUE):
sample(1:10,20, replace=TRUE) # ok!

Vamos criar uma moeda e "jogá-la" para ver quantas caras e quantas coroas saem em 10 jogadas.
moeda <- c("CARA","COROA")
sample(moeda,10) # erro! Por quê?
sample(moeda,10, replace=TRUE)

Vamos testar se essa função consegue amostrar aleatoriamente mesmo. Vamos jogar essa moeda
100 vezes e ver quantas caras e quantas coroas temos:
teste <- sample(moeda, 1000, replace=TRUE)
table(teste) # a função table() faz uma tabela de frequência dos valores

1.9.5. Reordenar dados

Vamos criar um vetor qualquer:
exemplo <- sample(1:100,10) # amostra de 10 valores entre 1 e 100
exemplo # veja que os valores não estão em ordem
[1] 7 14 61 97 5 77 9 55 88 67 # ATENÇÃO!!!! Seus valores serão diferentes dos
mostrados aqui, já que a função gera um conjunto aleatório diferente a cada rodada

A função sort(obj) retorna os valores do objeto, em ordem crescente ou em ordem decrescente:

6
sort(exemplo) # para colocar em ordem crescente
[1] 5 7 9 14 55 61 67 77 88 97 # novamente: seus valores serão diferentes dos
mostrados aqui!
sort(exemplo, decreasing=TRUE) # para colocar em ordem decrescente
[1] 97 88 77 67 61 55 14 9 7 5
Já a função order(objeto) retorna a posição original dos valores de um objeto, em ordem crescente.
Ou seja, ele retorna a posição do menor valor, a posição do segundo menor valor, a posição do terceiro
menor valor etc.:
exemplo # este é o objeto original
[1] 7 14 61 97 5 77 9 55 88 67
order(exemplo) # este comando mostrará a posição do menor valor, depois a posição do
2º menor valor etc.
[1] 5 1 7 2 8 3 10 6 9 4 # o menor valor de “exemplo” (que é 5) ocupa a 5ª posição;
o segundo menor valor de “exemplo” (que é 7) ocupa a primeira posição; etc.

Dedique um tempo para entender bem a diferença entre sort(exemplo) e order(exemplo). Esses
dois comandos são muito úteis para reordenar uma planilha inteira, como veremos nas próximas aulas.

1.10. CRIANDO OBJETOS, PARTE 2: MATRIZES

Até aqui, trabalhamos sempre com vetores, que são o tipo de objeto mais simples no R. Veremos agora
um segundo tipo de objeto: as matrizes. Uma matriz é uma coleção de valores organizados em linhas e
colunas, sendo que todos os valores dever ser do mesmo tipo: numéricos (1,2,3...), caracteres (“joao”,
“maria”, “jose”) ou lógicos (TRUE, FALSE).

Para criar matrizes podemos juntar inúmeros vetores que já existem, ou usar o comando
matrix(sequência,linhas,colunas), que distribui a sequência na matriz de dimensões que você
indicou. Vamos supor que temos estimativas de riqueza de comunidades de aves, de 5 locais, amostrados
em duas estações diferentes. Podemos organizar os dados usando uma matriz:
aves2 <- matrix(c(22,28,37,34,13,24,39,5,33,32),5,2) # cuide com os parênteses!
Observe que há uma função c() dentro da função matrix()

aves2

Como já criamos anteriormente um objeto para guardar as riquezas, chamado aves, podemos criar a
mesma matriz de outra forma:
aves2 <- matrix(aves,5,2) # matriz com os valores de aves organizados em 5 linhas e
2 colunas
aves2

Lembra que o comando length(x) retorna o comprimento (ou número de elementos) de um vetor?
Analogamente, o comando dim(x) retorna as dimensões da matriz, ou seja, o número de linhas e
colunas:
dim(aves2)

Obs: a função length() ‘funciona’ para outros objetos, além de vetores, pois a maioria dos objetos no
R são construídos com base em vetores. Veja, por exemplo, o que acontece fazendo length(aves2)
ou aves2+1:10.

1.11. EXERCÍCIOS
(modificados de Landeiro, Zucco e Menezes, 2010. Introdução ao uso do programa R)
1. Você estimou o número de árvores em cada uma de suas parcelas no campo: 18, 14, 14, 15, 14, 34,
16, 17, 21, 26. Salve estes valores no R, em um objeto chamado de “abund”. Usando as funções do R,
encontre a abundância máxima, mínima e média.

1.1. O valor 34 foi anotado de forma errada; ele na verdade é 15. Sem digitar tudo novamente, e usando
colchetes [ ], mude o valor e calcule novamente a abundância média.

2. Tente prever o resultado dos comandos abaixo. Pense primeiro; a seguir, execute os comandos e
confira o resultado:
7
2.1. x <- c(1,3,5,7,9)
2.2. y <- c(2,3,5,7,11,13)
2.3. x+1
2.4. y*2
2.5. length(x) e length(y)
2.6. x + y
2.7. y[3]
2.8. y[-3]

3. Todos os anos, o trinta-réis-ártico (Sterna paradisuea), uma avezinha preta e branca, com pouco menos
de 40 centímetros, realiza um longo voo de pólo a pólo. Durante nove meses, ele percorre 20000
quilômetros, do Círculo Polar Ártico até o limite da Antártida, e retorna, então, ao ponto de partida.
Usando o R, em apenas uma linha de comando, calcule a velocidade média em m/s dessa ave
(assumindo que 1 mês tem 30 dias).

4. Calcule |2^3-3^2|, ou seja, o módulo de 2 elevado a 3 menos 3 elevado a 2. Faça isso em apenas uma
linha de comando.

5. Suponha que você coletou 10 amostras em duas reservas, as 5 primeiras amostras na reserva A, e as
demais na reserva B. Crie um objeto chamado "locais" para especificar as reservas onde as amostras
foram coletadas. Dica: a função rep pode ajudar aqui!

6. Você deseja jogar na megasena, mas não sabe que números jogar, entre 1 e 60. Use a função sample
do R para escolher os seis números para você jogar. Neste caso, devemos usar amostragem com ou sem
reposição?

7. Crie uma sequência de valores de 1 a 30, apenas com números ímpares. Dica: a função seq pode
ajudar!

8. Simule o resultado de 25 jogadas de um dado. Você precisará criar o objeto dado, e usar a função
sample. Neste caso, devemos usar amostragem com ou sem reposição?

9. Crie um objeto com estes valores: 9 0 10 13 15 17 18 17 22 11 15 e chame-o de temp.

Calcule:
9.1. A raiz quadrada de temp
9.2. O log natural de temp. O que acontece com o segundo elemento?
9.3. O log natural dos valores de temp+1. O problema persiste?
9.4. Eleve os valores de temp ao quadrado.

10. Crie um objeto chamado info que contenha seu nome, idade, e-mail e telefone.
Feche o RStudio: Ao fechar aparecerá um a pergunta sobre salvar ou não o Workspace, diga que sim.

8
 AULA 2
Abra o RStudio e crie um novo projeto:

- Clique em File > New Project > New Directory > New Project (ou “Empty Project”, dependendo
da versão do seu RStudio). Em “Directory name:”, coloque “Aula2”. Selecione, em “Brownse”, a pasta
onde deseja salvar no seu computador. LEMBRANDO: Repita estes passos no início de cada aula,
criando sempre uma pasta separada para cada aula (Aula2, Aula3...Aula5).

Fora do R, vá até a pasta recém criada (“Aula2”). Coloque dentro desta pasta os seguintes arquivos,
fornecidos por e-mail pelos professores: “amostras.txt”, “moluscos.txt”, “simu.txt” e “minhocas.txt”.

Usando scripts no RStudio

Na 1ª aula, digitamos todos os comandos diretamente no console do R Studio. No entanto, há outra
maneira de fazer isso, que otimiza o uso do R e que poupa muito tempo: usar um script. Neste caso, os
comandos são digitados em um editor de texto (R Script). Com o script, você facilmente faz alterações e
correções, além de salvar os comandos e poder refazer rapidamente suas análises no futuro.

Para criar um script, dentro do RStudio, clique no símbolo da folha em branco (logo abaixo de File,
no canto superior esquerdo) e selecione R Script. Uma nova janela será aberta, que corresponde ao
script. Digite 3+3 no script e aperte Ctrl+Enter ou Ctrl+R (dependendo da sua versão do RStudio – teste
os dois!). O 3+3 será enviado para o console do R, e o resultado aparecerá na tela inferior. Isso equivale
a digitar 3+3 diretamente no console e apertar Enter; a vantagem é que, digitando no script, deixamos
tudo organizado, e podemos salvar o script. Para salvar seu script, clique em qualquer parte dele e digite
Ctrl+S; coloque o nome que quiser (ex: “ScriptAula2”) e salve na pasta desta aula (Aula2). Outra forma
de salvar seu script é clicar no símbolo do disquete azul, à esquerda de “Source on Save”.

Daqui em diante, use sempre o script para digitar todos os seus comandos, e salve-o
periodicamente.

2.1. IMPORTAR DADOS PARA O R

Primeiro, abra o arquivo “amostras.txt”, fornecido pelos professores, no bloco de notas (fora do
RStudio), apenas para visualizar seu conteúdo. Note que este arquivo contém uma tabela com variáveis
numéricas e categóricas, portanto este é um exemplo de objeto do tipo “dataframe”. Para importar
dataframes em formato “.txt” para o R, a função é read.table. No script do R Studio, digite o comando
abaixo, e depois Ctrl+Enter ou Ctrl+R:
read.table("amostras.txt", header=TRUE)
O argumento header=TRUE informa que os dados possuem cabeçalho, ou seja, a primeira linha contém
os nomes das variáveis.

Nunca se esqueça de criar um objeto para salvar os dados; para isso, neste caso, digite:
macac <- read.table("amostras.txt", header=TRUE) #lembre-se sempre de digitar
Ctrl+Enter ou Ctrl+R, para enviar os comandos ao console

O objeto macac é um objeto do tipo dataframe. Isso quer dizer que macac é um objeto que possui
linhas e colunas (observações nas linhas e variáveis (atributos) nas colunas). Para ver os dados, digite o
nome que você atribuiu ao objeto dentro do RStudio:
macac
Para verificar se os dados foram importados corretamente para o R, verifique a estrutura dos mesmos
com:

str(macac) #olhe com calma o resultado deste comando

Novamente: é fundamental salvar seu script, para não perder os comandos já digitados. Para isso, clique
no símbolo do disquete logo acima do script, ou Ctrl+S. Daqui pra frente, lembre-se de salvar o script
periodicamente.

9
2.2 PROCURAR OS DADOS NO COMPUTADOR

Os comandos para importar dados, como o read.table(), sempre procuram pelos arquivos na
pasta atual de trabalho (“working directory”; no caso, a pasta Aula2). No entanto, você pode chamar
arquivos de outras pastas se souber indicar corretamente o endereço completo do arquivo, por exemplo:

read.table("C:/Users/ja_pr/OneDrive/Introducao ao R_2020/Aula2/amostras.txt")
#este é apenas um exemplo; não vai funcionar no seu computador!

No ambiente Windows, você pode usar tanto a barra simples / ou duas barras invertidas \\, para
indicar o caminho do arquivo. Caso você não lembre o nome do arquivo que deseja importar, existe a
opção de procurar os dados no computador com a função file.choose(). Essa função abre uma caixa
de diálogo, onde você procura pelo arquivo como em outros programas para Windows:
macac <- read.table(file.choose(),header=T) # abre uma caixa de diálogo, que pode
aparecer no RStudio ou na sua barra de tarefas

Você também pode conferir se um determinado arquivo de dados existe na sua pasta atual de trabalho
(working directory):
file.exists("amostras.txt")

Por fim, no Rstudio, há também um atalho para importar tabelas. No painel direito superior, clique em
Import Dataset > From Text (base) (Nota: essa opção pode estar indisponível em versões mais antigas
do RStudio).

2.3. TRANSFORMAR VETORES EM MATRIZES E DATAFRAMES

Além de importar tabelas, existem opções para criar arquivos do tipo dataframe ou matriz, por dentro
do R. Uma das opções é juntar vetores. Por exemplo, para criar uma matriz, podemos usar “column bind”
cbind(vetor1,vetor2,...) ou “row bind” rbind(vetor1, vetor2,...). Vamos ver como eles
funcionam. Vamos criar três vetores e depois juntá-los em uma matriz. Digite os seguintes comandos, um
de cada vez (seguido de Ctrl+Enter ou Ctrl+R):
aa <- c(1,3,5,7,9)
Importante: para visualizar o objeto aa recém criado, digite o nome do objeto (aa) seguido de Ctrl+Enter
ou Ctrl+R. Outra possibilidade é selecionar com o mouse o nome do objeto (aa) no seu script, e apertar
Ctrl+Enter ou Ctrl+R. Daqui pra frente, se habitue a sempre visualizar o objeto recém criado, para
entender bem o que cada comando está fazendo.

bb <- c(5,6,3,8,9)
cc <- c("a","a","b","a","b")
cbind(aa, bb) # junta os vetores em colunas
rbind(aa, bb) # junta os vetores em linhas

Lembre-se que matrizes, ao contrário de dataframes, podem conter apenas valores numéricos ou apenas
caracteres. Por isso, se juntarmos o vetor cc, nossa matriz será transformada para caracteres:
cbind(aa,bb,cc) # junta os vetores em colunas, mas transforma números em caracteres

Para criar um dataframe, que aceita valores numéricos e de caracteres, use a função data.frame:
data.frame(aa,bb,cc) # agora temos variáveis numéricas e categóricas

2.4. ACESSAR PARTES DA TABELA DE DADOS (MATRIZES OU DATAFRAMES)

Agora vamos aprender a selecionar (extrair) apenas partes do nosso conjunto de dados macac
usando [] (colchetes). Como já vimos, O uso de colchetes para objetos em duas dimensões funciona
assim: objeto[linhas,colunas]. Vejamos:
macac[,1] # extrai a primeira coluna e todas as linhas
macac[,2] # extrai a segunda coluna e todas as linhas
macac[1,] # extrai a primeira linha e todas as colunas

macac[3,3] # extrai o valor da terceira linha e da terceira coluna

macac[1,3] # extrai o valor da primeira linha e da terceira coluna
macac[c(1:5), c(2,3)] # extrai as linhas 1 a 5 e as colunas 2 a 3

10
Existem outras duas maneiras de extrair dados de uma dataframe. Uma é usando a função
attach(objeto), que torna as variáveis acessíveis no R, apenas digitando o nome delas na linha de
comandos, como se elas fossem objetos também. Para entender, digite macacos na linha de comandos
e veja o que acontece:
macacos
Error: object "macacos" not found
Agora use a função attach(macac), e depois digite macacos novamente, para ver o que acontece:
attach(macac) # torna cada coluna do objeto “macac” acessível como um objeto
macacos # agora os dados da coluna “macacos” estão disponíveis

frutas # para ver o número de frutas

reserva # para ver as reservas
plot(macacos, frutas) # gráfico simples

Atente para o seguinte: se houver algum objeto no workspace com o mesmo nome de alguma
variável do dataframe fixado (exemplo: macacos), o R pode retornar o objeto errado. Para evitar isso:
detach(macac) # desfaz a fixação feita com o attach, para não gerar referência cruzada
com outras variáveis com mesmo nome

Para evitar esses possíveis efeitos indesejados do attach(), existe uma forma melhor de acessar
colunas pelo nome: usar o símbolo cifrão ($), ao invés de attach(). O uso é basicamente o seguinte:
objeto$variável (a variável corresponde à coluna que se deseja extrair). Por exemplo, para extrair a
coluna macacos, use:
macac$macacos

Ou então usar colchetes e o nome da variável:

macac[,"macacos"] # retorna todas as linhas da coluna macacos

Vamos fazer um gráfico de macacos X frutas, usando $, além da função plot:

plot(macac$frutas, macac$macacos)

Veremos como formatar os gráficos na próxima aula. Por enquanto, como exercício adicional, faça o
gráfico de frutas X macacos usando colchetes ao invés de $. Repare que o nome das variáveis nos eixos
x e y ficam diferentes, em relação ao gráfico feito usando $.

2.5. OPERAÇÕES USANDO DATAFRAMES

2.5.1. Ordenar a tabela

Os dados de macac estão dispostos na ordem em que foram coletados em campo. Em alguns casos
podemos querer colocá-los em outra ordem - por exemplo, na ordem crescente de quantidade de árvores
frutificando. Para isso, use a função order(), vista na aula passada:
macac[order(macac$frutas), ] # ordena as linhas de macac pela em ordem crescente de
frutas

Pare um momento para estudar o comando acima. Por que usamos os colchetes? Por que, depois da
vírgula, não especificamos quais colunas queríamos? Compare também o resultado do comando acima,
com o resultado de macac (dataframe original); qual a diferença?
O parâmetro decreasing=TRUE/FALSE controla se o ordenamento é crescente ou decrescente. O
default é FALSE. Por isso, para fazer ordenamento decrescente é necessário informar:
macac[order(macac$frutas, decreasing=TRUE), ]
Tome um tempo para entender porque o ordenamento de tabelas funciona com o comando order()
e não com o comando sort(), que vimos na aula passada. Para tanto, vamos decompor o comando
passo a passo. Primeiro, olhamos a função order():

11
order(macac$frutas)
[1] 11 15 8 5 14 19 16 20 18 12 13 6 17 1 2 10 4 7 9 3

Veja que o output indica uma sequência de números que correspondem à posição dos elementos
na coluna macac$frutas, em ordem crescente. Ou seja, os elementos 11 e 15 são os que possuem
menores valores de frutas, seguidos de 8, 5, 14 etc. Ao colocar esse comando dentro de macac[ ,]
estamos dizendo que queremos a sequência de linhas expressas por order(macac$frutas).
Salve seu script!

2.5.2. Calcular a média de uma linha ou de uma coluna

Podemos calcular a média de cada coluna da dataframe usando:
mean(macac[ ,"macacos"]) # média de macacos
mean(macac$macacos) # idem
mean(macac$reserva) # média da coluna reserva
[1] NA
Warning message:
In mean.default(macac) : argumento não é numérico nem lógico: retornando NA
Repare que o resultado foi NA, e em seguida apareceu uma mensagem de aviso. NA indica Not
Available, pois não é possível calcular a média de variáveis categóricas.

Nós calculamos a média de macacos por unidade amostral (site), mas sem considerar a reserva
onde as amostras foram coletadas. O que fazer para calcular a média de macacos em cada reserva?
Basta selecionar as linhas correspondentes a cada reserva.
mean(macac[1:10, 3]) # média de macacos na reserva A; repare que estamos selecionando
as linhas 1 a 10 da terceira coluna; faz sentido?
mean(macac[11:20, 3]) # média de macacos na reserva B

2.5.3. Soma de todas as linhas ou colunas

Agora, vamos usar outro conjunto de dados, relacionados a abundância de moluscos coletados em
dez parcelas. O arquivo com os dados é “moluscos.txt”; importe-o para o R, chamando-o de mol, para
facilitar. Faça um esforço para lembrar os comandos para fazer isso; se não lembrar, veja acima como
fizemos com o arquivo “amostras.txt”, que chamamos de macac. Para ver o conteúdo da tabela, digite:
mol

Repare que esse objeto contém informações sobre quantidade de chuva em cada site (parcela) e
em qual de duas reservas (A ou B) a parcela estava localizada. Vamos primeiro somar os valores de
colunas ou linhas, usando as funções colSums(objeto) para somar colunas e rowSums(objeto)
para somar linhas:
colSums(mol[ ,2:7]) #Note que estamos somando apenas as informações sobre as seis
espécies (colunas 2 a 7)

rowSums(mol[ ,2:7])

Que informação biológica você obteve ao usar cada um dos dois comandos acima? Pense com calma.

2.5.4. Médias de todas as linhas ou colunas

Calcule agora a média das colunas e linhas, ou seja, a abundância média por parcela e a abundância
média por espécie:
colMeans(mol[ ,2:7])
rowMeans(mol[ ,2:7])

E se quisermos calcular a abundância total de moluscos (juntando todas as espécies) na reserva A

(linhas 1 a 5)? Veja as opções abaixo e diga qual delas fará o cálculo correto:
rowMeans(mol[1:5, 2:7])
mean(rowSums(mol[1:5, 2:7]))
sum(rowSums(mol[1:5, 2:7]))

12
2.6. OPERAÇÕES EM SUB-CONJUNTOS - tapply

Um procedimento bastante comum no processamento de dados é a execução de funções

(matemáticas, estatísticas ou contagem) por grupos dentro dos seus dados. Um exemplo prático desse
tipo de demanda foi posto agora há pouco, quando nós quisemos calcular a média de macacos por
unidade amostral (site), para cada reserva em separado. Nesse caso, temos uma função sendo executada
em série pelo sub-conjunto reserva. Nesse caso, foi fácil solucionar o problema com um comando simples
como:
macac # apenas para lembrar como é a planilha original
mean(macac[1:10, 3]) # para reserva A
mean(macac[11:20, 3]) # para reserva B

Porém, imagine esse tipo de solução quando os seus dados forem mais extensos, e você possuir,
por exemplo, coletas em 30 reservas. Você precisaria de um comando para cada reserva (30 linhas de
comandos). Uma alternativa mais elegante e simples é dizer ao R “calcule a média de macacos em cada
unidade amostral por reserva”. O comando tapply( ) executa esse procedimento assim:
tapply(dados, grupos, função)

Essa sintaxe diz que será aplicada uma função (média, por exemplo) a um conjunto de dados (a
coluna macacos, por exemplo), separadamente para cada grupo (a coluna reserva):

tapply(macac$macacos, macac$reserva, mean) # média de macacos em cada reserva

Como você faria para calcular a quantidade total de frutas por reserva, com tapply?

tapply(macac$frutas, macac$reserva, sum) # total de frutas em cada reserva

Tome um tempo para entender os comandos acima.

NOTA: o comando tapply faz parte de uma família de funções “apply” – que incluem apply, tapply,
lapply, etc. Todas têm a mesma lógica, mas se aplicam a diferentes tipos de objetos – matrizes,
dataframes etc – e retornam os resultados de formas diferentes.

2.7. EXEMPLO COM DADOS REAIS

Na pasta do curso existe um arquivo chamado “simu.txt”. Este arquivo contém amostras de
Simuliidae (borrachudos - piuns) coletadas em 50 riachos da Chapada Diamantina - Bahia. Importe este
arquivo para o R:
simu <- read.table("simu.txt",header=T)

A tabela é grande, por isso fica truncada, o que atrapalha a visualização. Use View()para ver a tabela
de forma mais organizada (repare o V maiúsculo):

View(simu)
Volte ao script e use head para ver o início da tabela:
head(simu)

Use names()para ver o nome das variáveis (cabeçalho da tabela):

names(simu)

Note que a coluna 1 mostra os nomes dos riachos; a coluna 2 mostra o nome dos municípios; e as
colunas 3 a 7 mostram os valores das variáveis ambientais. A partir da coluna 8, temos os dados das
espécies (abundâncias).

Primeiro, vamos separar os dados das espécies dos dados ambientais (incluindo os municípios):
ambi <- simu[,2:7] # dados ambientais mais municípios
ambi
spp <- simu[,8:27] # dados das espécies
spp
Vamos fazer gráficos simples, para ver as relações entre as variáveis ambientais:
plot(ambi[ ,"altitude"], ambi[ ,"temperatura"])
13
plot(ambi[ ,"altitude"], ambi[ ,"pH"])
plot(ambi[ ,"condutividade"], ambi[ ,"pH"])
Nota: veremos gráficos em detalhes na próxima aula.

A função pairs()faz um gráfico cruzando todos os pares de variáveis possíveis em um dado objeto.
É um passo inicial da exploração de dados, mas deve ser usado com parcimônia.
pairs(ambi) # se retornar um erro, tente “pairs(ambi[-1])”. Esse comando exclui a
primeira coluna, que contém os nomes dos municípios (que são caracteres, e não valores).
Se a figura ficar muito pequena, ajuste com o mouse o tamanho dos quatro painéis do R,
de forma a aumentar o painel inferior direito

Vamos calcular a abundância total de borrachudos em cada riacho:

rowSums(spp) # soma das linhas (riachos)

Para salvar a abundância total:

abund <- rowSums(spp)

Como podemos calcular a riqueza de espécies, em cada riacho? Primeiro precisamos transformar
os dados de abundância para presença e ausência (1 e 0, respectivamente). Primeiro, vamos criar uma
cópia do arquivo original:
copia <- spp # cópia é igual a spp

Agora vamos criar o arquivo de presença e ausência:

copia[copia>0] <- 1 # se o valor for maior que 0, substitui por 1

pres.aus <- copia # apenas muda o nome do arquivo, para deixar mais intuitivo
pres.aus # veja que agora os dados estão apenas como 0 e 1

Para calcular a riqueza de espécies, basta somar as linhas do arquivo de presença e ausência:
riqueza <- rowSums(pres.aus) # número de espécies por riacho (riqueza)

Para calcular a riqueza média de todos os riachos:

riq.media <- mean(rowSums(pres.aus))

Vamos calcular a riqueza média por município:

riq.muni <- tapply(riqueza, ambi[ ,"município"], mean)

Agora, aplique a função colSums(), aos objetos pres.aus e spp, para ver em quantos riachos
cada espécie ocorreu e qual a abundância total de cada espécie. Qual espécie ocorreu em mais riachos?
Qual a mais abundante?

Para transformar os dados de abundância de espécies em log:

simu.log <- log(spp)

Veja o resultado em log:

simu.log # Note a presença do valor -inf

Relembrando: o valor -inf ocorre porque não é possível calcular o log de 0. Veja:
log(0)

Por isso é comum você ver em trabalhos os dados transformados em log(x+1):

spp.log <- log(spp+1)
spp.log

Agora vamos retornar ao nosso arquivo completo, simu, e ordenar a tabela de acordo com a altitude,
de forma que o primeiro riacho seja o que está localizado em menor altitude.
14
simu[order(simu[ ,"altitude"]), ] # tabela ordenada pela altitude

Agora vamos fazer 4 gráficos da riqueza de espécies em relação a altitude, pH, temperatura e
condutividade (lembrando que veremos gráficos, em detalhes, na próxima aula). Primeiro vamos dividir a
janela de gráficos em 4 partes.
par(mfrow=c(2,2))

Riqueza X altitude:
plot(simu[ ,"altitude"], rowSums(pres.aus))

EXERCÍCIO: Faça os outros três gráficos.

Agora vamos fazer um gráfico para ver a riqueza de espécies nas três áreas (Lençóis, Mucugê e Rio
de contas). Para isso, primeiro vamos restaurar a janela de gráficos, para plotar apenas 1 gráfico (e não
4, como antes):
par(mfrow=c(1,1))
stripchart(riqueza ~ simu[ ,"município"])

Experimente também stripchart(riqueza ~ simu[ ,"município"], vertical=T)

2.8 TRANSPOR UMA TABELA DE DADOS

Em alguns casos é necessário transpor uma tabela de dados, ou seja, colocar as informações das
linhas nas colunas e as colunas nas linhas. A função é t() e indica transpose.
t(spp) # inverte linhas e colunas

2.9 COMANDOS DE LÓGICA

2.9.1. Opções para manipular conjunto de dados.

Primeiro vamos ver o significado dos comandos abaixo:

> maior que >= maior que ou igual a

< menor que <= menor que ou igual a

== igualdade != diferença

x <- c(1,2,9,4,5)
y <- c(1,2,6,7,8)
x > y # Retorna TRUE para os maiores e FALSE para os menores
x >= y
x < y
x == y # Retorna TRUE para os x que são iguais a y
x != y # Retorna TRUE para os x que são diferentes de y

Agora vamos selecionar partes dos dados que obedecem a algum critério de seleção.

2.9.2. which(teste lógico)

A função which(teste lógico) retorna a especificação lógica TRUE ou FALSE para uma dada
condição lógica apresentada. Na prática ele funciona como se fosse a pergunta: Quais?
a <- c(2,4,6,8,10,12,14,16,18,20)
a > 10 # retorna um vetor contendo TRUE se for maior e FALSE se for menor
which(a>10) # Equivale a pergunta: "Quais valores de a são maiores que 10?". Note que
a resposta é a posição dos valores (o sexto, o sétimo…), e não os valores que são
maiores que 10.
a[6] # selecionamos o sexto valor de a
a[c(6:10)] # selecionamos do sexto ao décimo valor

15
 Tente prever o que ocorrerá usando o comando abaixo:
a[which(a>=14)]

Acertou? Selecionamos os valores de a que são maiores ou igual a que 14! Se errou, sem problemas -
tente rodar os comandos em partes, de dentro para fora, ou seja: primeiro, rode a>=14; depois,
which(a>=14); finalmente, a[which(a>=14)]. Em cada etapa, pare e pense sobre o que está sendo
feito. DICA: Sempre que encontrar comandos dentro de comandos, como neste caso, rode de dentro para
fora, para entender o que está sendo feito.

Também podemos usar a função which() para selecionar partes de uma tabela de dados. Por
exemplo, vamos selecionar apenas as parcelas dos dados de moluscos onde a chuva é maior que 1650
mm. Lembre-se que para selecionar partes de uma tabela podemos usar colchetes [linhas,colunas]
e especificar as linhas e colunas que desejamos usar. Vamos usar o comando which() para escolher
apenas as linhas (parcelas) onde a chuva é maior que 1650mm:
mol[which(mol$chuva>1650),]

Poderíamos, alternativamente, escolher apenas a parte da tabela que corresponde às amostras da

reserva A:
mol[which(mol$reserva=="A"), ]

Também podemos incluir um segundo critério de escolha usando & (que significa "e"). Vamos
escolher apenas as parcelas da reserva B e que tenham o valor de chuva maior que 1650mm:
mol[which(mol$reserva=="B" & mol$chuva>1650), ]

2.9.3. ifelse(teste lógico ,valor se TRUE, valor se FALSE)

Agora vamos aprender a usar o comando ifelse() que significa: “se for isso, então seja aquilo, se
não, seja aquilo outro”. O comando funciona da seguinte maneira: ifelse(teste lógico, valor
caso o teste for verdade, valor caso seja falso). Complicado? Vamos ver alguns
exemplos para facilitar as coisas.

Primeiro crie no R um objeto com o valor do salário de dez pessoas:

salarios <- c(1000, 400, 1200, 3500, 380, 3000, 855, 700, 1500, 500)
Vamos pedir para o R retornar "pouco" para quem ganha menos de 1000, e "muito" para quem ganha
mais de 1000:
ifelse(salarios<1000, "pouco", "muito") # Se o salário é menor que 1000, retorne
“pouco”, se for maior, retorne “muito”

Também podemos usar o comando ifelse para transformar os dados em presença e ausência.
Vamos usar os dados das espécies de borrachudos (spp) da Chapada Diamantina:
ifelse(spp>=1, 1, 0) # se o valor for maior ou igual a 1 seja 1, se não, seja 0

2.10. EXERCÍCIOS COM DATAFRAMES E COMANDOS DE LÓGICA:

1. Calcule a média de macacos e de frutas dentro de cada reserva, usando o conjunto de dados
macac.txt.

2. Quais informações podem ser obtidas da tabela moluscos.txt quando usamos os quatro comandos
abaixo? Tente prever o resultado antes de rodar cada comando.

2.1. sum(mol[,2:7])
2.2. rowMeans(mol[1:5, 2:7])
2.3. colMeans(mol[1:5, 2:7])
2.4. mean(rowSums(mol[1:5, 2:7]))

3. a) Use a função t para transpor os dados de moluscos (apenas as espécies). b) Multiplique o valor da
abundância de cada espécie de molusco pelo valor de chuva da parcela correspondente. Por exemplo:

16
 Na parcela 1 a chuva foi de 1800 mm e nesta parcela ocorreram 10 indivíduos da espécie 1, portanto
o novo valor para a sp1 na parcela 1 será de 1800 x 10 = 18000.
4. Faça um gráfico de pontos para comparar o número de macacos na reserva A com o número de
macacos na reserva B. Use o conjunto de dados macac. Use a função stripchart.
5. Importe para o R o arquivo “minhocas.txt”. Este arquivo possui dados sobre a densidade de minhocas
em 20 fazendas. As variáveis medidas são: área, inclinação do terreno, tipo de vegetação, pH do solo,
se o terreno é alagado ou não e a densidade de minhocas.

5.1. Veja a tabela na forma original e depois a ordene de acordo com o tamanho da área.
5.2. Faça um gráfico para ver a relação entre minhocas e área do terreno e outro gráfico para ver a
relação entre minhocas e tipo de vegetação.
5.3. Selecione a parte da tabela que contém apenas dados de locais alagados.
5.4. Calcule a densidade média de minhocas, e a densidade média em locais alagados e em locais
não alagados.
5.5. Qual a área média das fazendas?

Podemos usar a função ifelse() para transformar dados de abundância em dados de presença e
ausência. Transforme os dados de abundância de moluscos mol em dados de presença e ausência.
Com os dados transformados em presença e ausência, use a função rowSums para ver quantas espécies
de moluscos ocorrem em cada parcela. Use colSums para ver em quantas parcelas cada espécie
estava presente.

Salve o seu script e feche o RStudio. Ao fechar aparecerá um a pergunta sobre salvar ou não o
Workspace, diga que sim.

17
 AULA 3 - GRÁFICOS
Como nas aulas anteriores, o primeiro passo é abrir o RStudio e criar um novo projeto:
- Clique em File > New Project > New Directory > New Project (ou “Empty Project”, dependendo
da versão do seu RStudio). Em “Directory name:”, coloque “Aula3”. Selecione em “Brownse” a pasta do
seu computador onde deseja salvar.

Crie um novo script, clicando no símbolo da folha em branco (logo abaixo de File) e selecionando R
Script. Como especificado no capítulo da Aula 2, digite todos os comandos nesse script, e não diretamente
no console do R.

O R é amplamente reconhecido por ter grande potencial para geração de gráficos de alta qualidade
e originalidade. Você pode fazer praticamente qualquer gráfico que imaginar. Os gráficos mais comuns
são os gráficos de barras, pizza e de dispersão (pontos).

3.1 GRÁFICOS DE BARRAS – barplot(objeto)

Para fazer gráficos de barras no R a função é barplot(objeto). Essa função gera um barplot
para cada coluna do objeto:
barplot(sample(10:100,10)) #sample gera amostras aleatórias
O R tem uma sessão de exemplos que nos permite ter uma noção de seu potencial:
example(barplot) ## clique no console e aperte Enter sucessivamente, para ir passando
os exemplos, até acabar

3.2. HISTOGRAMAS – hist(objeto,breaks)

O histograma é diferente do gráfico de barras pois retorna a frequência de valores dentro de
intervalos, enquanto o barplot retorna uma barra para cada valor. O número de barras no histograma
depende do número de intervalos em que a distribuição será dividida. Ele é definido por um algoritmo
próprio, mas mexendo no argumento breaks você pode controlar o número de barras, indicando onde
estarão as quebras entre barras:
hist(rnorm(300,100,10))

NOTA: se a janela dos gráficos estiver dividida, digite par(mfrow=c(1,1)) para restaurá-la

hist(rnorm(300,100,10), breaks=seq(60,140,5)) # com barras de largura=5

HISTOGRAMA <- hist(rnorm(300,100,10), breaks=seq(60,140,5)) # com barras com

intervalo de classe de largura=5

hist(rnorm(300,100,10), breaks=seq(60,140,5), xaxp=c(range(HISTOGRAMA$mids),

length(HISTOGRAMA$mids)-1)) # aqui, usamos argumentos adicionais, para
corrigir a posição e o número de tick marks no eixo x

3.3. GRÁFICOS DE PIZZA – pie(objeto)

Para fazer gráficos de pizza, use a função pie:
pie(c(1,5,7,10))

Veja os exemplos de gráficos de pizza:

example(pie) ## novamente: clique no console e aperte Enter sucessivamente para ir
passando os exemplos

18
3.4. GRÁFICO DE PONTOS – plot(x,y)
3.4.1. Gráficos com variáveis numéricas
Primeiro vamos inserir os dados de duas variáveis numéricas. Lembre-se que a forma mais simples
de inserir dados no R é usando a função de concatenar (combinar) dados c():
y <- c(110,120,90,70,50,80,40,40,50,30)
x <- 1:10

Apesar de não ser uma norma, colocar a variável resposta no eixo y (vertical) dos gráficos é um
consenso entre a maioria dos estatísticos, daí a letra y para dados resposta. x é chamada de variável
independente ou explicativa e aparece no eixo x (horizontal).

É muito simples fazer no R um gráfico de pontos de y contra x. A função utilizada é plot(), que
precisa de apenas dois argumentos: o primeiro é o nome da variável do eixo X, o segundo é o da variável
do eixo y:

plot(x,y)

Para usuários de outros programas que usam linha de comando, é comum trabalhar com a lógica
“plote y em função de x” de maneira que o primeiro argumento é sempre a variável resposta. Para isso,
você pode usar:
plot(y~x) # produz o mesmo resultado do comando anterior

3.4.2. Gráficos com variáveis explicativas categóricas

Variáveis categóricas são fatores com dois ou mais níveis. Por exemplo, sexo é um fator com dois
níveis (macho e fêmea). Podemos criar uma variável que indica o sexo da seguinte forma:
sexo <- c("macho","fêmea")

A variável categórica é o fator sexo, e os dois níveis são "macho" e "fêmea". Em princípio, os níveis
do fator podem ser nomes ou números (“1” para macho e “2” para fêmea). Contudo, atente para o
seguinte: se for utilizado número sem as aspas, o programa R irá reconhecer essa variável como
numérica, e não como um nome. Embora isso possa ser corrigido, use nomes aqui para facilitar.

Vamos supor que estamos avaliando o peso de machos e fêmeas de uma dada espécie. Digamos
que, na nossa amostra, os 5 primeiros indivíduos eram machos e os últimos cinco eram fêmeas. Vamos
criar uma variável que indica isso:

sexo <- c("Ma","Ma","Ma","Ma","Ma","Fe","Fe","Fe","Fe","Fe")

Se fossem 20 machos e 20 fêmeas, seria muito trabalhoso digitar tudo. Para facilitar, tente recriar a
variável sexo com 5 “Ma” e 5 “Fe” usando o comando rep(x,vezes).

O peso dos animais será dado pelos valores do objeto y que criamos há pouco. Apenas indique isso:
peso <- y # peso é igual a y
peso

Agora vamos fazer o gráfico:

plot(sexo,peso)

Observe que o comando não funcionou - deu erro! Isso ocorreu porque não informamos que sexo é um
fator. Vamos verificar o que o R acha que é a variável sexo:
class(sexo) # que tipo de objeto é sexo?

Veja que o R trata a variável sexo como um "vetor de caracteres". Mas nós sabemos que sexo é o
nosso fator, então precisamos dar esta informação ao R. A função factor(objeto) transforma o vetor
de caracteres em fator. O fator é um novo tipo de objeto, que ainda não tínhamos visto. É caracterizado

19
por um conjunto de dados categóricos ou nominais que podem assumir um número finito de níveis. Várias
funções do R requerem que as variáveis categóricas sejam apresentadas na forma de fator. Seguindo
adiante, vamos converter sexo em fator:
factor(sexo)

Veja que o R mostra os "valores" (nomes) e depois mostra os níveis do fator.

Agora podemos fazer o nosso gráfico adequadamente:
plot(factor(sexo), peso) # plot também pode ser usado para produzir boxplot!

Gráficos do tipo boxplot são bons quando o número de observações (de dados) é muito grande.
Neste caso, um gráfico com pontos pode ser melhor, para mostrar ao leitor quantas observações foram
utilizadas para produzir o gráfico.

Para fazer um gráfico de pontos quando uma variável é categórica precisamos usar a função
stripchart(y~x):
stripchart(peso~sexo) # faz o gráfico, mas na horizontal
stripchart(peso~sexo, vertical=TRUE) # agora o gráfico está na vertical, porém os
pontos aparecem nas extremidades. TRUE pode ser abreviado para apenas T.
stripchart(peso~sexo, vertical=T, at=c(1.5, 2)) # agora os pontos estão
centralizados, pois com o argumento at, nós especificamos a localização dos pontos no
eixo X. Nota: caso os pontos não estejam centralizados, tente substituir c(1.5, 2) por
c(1.3, 1.7)

Note que agora só há um problema. Eram cinco fêmeas e no gráfico aparecem apenas quatro. Isso
ocorreu porque duas fêmeas têm o mesmo peso. Para melhorar o gráfico, é necessário usar o argumento
method="stack", para que os pontos não fiquem sobrepostos.
stripchart(peso~sexo, vertical=T, at=c(1.5, 2), method="stack")

Os pontos não estão mais totalmente sobrepostos, mas um símbolo ainda está sobre o outro. Usando
o argumento offset=valor conseguimos separá-los:
stripchart(peso~sexo, vertical=T, at=c(1.5, 2), method="stack", offset=1)

É possível combinar um boxplot com o stripchart com o argumento add=T:

plot(factor(sexo), peso, outpch = NA) # o argumento outpch = NA serve para omitir

os outliers

stripchart(peso~sexo, vertical=T, add=T, method="stack", pch=16, cex=1.3,

col="red")

3.5. ALTERANDO A APARÊNCIA (PARÂMETROS DO GRÁFICO)

Para a proposta de apenas explorar os dados, o gráfico acima geralmente é o que você precisa. Mas
em publicações é necessário melhorar a aparência do gráfico. É essencial ter nomes informativos nos
eixos (no R a opção default de nome das legendas é o próprio nome dos objetos). Suponha então que
queremos mudar o nome da variável do eixo x para "Variável explanatória". Para isso, o argumento xlab
("x label") é utilizado:
plot(x,y, xlab="Var explanatória")

Você pode alterar a legenda do eixo y da mesma forma, porem usando ylab:
plot(x,y,xlab="Var explanatória",ylab="Var resposta")

Também é fácil mudar os símbolos do gráfico. Até aqui, estamos usando a opção default, que é a
"bolinha vazia" (pch=1). Se você deseja que o símbolo seja um "x", por exemplo, use pch=4:
plot(x,y,xlab="Var explanatória",ylab="Var resposta",pch=4)

Para colocar título no gráfico uso o argumento main:

20
plot(x,y,xlab="Var explanatória",ylab="Var resposta" ,pch=4, main="Título do
gráfico")

Há uma infinidade de parâmetros para serem alterados em gráficos. Use a função help -
help(barplot) e help(plot) - e veja quantas coisas você pode alterar em gráfico. No quadro abaixo,
relacionamos alguns parâmetros relativamente importantes para o uso cotidiano.

PARÂMETROS COMUNS A DIVERSOS TIPOS DE GRÁFICOS

• pch=nº(1:20)– define símbolo dos pontos
• col=nº(1:8)– define cor dos pontos
• cex=nº – define tamanho dos símbolos (default=1)

• log=”x”/”y”/”xy” – define se um ou ambos eixos estão em escala logo

• main=”text” – título do gráfico
• xlab/ylab=”text” – define rótulo do eixo x ou y
• xlim/ylim=c(min,max) – define intervalo do eixo x ou y

• xaxp/yaxp=c(min,max,n) – define mínimo, máximo e número

de tick marks do eixo.
• asp=y/x – define o formato do gráfico (o default é quadrado)

3.5.1. Adicionando linhas a um gráfico de pontos

A função utilizada para inserir linhas é abline(arg1,arg2,arg3,..). Ele é usado em uma linha
de comando após aquela que cria o gráfico. Vamos usar a função abline para inserir uma linha que
mostra a média dos dados do eixo y:
abline(h=mean(y)) #h indica que será uma linha horizontal, passando pela média de y

Para passar uma linha que passa pela média de x

abline(v=mean(x)) # o v é de vertical

Vamos passar uma linha que passa pelo sétimo valor do eixo x e mudar a cor da linha:
abline(v=7,col="red") # pode escrever o nome da cor ou números (abaixo)

Também é possível inserir as duas linhas ao mesmo tempo:

plot(x,y)

abline(h=mean(y),v=mean(x),col=4) # indicando a cor pelo número 4

E com cores diferentes:

abline(h=mean(y), v=mean(x),col=c(2,4))

Há, no entanto, uma linha muito mais interessante e útil que podemos inserir num gráfico de pontos:
aquela que expressa a relação linear entre duas variáveis. No curso de estatística, aprendemos que a
equação da reta é y= a + bx. Assim, para produzir a linha no gráfico, basta informar quais os valores das
constantes a (intercepto) e b (inclinação).

Para extrair rapidamente essa informação (sem entrar em detalhes sobre regressão linear), nós
usamos a função lm(y~x), que significa linear model de y em função de x. Em seguida, fazemos o
gráfico e inserimos a linha informando as constantes:
lm(y~x)

Call:
lm(formula = y ~ x)
Coefficients:
(Intercept) x
118.667 -9.212
21
abline(a=118.667,b=-9.212) # a = intercepto, b = inclinação

Agora que você já entendeu como o R faz para inserir a linha do modelo, você gostará de saber que
há uma maneira mais fácil e direta de inserir esta informação no gráfico:

Plotar a linha de um modelo linear de regressão

abline(lm(y~x))

3.5.2. Adicionar mais pontos ao gráfico

Em alguns casos podemos querer inserir pontos de outro local no mesmo gráfico, usando símbolos
diferentes para o novo local. Suponha que temos novos valores da variável resposta e da variável
explanatória, coletados em outro local, e queremos adicionar estes valores no gráfico. Os valores são:

v <- c(3,4,6,8,9) ## novos valores da variável explanatória

w <- c(80,50,60,60,70) ## novos valores da variável resposta

Para adicionar estes pontos ao gráfico, basta usar a função points(). Assim como abline(), ela
também é inserida numa linha de comando em separado. Portanto, primeiro vamos refazer o gráfico com
x e y e depois adicionar os novos pontos usando uma cor diferente para diferenciar:

plot(x,y,pch=16, col="black")
points(v,w,pch=16, col="blue")

É possível adicionar pontos nos gráficos indicando com o mouse onde eles deverão ficar, usando
a função locator(n). O n indica o número de pontos que você deseja indicar no gráfico. A função
locator(n) permite que você clique no gráfico com o mouse e adicione o texto na posição desejada:

points(locator(2),pch=16,col="red") # clique em dois locais do gráfico, para

adicionar pontos

3.5.3. Inserir texto em gráficos

Para inserir textos em gráficos a função é text(cooX,cooY,"texto"). Neste caso, cooX e cooY
indicam as coordenadas do eixo X e do eixo Y, onde o texto deverá ser inserido. Vamos criar um gráfico
simples:
plot(1:10,1:10)

Agora vamos adicionar "seu nome" no gráfico nas coordenadas 6 e 7. Isso indica que seu nome
ficará na posição 6 do eixo X e na posição 7 do eixo Y.
text(6,7,"seu nome")

Para inserir duas palavras:

text(c(2,3), c(8,6), c("nome","sobrenome")) # A primeira palavra ficará na posição
2-8 e a segunda palavra ficará na posição 3-6.

Também é possível adicionar texto aos gráficos usando a função locator(n). Para mais de um
texto:
plot(1:10,1:10)
text(locator(3),c("texto 1","texto 2","texto 3")) # clique em três locais do
gráfico para adicionar os textos

3.6. DIVIDIR A JANELA DOS GRÁFICOS

Para apresentar ou comparar dois ou mais gráficos é possível dividir a janela de gráficos do R (já
vimo isso brevemente, anteriormente). A função par(arg1,arg2,arg3,...) controla diversas
características (parâmetros) dos gráficos. Sempre que quiser melhorar algum aspecto de seu gráfico
consulte o help da função par (?par) e descubra o argumento necessário. Tome um tempo agora para
dar uma olhada nesse help.
22
 Vamos dividir a janela de gráficos e preencher com diferentes gráficos, com a função par():
par(mfrow=c(1,2)) # uma linha e duas colunas, ou seja, um gráfico ao lado do outro
hist(rnorm(300,0,2), breaks=20,col=1) # apenas para gerar um gráfico qualquer
hist(runif(300,0,2), breaks=20,col=1)

Agora vamos dividir a janela em duas linhas e uma coluna:

par(mfrow=c(2,1))
hist(rnorm(300,0,2),breaks=20,col=1)
hist(runif(300,0,2),breaks=20,col=1)
(NOTA: Se aparecer a mensagem “Error in plot.new() : figure margins too large”,
aumente o tamanho do painel inferior direito do R, usando o mouse)

Agora vamos dividir a janela em duas linhas e duas colunas (para plotar 4 gráficos)
par(mfrow=c(2,2))
hist(rnorm(300,0,2),breaks=20,col=1)
hist(runif(300,0,2),breaks=20,col=1)
hist(rnorm(300,0,2),breaks=10)
hist(runif(300,0,2),breaks=10)

Lembre-se que, para restaurar a janela gráfica para o default (ou seja, para plotar apenas 1 gráfico em
toda a janela gráfica), digite par(mfrow=c(1,1)) ou dev.off().

3.7. SALVAR OS GRÁFICOS

Existem diversas opções para salvar os gráficos do RStudio. A mais simples é clicar no botão Export,
que fica no painel direito inferior; contudo, a figura exportada dessa forma tem baixa resolução
(geralmente próximo de 96 dpi).

Uma forma melhor é salvar os gráficos diretamente para o arquivo (pasta de trabalho), em formato
TIFF, PDF, JPEG, BMP, PNG ou outros formatos, com alta resolução (≥300 dpi), como solicitado por
muitas revistas científicas. Para tanto, você pode usar a função png(), entre outras. Vejamos um exemplo,
salvando em formato TIFF. Para funcionar, digite todos os três comandos abaixo, e depois veja o gráfico
na sua pasta de trabalho (FORA DO R – nenhum gráfico aparecerá dentro do R):
png("Fig1.tiff", width=8, height=8, units="cm", res=600)
plot(1:10,1:10)
dev.off()

O primeiro comando especifica o nome e tipo de gráfico; a largura e altura; e a resolução (no caso,
600 dpi). O segundo comando produz o gráfico. O terceiro comando informa ao R que o gráfico está
pronto e pode ser salvo na sua pasta de trabalho atual.

3.8. EXERCÍCIOS COM GRÁFICOS

1. Um biólogo foi ao campo e contou o número de sapos em 20 locais. Ele também anotou a umidade e
a temperatura em cada local. Faça dois gráficos de pontos para mostrar a relação do número de sapos
com as variáveis temperatura e umidade. Use a função par() para dividir a janela em duas e visualizar
os dois gráficos simultaneamente:

Os dados são:
sapos 6-5-10-11-26-16-17-37-18-21-22-15-24-25-29-31-32-13-39-40
umid 62-24-21-30-34-36-41-48-56-74-57-46-58-61-68-76-79-33-85-86
temp 31-23-28-30-15-16-24-27-18-10-17-13-25-22-34-12-29-35-26-19

2. Um biólogo interessado em saber se o número de aves está relacionado ao número de uma

determinada espécie de árvore realizou amostras em 10 locais. Os valores obtidos foram:
aves <- c(22,28,37,34,13,24,39,5,33,32)
arvores <- c(25,26,40,30,10,20,35,8,35,28)
23
 Faça um gráfico que mostre a relação entre o número de aves e o número de árvores. Ops, a janela
gráfica ficou dividida! Como restaurá-la?

2.1. Um colega coletou mais dados sobre aves e árvores, em outra área, que podemos aproveitar. Os
dados são:
aves2 <- c(7,15,12,14,4,14,16,20,13,16)

arvores2 <- c (9,17,18,11,10,15,20,16,12,15)

Inclua estes novos pontos no gráfico com um símbolo diferente e cor azul.

2.2. Junte o seu arquivo de aves com o arquivo de aves do seu amigo, para que fique em um arquivo
completo: aves.c <- c(aves,aves2). Faça o mesmo para árvores.

2.3. Os dados do exercício anterior foram coletados em regiões diferentes (você coletou no local A e
seu amigo no local B). Crie um novo objeto com os nomes dos locais onde cada coleta foi feita.

2.4. Faça um gráfico para ver qual região tem mais aves e outro para ver qual tem mais árvores.
Lembre-se que a região deve ser um fator, para que o gráfico seja feito. Use função stripchart.

2.5. Existem locais com o mesmo número de aves, e no gráfico estes pontos apareceram sobrepostos.
Faça o gráfico sem pontos sobrepostos (lembre-se dos argumentos method e offset)

2.6. Refaça os gráficos do exercício 2.4 combinando boxplot e stripchart.

Se sobrar tempo, brinque um pouco com seus gráficos, adicionando pontos, mudando cores e
símbolos, colocando nomes nos eixos etc. Tente também fazer gráficos com dados próprios, da sua
dissertação ou tese.

Existem diversos outros comandos para alterar a aparência de gráficos - veja por exemplo a página
do help da função par (?par). Não se preocupe se você ficar confuso sobre as opções desse help. Com
o tempo e com a prática, você irá dominar estes e outros comandos.

24
 AULA 4 – FUNÇÕES E REPETIÇÕES (LOOPS)
Como nas aulas anteriores, o primeiro passo é abrir o RStudio e criar um novo projeto:
- Clique em File > New Project > New Directory > New Project (ou “Empty Project”, dependendo
da versão do seu RStudio). Em “Directory name:”, coloque “Aula4”. Selecione a pasta onde deseja salvar
no seu computador. Crie um novo script, clicando no símbolo da folha em branco (logo abaixo de File) e
selecionando R Script. Digite todos os comandos nesse script.

O R é extremamente útil para a análise de dados, mas sua principal vantagem é a possibilidade dada
aos usuários de criarem suas próprias funções, seja de simples manipulação de dados, seja de análise
estatística complexa. Além de ser um programa para análises estatísticas, o R é acima de tudo uma
linguagem de programação, praticamente ilimitada. Seus limites quase sempre serão dados pelos limites
de processamento do seu computador.

Nesta aula, vamos aprender o funcionamento básico de programação em R, incluindo a criação de

funções e repetições, com os comandos function(){ } e for(){ }. Nas aulas anteriores, já
utilizamos várias funções prontas do R, como sum(), mean(), read.table(), plot() etc. Nesta
aula, vamos entender como as funções podem ser criadas e alteradas. Pense nas funções como
pequenos programas de computador, que executam alguma tarefa, como calcular uma média, ler uma
planilha ou produzir um gráfico.

4.1. SINTAXE PARA ESCREVER FUNÇÕES

A sintaxe básica para criar uma função é:

funçãoA <- function(lista de argumentos){corpo da função}
O que está em verde pode ser alterado por nós; o que está em azul, não – deve ser mantido exatamente
como está, para o R entender.
function(){} é a função para criar funções. No comando acima, está dito: "estou criando uma função
que vai se chamar funçãoA. A partir de agora, essa função será um objeto no seu workspace. Na verdade,
todas as funções do R, como mean() e sum(), são objetos, mas elas estão contidas nos pacotes que já
vêm com o R, e não precisam figurar como objetos do seu workspace. As novas funções criadas pelo
usuário, por outro lado, precisam ser materializadas como objetos do workspace, como faremos a seguir.

Dentro de function(), devemos listar todos os argumentos que a funçãoA terá. Eles serão usados
no corpo da função, que é a parte onde é escrito o "algoritmo", ou seja, os procedimentos ou comandos
a serem executados. Esta parte vem entre chaves. Veremos tudo isso em detalhes.

4.1.1. Praticando o comando function( ){ }

Vamos ver como criar funções começando por uma função simples, que apenas simula o sorteio de
uma moeda. Neste caso, a função terá dois argumentos, x e n. O argumento x será o elemento a sortear
(a moeda) e n será o número de vezes que se deseja “jogar” a moeda. Vamos dar o nome a esta função
de jogador. No script do R, digite:
jogador <- function(x,n){ # não digite tudo na mesma linha (leia o quadro abaixo)
sample(x, n, replace=T)
} # fim da função

DICA DE PROGRAMAÇÃO!!
Embora não seja uma obrigação, é praxe entre programadores colocar a chave de abertura
da função “{“ no fim da primeira linha, e a chave de encerramento “}” numa linha separada após
o fim do corpo da função. Isso auxilia na leitura de linhas de programação quando elas são
muito extensas e possuem funções dentro de funções.

O comando que está dentro da nossa função, sample(x, n), indica que desejamos amostrar
valores de x, n vezes. No caso, x é um objeto representando a nossa moeda. Precisamos criar esse
objeto, antes de “jogá-lo”:

25
moeda <- c("Cara","Coroa")
Agora, podemos usar nossa função para jogar nossa moeda:
jogador(moeda,2)
jogador(moeda,10)
jogador(moeda,1000)

Veja que jogando 1000 moedas ficou difícil saber quantas caras e quantas coroas saíram. Lembra
como fizemos para conferir isso, na aula 1? Use a função table():
table(jogador(moeda,1000))
Agora, vamos usar nossa função jogador para arremessar um dado. Novamente, precisamos
primeiro criar um objeto que represente um dado. Como um dado tem seis valores possíveis, podemos
fazer o seguinte:
dado <- 1:6 # veja que “dado <- c(1,2,3,4,5,6)” produziria o mesmo resultado

Agora, podemos usar nossa função para jogar nosso dado:

jogador(dado,2)
table(jogador(dado,200))

Nossa função jogador é muito simples e nem é necessária, pois nós apenas imitamos uma função
que já existia no R, sample():
sample(c("cara","coroa"), 10, replace=T)
Agora suponha que você não sabe qual função do R calcula a média, mas você sabe a fórmula para
calcular média: soma dos valores, dividido pelo número de valores:

𝑆𝑜𝑚𝑎(𝑥)
𝑀é𝑑𝑖𝑎 =
𝑛
Conhecendo a fórmula, você pode criar sua própria função, para calcular a média de qualquer
conjunto de valores! Note que você pode inserir comentários dentro da função, para depois lembrar o
que fez:
media <- function(dados){ # função chamada media
soma <- sum(dados) # soma das observações
n <- length(dados) # n é o número de observações
med <- soma/n # calcula a média
return(med) # resultado final da função (no caso, o valor de med)
}# fim da função

Vamos usar essa nova função para calcular a média dos valores abaixo:
valores <- c(21, 23, 25, 19, 10,1 ,30, 20, 14, 13)
media(valores)

Para verificar se o cálculo foi feito corretamente, compare o resultado obtido com a função já pronta do
R:
mean(valores)

É possível criar funções para fazer conversões entre medidas. Por exemplo, em muitos filmes e
livros americanos é comum aparecer a temperatura em graus Fahrenheit (e.g. 60º F), enquanto no Brasil
estamos acostumados a graus Celsius. A fórmula para fazer a conversão é a seguinte:
𝑇𝑒𝑚𝑝𝐶𝑒𝑙𝑠𝑖𝑢𝑠 = (𝑇𝑒𝑚𝑝𝐹𝑎ℎ𝑟𝑒𝑛ℎ𝑒𝑖𝑡 − 32) ∗ (5/9)
Você consegue criar uma função para fazer essa conversão? Pense sozinho(a) primeiro, e tente criar
essa função. Uma possível resposta é apresentada a seguir:
fahrenheit_para_celsius <- function(temp_F) {
temp_C <- (temp_F - 32) * (5/9)
return(temp_C)
}

fahrenheit_para_celsius(60) # Exemplo - converter 60ºF em ºC

26
 De forma similar, podemos criar funções para estimar alguns parâmetros ecológicos com base em
outros. Por exemplo, em mamíferos, a densidade populacional pode ser estimada a partir da massa
corporal média da espécie (Silva & Downing 1995. The allometric scaling of density and body mass: a
nonlinear relationship for terrestrial mammals. American Naturalist 145:704–727). Podemos criar uma
função que usa a massa corporal (em kg), para estimar a densidade (número de indivíduos por km2):
Densidade.Massa <- function(massa) {
log_10_dens <- 1.21 - 0.70*(log10(massa)) # Fórmula de Silva & Downing 1995
densidade <- 10^log_10_dens # anti-log – para que o resultado seja em n. indiv
return(densidade)
}

Densidade.Massa(1) # Exemplo - mamífero com massa de 1 kg

Densidade.Massa(10) # Exemplo - mamífero com massa de 10 kg
(PERGUNTA: Quem possui maior densidade, o mamífero de maior ou menor massa corporal? Isso faz
sentido ecológico?)

4.2. REPETIÇÕES: COMANDO for()

O comando for é usado para fazer loopings, isto é, repetir um mesmo procedimento inúmeras
vezes. Funciona da seguinte maneira:
for(i in 1:n){comandos}
Novamente: o que está em verde pode ser alterado por nós; o que está em azul, não – deve ser mantido
exatamente como está, para o R entender.
O comando acima quer dizer que, para cada valor i, variando de 1 até n, o R vai calcular os
comandos que estão entre as chaves. Para entender, precisamos de um exemplo. Vamos primeiro criar
um objeto vazio, para guardar os resultados que serão gerados pelo for:
resu <- numeric(0) # cria o objeto inicialmente vazio
resu

Agora vamos usar o for(){} para preencher esse objeto com valores. No caso, vamos preencher com
valores de 1 a 5, elevados ao quadrado:
for(i in 1:5){
resu[i] <- i^2
}
resu

Vamos fazer uma pausa para entender exatamente o que está acontecendo. O "(i in 1:5)" indica
que o símbolo i assumirá todos os valores no intervalo entre 1 e 5, sempre que ele aparecer em qualquer
parte de dentro da função. Ou seja, na primeira rodada do for, o i será substituído pelo número 1. Assim,
o R entenderá a linha de comando resu[i] <- i^2 como resu[1] <- 1^2. Em outras palavras,
na primeira posição do objeto resu (resu[1]), o R irá guardar o resultado de 1 elevado ao quadrado
(1^2). Depois, na segunda rodada do for, o i será substituído pelo número 2. Assim, o R entenderá a
linha de comando resu[i] <- i^2 como resu[2] <- 2^2. Em outras palavras, na segunda posição
do objeto resu (resu[2]), o R irá guardar o resultado de 2 elevado ao quadrado (2^2). E assim por
diante, até a 5ª rodada (já que mandamos o R ir de 1 a 5, ou seja, 1:5).

Entenda que o i dentro do for poderia ser qualquer outra letra ou palavra. Por exemplo, os comandos
abaixo produzem exatamente o mesmo resultado que os comandos acima:
for(BLABLA in 1:5){
resu[BLABLA] <- BLABLA^2
}
resu
Neste caso, trocamos o i por BLABLA; sempre que aparecer BLABLA dentro do for, o R entenderá
que deve trocá-lo por “algo”. Esse “algo”, no caso, é o número 1 na primeira rodada; 2 na segunda
rodada, etc., já que colocamos “1:5” dentro do for.
Da mesma forma, o “1:5” poderia ser outra coisa. O que aconteceria, por exemplo, se colocássemos
c(1,2), ao invés de 1:5? Pense primeiro, e depois teste no R!

27
Para deixar ainda mais claro, vamos fazer uma
espécie de "filminho" mostrando o que o for faz. Resumo sobre comando for(i in x)
Primeiro, vamos criar um gráfico vazio, apenas
plotando os eixos, indo de 0 a 10. Para tanto, vamos
• O loop for executa o mesmo
colocar o argumento type="n" para que os pontos
não apareçam: procedimento repetidamente para cada
valor que i assume.
plot(0:10, 0:10, type="n") • A linha de comandos que está dentro de
{ } precisa incluir o i como um dos seus
Agora, vamos usar o for para inserir textos
elementos em algum lugar
no gráfico. Um texto será colocado a cada passo
do for:

for(i in 1:9){
text(i, i, paste("Passo", i))
}

O R fez tudo muito rápido, de forma que não conseguimos ver o passo-a-passo do for. Vamos fazer
novamente, mas agora inserindo um comando que retarde o R em 1 segundo. Ou seja, cada passo irá
demorar 1 segundo:
plot(0:10, 0:10, type="n")

for(i in 1:9){
text(i, i, paste("Passo", i))
Sys.sleep(1)# retarda os passos em 1 segundo
}

Entendeu o que está sendo feito? No primeiro passo do for, o i foi substituído pelo número 1.
Portanto, a linha de comando text(i, i, paste("Passo", i)) virou text(1, 1,
paste("Passo", 1)). Como resultado, apareceu o texto "Passo 1", na coordenada x=1, y=1 do
gráfico. Note que a função paste() gera uma palavra ou frase, combinando os caracteres ou números
que nós incluímos dentro do parênteses. No segundo passo, o i foi substituído pelo número 2, portanto
apareceu o texto "Passo 2" na coordenada x=2, y=2, e assim por diante.

O for é um comando extremamente versátil e muito utilizado em diversas funções e na simulação

de dados. Fique atento ao uso do for nas funções seguintes e pergunte caso não tenha entendido.
Vejamos mais um exemplo do for, neste caso para gerar a famosa “Sequência de Fibonacci”, muito
conhecida na matemática. Os dois primeiros números da sequência são [1, 1]. Os números subsequentes
são compostos pela soma dos dois números anteriores. Assim, o terceiro número da sequência de
Fibonacci é 1+1=2, o quarto é 1+2=3, o quinto é 2+3=5 e assim por diante. Vamos usar a função for para
descobrir os 12 primeiros números da sequência de Fibonacci:
Fibonacci <- c(1,1) # cria o objeto e coloca o número 1 nas posições 1 e 2
for(n in 3:12){ # começamos com 3 porque já temos os dois primeiros números (1,1)
Fibonacci[n] <- Fibonacci[n-2] + Fibonacci[n-1]
}

Fibonacci
[1] 1 1 2 3 5 8 13 21 34 55 89 144

Dedique o tempo que for necessário para entender o que está sendo feito. O for está sendo usado para
preencher o objeto Fibonacci. Os dois primeiros valores desse objeto são 1, 1, conforme nós indicamos
na linha acima (Fibonacci[c(1,2)] <- 1). Os valores 3 a 12 do objeto serão preenchidos pelo for.
Na primeira rodada do for, o símbolo n será substituído pelo número 3, então o R fará isto:
Fibonacci[3] <- Fibonacci[3-2] + Fibonacci[3-1]. Ou seja, na 3a posição
(Fibonacci[3]), o R colocará o resultado da soma entre o valor da 1a posição (Fibonacci[3-2], o
que equivale a Fibonacci[1]) e o valor da 2a posição (Fibonacci[3-1], o que equivale a
Fibonacci[2])). Releia tudo com calma; se necessário, pergunte aos professores.

28
4.3. EXERCÍCIOS - PARTE 1
1. Crie uma função e use-a para sortear seis números para jogar na mega sena. Lembre-se que: (i) os
números da mega sena variam de 1 a 60; um mesmo número não pode ser sorteado duas vezes.

2. Modifique o código para gerar a sequência de Fibonacci de forma que:

2.1 os dois primeiros elementos da sequência sejam 2 e 2

2.2 os dois primeiros elementos da sequência sejam 3 e 2

2.3. modifique o código para que os valores sejam compostos pela diferença (e não a soma) entre
os dois valores anteriores.

2.4. modifique o código para que os valores sejam compostos pela diferença entre os dois valores
imediatamente anteriores somada ao terceiro valor imediatamente anterior. Para isto, faça
inicialmente com que a sequência Fibonacci já comece com 3 valores [1,1,1]. Cuidado aqui: se a
sequência inicial já tem 3 valores, será que ainda deveremos usar 3:12 dentro do for??

4.4. CRIANDO FUNÇÕES MAIS COMPLEXAS

4.4.1. Índice de Diversidade de Shannon
Agora vamos usar o for para fazer uma função mais complexa e também mais útil para nosso dia
a dia. Vamos elaborar uma função que calcula o índice de diversidade de Shannon-Wiener. Este índice,
bastante conhecido entre nós, mede a diversidade em uma comunidade, com base em valores de
abundância de cada espécie. O índice aumenta com o aumento do número de espécies e com o aumento
do componente conhecido como equitatividade (ou equidade; evenness). A fórmula do índice de Shannon
é:

onde Pi é a abundância relativa da espécie na comunidade (N da sp / N total), ln é o logaritmo

natural e S é a riqueza (número de espécies). Vamos pensar com calma o que precisamos fazer, antes
de ir para o R. Segundo a fórmula, primeiro temos que calcular a abundância relativa (Pi) de cada espécie;
depois, precisamos multiplicar Pi por lnPi, para cada espécie. Depois, precisamos somar o resultado dessa
multiplicação entre as espécies. Uma possibilidade é:

shannon <- function(dados){ #cria a função shannon

n <- length(dados) #número de espécies na comunidade
resu <- numeric() #objeto para guardar os resultados do for, a seguir

for(i in 1:n){ #loop para fazer o cálculo para cada espécie

Pi <- dados[i]/sum(dados) #calcula a abundância relativa, Pi
Pi_LnPi <- Pi * log(Pi) #calcula Pi * ln(Pi)
resu[i] <- Pi_LnPi #guarda o resultado da multiplicação
} #fim do loop (for)

H <- - sum(resu) #soma os resultados entre as spp (repare o “menos” na frente)

return(H) #especifica o que deve ser mostrado como resultado da função
} #fim da função

Agora vamos usar a função shannon para calcular o índice de Shannon para dados de uma
comunidade hipotética. Essa comunidade possui 5 espécies, com as abundâncias abaixo:
comunidade <- c(8,7,4,1,1)
shannon(comunidade)

Vamos testar seus conhecimentos ecológicos: o valor de shannon seria maior ou menor, se a comunidade
tivesse a mesma riqueza (5), mas abundâncias 1,1,1,1,1? E se tivesse apenas 4 espécies, com essas
mesmas abundâncias (1,1,1,1)? Por fim, a diversidade de Shannon seria diferente entre uma
comunidade com abundâncias (8,8,8,8,8) e outra com (100,100,100,100,100)? Você pode
conferir os resultados comparando com a função já pronta do R, diversity(). Para usar esta função,
você terá que instalar o pacote vegan, e depois carregá-lo no R:

29
install.packages("vegan") # é necessário ter conexão de internet!
library("vegan")
diversity(c(1,1,1,1))
shannon(c(1,1,1,1))

4.5. EXERCÍCIOS - PARTE 2

1. Crie uma função para calcular outro índice de diversidade, o índice de Simpson. A fórmula desse índice
é:
𝑆𝑖𝑚𝑝𝑠𝑜𝑛 = 1 − ∑𝑆𝑖 𝑃𝑖 2

Sendo Pi a abundância relativa de cada espécie. Aplique esse índice a uma comunidade com 10
espécies, com as seguintes abundâncias: 100, 88, 70, 40, 5, 5, 3, 1, 1, 1. Confira o resultado usando
a função diversity(dados, index = "simpson"), do pacote vegan, sendo “dados” o objeto
contendo a sua comunidade. (Nota: dependendo da versão, pode ser necessário usar index =
"simp" – veja no help da função diversity)

2. Modifique a função acima (Simpson) para calcular a diversidade em duas comunidades de uma única
vez. Ou seja, a função deve dar como resultado não apenas um valor, e sim dois (um por comunidade).
Primeiro, crie um dataframe para representar as duas comunidades, como abaixo:

comunidades <- data.frame(com1 = c(10, 1, 1), com2 = c(4, 4, 4), row.names

= c("sp1", "sp2", "sp3"))

comunidades

Depois, modifique sua função e aplique-a a esse dataframe.

3. A função shannon criada ao longo da aula tem um problema: ela não funciona se alguma espécie da
comunidade tiver abundância = 0:

shannon(c(0,1,1))
[1] NaN

Isso ocorre porque aplicamos logaritmo em uma das etapas do cálculo (reveja a fórmula do índice), e
o log(0) não existe. Como você modificaria a função shannon, para que ela ignorasse as espécies
que têm abundância 0 e mesmo assim conseguisse calcular o valor de diversidade? Dica: a função
ifelse(), que vimos na segunda aula, pode ajudar.

4. Você é professor de Biologia e, chegando ao fim do semestre, precisa calcular as notas de seus alunos.
No entanto, suas avaliações tiveram peso diferente e o cálculo precisa ser de uma média ponderada. Os
dados estão na planilha “alunos.txt”. Cada linha corresponde a uma avaliação, a primeira coluna indica o
peso das avaliações e as demais colunas indicam o os nomes dos alunos. Crie uma função para calcular
a média ponderada de cada aluno. Quem é o melhor aluno da turma?

5. Crie uma função para converter coordenadas geográficas, de graus/minutos/segundos para graus
decimais. Por exemplo, a latitude da UERJ, em graus/minutos/segundos é 22° 54' 40" S. Para converter
para graus decimais, precisamos converter os minutos e os segundos em graus, e somar com os 22º.
Para tanto, basta lembrar que 60' = 1°, e 60" = 1'. Assim, no caso da UERJ, teríamos 22 + (54/60) +
(40/3600) = 22.91111 graus decimais. Depois que criar a função, aplique-a às seguintes coordenadas:

22° 54' 44" S Maracanã

15° 47' 58" S Congresso Nacional
25° 41' 43" S Cataratas do Iguaçu

Nota: você terá que formatar esses dados e incluí-los no R, da forma que achar melhor – ex: vetores e
dataframes criados no R mesmo; planilha txt. Importada; arquivo Excel etc. Isso tudo faz parte do
exercício!

30