Tipos de dados, variáveis e vetores

Tipos de dados

Em R existem os seguintes tipos de dados e variáveis:

Tipo de Dado Exemplo
Lógico (Logic) TRUE, FALSE
Numérico (Numeric) 12.3, 5, 999
Inteiro (Integer) 2L, 34L, 0L
Complexo (Complex) 1 + 2i
Caracter (Character) ‘a’, “Bom dia”, “TRUE”, ‘23.4’
(Raw) “Bom dia” é armazenado como 42 6f 6d 20 64 69 61
*Em R não existem, de fato, escalares. Eles são representados por vetores com um único componente.

Com estes dados (e variáveis) se pode construir objetos predefinidos e mais complexos: eles são os escalares* (scalars), vetores (vectors), matrizes (matrices), arrays (matrizes em dimensões maiores que m × n), data frames e listas (lists).

Observe que R é sensível ao caso. TESTE, Teste e teste são variáveis diferentes. Os valores lógicos devem ser escritos em maiúsculas (mas podem ser abreviados para T e F).

Com frequência mencionaremos o nome de uma entidade em inglês para facilitar a leitura dos textos abundantes na internet. Em alguns casos podemos manter a nomenclatura original, em inglês.

Variáveis e vetores

e <- 154 # um escalar, numérico
l <- "pedro" # um escalar, caracter

a <- c(1, 3, 9.5, 6, -2, 4) # vetor numérico
b <- c("um", "dois", "três") # vetor de caracter
c <- c(TRUE, TRUE, FALSE, TRUE, FALSE) # vetor lógico

Todos os componentes de um vetor devem ser do mesmo tipo.

> # um escalar pode ser criado assim:
> x <- 10
> x
[1] 10
> print(x)
[1] 10
> # um vetor é criado usando o operador c()
> vetor_numerico <- c(1.2, 3.4, 5, 7, 8)
> vetor_numerico
[1] 1.2 3.4 5.0 7.0 8.0
> vetor_string <- c("a", "b", "c", "d")
> vetor_string
[1] "a" "b" "c" "d"
> vetor_logico <- c(FALSE, TRUE, TRUE)
> vetor_logico
[1] FALSE  TRUE  TRUE
> vetor_inteiros <- c(12L, 15L, 18L)
> vetor_inteiros
[1] 12 15 18
> # a classe de um objeto pode ser consultada com a função class()
> class(vetor_inteiros)
[1] "integer"
> class(vetor_logico)
[1] "logical"
> # O primeiro componente do vetor_numerico é
> vetor_numerico[1]
[1] 1.2
> # Seu comprimento
> length(vetor_numerico)
[1] 5
> # Podemos então obter seu último componente
> vetor_numerico[length(vetor_numerico)]
[1] 8
> # O terceiro e o quinto componentes são
> vetor_numerico[c(3, 5)] # 2nd and 4th elements of vector
[1] 5 8
> # O vetor v = (1, 2, 3, 4, 5, 6) pode ser criado com
> v <- c(1:6)
> v
[1] 1 2 3 4 5 6
> # Desta forma podemos obter 4 (por ex.)
> # elementos sequenciados de vetor_numerico
> vetor_numerico[(1:4)]
[1] 1.2 3.4 5.0 7.0
# Um componente pode ser alterado a qualquer momento
> vetor_numerico[1] <- 0
> vetor_numerico
[1] 0.0 3.4 5.0 7.0 8.0
# Novos componentes podem ser inseridos
> vetor_numerico[6] <- 203
> vetor_numerico
[1]   0   3   5   7   8 203
> Observe que o operador c concatena vetores
> frutas <- c("maçã","laranja")
> verduras <- c("alface", "brocolis","couve")
> c(frutas, verduras)
[1] "maçã"  "laranja"  "alface"  "brocolis"  "couve"

> # Em R um objeto é dinâmicamente modificado para acomodar uma atribuição
> w <- 1:3
> w[7] <- 17
> w
[1]  1  2  3 NA NA NA 17
NA é uma constante interna representando um valor ausente ou não disponível, Not Available.

Diferente do que ocorre na maioria das linguagens de programação os índices são contados à partir de 1 (e não 0).

Usamos os seguintes novos operadores:

Operador Efeito
v <- c(1:6) cria* o vetor v = (1, 2, 3, 4, 5, 6)
v <- c(a1, ..., an) cria o vetor v = (a1, ..., an), de comprimento n
v[r] retorna o r-ésimo componente, ar, se r ≤ n, NA caso contrário
v[c(p, q)] retorna componentes ap e aq
v[r] <- 5 substitui o valor de ar se r ≤ n, insere caso contrário
lenght(v) retorna o comprimento do vetor, lenght(v) = n neste caso.
*Mencionamos que o operador c concatena vetores.

Como já foi usado acima, podemos filtrar um vetor para pegar apenas alguns de seus componentes. Para ilustrar esta operação vamos criar um longo vetor e, a partir dele construir outro vetor apenas com algumas de suas componentes:

> u <- 1:10 # forma resumida de c(1:10)
> filtro <- c(T,T,T,F,F,F,T,T,T,F) # resumindo T = TRUE, F = FALSE
> u[filtro]
[1] 1 2 3 7 8 9
> # Observe ainda que podemos excluir o terceiro elemento
> u[-3]
[1]  1  2  4  5  6  7  8  9 10
> # ou todos os elementos entre o terceiro e o quinto, inclusive
> u[-3:-5]
[1]  1  2  6  7  8  9 10
> # Podemos atribuir este vetor filtrado a outra variável, para uso futuro
> novo_u <- u[-3:-5]
> # e remover o antigo, caso ele não seja mais necessário
> rm(u)
> # Se um valor for inserido o vetor muda de comprimento
> u[12] <- 100
> u
[1] 1 2 3 4 5 6 7 8 9 10 NA 100
> # A posição 11 fica indeterminada (NA)

> # A função seq fornece uma forma adicional de criar um vetor
> # onde se fornece os valores inicial e final e o acréscimo (ou passo)
> v2 <- seq(from=0, to=3, by=.25)
> v2
[1] 0.00 0.25 0.50 0.75 1.00 1.25 1.50 1.75 2.00 2.25 2.50 2.75 3.00
> # Um vetor pode ser repetido dentro de outro vetor maior
> v <- 1:3    # um shortcut para c(1:3)
> rep(v, times=3)
[1] 1 2 3 1 2 3 1 2 3
# Para repetir cada componente 2 vezes
> rep(v, each=2)
[1] 1 1 2 2 3 3
> # Podemos especificar quantas vezes repetir cada componente
> # No ex. abaixo repetir o primeiro componente 4 x, o segundo 2
> rep(c(0, 7), times = c(4,2))
[1] 0 0 0 0 7 7
> rep(v, times = c(1,0,3))
[1] 1 3 3 3
> # Repetir um vetor até obter outro de comprimento length.out
> rep(v,length.out=7)
[1] 1 2 3 1 2 3 1
> # Além das funções rep e seq podemos usar:
> # any: testa se algum elemento do vetor satisfaz uma condição
> any(v > 2)
[1] TRUE
>  any(v >= 4)
[1] FALSE
> # all: testa se todos os elementos do vetor satisfazem uma condição
> all(v > 2)
[1] FALSE
>  all(v >= 0)
[1] TRUE

Resumindo, usamos:

Função Efeito
rep(v, times = n) repete o vetor v n vezes
rep(v, times = c(r, s)) repete o primeiro componente r vezes, o segundo s vezes
rep(v, each = n) repete o vetor v, cada componente n vezes
rep(v, lenght.out = l) repete o vetor v até atingir um vetor de comprimento l
any(v condição) verifica se algum componente de v satisfaz à condição
all(v condição) verifica se todos os componentes de v satisfazem à condição

Um vetor vazio pode ser criado através da função vector(). O vetor pode ser populado em seguida. Além disso vetores possuem o atributo names que é também um vetor. Ele permite atribuir nomes aos componentes do vetor, como mostrado abaixo:

> # Cria um vetor vazio (inicialmente um vetor lógico)
> v <- vector()
> v
logical(0)
> # Popula o vetor v
> v[1] <- 1
> v[2] <- 2
> v[3] <- 3
> v
[1] 1 2 3
> is.vector(v)
[1] TRUE
# Nenhum valor foi associado a names
> names(v)
NULL
> # Popula o vetor names associado a v
> names(v)[1] <- "primeiro"
> names(v)[2] <- "segundo"
> names(v)[3] <- "terceiro"
> v
primeiro  segundo terceiro
       1        2        3
> # Alternativamente
> names(v) <- c("um", "dois" ,"três")
> v
  um dois três
   1    2    3
> # O vetor continua sendo um vetor numérico
> class(v)
[1] "numeric"
> # Um vetor pode ser criado com seu atributo names definido
> v <- c('a'=1, 'b'=2, 'c'=3)
> names(v)
[1] "a" "b" "c"
> # As aspas acima são opcionais.
> # O mesmo efeito seria obtido com v <- c(a=1, b=2, c=3)
> v
a b c
1 2 3
> # Como dito, names é um vetor. Seu primeiro componente é
> names(v)[1]
[1] "a"
> # É possível obter o componente do vetor pelo seu atributo
> pessoa <- c("nome"="Pedro","Sobrenome"="Malazartes")
> pessoa["nome"]
   nome
"Pedro"

Regras de reciclagem (recycling)

Vetores que aparecem um uma expressão não precisam, necessariamente, ter o mesmo comprimento. Caso um dos vetores seja de menor comprimento que o outro (ou outros) o resultado da expressão terá o comprimento do maior deles e os vetores menores serão reciclados (recycled). Na reciclagem eles são repetidos quantas vezes for necessário, podendo ser fracionados. Uma constante (um vetor de um elemento) é simplesmente repetido.

> u <- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
> v <- c(1, 2, 3)
> u + v
[1]  2  4  6  5  7  9  8 10  12  11
> # v é reciclado para v' = (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2)
> u + 10
 [1] 11 12 13 14 15 16 17 18 19 20


Matrizes e Arrays.

Estudos sobre o Software Estatístico R

Introdução ao R

R é uma linguagem de programação especialmente voltada para o tratamento de dados e estatística. É um software livre e de código aberto (free and open source), desenvolvido pelos estatísticos Ross Ilaka e Robert Gentleman a partir de 1993, inicialmente como um subconjunto da linguagem S. Em sua instalação básica R contém um grande número de funções estatísticas (modelagem linear e não linear, testes estatísticos clássicos, análise de séries temporais, classificação, agrupamento e muitos outros) e voltadas para a geração gráficos amplamente customizáveis. Além disso sua funcionalidade pode ser estendida por meio da instalação de pacotes (packages) muitos deles criados e disponibilizados por usuários. Tanto os pacotes de instalação como as extensões podem ser encontradas no site CRAN, The Comprehensive R Archive Network.

Pode-se interagir com R diretamente através de comandos de linha em um terminal ou por meio de alguns IDEs (ambientse de desenvolvimento integrados). Neste estudo usaremos o RStudio que pode ser baixado neste link.

Ao ser iniciado o ambiente do RStudio vemos uma informação de licença e algumas instruções básicas de uso. O prompt de comando é representado por um sinal (>), onde podemos inserir os comandos. Por exemplo, o comando help() abre as páginas de ajuda que aparecem, por default, no canto inferior esquerdo da tela. O comando help.start() acessa páginas html em CRAN e q() encerra a sessão do Studio. Um histórico dos comandos usados fica armazenado na pasta de trabalho em um arquivo oculto .Rhistory. Durante a sessão, ou quando ela é reiniciada, estes comandos ficam disponíveis e podem ser acessados usando as setas e do teclado.

R version 3.5.1 (2018-07-02) -- "Feather Spray"
Copyright (C) 2018 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

  Natural language support but running in an English locale

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

[Workspace loaded from ~/Projetos/R/.RData]

Usaremos o console e suas respostas para introduzir alguns conceitos. As instruções contendo atribuições e funções podem ser separadas por linhas ou por ponto-e-vírgula (;). Os comentários em R, que são linhas que são ignoradas pelo interpretador, são marcados uma linha de cada vez, com o sinal #.

> # Escolher uma pasta de trabalho
> setwd("/home/usuario/Projetos/R")
> # Verificar a atual pasta de trabalho
> getwd()
[1] "/home/usuario/Projetos/R"
> # Criar uma nova pasta de trabalho
> dir.create("teste")
> setwd("/home/usuario/Projetos/R/teste")
> getwd()
[1] "/home/usuario/Projetos/teste"
> # Atribuição de valor à uma variável
> x <- 1; y <- 2
> # Operações podem ser feitas interativamente
> x + y
[1] 3
> # Se o código estiver rodando de dentro de um arquivo
> print(x + y)
[1] 3
> # O estado da atual sessão pode ser gravado
> save.image("sessao1.R")
> # A sessão pode ser mais tarde recuperada com o comando
> load("/home/usuario/Projetos/teste/sessao1.R")

A Área de Trabalho (Workspace) de R é o ambiente em uso durante uma sessão, incluindo os pacotes carregados, variáves e funções definidas pelo usuário, incluindo os objetos vetores, matrizes, data frames e listas. Uma imagem do workspace atual pode ser salva ao final de uma sessão. Ela será automaticamente recuperada quando a sessão for reiniciada. O diretório (ou pasta) de trabalho atual será usado (por default) por R para ler ou gravar arquivos e dados. Para ler ou gravar em outra pasta o caminho completo deve ser fornecido. A tabela abaixo reune alguns comandos usados para a manipulação do ambiente de trabalho em R:

Comando: Resultado:
getwd() pasta atual
setwd(“pasta”) altera pasta atual
dir.create(“teste”) cria a pasta teste
dir() lista arquivos na pasta atual
save.image(“arquivo.R”) grava estado da sessão em arquivo.R
load(“arquivo.R”) recupera a sessão gravada em arquivo.R
ls() lista os objetos carregados na workspace atual
rm(objectlist) remove um ou mais objetos
help(options) fornece informação sobre as opções disponíveis
options() exibe e modifica as opções disponíveis
history(#) exibe os últimos # commandos (default = 25)
savehistory(“myfile”) grava o histórico de comandos no arquivo myfile (default =.Rhistory)
loadhistory(“myfile”) recupera o histórico de comandos no arquivo myfile (default = .Rhistory)
save.image(“myfile”) grava o workspace no arquivo myfile (default = .RData)
save(objectlist, file=”myfile”) grava objetos específicos em um arquivo
load(“myfile”) carrega para a sessão atual o workspace
sink(“nomeArquivo.txt”) redireciona todas as saídas do R para o arquivo. O arquivo gravado é fechado com sink()
q() encerra a sessão de R (oferecendo ao usuário salvar o workspace.)
Vimos também que o operador de atribuição em R é (diferente da maioria das demais linguagens de programação) <-.Atribuições também podem ser feitas da seguinte forma
r = 5
98 -> kk .
Estas não são práticas recomendadas, por convenção.

Maiores ajudas sobre uma função pode ser obtida:

Operador de ajuda Efeito
help.start() ajuda geral
help(“foo”) (?foo) ajuda sobre a função foo (aspas optionais)
help.search(“foo”) (??foo) busca pela string ‘foo’ no sistema de ajuda
example(“foo”) exemplos de uso da função foo
RSiteSearch(“foo”) busca pela string ‘foo’ no sistema de ajuda online e mailing lists
vignette() lista todas as vignettes disponíveis para os pacotes instalados
vignette(“foo”) lista todas as vignettes disponíveis para o tópico “foo”
data() lista todos os exemplos disponíveis de conjunto de dados contidos nos pacotes instalados

Vignettes são artigos introdutórios em formato pdf disponíveis para alguns pacotes.

Palavras Reservadas em R

Palavras Reservadas Uso
If, else, repeat, while, function, for, in, next, break Usados em loops, condicionais e funções
TRUE, FALSE Constantes lógicas
NULL Valor ausente ou indefinido
Inf Infinito
NaN Not a Number (não número)
NA Not Available (não disponível)
NA_integer_, NA_real_, NA_complex_, NA_ character_ Constantes de vetores com valores ausentes
Permite que uma função passe argumentospara outra

Regras e convenções para nomes de Variáveis

Para dar nomes às variáveis em R existem algumas regras e algumas convenções. Nomes válidos consistem de letras, números, pontos ou underline. A variável deve começar com uma letra ou ponto não seguido de número e não devem ser palavras reservadas.
Como convenção se pode usar:

Tipo Exemplo
apenas letras minúsculas idadealuno
palavras separadas por . idade.aluno
palavras separadas por _ idade_aluno
CamelCase minúsculas idadeAluno
CamelCase maiúsculas IdadeAluno

É aconselhável que um dos estilos seja escolhido e usados de forma consistente.

Em R o ponto . não tem um significado especial, sendo tratado apenas como um caracter.

Pacotes (Packages)

Apesar de que R já vem com um grande volume de funções em seu núcleo mínimo, um parte importante de sua funcionalidade está na possibilidade da instalação de módulos ou packages escritos por usuários que estão disponíveis para download e instalação. Estes pacotes são coleções de funções ou dados organizados de forma pré-estabelecida. Quando carregadas estas funções são usadas da mesma forma que as funções nativas.

Uma vez instalado o pacote passa a fazer parte de sua biblioteca (library). Ele fica disponível em uma sessão através do uso da função library(pacote). Você pode preparar seu ambiente de trabalho para que alguns pacotes escolhidos sejam carregados na inicialização. Por default R carrega pacotes padrões, incluindo: base, datasets, utils, grDevices, graphics, stats e methods.

Função Descrição
.libPaths() exibe localização da biblioteca.
install.packages(“pacote“) instala pacote.
library() exibe pacotes instalados.
library(pacote) Carrega pacote para uso.
installed.packages() exibe pacotes instalados.
remove.packages(“pacote“) desinstala pacote.
search() informa os pacotes carregados para uso.
update.packages() atualiza pacotes instalados.
help(package=”pacote“) Documentação sobre pacote
library(help = “pacote“) Sobre pacote (mais compacto que help(package=”pkt”)
Uma forma alternativa de desinstalação de pacotes é através do comando de linha R CMD REMOVE pacote.
Ao instalar um pacote usando a função install.packages() preste atenção às mensagens exibidas no console. Falhas na instalação são exibidas e, em geral, alguma sugestão de como o problema pode ser resolvido. A causa mais comum de falha são as dependências ausentes e, neste caso, bibliotecas específicas podem ser instaladas separadamente. Pode ocorrer que a biblioteca necessite de uma instalação funcional do Java, por exemplo. Esta instalação depende da plataforma que você está usando.

Você pode encontrar uma lista de pacotes no site CRAN – Contributed Packages, junto com instruções de instalação e uso. No final de 2018 existem mais de 13500 pacotes disponíveis no site CRAN.

Um exemplo de uso: instalamos o pacote “vcd” que contém uma tabela chamada Arthrites

> # instala o pacote vcd
> install.packages("vcd")    # um diálogo exibe as etapas da instalação
> # ajuda sobre o pacote
> help(package="vcd")        # exibe ajuda sobre vcd
> # para usar o pacote
> library(vcd)
> # para informações sobre Arthritis
> help(Arthritis)           # exibe informações sobre Arthritis
> head(Arthritis)           # exibe as 6 primeiras linhas da tabela 
  ID Treatment  Sex Age Improved
1 57   Treated Male  27     Some
2 46   Treated Male  29     None
3 77   Treated Male  30     None
4 17   Treated Male  32   Marked
5 36   Treated Male  46   Marked
6 23   Treated Male  58   Marked

Processamento em Lote (Batch processing)

Além de executar as linhas de código em uma sessão interativa de R (ou do RStudio) você pode digitar as linhas em um arquivo ASCII simples e executá-lo em lote. Isso pode ser útil no caso de um processamento demorado ou para operações programadas para ocorrer em algum momento.

Se você estiver trabalhando em Linux ou Mac OS X você deve digitar no console:

R CMD BATCH opções arquivoLote arquivoSaida
onde arquivoLote é o arquivo com as linhas de código e arquivoSaida o arquivo que deverá receber os resultados da execução. Por convenção o arquivoLote tem extensão .R e arquivoSaida tem extensão .Rout.

No Windows você digita no terminal:

“C:\Program Files\R\R-3.1.0\bin\R.exe” CMD BATCH –vanilla –slave “c:\my projects\myscript.R”

cuidando para dar o caminho correto de instalação de R e de seu arquivo de script.

Maiores detalhes em na documentação do CRAN, Introduction to R.


Tipos de dados, variáveis e vetores