O uso de softwares e pacotes estatísticos
para análise de dados é de grande importância.
Dentre os softwares de domínio público, um
que tem ganhado destaque é o Ambiente R.
R é uma linguagem de alto nível e um
ambiente para análise de dados e geração de gráficos.
Tem código aberto: pode ser modificado,
aprimorado a qualquer momento por qualquer usuário.
Foi desenvolvida por Chambers e cols. Início em 1976 para análises estatísticas,
usando Fortran
1991 – Criado na Nova Zelândia (University of
1993 – Primeira divulgação ao público. 1995 – Tornou-se um software livre.
1997 – É formado o Core Group, que controla
o código fonte do R.
2000 – A versão 1.0.0 é lançada. 2018 – Versão 3.5.0
Instalando o R:
http://www.r-project.org/
Clique em
CRAN mirror
.
A execução do R faz aparecer a janela do
aplicativo.
Esta janela apresenta o prompt do R (> ), com
o cursor à sua frente.
É aqui que vamos introduzir os comandos que
pretendemos que o R execute.
Podemos começa por um exemplo:
escreva o seguinte comando no prompt : > R.version
Os arquivos com o dados da sessão são
sempre gravados no diretório atual do R.
Para saber o diretório atual do R: > getwd()
O R tem um sistema de ajuda bastante elaborado
que lhe permitirá obter muita informação extra sobre a linguagem, bem como muitos outros aspectos.
Nas versões Windows do R, a forma mais fácil de
obter ajuda é através do menu Help
Se pretende simplesmente obter ajuda sobre uma
função em particular do R, a forma mais simples é usar a função help():
Para terminar a execução do R basta executar o
seguinte comando:
> q()
Aparece uma janela salvar, se responderYes
vai salvar a informação contida na memória do computador num arquivo.
A informação guardada consiste basicamente na
história de comandos que executamos nesta sessão (Rhistory), bem como os objetos que criamos (Rdata).
Interface para o R.
IDE – Integrated Development Enviroment Integração com o R e um editor de texto para
Instalando Rstudio:
https://www.rstudio.com/
Integra-se à última versão do R
Janela onde devem ser digitados os comandos
Após clicar em Run, a linha de comandos atual ou as linhas selecionadas são
Lista com os objetos criados Aba com histórico dos
Files: conteúdo do diretório atual Plots: exibe os gráficos gerados
Packages: pacotes instalados e carregados Help: ajuda
Uma instalação do R vem já com um conjunto de pacotes
instalados.
Os pacotes são conjuntos de funções que foram criadas por
alguém e disponibilizadas.
Qualquer pessoa pode criar as seus pacotes e submetê-los
ao portal do R.
Quando se executa o R só algumas funções estão
disponíveis de imediato.
Em qualquer momento poderemos “carregar” um pacote
que contenha funções extra que necessitemos.
Para isso o pacote ter que estar instalado no nosso
computador.
Definir uma pasta de trabalho
Crie uma pasta para a disciplina Entre em Tools>Global options
Em Default working directory escolher a pasta
criada.
O R é uma linguagem baseada em objetos.
Isto quer dizer que tudo o que vamos usar no R
está guardado na memória do computador sob a forma de um objeto.
Todos os objetos em R tem um nome
associado e podem armazenar diferentes tipos de coisas (números, texto, vetores, matrizes, expressões, chamadas a funções, etc.).
Para armazenar algo num objeto usamos o
operador de atribuição:
<- Exemplo:
freq.p <- 0.6
Para ver o conteúdo do objeto:
O [1] que aparece antes do número guardado no
objeto tem o significado “esta linha mostra o
conteúdo do objeto, começando pelo elemento nº 1”.
O significado disto tornar-se mas claro quando virmos
objetos que podem armazenar mais do que um elemento, p. ex. um vetor contendo 100 números.
A operação de atribuição é destrutiva no sentido que
ao atribuir um novo valor a um objeto existente,
vamos perder o conteúdo que ele estava armazenado anteriormente.
Também podemos atribuir expressões numéricas a
objetos.
O resultado de tal operação é o de que o resultado
do cálculo da expressão é colocado no objeto, e não a expressão propriamente dita:
z <- 5 w <- z^2 w [1] 25 i <- (z * 2 + 45)/2 i [1] 27.5
Sempre que criamos um novo objeto ele ficará
na memória do computador. Como esta é
limitada, poderemos apagar os objetos sempre que não precisarmos mais deles.
Podemos ver quais os objetos atualmente na
memória do computador usando as funções ls()
ou objects().
Se não necessitamos de algum dos objetos
O nome dos objetos pode ser formado por
qualquer letra maiúscula ou minúscula, os dígitos 0 a 9 (exceto no início do nome), e também o ponto final.
Os nomes dos objetos em R são sensíveis às
letras maiúsculas / minúsculas.
Note também que não pode usar espaços nos
O objeto mais básico do R para guardar
dados é o vetor.
Um vetor é uma estrutura de dados que
permite armazenar um conjunto de valores do mesmo tipo (por exemplo números) sob um mesmo nome.
Esses elementos podem depois ser acessados
individualmente usando um esquema de indexação.
Este tipo de estrutura de dados é bastante
útil quando pretendemos armazenar várias coisas relacionadas na memória do
Todos os vetores em R tem um modo e um
tamanho.
O modo determina o tipo de valores guardado no
vetor.
Em R podemos ter vetores com modo character,
logical,numeric e complex.
Ou seja, podemos ter vetores para armazenar os
seguintes tiposde dados: conjuntos de caracteres, valores lógicos (F ou T ou FALSE ou TRUE),
Para criar vetores usamos a função c() para
indicar ao R os elementos que formam o vetor separando-os por vírgulas:
v <- c(4, 7, 23.5, 76.2, 80) v [1] 4.0 7.0 23.5 76.2 80.0 length(v) [1] 5 mode(v) [1] "numeric"
Todos os elementos de um vetor tem que ser
do mesmo tipo (modo).
Caso tentemos criar um vetor com tipos
diferentes, o R vai forçá-los a ser do mesmo tipo, alterando-os.
Vejamos um exemplo disso:
v <- c(4, 7, 23.5, 76.2, 80, "rrt") v
Todos os vetores podem ter um elemento
especial que é o NA.
Este valor representa um valor desconhecido. Por exemplo, se temos a idade de pacientes
guardados num vetor, mas não temos essa
informação de um indivíduo, podemos criar esse vetor:
idade<- c(23, 45, NA, 34) idade
Os elementos de um vetor podem ser
acessados através de um índice:
idade[2]
O R permite-nos criar vetores vazios usando a
função vector():
k <- vector()
O tamanho de um vetor existente pode ser
alterado atribuindo mais elementos a índices até agora inexistentes:
k[3] <- 45 k
A linguagem R permite “vetorizar” a maioria
das suas funções.
Exemplo:
a função sqrt() que serve para calcular raízes
quadradas: v <- c(4, 7, 23.5, 76.2, 80) x <- sqrt(v) x [1] 2.000000 2.645751 4.847680 8.729261 8.944272
O R pode ser usado para fazer operações
aritméticas envolvendo vetores:
v1 <- c(4, 6, 87)
v2 <- c(34, 32.4, 12)
v1 + v2
O que acontece se tentamos realizar
operações envolvendo vetores de tamanho diferente?
O R vai usar um regra de reciclagem dos
valores do vetor mais curto até este atingir o tamanho do maior. Por exemplo:
v1 <- c(4, 6, 8, 24)
v2 <- c(10, 2)
v1 + v2
Os fatores proporcionam uma forma fácil e
compacta de lidar com dados categóricos (ou nominais).
Este tipo de dados podem ser vistos como
variáveis que podem tomar como valores
possíveis um conjunto finito de etiquetas (por exemplo uma variável que armazene o estado civil de uma pessoa).
Os fatores tem associados a eles um conjunto de
níveis que são os valores possíveis que podem tomar.
Vejamos como criar fatores em R.
Suponhamos que pretendemos guardar o
sexo 10 indivíduos num vetor:
s <- c("f", "m", "m", "m", "f", "m", "f", "m",
"f", "f")
s
Ao transformarmos um vetor de caracteres
num fator, o R vai dar-nos a possibilidade de fazer coisas como por exemplo contar
quantas vezes ocorre cada valor desse fator.
Podemos transformar um vetor de caracteres
num fator da seguinte forma:
s <- factor(s)
s
[1] f m m m f m f m f f
Suponha agora que temos 4 indivíduos cujo sexo
pretendemos armazenar.
Imagine que por coincidência todos pertencem
ao sexo masculino.
Se pretendemos que o fator resultante
mantenha os 2 níveis possíveis para o sexo de um indivíduo teremos que fazer:
outro.s <- factor(c("m", "m", "m", "m"), levels = c("f", "m"))
outro.s
[1] m m m m
Uma das vantagens de transformar um vetor de
caracteres num fator, é a possibilidade de usar funções específicas para lidar com fatores.
Uma dessas funções permite-nos contar o número de
ocorrências de cada valor (nível):
table(s) s f m 5 5 table(outro.s) outro.s f m 0 4
A função table() também pode ser usada para
fazer tabulações cruzadas de dois fatores,
desde que estes tenham o mesmo tamanho.
Imaginemos que temos um outro vetor com
as idades dos indivíduos cujo sexo está armazenado em s.
Podemos fazer uma tabulação cruzada da
idade <- factor(c("adulto", "adulto", "jovem", "jovem", "adulto“, "adulto", "adulto", "jovem", "adulto", "jovem"))
table(idade, s)
idade f m
adulto 4 2
Também é possível obter frequências
marginais e relativas.
Por exemplo, para saber o número total de
adultos e jovens faríamos:
tabela.cruzada <- table(idade, s)
margin.table(tabela.cruzada, 1)
idade
adulto jovem
Frequências relativas função prop.table() prop.table(tabela.cruzada, 1) s idade f m adulto 0.6666667 0.3333333 jovem 0.2500000 0.7500000 prop.table(tabela.cruzada, 2) s idade f m adulto 0.8 0.4 jovem 0.2 0.6 prop.table(tabela.cruzada) s idade f m adulto 0.4 0.2 jovem 0.1 0.3
Podem-se gerar sequências em R de várias de
formas.
Por exemplo, para criar um vetor com os
números de 1 a 1000.
Em vez de os escrevermos todos, podemos
usar:
Exemplos: seq(from = 1, to = 5, length = 4) [1] 1.000000 2.333333 3.666667 5.000000 seq(from = 1, to = 5, length = 2) [1] 1 5 seq(length = 10, from = -2, by = 0.2) [1] 2.0 1.8 1.6 1.4 1.2 1.0 0.8 0.6 0.4 -0.2
Uma outra função bastante útil para gerar
sequências é a função rep():
rep(5, 10)
[1] 5 5 5 5 5 5 5 5 5 5 rep("sim", 3)
[1] "sim" "sim" "sim“
rep(1:3, 2)
A função gl() pode ser usada para gerar
sequências envolvendo fatores.
A sintaxe é gl(k,n), em que k é o número de níveis
do fator e n o número de fatores de cada nível.
Vejamos dois exemplos, gl(3, 5)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
Levels: 1 2 3
gl(2, 5, labels = c("nao", "sim"))
[1] nao nao nao nao nao sim sim sim sim sim
O R tem uma série de funções para gerar
sequências aleatórias de acordo com uma série de funções de distribuição de
probabilidade.
Essas funções tem a forma genérica rfunc(n,
par1, par2, ...), em que n é o número de dados a gerar, e par1, par2, ...são valores de alguns parâmetros que a função específica possa precisar
Por exemplo, se pretendemos 10 números
gerados aleatoriamente de acordo com uma distribuição normal de média 0 e desvio
padrão unitário, podemos fazer:
Se preferirmos 10 números provenientes de
uma distribuição normal com média 10 e desvio padrão 3, faríamos:
De igual modo para obter 5 números obtidos
de forma aleatória de uma distribuição t de Student com 10 graus de liberdade, fazemos:
Por vezes poderemos estar interessados em
armazenar a nossa informação em estruturas de dados com mais do que uma dimensão.
As matrizes arranjam a informação em duas
dimensões.
Em R, as matrizes são vetores com uma
Exemplo: temos 12 números correspondentes às
vendas trimestrais durante um ano, em três lojas.
As instruções seguintes permitem “organizar” esses
números como uma matriz:
vendas <- c(45, 23, 66, 77, 33, 44, 56, 12, 78, 23, 78, 90) vendas [1] 45 23 66 77 33 44 56 12 78 23 78 90 dim(vendas) <- c(3, 4) vendas [,1] [,2] [,3] [,4] [1,] 45 77 56 23 [2,] 23 33 12 78 [3,] 66 44 78 90
Na realidade seria mais simples criar a matriz
usando uma função específica para isso:
vendas <- matrix(c(45, 23, 66, 77, 33, 44,
Os números foram “espalhados” pela matriz
por coluna, i.e. primeiro foi preenchida a primeira coluna, depois a segunda, etc.
Caso não seja isto o que queremos,
poderemos preencher a matriz por linhas da seguinte forma:
vendas <- matrix(c(45, 23, 66, 77, 33, 44,
> vendas
[,1] [,2] [,3] [,4]
[1,] 45 23 66 77
[2,] 33 44 56 12 [3,] 78 23 78 90
Nas matrizes podemos dar nomes para linhas e
colunas:
Vejamos como fazer isso no exemplo anterior: rownames(vendas) <- c("loja1", "loja2",
"loja3")
colnames(vendas) <- c("1.trim", "2.trim", "3.trim", "4.trim")
Podemos acessar elementos individuais das
matrizes usando um esquema de indexação:
vendas[2, 2]
[1] 44
Ou então, usando os nomes:
vendas["loja2", "2.trim"]
As funções cbind() e rbind() podem ser
usadas para juntar dois ou mais vetores ou matrizes, por colunas ou por linhas,
O seguinte exemplo ilustra o seu uso: m1 <- matrix(c(45, 23, 66, 77, 33, 44, 56, 12, 78, 23), 2, 5) m1 [,1] [,2] [,3] [,4] [,5] [1,] 45 66 33 56 78 [2,] 23 77 44 12 23 cbind(c(4, 76), m1[, 4]) [,1] [,2] [1,] 4 56 [2,] 76 12
As regras aritméticas também se aplicam as matrizes. Exemplos: m <- matrix(c(45, 23, 66, 77, 33, 44, 56, 12, 78, 23), 2, 5) m [,1] [,2] [,3] [,4] [,5] [1,] 45 66 33 56 78 [2,] 23 77 44 12 23 m * 3 [,1] [,2] [,3] [,4] [,5] [1,] 135 198 99 168 234 [2,] 69 231 132 36 69
Os arrays são extensões das matrizes para
mais do que duas dimensões. Isto significa que podem ter vários índices.
Existe uma função array() para facilitar a
criação de arrays
Lista é uma coleção ordenada de objetos
conhecidos como os componentes da lista.
Esses componentes não necessitam de ser do
mesmo tipo, modo ou tamanho.
Os componentes de uma lista em R são sempre
numerados e podem também ter um nome associados a eles.
estudante <- list(nro = 34453, nome = "Carlos + Silva", notas = c(14.3, 12, 15, 19))
estudante[[1]] ou
Um data frame é um objeto do R usado para guardar
tabelas de dados de um problema qualquer.
É muito semelhante a uma matriz, mas as suas colunas
tem nomes e podem conter dados de tipo diferente, diferente da matriz.
Um data frame pode ser visto como uma tabela de uma
base de dados, em que cada linha corresponde a um registro (linha) da tabela. Cada coluna corresponde às propriedades (campos) a serem armazenadas para cada registro da tabela.
notas.inform <- data.frame(nros = c(2355, 3456, 2334,
+5456), turma = c("tp1", "tp1", "tp2", "tp3"), notas = +c(10.3, 9.3, 14.2, 15))
