Capítulo 3 Estruturas básicas no R

Na maior parte das vezes que estivermos usando o R, estaremos trabalhando com arquivos de dados como o mostrado na figura 3.1.

Parte do conteúdo do conjunto de dados juul2 do pacote ISwR (GPL-2 | GPL-3).

Figura 3.1: Parte do conteúdo do conjunto de dados juul2 do pacote ISwR (GPL-2 | GPL-3).

Também frequentemente podemos realizar nossas análises e manipulações em arquivos de dados, usando os menus do R Commander.

Porém eventualmente teremos que manipular as estruturas de dados que suportam esses arquivos ou utilizar recursos de comandos que não encontram suporte em uma interface gráfica.

Neste capítulo, serão mostrados as classes básicas do R, as operações e as comparações lógicas que podem ser realizadas com elas. O RStudio será utilizado neste capítulo.

Os conteúdos das seções 3.1, 3.2, 3.3 e 3.4 deste capítulo podem ser visualizados neste vídeo.

3.1 Console do RStudio

Ao executarmos o RStudio, a console do RStudio, primeira aba da janela inferior à esquerda (figura 3.2), permite ao usuário digitar, executar os comandos e visualizar os resultados. Na console, é exibida a versão do R utilizada e algumas informações sobre o R e, na parte inferior, o sinal “>”. Esse símbolo é chamado prompt de comando e significa que o R está apto a receber um comando nesta linha. Por essa razão, essa linha é chamada linha de comando.

Console do RStudio com o prompt (>) e o cursor aguardando a digitação de um comando.

Figura 3.2: Console do RStudio com o prompt (>) e o cursor aguardando a digitação de um comando.

Para executarmos um comando, basta digitá-lo e, em seguida, apertarmos a tecla <Enter>. O resultado do comando é o que chamamos de output ou saída. Neste texto, os comandos serão mostrados sem o prompt e numa área sombreada e o resultado da execução do comando é mostrado a seguir, precedido de ## quando houver resultados a serem exibidos.

Exemplo 1: para realizarmos a operação 4+3-5, basta digitá-la na linha de comando como abaixo e pressionarmos <Enter>. Essa expressão apresenta os operadores de soma (+) e subtração (-).

## [1] 2

O número 1 entre colchetes ([1]) precedendo o resultado apenas indica que o elemento a seguir é o primeiro elemento do resultado. Nesse exemplo, só há um elemento no resultado (2).

Mais de um comando podem ser digitados na mesma linha, separados por “;”.

Exemplo 2: Execute no R os comandos abaixo.

## [1] 11
## [1] 13

Na primeira expressão, temos a multiplicação (*) e a soma, com a prioridade dada para a multiplicação. Na expressão seguinte, são realizadas a potenciação (^), que tem prioridade em relação às demais, a divisão (/) e a soma, nesta ordem. A ordem de prioridade das operações são portanto:

potenciação, multiplicação/divisão, adição/subtração

Observação: Para expressões nas quais desejarmos mudar as prioridades, devemos usar parênteses, e nunca colchetes ou chaves, como delimitadores (a rigor, as chaves podem ser utilizadas, mas não é recomendável). Por exemplo, se desejarmos somar 5 com 1 e depois multiplicar o resultado por dois, devemos fazer 2*(5+1), e não 2 * [5 + 1].

Exemplo 3: A expressão abaixo gera a sequência de números inteiros de 10 a 30. Agora o resultado tem mais de 1 elemento. O número entre colchetes indica a posição do elemento seguinte na sequência de números.

##  [1] 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

Notas:
- Na atual linha de comando, é possível acessar comandos já executados, utilizando as setas \(\uparrow\) e \(\downarrow\) do teclado;
- Para incluir um comentário no R (ou seja, uma sequência de caracteres que deve ser ignorada pelo R, mas que serve como informação para o usuário), basta digitar o símbolo # e, em seguida, o comentário. Tudo que aparece depois do sinal # é ignorado pelo R.

## [1] 11

3.2 Objetos no R

Tudo no R é um objeto. Para atribuirmos resultados de operações a algum objeto que pode posteriormente ser manipulado, usamos a expressão de atribuição “<-”:

objeto <- expressão

Os nomes dos objetos devem começar com uma letra (pode inclusive ser apenas uma letra), e podem conter letras, números, pontos, sublinhado (não são permitidos vírgula, ponto e vírgula, dois pontos e espaço). Veja o exemplo a seguir:

Ao executarmos o comando acima, nenhum resultado é mostrado na tela, mas o objeto y foi criado na memória do computador.

Para exibirmos o conteúdo de y, há duas formas. A primeira delas é digitarmos o nome do objeto na linha de comando e pressionarmos <Enter>. Isso é chamado de autoimpressão.

## [1] 4

Outra forma é usar a função “print”, como mostrado abaixo:

## [1] 4

Observações:
1) no modo interativo, usualmente não usamos a função print. É muito mais fácil usar a autoimpressão. Porém, ao escrever scripts, funções, ou programas mais longos, há a necessidade de explicitamente imprimir objetos, porque a autoimpressão não funciona nesses cenários;
2) atualmente, o R também aceita o sinal de igual no lugar do operador de atribuição “<-”, produzindo o mesmo resultado. Neste texto, usaremos indistintamente tanto o sinal de “=” quanto “<-”;
3) é recomendável atribuir nomes que tenham um significado lógico. Isso facilita lidar com um grande número de objetos;
4) letras maiúsculas e minúsculas são consideradas diferentes para o R.

O R possui cinco classes básicas ou “atômicas” de objetos:
- character;
- numeric (números reais);
- integer (números inteiros);
- complex (números complexos);
- logical (Falso/Verdadeiro)

A função class(), aplicada a um objeto, retorna a sua classe. Vejamos alguns exemplos:

## [1] "character"
## [1] "character"
## [1] "numeric"
## [1] "integer"
## [1] "logical"
## [1] "logical"
## [1] "complex"

Observações:
1) expressões do tipo character devem aparecer entre aspas duplas ou simples;
2) números no R são geralmente tratados como objetos numéricos (números reais de dupla precisão). Mesmo números inteiros são tratados como numéricos. Para fazer um número inteiro ser tratado como objeto inteiro, deve-se utilizar a letra L após o número;
3) os valores lógicos (ou booleanos) são TRUE ou FALSE. T ou F também são aceitos;
4) Acima foram criados diversos objetos no R (x, y, z.1, z.2 e c1). A aba Environment do RStudio (seta verde na figura 3.3) mostra os objetos criados até então na sessão corrente.

Ambiente de trabalho do R, mostrando os objetos criados na sessão corrente.

Figura 3.3: Ambiente de trabalho do R, mostrando os objetos criados na sessão corrente.

3.3 Valores especiais

O R possui alguns valores que são especiais: NA, Inf, -Inf, e NaN.

Inf significa infinito e nos permite representar resultados de operações como 1/0 e pode ser usado em cálculos ordinários. Por exemplo, 1/Inf é zero. Analogamente -Inf representa menos infinito. Vejam as expressões abaixo:

## [1] Inf
## [1] -Inf
## [1] 0
## [1] 0

O valor NaN representa um valor indefinido (not a number), por exemplo 0/0. NA é usado para representar valores ausentes (missing em inglês). NaN também pode ser usado com essa finalidade. Voltaremos a essa questão na seção 3.12.

3.4 Funções

Como dito na introdução, o R é uma linguagem altamente extensível. Novas funcionalidades são adicionadas ao ambiente por meio da implementação de funções agrupadas em módulos ou pacotes. Em geral, ao realizar uma análise estatística, o usuário não irá implementar novas funções, e sim irá utilizar as funções já disponíveis no R.

As funções no R possuem um nome seguido de zero ou mais argumentos entre parênteses. Vejamos alguns exemplos de funções. Os argumentos podem ser especificados pela posição na lista de argumentos ou pelo nome.

## [1] 10  6  4  1  1
## [1] 1
## [1] 10
## [1] 22
## [1] 240
## [1] 5
## [1]  1  4  6 10

Mais detalhes de funções serão apresentados no capítulo 11.

3.5 Vetores (vector)

Os conteúdos desta seção e da seção 3.5.1 podem ser visualizados neste vídeo.

A figura 3.4 mostra um conjunto de dados contendo 1339 observações e 8 variáveis.

Cada uma dessas variáveis é tratada no R como uma coleção de valores da mesma classe. Nesse conjunto de dados, cada variável é chamada de vetor no R.

A coleção formada pelas 8 variáveis forma um objeto da classe list (lista). Então cada uma das variáveis é um vetor e os oito vetores formam uma lista. Essa é uma lista especial onde cada um dos vetores possuem o mesmo número de elementos.

Um objeto que encapsula este conjunto de dados é da classe data.frame. Assim um data frame contém uma lista na qual todos os seus componentes possuem o mesmo número de elementos.

Essas classes serão apresentadas nesta e nas próximas seções.

Representação de um conjunto de dados no R. Neste conjunto de dados, cada variável é um vetor no R. O conjunto das variáveis forma uma lista especial, da classe data.frame. Conjunto de dados: juul2, pacote ISwR (GPL-2 | GPL-3).

Figura 3.4: Representação de um conjunto de dados no R. Neste conjunto de dados, cada variável é um vetor no R. O conjunto das variáveis forma uma lista especial, da classe data.frame. Conjunto de dados: juul2, pacote ISwR (GPL-2 | GPL-3).

Uma maneira de criarmos vetores é usarmos a função c(entradas do vetor separadas por vírgulas). O operador “:” entre dois números inteiros retorna uma sequência de números inteiros entre os dois números. Vejamos alguns exemplos.

## [1]  3  7  2 12
## [1] "Luiz"   "Maria"  "Rafael"
## [1]  TRUE FALSE FALSE
##  [1] 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
##  [1] 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10
## [1] "numeric"

Podemos gerar um vetor por meio da concatenação de um outro vetor com outros elementos:

## [1]  7  9 11  3

A função vector() também pode ser usada para inicializar vetores.

##  [1] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

3.5.1 Acessando elementos de um vetor

Um elemento de um vetor pode ser acessado por meio de um índice entre colchetes que indica a posição do elemento no vetor. Vejam o exemplo abaixo.

## [1] 7

Múltiplos elementos podem ser extraídos por meio de um índice que consiste de um vetor de inteiros:

## [1] 12 13 14
## [1] 13 11

Índices negativos significam que os elementos indicados pelos índices não serão selecionados:

##  [1] 10 11 13 14 15 16 17 18 19 20
## [1] 10 11 13 14 15 16 18 19 20

O comando abaixo retorna os elementos de y, com exceção dos situados entre o 3º e o 8º, inclusive:

## [1] 10 11 18 19 20

Para selecionarmos elementos de um vetor, podemos utilizar também uma expressão lógica, com os operadores == (igual), > (maior), < (menor), >= (maior ou igual), <= (menor ou igual), != (diferente), ou combinações de expressões lógicas por meio dos operadores booleanos “OU” (|), “E” (&), e “Não” (!).

Este vídeo mostra alguns exemplos do uso de expressões lógicas.

Vejamos alguns exemplos de uso de expressões lógicas para selecionar elementos de um vetor:

## [1] 15
## [1] 10 11 12 13
## [1] 17 18 19 20

O comando abaixo seleciona os elementos de y menores que 13 ou maiores que 18. Repare o uso dos parênteses. Nesse caso, eles não são necessários, mas facilita a leitura da expressão lógica.

## [1] 10 11 12 19 20

O comando abaixo seleciona os elementos de y maiores do que 16 e menores do que 19.

## [1] 17 18

Os operadores lógicos também funcionam com valores textuais, já que o R considera a ordem alfabética.

## [1] "Joana"

As operações de seleção por meio de expressões lógicas são equivalentes a gerar um vetor de valores lógicos que indica em cada posição se o elemento correspondente deve ser ou não selecionado e utilizar este vetor para realizar a seleção.

O comando abaixo seleciona os elementos de y menores ou iguais a 13.

## [1] 10 11 12 13

O mesmo resultado pode então ser obtido assim:

  1. o comando abaixo cria um vetor com 11 elementos, sendo os 4 primeiros TRUE e os restantes FALSE, porque os 4 primeiros elementos de y são menores do que 13:
##  [1]  TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
  1. o comando abaixo seleciona todos os elementos de y cujos elementos na posição correspondente em u possuem o valor TRUE:
## [1] 10 11 12 13

Elementos de um vetor também podem ser alterados por meio dos operadores de atribuição. Vejam o exemplo abaixo, onde o terceiro elemento do vetor foi alterado para o valor 50:

##  [1] 10 11 50 13 14 15 16 17 18 19 20

3.5.2 Gerando sequências - Função seq

Os conteúdos desta seção e da seção seguinte podem ser visualizados neste vídeo.

A função seq gera uma sequência do valor do argumento from até o valor do argumento to, com salto entre valores consecutivos de acordo com o argumento by. Caso os nomes dos argumentos não sejam especificados na chamdada da função, o primeiro valor corresponde ao argumento from, o segundo valor corresponde ao argumento to, e o terceiro valor ao argumento by.

Para sequências decrescentes, o valor do argumento by obrigatoriamente deverá vir acompanhado do sinal negativo.

O término da sequência será o segundo argumento ou algum número anterior a este na sequência, a depender do valor do terceiro argumento.

A função seq pode ser escrita apenas com os dois primeiros argumentos. Nesse caso, o terceiro argumento será, por padrão, igual a 1 (para sequências crescentes) ou -1 (para sequências decrescentes).

## [1] 10 13 16 19 22
## [1] 10 15 20
## [1] 22 19 16 13 10
## [1] 22 17 12
## [1] 3 4 5 6 7 8
## [1] 3 4 5 6 7 8
## [1] 8 7 6 5 4 3
## [1] 8 7 6 5 4 3
##  [1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0

3.5.3 Gerando repetições: função rep

A função rep, como o nome indica, gera uma sequência onde o primeiro argumento representa a expressão a ser repetida. O argumento times representa o número de repetições.

## [1] 0 0 0 0 0 0
## [1] 1 7 1 7 1 7 1 7
##  [1] -1.0 -0.5  0.0  0.5  1.0 -1.0 -0.5  0.0  0.5  1.0
## [1] 1 1 1 3 3 5

Reparem a diferença entre o segundo e o quarto exemplo acima. O segundo exemplo, rep(c(1,7), 4), significa que o vetor (1,7) será repetido quatro vezes. O quarto exemplo, rep(c(1,3,5),c(3,2,1)), indica que o primeiro elemento do primeiro argumento será repetido 3 vezes, o segundo elemento 2 vezes e o terceiro elemento 1 vez.

Um pouco mais sobre a criação de vetores numéricos pode ser visto neste vídeo.

3.6 Listas (list)

Os conteúdos desta seção e suas subseções, bem como da seção 3.7 podem ser visualizados neste vídeo.

Listas são coleções de elementos que não precisam ser da mesma classe. list é uma importante classe de objetos no R.

Listas podem ser criadas explicitamente usando a função list(). Vejamos alguns exemplos:

## [[1]]
## [1] 5
## 
## [[2]]
## [1] "kiwi"
## 
## [[3]]
## [1] FALSE  TRUE  TRUE
## 
## [[4]]
## [1] 3+1i
## 
## [[5]]
## [1] 2
## [1] "list"
## [1] "kiwi"

Observações:
1) uma lista pode conter vetores e outras listas;
2) cada componente da lista pode ser acessado por meio de um índice entre dois colchetes []. Por exemplo, no exemplo acima, x[[2]] = “kiwi”;

Uma lista vazia com um comprimento pré-especificado pode ser criada por meio da função vector(). Todos os elementos de uma lista vazia são inicializados como NULL.

## [[1]]
## NULL
## 
## [[2]]
## NULL
## 
## [[3]]
## NULL

3.6.1 Extraindo múltiplos elementos de uma lista

Podemos extrair vários elementos da lista de maneira semelhante ao utilizado para vetores:

## [[1]]
## [1] FALSE  TRUE  TRUE
## 
## [[2]]
## [1] 5

3.6.2 Extraindo elementos aninhados de uma lista

Uma lista pode ser composta de elementos que são eles próprios uma lista ou vetores. Elementos de uma lista que pertence a outra lista são chamados elementos aninhados.

Há duas maneiras de acessar um elemento aninhado de uma lista. Vejamos o exemplo a seguir:

## [1] FALSE
## [1] FALSE

No exemplo acima, temos uma lista x cujo terceiro elemento é um vetor com três elementos. Para acessarmos o primeiro elemento desse vetor, usamos a função c() entre [], onde o primeiro argumento de c indica a posição do vetor na lista e o segundo argumento a posição do elemento desejado dentro do vetor. Também podemos usar uma sequência de índices entre [] até chegarmos ao elemento desejado na lista.

3.7 Nomes

Vetores e listas podem ser criados com cada elemento recebendo um nome, e esses nomes podem ser usados para referenciar o respectivo elemento. Vejamos alguns exemplos:

## a b 
## 1 2
## a 
## 1
## a 
## 1
## $a
## [1] 1
## 
## $b
## [1] FALSE
## 
## $c
## [1] "kiwi"
## [1] "kiwi"
## [1] "kiwi"

Observações:
1) cada elemento do vetor pode ser acessado pela sua posição ou pelo seu nome entre aspas;
2) cada elemento de uma lista pode ser acessado pela sua posição entre [] ou pelo seu nome precedido por “$”.

Para sabermos os nomes de uma lista ou vetor, usamos a função names():

## [1] "a" "b"
## [1] "a" "b" "c"

3.8 Fatores

O conteúdo desta seção pode ser visualizado neste vídeo.

A figura 3.5 mostra parte do conteúdo do conjunto de dados PimaIndiansDiabetes2, disponível no pacote mlbench (GPL-2). Esse conjunto de dados contém observações de 768 mulheres com herança dos indígenas Pima, diabéticas e não diabéticas.

A variável diabetes é da classe factor. É uma variável dicotômica com dois níveis ou categorias, positivo ou negativo, indicando se a mulher é ou não diabética.

Fatores (factor) são usados para representar variáveis categóricas. As variáveis categóricas podem ser nominais (não ordenadas) ou ordinais (ordenadas).

Assim a lista que forma um conjunto de dados no R também pode conter, além de vetores, elementos da classe factor.

Exemplo de um conjunto de dados composto por vetores e fatores. Fonte: PimaIndiansDiabetes2, pacote mlbench (GPL-2)...

Figura 3.5: Exemplo de um conjunto de dados composto por vetores e fatores. Fonte: PimaIndiansDiabetes2, pacote mlbench (GPL-2)...

Objetos do tipo factor são criados por meio da função factor. Os valores possíveis de um objeto do tipo fator são chamados de níveis (levels). Os comandos a seguir criam o objeto dor da classe factor com os níveis nenhuma, leve, razoável e muita dor:

## [1] nenhuma   nenhuma   leve      razoável  muita dor leve     
## Levels: leve muita dor nenhuma razoável

Usar fatores com rótulos é melhor do que usar inteiros, porque os rótulos são autoexplicativos. Por exemplo, trabalhar com uma variável chamada sexo que possui os valores “masculino” e “feminino” é melhor do que uma variável que possui os valores 1 e 2.

Podemos ordenar os níveis de um fator por meio da função levels. Se nada for especificado, o R vai assumir a ordem alfabética, como indicado no exemplo anterior. Em muitas situações, é necessário especificar uma ordem mais natural para os níveis do fator, como mostrado a seguir, que ordena os níveis de acordo com a intensidade da dor:

## [1] razoável  razoável  nenhuma   muita dor leve      nenhuma  
## Levels: nenhuma leve razoável muita dor

Também podemos especificar a ordem dos níveis diretamente na criação do fator, por meio do argumento levels:

## [1] nenhuma   nenhuma   leve      razoável  muita dor leve     
## Levels: nenhuma leve razoável muita dor

3.9 Coerção

O conteúdo desta seção pode ser visualizado neste vídeo.

Ao criar um vetor com valores de diferentes classes, o R tenta uma maneira de transformar todos os objetos como sendo de uma mesma classe. Essa transformação é chamada de coerção. Para as classes atômicas, a conversão é feita de acordo com a seguinte sequência:

\[logical \rightarrow integer \rightarrow numeric \rightarrow complex \rightarrow character\] Exemplos:

## [1] 1 2 0
## [1] "integer"

No exemplo acima, a classe do objeto y é integer, porque o número 2 (da classe integer) sucede aos elementos da classe logical na sequência de conversão. Ao convertermos um valor lógico para numérico, TRUE é equivalente a 1 e FALSE a 0.

## [1] 1.7 4.0
## [1] "numeric"

No exemplo acima, a classe do objeto y é numeric e o número 4 (integer) é convertido para numeric.

## [1] 1.7+0i 3.0+5i
## [1] "complex"
## [1] "1.7+2.3i" "a"
## [1] "character"

Objetos podem ser convertidos de uma classe para outra por meio das funções as.*: as.numeric, as.logical, as.integer, as.character, as.complex. Outras funções de coerção serão apresentadas à medida que for necessário.

Exemplos:

## [1] FALSE  TRUE  TRUE  TRUE
## [1] "0"   "1"   "4"   "5.8"

Quando o R não consegue realizar a conversão, NA é gerado como resultado e uma mensagem de alerta é emitida.

## Warning: NAs introduzidos por coerção
## [1]  NA  NA  NA 8.8

A classe do objeto x é character. Portanto o elemento 8.8 é tratado como character e não como número, mas ele pode ser convertido para número. Os elementos “a”, “b” e “c” não podem ser convertidos nem para números nem para valores lógicos. Portanto os três primeiros elementos da avaliação de as.numeric(x) são NA e o último é o número 8.8.

## [1] NA NA NA NA

Já a avaliação de as.logical(x) retorna todos os elementos NA, já que mesmo o elemento do tipo character de x (“8.8”) não pode ser convertido para um valor lógico.

Vamos supor que temos uma variável sexo representada como um vetor numérico, onde 1 representa feminino e 2 masculino.

Na análise estatística, precisamos converter essa variável de numérica para categórica. Podemos usar a função as.factor como mostrado abaixo, onde nomeamos o objeto transformado como sexo.cat.

## [1] 1 2 2 1 1 1 2
## Levels: 1 2

Agora vamos colocar nomes descritivos aos níveis da variável sexo.cat, usando o atributo levels, como abaixo:

## [1] feminino  masculino masculino feminino  feminino 
## Levels: feminino masculino

3.10 Matrizes

Os conteúdos desta seção e de sua subseção podem ser visualizados neste vídeo.

Matrizes são vetores com um atributo de dimensão (dimension), que é ele próprio um vetor inteiro de tamanho 2: número de linhas e número de colunas.

Uma matriz é criada por meio da função matrix(). Essa função possui os seguintes argumentos:
- data: vetor que contém os valores da matriz;
- nrow: número de linhas da matriz;
- ncol: número de colunas da matriz;
- byrow: indica como a matriz é montada. Se for TRUE, ela é montada linha a linha. Se for FALSE, ela é montada coluna a coluna;
- dimnames: nomes das linhas e colunas, respectivamente.

##       out1 out2 out3
## trat1    1    2    3
## trat2    4    5    6

No exemplo acima, a matriz vai sendo preenchida com os números de 1 a 6, linha a linha.

O comando abaixo vai gerar uma matriz com os mesmos elementos da matriz acima, mas omitindo o nome do argumento data e o argumento nrow. Quando o nome de um argumento não é especificado, o R tenta associar um objeto à respectiva posição do argumento.

##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6

Assim, na chamada da função matrix acima, o argumento data recebe o vetor de 1 a 6, por ser o primeiro argumento da função. Para facilidade de leitura, é recomendável colocar os nomes dos argumentos.

Se dimnames não for especificado, os nomes das linhas e colunas serão os números das respectivas linhas e colunas.

Como há 6 elementos no argumento data e 3 colunas, então o número de linhas é calculado dividindo-se o número de elementos (6) pelo número de colunas (3).

Também poderíamos ter especificado o argumento nrow ao invés do argumento ncol, como mostrado a seguir. O número de colunas será obtido dividindo-se o número de elementos (6) pelo número de linhas (2).

Se o argumento byrow não for especificado, então a matriz será construída a partir das colunas. A matriz vai sendo preenchida com os números de 1 a 6 coluna a coluna.

##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6

Se os valores da matriz não forem especificados, as células da matriz são preenchidas com NA.

##      [,1] [,2] [,3]
## [1,]   NA   NA   NA
## [2,]   NA   NA   NA

Para obtermos a dimensão de uma matriz, usamos a função dim.

## [1] 2 3

Se somente um valor for especificado para o argumento data da função matrix, a matriz será criada com todos os valores iguais.

##      [,1] [,2]
## [1,]    2    2
## [2,]    2    2
## [3,]    2    2

Matrizes também podem ser criadas a partir de vetores, adicionando um atributo de dimensão por meio da função dim().

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10

Outra maneira de se criar matrizes é pela adição de linhas ou colunas por meio das funções rbind() e cbind(), respectivamente. rbind() monta uma matriz, empilhando os argumentos linha a linha na ordem em que aparecem na lista. Já cbind() monta a matriz colocando os argumentos lado a lado na ordem em que aparecem na lista.

##   [,1] [,2] [,3] [,4]
## x    1    2    3    4
## y   10   11   12   13
##      x  y
## [1,] 1 10
## [2,] 2 11
## [3,] 3 12
## [4,] 4 13

3.10.1 Extraindo células/linhas/colunas/submatrizes de uma matriz

Os elementos (células) de uma matriz podem ser acessados por um par de índices que indicam, respectivamente, a linha e a coluna do elemento desejado.

## [1] 8

Para extrairmos todos os elementos de uma linha, basta não especificarmos o índice correspondente à coluna.

## [1]  9 10 11 12

Para extrairmos todos os elementos de uma coluna, basta não especificarmos o índice correspondente à linha

## [1]  2  6 10 14

Índices negativos excluem os elementos indicados.

##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]   13   14   15   16
##      [,1] [,2] [,3]
## [1,]    1    2    4
## [2,]    5    6    8
## [3,]    9   10   12
## [4,]   13   14   16

Podemos utilizar vetores de índices para selecionarmos uma submatriz de uma matriz.

##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12
##      [,1] [,2] [,3]
## [1,]    2    3    4
## [2,]    6    7    8
## [3,]   10   11   12
## [4,]   14   15   16

O comando a seguir seleciona a submatriz de A formada pelos elementos da primeira à terceira linha e da segunda à quarta coluna.

##      [,1] [,2] [,3]
## [1,]    2    3    4
## [2,]    6    7    8
## [3,]   10   11   12

O comando a seguir seleciona a submatriz de A formada pelos elementos da primeira e terceira linhas, segunda e quarta colunas.

##      [,1] [,2]
## [1,]    2    4
## [2,]   10   12

3.11 Data frame

Os conteúdos desta seção e de sua subseção podem ser visualizados neste vídeo.

Data frames são utilizados para armazenar dados tabulados no R. Eles são usualmente criados quando lemos um arquivo de dados para ser analisado. Internamente no R, os data frames são representados como uma lista especial onde cada elemento da lista possui o mesmo tamanho. Cada elemento da lista pode ser interpretado como uma coluna e o tamanho de cada elemento da lista é o número de linhas ou observações. Como se trata de uma lista, os elementos de um data frame não precisam ser da mesma classe.

Um data frame pode ser criado explicitamente por meio da função data.frame().

##   id      sexo pad pas
## 1 P1  feminino  80 130
## 2 P2  feminino  85 140
## 3 P3 masculino 100 150
## 4 P4 masculino  95 145

Temos aqui um data frame com 4 variáveis, nomeadas: id, sexo, pad e pas.

O atributo names de um data frame retorna os nomes das colunas ou variáveis do data frame.

## [1] "id"   "sexo" "pad"  "pas"

Um outro atributo de um data frame é chamado row.names, que fornece uma informação sobre cada linha do data frame.

## [1] "1" "2" "3" "4"

Podemos especificar os nomes das linhas, atribuindo valores a row.names:

##         id      sexo pad pas
## Bia     P1  feminino  80 130
## Claudia P2  feminino  85 140
## Leo     P3 masculino 100 150
## Carlos  P4 masculino  95 145

3.11.1 Acessando os elementos de um data frame

Os elementos de um data frame podem ser acessados como os elementos de uma lista ou de uma matriz. As variáveis podem ser identificadas pela sua posição no data frame. Vejamos os seguintes exemplos, utilizando o data frame pacientes, criado na seção anterior:

## [1]  80  85 100  95
##         pad pas
## Bia      80 130
## Claudia  85 140
## Leo     100 150
## Carlos   95 145
##         id     sexo pad pas
## Bia     P1 feminino  80 130
## Claudia P2 feminino  85 140
##         id pad
## Bia     P1  80
## Claudia P2  85
## Leo     P3 100
## Carlos  P4  95
##              sexo pas
## Bia      feminino 130
## Claudia  feminino 140
## Leo     masculino 150
## Carlos  masculino 145
##              sexo pas
## Bia      feminino 130
## Claudia  feminino 140
## Leo     masculino 150
## Carlos  masculino 145
##        pad pas
## Bia     80 130
## Carlos  95 145
##         id     sexo pad pas
## Bia     P1 feminino  80 130
## Claudia P2 feminino  85 140
##        id      sexo pad pas
## Leo    P3 masculino 100 150
## Carlos P4 masculino  95 145
##              sexo pad pas
## Bia      feminino  80 130
## Claudia  feminino  85 140
## Leo     masculino 100 150
## Carlos  masculino  95 145

3.12 Valores ausentes

Como mostrado anteriormente, valores ausentes (missing values) são denotados por NA ou NaN.

Um valor NaN também é NA, mas a recíproca não é verdadeira. As funções is.na() e is.nan() são usadas para testar se um objeto é NA ou NaN, respectivamente.

## [1] FALSE FALSE  TRUE FALSE FALSE
## [1] FALSE FALSE FALSE FALSE FALSE
## [1] FALSE FALSE  TRUE FALSE  TRUE
## [1] FALSE FALSE FALSE FALSE  TRUE
## [1]  1  2 10

Observem no último exemplo que podemos utilizar a função is.na() para selecionarmos os elementos NA de um vetor.

3.13 Ajuda no R

Para obtermos ajuda sobre alguma função do R, basta digitarmos o nome da função precedido de uma interrogação na janela do R e apertar <Enter>. De maneira equivalente, podemos usar a função help("nome_da_função"). Para solicitarmos a ajuda sobre a função data.frame(), por exemplo, podemos usar um dos dois comandos a seguir:

A figura 3.6 exibe a descrição e argumentos da função data.frame na aba Help, ao executarmos a função help("data.frame") na console do RStudio.

Aba de Ajuda do RStudio, mostrando a descrição e os argumentos da função data.frame.

Figura 3.6: Aba de Ajuda do RStudio, mostrando a descrição e os argumentos da função data.frame.

Para localizar funções relacionadas a alguma expressão, usam-se duas interrogações em vez de uma antes da expressão, ou ainda a função help.search("expressão_para_a_busca").

Exemplo: Qual função retorna o desvio padrão?

3.14 Instalação de pacotes via linha de comando

Para instalar um pacote no R, sem a necessidade de usarmos uma interface gráfica, como foi mostrado na instalação do R Commander, usamos a função install.packages("nome_do_pacote"). Vamos instalar o pacote ISwR, que será utilizado em outros capítulos. Executamos a função abaixo, onde o nome do pacote deve aparecer entre “"”:

3.15 Exercícios

  1. Quais são os resultados das seguintes expressões, respectivamente: 3 + 5*8/2^2 e (3 + 5)*8/(2^2)?
  1. 13 e 16
  2. 16 e 13
  3. 403 e 13
  4. 403 e 16
  5. 16 e 16
  1. Na expressão 30 - 6^2 / 2*3, qual a sequência dos cálculos até chegar ao resultado final?
  1. 30-6, 24^2, 576/3, 192*3
  2. 30-6, 2/2, 1*3, 30-27
  3. 6^2, 30-36, 2*3, -6/6
  4. 6^2, 36/2, 18*3, 30-54
  1. Após a sequência de comandos x = 3; y = 4; x = x + 2*y; x=20, qual será o valor de x?
  1. 3
  2. 4
  3. 11
  4. 20
  5. (3, 20)
  1. Se executarmos a expressão x = 6, qual será a classe do objeto x, se usarmos a função class?
  1. list
  2. numeric
  3. integer
  4. complex
  5. character
  6. real
  1. Associe os vetores abaixo aos respectivos tipos de dados:
  1. (1, 2.5, 4, 0)
  2. (TRUE, FALSE, FALSE, TRUE)
  3. 1:40
  4. (“a”, “Jeannie”, 5)
  5. (\(2 + 4i\), \(3i\), \(3\), \(6\)
  1. Se você tiver dois vetores x = c(2, 4, 5, 6) e y = c(-3, -2, 0, 7), qual será o resultado da expressão cbind(x, y)?
  1. Um vetor de comprimento 8
  2. Uma matriz 4x2
  3. Uma matriz 2x4
  4. Uma lista com dois elementos
  5. Um vetor de comprimento 4
  1. Que afirmações abaixo são verdadeiras em relação aos vetores no R?
  1. Os elementos de um vetor podem ser de diferentes classes.
  2. Os elementos de um vetor precisam ser da mesma classe.
  3. Os elementos de um vetor somente podem ser numeric ou character.
  4. Se um vetor contiver elementos da classe character e da classe numeric, os elementos do tipo character são convertidos para numeric.
  5. Se um vetor contiver elementos da classe character e da classe numeric, os elementos do tipo numeric são convertidos para character.
  1. Suponha que você tenha uma lista definida como x = list(4, "cara", "coroa", FALSE). O que a expressão x[[1]] fornece? Marque todas as opções corretas.
  1. Um vetor do tipo character contendo o elemento “4”
  2. Uma lista com o número 4
  3. Um vetor numérico contendo o número 4
  4. Um vetor numérico de comprimento 1
  5. Uma lista contendo o elemento “4”
  6. Um vetor contendo o elemento “cara”
  1. Suponha que você tenha um vetor x = c(4, 6, 8, 9, 12, 3, 2) e que você deseja fazer com que todos os elementos de x menor que 9 sejam iguais a zero. Selecione o código abaixo que gera o resultado esperado.
  1. x[x == 0] < 9
  2. x[x < 9] == 0
  3. x[x >= 9] <- 0
  4. x[x != 9] = 0
  5. x[x < 9] <- 0
  1. Dado o vetor x = 1:12, que expressões abaixo irão gerar uma matriz 3x4?
  1. matrix(x, ncol=4)
  2. matrix(x, nrow = 3)
  3. matrix(x, ncol=4, byrow = TRUE)
  4. matrix(x)
  5. matrix(x, nrow = 4)
  6. matrix(x, ncol = 3)
  1. Dada a matrix gerada pela expressão x = matrix(1:12 , ncol = 4), que afirmações abaixo são verdadeiras?
  1. x[2,3] = 8
  2. x[2,3] = 6
  3. x[1,] = (1, 2, 3, 4)
  4. x[1, ] = (1, 4, 7, 10)
  5. x[c(1,3), 3] = (7, 9)
  6. x[1, c(2,3)] = (1, 2, 3)
  1. Que afirmações abaixo são verdadeiras em relação a data frames?
  1. data frames são iguais a matrizes
  2. Os componentes de um data frame são listas onde cada lista pode possuir qualquer tamanho
  3. Todos os componentes de um data frame têm que ser do mesmo tipo
  4. Todos os componentes de um data frame devem possuir o mesmo tamanho
  5. Um estudo clínico, em geral, pode gerar um conjunto de dados, onde cada variável é uma coluna de um data frame e cada linha são os valores de cada variável para a unidade de observação correspondente
  1. A figura 3.7 mostra as 6 primeiras linhas de um data frame chamado Melanoma. Que afirmações abaixo estão corretas?
6 primeiras observações do conjunto de dados Melanoma.

Figura 3.7: 6 primeiras observações do conjunto de dados Melanoma.

  1. Melanoma[3,] = c(NA, NA, NA, NA, NA, NA, NA) faz com que todos os valores da terceira linha se tornem NA
  2. Melanoma$age[1:6] retorna o vetor (76, 56, 41, 71, 52, 28)
  3. Melanoma[[4]][1:6], Melanoma$age[1:6], Melanoma[1:6,4] e Melanoma[[“age”]][1:6] retornam o mesmo resultado
  4. names(Melanoma) retorna os nomes das variáveis
  5. names(Melanoma) retorna os números 1, 2, 3, 4, 5, 6
  1. Suponha que no conjunto de dados da questão anterior, os valores da variável sex fossem masculino ou feminino. Que expressão você usaria para obter os registros cuja idade fosse menor ou igual a 50 anos e cujo sexo fosse masculino?
  1. Melanoma[Melanoma$age <= 50 & Melanoma$sex == “masculino”,]
  2. Melanoma[Melanoma$age <= 50 | Melanoma$sex == masculino,]
  3. Melanoma[Melanoma$age <= 50 | Melanoma$sex == “masculino”,]
  4. Melanoma[Melanoma$age <= 50 & Melanoma$sex == masculino,]

Resposta dos exercícios:

  1. a

  2. d

  3. d

  4. b

    1. Numeric, b) logical, c) Integer, d) character, e) complex

  6. c

  7. b, e

  8. c, d

  9. e

  10. a, b, c

  11. a, d, e

  12. d, e

  13. a, b, c, d

  14. a