matematicaEstatisticaIpmaia Rstudio

Matemática e Estatística
CTeSP Tecnologias e Programação de Sistemas de Informação
Alexandre Sousa (avs@ismai.pt)
Setembro 2019
A linguagem R
Análise de dados
Programação em R
Objetivos (Usando Excel e R)

Aceder a dados textuais e numéricos provenientes de
fontes diversas (ficheiros Excel, bases de dados, ficheiros
de texto com uma dada estrutura)
Limpar os dados (adicionar dados em falta, corrigir ou
apagar dados errados, alterar os dados de modo a
passarem a estar num formato mais útil)
Anotar os dados (de modo a saber a que é que
correspondem)
Sumariar os dados (estatísticas para ajudar a caracterizar
os dados)
Visualizar os dados (gráficos)
Modelar os dados (descobrir relações e testar hipóteses)
Preparar os resultados (criar tabelas e gráficos
apropriados para publicação num relatório)
CTeSP TPSI Matemática e Estatística 2 / 174
A linguagem R
Análise de dados
Programação em R
Índice
1 A linguagem R
História do R
Usar o R
Exemplos
2 Análise de dados
Tipos de dados e operações básicas em R
Vector, Matrix, Array, List
Factor, Data frame, Ausência de valores
3 Programação em R
Estruturas de controle de fluxo e funções em R
Funções estatísticas em R
Gráficos em R usando ggplot2

A linguagem R História do R
Análise de dados Usar o R
Programação em R Exemplos
Origens do R
R é um dialecto da linguagem S
S é uma linguagem cujo desenvolvimento se iniciou em
1976 por John Chambers e outros do Bell Labs, tratava-se
de um ambiente para análise estatística implementado
como um conjunto de bibliotecas em Fortran. Em 1988 o
systema foi reescrito na linguagem C (versão 3), e em
1998 apareceu a versão 4.
Em 1993 Bell Labs forneceu a StatSci (que agora se
chama Insightful Corp.) uma licença exclusiva para
desenvolver e vender a linguagem S. Em 2004 Insightful
comprou à Lucent (Bell Labs) a linguagem S por $2M.
Insightful vende a sua implementação da linguagem S
usando o nome S-PLUS

Origens do R (cont.)
A linguagem R foi criada na Nova Zelândia por Ross Ihaka
e Robert Gentleman em 1991, como uma variante do S.
Em 1993 a linguagem R foi anunciada para o público em
geral
Em 1995 a linguagem R passa a ser open source (GNU
General Public License)
Em 1997 é criado o Core Group do R
Em 2000 aparece o R 1.0
Em 2013 aparece o R 3.0 (versão 3.6.1 em 5-Jul-2019)
A sintaxe do R é parecida com a do S-PLUS mas a
semântica é bastante diferente
R existe para muitas plataformas incluindo Windows / Mac
OS X / Linux / (como o Android é uma variante do Linux
existe a possibilidade de se compilar o R para Android)
Origens do R (cont.2)
O R encontra-se em desenvolvimento activo e é

potencialmente o ambiente open source para cálculo
estatístico mais difundido e mais interessante.
Existem muitos livros publicados sobre o uso do R em
diversos contextos e muitos sistemas de desenvolvimento
possuem um interface para o R (Mathematica, Python, etc)
Principais desvantagens do R
Os objectos têm de ser armazenados em memória RAM o
que limita a dimensão máxima desses objectos
Pouco suporte para gráficos dinâmicos (embora exista o
http://www.rstudio.com/shiny/) ou gráficos 3D

The Comprehensive R Archive Network

O R consiste no “base R system” e num conjunto de
packages auxiliares
O “base R system” contém os pacotes base, utils,
stats, datasets, graphics, grDevices, grid,
methods, tools, parallel, compiler,
splines, tcltk, stats4
As recommended packages são: boot, class,
cluster, codetools, foreign, KernSmooth,
lattice, mgcv, nlme, rpart, survival, MASS,
spatial, nnet, Matrix
Existem 14925 packages no CRAN (Comprehensive R
Archive Network): http://cran.r-project.org
http://cran.dcc.fc.up.pt/web/packages/
O R Studio (www.rstudio.com) é um ambiente de
desenvolvimento integrado para o R
Instalar o R
Em Windows, em Mac OS X, ou em Linux:

Instalar o R
http://www.r-project.org
(neste momento existe a versão 3.6.1 de Julho 2019)
A seguir instalar o ambiente de desenvolvimento RStudio
http://www.rstudio.com
(neste momento existe a versão 1.2.1578)
Em Linux (testado em Debian, Ubuntu, e RedHat/CentOS)
pode-se igualmente instalar o RStudio server para
remotamente, via um browser, se poder usar o RStudio
(fica disponível para os utilizadores da máquina usando o
respectivo username e password que tenham no sistema
operativo): https://www.rstudio.com/ide/server/

Usar o R
getwd(), get working directory, fornece o directório onde
vai procurar os ficheiros que se mandar abrir
setwd("c:/users/avs/dados"), set working
directory, altera o directório de trabalho, usar / mesmo em
Windows
sink("output.txt"), redirecciona o output (não afecta
os gráficos) para um ficheiro de texto, se o ficheiro já
existir escreve por cima, sink("output.txt",
append=TRUE) escreve a partir do fim do ficheiro,
sink("output.txt", append=TRUE, split=TRUE)
escreve simultaneamente para o ecrã e para o ficheiro
sink() redirecciona output de novo somente para o ecrã
Nas strings pode-se usar aspas simples ou duplas mas é
preferível usar aspas duplas, isto é, só usar aspas simples
nas strings que tem texto com aspas duplas
Usar o R (cont.)
pdf("imagem.pdf") redirecciona o output gráfico para
um ficheiro PDF. Pode-se também usar
jpeg("imagem.jpg"), png("imagem.png"),
win.metafile("imagem.wmf")ou
postscript("imagem.eps") com ps.options() e
setEPS()
dev.off() faz flush do ficheiro e reset do output gráfico
para passar a vir somente para o ecrã
source("ficheiro.R"), executa os comandos R que
se encontrarem dentro desse ficheiro
ls(), lista objectos do workspace (não são os ficheiros
mas sim os objectos criados no ambiente de trabalho)
rm(nome) ou rm("nome") remove do workspace o
objecto, rm(list=ls()) remove a maioria dos objectos
neste momento existentes no workspace (liberta memória)
Usar o R (cont.2)
install.packages("nome") instala um novo package,
seguidamente é necessário fazer library(nome) para o
carregar
old.packages() informa que packages podem ser
actualizados (mas não actualiza)
update.packages() actualiza todos os packages que
estejam instalados
installed.packages() diz o nome e a versão dos
packages instalados
library() fornece nome e descrição duma linha dos
packages instalados
help(package="packageName") dá a ajuda do
package incluindo índice das novas funções, depois
pode-se usar help(...) para cada uma dessas funções
R.version diz qual é a versão do R
Usar o R (cont.3)
Executar expressão R ou programa R em comandos.R a
partir da shell (linha de comando do sistema operativo):
Rscript -e ’installed.packages()’
Rscript comandos.R
q(): sair do R
help.start(): ajuda inicial do R
help(foo) ou ?foo fornece o help da função foo
vignette(package="foo"): docs extra do package foo
apropos("foo"): devolve vector com todos os objectos
que contém o texto foo (isto é que possuem um match
parcial no nome foo)
??foo ou help.search("foo"): procura a expressão
regular foo na documentação de todos os packages
RSiteSearch("foo"): abre browser e procura foo no
site do R
Usar o R (cont.4)
Pode-se alterar a prompt do R ou do RStudio usando

options(prompt="R> ")
A prioridade das operações em R é da esquerda para a
direita e nesta ordem de prioridade: Parêntesis,
Expoentes, Multiplicação e Divisão, Adição e Subtração
(PEMDAS)
O R considera que um número negativo é uma operação
aritmética, isto é, interpreta -2 como sendo -1 * 2, por
isso é necessário colocar parêntesis à volta de (-2)^4
para obter o valor correto de 16, se não o fizermos
obtemos -16
Usa-se e para representar um número na notação
científica: 2.1567e12, o que representa 2.1567 × 1012

Exemplo 1: analizar relação Idade vs Peso
Idade (meses) Peso (Kg)

1 4.4
3 5.3
5 7.2
2 5.2
11 8.5
9 7.3
3 6.0
9 10.4
12 10.2
3 6.1
Criar 2 vectores, um para cada um dos dois tipos de dados:

> idade = c(1, 3, 5, 2, 11, 9, 3, 9, 12, 3)
> peso=c(4.4,5.3,7.2,5.2,8.5,7.3,6,10.4,10.2,6.1)
Exemplo 1: analizar relação Idade vs Peso (cont.)

Calcular a média (mean) do peso:
> mean(peso)
Calcular o desvio padrão (standard deviation) do peso:
> sd(peso)
Calcular a correlação (correlation) entre idade e peso:
> cor(idade, peso)
Criar gráfico de pontos (scatter plot) para cada par idade,
peso:
> plot(idade, peso) ou
> plot(idade,peso,type="b") para unir com linhas
Para escrever a imagem para um ficheiro executar estes 3
comandos:
> pdf("grafico.pdf")
> plot(idade, peso)
> dev.off()
Exemplo 1: analizar relação Idade vs Peso (cont.2)

10
9
8
peso
7
6
5
2 4 6 8 10 12
idade
Figure: plot(idade, peso)

Exemplo 1: analizar relação Idade vs Peso (cont.3)
Sumariar (resultado depende do formato dos dados):

> summary(peso); summary(idade)
(fornece mín, 1o quartil, mediana, média, 3o quartil e máx)
¯ ¯
Em estatística um quartil é qualquer um dos três valores
que divide o conjunto ordenado de dados em quatro partes
iguais, e assim cada parte representa 1/4 da amostra ou
população. No caso duma amostra ordenada, o primeiro
quartil (designado por Q1/4 ou quartil inferior) é o valor até
aos 25% da amostra ordenada, o segundo quartil
(designado por Q2/4 ou mediana) é o valor até ao qual se
encontra 50% da amostra ordenada, o terceiro quartil
(designado por Q3/4 ou quartil superior) é o valor a partir
do qual se encontram 25% dos valores mais elevados)

Exemplo 2: pessoas com excesso de peso
O índice da massa corporal imc é definido como sendo o

peso em kg dividido pelo quadrado da altura em metros,
22.5 é o valor considerado normal. Eis um exemplo com
dados de 6 pessoas:
> peso <- c(60, 72, 57, 90, 95, 72)
> altura<- c(1.75,1.80,1.65,1.90,1.74,1.91)
> imc <- peso / altura ^ 2
> plot(altura, peso)
> xx<-seq(min(altura),max(altura),0.05) # x
> lines(xx, 22.5 * xx ^2) # os y correspondentes
Do gráfico conclui-se que 2 pessoas têm excesso de peso
Embora não pareça, a linha não é uma recta mas sim uma
curva (y = 22.5 × x 2 , onde x é a altura e y o peso ideal)

Exemplo 2: pessoas com excesso de peso (cont.)
90
●
80
peso
● ●
70
60
1.65 1.70 1.75 1.80 1.85 1.90
altura
Figure: plot(peso, altura); lines(xx, 22.5 * xx ^ 2)

Complementar gráfico c/ elementos adicionais

points(x, y) adiciona um ponto ao gráfico
text(x, y, labels) adiciona texto ao gráfico
abline(a, b) adiciona a linha y = a + bx
abline(h=y) adiciona linha horizontal na coordenada y
abline(v=x) adiciona linha vertical na coordenada x
segments(x0, y0, x1, y1) desenha segmentos de
recta entre pares de pontos
arrows(x0,y0,x1,y1) setas entre pares de pontos
symbols(x,y, ) desenha círculos, quadrados, etc
legend(x, y, legend) adiciona uma legenda
title(principal, subtitulo, xLabel, yLabel)
adiciona o título principal, subtítulo, legenda para o eixo do
x e legenda para o eixo do y
axis(side, at, labels) adiciona um eixo
grid() adiciona uma grid
Complementar gráfico c/ elementos adicionais (cont.)
Ver o texto de help associado a ?par (set or query

graphical parameters)
Pode-se usar plot(..., las=2) para que a legenda no
x seja colocada com letras na vertical (na realidade
está-se é a dizer que a legenda deve ser sempre
perpendicular ao eixo), é útil quando se trata de nomes e
se isso não fosse feito o texto não cabia ou não aparecia a
legenda para todos os nomes
Se mesmo quando se usa las=2 o tamanho da letra é
excessivo face à largura do gráfico pode-se usar por
exemplo cex.axis=0.8 e cex.lab=0.8 para reduzir
para 80% o tamanho da letra utilizada nas legendas

A linguagem R Tipos de dados e operações básicas em R
Análise de dados Vector, Matrix, Array, List
Programação em R Factor, Data frame, Ausência de valores
Tipos de dados em R
Tipos primitivos:
character: "Ana Silva" ou ’Ana Silva’ (texto)
numeric: 12.4 (no real) ou -45 (apesar de ser inteiro)
¯
integer: -45L (no inteiro, sufixo L força armazenamento
¯
inteiro, ver class() e mode() de -45 versus -45L)
complex: 3 + 7i (números imaginários)
boolean: TRUE ou FALSE (pode-se também usar: T, F)
Tipos compostos:
vector: conjunto indexável de objectos do mesmo tipo
matrix: vector duplo (2 dimensões, linhas x colunas)
array: matriz podendo ter mais do que 2 dimensões
list: conjunto indexável de objectos que podem ser de
tipos diferentes
data.frame: tabela em que cada coluna tem um tipo
factor: vector de inteiros onde a cada inteiro corresponde
um nome, para representar categorias (enum, masculino e
feminino em vez de 0 e 1)
Booleanos
T e F são abreviaturas para TRUE e FALSE, infelizmente

ao contrário de TRUE e FALSE, T e F são variáveis
pré-definidas pelo que é possível que o utilizador por
engano as use como variáveis e atribua valores a elas, o
que pode ter consequências graves na correção do que for
executado a seguir
Embora T e F correspondam aos valores 1 e 0 (isto é, se
fizermos operações aritméticas com eles são convertidos
para esses valores), e embora no sentido inverso 1||0 dê
T e 0&&1 dê F, não é a mesma coisa usar valores
booleanos ou usar inteiros como índices de vectores ou
matrizes

Representação de datas em R
Usa-se as.Date("2016-09-15") para converter um
string para uma data, e usa-se as.character(aData)
para converter no sentido contrário
Pode-se criar uma data marcando uma origem e dando
depois um no negativo (no de dias antes dessa data) ou
¯ ¯
positivo (no de dias depois dessa data):
¯
as.Date(-100, origin="2016-01-31")
as.Date(12, origin="2016-01-31")
Sys.Date() dá a data atual, date() a data atual
incluindo hh:mm:ss, datas podem ser subtraídas entre si
Para formatar uma data usa-se por exemplo
format(Sys.Date(), format="%B %d %Y"), onde
%d dia de 1 a 31, %a dia da semana abreviado e %A não
abreviado, %m mês de 1 a 12, %b mês abreviado e %B não
abreviado, %y ano com 2 dígitos e %Y com 4 dígitos
Representação de datas em R (cont.)

As datas usam o formato ano, mês, dia: "2016-09-25"
ou "2016/09/25" (nunca usar "25-09-2016")
Para extrair o ano, mês ou dia de datas podemos usar o
package gdata (necessita da linguagem perl,
descarregar e instalar por exemplo o “active perl ”):
> install.packages("gdata")
> library(gdata)
> dataAtual <- Sys.Date()
> getYear(dataAtual)
[1] "2016"
e da mesma forma podemos usar getMonth() (número
de 1 a 12) e getDay() (número de 1 a 31)
Não esquecer que estas funções têm de ser aplicadas a
uma data, pelo que se tivermos uma string teremos de
primeiro convertê-la para uma data usando as.Date()
Análise de dados em R
O vector é o objecto mais básico do R para guardar dados
Preparar dados para poderem ser analisados envolve:
Seleccionar a estrutura de dados onde se vai colocar os
dados
Importar os dados dum ficheiro para a estrutura de dados
Um dataset (conjunto de dados) é normalmente uma
tabela onde as linhas representam observações e as
colunas representam variáveis:
Linhas / Registos / Observações / Exemplos
Colunas / Campos / Variáveis / Atributos
Em R um objecto é qualquer coisa que pode ser
armazenada numa variável, podem ser constantes,
estruturas de dados, funções ou grafos. Os objectos têm
um mode() que descreve como o objecto é armazenado,
e uma class() utilizada por funções genéricas tais como
print() para saber como o objecto deve ser tratado
Especificidades do R
Nomes de objectos (variáveis): começar com uma letra e
depois uma combinação de letras, dígitos, ou o ponto
O ponto “.” não tem significado especial nos nomes, o $ é
semelhante ao ponto noutras linguagens orientadas a
objectos: A$x quer dizer variável x no data frame A
Tipos especiais do R: NaN (Not a Number), Inf (infinity,
1/0=Inf), -Inf, NA (Not Available), NULL (objecto nulo)
O símbolo # indica início dum comentário que se estende
até ao fim da linha, não existem comentários multi-linha
mas pode-se usar “if (FALSE) {...}” para comentar
um fragmento de código
Se se atribuir valores a um elemento não existente de um
vector, list, matrix, ou array, a estrutura é
expandida de modo a acomodar o novo valor, os valores
intermédios ficam com o valor NA (Not Available)
Especificidades do R (cont.)
Ao contrário da maioria das linguagens de programação
os índices das estruturas de dados começam em 1 em vez
de em 0
O R é sensível à diferença entre maiúsculas e minúsculas,
por exemplo help() funciona mas Help() dá erro
(função desconhecida)
No R ou no R Studio após se escrever o início do nome de
uma função pode-se usar a tecla tab para preencher
automaticamente o resto do nome da função ou mostrar a
lista de nomes possíveis
Para se aceder à documentação do R e se obter help
sobre como utilizar uma função coloca-se um ? antes do
nome da função: ?mode, ?is.integer
Todas as expressões em R devolvem um valor (pode ser
NULL), às vezes o valor é invisível pelo que não é impresso
Especificidades do R (cont.2)
O R suporta 3 tipos de operadores para efectuar a
atribuição de um valor (isto é colocar um valor numa
variável), pelo que estas 3 instruções são equivalentes
embora seja preferível usar somente a primeira forma:
x <- 5
x = 5
5 -> x
(x <- 5) atribuir valor e também imprimir o resultado
Atenção que “x = c(-12, -14, -20, -34)” seguido
de x[x < -15] dá como resultado “[1] -20 -34” mas
“x[x <-15]” devido à falta do espaço destrói o valor do x
dando o resultado “[1] NA” e o x passa a valer “[1] 15”
Operadores nas condições: == (igualdade), !=
(desigualdade), < (menor), > (maior), <= (menor ou igual),
>= (maior ou igual), & (e lógico), | (ou), ! (negação)
Especificidades do R (cont.3)
Atenção ao escolher os nomes das variáveis já que os

nomes pré-definidos do R podem ficar escondidos. Por
exemplo no R estão pré-definidos diversos nomes só com
uma letra: c, q, t, C, D, F, I, T, embora só F (abreviatura
para FALSE) e T (abreviatura para TRUE) sejam variáveis,
os outros são funções pelo que serem reutilizados no
programa do utilizador causa menos problemas
Pode-se fazer aritmética com vectores de tamanhos
diferentes (o caso mais comum é um dos vectores ter
tamanho 1), nesse caso o vector mais curto é reutilizado
de uma forma cíclica, dando um aviso se o tamanho do
maior não for um múltiplo do tamanho do menor

Usar rep() para gerar valores com padrão de repetição

rep(x, n) gera vector com elemento x repetido n vezes
rep(5, 4) gera vector com 5, 5, 5, 5
rep(x=c(10,20,7), times=3) ou
rep(x=c(10,20,7), 3) gera vector com
10, 20, 7, 10, 20, 7, 10, 20, 7
rep(x=c(10,20,7), each=4) gera vector com
10, 10, 10, 10, 20, 20, 20, 20, 7, 7, 7, 7
rep(x=c(10,20,7)) gera vector com 10, 20, 7
porque times e each por omissão valem 1
Pode-se igualmente usar o argumento length.out para
definir o tamanho total do vector, se necessário o vector é
truncado para ficar com esse tamanho
rep(x=c(10,20), times=3, length.out=5) gera
vector 10, 20, 10, 20, 10
Usar rep() para gerar valores com padrão de repetição

(cont.)
No rep() pode-se também usar em simultâneo times e

each, por exemplo rep(x=c(3, 62, 8.3), times=3,
each=2) gera o vector 3.0, 3.0, 62.0, 62.0, 8.3,
8.3, 3.0, 3.0, 62.0, 62.0, 8.3, 8.3, 3.0,
3.0, 62.0, 62.0, 8.3, 8.3
E pode-se até usar em simultâneo times, each, e
length.out, por exemplo rep(x=c(3, 62, 8.3),
times=3, each=2, length.out=11) gera o vector
3.0, 3.0, 62.0, 62.0, 8.3, 8.3, 3.0, 3.0,
62.0, 62.0, 8.3
em que os resultados que ultrapassavam o comprimento
pretendido são simplesmente truncados

Usar seq(from,to,by) para gerar sequência de valores

seq(10,15) é equivalente a 10:15 e qualquer um deles
gera o vector 10, 11, 12, 13, 14, 15
seq(10,15,2) ou seq(10,14,2) gera vector 10,12,14
Pode-se usar variáveis e parêntesis ao usar o : para
representar sequências de valores, por exemplo se x=4
então 2:(x+1) gera o vector 2, 3, 4, 5
seq(10, 15, 0.5) cria um vector com a sequência de
valores entre 10 e 15 avançando de 0.5 em 0.5
seq(10, 4, -2) gera o vector 10, 8, 6, 4
seq(10, 15, length.out=4) cria um vector com 4
elementos igualmente espaçados entre 10 e 15, isto é,
10.00000, 11.66667, 13.33333, 15.00000
seq(5, 2) gera o vector 5, 4, 3, 2, isto é, se o 2o
¯
argumento for menor que o 1o gera uma sequência
¯
decrescente, isto pode ser um pouco inesperado
Programação em R
O “&&” e o “||” são usados em instruções condicionais na
parte relativa à programação, por exemplo
“if (x < 4 && y > 0) { ... } else { ... }”
Ciclos: for (k in 1:10) { print(k)}
k <- 1; while (k < 10) {print(k); k<-k+1}
Definir uma nova função com 3 argumentos:
f1 <- function(a, b, somar=TRUE) {
if (somar) a + b else 0
}
o último argumento não necesita de ser fornecido dado
possuir um valor por omissão, os argumentos são dados
de acordo com a sua ordem, ou usando os seus nomes e
ignorando a ordem: f1(b=2, a=4) ou f1(4, 2)
args(f1) fornece os nomes dos argumentos da função,
“...” representa um no variável de argumentos
¯
Aritmética com valores escalares

Valores escalares
> x <- 3
> x
[1] 3
> x ^ x
[1] 27
Notas
O > representa a prompt do R Studio, operadores
aritméticos: -, +, *, /, ^ (potência), %/% (divisão inteira),
%% (resto da divisão inteira)
R converte elementos individuais (escalares) para vectores
só com 1 elemento, é por isso que imprime o [1] para
representar o índice do 1o (e único) elemento do vector
¯
Aritmética com valores escalares (cont.)

Valores escalares (nos inteiros versus nos reais)
¯ ¯
> x <- 3
> mode(x)
[1] "numeric"
> y <- 5L
> mode(y)
[1] "numeric"
> is.integer(x)
[1] FALSE
> is.integer(y)
[1] TRUE
Mesmo quando se fornece um inteiro ele é armazenado

como um valor real excepto se se colocar o sufixo L,
normalmente não vale a pena colocar o L
Vector
Num vector todos os dados têm de ser do mesmo tipo, os
vectors podem ser numéricos, lógicos ou de caracteres
Um vector vazio pode ser criado usando vector()
Se se tentar misturar no mesmo vector dados de tipos
diferentes, o R converte alguns desses dados, de modo a
ficarem todos os dados com o mesmo tipo
Para se criar um vector usa-se a função c(), que permite
combinar os seus argumentos num vector ou numa lista
> x <- c(12, 15, 17, 30:38, 70)
> x
[1] 12 15 17 30 31 32 33 34 35 36 37 38 70
Para se saber o tipo de um vector usa-se a função mode(),
usa-se length() para se saber o seu tamanho
Somar (+), subtrair (-), multiplicar (*) ou dividir (/) vetores:
x <- 1:4; y <- 6:9; x + y
[1] 7 9 11 13
Vector (cont.)
Para multiplicar todos os elementos dum vector por um
valor escalar multiplica-se o vector pelo valor pretendido:
> x <- c(2:8) # bastava: x <- 2:8
> x
[1] 2 3 4 5 6 7 8
> y <- x * 10
> y
[1] 20 30 40 50 60 70 80
Acede-se a valores específicos do vector indexando:
> x[2]
[1] 3
> x[3:5]
[1] 4 5 6
> x[c(2, 4, 7)]
[1] 3 5 8
Vector (cont.2)
Em alternativa pode-se atribuir nomes às posições
(índices) do vector ao se criar o vector ou a posteriori:
temperaturas <- c(braga=32.4, porto=24.6,
coimbra=31, lisboa=29)
temperaturas <- c(32.4, 24.6, 31, 29)
names(temperaturas) <- c("braga", "porto",
"coimbra", "lisboa")
Resultado:
> temperaturas
braga porto coimbra lisboa
32.4 24.6 31.0 29.0
> temperaturas[1] ou temperaturas["braga"]
braga
32.4
names(temperatura) devolve vector com os nomes ou
NULL se não houver nomes
Vector (cont.3)
Se se tiver um vector x de tamanho 5 (índices de 1 a 5) e
se fizer x[8] <- 2 então o vector é estendido para poder
comportar esse novo valor e os 2 valores em falta (nos
índices 6 e 7) são preenchidos com NA
Se se tiver um vector de inteiros e se atribuir a uma das
posições do vector um string (character) então todos os
valores do vector são convertidos para character
Para apagar a posição 2 do vector e reduzir o seu
tamanho de uma unidade fazer x <- x[-2]
Para apagar as posições 3 e 9 do vector e reduzir o seu
tamanho de duas unidade fazer x <- x[c(-3, -9)]
Dado um vector x substituir todos os seus elementos pelo
valor 2: x[] <- 2 (a ausência de uma condição dentro
do [] significa seleccionar todos)
Vector (cont.4)
Dado um vector x substituir todos os seus elementos

maiores que 10 pelo valor 100: x[x > 10] <- 100
Para se contar a quantidade de elementos de cada valor
existentes num vector pode-se usar a função table()
> z <- c(10, 15, 20, 7, 4, 2, 10, 4, 10)
> table(z)
z
2 4 7 10 15 20
1 2 1 3 1 1

Conversão de Vector para Matrix

Um vector pode ser convertido para matrix atribuindo
valores às dimensões do vector:
> x <- c(1:10)
> x
[1] 1 2 3 4 5 6 7 8 9 10
> dim(x)
NULL
> dim(x) <- c(2, 5) # atribuir dimensões ao vector
> dim(x)
[1] 2 5
> x
[,1] [,2] [,3] [,4] [,5]
[1,] 1 3 5 7 9
[2,] 2 4 6 8 10
Valores ficaram de cima para baixo da esq. para a direita
Indexar vector c/ índices positivos e negativos

v <- c(5, -2.3, 4, 5, 6, 7, 8, 10, 40, -7)
v[length(v):7]
[1] -7 40 10 8
isto é, podemos indexar de trás para a frente
indexes <- c(4, rep(x=2,times=3),1,1,2,3:1)
v[indexes]
[1] 5.0 -2.3 -2.3 -2.3 5.0 5.0 -2.3
[8] 4.0 -2.3 5.0
isto é, podemos repetir índices, pelo que não estamos a
indexar no sentido estrito do termo, estamos a criar um
novo vector de qualquer tamanho e que inclui alguns dos
elementos do vector inicial na ordem que quisermos
v[-c(1,3)]
[1] -2.3 5.0 6.0 7.0 8.0 10.0 40.0 -7.0
remove o 1o e o 3o elemento do vector
¯ ¯
Indexar vector c/ índices positivos e negativos (cont.)

Não se pode misturar índices positivos e negativos na
mesma indexação, se usarmos índices positivos estamos
a dizer que elementos queremos, se usarmos índices
negativos estamos a dizer que elementos queremos
removidos (podemos misturar zeros com valores
negativos, ou misturar zeros com valores positivos, em
ambos os casos os zeros são ignorados)
Podemos igualmente indexar de modo a alterar alguns dos
valores do vector inicial:
v[2] <- 9 coloca 9 no 2o elemento
¯
v[c(2,4,6)] <- 9 coloca 9 no 2o, 4o e 6o elementos
¯ ¯ ¯
v[c(2,4,6)] <- c(-6,-5,-4) coloca -6 no 2o, -5 no
¯
4o e -4 no 6o elemento, isto é, ao substituir podemos
¯ ¯
especificar um único valor ou podemos especificar tantos
valores diferentes quantos os índices
Combinar 2 vectors intercalando os valores
Se tivermos 2 vectors x e y com a mesma quantidade de

elementos e os quisermos combinar num único vector de
tal forma que os valores sejam alternadamente obtidos do
1o e do 2o vectors, fazemos c(rbind(x, y))
¯ ¯
> x = c(1,2,3,4,5)
> y = c(6,7,8,9,10)
> c(rbind(x,y))
[1] 1 6 2 7 3 8 4 9 5 10
isto funciona porque
> rbind(x,y)
[,1] [,2] [,3] [,4] [,5]
x 1 2 3 4 5
y 6 7 8 9 10

Matrix
A matrix é um array bidimensional em que todos os

elementos têm o mesmo modo (numeric, character ou
logic)
“x <- matrix(oVector, nrow=n, ncol=m,
byrow=TRUE)”, cria a matriz x com os dados de oVector
ficando com n linhas e m colunas e preenchendo os dados
ao longo da linha (se o argumento opcional byrow não for
dado ele vale FALSE pelo que preenche usando os dados
de oVector distribuindo-os ao longo das colunas)
Para indexar um elemento da matriz usa-se x[l,c] em
que o primeiro índice l é o no da linha e o segundo índice
¯
c é o no da coluna
¯

Matrix (cont.)
O outro argumento opcional de matrix denominado
dimnames=list(rowNames, colNames) permite
atribuir nomes às linhas e às colunas:
> x <- matrix(1:20, nrow=4, ncol=5,
byrow=TRUE, dimnames=list(c("R1", "R2",
"R3", "R4"), c("c1", "c2", "c3", "c4",
"c5")))
> x
c1 c2 c3 c4 c5
R1 1 2 3 4 5
R2 6 7 8 9 10
R3 11 12 13 14 15
R4 16 17 18 19 20
Agora pode-se usar x[2,4] ou x["R2","c4"] para
obter o 9
Matrix (cont.2)
Uma matriz pode também ser criada usando a função

cbind() que combina por colunas ou rbind() que
combina por linhas (rows):
> x <- 1:3
> y <- 10:12
> cbind(x, y)
x y
[1,] 1 10
[2,] 2 11
[3,] 3 12
> rbind(x, y)
[,1] [,2], [,3]
x 1 2 3
y 10 11 12
Matrix (cont.3)
Aritmética com matrizes:

> x<-matrix(1:4,2,2);y<-matrix(rep(10,4),2,2)
> x * y ## multiplicação elemento a elemento
[,1] [,2]
[1,] 10 30
[2,] 20 40
> x / y ## divisão elemento a elemento
[,1] [,2]
[1,] 0.1 0.3
[2,] 0.2 0.4
> x %*% y ## verdadeira multiplicação de matrizes
[,1] [,2]
[1,] 40 40
[2,] 60 60

Matriz identidade
A matriz identidade é uma matriz quadrada que contém 1’s

na sua diagonal principal e 0’s nas restantes posições
Pode-se criar uma matriz identidade de tamanho n usando
diag(n)
Note-se que diag(x) depende do tipo do argumento x,
se x for um número inteiro positivo então diag(x) cria
uma matriz identidade de tamanho x, se x for uma matriz
então diag(x) devolve os valores que se encontrarem na
diagonal principal da matriz

Indexar matrix c/ índices positivos e negativos

Para extrair uma célula usar x[linha,coluna] onde
linha é o no da linha e coluna é o no da coluna
¯ ¯
Para extrair uma linha completa usar x[linha,] onde
linha é o no da linha
¯
Para extrair uma coluna completa usar x[,coluna] onde
coluna é o no da coluna
¯
Em x<-matrix(1:12, 4, 3) se quisermos:
Extrair a 1a e a 3a colunas completas: x[,c(1,3)]
¯ ¯
Extrair da 2a à 4a linha completas: x[2:4,] ou
¯ ¯
x[c(2,3,4),] ou x[c(2:4),] (não esquecer a vírgula
após o fechar parêntesis)
Pode-se usar como índice um no negativo ou um conjunto
¯
de nos negativos quando se quer todos elementos excepto
¯
esses: x[-2] devolve vector c/ todos excepto x[2,1],
x[,-2] matrix c/ todos excepto 2a coluna,
¯
x[c(-2,-4),] matrix c/ todos excepto 2a e 4a linhas
¯ ¯
Indexar matrix c/ índices positivos e negativos (cont.)

Nas matrizes, se os índices forem tais que selecionam um
único elemento, o resultado é o vector com esse
elemento, se pretendermos que o resultado seja uma
matriz que contenha somente um elemento temos de
adicionar o argumento adicional drop=FALSE:
x[1, 2, drop=FALSE]
Da mesma forma quando se extrai uma linha ou uma
coluna de uma matriz o resultado é um vector, se
quisermos, no caso de uma matriz z de n linhas por m
colunas, extrair a segunda coluna e que o resultado seja
uma matriz com n linhas e 1 coluna, temos de fazer
z[,2,drop=FALSE], e se quisermos extrair a terceira
linha e que o resultado seja uma matriz com 1 linha e m
colunas temos de fazer z[3„drop=FALSE] (atenção à
dupla vírgula)
Array
Um array é semelhante a uma matriz (todos os elementos

têm de ser do mesmo tipo), mas pode ter mais do que 2
dimensões
> dim1 <- c("A1", "A2")
> dim2 <- c("B1", "B2", "B3")
> dim3 <- c("C1", "C2", "C3", "C4", "C5")
> a <- array(1:30, c(2, 3, 5),
dimnames=list(dim1, dim2, dim3))
> a["A2","B2",]
C1 C2 C3 C4 C5
4 10 16 22 28

Indexar array
Indexar num array é semelhante a indexar numa matrix, o
que é importante é colocar corretamente as vírgulas como
separadores das dimensões que se querem aceder
Dado o array a<-array(1:30,c(2,3,5)) se fizermos:
a[2„3] obtemos vector com a segunda linha da terceira
camada
a[2,c(3,1),4] obtemos vector com a terceira e a
primeira colunas (nesta ordem) da segunda linha, da
quarta camada
a[1„] obtemos uma matrix com as primeiras linhas de
cada camada, só que cada uma dessas linhas aparece
como uma coluna da matrix resultado (quando múltiplos
vectors são extraídos de um array por omissão são
devolvidos como colunas)
a[-1„] obtemos uma matrix com todas exceto as
primeiras linhas de cada camada (só que devolvidas como
colunas)
Indexar vector ou matrix usando condições

Num vector ou matriz x pode-se igualmente extrair valores
indexando com uma condição relacionada com os valores
propriamente ditos, o resultado é um vector com os
valores que verificam a condição:
x[x > 10] devolve vector com elementos maiores que 10
x[x > 10 & x < 18] devolve vector com os elementos
maiores do que 10 e menores do que 18
x[x < 10 | x > 18] devolve vector com os elementos
menores do que 10 ou maiores do que 18
Nestes casos atenção ao uso de espaços de modo a que
“x[x < -15]” não seja escrito “x[x<-15]” porque isso
origina uma atribuição que não era pretendida dando o
resultado errado e destruindo o valor de x
b <- x > 10 cria vector/matriz de booleanos com as
mesmas dimensões que x, cada valor é TRUE / FALSE
consoante o valor em x verifica ou não a condição
Indexar vector ou matrix usando condições (cont.)

Se numa condição compararmos 2 vectores de tamanho
diferente os dados do vector mais pequeno são reciclados
de modo a poder comparar todos os elementos do vector
maior: v1 <- 10:29, v2 <- c(8,40), o resultado de
v1 > v2 é TRUE FALSE TRUE FALSE TRUE FALSE
TRUE FALSE TRUE FALSE TRUE FALSE TRUE FALSE
TRUE FALSE TRUE FALSE TRUE FALSE
É por esta razão que ao compararmos um vector contra
um único valor obtemos o resultado que obtemos (esse
único valor é reciclado tantas as vezes quanto o tamanho
do vector)
Quando temos um vector de booleanos a função any()
devolve TRUE se pelo existir pelo menos um TRUE e a
função all() devolve TRUE se todos forem TRUE
Indexar vector ou matrix usando condições (cont2.)

Eis um exemplo da utilização de any() e all():
> x <- c(10, 20, 30, 40)
> y <- c(11, 21, 32, 45)
> z <- c(30, 40) # vai ser reciclado
> x < z
[1] TRUE TRUE FALSE FALSE
> any(x < z)
[1] TRUE
> all(x < z)
[1] FALSE
> all(y > x)
[1] TRUE
desta forma duma forma expedita verificamos os
elementos existentes num vector de booleanos no
contexto de compararmos os elementos de 2 vectors.
Indexar vector ou matrix usando condições (cont3.)

Ao indexar um vector com um vector de booleanos com
tantos elementos quantos o vector (pode expandir usando
reciclagem de valores) obtemos o sub vector que contém
somente os valores indexados com o booleano TRUE:
> x <- c(10, 20, 30, 40)
> x[T] # vai ser reciclado
[1] 10 20 30 40
> x[F] # vai ser reciclado
numeric(0) # vector vazio !
> x[c(T,F)] # vai ser reciclado
[1] 10 30
> x[c(T,F,F,T)]
[1] 10 40
> x[x < 15 | x == 40]
[1] 10 40
As 2 versões dos operadores lógicos

Os operadores lógicos ou (|| versus |), e (&& versus &)
existem em 2 versões:
As versões mais curtas devolvem um vector de booleanos,
são apropriadas para comparar 2 vectores elemento a
elemento, o resultado é um vector de booleanos com tantos
elementos quantos os vectores que se esteve a comparar
As versões longas devolvem um único valor booleano, são
apropriadas para comparar dois elementos únicos, se
forem aplicadas a dois vectores comparam somente o
primeiro elemento de cada vector (o que não é
provavelmente o que se pretendia)
Ao se comparar um único elemento (em vez de um vector)
podia-se usar as versões curtas mas deve-se usar
preferencialmente as versões longas para salientar que se
quer um único resultado
A negação (not) exprime-se usando !
List
Uma lista é um vector genérico podendo conter valores de
tipos diferentes, é criado usando a função list()
> x <- list(12,c("alfa","beta"),TRUE,5:9)
> x
[[1]]
[1] 12
[[2]]
[1] "alfa" "beta"
[[3]]
[1] TRUE
[[4]]
[1] 5 6 7 8 9
List (cont.)
Para se obter um elemento da lista indexa-se usando
duplos parentesis rectos:
> x <- list(12,c("alfa","beta"),TRUE,5:9)
> x[[4]]
[1] 5 6 7 8 9
Usando somente um par de parentesis rectos obtém-se a
sublista com o elemento que se encontra nesse índice:
> x[4]
[[1]]
[1] 5 6 7 8 9
Portanto a diferença é que x[[...]] devolve um
elemento da lista, enquanto que x[...] devolve uma lista
Para se obter uma sublista com o 2o e o 4o elementos da
¯ ¯
lista usa-se x[c(2,4)]
List (cont.2)
Os elementos da lista podem ser acedidos pelo nome se
ao se criar a lista se atribuir um nome a cada um deles
> x <- list(nome="Ana Silva", morada="Rua
Nova 17", telefone=229866123)
> x
$nome
[1] "Ana Silva"
$morada
[1] "Rua Nova 17"
$telefone
[1] 229866123
Agora pode-se usar x[["telefone"]] ou x$telefone
ou x[[3]] para obter o valor do telefone
List (cont.3)
Duas formas de extrair um elemento de uma lista de listas:
> x<-list(a=list(10,12,15),b=c(3.14,2.81))
> x[[c(1, 3)]]
[1] 15
> x[[1]][[3]]
[1] 15
Adicionar um novo elemento a uma lista: basta atribuir um valor
a um novo nome ou a um novo índice, a lista expande para
incluir esse novo valor: “x$novoNome <- novoValor” ou
“x[[novoIndice]] <- novoValor”
Fazer append a uma lista: x[length(x) + 1] <- y
Remover um elemento de uma lista: basta atribuir NULL a esse
elemento (x[[y]] <- NULL), após isso ser feito os índices a
seguir a y reduzem-se todos de 1 unidade
Para converter uma lista num vector usa-se unlist(), esta
função achata a lista e efectua todas as conversões que forem
necessárias
Factor
As variáveis podem ser descritas como sendo nominais,
ordinais, e contínuas:
Variáveis nominais representam categorias, não possum
uma ordem implícita (ex.: mobiliário, ferramenta, viatura)
Variáveis ordinais representam categorias ordenadas,
possuem uma ordem implícita mas não possuem um valor
numérico (ex.: mau, medíocre, suficiente, bom, excelente)
Variáveis contínuas podem tomar qualquer valor dentro de
um dado intervalo, e possuem uma ordem implícita e um
valor numérico associado (ex: a idade, 12 ou 12.4 ou 13)
Em R as variáveis do tipo categoria ou do tipo categoria
ordenada são representadas usando factor
A função factor() associa aos valores das categorias
um vector de inteiros de 1 a n, onde n é a quantidade de
valores diferentes que essa variável toma, por omissão a
atribuição de índices aos nomes é por ordem alfabética
Factor (cont.)
No caso de categorias converte-se simplesmente para

factor:
> material <- c("mobília", "ferramenta",
"ferramenta", "viatura")
> m <- factor(material)
No caso de categorias ordenadas usa-se order=TRUE e
se a ordenação por ordem alfabética não servir usa-se
também levels=c(...) para dizer a ordem:
> estado <- c("mau", "bom", "mau",
"suficiente")
> e <- factor(estado, order=TRUE,
levels=c("mau", "suficiente", "bom"))

Factor (cont.2)
Se um factor tiver um conjunto de valores e alguns desses

valores não se encontrarem presentes na amostra, ao se
criar o factor usa-se levels para explicitar os valores em
falta (explicitando igualmente a sua ordenação se for caso
disso):
amostra <- factor(c("baixo", "médio",
"baixo"), levels=c("alto", "médio",
"baixo"), order=TRUE)
No caso de se ter um vector de números que representam
codificações de categorias converte-se para factor usando
labels para fornecer os nomes das categorias:
estado <- factor(c(1, 2, 1, 2, 2, 1),
labels=c("mau", "suficiente"))

Factor (cont.3)
Se se criar um factor a partir de um vector que possui
valores que não existem nos levels, então os valores em
falta são substituídos por NA
Em alternativa a se fornecer os levels, para remover
(substituir por NA) valores do factor que se encontravam no
vector a partir do qual ele está a ser criado, usa-se
exclude, isto é factor(..., exclude=c(...)),
esses valores são substituídos por NA
x é um factor e quer-se remover todos os levels que não
estão a ser usados: x <- factor(x, exclude=NULL)
Em casos muito especiais pode-se também usar NA nos
levels do factor x, por omissão este fica a ser o último
level. Mas isto tem algumas limitações e deve ser evitado,
até porque para se ter também NA nos valores tem-se de
usar a atribuição is.na(x)[i] <- TRUE (ver ?factor)
Factor (cont.4)
Para se saber a quantidade de elementos presentes em

cada level do factor usar a função table, isto é,
table(x)
> x <- factor(c("f", "m", "f", "f"))
> table(x)
x
f m
3 1

Factor (cont.5)
A função table também pode ser usada para fazer uma

tabulação cruzada de 2 factor’s, desde que estes tenham o
mesmo tamanho
> sexo <- factor(c("f", "m", "f", "f"))
> idade <- factor(c("adulto", "adulto",
"jovem", "adulto"))
> table(sexo, idade)
idade
sexo adulto jovem
f 2 1
m 1 0

Factor (cont.6)
Podemos obter os códigos numéricos com unclass():

> x<-factor(c("yes","yes","no","yes","no"))
> x
[1] yes yes no yes no
Levels: no yes
> table(x)
x
no yes
2 3
> unclass(x)
[1] 2 2 1 2 1
attr(,"levels")
[1] "no" "yes"

Factor (cont.7)
Para se obter a frequência marginal (no total de

¯
ocorrências de cada tipo) usa-se margin.table dando
como segundo argumento 1 para obter os totais por linha
(dado essa ser a 1a dimensão do objecto) ou 2 para obter
¯
os totais por coluna
> tabela.cruzada <- table(sexo, idade)
> margin.table(tabela.cruzada, 1)
sexo
f m
3 1
> margin.table(tabela.cruzada, 2)
idade
adulto jovem
3 1
Factor (cont.8)
Para se obter a frequência relativa (% de ocorrências de

cada tipo) usa-se prop.table, podendo-se dar como 2o
¯
argumento 1 para obter a proporção relativamente ao total
por linha (somatório da linha dá 100%)
> tabela.cruzada
idade
sexo adulto jovem
f 2 1
m 1 0
> prop.table(tabela.cruzada, 1)
idade
sexo adulto jovem
f 0.6666667 0.3333333
m 1.0000000 0.0000000
Factor (cont.9)
ou dando-se 2 como 2o argumento para obter a proporção

¯
face ao total por coluna (somatório coluna = 100%)
Para obter o resultado em percentagem multiplicar por 100
e para ter 2 casas decimais usar round(...,2)
> tabela.cruzada
idade
sexo adulto jovem
f 2 1
m 1 0
> round(100*prop.table(tabela.cruzada,2),2)
idade
sexo adulto jovem
f 66.67 100.00
m 33.33 0.00
Factor (cont.10)
ou não se dando o 2o argumento para obter a proporção

¯
face ao no total de elementos (somatório de todas as
¯
linhas e colunas dá 100%)
> tabela.cruzada
idade
sexo adulto jovem
f 2 1
m 1 0
> prop.table(tabela.cruzada)
idade
sexo adulto jovem
f 0.50 0.25
m 0.25 0.00

Factor (cont.11)
As funções de modelação lm() (fitting Linear Models) e

glm() (fitting Generalized Linear Models) dão um
tratamento especial a variáveis do tipo factor
Quando se está a fazer modelação linear o primeiro
level é usado como baseline level, daí ser importante
conseguir escolhê-lo (usando levels=...)

Data frame
Ao contrário da matriz cada coluna pode ter tipo diferente
> codigo <- c(1, 3, 4, 5)
> estado <- c("novo", "usado", "novo",
"defeituoso")
> valor <- c(100, 30, 90, 12)
> categoria <- c("mobilia", "mobilia",
"ferramentas", "mobilia")
> osDados <- data.frame(codigo, estado,
categoria, valor)
> osDados
codigo estado categoria valor
1 1 novo mobilia 100
2 3 usado mobilia 30
3 4 novo ferramentas 90
4 5 defeituoso mobilia 12
Indexar linhas e colunas dum data frame

osDados[2] ou osDados["estado"] devolve 2a coluna
¯
osDados[2,] ou osDados["2",] devolve a 2a linha
¯
osDados[2:4] ou osDados[c("estado",
"categoria", "valor")] devolve da 2a à 4a colunas
¯ ¯
osDados[2:4,] devolve da 2a à 4a linhas
¯ ¯
osDados[-(2:4),] devolve todas as linhas exceto da 2a
¯
à 4a linhas
¯
row.names(osDados) permite obter nomes das linhas
(por omissão são números gerados automaticamente)
row.names(osDados) <- c("alfa", "beta",
"gama", "delta") permite alterar os nomes das linhas,
depois disso osDados[2,] continua a devolver a 2a linha
¯
mas pode-se igualmente usar osDados["beta",]
row.names(osDados) <- NULL faz reset nomes das
linhas (voltam a ficar os nomes definidos por omissão)
Inserir linhas no fim dum data frame (append)
Para inserir linhas no fim dum data frame usa-se a função

rbind() que permite combinar 2 data frames, e atribui-se
o resultado ao primeiro data frame:
osDados <- rbind(osDados,
data.frame(codigo=6, estado="novo",
categoria="mobilia", valor=70))
Usando um ciclo for criar um data frame vazio e ir
adicionando linhas a ele (neste caso criando uma tabela
com os quadrados dos números de 1 a 10):
df <- data.frame(num=NULL, valor=NULL)
for (k in seq(10)) {
df<-rbind(df,data.frame(num=k,valor=k*k))
}

Inserir linhas no meio dum data frame
Para inserir uma ou mais linhas no índice n (na linha n)

dum data frame usa-se a função rbind() da seguinte
forma (neste caso assumiu-se n=4 e df terá de ser um
data frame com uma ou mais linhas que seja compatível
com o data frame osDados):
n <- 4
k <- n-1 # os 1¯ os n-1 não são empurrados
df <- data.frame(...) # 1 ou + novas linhas
osDados <- rbind(osDados[1:k,], df,
osDados[-(1:k),])

Data frame (cont.)
Para se extrair somente a coluna do estado usar

osDados$estado
Para extrair a primeira e a terceira colunas usar
osDados[c("codigo", "categoria")] ou
osDados[c(1, 3)]
Para sumariar os dados usar summary(osDados)
Para se ver a relação de cada uma das variáveis com cada
uma das restantes variáveis usar plot(osDados)
Para evitar estar sempre a escrever nome$coluna
pode-se usar with(nome, {... coluna ...}), isto
é, dentro das chavetas pode-se usar somente o nome das
colunas, mas neste caso as atribuições são locais às
chavetas a não ser que se use <<- em vez de <-

Data frame (cont.2)

1.0 1.5 2.0 2.5 3.0 20 40 60 80 100
● ● ●
5
● ● ●
4
codigo ● ● ●
3
2
● ● ●
1
3.0
● ● ●
2.5
estado
2.0
● ● ● ● ● ●
1.5
1.0
● ● ●
1.0 1.2 1.4 1.6 1.8 2.0

● ● ● ● ● ● ● ● ●
categoria
● ● ●
100
● ● ●
● ● ●
80
60
valor
40
● ● ●
20
● ● ●
1 2 3 4 5 1.0 1.2 1.4 1.6 1.8 2.0
Figure: plot(osDados), compara todas as combinações de

colunas atribuindo códigos numéricos aos dados não numéricos
Data frame (cont.3)
Para se ver qual é a estrutura de um data frame usa-se a

função str()
> osDados
> str(osDados)
’data.frame’: 4 obs. of 4 variables:
$ codigo : num 1 3 4 5
$ estado : Factor w/ 3 levels "defeituoso","novo",..: 2
3 2 1
$ categoria: Factor w/ 2 levels "ferramentas",..: 2 2 1 2
$ valor : num 100 30 90 12

Data frame (cont.4)

No caso de dados que representam categorias ordenadas
é necessário explicitar a ordem pretendida:
> estado <- factor(c("novo", "usado", "novo",
"defeituoso"), order=TRUE, levels=c("defeituoso", "usado",
"novo"))
> osDados2 <- data.frame(codigo, estado, categoria, valor)
> osDados2
> str(osDados2)
’data.frame’: 4 obs. of 4 variables:
$ codigo : num 1 3 4 5
$ estado : Ord.factor w/ 3 levels
"defeituoso"<"usado"<..: 3 2 3 1
$ categoria: Factor w/ 2 levels "ferramentas",..: 2 2 1 2
$ valor : num 100 30 90 12
Data frame (cont.5)

Data frames podem ser criados usando data.frame(),
read.table(),read.csv(),read.xls(),read.xlsx()
As linhas de um data frame possuem o atributo
row.names, isso é útil para anotar os dados, por exemplo
cada linha pode representar um indivíduo que participou
num estudo e nesse caso o row name seria o ID do
indivíduo, no caso dos nomes não serem relevantes (e não
serem especificados) ficam com os nomes por omissão de
1, 2, 3, ...
O data frame pode ser convertido para uma matriz com
data.matrix(), nesse caso como numa matriz todos os
dados tem de ser do mesmo tipo os dados podem ser
convertidos o que pode originar algo de inesperado
Obtém-se o no de linhas usando nrow() e o no de
¯ ¯
colunas usando ncol()
Data frame (cont.6)
Pode-se usar a função I() (inhibit interpretation /

conversion of objects) para evitar que num data frame as
strings sejam automaticamente convertidas para factors
Assumindo o data frame df <- data.frame(codigo,
estado, categoria, valor)
head(df) para obter as primeiras 6 linhas
tail(df) para obter as últimas 6 linhas
head(df, n=10L) para obter as primeiras 10 linhas
tail(df, n=10L) para obter as últimas 10 linhas
Se num data frame x quisermos remover as linhas que
possuem o valor NA numa coluna qualquer, podemos usar
x <- na.omit(x)

Data frame (cont.7)

library(dplyr): no contexto dum data frame suporta
select para extrair um subconjunto das colunas, filter
para extrair um subconjunto das linhas, arrange para
reordenar as linhas, rename para alterar o nome das
colunas, mutate para adicionar novas colunas ou alterar
colunas existentes, summarize ou summarise para
sumariar estatísticas de algumas colunas, sample_n para
obter n linhas aleatórias, group_by para agrupar, %>% (do
package magrittr usado pelo dplyr) para combinar
numa pipeline vários destes comandos, etc.
Todas as funções de dplyr tem o seguinte formato: o 1o
¯
argumento é o data frame, os restantes argumentos
descrevem o que se pretende, pode-se usar os nomes das
colunas sem se ter de incluir o $, o resultado é um novo
data frame
Data frame (cont.8)

?select para obter o texto de ajuda
select(df, c(estado, valor)) devolve colunas
estado e valor
select(df, estado:valor) devolve colunas estado,
categoria, valor
select(df, -(estado:valor)) omite as colunas
estado, categoria, valor
select(df, ends_with("ata")) devolve as colunas
que tem esse sufixo
select(df, starts_with("total")) devolve as
colunas que tem esse prefixo
select(df, -contains("local")) omite as colunas
que incluem essa substring
select(df, matches(".t.")) devolve as colunas
que obedecem à expressão regular
Data frame (cont.9)
filter(df, codigo == 3) obter as linhas com o

código 3
filter(df, codigo == 3 & estado ==
"usado"), obter as linhas com o código 3 e no estado de
usado, sendo que em vez de se usar & pode-se recorrer a
argumentos adicionais, isto é, filter(df, codigo ==
3, estado == "usado")
filter(df, codigo == 3 | estado == "novo"),
obter as linhas que ou tem o código 3 ou o estado é novo
filter(df, codigo > 3 | codigo <= 1), obter as
linhas que ou tem o código maior que 3 ou tem o código
menor ou igual a 1

Data frame (cont.10)

Ao filtrar em muitos casos não queremos usar == porque
isso obriga-nos a usar a string completa e estamos
interessados em explicitar somente uma substring
O comando grepl pode ser usado em filter e permite
reconhecer substrings recorrendo a expressões regulares
A expressão regular mais simples é colocar somente a
substring que se quer procurar, selecionando (ou
excluindo usando !) os registos correspondentes
filter(df,
grepl("usa",estado,ignore.case=T),
!grepl("ment",categoria))
seleciona as linhas que possuem o substring “usa” (em
maiúsculas ou minúsculas) na coluna estado e não
possuem o substring “ment” na coluna categoria
Usa-se unique(...) para eliminar dados repetidos
Exemplo com os emails da Hillary Clinton

Emails enviados para a Cheryl por alguém que não a Hillary,
que pessoas é que os enviaram? (sem duplicados)
library(jsonlite)
library(dplyr)
servidor = "http://graphics.wsj.com"
api = "hillary-clinton-email-documents/api/"
argsApi="sort=docDate&order=desc&limit=50000"
url = paste(servidor, "/", api, "search.php?",
argsApi, sep="")
clinton_emails <- fromJSON(url)$rows
save(clinton_emails,file="clinton-emails.rda")
unique(filter(clinton_emails,
!grepl("Hillary", from),
grepl("Cheryl", to))$from)
(aplica-se ao filtro unique(...$from) p/ obter nomes únicos)
Exemplo com os emails da Hillary Clinton (cont.)

O comando %>% na verdade não pertence ao package
dplyr mas sim ao package magrittr que é uma das
dependências do package dplyr:
install.packages("gtools")
library(gtools)
getDependencies("dplyr")
vignette("magrittr")
Pode-se combinar em série comandos do dplyr usando
pipes de modo a criar uma pipeline (linha de montagem)
de comandos, usa-se %>% para ligar os componentes, nos
comandos seguintes deixa de se dar o dataframe como
argumento já que se usa o dataframe que vem de trás
O uso destes pipes evita que se tenha de colocar funções
dentro de funções, dentro de funções, o que torna o
código mais legível e fácil de escrever e perceber
Exemplo com os emails da Hillary Clinton (cont.2)
select(clinton_emails, from) %>% distinct()

permite saber que utilizadores distintos enviaram emails.
Se não usassemos pipes o código seria
distinct(select(clinton_emails, from))
length((select(clinton_emails, from) %>%
distinct())$from) permite saber quantos utilizadores
distintos enviaram emails. Outra forma ainda mais legível
seria select(clinton_emails, from) %>%
distinct() %>% nrow(). Se não usassemos pipes o
código seria
nrow(distinct(select(clinton_emails,from)))

select(clinton_emails, to) %>% group_by(to)

%>% count(sort=T) %>% head(n=12) permite
saber quem foram os 12 destinatários que receberam mais
emails. Se não usassemos pipes o comando seria
head(count(group_by(select(clinton_emails,
to), to), sort=T), n=12) onde é muito mais difícil
visualizar a que comando pertence cada argumento


O comando %in% pode ser usado para selecionar os elementos que
pertencem a um conjunto, devolve um vetor de booleanos.
> resultado = select(osEmails, from, docDate) %>%
filter(grepl("2012-02", docDate)) %>% select(from)
%>% unique() %>% arrange(from)
> osQueEnviaram = resultado$from
> nRecebidos = select(osEmails, to, docDate) %>%
filter(grepl("2012-02", docDate)) %>% select(to)
%>% group_by(to) %>% count()
> osQueInteressam=nRecebidos$to %in% osQueEnviaram
> quemEnviou = nRecebidos$to[osQueInteressam]
> quantosRecebeu = nRecebidos$n[osQueInteressam]
> data.frame(quemEnviou, quantosRecebeu)
permite saber em Fevereiro 2012 de que pessoas foram enviados
emails, e para cada uma dessas pessoas quantos emails
foram recebidos por elas.

Quais foram as datas e assuntos dos primeiros 8 emails
enviados pela Hillary para o Russo em Outubro 2012?
select(clinton_emails, from, to, subject,
docDate) %>%
filter(grepl("Hillary",from),
grepl("Russo",to), docDate>="2012-10-01",
docDate<="2012-10-31") %>%
select(subject, docDate) %>%
arrange(docDate) %>% head(n=8)
selecionou-se as colunas que interessavam, filtrou-se de
modo a só se ficar com as linhas correspondentes ao que
foi pedido, eliminou-se as colunas que não interessavam,
ordenou-se por ordem crescente pela data (usar-se-ia
arrange(desc(docDate)) para ordenar por ordem
decrescente), e escolheram-se as primeiras 8 linhas
A função summarize() do dplyr
Para se usar a função summarize() do package dplyr

devemos começar por usar group_by() e só depois
aplicamos o summarize()
O summarize() necessita de um ou mais argumentos,
cada um dos argumentos é um par do tipo
nome=funcao(), onde nome é o nome da variável que
queremos que apareça no resultado, e a função é uma
expressão que deve retornar um único valor, por exemplo
min(x), n(), ou sum(is.na(y))
O resultado do summarize é um data frame com tantas
colunas quantas as que foram colocadas no group_by()
mais as que foram colocadas no summarize()

A função summarize() do dplyr (cont.)

Assumindo o data frame da pág. 76 eis um exemplo da
utilização do summarize():
> df=data.frame(codigo,estado,categoria,valor)
> df %>% group_by(estado) %>%
summarize(x=sum(valor))
# A tibble: 3 x 2
estado x
<fct> <dbl>
1 defeituoso 12
2 novo 190
3 usado 30
isto é, obtivemos um dataframe em que a coluna x contém a

soma do valor para cada estado (tibble significa table data
frame)
Extrair um subconjunto dos dados
[ devolve sempre um objeto do mesmo tipo (classe) que o

original, pode ser usado para selecionar mais do que um
elemento. Exceção: no caso das matrizes, se os índices
forem tais que selecionam um único elemento, o resultado
é o vector com esse elemento, se pretendermos que o
resultado seja uma matriz com um elemento temos de
adicionar o argumento adicional drop=FALSE:
x[1, 2, drop=FALSE]
[[ permite extrair um único elemento de uma lista ou de
um data frame, o tipo devolvido não é necessariamente o
mesmo que o do original
$ é usado para extrair elementos de uma lista ou de um
data frame a partir do seu nome, o resultado é semelhante
ao uso do [[
Extrair um subconjunto dos dados (match parcial)

O match parcial não deve ser usado em programas R, só
quando interativamente se experimenta com dados de
modo a evitar ter de escrever na totalidade nomes
compridos
O operador $ por omissão aceita matches parciais
O operador [[ por omissão não aceita matches parciais, é
necessário ativar exact=FALSE
> x <- list(aardvark = 1:5, crocodilo = 6:11)
> x$a
[1] 1 2 3 4 5
> x[["a"]]
NULL
> x[["a", exact = FALSE]]
[1] 1 2 3 4 5
O match é feito no prefixo do nome, resultado NULL se o match
parcial for ambíguo (match de mais do que um nome)
Ausência de valores
NaN (Not a Number) é usado para resultados indefinidos
em operações matemáticas, is.nan() é usado para
testar essas situações
NA (Not Available) é usado nos restantes casos, is.na()
é usado para testar essas situações
Os valores NA também possuem um tipo (uma classe),
podem ser integer NA, character NA, etc
Um valor NaN é também um NA (isto é, algo que tem o
valor NaN é considerado como sendo um valor em falta),
mas o inverso não é verdade
> x <- c(1, 2, NaN, NA, 4)
> is.na(x)
[1] FALSE FALSE TRUE TRUE FALSE
> is.nan(x)
[1] FALSE FALSE TRUE FALSE FALSE
Ausência de valores (cont.)
Não se pode comparar com NA ou comparar com NaN (isto

é, não se pode usar == ou !=), tem de se usar as funções
is.na() ou is.nan() ou as suas negações !is.na(),
!is.nan()
> x = NA
> x == NA
[1] NA
> y = NaN
> y == NaN)
[1] NA
> is.na(x)
[1] TRUE
> is.nan(y)
[1] TRUE
Remover valores em falta (NA) de um ou mais vectors

Remover os valores que são NA:
> x <- c(1, 2, NA, 4, NA, 5)
> bad <- is.na(x)
> x[!bad]
[1] 1 2 4 5
Para remover valores que são NA quando se tem mais do que
um vector usa-se a função complete.cases():
x <- c(1, 2, NA, 4, NA, 5)
y <- c("a", "b", NA, "d", NA, NA)
good <- complete.cases(x, y)
> good
[1] TRUE TRUE FALSE TRUE FALSE FALSE
x[good]
[1] 1 2 4
y[good]
[1] "a" "b" "d"
Remover valores em falta (NA) de um data frame

complete.cases() permite remover NA de data frames:
airquality <- read.csv("dados.csv")
> airquality[1:5, ]
Ozone Solar.R Wind Temp Month Day
1 41 190 7.4 67 5 1
2 36 118 8.0 72 5 2
3 12 149 12.6 74 5 3
4 18 313 11.5 62 5 4
5 NA NA 14.3 56 5 5
> good <- complete.cases(airquality)
> airquality[good, ][1:5, ]
Ozone Solar.R Wind Temp Month Day
1 41 190 7.4 67 5 1
2 36 118 8.0 72 5 2
3 12 149 12.6 74 5 3
4 18 313 11.5 62 5 4
7 23 299 8.6 65 5 7
Fornecer dados através do editor embebido no R
Para se introduzir uma pequena quantidade de dados,

principalmente no caso de um data frame com várias
colunas, pode-se usar o editor disponibilizado pelo R:
osDados <- data.frame(idade=numeric(0),
genero=character(0), peso=numeric(0))
osDados <- edit(osDados)
Note-se que edit() trabalha sobre uma cópia do objecto
pelo que é necessário voltar a atribuir o resultado ao
objecto
Também se pode usar fix(osDados), que é equivalente
a osDados <- edit(osDados)
Para se ler uma maior quantidade de dados é preferível
obtê-los de um ficheiro de texto ou de um ficheiro Excel

Importar dados de um ficheiro de texto

Ler/escrever texto não formatado: readLines() /
writeLines()
Ler dados de oFicheiro.txt que se encontra no
directório c:/users/avs/dados, sendo que a primeira
linha tem os nomes das colunas, e que o separador das
colunas é um caracter de tabulação (um tab, \t):
getwd()
setwd("c:/users/avs/dados")
osDados <- read.table("oFicheiro.txt",
header=TRUE, sep="\t", quote="")
Desligou-se as quotes, por omissão quote="\"’" (tabs
poderiam estar embebidos em aspas simples ou duplas)
Usa-se file.choose() para interactivamente escolher o
nome dum ficheiro, e list.files("nomeDir") para
obter o conteúdo do directório nomeDir
Importar dados de um ficheiro de texto (cont.)
No R Studio pode-se igualmente utilizar o menu Tools /

Import dataset / From Text File, podendo-se especificar o
encoding, se tem cabeçalho, os nomes das linhas, o
separador dos campos, usar vírgula ou ponto para casas
decimais, o tipo de quotes utilizado, o carater usado para
comentários, e se os strings devem ser convertidos em
factors
Se o ficheiro por exemplo contiver:
"Ozone","Solar.R","Wind","Temp","Month","Day"
41,190,7.4,67,5,1
36,118,8,72,5,2
...
isto executa
osDados <- read.csv("~/dados/hw1_data.csv")
Importar dados de um ficheiro de texto (cont2.)
read.table() é idêntico a read.csv() exceto que o

separador por omissão em read.table() é um espaço
e em read.csv() é uma vírgula, e a existência de
cabeçalho (header) por omissão é falso em
read.table() e verdadeiro em read.csv()
Ver a help page para read.table() relativamente a
como poupar memória quando se estiver a ler tabelas de
grande dimensão
Optimização: colocar comment.char="" se não
existirem comentários no ficheiro de dados
Optimização: dizer quanto é que vale nrows (obtido por
exemplo usando o wc do Unix), isso não torna a leitura
mais rápida mas permite poupar memória

Importar dados de um ficheiro de texto (cont3.)
Optimização: usar colClasses para especificar o tipo de

dados em cada coluna torna o programa muito mais
rápido (provavelmente 2x mais rápido). Pode-se
especificar uma lista de tipos ou especificar um único tipo
(nesse caso assume que todas as colunas são desse tipo,
por exemplo colClasses=numeric)
Optimização: usando nrows ler somente as primeiras
linhas de dados, depois fazer um ciclo sobre cada coluna
usando sapply e chamando a função class de modo a
descobrir qual é o tipo de dados em cada coluna, depois
voltar a ler a tabela toda usando essa informação:
x<-read.table("dados.txt", nrows=100)
osTipos <- sapply(initial, class)
x<-read.table("dados.txt", colClasses=osTipos)

Obter em formato R representação textual dum objeto

dump() imprime a representação textual de um objeto
> x <- 1:3
> dump("x", file="")
x <-
1:3
> dump("readLines", file="")
readLines <-
function (con = stdin(), n = -1L, ok = TRUE,
warn = TRUE, encoding = "unknown",
skipNul = FALSE)
{
if (is.character(con)) {
con <- file(con, "r")
on.exit(close(con))
}
.Internal(readLines(con, n, ok, warn,
encoding, skipNul)) }
source() permite ler programas
CTeSP TPSI escritos
Matemática em R (é
e Estatística 109o/ 174
inverso de
dump/source, dput/dget
Em dump() e dput() usa-se o argumento file="" se

se quiser escrever para a consola
dump(..., file="...") escreve a representação
textual de um objeto R para um ficheiro, a seguir pode-se
usar source() para o reimportar noutra sessão R
dput() é semelhante a dump() mas menos poderoso,
não imprime o nome do objeto e só pode ser usado para
um objeto de cada vez: dput(x, file="")
dget() permite ler um objeto R que foi deparsed num
ficheiro de texto
dput/dump adicionam metadados aos dados

save/load, serialize/unserialize
load() (saved workspaces) e unserialize() permitem

ler objetos binários
save() escreve a representação textual de objetos R
para um ficheiro que pode depois ser reimportado (é
melhor que dput()), neste caso não se pode escrever
para a consola é necessário fornecer o nome dum ficheiro
file / gzfile / bzfile / url: usado para abrir
um ficheiro, um ficheiro comprimido com gzip ou bzip2, ou
uma página web:
h <-url("http://dev1.portodigital.pt","r")
s <-readLines(h)
head(s)

Importar dados de um ficheiro Excel

As alternativas incluem usar-se um dos packages RODBC
(ficheiros Excel ou bases de dados SQL), xslx, ou gdata
O package gdata (necessita da linguagem perl, por
exemplo descarregar e instalar o “active perl ”) permite ler
ficheiros .xls e .xlsx (locais ou da internet usando
http://, https://, ftp://):
> install.packages("gdata")
> library(gdata); xlsFormats()
> z = read.xls("/Users/avs/dados.xls")
> y = read.xls("/Users/avs/valores.xlsx")
Por omissão lê a 1a folha do Excel, pode-se especificar
¯
outra folha usando o argumento sheet="nomeDaFolha"
ou sheet=n onde n é o no da folha, ver ?read.xls
¯
Se o perl não estiver no PATH é necessário usar o
argumento perl="c:/perl64/bin/perl.exe"
Importar dados de um ficheiro Excel (cont.)
Se ao se usar o comando read.xls do package gdata se

obtiver um erro do tipo
Error in make.names(col.names, unique =TRUE) :
invalid multibyte string 3
isso significa que no título da coluna 3 existe um carater
acentuado que está a originar problemas na criação do
dataframe com o conteúdo do ficheiro. Nesse caso abrir o
ficheiro Excel e retirar os carateres acentuados dos títulos de
todas as colunas (o problema é só com carateres acentuados
nos títulos), gravar, e voltar a ler o ficheiro. Este problema
acontece em Mac OS X, podendo não ocorrer em Microsoft
Windows.

Importar dados de um ficheiro Excel (cont.2)
O package xlsx (permite ler ficheiros .xlsx e .xls) é mais

rápido a executar do que o package gdata, em vez do
perl necessita da linguagem java. Disponibiliza
read.xlsx() e read.xlsx2(), este último é ainda
mais rápido (faz a maioria do processamento em Java).
> install.packages("xlsx")
> library(xslx)
> z =read.xlsx("c:/dados.xls",sheetIndex=1)
> y =read.xlsx("c:/b.xls",sheetName="Base")
NOTA: read.xls() do package gdata, read.xlsx() e
read.xlsx2() do package xlsx, todos os 3 podem dar
resultados ligeiramente diferentes entre si devido a
usarem heurísticas ligeiramente diferentes na
interpretação dos dados (número de factors, etc.)
Importar dados de um ficheiro Excel (cont.3)

Usando proc.time() eis uma comparação de tempos
de execução entre read.xls(), read.xlsx(), e
read.xlsx2() a ler uma folha dum ficheiro .xls com
107 linhas e 12 colunas (CPU de 64 bits com 4 cores):
user system elapsed (read.xls)
11.194 0.183 11.386
user system elapsed (read.xlsx)
2.445 0.116 1.630
user system elapsed (read.xlsx2)
0.764 0.039 0.263
Para ler ficheiros .ods (Open Office / Libre Office
spreadsheet) pode-se usar a função read.ods() do
package ROpenOffice ou pode-se a partir do Open
Office / Libre Office gravar o ficheiro no formato Excel
(.xlsx)
Exportar dados de data frame para ficheiro Excel

Um data frame tem os dados organizados num formato
apropriado para serem colocados numa folha de cálculo
Em vez de escrever diretamente para o ficheiro Excel é
preferível escrever para um ficheiro de texto usando o tab
(\t) como separador, e depois abrir esse ficheiro de texto
e usar copiar/colar para colocar esses dados no ficheiro
Excel, para isso usa-se write.table()
Por omissão quote=TRUE, coloca os dados com aspas à
volta deles, isso só seria necessário se pudessem existir
tabs embebidos nos dados, em caso contrário atrapalha
Se se escrever para um ficheiro de texto mas que tenha
a extensão .xls o Excel abre-o diretamente sem ser
necessária a operação de copiar/colar
write.table(dataFrame, file="filename.xls",
quote=FALSE, sep="\t")
Obter dados diretamente da internet

download.file(url, destino, mode), descarrega um
ficheiro da internet e grava num ficheiro, por exemplo
download.file("https://portodigital.pt/dados.xls",
"c:/users/avs/dados.xls", mode ="wb"), sempre que
um ficheiro é binário em Windows é importante usar-se
mode="wb" senão o ficheiro fica corrompido (se o ficheiro for
de texto é preferível não fornecer o argumento mode)
Para obtermos dados tabulares diretamente da internet podem
usar-se várias formas, uma delas é a função fread() do
package data.table que pode ler dados em formato CSV
quer de ficheiros locais quer da internet:
install.packages("data.table")
library(data.table)
x = fread("c:/docs/dados.csv")
y = fread("http://portodigital.pt/dados.csv")
O read.xls() do package gdata permite ler diretamente da
internet (read.xlsx() e read.xlsx2() já não o permitem)
Obter dados diretamente da internet (cont.)
Package httr para trabalhar com APIs:

Internamente utiliza os packages jsonlite, curl, mime
e R6
Disponibiliza ferramentas para aceder à internet (URLs
com os protocolos HTTP ou HTTPS) estando organizado
de acordo com os verbos dos comandos HTTP (DELETE,
GET, HEAD, PATCH, POST, PUT) com suporte para
autenticação, headers, options, cookies, etc.
O comando VERB permite executar um verbo arbitrário
Possui igualmente os comandos BROWSE e RETRY que
não sendo verbos HTTP neste package estão com um
interface no mesmo formato
https://cran.r-project.org/web/packages/httr/httr.pdf

Package readit
O objetivo deste package é adivinhar o formato a partir da
extensão do nome do ficheiro e de uma análise heurística
dos dados, e a seguir fazer tudo automaticamente
install.packages("readit")
Consegue processar ficheiros .txt (desde que tenham
um delimitador qualquer, o package tenta adivinhar o
delimitador), .csv, .xls/.xlsx (incluindo ler de outra
folha que não a primeira), .sas7bdat/.sas7bcat
(ficheiros do programa SAS), .dta (ficheiros do programa
Stata), .sav/.por (ficheiros do programa SPSS), .json
(arrays JSON, que são convertidos em data frames)
x = readit("file.json")
y = readit("file.xlsx")
z = readit("file.xlsx", sheet=2)
Listar ficheiros e diretórios e/ou testar o seu tipo
dir() lista os ficheiros e diretórios existentes no diretório

por omissão (o que foi definido usando setwd())
dir("c:/users") lista os ficheiros e diretórios
existentes nesse diretório
list.dirs("c:/users") lista recursivamente os
subdiretórios existentes nesse local
list.dirs("c:/users", recursive=FALSE) lista
somente o primeiro nível de subdiretórios
Testes úteis (necessitam que se carregue a biblioteca
assertthat): is.dir(path), is.writeable(path),
is.readable(path), has_extension(path, ext)

A linguagem R Estruturas de controle de fluxo e funções em R
Análise de dados Funções estatísticas em R
Programação em R Gráficos em R usando ggplot2
if / for / while / repeat / break / next / return()
if, else: testar uma condição

for: executar ciclo uma dada quantidade de vezes
while: executar ciclo enquanto condição for verdadeira
repeat: executar ciclo infinito
break: terminar a execução de qualquer tipo de ciclo
next: saltar por cima de uma interação de um ciclo
return(): retornar um valor de uma função, ao usar
return() é necessário colocar a expressão com o
resultado entre parêntesis, por exemplo: return(x+3)
ou return(x). Note-se que uma função retorna
automaticamente o valor da última expressão que foi
calculada nessa função, nesses casos o return() não é
necessário (embora se for usado fica mais legível)
if / else
if sem else:
if(x > 3) {
x <- 3
}
Tipo normal de if:
if(x > 3) {
y <- 10
} else {
y <- 0
}
Tipo especial de if:
y <- if(x > 3) {
10
} else {
0
}
for
x <- c("a", "b", "c", "d")
Usando índices definidos manualmente:
for(i in 1:4) {
print(x[i])
}
Usando índices definidos automaticamente:
for(i in seq_along(x)) {
print(x[i])
}
Usando os próprios valores sem recorrer a índices:
for(k in x) {
print(k)
}
Sem usar chavetas (e colocando tudo na mesma linha para ser
mais compacto): for(i in 1:4) print(x[i])

for (cont.)
Usar ciclos encadeados para iterar em todos os elementos

de uma matriz:
x <- matrix(1:6, 2, 3)
for(i in seq_len(nrow(x))) {
for(j in seq_len(ncol(x))) {
print(x[i, j])
}
}

while
contador <- 0
while (contador < 10) {
print(contador)
contador <- contador + 1
}
z <- 5
while (z >= 3 && z <= 10) {
print(z)
moeda <- rbinom(1, 1, 0.5)
if (moeda == 1) { ## random walk
z <- z + 1
} else {
z <- z - 1
}
}

repeat
repeat {
...
if (...)
break
...
}

Criar funções em R
No RStudio usar File / New File / R Script

Uma função retorna o valor da última expressão que tiver
executado
somar2 <- function(x, y) {
x + y
}
Os argumentos duma função podem ter valores por omissão:
> acima <- function(x, n = 10) {
valores <- x > n
x[valores]
}
> acima(1:20, 12)
[1] 13 14 15 16 17 18 19 20
> acima(1:20)
[1] 11 12 13 14 15 16 17 18 19 20
Criar funções em R (cont.)
Calcular média das colunas duma matriz:

mediaColuna <- function(m) {
nCols = ncol(m)
medias <- numeric(nCols)
for (i in 1:nCols) {
medias[i] <- mean(m[,i])
}
medias
}
> mediaColuna(hw1_data)
[1] NA NA 9.957516 77.882353
6.993464 15.803922

Criar funções em R (cont.2)
Calcular média das colunas duma matriz ignorando os NA:

mediaColuna <- function(m, eliminarNA = TRUE) {
nCols = ncol(m)
medias <- numeric(nCols)
for (i in 1:nCols) {
medias[i]<-mean(m[,i], na.rm=eliminarNA)
}
medias
}
> mediaColuna(hw1_data)
[1] 42.129310 185.931507 9.957516 77.882353
6.993464 15.803922
> mediaColuna(hw1_data, eliminarNA = FALSE)
[1] NA NA 9.957516 77.882353
6.993464 15.803922


Funções são objetos que possuem a class function
Funções podem ser passadas como argumentos para
outras funções
Funções podem ser encadeadas (definir umas dentro das
outras)
O valor de retorno de uma função é o valor da última
expressão existente no corpo da função que foi executada
Os argumentos de uma função podem ser explicitados
usando a ordem em que são apresentados ou podem ser
explicitados recorrendo ao seu nome
No caso de argumentos fornecidos pelo nome em 1o lugar
¯
tenta fazer um match perfeito, a seguir tenta fazer um
match parcial, dá erro se não houver nenhum match ou se
o nome parcial fizer match com vários argumentos
Pode-se misturar os 2 tipos de argumentos (usando a

ordem e usando o nome), nesse caso os argumentos
dados pelo nome são matched e removidos da lista de
argumentos, seguidamente os restantes argumentos são
matched na ordem em que aparecem
> args(lm)
function (formula, data, subset, weights,
na.action, method="qr", model=TRUE, x=FALSE,
y=FALSE, qr=TRUE, singular.ok=TRUE,
contrasts=NULL, offset, ...)
estas 2 chamadas são por conseguinte equivalentes:
lm(data = mydata, y ~ x, model = FALSE, 1:100)
lm(y ~ x, mydata, 1:100, model = FALSE)
NOTA: o operador ~ é usado para separar o lado esquerdo do
lado direito da fórmula de um modelo


Os argumentos duma função são calculados duma forma
preguiçosa (lazy), se um argumento não chegar a ser
necessário e não for fornecido na chamada à função o
programa não dá erro
Se chegar a necessitar do argumento dá erro, mas isso só
acontece no momento em que o argumento é necessário,
isto é, pode já ter executado uma parte da função antes de
necessitar do argumento em falta e só aí dá erro:
> f <- function(a, b) { print(a); print(b); }
> f(12, 3)
[1] 12
[1] 3
> f(12)
[1] 12
Error in print(b) : argument "b" is missing,
with no default

Usa-se o argumento ... para receber argumentos que se
quer passar para outra função sem ter de os explicitar a
todos. A função myplot() altera plot() usando por
omissão linhas em vez de círculos nos pontos (permitindo
no entanto que se explicite outro valor que não o de
omissão):
myplot <- function(x, y, type = "l", ...) {
plot(x, y, type = type, ...)
}
O argumento ... também é necessário quando não se sabe
quantos argumentos vão ser fornecidos à função
> args(paste)
function (..., sep=" ", collapse=NULL)
> args(cat)
function (..., file="", sep=" ", fill=FALSE,
labels=NULL, append=FALSE)
Quando se usa ... os argumentos que sejam fornecidos

a seguir tem de ser fornecidos usando o nome (não se
pode usar a posição), e o nome tem de fazer um match
perfeito (matches parciais não funcionam)
O scope dos nomes (contexto e ordem em que os
encontra e utiliza) é o definido em search() (sendo o
.GlobalEnv o contexto em que o utilizador está a criar os
símbolos):
> search()
[1] ".GlobalEnv" "tools:rstudio"
"package:stats" "package:graphics"
[5] "package:grDevices" "package:utils"
"package:datasets" "package:methods"
[9] "Autoloads" "package:base"
Quando se usa library() para carregar um package

esse package é colocado na posição 2 da search() lista
e os restantes são empurrados para a direita
O R usa um namespace separado para funções e para
não funções, pelo que é possível ter um objeto chamado c
e uma função chamada c

max(), min(), pmax(), pmin()

As funções max() e min() devolvem o máximo e o
mínimo dos argumentos. Se um dos argumentos for NA
retornam NA exceto se se usar o argumento opcional
na.rm=TRUE (nesse caso os NA são ignorados)
pmax() e pmin() (onde o p quer dizer paralelo) são
equivalentes às anteriores mas se os argumentos forem
vetores de valores devolvem um vetor com o maior dos
valores em posições correspondentes
> x = c(10, 7, 15, -3)
> y = c(8, -2, 16, -4)
> z = c(5, 11, 7, -4)
> max(x, y, z)
[1] 16
> pmax(x, y, z)
[1] 10 11 16 -3
Aplicar uma função aos elementos duma lista
A função lapply(), list apply, permite aplicar uma função

a todos os elementos de uma lista
lapply(aLista, aFuncao) aplica a função
aFuncao() a todos os elementos da lista e devolve o
resultado
soma <- lapply(list(10:20), sum) vai usar a
função sum para somar os valores de 10 a 20. Em R isto é
uma forma mais eficaz de fazer o mesmo que na maioria
das linguagens de programação seria feito desta forma:
soma <- 0
for (k in 10:20)
soma <- soma + k

Aplicar uma função aos elementos duma lista (cont.)
rnorm(n) devolve n números que tem uma distribuição

normal com média = 0 e desvio padrão = 1
rnorm(n, 5) devolve n números que tem uma
distribuição normal com média = 5 e desvio padrão = 1
rnorm(n, 5, 2) devolve n números que tem uma
distribuição normal com média = 5 e desvio padrão = 2
> x<-list(1:10,rnorm(1000),rnorm(1000,5))
> lapply(x, mean)
[[1]]
[1] 5.5
[[2]]
[1] 0.01904784
[[3]]
[1] 4.995056
Aplicar uma função aos elementos duma lista (cont2.)

A função sapply é semelhante a lapply mas tenta
simplificar o resultado, se possível:
Se o resultado for uma lista onde cada elemento tem
comprimento 1 então devolve um vector
Se o resultado for uma lista onde cada elemento tem
comprimento maior do que 1 então devolve uma matrix
> x <- list(a=1:4, b=rnorm(100,5))
> lapply(x, mean)
$a
[1] 2.5
$b
[1] 4.883887
> sapply(x, mean)
a b
2.500000 4.883887
Partir um vector, list ou data frame em subconjuntos

A função split quando aplicada a um objecto parte-o em
subconjuntos de acordo com um factor ou uma lista de
factors. O primeiro argumento é o objeto, o 2o o
¯
factor, e o 3o drop=FALSE é opcional permitindo
¯
eliminar níveis vazios
A combinação de split() com a função lapply() ou
sapply() é muito comum em R, a ideia é partir de uma
estrutura de dados, parti-la em subconjuntos definidos por
outra variável, e aplicar uma função a cada um desses
subconjuntos, o resultado é depois agregado e retornado
num único objeto. A esta sequência de operações
chama-se map-reduce
> x <- c(rnorm(10), runif(10), rnorm(10,1))
> f<-gl(3,10) #gerar 3 factor repetidos 10x
> sapply(split(x,f),mean)#calcular 3 médias
Aplicar uma função a subconjuntos de um vector
A função tapply() é usada para aplicar uma função a

subconjuntos de um vector, representa uma combinação
de split() e sapply() que só funciona com vectors.
Assumindo que temos estes dados:
> x <- c(rnorm(10), runif(10), rnorm(10,1))
> f<-gl(3,10) #gerar 3 factor repetidos 10x
então este uso de sapply() e split():
> sapply(split(x,f),mean)#calcular 3 médias
é equivalente a este uso de tapply():
> tapply(x, f, mean) # calcular 3 médias

Aplicar uma função aos elementos duma matrix
A função apply serve para aplicar uma função às linhas

ou colunas de uma matrix ou array:
x<-matrix(rnorm(12),4,3) # 4 linhas, 3 cols
> apply(x, 1, mean) # média das linhas
[1] 0.3595297 -0.1530043 -0.9369527
0.6276206
> apply(x, 2, mean) # média das colunas
[1] -0.05125631 0.68470648 -0.71055521
Estas 4 funções são versões optimizadas de apply():
rowSums = apply(x, 1, sum)
rowMeans = apply(x, 1, mean)
colSums = apply(x, 2, sum)
colMeans = apply(x, 2, mean)

Ordenar vector usando sort()
sort(...) para ordenar por ordem crescente

sort(..., decreasing=TRUE) para ordenar por
ordem decrescente
sort(..., ..., na.last=xxx) para definir o que
fazer aos NAs se existirem. O xxx pode ser TRUE (os
NAs se existirem são colocados no fim), FALSE (no
princípio), NA (removidos).
O sort() tem mais opções (ordenações parciais,
explicitar o algoritmo de ordenação, etc.), ver a
documentação.

Ordenar data frame (decr. 1a, crescente 2a, decr. 3a)

¯ ¯ ¯
dd=data.frame(x=c(1,1,3:1),y=c(9,9:6),z=c(2,1:4))
> dd
x y z
1 1 9 2
2 1 9 1
3 3 8 2
4 2 7 3
5 1 6 4
> dd[order(-x, y, -z), ]
x y z
3 3 8 2
4 2 7 3
5 1 6 4
1 1 9 2
2 1 9 1
Desvio padrão (standard deviation)
Em estatística o desvio padrão (σ, sigma) representa a

quantidade de variação ou dispersão dos dados face ao
valor médio desses mesmos dados. Um valor baixo do
desvio padrão significa que a maioria dos dados estão
próximos do valor médio
Para além de expressar a variabilidade dos dados
representa o grau de confiança que se pode ter em
conclusões estatísticas. Por exemplo ao analisar o
resultado de uma sondagem considera-se que a margem
de erro é cerca de 2 desvios padrões já que isso numa
distribuição normal dos dados cobre cerca de 95% dos
resultados

Distribuição normal
A distribuição normal é muito usada em estatística, sendo

especialmente apropriada para a estimativa de erros de
medidas experimentais (ou de variações de tamanhos ou
dimensões) quando o no de medidas é suficientemente
¯
grande. Considera que os dados vão estar distribuídos de
forma a terem valores superiores e inferiores ao valor
médio (valor esperado), espalhados de tal forma que
criem uma curva em forma de sino
Em R um vetor de n observações de uma variável
aleatória com distribuição normal é gerado por
rnorm(n,m,s), onde m é a média e s é o desvio padrão,
os valores por omissão são 0 para m e 1 para s

Desvio padrão (standard deviation), regra 68-95-99.7

11/27/2016 https://upload.wikimedia.org/wikipedia/commons/8/8c/Standard_deviation_diagram.sv
0.4
0.3
0.2
34.1% 34.1%
0.1
2.1% 2.1%
0.1% 13.6% 13.6% 0.1%
0.0
−3σ −2σ −1σ 0 1σ 2σ 3σ
Desvio padrão numa distribuição normal dos dados:

O intervalo desde o valor médio até à distância de 1
desvio padrão inclui cerca de 68% dos dados
desvios padrão inclui cerca de 95% dos dados
desvios padrão inclui cerca de 99.7% dos dados
Cálculo manual do desvio padrão

O desvio padrão é a raiz quadrada da variância
A variância é a média do somatório da diferença ao
quadrado entre cada valor e a média
Se tivermos este conjunto completo de notas de 8 alunos:
notas = c(4, 8, 8, 8, 10, 10, 14, 18) então a
média mean(notas) vale 10, a variância vale
((4 − 10)2 + (8 − 10)2 + (8 − 10)2 + (8 − 10)2 + (10 − 10)2 +
(10 − 10)2 + (14 − 10)2 + (18 − 10)2 )/8 = 16, e o desvio
padrão é a raiz quadrada deste valor pelo que vale 4
Para calcular a variância no caso de ser uma
amostra aleatória de tamanho n dos valores existentes
numa dada população, ao calcular a média das diferenças
ao quadrado não se divide por n mas sim por n − 1
(correção de Bessel, só deve ser usada quando a média
da população foi estimada a partir da média da amostra)
Cálculo manual do desvio padrão (cont.)

O R na função sd() usa a correção de Bessel, isto é,
assume que se trata de uma amostra da população e que
a média que estamos a usar não é a média verdadeira da
população mas sim a média dos valores na amostra, pelo
que divide por n-1, que neste caso seria 7:
> notas = c(4, 8, 8, 8, 10, 10, 14, 18)
> mean(notas)
[1] 10
> sd(notas)
[1] 4.27618
((4 − 10)2 + (8 − 10)2 + (8 − 10)2 + (8 − 10)2 + (10 − 10)2 +
(10 − 10)2 + (14 − 10)2 + (18 − 10)2 )/7 = 18.285714, e a
raiz quadrada dá 4.27618
O desvio padrão é 4.27618 se estes dados forem uma
amostra, e é 4 se estivermos com a população completa
Gráfico distribuição normal com 1 milhão medidas

Histogram of rnorm(1e+06)
4000
3000
Frequency
2000
1000
0
−4 −2 0 2 4
rnorm(1e+06)
1 milhão de medidas agrupadas num histograma com 1000

blocos: pdf("DistribuicaoNormal.pdf")
plot(hist(rnorm(1000000), breaks=1000))
dev.off()
Probabilidades (dados normais e viciados)
runif(1) (Random with UNIForm distribution) gera um

número pseudo aleatório entre 0 e 1 (o zero pode sair mas
o 1 nunca sai, o máximo que pode sair é 0.99999999...),
todos os valores têm igual probabilidade de saírem
runif(30) gera 30 números pseudo aleatórios entre 0 e
1
floor(), trunc() ou as.integer() permitem dado
um número com casas decimais arredondá-lo para baixo
(truncá-lo), ficando somente com a parte inteira
Em vez de se usar runif() poder-se-ia usar sample(),
a função sample() tem uma funcionalidade mais
sofisticada

Probabilidades (dados normais e viciados) cont.

Numa linguagem de programação (mas não em R):
Obtém-se um no aleatório que possa ter casas decimais e
¯
que esteja entre min e max com a fórmula
min + (max - min) * random()
Obtém-se um no aleatório inteiro entre min e max (ambos
¯
inclusive) com a fórmula
min + int((max - min + 1) * random())
Portanto numa linguagem de programação qualquer, se
quisermos ter o valor do lançamento dum dado (valor
entre 1 e 6) usa-se a fórmula min + int((max-min+1)
* random()) = 1 + int((6-1+1) * random()) =
1 + int(6 * random())
Em R isto escreve-se da seguinte forma:
1 + trunc(6 * runif(1))
20 lançamentos de 1 dado normal (não viciado) obtém-se
com: 1 + trunc(6 * runif(20))
Probabilidades (dados normais e viciados) cont.2

Em vez de trunc() pode-se usar floor() ou
as.integer()
Se quisermos lançar 2 dados e somar os pontos de ambos
não podemos gerar um número aleatório de 2 a 12 porque
isso significaria que todos os valores eram igualmente
prováveis, ora o valor 7 é muito mais provável de sair do
que por exemplo 2 ou 12. O que se tem de fazer é usar a
fórmula de geração de números aleatórios para cada um
dos dados, e depois somar os valores obtidos, por
exemplo obtém-se 20 lançamentos de 2 dados com
1+trunc(6*runif(20)) + 1+trunc(6*runif(20))
Um dado viciado ou tem alguns dos cantos mais
arredondados ou possui um pequeno peso no interior de
modo a desiquilibrá-lo a favor de um dado valor (ao atirar o
dado a parte mais pesada tende a ficar em baixo).

Como runif() dá como resultado uma distribuição
uniforme a única forma de representar dados viciados é
gerar mais valores e depois mapear os valores extra
naqueles que queremos que saiam mais.
Se tivermos um dado viciado em que o 5 ou o 6 saiem
50% das vezes, e os restantes valores (1, 2, 3, 4) têm
igual probabilidade de saírem e representam os restantes
50%, então podemos considerar que temos 1->1, 2->2,
3->3, 4->4, 5->5, 6->5, 7->6, 8->6, isto é, precisamos
de ter um valor entre 1 e 8, e se sair 5 ou 6 representa o 5
e se sair 7 ou 8 representa o 6. Eis como com 3 instruções
colocamos em x 15 lançamentos deste dado viciado:
> x = 1+trunc(8*runif(15))
> x[x >= 5 & x <= 6] = 5
> x[x >= 7 & x <= 8] = 6

Dado um vector x é importante perceber-se o que significa
fazer x[x >= 7 & x <= 8] = 6 e porque é que isso
em R funciona (as outras linguagens de programação não
suportam este tipo de sintaxe)
Em primeiro lugar x >= 7 & x <= 8 dá como resultado
um vector de booleanos (TRUE ou FALSE) com o mesmo
tamanho do vector x e que terá o valor TRUE sempre que
a condição é verificada
Quando se faz x[x >= 7 & x <= 8] está-se a
selecionar somente os elementos do vector que
correspondem a entradas TRUE
Quando se faz x[x >= 7 & x <= 8] = 6 está-se a
colocar o valor 6 em todos os elementos do vector que
correspondem a entradas TRUE

set.seed(n) onde n é um número qualquer (tanto faz
qual seja esse número) inicializa o gerador de números
aleatórios com esse número. Isso permite que se antes de
se voltar a correr o mesmo programa se executar o mesmo
set.seed(n) (o n tem de ser o mesmo), consegue-se
que os números aleatórios sejam exatamente os mesmos.
Isto ajuda durante o debug (depuração) do código R que
se está a escrever. Por exemplo se fizermos:
> set.seed(99)
> x = 1+trunc(6*runif(20))
> y = 1+trunc(6*runif(15))
> set.seed(99)
> z = 1+trunc(6*runif(20))
> w = 1+trunc(6*runif(15))
sabemos que x = z e y = w

Em vez de se usar runif() pode-se usar sample(), que
permite obter uma amostra de um conjunto de valores
Dado um vector x se quisermos obter um outro vector com
os dados que se encontram em x numa ordem aleatória
usa-se sample(x), se só quisermos n desses elementos
usa-se sample(x, n)
sample(n) onde n é um número inteiro devolve n
números entre 1 e n numa ordem aleatória
sample(n, m, replace=TRUE), onde m pode ser
maior que n, devolve m números entre 1 e n (podem
aparecer números repetidos)
sample(n, m, replace=FALSE), ou somente
sample(n, m), devolve m números entre 1 e n (não
podem aparecer números repetidos pelo que m tem de ser
menor ou igual a n)
O argumento opcional prob permite definir probabilidades

diferentes para cada elemento, nesse caso o vector
fornecido em prob tem que ter tantos elementos quantos
o vector ao qual se aplica o sample
sample(6, 20, replace=T, prob=c(50, 20, 10,
10, 10, 10)) devolve 20 números entre 1 e 6, sendo
que a probabilidade de ser 1 é de 50%, de ser 2 é de 20%
e 10% para os restantes

Notas sobre probabilidades:

Sempre que temos dois acontecimentos independentes
que queremos que aconteçam em simultâneo, a
probabilidade disso acontecer é o produto das
probabilidades de cada um deles
Sempre que temos dois acontecimentos independentes e
tanto nos faz qual deles vai acontecer desde que aconteça
um deles, a probabilidade disso acontecer é igual à soma
das probabilidades de cada um deles

ggplot2
Baseada no conceito de Gramática de gráficos: conjunto
de componentes independentes que podem ser
compostos de diferentes formas
Os gráficos podem ser criados de uma forma iterativa e
editados mais tarde
Usa um conjunto bem escolhido de valores por omissão
(defaults) de modo a facilitar a criação da maior parte dos
gráficos
Os gráficos são criados por camadas: a primeira camada
mostra os dados em bruto, e depois adiciona-se camadas
de anotações e sumários estatísticos
O uso da gramática dos gráficos evita que os gráficos
sejam somente um conjunto de casos especiais,
permitindo olhar para um gráfico como uma coleção de
elementos que podem ser combinados
ggplot2 — gramática dos gráficos
A gramática dos gráficos (criada por Wilkinson em 2005)

representa os aspetos mais profundos de todos os
gráficos estatísticos, é uma resposta à questão “o que é
um gráfico estatístico”
A gramática diz que um gráfico estatístico é um
mapeamento dos dados para atributos estéticos (cor,
forma, tamanho) de objetos geométricos (pontos, linhas,
barras)
O gráfico pode conter transformações estatísticas dos
dados e é desenhado num sistema de coordenadas
específico
Usando facetas pode-se gerar o mesmo gráfico para
diferentes subconjuntos dos dados

ggplot2 — gramática dos gráficos (cont.)
data: os dados que se pretende visualizar e um conjunto

de mapeamentos estéticos descrevendo como é que as
variáveis nos dados são mapeadas em atributos estéticos
geoms: objetos geométricos representando o que se vê
no gráfico: pontos, linhas, polígonos
stats: transformacções estatísticas que sumariam os
dados, por exemplo colocar em contentores e somar as
observações para obter um histograma
scales: mapeiam valores no espaço dos dados num
espaço estético, podendo ser cor, tamanho ou forma. As
escalas desenham uma legenda ou eixos que fornecem
um mapeamento inverso para permitir ler os dados
originais a partir do gráfico

ggplot2 — gramática dos gráficos (cont.2)

coord: um sistema de coordenadas que descreve como
os dados são mapeados no plano do gráfico, fornece eixos
e grelhas para facilitar ler o gráfico, normalmente usa-se
coordenadas cartesianas, mas às vezes usa-se
coordenadas polares ou projeções esféricas num mapa
facet: (também conhecido como condicionamento ou
latticing/trellising) uma especificação de facetas que
permite particionar os dados em subconjuntos e dizer
como visualizar esses subconjuntos
A gramática não especifica como é que o gráfico deve
aparecer (nomeadamente a cor de fundo ou o tamanho ou
tipo de letra), para isso usa-se o suporte que ggplot2
fornece para se criar temas
A gramática não especifica suporte para interação, é
somente para gráficos estáticos
Os dados, os mapeamentos estéticos, as stats, os geoms,

e os ajustes de posição formam uma camada, um plot
pode ter várias camadas
Um gráfico em ggplot2 é por conseguinte a combinação
de:
Um conjunto de dados base (normalmente um dataframe)
e um conjunto de mapeamentos de variáveis em atributos
estéticos
Uma ou mais camadas, cada uma delas composta de um
objeto geométrico, uma transformação estatística, um
ajuste de posição, e opcionalmente um conjunto de dados
e mapeamentos estéticos
Uma escala para cada um dos mapeamentos estéticos
Um sistema de coordenadas
A especificação das facetas

O modelo usado pelo plot() standard é o de papel e

caneta, uma vez um gráfico desenhado só se pode
desenhar mais coisas em cima do gráfico, não se pode
apagar nem modificar
No ggplot2 já os gráficos podem ser modificados mais
tarde, começa-se por se criar o gráfico base e a seguir
aplicam-se alterações que podem ser adições, remoções
ou modificações
Por esta razão com o ggplot2 consegue-se ter muito
mais controle sobre o aspeto e o conteúdo dos gráficos

ggplot2 — qplot (quick plot)
install.packages("ggplot2");
library(ggplot2)
mpg é um dataframe que vem com o ggplot2 com 234
linhas e 11 variáveis para os 38 modelos de carros que
foram atualizados todos os anos entre 1999 e 2008 nos
Estados Unidos (isto é, os modelos mais populares).
Contém os seguintes dados: manufacturer, model,
displ (litros), year (1999 ou 2008), cyl, trans (tipo de
transmissão), drv (tracção), cty (consumo em milhas por
galão na cidade), hwy (idem highway), fl (tipo de
combustível), class. Para mais informação executar
?mpg

ggplot2 — qplot (cont.)
qplot() (quick plot) permite de uma forma rápida criar

gráficos usando valores pré-definidos do ggplot2
qplot(x, y, ..., data, facets=NULL,
margins=FALSE, geom="auto", xlim=c(NA,NA),
ylim=c(NA,NA), log="", main=NULL,
xlab=NULL, ylab=NULL, asp=NA, stat=NULL,
position=NULL)
qplot(displ, hwy, data=mpg) permite comparar a
eficiência de combustível em autoestrada em função da
cilindrada do motor usando o dataframe mpg

ggplot2 — qplot (cont.2)
qplot(displ, hwy, colour=cyl, data=mpg)

permite comparar a eficiência de combustível em
autoestrada em função da cilindrada do motor mas
tomando também em linha de conta o no de cilindros.
¯
Uma vez que o no de cilindros é um valor discreto é
¯
preferível fazer (e obtém-se um gráfico mais legível):
qplot(displ, hwy, colour=factor(cyl),
data=mpg), neste caso como o no de cilindros é 4, 5, 6
¯
ou 8 (4 hipóteses) o qplot escolhe 4 tonalidades o mais
afastadas possível umas das outras
Cada ponto no scatterplot (gráfico de pontos) pode ter uma
cor, um tamanho e uma forma, no caso anterior o tamanho
e a forma eram fixos e usam os valores por omissão, e a
cor foi usada para representar o no de cilindros
¯
O argumento facets permite criar uma matriz de

gráficos, cada um deles representando um subconjunto
dos dados, facets=row_var~col_var cria uma matriz
com row_var como a variável de linha e col_var como
a variável de coluna. Se se pretender somente uma coluna
usa-se facets=row_var~. e se se pretender somente
uma linha usa-se facets=.~col_var
qplot(displ,hwy,data=mpg, facets= .~year)
cria uma matriz de gráficos com 1 linha e 2 colunas
(porque só existem 2 datas, 1999 e 2008) com os valores
correspondentes a 1999 e a 2008

qplot(displ,hwy,data=mpg, facets= .~year) +

geom_smooth() adiciona ao gráfico uma função
estatística, neste caso usa um loess smoother (LOcal
regrESSion, uma generalização de LOcally WEighted
Scatterplot Smoothing) para suavizar os dados criando
uma linha que passa pelo meio dos dados, desta forma
representando a tendência dos dados
Em ggplot2 pode-se usar last_plot para obter o
último gráfico qu foi criado (útil se nos esquecemos de o
atribuir a uma variável e agora pretendemos modificá-lo ou
imprimi-lo

Comparação entre qplot() e ggplot()
O ggplot() permite que usando camadas se junte dados

adicionais a um gráfico
No ggplot() cada camada pode vir de um conjunto de
dados diferente e ter um mapeamento estético diferente,
este tipo de plots não pode ser gerado por qplot() visto
que o qplot() só permite ter um único conjunto de
dados e um único conjunto de mapeamentos estéticos

Equivalente ggplot() de comando qplot()
1 qplot(x, y, data=dados, shape=shape1,

colour=colour1)
ggplot(dados, aes(x, y, shape=shape1),
colour=colour1)) + geom_point()
2 qplot(x, y, data=dados, colour=I("red"))
ggplot(dados, aes(x, y)) +
geom_point(colour="red")
3 qplot(x, y, data=dados, geom="line")
ggplot(dados, aes(x, y)) + geom_line()
4 qplot(x, y, data=dados, geom=c("point",
"smooth"))
ggplot(dados, aes(x, y)) + geom_point() +
geom_smooth()

Equivalente ggplot() de comando qplot() (cont.)
5 qplot(x, y, data=dados, stat="bin")

geom_point(stat="bin")
6 qplot(x, y, data=dados, geom=C("point",
"smooth"), method="lm")
geom_point(method="lm") +
geom_smooth(method="lm")
7 qplot(x, y, data=dados, xlim=c(1, 5),
xlab="Legenda X")
scale_x_continuous("Legenda X",
limits=c(1, 5))

Equivalente ggplot() de comando qplot() (cont.2)
8 qplot(x, y, data=dados, xlim=c(1, 5),

ylim=c(10, 20))
scale_x_continuous(limits=c(1, 5)) +
scale_y_continuous(limits=c(10, 20))
9 qplot(x, y, data=dados, log="xy")
scale_x_log10() + scale_y_log10()
10 qplot(x, y, data=dados, main="Título",
asp=1)
opts(title="Título", aspect.ratio=1)

matematicaEstatisticaIpmaia Rstudio

Enviado por

Dados do documento

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

matematicaEstatisticaIpmaia Rstudio

Enviado por

Direitos autorais:

Formatos disponíveis

Matemática e Estatística

CTeSP Tecnologias e Programação de Sistemas de Informação

Alexandre Sousa (avs@ismai.pt)

Objetivos (Usando Excel e R)

CTeSP TPSI Matemática e Estatística 3 / 174

CTeSP TPSI Matemática e Estatística 4 / 174

O R encontra-se em desenvolvimento activo e é

CTeSP TPSI Matemática e Estatística 6 / 174

The Comprehensive R Archive Network

Em Windows, em Mac OS X, ou em Linux:

CTeSP TPSI Matemática e Estatística 8 / 174

Pode-se alterar a prompt do R ou do RStudio usando

CTeSP TPSI Matemática e Estatística 13 / 174

Exemplo 1: analizar relação Idade vs Peso

Idade (meses) Peso (Kg)

Criar 2 vectores, um para cada um dos dois tipos de dados:

Exemplo 1: analizar relação Idade vs Peso (cont.)

Exemplo 1: analizar relação Idade vs Peso (cont.2)

Figure: plot(idade, peso)

CTeSP TPSI Matemática e Estatística 16 / 174

Exemplo 1: analizar relação Idade vs Peso (cont.3)

Sumariar (resultado depende do formato dos dados):

CTeSP TPSI Matemática e Estatística 17 / 174

Exemplo 2: pessoas com excesso de peso

O índice da massa corporal imc é definido como sendo o

CTeSP TPSI Matemática e Estatística 18 / 174

Exemplo 2: pessoas com excesso de peso (cont.)

1.65 1.70 1.75 1.80 1.85 1.90

Figure: plot(peso, altura); lines(xx, 22.5 * xx ^ 2)

CTeSP TPSI Matemática e Estatística 19 / 174

Complementar gráfico c/ elementos adicionais

Complementar gráfico c/ elementos adicionais (cont.)

Ver o texto de help associado a ?par (set or query

CTeSP TPSI Matemática e Estatística 21 / 174

T e F são abreviaturas para TRUE e FALSE, infelizmente

CTeSP TPSI Matemática e Estatística 23 / 174

Representação de datas em R (cont.)

Atenção ao escolher os nomes das variáveis já que os

CTeSP TPSI Matemática e Estatística 30 / 174

Usar rep() para gerar valores com padrão de repetição

Usar rep() para gerar valores com padrão de repetição

No rep() pode-se também usar em simultâneo times e

CTeSP TPSI Matemática e Estatística 32 / 174

Usar seq(from,to,by) para gerar sequência de valores

Aritmética com valores escalares

Aritmética com valores escalares (cont.)

Mesmo quando se fornece um inteiro ele é armazenado

Dado um vector x substituir todos os seus elementos

CTeSP TPSI Matemática e Estatística 41 / 174

Conversão de Vector para Matrix

Indexar vector c/ índices positivos e negativos

Indexar vector c/ índices positivos e negativos (cont.)

Combinar 2 vectors intercalando os valores

Se tivermos 2 vectors x e y com a mesma quantidade de

CTeSP TPSI Matemática e Estatística 45 / 174

A matrix é um array bidimensional em que todos os

CTeSP TPSI Matemática e Estatística 46 / 174

Uma matriz pode também ser criada usando a função

Aritmética com matrizes:

CTeSP TPSI Matemática e Estatística 49 / 174

A matriz identidade é uma matriz quadrada que contém 1’s

CTeSP TPSI Matemática e Estatística 50 / 174

Indexar matrix c/ índices positivos e negativos

Indexar matrix c/ índices positivos e negativos (cont.)