1 Objetos no R

O R trabalha com vários tipos de objetos. Esses objetos podem ser vetores, matrizes, funções, planilhas de dados, etc. A seguir apresentamos alguns destes objetos e como eles podem ser criados.

1.1 Vetores

Os vetores são um dos tipos de objetos mais importantes e mais usados no R. Eles podem armazenar números, nomes, elementos lógicos, desde que sejam da mesma classe.

1.1.1 Criando vetores no R

Um vetor é criado no R com a função c() (c de “concatenate”), onde entre os parênteses escrevemos os elementos do vetor separados por vírgula. Mostramos, a seguir, alguns exemplos:

Vamos guardar num vetor denominado notas as notas de 5 alunos na prova de Estatística: 19, 20, 25, 23, 29. Para isto fazemos:

notas = c(19, 20, 25, 23,  29)
notas
## [1] 19 20 25 23 29

Suponha que as notas acima correspondam aos alunos: Bruno, Luara, Caio, Maria e Rita. Um vetor com os nomes dos alunos, nomeado como nomes, e criado fazendo:

nomes = c("Bruno", "Luara", "Caio","Maria", "Rita")
nomes
## [1] "Bruno" "Luara" "Caio"  "Maria" "Rita"

Ao criar um vetor de caracteres os nomes que constituem os elementos do vetor devem ser escritos entre aspas duplas.

1.1.2 Valores faltantes no R

Suponha que o aluno Pedro não realizou a prova e, portanto, a informação sobre sua nota não está disponível. No R, usamos o símbolo NA (not available) para identificar as observações faltantes. Vamos incluir o nome Pedro no vetor nomes e criar um novo vetor de notas denominado notasE, incluindo a observação NA para Pedro.

nomes = c(nomes, "Pedro")
notasE = c(notas, NA)
nomes
## [1] "Bruno" "Luara" "Caio"  "Maria" "Rita"  "Pedro"
notasE
## [1] 19 20 25 23 29 NA


1.1.3 Criando vetores com sequências regulares de valores

Existem casos em que uma ordem ou sequência de observações se repete muitas vezes. Para estes casos, as funções seq() e rep() são muito úteis para a criação de um vetor, minimizando o tamanho do código necessário para a sua criação.

  1. Criar um vetor com números de 1 a 20 de nome “seq_a”:
seq_a = seq(from = 1 , to = 20, by = 1)
seq_a
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20
  1. Criando um vetor com a sequência acima no sentido inverso:
seq_b = seq(20,1)
seq_b
##  [1] 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1
  1. Criando uma sequência de 0 a 50 com intervalos de tamanho 5:
seq_c = seq(0,50,5)
seq_c
##  [1]  0  5 10 15 20 25 30 35 40 45 50
  1. Criando uma sequência de 21 valores distribuídos de maneira uniforme no intervalo de 0 a 50:
seq_d = seq(0, 40, length.out = 21)
seq_d
##  [1]  0  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
  1. Criando a sequência: 2,2,2,3,3,3,4,4,4,5,5,5,6,6,6:
seq_e<-rep(c(2,3,4,5,6),each=3) # each indica que cada elemento deve ser repetido 3 vezes
seq_e
##  [1] 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6
  1. Criando a sequência: 2,3,4,2,3,4,2,3,4,2,3,4,2,3,4:
seq_f = rep(c(2,3,4),times=5)  # times indica a quantidade de vezes que a sequência 2, 3, 4 deve ser repetida 
seq_f
##  [1] 2 3 4 2 3 4 2 3 4 2 3 4 2 3 4
  1. Sequência com os elementos aluno_1, aluno_2, aluno_3, aluno_4:
seq_g  = paste(c("aluno"),1:4,sep="_") # sep="_" indica que o nome do aluno é separado do número por um traço. 
seq_g
## [1] "aluno_1" "aluno_2" "aluno_3" "aluno_4"


1.1.4 Vetores lógicos

É possível criar vetores com padrões lógicos no R. Por exemplo, considere o vetor “notasE” com as notas de 6 alunos na prova de Estatística. Para sabermos quais alunos obtiveram nota maior ou igual a 60, avaliamos a seguinte condição lógica: notas >= 60. O R retorna a resposta TRUE se e condição avaliada é verdadeira e FALSE caso contrário, a resposta NA é impressa para os alunos para os quais não foi possível avaliar a condição de interesse.

notasE = c(56,89,90,100,47,NA)
aprovado = notasE>=60
aprovado
## [1] FALSE  TRUE  TRUE  TRUE FALSE    NA
No quadro abaixo indicamos como expressar outras condições lógicas. Observe que para expressar a condição lógica de igualdade usamos 2 sinais de igualdade.

Operação lógica Operador
maior que <
menor que >
igual a ==
maior ou igual que >=
menor ou igual que <=
diferente que !=
avalia se condição
x é falsa 		!x
avalia se condições
x e y são verdadeiras 		x & y
avalia se condições
x ou y são
verdadeiras 		x | y


Frequentemente a expressão lógica a ser avaliada é composta de 2 ou mais expressões logicas aplicadas aos elementos de um ou mais vetores. Por exemplo, considere que vetor “notasC” expresse as notas de Cálculo 1, com o seguintes valores: 70, 65, 85, 90, 6, 89:

notasC = c(70,65,85,90,6,89)

Como podemos avaliar as seguintes condições lógicas?:
a) Nota menor do que 80 nas duas disciplinas.
b) Nota menor do que 80 em pelo menos uma das disciplinas.

Para isto, vamos usar os operadores lógicos “&” e “|”.

notasE<80 & notasC<80  # ambas notas menores do que 80
## [1]  TRUE FALSE FALSE FALSE  TRUE FALSE
notasE<80 | notasC<80  # uma ou mais notas menores do que 80
## [1]  TRUE  TRUE FALSE FALSE  TRUE    NA

A função is.na() é uma expressão lógica que retorna TRUE se o elemento do vetor é NA e FALSE, caso contrário. Se desejarmos saber se o elemento do vetor não é um NA, utilizamos !is.na(). Veja os exemplos:

is.na(notasE) # responde a pergunta: o elemento do vetor é um NA?
## [1] FALSE FALSE FALSE FALSE FALSE  TRUE
!is.na(notasE) # responde a pergunta: o elemento do vetor é um NA?
## [1]  TRUE  TRUE  TRUE  TRUE  TRUE FALSE


1.1.5 Operações com vetores

Cálculos matemáticos podem ser realizados com os elementos de um vetor numérico. Valem aqui as propriedades de vetores. Considere os seguintes exemplos:

  1. Acrescentar 3 pontos a nota de cada aluno na prova de Estatística:
notasE + 3
## [1]  59  92  93 103  50  NA
  1. Somar para cada aluno as notas de Estatística e Cálculo:
(notasE + notasC)
## [1] 126 154 175 190  53  NA
  1. Obtendo a nota média nas 2 provas:
(notasE + notasC)/2
## [1] 63.0 77.0 87.5 95.0 26.5   NA

Quando algum cálculo numérico for impossível de ser realizado o R retorna a observação NaN (not a number). Por exemplo, quando calculamos o logaritmo da diferença entre as notas dos alunos nas 2 provas o simbolo NaN é retornado, para a primeira observação que apresenta valor negativo para a diferença entre as notas.

notasE-notasC
## [1] -14  24   5  10  41  NA
log(notasE-notasC)
## Warning in log(notasE - notasC): NaNs produzidos
## [1]      NaN 3.178054 1.609438 2.302585 3.713572       NA
Na tabela seguinte são apresentados os símbolos utilizados pelo R para representar as operações matemáticas elementares e outros operações muito utilizadas.

Operador Aritmético Elementar Simbologia
Soma +
Subtração -
Divisão /
Multiplicação *
Potência ^
Raiz quadrada sqrt()
Logaritmo log()
Exponencial exp()
Cosseno cos()
Sen sen()
Tangente tan()


1.1.6 Acessando, selecionando e modificando elementos de um vetor

Os elementos de um vetor são identificados por suas posições variando de 1 a n, onde n é o comprimento do vetor. Por exemplo, para o vetor “notasE” com 6 elementos as posições variam de 1 a 6. Subconjuntos ou elementos de um vetor são selecionados indicando entre colchetes a ordem dos elementos desejados. Mostramos a seguir alguns exemplos.

nomes
## [1] "Bruno" "Luara" "Caio"  "Maria" "Rita"  "Pedro"
notasE
## [1]  56  89  90 100  47  NA
notasE[1]      # retorna a nota do aluno 1, Bruno
## [1] 56
notasE[1:3]  # retorna as notas dos alunos 1,2 e 3: Bruno, Luara e Caio
## [1] 56 89 90
notasE[c(2,4,6)] # retorna as notas dos alunos 2, 4 e 6: Luara, Maria e Pedro
## [1]  89 100  NA

Podemos também usar as expressões lógicas para selecionar as notas dos alunos. Seguem alguns exemplos:

notasE[notasE > 80]  # retorna  notas maiores do que 80
## [1]  89  90 100  NA
notasE[!is.na(notasE)] # retorna notas sem dados faltantes
## [1]  56  89  90 100  47
notasE[nomes=="Maria"] # retorna  nota de Maria
## [1] 100
notasE[nomes == "Maria" | nomes == "Rita"] # retorna notas de notas dos alunos MAria e Rita
## [1] 100  47
nomes[notasE>80 & !is.na(notasE)] #retorna notas maiores do que 80 e diferentes de NA
## [1] "Luara" "Caio"  "Maria"

Agora que sabemos como acessar os elementos é fácil modificar um elemento do vetor. Suponha que o aluno Pedro fez a segunda chamada da prova e obteve nota 80. Podemos substituir a observação NA atribuída a nota de Pedro pela nota 80 fazendo:

notasE[6]=80
notasE
## [1]  56  89  90 100  47  80

ou de forma equivalente fazendo notasE[nomes=="Pedro"] = 80.

1.1.7 Verificando características dos vetores

Apresentamos a seguir algumas funções úteis que permitem avaliar propriedades dos vetores:

  1. Para avaliar o tamanho do vetor usamos a função length():
length(nomes)
## [1] 6
  1. Para avaliar o tipo de vetor, se numérico (num), de caracteres (chr) ou lógico (logi) usamos a função str(structure):
str(nomes)
##  chr [1:6] "Bruno" "Luara" "Caio" "Maria" "Rita" "Pedro"
str(notasE)
##  num [1:6] 56 89 90 100 47 80
str(aprovado)
##  logi [1:6] FALSE TRUE TRUE TRUE FALSE NA
  1. Para avaliar se um objeto é um vetor usamos a função is.vector():
is.vector(notasE)
## [1] TRUE
  1. Para encontrar o valor mínimo e máximo de um vetor:
min(notasE)
## [1] 47
max(notasE)
## [1] 100
  1. Para calcular a soma e o produto de todos os elementos de um vetor:
sum(notasE)
## [1] 462
prod(notasE)
## [1] 168658560000
  1. Para ordenarmos os valores de um vetor, usamos a função sort(). Para ordenação crescente fazemos o argumento decreasing igual a TRUE. Quando não especcificamos esse argumento ou o fazemos igual a FALSe a ordenação crescente é considerada.
sort(notasE,decreasing = FALSE) # ordem crescente dos valores
## [1]  47  56  80  89  90 100
sort(notasE, decreasing = TRUE) #ordem decrescente dos valores
## [1] 100  90  89  80  56  47

Quando o vetor contiver nomes (quantidades não numéricas), a ordenação é realizada segundo a ordem alfabética dos seus elementos.

  1. Para atribuir posições (ranks) aos elementos do vetor:
rank(notasE)
## [1] 2 4 5 6 1 3

Por exemplo, o aluno Bruno, que ocupa a primeira posição no vetor notasE, ocupa a segunda posição quando as notas são dipostas numa sequência ordenada crescente.

1.2 Fator

Fatores são os objetos do R adequados para representar variáveis categóricas. Por exemplo, considere as variáveis sexo (masculino ou feminino) e classe de renda (C < B < A). A variável sexo é uma variável categórica nominal e a variável renda categórica ordinal.

Quando uma variável é declarada como fator no R, seus valores são armazenados na memória do R como números inteiros e cada número possui um nome (label) associado. Por exemplo, a informação sobre sexo (masculino, feminino) é armazenada como (1,2).

Fatores possuem um número finito de categorias chamados de níveis que, a menos que se especifique de outra forma, são ordenados segundo a ordem alfabética. Por exemplo, o valor 1 é associado a categoria feminino e o valor 2 a categoria masculino. Embora o R armazene as categorias como valores inteiros, ele retorna seus “labels” quando visualizamos o fator.

1.2.1 Criando fatores no R

Para criar um fator no R usamos a função factor. A seguir criamos o fator esporte a partir da informação do tipo de esporte praticado por 8 pessoas.

esportes = factor(c("basquete","hipismo","handebol","futebol","tenis","judô","basquete", "futebol"))
esportes
## [1] basquete hipismo  handebol futebol  tenis    judô     basquete futebol 
## Levels: basquete futebol handebol hipismo judô tenis

Para visualizar os níveis do fator esportes, usamos a função levels como segue:

levels(esportes)
## [1] "basquete" "futebol"  "handebol" "hipismo"  "judô"     "tenis"

Suponha que as 8 pessoas acima foram classificadas como atletas de baixo, médio ou alto desempenho, e seus resultados foram armazenados no vetor de caracteres que denominamos de desempenho:

desempenho = c("baixo", "baixo","alto", "medio","baixo","medio","alto","alto")
desempenho
## [1] "baixo" "baixo" "alto"  "medio" "baixo" "medio" "alto"  "alto"

Transformamos o vetor desempenho em fator fazendo.

desempenho1 = factor(desempenho)
desempenho1
## [1] baixo baixo alto  medio baixo medio alto  alto 
## Levels: alto baixo medio

Observe que os níveis do fator estão ordenados segundo a ordem alfabética de seus nomes. Quando desejarmos uma outra ordenação dos níveis do fator, isto pode ser feito usando o argumento levels da função factor, onde especificamos a ordem desejada. Para que os níveis sejam ordenados na ordem baixo, médio, alto, fazemos:

desempenho1 = factor(desempenho,levels=c("baixo","medio","alto"))
desempenho1
## [1] baixo baixo alto  medio baixo medio alto  alto 
## Levels: baixo medio alto

Para algumas análises a informação da ordem dos fatores não importa, mas para outras sim. Informamos que a ordem é importante fazendo o argumento ordered. igual a TRUE.

desempenho1 = factor(desempenho,levels=c("baixo","medio","alto"),ordered=TRUE)
desempenho1
## [1] baixo baixo alto  medio baixo medio alto  alto 
## Levels: baixo < medio < alto

Observe que o output acima retorna o ordenamento dos níveis do fator.

1.2.2 Criando novas categorias para os níveis do fator

Para criamos um novo fator, denominado de tipo_esporte, com a classificação dos esportes em individual ou coletivo, primeiro fazemos:

tipo_esporte = esportes  # faz tipo de esporte  igual a esportes
levels(tipo_esporte)  # retorna os niveis da variavel tipo_esporte
## [1] "basquete" "futebol"  "handebol" "hipismo"  "judô"     "tenis"

Agora redefinimos os níveis da variável tipo_esporte atribuindo a cada um dos níveis originais do fator os novos labels. Por exemplo, ao primeiro nível, basquete, associamos o label coletivo, ao segundo nível, futebol, também associamos o label coletivo, e assim por diante. O codigo usado para isto é o seguinte.

levels(tipo_esporte)=c("coletivo","coletivo","coletivo","individual","coletivo","coletivo")
tipo_esporte
## [1] coletivo   individual coletivo   coletivo   coletivo   coletivo   coletivo  
## [8] coletivo  
## Levels: coletivo individual

Observe que o fator tipo_esporte tem agora 2 níveis, coletivo e individual.

1.3 Matriz

Matriz é um conjunto de vetores de mesmo comprimento que são organizados lado a lado. Uma matriz, assim como um vetor, deve conter somente elementos do mesmo tipo, isto é, uma matriz só poderá conter vetores numéricos, lógicos ou de caracteres.

1.3.1 Como construir uma matriz no R

Para construir uma matriz vamos usar a função matrix(), que cria uma matriz a partir de um conjunto de valores. Esta função tem como argumentos o conjunto de valores (data), o número de linhas (nrow) e o número de colunas (ncol).

Considere que 58 peças do tipo A e 58 peças do tipo B foram inspecionadas e classificadas segundo a presença de defeito, obtendo-se 12 defeituosas entre as do tipo A e 20 defeituosas entre as do tipo B. Como exemplo, vamos criar uma matriz, de nome M, com estes valores, representando a variável tipo da peça nas linhas e a variável presença de defeitos nas colunas, como mostrado na tabela seguinte:


Tipo de peça Presença de defeitos
Sim Não
A 12 46
B 20 38


Para dispor os elementos do vetor na forma de uma matriz é preciso informar o número de colunas da matriz com o argumento ncol, neste caso igual a 2.

M = matrix(data = c(12,20,46,38), ncol = 2)
M
##      [,1] [,2]
## [1,]   12   46
## [2,]   20   38

Note que os elementos do vetor data foram dispostos na matriz no sentido das colunas. Caso deseje preencher a matriz seguindo o sentido das linhas faça o argumento byrow igual a TRUE, como mostrado a seguir:

M = matrix(c(12,20,46,38), ncol = 2,byrow=T)
M
##      [,1] [,2]
## [1,]   12   20
## [2,]   46   38


Nesse caso a variavel tipo de peça corresponde às colunas e a variável presença de defeito ás linhas da tabela.

1.3.2 Nomeando as linhas e colunas da matriz

É possível adicionar nomes às colunas e às linhas da matriz usando o comando dimnames" e com o auxílio do objeto lista, list(), como mostrado abaixo:

M = matrix(c(12,20,46,38), ncol = 2, dimnames = list(c("Peças A","Peças B"),c("Com defeito","Sem defeito")))
M
##         Com defeito Sem defeito
## Peças A          12          46
## Peças B          20          38

As funções colnames e rownames também pode ser usadas para nomear as colunas e linhas de uma matriz. Por exemplo, para quiséssemos mudar os nomes das colunas da matriz M para “defeituosos” e não defeituosos”, basta fazer:

colnames(M) = c("Defeituosos","Não defeituosos")
M
##         Defeituosos Não defeituosos
## Peças A          12              46
## Peças B          20              38


1.3.3 Acessando e modificando elementos da matriz

Os elementos da matriz são identificados pela linha e coluna da matriz em que se encontram. Para obtermos o elemento pertencente à linha i e à coluna j da matriz M, usamos o código M[i,j]. Por exemplo:

M[1,1]   # retorna o elemento pertencente à primeira linha e primeira coluna de M
## [1] 12
M[2,1]  # retorna o elemento pertencente à segunda  linha e primeira coluna de M
## [1] 20

Para obter uma linha (coluna) inteira da matriz indique a sua posição e deixe em branco a posição da coluna (linha), como mostrado nos exemplos seguintes.

M[1,]  #retorna a primeira linha da matriz M
##     Defeituosos Não defeituosos 
##              12              46
M[,1] # retorna a primeira coluna da matriz
## Peças A Peças B 
##      12      20

Elementos da matriz podem ser modificados de maneira similar ao visto para os vetores.

1.3.4 Algumas funções importantes

Existem diversos outras funções para obter informações sobre a matriz criada, alguns deles são:

  1. Dimensão da matriz:
dim(M)
## [1] 2 2

A matriz “M” é composta por 2 linhas e 2 colunas.

  1. Quantidade de elementos na matriz:
length(M)
## [1] 4

A matriz “M” possui 4 elementos.

  1. Soma dos elementos da matriz:
sum(M)
## [1] 116

A soma de todos os elementos da matriz resulta em 116.

  1. Soma das linhas da matriz:
rowSums(M)
## Peças A Peças B 
##      58      58
  1. Soma das colunas:
colSums(M)
##     Defeituosos Não defeituosos 
##              32              84
  1. Caso deseje encontrar relações de proporção entre as variáveis é possível utilizar o software R para realizar alguns cálculos como nos exemplos:
M[1,1]/sum(M[1,])  #Proporção de peças A com defeito
## [1] 0.2068966
M[1,1]/sum(M[,1])  #Proporção de peças defeituosas do tipo A
## [1] 0.375
sum(M[,1])/sum(M)       #Proporção total de peças com defeito
## [1] 0.2758621
  1. Obtendo a matriz transposta de M:
t(M)
##                 Peças A Peças B
## Defeituosos          12      20
## Não defeituosos      46      38
  1. Obtendo a inversa da matriz M:
solve(M)
##                     Peças A     Peças B
## Defeituosos     -0.08189655  0.09913793
## Não defeituosos  0.04310345 -0.02586207


  1. Obtendo os elementos da diagonal principal de uma matriz

Considere que 2 profissionais inspecionaram 50 peças e as classificaram quanto a presença ou não de defeitos. Os resultados obtidos são dados na matrix D,onde na linha temos as avaliações do profissional A e nas colunas as avaliações do profissional B.

D = matrix(c(12,20,46,38), ncol = 2, dimnames = list(c("não defeituosa","defeituosa"),c("não defeituosa","defeituosa")))
D
##                não defeituosa defeituosa
## não defeituosa             12         46
## defeituosa                 20         38

A funçao diag() retorna os elementos da diagonal da matriz e somando os valores destes elementos temos o total de classificações concordantes.

diag(D)
## não defeituosa     defeituosa 
##             12             38
sum(diag(D))
## [1] 50
diag(M)
## [1] 12 38

1.3.5 Outras formas de criar uma matriz

Além dos comandos apresentados existem também outros modos de criar matrizes e realizar operações matriciais a partir delas, como por exemplo:

  1. criando uma matriz com todos os elementos iguais
M1 = matrix(0,ncol=3,nrow=2) #Cria uma matriz nula de 3 colunas e 2 linhas
M1
##      [,1] [,2] [,3]
## [1,]    0    0    0
## [2,]    0    0    0
  1. Criando uma matriz diagonal
M2 = diag(4,nrow=3)     #Cria  uma matriz diagonal de ordem 3 e com todos os elementos da diagonal principal iguais a 4
M2
##      [,1] [,2] [,3]
## [1,]    4    0    0
## [2,]    0    4    0
## [3,]    0    0    4
M3 = diag(c(1,2,3))     #Cria uma matriz diagonal com elementos iguais ao elementos de um vetor
M3
##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    2    0
## [3,]    0    0    3
  1. Usando as funções rbind e cbind
M4 = cbind(1:4, 6:9)   #Cria a matriz combinando as colunas formadas pelos vetores 1:4 e 6:9.
M4
##      [,1] [,2]
## [1,]    1    6
## [2,]    2    7
## [3,]    3    8
## [4,]    4    9

A função cbind(rbind) combina objetos do R, que podem ser vetores, matrizes ou data.frame no sentido das colunas(linhas).

M5 = rbind(3:5,9:11) #Cria a matriz combinando as linhas formadas pelos vetores 3:5 e 9:11.
M5
##      [,1] [,2] [,3]
## [1,]    3    4    5
## [2,]    9   10   11
  1. Somando os elemetos de uma matriz
 M6 = M2 + M3     #Soma cada elemento da matriz M2 com o elemento correspondente da matriz M3
 M6
 ##      [,1] [,2] [,3]
 ## [1,]    5    0    0
 ## [2,]    0    6    0
 ## [3,]    0    0    7
  1. Multiplicando elementos de 2 matrizes
M7 = M2 * M3     #Multiplica cada elemento da matriz M2 com o elemento correspondente da matriz M3
M7
##      [,1] [,2] [,3]
## [1,]    4    0    0
## [2,]    0    8    0
## [3,]    0    0   12
  1. Multiplicando matrizes
 M8 = M4 %*% M5     #multiplicação matricial das matrizes M4 e M5
 M8
 ##      [,1] [,2] [,3]
 ## [1,]   57   64   71
 ## [2,]   69   78   87
 ## [3,]   81   92  103
 ## [4,]   93  106  119

1.4 Data.frame

Vetores e matrizes são objetos que podem conter observação de uma única classe. Entretanto, quando analisamos dados geralmente nossas planilhas de dados contém variáveis de diferentes classes, como por exemplo sexo (caracter) e idade (numérica). Numa planilha de dados, geralmente, cada linha corresponde a um indivíduo e cada coluna a uma variável. Data frames são o objeto do R adequado para armazenar planilhas de dados com esta características. Num data frame cada coluna é formada por objetos da mesma classe.

1.4.1 Visualizando um data.frame

O R possui um pacote chamado”datasets”, que possui muitos arquivos de dados, muitos deles no formato de data.frames. Cada pacote do R tem seus próprios conjuntos de dados. Para saber quais são estes conjuntos de dados, executamos o código data(), que retorna para cada um dos pacotes carregados na sessão, os conjuntos de dados disponíveis.
Um dos arquivos de dados disponíveis é o arquivo cars, que possui informações de velocidade e distância percorrida para 50 automóveis. Para utilizar este conjunto de dados é preciso carregá-lo, o que é feito fazendo:

data(cars)  # carrega o arquivo de dados

O arquivo pode ser visualizado na primeira janela do RStudio, executando o código View(cars) ou pode ser mostrado na janela console executando o código cars. Para visualizarmos somente as primeiras linhas do data.frame usamos a função head() e para vermos as últimas linhas, usamos a função tail(). Estas funções também são aplicáveis a vetores.

head(cars)
##   speed dist
## 1     4    2
## 2     4   10
## 3     7    4
## 4     7   22
## 5     8   16
## 6     9   10
tail(cars)
##    speed dist
## 45    23   54
## 46    24   70
## 47    24   92
## 48    24   93
## 49    24  120
## 50    25   85


1.4.2 Acessando e modificando elementos do data.frame

Os elementos de um data.frame, assim como os elementos de uma matriz são indexados pela linha e coluna aos quais pertencem e praticamente todos os recursos vistos para seleção e modificação dos elementos de uma matriz aplicam-se também aos dataframes. Por exemplo, cars[1,] retorna os valores de todas as variáveis para o automóvel presente na primeira linha do data.frame e cars[,1] ou cars[,“speed”] retorna os valores da variável velocidade (speed) para os 50 automóveis.

As variáveis (colunas) de um data.frame são mais facilmente acessadas escrevendo nome do data.frame seguido do símbolo $ e do nome da variável, como mostrado no exemplo seguinte:

cars$speed   # retorna os valores da variável speed
##  [1]  4  4  7  7  8  9 10 10 10 11 11 12 12 12 12 13 13 13 13 14 14 14 14 15 15
## [26] 15 16 16 17 17 17 18 18 18 18 19 19 19 20 20 20 20 20 22 23 24 24 24 24 25
mean(cars$speed) # calcula a média da variável speed
## [1] 15.4

Uma outra maneira de acessar a variável speed data.frame cars é escrevendo cars[[“speed”]].

Os objetos retornados pelos códigos cars$peed e cars[[“speed”]] são vetores. Para que o R retorne objetos do tipo data.frame use cars[“speed“] ou cars[,“speed“,drop=F].

1.4.3 Criando um data.frame no R

Agora que já sabemos o que é um data,frame e como acessar suas linhas e colunas, vamos mostrar como criar um data.frame no R, usando a função data.frame. Como exemplo vamos construir um data.frame com as observações referentes a idade, salário e estado civil de 5 pessoas, dadas na tabela seguinte:

Nome Idade Salário Estado Civil
Joaquim 24 5000 solteiro
Francisca 30 4000 casado
João 62 3700 casado
Teresa 19 1200 solteiro
Luis 36 3500 casado


O data.frame de nomes dados é criado concatenado os vetores contendo as informações de cada variável.

dados<-data.frame(nome = c("Joaquim", "Francisca", "Joao", "Teresa", "Luis"), idade = c(24,30,62,19,36), salario = c(5000,4000,3700,1200,3500), estado_civil = c("solteiro", "casado", "casado","solteiro","casado"))
dados
##        nome idade salario estado_civil
## 1   Joaquim    24    5000     solteiro
## 2 Francisca    30    4000       casado
## 3      Joao    62    3700       casado
## 4    Teresa    19    1200     solteiro
## 5      Luis    36    3500       casado

Linhas e colunas são facilmente acrescentadas ao data frame. Apresentamos a seguir diferentes maneiras para acrescentar uma variável contendo informação do sexo das 5 pesoas. Observe o exemplo:

dados$sexo = c("M", "M", "F", "F", "F")

Outras formas são:
- dados[,”sexo”] = c(“M”, “M”, “F”, “F”, “F”)
- dados[[“$sexo”]] = c(“M”, “M”, “F”, “F”, “F”)
- cbind(dados,sexo = c(“M”,“M”,“F”,“F”,“F”), stringsAsFactors = FALSE))

O argumento stringsAsFactors = FALSE indica que as variáveis do tipo caracter não devem ser consideradas como fatores.

Se quisermos acrescentar uma linha ao data frame com os dado de Joana, podemos usar um dos 2 caminhos seguintes:

dados[6,] = data.frame(nome="joana",idade="28",salario=5000, estado_civil="casado")

A outra forma é:
- rbind(dados, data.frame(nome="joana",idade="28",salario=5000, estado_civil = "casado"), stringsAsFactors = FALSE)

Observe que a nova linha foi construída como um data.frame, pois este objeto, ao contrário do vetor, pode conter observação de diferentes classes.

1.5 Listas

Uma lista pode ser vista como um vetor de objetos onde estes objetos podem ser de diferentes tipos e é criada com a função list().

Vamos criar uma lista com 3 objetos: um vetor A, com os valores de 1 a 5, um vetor B, com as letras X, Y e Z e uma matriz C, contendo na diagonal os elementos do vetor A.

A = seq(1:5)
B = c("X","y","Z")
C = diag(A,nrow=5)
lista=list(A=A,B=B,C=C)

Um elemento da lista pode ser acessado de diferetes maneiras. Por exemplo, para acessar o elemento B podemos usar um dos seguintes codigos:

lista[2]
## $B
## [1] "X" "y" "Z"
lista["B"]
## $B
## [1] "X" "y" "Z"

Essas formas de acessar um objeto da lista retornam o objeto, mas não permitem acessar os seus elementos. Observe que o código lista[2][1] não retorna o primeiro elemento do vetor B, mas todo o vetor.

lista[2][1]
## $B
## [1] "X" "y" "Z"

Para acessar os elementos do componente da lista, devemos usar colchetes duplos, como no exemplo seguinte:

lista[[2]]  # retorna o vetor B, segundo objeto da lista
## [1] "X" "y" "Z"
lista[[2]][1] # retorna o primeiro elemento do vetor B, segundo elemento da lista
## [1] "X"
lista[["C"]]  # retorna a matriz C, terceiro objeto da lista
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    0    0    0    0
## [2,]    0    2    0    0    0
## [3,]    0    0    3    0    0
## [4,]    0    0    0    4    0
## [5,]    0    0    0    0    5
lista[["C"]][1,1] # retorna o elemento contido na primeira linha e primeira coluna da matriz C, contida na lista
## [1] 1

1.6 Pacotes

Os pacotes são de extrema importância no R pois eles vieram para complementar e maximizar ações do R base. Um pacote é constituído de funções extras e conjuntos de dados devidamente documentados que permitem, que implementam novas técnicas de manipulação de dados.

Vimos na seção 1.1.3 como instalar um pacote do repositório CRAN a partir do menu disponível no painel 4 do Rstudio. Um pacote deste repositório pode ser instalado usando a função install. Um pacote que utilizaremos mais tarde é pacote packHV. para instalá-lo faça:

install.packages("packHV")

Para visualizar todos os pacotes instalados no seu computador use o comando:

installed.packages(")

Para remover um pacote use a função remove.packages(pkgs = “nome do pacote”) e para atualizá-lo use a função update,package(pkgs = “nome do pacote” ). Para saber se um pacote necessita de atualização execute o cÓdigo o old.packages().

1.7 Funções

Uma função no R, como em outras linguagens de programação é um codigo escrito para realizar uma tarefa específica, necessitando para isto de algumas informações(argumentos) e retornando o resultados obtidos após a sua realização. Esse codigo forma um objeto unitário e recebe um nome que é usado para acessá-lO sempre que desejar executá-lo.

Utilizamos até aqui várias funções do R. Por exemplo: a função mean(), tendo com argumento um vetor de dados retorna a média deste conjunto de dados; a função t(), recebendo como argumento uma matriz, retorna a sua transposta.

Existem funções já construídas e disponibilizadas nos vários pacotes do R para muitas tarefas que desejamos realizar. Cada pacote possui um conjunto de funções proprias e para acessá-las é preciso antes disto carregar o pacote, se ele já tiver sido instalado. Entretanto, para muitas outras tarefas, estas funções não existem,mas podemos construí-las.

A sintaxe básica de uma funçção R é dada no quadro seguinte:


   Sintaxe de uma função:
   nome = function (argumento 1 , … , argumento n) {
   instruções da função
   return(o que deseja que seja retornado)
   }


No código acima, arg1,….., argn são os argumentos de entrada da função, ou seja os elementos que o usuário precisa informar para a execução da função. No espaço entre os 2 símbolos de chave são escritas as instruções da função. A função return especifica o elemento de saída, ou seja o elemento que a função deve retonar como resultado. O elemento de saída desve ser formado por um único objeto R, que pode ser um número, um vetor, uma lista, um gráfico, etc.

Para exemplificar, vamos construir uma função nomeada por JC que retorna o valor acumulado em juros durante certo período de tempo de nome, por um capital sujeito à uma taxa efetiva anual de juros constante, a partir dos argumentos: capital taxa e tempo. Para isto, vamos usar o resultado: \[Juros=capital((1+taxa)^{tempo}-1)\].

JC=function(capital, taxa, tempo){
juros=capital*((1+taxa)^tempo-1)
names(juros)="Juros"
return(juros)}

Aplicando a função JC com os argumentos capital = 1000, tempo = 1,5 anos e taxa = 0,05, obtemos:

JC(capital=1000, taxa=0.05, tempo=1.5)
##    Juros 
## 75.92983

Se mantivermos a ordem dos argumentos como definida na função podemos suprimir seus nomes ao utilizá-la.

JC(1000, 0.05, 1.5)
##    Juros 
## 75.92983

Com a função args podemos verificar os argumentos de qualquer função. Por exemplo:

args(JC)
## function (capital, taxa, tempo) 
## NULL

Vamos modificar a função juros para que ela também retorne o montante, isto é o capital acumulado ao longo do período, e os valores dos argumentos utilizados. Como resultado, vamos criar uma lista contendo todas estas quantidades.

JC=function(capital, taxa, tempo){
juros=capital*((1+taxa)^tempo-1)
montante=capital+juros
imputs=c(capital,taxa,tempo)
names(imputs)=c("Capital","Taxa","Tempo")
resultado=list(imputs, juros,montante)
names(resultado)=c("Argumentos_Utilizados","Juros","Montante")
return(resultado)}

Observe abaixo os resultados obtidos com a utilização da funçao:

JC(1000, 0.05, 1.5)
## $Argumentos_Utilizados
## Capital    Taxa   Tempo 
## 1000.00    0.05    1.50 
## 
## $Juros
## [1] 75.92983
## 
## $Montante
## [1] 1075.93

Muitas vezes é interessante estabelecermos valores padrão para um ou mais argumentos da função, isto é, valores que serão assumidos casos eles não sejam especificados pelo usário. Por exemplo, para a função JC queremos estabelecer uma taxa de juros padrão igual a 0,05. Isto é feito fazendo taxa = 0.05 ao especificar o argumento taxa no código da função, como mostrado a seguir.

JC=function(capital, taxa = 0.05, tempo){
juros=capital*((1+taxa)^tempo-1)
montante=capital+juros
imputs=c(capital,taxa,tempo)
names(imputs)=c("capital","Taxa","Tempo")
resultado=list(imputs, juros,montante)
names(resultado)=c("Argumentos_Utilizados","JUros","Montante")
return(resultado)}
JC(1000, 0.05, 1.5)
## $Argumentos_Utilizados
## capital    Taxa   Tempo 
## 1000.00    0.05    1.50 
## 
## $JUros
## [1] 75.92983
## 
## $Montante
## [1] 1075.93

Agora vamos incluir como resultado da função um gráfico mostrando a evolução do montante ao longo do tempo. Este gráfico será criado com a função \(curve\), que traça a curva para uma função qualquer, \(f(x)\), no intervalo especificado pelos argumentos from e to.

JC=function(capital, taxa = 0.05, tempo){
juros=capital*((1+taxa)^tempo-1)
montante=capital+juros
imputs=c(capital,taxa,tempo)
names(imputs)=c("capital","Taxa","Tempo")
curve(capital*(1+taxa)^x, from=0,to=tempo,xlab="tempo(anos",ylab="Montante",col="red")
resultado=list(imputs, juros,montante)
names(resultado)=c("Argumentos_Utilizados","JUros","Montante")
return(resultado)}
JC(1000, 0.05, 30)

## $Argumentos_Utilizados
## capital    Taxa   Tempo 
##   1e+03   5e-02   3e+01 
## 
## $JUros
## [1] 3321.942
## 
## $Montante
## [1] 4321.942

Por fim, ressaltamos que uma função construída pelo usuário fica disponivel para uso, enquanto durar a sessão de trabalho, após a execução de seu código.