6.1 Classes de dados
Existem vários classes de dados no R. As mais utilizadas são mostradas na 6.1. A classe de um objeto é obtida com a função class().
x <- 51
class(x)
#> [1] "numeric"| Classes de dados | Classes no R | exemplo |
|---|---|---|
| Números | numeric | 2.5, 2 |
| Caracteres | character | a |
| Lógicos | logical | TRUE, FALSE |
| Datas | Date | 2010-01-01 |
| Datas e horários | POSIX | 2010-01-01 00:00:00 |
6.1.1 Números
É a classe de objeto mais usada. Essa classe é chamada numeric no 
e é similar a float ou double em outras linguagens. Ela trata de inteiros, decimais, positivos, negativos e zero. Um valor numérico armazenado em um objeto é automaticamente assumido ser numérico. Para testar se um objeto é numérico usa-se a função is.numeric().
is.numeric(x)
#> [1] TRUE
is.numeric(pi)
#> [1] TRUEOutro tipo é o integer (inteiro), ou seja não há parte decimal. Para definir um objeto como inteiro é necessário acrescentar ao valor numérico um L. Analogamente, uma forma de verificação se o objeto é inteiro é através função is.integer().
i <- 3L
is.integer(i)
#> [1] TRUE
is.integer(pi)
#> [1] FALSEMesmo com o objeto i sendo inteiro, ele também passa na verificação is.numeric().
is.numeric(i)
#> [1] TRUEO R converte inteiros para numéricos quando necessário. Vamos usar a função typeof() para determinar o tipo de dado e as conversões que o R faz. Por exemplo:
## integer * numeric
typeof(5L)
#> [1] "integer"
typeof(4.5)
#> [1] "double"
(prod_i <- 5L * 4.5)
#> [1] 22.5
typeof(prod_i)
#> [1] "double"
## integer/integer
typeof(5L)
#> [1] "integer"
typeof(2L)
#> [1] "integer"
typeof(5L/2L)
#> [1] "double"
# número complexo
typeof(3 + 2i)
#> [1] "complex"6.1.2 Caractere
O tipo de dado caractere (do termo em inglês character ou string) é bastante utilizado e deve ser manipulado com cuidado. Há duas principais formas de lidar com caracteres: a função character() e a factor(). Embora pareçam similares eles são tratados de forma diferente.
(char <- "Vai chover hoje?")
#> [1] "Vai chover hoje?"
charf <- factor("Vai chover hoje?")
charf
#> [1] Vai chover hoje?
#> Levels: Vai chover hoje?
levels(charf)
#> [1] "Vai chover hoje?"
ordered(charf)
#> [1] Vai chover hoje?
#> Levels: Vai chover hoje?char contém as palavras "Vai chover hoje?", enquanto, charf tem as mesmas palavras porém sem as aspas e a segunda linha de informação sobre os níveis (levels) de charf. Nós veremos esse tipos de dado futuramente em vetores.
Lembre-se que caracteres em letras minúsculas e maiúsculas são coisas diferentes no R.
Para encontrar o tamanho de um character usamos a função nchar().
nchar(char)
#> [1] 16
nchar("abc")
#> [1] 3Esta função não funcionará para um objeto do tipo factor.
nchar(charf)
#> Error in nchar(charf): 'nchar()' requires a character vector6.1.3 Lógico
Valores lógicos (logical no ) são uma forma de representar dados que podem assumir valores booleanos, isto é, TRUE (verdadeiro) ou FALSE (falso). O aceita as abreviaturas T e F para representar TRUE e FALSE,
# variável lógica
vl <- c(FALSE, T, F, TRUE)
vl
#> [1] FALSE TRUE FALSE TRUEEntretanto, esta não é uma prática recomendável, conforme exemplo abaixo.
TRUE
#> [1] TRUE
T
#> [1] TRUE
class(T)
#> [1] "logical"
T <- 10
class(T)
#> [1] "numeric"Valores lógicos podem ser usados em operações aritméticas. Neste caso, serão convertidos numericamente para 1 (TRUE) e 0 (FALSE).
vl * 5
#> [1] 0 5 0 5
TRUE * 4
#> [1] 4
TRUE + TRUE
#> [1] 2
FALSE - TRUE
#> [1] -1Assim como as outras classes de dados, existem funções para verificar a classe de dados lógicos.
class(vl)
#> [1] "logical"
is.logical(vl)
#> [1] TRUEValores lógicos resultam da comparação de números ou caracteres.
4 == 3 # 4 é idêntico a 3?
#> [1] FALSE
teste2i2 <- 2 * 2 == 2 + 2
teste2i2
#> [1] TRUE
teste2d2 <- 2 * 2 != 2 + 2 # operador: diferente de
teste2d2
#> [1] FALSE
4 < 3
#> [1] FALSE
4 > 3
#> [1] TRUE
4 >= 3 & 4 <= 5
#> [1] TRUE
4 <= 3 | 4 <= 5
#> [1] TRUE
"abc" == "defg"
#> [1] FALSE
"abc" < "defg"
#> [1] TRUE
nchar("abc") < nchar("defg")
#> [1] TRUEA Tabela 6.2 apresenta os principais operadores lógicos disponíveis no .
| Operador | Descrição |
|---|---|
| < | menor que |
| <= | menor ou igual a |
| > | maior que |
| >= | maior ou igual |
| == | idêntico |
| != | diferente |
| !x | não é x (negação) |
| x | y | x ou y |
| x & y | x e y |
| isTRUE(x) | teste se x é verdadeiro |
| %in% | está contido em |
6.1.4 Datas e horários
Lidar com datas e horários pode ser difícil em qualquer linguagem e pode complicar mais ainda quando há diversas opções de classes de datas disponíveis, como no . Entre as classes mais convenientes para este tipo de informação consideram-se:
DatePOSIXct
Date armazena apenas a data enquanto POSIXct armazena a data e o horário. Ambos dados são representados como o número de dias (Date) ou segundos (POSIXct) decorridos desde 1 de Janeiro de 1970.
data1 <- as.Date("2012-06-28")
data1
#> [1] "2012-06-28"
class(data1)
#> [1] "Date"
as.numeric(data1)
#> [1] 15519
data2 <- as.POSIXct("2012-06-28 17:42")
data2
#> [1] "2012-06-28 17:42:00 UTC"
class(data2)
#> [1] "POSIXct" "POSIXt"
as.numeric(data2)
#> [1] 1340905320A manipulação de dados da classe de datas e horários (Date-time) torna-se mais versátil através dos pacotes lubridate e chron, o que será visto posteriormente no curso.
Funções como as.numeric() e as.Date() não apenas mudam o formato de um objeto mas muda realmente a classe original do objeto.
class(data1)
#> [1] "Date"
class(as.numeric(data1))
#> [1] "numeric"