Introdução Ao Software R para Biologia - Marcos Vital UFAL - V26!09!2013

1
Bioestatística - Prof. Marcos Vinícius Carneiro Vital (ICBS – UFAL) - Material disponível no endereço http://marcosvital.wordpress.com/
Universidade Federal de Alagoas
Instituto de Ciências Biológicas e da Saúde
Prof. Marcos Vinícius Carneiro Vital
Introdução ao uso do software R para as Ciências Biológicas
Versão de 26/09/2013
Este documento nasceu como um guia para auxiliar os estudantes da disciplina de
Bioestatística do ICBS/UFAL no uso do software R. Aos poucos, porém, comecei a achar
que ele poderia ser útil para outras pessoas interessadas em aprender a usar o programa,
e comecei a editá-lo para que possa ser usado por qualquer um. Caso você deseje usar
e/ou distribuir este material, peço apenas que mantenha a sua total integridade e as
informações de autoria. À parte disso, ele pode ser usado e distribuído gratuitamente. Ah,
e um aviso importante: tenha em mente de que este é um guia não tem como objetivo
ensinar estatística: ele visa apenas a sua aplicação prática no R.
Como todos os documentos que publico no meu blog, este passará regularmente
por revisões e/ou atualizações. Para que este processo tenha maior eficiência, sugestões
de modificações e indicações de erros são muito bem vindos, então sinta-se à vontade
para entrar em contato sobre o conteúdo deste documento. Por fim, caso você não tenha
obtido este material diretamente no meu blog, sugiro acessá-lo para conferir se a sua
versão é a mais nova: http://marcosvital.wordpress.com/
Esta apostila foi concebida para ser usada de maneira prática, usando o R ao
mesmo que se lê o texto. Como sugestão de uso, então, o ideal é manter o R aberto durante
a leitura, e ir repetindo os procedimentos que aparecem aqui. Todos os procedimentos
descritos no texto aparecem em imagens do R com sua execução, para que você possa
comparar facilmente o que está fazendo com o que eu fiz. Caso você não tenha em mãos
os arquivos com os dados utilizados ao longo dos exemplos, há uma maneira alternativa
de obter os dados sem ter que usar os arquivos em si, que você poderá conferir no anexo
lá no final. Ah, e no final de cada seção eu inclui um resumo das funções utilizadas
naquela parte, para facilitar a revisão e servir para referências rápidas durante o seu
aprendizado.
Espero que todos aproveitem bem este manual e tenham uma ótima experiência
utilizando o R!
Atenciosamente
Marcos Vinícius Carneiro Vital
2
SUMÁRIO
1. Introdução ................................................................................................................. 3
1.1. Obtendo e instalando o software. ........................................................................ 3
1.1.1 Usando o R com um IDE ............................................................................... 4
1.2. Primeiro contato. ................................................................................................ 4
1.3. O R como uma calculadora ................................................................................. 5
1.4. Usando funções no R .......................................................................................... 6
1.5. Usando os mecanismos de ajuda ......................................................................... 7
1.6. Criando objetos................................................................................................... 8
1.7. Importando uma planilha de dados para o R ...................................................... 10
1.8. Instalando e ativando pacotes no R ................................................................... 13
1.8.1. Pacotes com interface gráfica ..................................................................... 14
1.9. Usando um script, inserindo comentários e salvando tudo ................................. 14
1.10. Resolvendo problemas comuns no R ............................................................... 17
1.10.1. Objeto não encontrado .............................................................................. 17
1.10.2. Não foi possível encontrar a função “qualquer” ........................................ 18
1.10.3. Símbolo inesperado .................................................................................. 18
1.10.4. Tio, um danado de um “maiszinho” fica aparecendo no lugar do ‘>’! ....... 19
1.10.5. Orientações gerais .................................................................................... 19
1.11. Funções utilizadas – seção 1 ........................................................................... 20
2. Dados e gráficos ...................................................................................................... 21
2.1. Reconhecendo variáveis de uma planilha .......................................................... 21
2.2. Medidas de tendência central e de dispersão ..................................................... 22
2.3. Lidando com subconjunto de dados .................................................................. 23
2.4. Estudando a distribuição de frequências de uma variável: o histograma ............ 23
2.5. Gráficos, gráficos, gráficos! .............................................................................. 24
2.5.1. Gráficos de dispersão ................................................................................. 26
2.5.2. Gráficos de barras ...................................................................................... 26
2.5.3. Boxplots e gráficos de média com barras de erro ........................................ 27
2.6. Funções utilizadas – seção 2 ............................................................................. 30
3. alguns testes estatísticos .......................................................................................... 31
3.1. A escolha de um teste estatístico ....................................................................... 31
3.2. O teste de qui-quadrado .................................................................................... 31
3.2.1. Pressupostos do qui-quadrado .................................................................... 33
3
3.3. O teste t de Student ........................................................................................... 33
3.3.1. Pressupostos do teste t ................................................................................ 34
3.4. A análise de variância (ANOVA)...................................................................... 36
3.4.1. Pressupostos da ANOVA ........................................................................... 37
3.5. A regressão linear simples ................................................................................ 38
3.5.1. Pressupostos da regressão linear simples .................................................... 39
3.6. Funções utilizadas – seção 3 ............................................................................. 40
ANEXO 1: dados utilizados ........................................................................................ 41
1. INTRODUÇÃO
Nesta introdução nós vamos: instalar e ter um primeiro contato com o programa;
ter nosso primeiro contato com uma função; aprender a usar os mecanismos de ajuda;
criar objetos; importar dados; instalar pacotes e, finalmente, criar e utilizar scripts.
1.1. Obtendo e instalando o software.

O R é um software livre, o que significa que não tem custos e que seu código fonte
está acessível para qualquer usuário. Ele pode ser obtido no site oficial:
http://www.r-project.org/
Basta acessar o link ‘CRAN’ no lado esquerdo da tela, selecionar um dos
endereços para fazer download, e selecionar o sistema operacional. Supondo que você
está usando um computador com Windows, clique em ‘Download R for Windows’, em
seguida em ‘base’ e, por fim, no link para download que aparecerá no alto da tela. O R
recebe atualizações constantes, e se você desejar instalar uma versão mais recente, saiba
que ele não substituirá a versão anterior, que deve ser desinstalada manualmente pelo
usuário (ou mantida, o que pode ser útil para utilizar pacotes antigos que não existam nas
versões mais novas). O processo de instalação em si é simples, então não vou detalhá-lo
aqui.
Nunca se esqueça de que o R possui uma quantidade imensa de material sobre seu
uso nas mais diversas áreas da ciência, e buscar material é bastante importante como parte
do processo de aprendizado. Na página inicial do programa há alguns manuais
disponíveis (no link ‘Manuals’, no lado esquerdo), que podem ser um bom ponto de
partida, e com qualquer busca na internet é bem fácil encontrar material gratuito
4
disponível, com os mais variados graus de detalhe e abrangência. Na medida em que
desejar avançar no uso do programa, faça buscas e aproveite a existência deste material,
que é uma das várias vantagens de se usar o R. Quando desejar buscar na internet por
algum material específico (como uma análise ou conjunto de análises de uma determinada
área), a dica é buscar por: [R] “análise desejada”.
1.1.1 Usando o R com um IDE

Como você mesmo verá (ou já viu), o R não é um programa muito “vistoso”. Mais
do que isso, com algum tempo você poderá pensar que algumas funcionalidades poderiam
estar mais facilmente acessíveis, como a visualização dos objetos utilizados durante uma
seção, o acesso às pastas de trabalho e outras coisas do tipo. Pensando nestes e em outros
aspectos, algumas pessoas desenvolveram os IDEs, que é uma sigla para Integrated
Development Environment (algo como ambiente de desenvolvimento integrado). Os IDEs
são programas que adicionam ao R uma interface de usuário mais amigável e com mais
funcionalidades. Para os usuários de Windows, existem pelo menos dois IDEs bem
conhecidos para o R:
RStudio: http://www.rstudio.com/
Tinn-R: http://nbcgib.uesc.br/lec/software/desenvolvidos/editores/tinn-r/en
Usá-los é simples: basta ter o R instalado no computador e depois instalar um dos
programas. O RStudio é bem conhecido e muito usado por aí; o Tinn-R não tem tanta
visibilidade, mas é bem conhecido aqui no Brasil, pois é desenvolvido na Universidade
Estadual de Santa Cruz (UESC), em Ilhéus, Bahia. Com certeza devem existir outras
opções por aí, e pode ser interessante pesquisar um pouco antes de escolher um IDE para
se usar. Não há nada de errado em usar o R “puro”, mas dar uma olhada nos IDEs é uma
boa, pois ele pode facilitar bastante a vida do usuário, especialmente para quem ainda está
se habituando com o programa.
1.2. Primeiro contato.

Ao abrir o programa pela primeira vez, não vemos um visual típico com muitos
menus e ícones: o que chama a atenção é uma janela central, o ‘R console’. Praticamente
todas as tarefas que executaremos serão feitas nesta janela, via comandos que devem ser
digitados manualmente. Após algumas informações sobre a versão, a licença de uso, os
contribuidores e os mecanismos de ajuda, o console termina com um símbolo ‘>’ em
vermelho, onde os comandos podem ser digitados. O funcionamento básico é bem
5
simples: basta digitar o comando desejado e teclar enter, e o programa responde
executando a tarefa desejada (ou apresentando uma mensagem de erro, caso ele não
“saiba” o significado do que foi digitado).
1.3. O R como uma calculadora

Nosso contato inicial com o programa R será feito usando-o para resolver
operações matemáticas. Neste sentido, podemos pensar no R como uma grande e
completa calculadora científica. Comece digitando uma operação bem simples, como
uma soma, por exemplo, e depois tecle enter:
O programa, então, executa a operação e apresenta o resultado. Temos que chamar

a atenção para duas coisas:
- o que foi executado vai ficando “para trás” no console, e não pode ser alterado
ou usado novamente sem repetir a operação. Mais adiante iremos aprender a salvar os
resultados de nosso interesse para posterior uso.
- o resultado aparece após o número 1 entre colchetes. Isto não é muito relevante
quando temos apenas um valor como resultado, mas faz diferença quando o nosso
resultado é um vetor com vários valores. Neste caso, o R sempre irá indicar, no início de
cada linha do console, qual é o primeiro valor da linha (se uma linha começar com [11],
por exemplo, isto quer dizer que o primeiro valor daquela linha é o 11º valor do vetor).
Agora siga adiante e faça algumas operações, para “sentir” um pouco o uso do R.
Para multiplicação use ‘*’, para divisão use ‘/’ e para calcular potências use o símbolo ‘^’
entre a base e o expoente (por exemplo, ‘2^3’ para dois elevado ao cubo). Lembre-se que
para o R executar qualquer tarefa você deve pressionar a tecla enter quando terminar de
escrever o comando desejado. Perceba, também, que o R entenderá o ponto como
separador decimal, e não a vírgula (este comportamento está associado apenas aos dados
6
inseridos diretamente no R; no caso de dados importados, o R normalmente segue a
configuração sobre separador decimal do computador, convertendo as vírgulas em pontos
sem problemas).
1.4. Usando funções no R

As operações matemáticas básicas são bem fáceis de executar, e envolvem apenas
a digitação dos operadores matemáticos em si. Mas é claro que o R permite ir além disso,
e realizar outras operações a partir do uso de suas funções. Todas as funções no R seguem
a mesma lógica de uso: basta digitar o nome da função seguido dos argumentos
necessários, que devem estar entre parênteses. Ao longo das apostilas nós vamos explorar
muitas funções, e seu uso ficará cada vez mais familiar. Sempre que você vir, ao longo
do texto, uma palavra em itálica seguida de “()”, estará diante de uma função.
Neste primeiro momento, vamos experimentar algumas funções matemáticas
simples. Experimente, por exemplo, calcular a raiz quadrada de um número usando a
função sqrt(). Se você digitar sqrt(16), por exemplo, estará calculando a raiz quadrada de
16. Agora vamos calcular um logaritmo com a função log(), digitando log(100,10), que é
o comando para se calcular o logaritmo de 100 na base 10. Note que como a função
precisou de dois argumentos, nós os separamos por uma vírgula, e este é um outro aspecto
geral das funções no R: os argumentos são sempre separados por vírgulas (você também
pode incluir espaços entre os argumentos, o que não afeta o seu funcionamento).
7
1.5. Usando os mecanismos de ajuda
No tópico anterior, usamos a função log, que utilizou dois argumentos: o número
e a base. Um questionamento que pode surgir é: como saber quais são os argumentos de
uma função? E a resposta é simples e muito útil: basta utilizar o mecanismo de ajuda do
R, que pode ser chamado digitando um ponto de interrogação seguido pelo nome da
função desejada. Experimente, então, usar o comando ?log. O resultado é uma nova
janela, aberta no navegador de internet, com informações da função log(). Tome algum
tempo para explorar o formato geral da página de ajuda, pois ela segue um padrão em
todas as funções. Um dos pedaços mais importantes das páginas de ajuda das funções fica
ao seu final: quase sempre há um ou mais exemplos de uso, o que é uma ótima ferramenta
para aprendizado.
A próxima pergunta provavelmente é: mas e se eu nem mesmo sei o nome da
função que desejo?! Aqui entra o mecanismo de busca do programa, que em sua versão
mais simples pode ser chamado com uma dupla interrogação seguida do termo a ser
buscado. Experimente, por exemplo, usar o comando ??variance (para buscar funções
que façam referência à palavra variância), e explore um pouco o resultado, composto por
diversas funções que se relacionam à palavra utilizada. Uma versão um pouco mais
completa desta mesma função é o help.search(), na qual termos com mais de uma palavra
poderão ser buscados, bastando estarem entre aspas simples. Experimente o comando
help.search(“linear regression”) e veja os resultados. Como toda documentação do R está
em inglês, lembre-se sempre em buscar utilizando as palavras neste idioma, ok?
8
Uma característica bacana do sistema de help do R é o seu funcionamento no
formato html, aberto pelo navegador de internet padrão do computador. Este sistema
permite que você possa abrir novas janelas ou abas usando os links (que aparecem como
palavras azuis grifadas) que aparecem em diversas palavras-chave que possuem páginas
de ajuda próprias. Desta forma, a partir de uma função você pode explorar outras
relacionadas, navegando de função em função. E não se engane: apesar de utilizar o
navegador, as páginas de ajuda estão todas em seu computador, então não há necessidade
de conexão com a internet.
1.6. Criando objetos

A linguagem R faz parte de uma categoria de linguagens de programação chamada
de “programação orientada a objetos”. A consequência prática para nós, meros mortais
usuários do programa, é que quase tudo o que desejarmos fazer no programa se
relacionará com algo que ele identifica como objeto. Um objeto será reconhecido como
um nome qualquer que nós mesmos atribuímos, e guardará “dentro” dele um conjunto de
informações. A criação de um objeto no R é simples e intuitiva: basta criar um nome e
“apontar uma seta” para ele. A tal seta é um comando chamado de assign, e é formada
por um traço (o sinal de menos do teclado) e o símbolo ‘>’ ou ‘<’ (a escolha do símbolo
depende da direção). Exemplificando, digite o comando: objeto1<-15. Se o R não der
nenhuma resposta, ele criou corretamente o objeto denominado “objeto1”, que é
9
composto pelo número 15. O fato do R ficar “silencioso” após o comando é normal: nós
mandamos o programa criar o objeto, e só; ele só iria exibir algum tipo de resultado se
fosse instruído para tanto. Se quiser, você pode dar o mesmo comando apontando a seta
para o outro lado, assim: 15->objeto1. O resultado é o mesmo.
Agora que criamos o objeto, podemos usá-lo à vontade. Por exemplo, podemos
“chamar” o objeto no R, simplesmente digitando seu nome e teclando enter. Experimente
fazer isso, e veja o resultado. Também podemos realizar operações matemáticas.
Experimente, por exemplo, digitar a operação objeto1*2. O R exibirá o resultado, mas
perceba que o objeto continua inalterado (basta chama-lo de novo e conferir). Isto
acontece porque nós apenas perguntamos ao R qual o resultado de se multiplicar o objeto
por 2. Se quisermos que ele armazene o resultado no lugar do número original, então o
comando seria: objeto1<-objeto1*2.
Note que ele apenas calculou o resultado...
... sem salvá-lo no objeto!
Aqui sim o resultado foi salvo no objeto.
Um comando simples, mas bastante importante, permite criar objetos com

sequências de valores (em um formato de vetor), e pode ser chamado no R simplesmente
com a letra c. Se precisarmos de um objeto com os números inteiros de 1 a 10, por
exemplo, poderíamos cria-lo assim: sequência<-c(1,2,3,4,5,6,7,8,9,10).
10
E nunca se esqueça: ao nomear um objeto no R, você sempre deverá chama-lo
pelo nome exatamente como foi criado. Se mudar uma letra maiúscula para minúscula,
um acento ou qualquer outro pequeno detalhe, o programa não irá entender. Por fim, o
comando ls() sempre pode ser chamado quando se quiser saber quais objetos estão na
memória.
Uma letra maiúscula faz toda a diferença.
E um simples acento também.
1.7. Importando uma planilha de dados para o R

Agora que já temos uma idéia de como criar e utilizar objetos, vamos dar um passo
além, e aprender a importar uma planilha de dados “para dentro” de um objeto do R. Esta
é uma tarefa importantíssima, pois na esmagadora maioria das vezes nós criamos uma
planilha de dados em um gerenciador de planilhas (como o Excel ou o Calc), que oferece
um ambiente voltado para organização e armazenamento de informações. O R oferece
diversos comandos que permitem a importação de dados, envolvendo diversos formatos
de arquivo diferentes. Como no dia à dia vocês podem se deparar com arquivos de
diferentes extensões, uma maneira de simplificar tudo é transformar os dados em um
formato chamado de “texto separado por tabulações” (com a extensão ‘.txt’), e importa-
los a partir daí. O processo de conversão de um formato de planilha para o txt com
tabulações é simples: podemos copiar e colar o conteúdo no bloco de notas e salvar
normalmente por lá; ou usar a função de ‘salvar como’ do gerenciador e selecionar o
formato apropriado.
11
Uma vez criado o arquivo, devemos primeiro indicar para o R a sua localização,
antes de importá-lo de fato. Este é um processo simples, feito pelo menu do R: basta
acessar o menu ‘Arquivo’ e selecionar a opção ‘Mudar dir...’, e selecionar o diretório
onde o arquivo se encontra (lembre-se de que o R não “verá” o arquivo, pois estamos
apenas selecionando o diretório). Este procedimento estabelece o que chamamos de
“diretório de trabalho”, e é um aspecto bem importante para termos um bom uso do
programa. Uma vez que o diretório de trabalho está estabelecido, tudo o que tentarmos
importar e tudo aquilo que exportarmos (ou seja, salvarmos “para fora” do R) será
automaticamente feito ali. Uma boa recomendação é criar uma pasta de fácil acesso, e
dentro dela criar subpastas para cada análise, projeto ou outra coisa relevante. E caso você
deseje definir o diretório de trabalho “manualmente”, veja as funções setwd() para
determinar o diretório e getwd() para saber qual o diretório atual.
Após a escolha do diretório desejado, caso queira você poderá conferir quais
arquivos estão salvos dentro dele com o comando dir(). Após conferir se o arquivo
desejado está ali, basta importá-lo para um objeto usando o comando read.table(). O
comando pede apenas um argumento obrigatório: o nome do arquivo (que deve estar entre
aspas e com a extensão). Mas usaremos outro argumento, este opcional: informaremos ao
R que a nossa planilha tem um cabeçalho, que é uma linha que identifica o nome das
variáveis. O comando completo, então, será: read.table(“nomedoarquivo.txt”,header=T).
O argumento header=T é a indicação de que existe um cabeçalho (o T é a abreviação de
TRUE).
12
Normalmente seguimos com um attach(planilha) para reconhecer as variáveis (veja na seção 2)!
Se por acaso você precisar abrir um arquivo que, por algum motivo, está fora do
seu diretório de trabalho, experimente usar a função file.choose() como argumento no
lugar do nome do arquivo, e veja o que acontece! Legal, não é?
Agora que conseguimos importar um conjunto de dados para o R, podemos
conferir o que foi importado. A maneira mais básica de se fazer isso é simples: basta
“chamar” o objeto que recebeu os dados. Este método, porém, não é lá muito prático, pois
todos os dados irão aparecer no console, o que não é útil para planilhas com muitas linhas
e/ou colunas. Vamos preferir, então, usar funções que permitam uma visão mais compacta
dos nossos dados. A função head() é uma delas: ela fará o R mostrar no console apenas
as seis primeiras linhas da tabela importada, permitindo, por exemplo, conferir os nomes
das variáveis. Outra função bastante útil é summary(), que nos dá algumas estatísticas
descritivas dos dados (o resultado exato depende da natureza das variáveis).
O comando summary() nos dá: para variáveis qualitativas, o número de vezes que
uma classe apareceu; e para variáveis quantitativas, o valor mínimo, o primeiro quartil, a
mediana, a média, o terceiro quartil e o valor máximo (nesta ordem).
13
Veja o resultado para uma variável categórica.
E para uma quantitativa.
1.8. Instalando e ativando pacotes no R

Agora que os aspectos mais gerais do R já foram cobertos, você já deve ser capaz
de usar o programa, tanto seguindo roteiros e sugestões de funções quanto descobrindo
por conta própria funções que possam fazer o que você precisa. Cedo ou tarde, entretanto,
você irá descobrir que o R é instalado apenas com um conjunto relativamente básico de
funções, o que pode tornar necessário o uso de um pacote. Um pacote do R é um conjunto
de funções compiladas juntas com um objetivo e/ou tema em comum. Há pacotes voltados
para análise de diversidade biológica (como o vegan e o biodiversityR, por exemplo),
pacotes para o uso de métodos filogenéticos comparativos (como o pacote ape), pacotes
com interface gráficas de usuário (como o Rcmdr), e muito mais.
Carregar um pacote que já esteja no seu computador é bem simples: basta usar o
comando library() com o nome do pacote. Caso você ainda precise instalar o pacote, uma
das maneiras mais simples é fazer isso pelo próprio R pelo menu ‘Pacotes’, na opção
‘Instalar Pacotes’. Esta função necessita que o computador tenha uma conexão com a
internet, e irá perguntar qual servidor usar para o pacote ser baixado. Uma vez baixado e
instalado, o pacote já estará na pasta adequada, e poderá ser carregado com a função
library().
Por fim, para saber qual o objetivo geral dos pacotes, você pode acessar a
homepage do R e, seguindo o mesmo caminho para baixar o programa, acessar o link
packages e acessar a opção “Table of avaliable packages, sorted by name”. Você verá,
em seguida, a lista de todos os pacotes oficiais do programa, com uma breve descrição do
seu propósito.
14
1.8.1. Pacotes com interface gráfica
O R possui alguns pacotes que, além de adicionar novas funções à nossa
disposição, adicionam novas maneiras de interagirmos com o programa ao criarem uma
nova janela de interface com o usuário. Dois pacotes são particularmente interessantes: o
Rcmdr e o GrapheR. O primeiro é focado na realização dos principais testes estatísticos,
e o segundo é voltado para a produção de gráficos. Se, por um lado, é fantástico termos
uma interface de usuário mais amigável, por outro devemos ter muita cautela de não
dependermos disso, pois pacotes com estes são sempre, por definição, limitados a
algumas funções. Uma boa maneira de usá-los é como uma ferramenta acessória no
aprendizado: ambos permitem que você veja os comandos das funções executadas, o que
pode ser muito útil para se aprender a usá-las. Em suma: vale à pena conhecê-los, mas
eles devem sempre ser usados com muita cautela, para que o usuário não acabe
dependendo completamente deles e acabe não dominando o uso do R.
1.9. Usando um script, inserindo comentários e salvando tudo

Comparado com a maioria dos outros softwares de estatística, o R pode ser
considerado um tanto exigente com o usuário, uma vez que praticamente todas as suas
funções devem ser executadas por linhas de comando. Para lidar com isso sem grandes
dificuldades, podemos nos aproveitar de algumas funcionalidades do programa: a
inserção de comentários, o uso de scripts e o armazenamento das informações do console.
Inserir comentários no R é uma tarefa bem simples: basta começar a linha com o
símbolo #, e tudo o que for escrito em seguida não será executado. É recomendável que
os comentários sejam usados durante o processo de aprendizado, na forma de lembretes
sobre o uso das funções. Eles também são bastante úteis durante a interpretação de
15
resultados de análises, pois permitem que o usuário anote as suas primeiras conclusões e
interpretações diretamente com os resultados.
No cotidiano do uso do R, é bem comum que precisemos fazer o mesmo

procedimento diversas vezes com diferentes conjuntos de dados. Isto pode se tornar bem
trabalhoso quando temos que repetir linhas de comando muito longas, o que torna muito
prático armazenar linhas prontas para que possam ser usadas novamente. O próprio
programa oferece uma maneira para trabalharmos diretamente com isso: os scripts. Criar
um script no R é bem fácil: vá no menu ‘Arquivo’ e selecione a opção ‘Novo script’. O
R então irá abrir uma janela em branco, onde podemos digitar o nosso script.
16
Um script do R é uma simples sequências de comandos (que podem incluir
comentários), que podem ser enviados para serem executados no console quando o
usuário assim o desejar. Basta selecionar a(s) linha(s) desejada(s) (ou selecionar todas
usando o atalho ctrl+a) e usar o atalho ctrl+r, e o console irá executar tudo. Uma vez que
a janela do script estiver selecionada, ele poderá ser salvo pelo menu ‘Arquivo’ na opção
‘Salvar’. Os arquivos de script do R são salvos como a extensão .R, mas podem ser abertos
pelo bloco de notas se for desejado.
Podemos criar scripts para diversas situações: para importação de dados,

carregamento de pacotes, execução de análises estatísticas, etc. É claro que o usuário deve
ficar atento para os nomes de arquivos, objetos e variáveis, pois quaisquer mudanças
podem impedir a execução correta do script. Uma dica é tentar, quando possível, usar
nomes “genéricos” de arquivos e objetos, evitando que o script tenha que ser muito
modificado a cada nova execução.
Por fim, após uma sessão de uso do R, é normalmente muito útil salvar tudo o que
se passou no console, para se ter registrados os procedimentos, seus resultados e os
eventuais comentários adicionados. Este é um procedimento bem simples: basta ir
novamente ao menu ‘Arquivo’ e selecionar a opção ‘salvar em arquivo’. O R então irá
salvar um arquivo de extensão .txt, que poderá ser aberto em qualquer editor de texto.
Caso você tenha problemas em abrir o arquivo depois de salvá-lo, verifique se o R inclui
a extensão; caso ele não a tenha incluído, basta renomear o arquivo incluindo a extensão
.txt no final do nome.
17
1.10. Resolvendo problemas comuns no R
AIMEUDEUSDOCÉUORNÃOFAZOQUEEUQUERO!!!!!1!!!
Calma, muita calma. Quando o R não faz o que queremos, ele normalmente nos
responde com uma mensagem de erro, que pode ser bastante informativa sobre o que está
acontecendo. Lembre-se sempre de ler com calma as mensagens de erro que surgirem, e
tentar interpretá-las, pois na imensa maioria das vezes a solução é bem simples. Na
medida em que nos habituamos com o programa, começamos a perceber quais são os
erros mais comuns, e as coisas vão ficando cada vez mais fáceis. Vamos ver, a seguir,
alguns dos erros mais comuns que costumamos ter com o R e como podemos solucioná-
los.
1.10.1. Objeto não encontrado
O erro acima ocorre quando tentamos fazer referência a um objeto que não existe.
Pode ocorrer quando nos esquecemos de importar os dados ou quando simplesmente
escrevemos errado o nome do objeto. Solução 1: confira quais objetos estão na
memória do R e quais os seus nomes com um ls().
O mesmo erro costuma aparecer quando importamos os dados mas nos

esquecemos de usar o comando attach() (veja-o na próxima seção) para que o R
reconheça os nomes das variáveis. Solução 2: use o comando attach() nos dados
importados.
18
1.10.2. Não foi possível encontrar a função “qualquer”
A mensagem é bem clara: você tentou chamar uma função que não existe.
Provavelmente você não digitou corretamente o nome da função. Solução 1: reveja o
que escreveu em busca de erros (fique atento ao detalhes, como letras maiúsculas e
símbolos).
Outra possibilidade é ter tentado chamar uma função de um pacote sem o ter
carregado previamente. Solução 2: use o comando library() para carregar o pacote
necessário.
1.10.3. Símbolo inesperado

Um erro comum, normalmente gerado quando erramos pontuação e/ou
espaçamento. No caso de objetos, costuma ocorrer quando adicionamos um espaço ou
símbolo que não existe no nome original (e o espaço é encarado como um símbolo pelo
R). Solução 1: novamente, confira o que você escreveu, e se necessário use o ls().
Quando associado à uma função, o mais provável é ter esquecido uma vírgula
entre os argumentos. Solução 2: confira o comando, e lembre-se de que todos os
argumentos de uma função devem ser separados por vírgula.
19
1.10.4. Tio, um danado de um “maiszinho” fica aparecendo no lugar do ‘>’!
Pois é, o famoso símbolo de “mais” atormenta muita gente, mas é algo muito
simples e não é um erro em si: ele surge como parte de uma funcionalidade do próprio R,
que é permitir que um comando seja escrito em várias linhas. Caso você esteja escrevendo
uma função bem longa, com muitos argumentos, o R permite que você a escreva aos
poucos, teclando enter entre um conjunto de argumentos caso ache necessário. Para isso
ser possível, basta que você tenha começado a escrever os argumentos e tecle enter antes
de fechar os parênteses daquela função ou aspas de uma parte da função; depois, basta
terminar de escrever e teclar enter novamente para que tudo volte ao normal.
Eventualmente erramos ao escrever uma função, e o símbolo de mais surge porque

esquecemos de fechar parênteses ou aspas. Se não for mais possível completar o
comando, basta teclar esc para que o R cancele o comando e volte para o prompt.
Aqui eu teclei esc, e ele voltou para o prompt
1.10.5. Orientações gerais

A maioria dos erros com os quais nos deparamos usando o R são coisas pequenas:
um errinho de digitação aqui, uma vírgula mal colocada ali, um parênteses não fechado
acolá, e por aí vai. Quando topar com um erro, então, sempre comece revisando com
calma todas as etapas que você seguiu, conferindo tudo o que você escreveu e
comparando com o que for relevante (nomes de arquivo ou de objetos, etc). Quase sempre
será bem fácil de resolver, e na medida em que descobrimos os nossos próprios erros
aprendemos mais e diminuímos a chance de cometê-los de novo. Agora, quando o erro
persiste e você não entende por quê, não há nada de errado em procurar ajuda! Fóruns na
internet, listas de discussão, colegas e professores: mais cedo ou mais tarde você irá
encontrar alguém que possa ajudar. Um dos aspectos mais interessantes do R é que existe
uma grande comunidade de usuários por trás do programa, e devemos saber usar isso a
nosso favor.
20
1.11. Funções utilizadas – seção 1
Vou resumir, a seguir, as funções que vimos até aqui:
+, -, *, / → operadores matemáticos
sqrt() → raiz quadrada
log() → logarítimo
?, ??, help.search() → mecanismos de ajuda
<-, -> → associa elementos (valores, nomes, planilhas, etc) a objetos do R
c → combina elementos em um vetor ou uma lista
ls() → lista os objetos na memória do R
dir() → lista os arquivos no diretório de trabalho
read.table() → lê uma planilhas em arquivo externo
head() → lista as seis primeiras linhas de uma planilha
summary() → resume as informações de um objeto do R
library() → carrega um pacote que já esteja no computador
# → permite a inserção de comentários
21
2. DADOS E GRÁFICOS
Nesta seção nós vamos lidar com conjuntos de dados no R, dando os primeiros
“passos estatísticos” com o programa. Especificamente, nós vamos aprender funções
básicas para sumarizar e manipular dados, além de aprender a criar os nossos primeiros
gráficos.
2.1. Reconhecendo variáveis de uma planilha

Na seção passada, aprendemos a usar a função read.table() para importar os dados
de uma planilha para o R, na forma de um objeto. O programa pode lidar com informações
em vários formatos, mas como o nosso foco é em estatística, vamos lidar com dados
organizados em planilhas nas quais as unidades amostrais estejam nas linhas e as variáveis
estejam nas colunas. Digitar os dados diretamente no R também seria possível, mas não
é lá muito prático, e o ideal é usar um bom e velho gerenciador de planilhas para isso.
Agora, se você estiver muito curioso, dê uma espiada nas funções data.frame(), edit() e
fix() para saber mais sobre como inserir dados diretamente no R, sem importação.
Uma vez que um conjunto de dados esteja inserido no R na forma de um objeto,
é conveniente que sejamos capazes de fazer o programa reconhecer as variáveis pelo seu
nome. Existem duas maneiras de fazer isso: a mais direta, sem usar funções
intermediárias, é usar o símbolo $. Basta escrever objeto$variável para que o R seja capaz
de entender a referência. Este detalhe sobre a linguagem do R pode ser bem útil na
manipulação de objetos que são gerados como resultado de análises estatísticas, então é
muito importante se lembrar disso. Já a outra maneira, que é bastante prática, é usar o
comando attach(), que faz com que todas as variáveis em uma planilha possam ser
identificadas pelo nome, da mesma forma que um objeto qualquer (mesmo que elas nãos
e transformem em objetos de fato). Há também, por fim, um comando que desfaz o
attach(): é o comando detach(). Este é um comando importante quando vamos lidar com
diversos conjuntos de dados diferentes em uma mesma seção do R.
22
Sem o attach(), a variável
não é reconhecida.
O detach() desfaz o que o attach() fez.
2.2. Medidas de tendência central e de dispersão

Na primeira parte deste guia, vimos que o comando summary() gera algumas
medidas descritivas sobre os nossos dados: a média, a mediana, os quartis e os valores
máximos e mínimos. Estas mesmas métricas podem ser calculadas individualmente, bem
como outras que podem ser úteis na descrição de conjuntos de dados.
Aqui estabelecemos os percentis que desejamos,

usando decimais.
23
As funções mean(), var() e sd() calculam, respectivamente, a média, a variância e
o desvio padrão. A função quantile() permite calcular a mediana, os quartis e quaisquer
percentis desejados (veja o exemplo para entender o uso desta última função).
2.3. Lidando com subconjunto de dados

O conjunto de dados que apareceu nos nossos exemplos até agora possui a variável
categórica “Ambiente”, que possui duas classes (que também podemos chamar de níveis).
Dado o contexto deste conjunto de dados, uma pergunta óbvia que poderia ser feita é: há
alguma diferença na riqueza média de espécies entre os dois tipos de ambiente? Nós
trataremos desta pergunta diretamente quando realizarmos um teste T, mas neste
momento seria interessante aprendermos como calcular as médias acima (como média e
desvio, por exemplo) de maneira restrita, de acordo com a nossa variável categórica. Para
fazer isso, vamos usar colchetes para criar condições no R. A sintaxe básica disso seria
algo como variável[condição], onde sinais como ‘>’, ‘<’ ou ‘==’ podem ser usados para
criar as condições desejadas. Lembre-se de que a igualdade deve ser sempre representada
com dois sinais de igual, e que os níveis de uma variável categórica devem sempre ser
representados entre aspas. Os exemplos a seguir devem ser o suficiente para se aprender
como usar este mecanismo.
Resultado usando apenas dados com

Ambiente da classe “secundário”.
Resultados usando apenas dados com

Área maior do que 100.
2.4. Estudando a distribuição de frequências de uma variável: o histograma

Os histogramas são gráficos que representam a distribuição de frequências dos
valores de uma variável quantitativa. Criá-los no R é bastante simples: basta usar a função
24
hist(). No uso básico da função o próprio R irá “decidir” em quantas classes dividir os
intervalos da variável, o que pode ser alterado pelo argumento breaks. Tome algum tempo
para explorar o help da função, dando especial atenção para os exemplos.
Usando o argumento breaks podemos

alterar o número de classes do
histograma.
2.5. Gráficos, gráficos, gráficos!

Se esta apostila representa o seu primeiro contato com o R, então parabéns: você
acaba de criar o seu primeiro gráfico neste programa! Este material não tem por objetivo
explorar as funcionalidades gráficas do R (que são imensas, por sinal), mas é conveniente
chamar a atenção para alguns detalhes.
Começando do começo: você deve ter notado que o R abriu uma nova janela
quando você executou o comando hist() para fazer o gráfico. Se você fechar a janela e
executar o comando novamente (ou executar um novo comando gráfico), uma nova janela
se abrirá. Se, por outro lado, você executar um novo comando sem fechar a janela, o novo
gráfico irá sobrescrever o anterior (e, neste caso, a janela não irá “pular” para a frente, e
continuará em segundo plano ou minimizada). Caso deseje salvar o gráfico, clique com o
botão direito do mouse sobre a imagem ou, com a janela em primeiro plano, vá ao menu
‘Arquivo’ e explore as opções disponíveis.
25
Existem muitos argumentos comuns a todas as funções gráficas do R, como xlab
e ylab (para dar nomes aos eixos), main (para atribuir títulos ao gráfico), axes (para se
adicionar ou remover os eixos) e muitas outras. A documentação de ajuda da função par()
é uma excelente fonte de informações sobre argumentos gerais que podem ser usados em
diversos gráficos diferentes. Ao explorar as funções gráficas do R, use e abuse dos
exemplos que aparecem nas páginas de ajuda, pois eles são uma das melhores maneiras
de se aprender. Caso esteja com dificuldades, tente criar seu gráfico passo à passo: crie
um gráfico básico e depois vá acrescentando, um a um, os argumentos desejados, até
chegar ao ponto ideal.
Usei o argumento main

para remover o título.
O nome veio como estava na planilha,

mas poderia ser mudado com xlab.
Vamos olhar agora, bem brevemente, para outros gráficos típicos da estatística.
Estes são gráficos que mostram a relação entre duas variáveis, situação na qual existe
uma convenção geral: sempre que existir uma variável explicativa (ou independente), ela
deve ser representada no eixo x, enquanto a variável resposta (ou dependente) deve ser
representada no y. A exceção, claro, são os gráficos de barras, nos quais o eixo y
representa apenas frequências, de maneira similar aos histogramas. Alguns destes
gráficos deles serão vistos novamente mais adiante, quando lidarmos com os testes
estatísticos, e na ocasião poderemos ver mais detalhes e argumentos conforme necessário.
26
2.5.1. Gráficos de dispersão
Os gráficos de dispersão representam a relação entre duas variáveis quantitativas.
Criá-los no R é extremamente simples: basta usar a função plot().
2.5.2. Gráficos de barras

Os gráficos de barras podem ser usados para representar uma ou duas variáveis
categóricas, e são construídos no R pela função barplot(). Em planilhas de dados comuns,
nas quais as linhas são as unidades amostrais e as colunas variáveis, a função table() é um
intermediário importante para chegarmos ao gráfico desejado. Veja o exemplo a seguir
para aprender o funcionamento básico da função (percebam que usei o argumento legend
para identificar as cores das colunas).
27
A ordem das variáveis faz
diferença! Experimente refazer
mudando a ordem e veja.
O argumento beside=T evita que as barras fiquem empilhadas.
2.5.3. Boxplots e gráficos de média com barras de erro

Quando desejamos comparar valores de uma variável quantitativa de acordo com
as classes determinadas por uma variável categórica, podemos usar gráficos que
representem alguma medida de tendência central acompanhada de uma ou mais medidas
de variação e/ou erro. A escolha de uma medida ou outra depende da natureza dos dados:
a média, por exemplo, é uma medida que não faz sentido em dados com uma distribuição
de frequência muito assimétrica.
Boxplots:
Uma das maneiras mais comuns de se representar medianas, normalmente
acompanhadas de quartis e/ou percentis, são os boxplots. Criá-los no R é feito com a
função boxplot(), como no exemplo a seguir (no qual usei alguns argumentos a mais para
modificar o gráfico básico). Para usar este comando, a relação entre as variáveis foi
determinada usando o símbolo ‘~’. Esta representação é bem comum no R, e irá aparecer
no uso de diversos modelos estatísticos. A lógica desta representação será sempre
‘variável_resposta~variável_explicativa’.
28
O argumento ylim foi usado para
estabelecer a escala do eixo y.
Médias e barras de desvio ou erro:

Para representarmos médias e alguma medida de desvio ou de erro, o mais comum
é usarmos um gráfico no qual a média é representada por um ponto (ou barra) e o desvio
ou erro por uma barra de variação em torno da média. Não há função básica no R para
conseguir isto diretamente, então temos que apelar para algum pacote que facilite este
processo.
A opção que é possivelmente a mais simples é utilizar a função
lineplot.CI() do pacote sciplot. Esta função cria um gráfico visualmente muito bom (e o
argumento type permite usar apenas os pontos, sem as linhas). O seu uso básico trabalha
apenas com barras que representem o erro padrão ou o intervalo de confiança, mas é
possível alterá-la para usarmos desvio padrão ou variância (veja os exemplos).
O argumento type é usado para se definir se

o gráfico terá linhas, pontos ou ambos.
Se não dissermos nada, as barras

são de erro padrão.
29
Neste último argumento mudei as barras
para o desvio. Use var() onde usei sd() para
ter o gráfico com as variâncias.
Uma outra possibilidade a função plotMeans() do pacote Rcmdr (que foi chamado
aqui apenas para usarmos esta função; não vamos explorar a sua janela de interface de
usuário, que pode ser fechada, mas fique à vontade para dar uma olhada no que ela
oferece). Neste caso, porém, perceba que a função não usará o ‘~’ em sua sintaxe. Uma
desvantagem desta função é que ela insere uma linha ligando as médias, e não há
argumento na função para removê-la.
O argumento error.bars define como

serão calculadas as barras; no
exemplo, foi o erro padrão.
Por fim, uma última opção é experimentar o pacote GrapheR. Este pacote oferece
uma interface gráfica de usuário voltada para a utilização de diversas funções gráficas do
R de maneira simplificada. É bastante útil durante para o aprendizado sobre gráficos no
R, e bem prático para produzirmos gráficos rápidos.
30
Vou resumir, a seguir, as funções que vimos nesta seção.
data.frame(), edit(), fix() → funções para se editar planilhas no R

$ → permite visualizar parte de um objeto (exemplo planilha$variável)
attach() → faz o R reconhecer os nomes das variáveis de uma planilha
detach() → desfaz o attach()
mean() → calcula a média aritmética
var() → calcula a variância amostral
sd() → calcula o desvio padrão amostral
quantile() → calcula percentis
[] → permite criar restrições ao se ver ou manipular um objeto ou variável
hist() → histogramas
par() → parâmetros gráficos gerais
plot() → gráficos de dispersão
barplot() → gráficos de barra
table() → tabelas de contingência
boxplot() → boxplots
plotMeans() → gráficos de média (pacote Rcmdr)
lineplot.CI() → gráficos de média (pacote sciplot)
31
3. ALGUNS TESTES ESTATÍSTICOS
Nesta seção vamos explorar alguns testes estatísticos básicos: o qui-quadrado, o
teste T, a ANOVA e a regressão linear. Esta seção, por ser a mais recente, ainda está um
pouco menos elaborada do que as duas primeiras, e ainda deve ser bastante modificada e
expandida.
3.1. A escolha de um teste estatístico

A escolha de um teste é definida, em parte, pela natureza das variáveis estudadas
e a sua (presumida) relação. O quadro a seguir é um resumo um pouco grosseiro de como
é feita esta escolha:
Var. explicativa
Categórica Quantitativa
Var. Categórica Qui-quadrado Regressão logística
resposta Quantitativa Teste T / ANOVA Regressão linear
Com exceção do teste de qui-quadrado, os demais três testes que veremos são
ditos paramétricos, e dependem de alguns pressupostos para que seus resultados sejam
considerados confiáveis. Quando for relevante, então, apresentarei métodos para se
verificar os pressupostos do teste no próprio R, e é recomendável que estas verificações
façam parte da sua rotina de testes estatísticos, uma vez que um pressuposto violado pode
inutilizar o resultado de um teste. Como sempre, não vou entrar em detalhes (já que o
nosso foco está na execução no R), e recomendo a leitura de livros de estatística para mais
detalhes. Nunca se esqueça de que tentar realizar um teste estatístico que você não domina
gera uma chance enorme de que os resultados sejam completamente equivocados!
3.2. O teste de qui-quadrado

Uma possível associação entre duas variáveis categóricas pode ser facilmente
visualizada se organizarmos os dados em uma tabela de contingência, que mostra a
contagem do número de vezes que cada par de categorias apareceram juntos. No R,
podemos associar as duas variáveis categóricas com a função table() (que vimos na
prática anterior ao construirmos um gráfico de barras) e, em seguida, testar a significância
desta associação pelo teste de Qui-quadrado com a função chisq.test(). A função mostra,
como resultado, o valor de qui-quadrado, os graus de liberdade e o valor de p.
32
Em muitos casos (e este não é uma exceção), é interessante associar o resultado
de um teste a um novo objeto, pois isto permite explorar resultados que não seriam
mostrados com a simples execução da função. No caso do teste de qui-quadrado, podemos
desejar ver, por exemplo, os valores das frequências esperadas por acaso. Se associarmos
o resultado do teste a um objeto e o inspecionarmos com a função summary(), notaremos
que existem vários componentes, e que um deles contém estes valores: o componente
expected. Observe, no exemplo a seguir, como podemos usar o símbolo ‘$’ para ter acesso
a estes valores (eu disse que ele seria útil!).
Por fim, para compreendermos o resultado do teste, é essencial investigarmos os
dados em si, o que normalmente é feito de forma gráfica. Veja o exemplo de gráfico de
barras na apostila anterior.
33
3.2.1. Pressupostos do qui-quadrado
O teste de qui-quadrado apresenta pressupostos bem simples, e não são
necessários métodos específicos para verifica-los. O mais básico é um pressuposto
comum a quase todos os testes: o de que as observações (ou seja, as unidades amostrais)
sejam independentes. Além deste pressuposto geral, devemos observar se a tabela de
contingência possui no máximo 20% dos seus valores menores do que cinco. Se este
pressuposto for violado, o resultado do teste não é confiável.
3.3. O teste t de Student

O teste t possui três variantes básicas: a mais usada é normalmente chamada de
teste t para amostras independentes, e permite a comparação de duas médias; o teste t para
uma amostra compara uma média com um valor fixo; e o teste t pareado (ou teste t para
amostras dependentes) compara médias de unidades amostrais dependentes aos pares.
Todos estas variações do teste t podem ser executadas no R pela função t.test(), e o uso
do teste t pareado e do teste t para uma amostra pode ser ativado com o uso dos
argumentos paired e mu, respectivamente, como pode ser visto nos exemplos a seguir.
Usualmente, o resultado de um teste t vem acompanhado de uma representação
gráfica. Veja o exemplo de gráfico de médias com barras de erro na apostila anterior.
Com var.equal=T, informamos que presumimos

variâncias homogêneas.
34
O argumento mu permite o teste t para
uma amostra.
O argumento paired define o teste

como pareado.
3.3.1. Pressupostos do teste t

O teste t possui dois pressupostos básicos sobre a variável quantitativa: que as
suas variâncias sejam homogêneas e que os dados não difiram significativamente da
distribuição normal. Ambos podem ser testados rapidamente no R, pelos testes de Levene
e de Shapiro-Wilk, respectivamente. O teste de Levene para homogeneidade de variância
pode ser feito com o comando leveneTest(), do pacote car, enquanto o teste de Shapiro-
Wilk para normalidade pode ser chamado pela função shapiro.test(). Note que para ambos
os testes nós “queremos” a hipótese nula! O que acontece é que o teste de Levene tem
como hipótese nula a homogeneidade das variâncias, e o teste de Shapiro-Wilk tem como
hipótese nula a normalidade dos dados; ou seja, os pressupostos do teste t serão aceitos
se os testes mencionados não rejeitarem a H0.
Se o pressuposto da homogeneidade de variâncias for rejeitado (ou seja, se
rejeitarmos a hipótese nula do teste de Levene), há uma saída prática: existe uma versão
do teste t que considera variâncias heterogêneas. Na prática, isto está automaticamente
feito no comando t.test(), a não ser que o usuário acrescente o argumento var.equal=T
35
(como fizemos no exemplo acima). Ou seja, se nada for dito, o R já fara o teste t para
variâncias heterogêneas. Mas lembre-se de que esta variação de teste t “gasta” mais graus
de liberdade, então é sempre vantajoso usar o teste t tradicional (com var.equal=T) caso
as variâncias sejam homogêneas.
Já no caso da rejeição do pressuposto de normalidade (que deve ser testado, aliás,

para os dados agrupados nos dois grupos a serem comparados, como foi feito no exemplo
acima), uma saída é recorrer a um teste não paramétrico. Não vamos explorar esta saída
36
aqui, mas caso você deseje conhecê-la, veja a documentação do comando wilcox.test()
para saber mais sobre o teste de Mann-Whitney.
3.4. A análise de variância (ANOVA)

A ANOVA é uma grande família de testes, e neste guia veremos a sua versão mais
simples, normalmente chamada de one-way ANOVA. Assim como o teste t, este é um
teste para comparação de médias, com a diferença de que na ANOVA nós vamos
comparar três ou mais classes da variável categórica (ou níveis do fator, na terminologia
específica desta análise). A ANOVA faz parte de uma família ainda maior de análises,
que chamamos de modelos lineares. O R lida com todos os modelos lineares de maneira
similar, e um detalhe importante é que todas as análises desta família devem ser salvas
em um objeto, para seu resultado ser apresentado após o comando summary(). No caso
da ANOVA, a função para realizar a análise é aov(). Veja o exemplo a seguir para
compreender seu uso.
Perceba que a hipótese nula da ANOVA é de que as médias não diferem. Ao

rejeitá-la, então, nós apenas sabemos que pelo menos duas das médias são diferentes entre
si, mas não sabemos quais são. Existem duas formas principais de seguir adiante com a
investigação: as comparações planejadas e os testes a posteriori. A primeira é bem mais
interessante de um ponto de vista “filosófico”, pois envolve perguntas diretas sobre quais
médias são diferentes de quais, ao invés de comparar todas com todas; e a segunda, por
outro lado, é justamente a execução de todas as comparações possíveis. De uma forma
geral, os testes a posteriori são bem mais comuns na literatura científica, e por este motivo
37
utilizo um como exemplo a seguir: é o teste de Tukey, chamado pela função TukeyHSD(),
que atua diretamente no objeto com o resultado da ANOVA.
O objeto usado deve ser o próprio

modelo da ANOVA realizada.
Por fim, a interpretação final do resultado de uma ANOVA costuma ser

acompanhada por uma representação gráfica. Assim como no teste t, veja na apostila
anterior o exemplo de gráfico de médias com barras de erro.
3.4.1. Pressupostos da ANOVA

A análise de variância (assim como todos os modelos lineares) presume
homogeneidade de variâncias e normalidade dos resíduos da análise (perceba que a
normalidade não precisa ser verificada nos dados em si, apenas nos resíduos). Estes
pressupostos, então, podem ser verificados com os mesmos comandos usados nos
pressupostos do teste t. A diferença aqui é que os resíduos devem ser usados na
normalidade, e eles podem ser encontrados como um “sub-objeto” $residuals no objeto
com o resultado da ANOVA. Veja o exemplo a seguir.
38
3.5. A regressão linear simples
A regressão linear simples testa a existência de uma relação linear de causa e efeito
entre uma variável explicativa e outra resposta, ambas quantitativas. Também faz parte
da família dos modelos lineares. No R, pode ser chamado pelo comando lm(). Veja o
exemplo a seguir, com os mesmos dados que foram usados no gráfico de dispersão da
apostila anterior.
Os resultados são parecidos com os de uma ANOVA, mas conta com alguns
detalhes a mais. No exemplo acima, a linha (Intercept) refere-se ao intercepto da equação
linear (o b, na equação y = ax + b), e verifica a hipótese nula de que ele seria igual a zero;
de uma forma geral, nós raramente nos preocupamos com a esta parte do resultado, pois
o intercepto normalmente não faz parte da nossa pergunta. Já a linha abaixo, com o nome
da variável explicativa, é sempre do nosso interesse: ela verifica a hipótese nula de que o
parâmetro a da equação seja igual a zero; ou seja, ao rejeitarmos a hipótese nula nós
concluímos que de fato há uma relação estatisticamente significativa entre as duas
variáveis, e que o efeito desta relação é medido por este parâmetro. No exemplo acima, o
teste rejeita a hipótese nula de que a riqueza de espécies não varia em função da área do
fragmento de mata, e o resultado da regressão permite concluirmos que, em média, cada
incremento de uma unidade de área aumenta a riqueza em 0,13885. Por fim, a
interpretação da correlação, que está representada no parâmetro Adjusted R-squared
também é importante. No exemplo acima, diríamos que 39,46% da riqueza de espécies é
explicada pelo tamanho da área dos fragmentos.
39
Os resultados de uma regressão linear que rejeita a hipótese nula são comumente
apresentados com uma representação gráfica que mostra os dados (em um gráfico de
dispersão) e a equação (na forma de uma reta). Para adicionar a reta da equação ao gráfico
criado pelo comando plot(), basta, com o gráfico aberto, executar o comando abline(),
fazendo referência ao objeto que contém o resultado da regressão. Veja o exemplo a
seguir.
3.5.1. Pressupostos da regressão linear simples

Uma regressão pressupõe homocedasticidade dos dados (equivalente à
homogeneidade de variâncias, mas aqui não temos classes para comparar) e normalidade
dos resíduos. O primeiro é verificado visualmente, comparando os resultados esperados
pela regressão com os resíduos da análise, enquanto o segundo pode ser verificado com
o teste de Shapiro-Wilk. Não vamos entrar em detalhes sobre isto nesta apostila, então
veja o exemplo da verificação visual da homocedasticidade a seguir e busque mais
informações em um bom livro de estatística.
40
Vou resumir, a seguir, as funções que vimos nesta seção.
chisq.test() → teste de Qui-quadrado

t.test() → teste T (argumentos paired e mu podem ser usados para se obter o T pareado
ou o T para uma amostra, respectivamente)
aov() → ANOVA (simples e outras variantes, só depende de como o modelo é construído)
TukeyHSD() → Teste a posteriori de Tukey para a ANOVA
lm() → regressão linear simples (ou outros modelos lineares, só depende de como o
modelo é construído)
shapiro.test() → Teste de normalidade
leveneTest() → Teste de homogeneidade de variâncias
abline() → Adicionar linha (como a de um modelo) a um gráfico
41
ANEXO 1: DADOS UTILIZADOS
Caso você não tenha os arquivos com os dados utilizados nos exemplos desta
apostila, basta copiar e colar o texto da caixa correspondente no console do R e pronto!
Dados do arquivo “pratica1.txt”:
dados<-structure(list(UA = 1:50, Ambiente = structure(c(1L, 1L, 1L,
1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L,
2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L), .Label = c("primário",
"secundário"), class = "factor"), Área = c(101L, 115L, 143L,
92L, 51L, 89L, 128L, 149L, 127L, 108L, 83L, 140L, 163L, 41L,
107L, 79L, 104L, 60L, 82L, 148L, 97L, 49L, 164L, 110L, 51L, 40L,
92L, 163L, 128L, 130L, 122L, 96L, 59L, 73L, 90L, 48L, 166L, 121L,
167L, 48L, 78L, 105L, 90L, 105L, 166L, 84L, 57L, 81L, 122L, 112L
), Riqueza = c(35L, 31L, 39L, 25L, 22L, 35L, 43L, 48L, 35L, 38L,
32L, 33L, 40L, 16L, 31L, 23L, 32L, 35L, 22L, 41L, 24L, 18L, 39L,
32L, 19L, 20L, 31L, 26L, 20L, 33L, 36L, 32L, 28L, 23L, 28L, 16L,
44L, 27L, 37L, 24L, 19L, 28L, 27L, 28L, 27L, 20L, 34L, 20L, 31L,
14L), Abund_sp1 = c(3L, 3L, 1L, 6L, 1L, 0L, 3L, 5L, 0L, 2L, 0L,
0L, 1L, 3L, 3L, 4L, 1L, 0L)), .Names = c("UA", "Ambiente", "Área",
"Riqueza", "Abund_sp1"), class = "data.frame", row.names = c(NA,
-50L))
#Pronto, os dados estão salvos no objeto ‘dados’; pressione enter siga adiante!
42
Dados do arquivo “fumo.txt”; as letras estão pequenas, mas está tudo aí!
dados<-structure(list(Fumo = structure(c(2L, 2L, 2L, 2L, 2L, 2L, 2L,

2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L,
3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L), .Label = c("Moderado",
"Não", "Pesado"), class = "factor"), Câncer = structure(c(1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L,
1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L,
2L, 2L), .Label = c("Não", "Sim"), class = "factor")), .Names = c("Fumo", "Câncer"), class = "data.frame", row.names = c(NA, -1011L))
43
Dados do arquivo “peixes.txt” (no exemplo de ANOVA):
dados<-structure(list(Predador = structure(c(3L, 3L, 3L, 3L, 3L, 3L,
2L, 2L, 2L), .Label = c("Libélula", "Nenhum", "Peixe"), class = "factor"),
Densidade = c(10.4993, 17.6714, 11.1032, 4.6647, 18.9767,
14.2042, 14.8269, 11.8394, 20.9545, 7.3108, 20.2219, 21.4057,
19.6589, 9.9067, 14.5693, 11.037, 11.1047, 4.9696, 7.7347,
16.9973, 7.6902, 10.1636, 1.9043, 1.767, 12.1435)), .Names = c("Predador",
"Densidade"), class = "data.frame", row.names = c(NA, -25L))

Introdução Ao Software R para Biologia - Marcos Vital UFAL - V26!09!2013

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Introdução Ao Software R para Biologia - Marcos Vital UFAL - V26!09!2013

Enviado por

Direitos autorais:

Formatos disponíveis

1

1.1. Obtendo e instalando o software.

1.1.1 Usando o R com um IDE

1.2. Primeiro contato.

1.3. O R como uma calculadora

O programa, então, executa a operação e apresenta o resultado. Temos que chamar

1.4. Usando funções no R

1.6. Criando objetos

Note que ele apenas calculou o resultado...

... sem salvá-lo no objeto!

Aqui sim o resultado foi salvo no objeto.

Um comando simples, mas bastante importante, permite criar objetos com

Uma letra maiúscula faz toda a diferença.

E um simples acento também.

1.7. Importando uma planilha de dados para o R

E para uma quantitativa.

1.8. Instalando e ativando pacotes no R

1.9. Usando um script, inserindo comentários e salvando tudo

No cotidiano do uso do R, é bem comum que precisemos fazer o mesmo

Podemos criar scripts para diversas situações: para importação de dados,

1.10.1. Objeto não encontrado

O mesmo erro costuma aparecer quando importamos os dados mas nos

1.10.3. Símbolo inesperado

Eventualmente erramos ao escrever uma função, e o símbolo de mais surge porque

Aqui eu teclei esc, e ele voltou para o prompt

1.10.5. Orientações gerais

2.1. Reconhecendo variáveis de uma planilha

O detach() desfaz o que o attach() fez.

2.2. Medidas de tendência central e de dispersão

Aqui estabelecemos os percentis que desejamos,

2.3. Lidando com subconjunto de dados

Resultado usando apenas dados com

Resultados usando apenas dados com

2.4. Estudando a distribuição de frequências de uma variável: o histograma

Usando o argumento breaks podemos

2.5. Gráficos, gráficos, gráficos!

Usei o argumento main

O nome veio como estava na planilha,

2.5.2. Gráficos de barras

O argumento beside=T evita que as barras fiquem empilhadas.

2.5.3. Boxplots e gráficos de média com barras de erro

Médias e barras de desvio ou erro:

O argumento type é usado para se definir se

Se não dissermos nada, as barras

O argumento error.bars define como

data.frame(), edit(), fix() → funções para se editar planilhas no R

3.1. A escolha de um teste estatístico

3.2. O teste de qui-quadrado

3.3. O teste t de Student

Com var.equal=T, informamos que presumimos

O argumento paired define o teste

3.3.1. Pressupostos do teste t

Já no caso da rejeição do pressuposto de normalidade (que deve ser testado, aliás,

3.4. A análise de variância (ANOVA)

Perceba que a hipótese nula da ANOVA é de que as médias não diferem. Ao

O objeto usado deve ser o próprio

Por fim, a interpretação final do resultado de uma ANOVA costuma ser

3.4.1. Pressupostos da ANOVA

3.5.1. Pressupostos da regressão linear simples

chisq.test() → teste de Qui-quadrado

Dados do arquivo “pratica1.txt”:

dados<-structure(list(UA = 1:50, Ambiente = structure(c(1L, 1L, 1L,

"secundário"), class = "factor"), Área = c(101L, 115L, 143L,