5 Tipos de datos

Vimos anteriormente cómo crear un objeto. Un objeto es como una caja en la que almacenaremos información. Hasta ahora solo hemos almacenado números, pero en este capítulo veremos que es posible almacenar otra información y nos detendremos en los tipos más comunes. En este capítulo utilizaremos funciones sobre las cuales volveremos más adelante.

5.1 El tipo numeric

El tipo numeric es lo que hemos hecho hasta ahora, almacenando números. Hay dos tipos principales de números en R: enteros (integer) y números decimales (double). Por defecto, R considera todos los números como números decimales y asigna el tipo double. Para verificar el tipo de datos utilizaremos la función typeof() que toma como argumento un objeto (o directamente la información que queremos probar). También podemos usar la función is.double() que devolverá TRUE si el número está en formato double y FALSE en caso contrario. La función genérica is.numeric() devolverá TRUE si el objeto está en formato numeric y FALSE en caso contrario.

nbrRep <- 5
typeof(nbrRep)
## [1] "double"
typeof(5.32)
## [1] "double"
is.numeric(5)
## [1] TRUE
is.double(5)
## [1] TRUE

Si queremos decirle a R que vamos a trabajar con un entero, entonces necesitamos convertir nuestro número decimal en un entero con la función as.integer(). También podemos usar la función is.integer() que devolverá TRUE si el número está en formato integer y FALSE en caso contrario.

nbrRep <- as.integer(5)
typeof(nbrRep)
## [1] "integer"
typeof(5.32)
## [1] "double"
typeof(as.integer(5.32))
## [1] "integer"
as.integer(5.32)
## [1] 5
as.integer(5.99)
## [1] 5
is.numeric(nbrRep)
## [1] TRUE

Vemos aquí que convertir un número como 5.99 a integer solo devolverá la parte entera, 5.

is.integer(5)
## [1] FALSE
is.numeric(5)
## [1] TRUE
is.integer(as.integer(5))
## [1] TRUE
is.numeric(as.integer(5))
## [1] TRUE

La suma de un número entero integer y un número decimal double devuelve un número decimal.

sumIntDou <- as.integer(5) + 5.2
typeof(sumIntDou)
## [1] "double"
sumIntInt <- as.integer(5) + as.integer(5)
typeof(sumIntInt)
## [1] "integer"

Para resumir, el tipo numeric contiene dos subtipos, los tipos integer para enteros y el tipo double para los números decimales. Por defecto, R asigna el tipo double a los números.

Tenga cuidado, hay una trampa para usar la función is.integer(). No nos dice si el número es un número entero, pero si es de tipo integer. De hecho, uno puede almacenar un entero en una variable de tipo double.

Los números almacenados en una variable de tipo integer son codificados en 32 bits y, por lo tanto, pueden tomar valores entre 0 y 2^32-1 = 4294967295. Hay otra forma de decirle a R que un número es un número entero, usando el sufijo L. Por ejemplo, 5L es lo mismo que as.integer(5). El origen del sufijo L, que se remonta a una época en que las computadoras usaban palabras de 16 bits y 32 bits, era un tipo Long. ¡Ahora las computadoras usan palabras de 64 bits y 32 bits es bastante corto!

No podemos dejar esta sección sin mencionar las funciones round() ceiling() trunc() o floor() que devuelven la parte entera de un número, pero déjelo en el tipo double. Para obtener más información, podemos usar la ayuda de R con ?round.

roundDou <- round (5.2)
typeof (roundDou)
## [1] "double"

5.2 El tipo character

El tipo character es texto. De hecho, R permite trabajar con texto. Para especificar a R que la información contenida en un objeto está en formato de texto (o generalmente para todos los textos), usamos las comillas dobles (") o las comillas simples (').

myText <- "azerty"
myText2 <- 'azerty'
myText3 <- 'azerty uiop qsdfg hjklm'
typeof(myText3)
## [1] "character"

Tanto las comillas dobles y simples son útiles en nuestro texto. También podemos escapar un carácter especial como comillas gracias al signo de barra invertida \.

myText <- "a 'ze' 'rt' y"
print(myText)
## [1] "a 'ze' 'rt' y"
myText2 <- 'a "zert" y'
print(myText2)
## [1] "a \"zert\" y"
myText3 <- 'azerty uiop qsdfg hjklm'
print(myText3)
## [1] "azerty uiop qsdfg hjklm"
myText4 <- "qwerty \" azerty "
print(myText4)
## [1] "qwerty \" azerty "
myText5 <- "qwerty \\ azerty "
print(myText5)
## [1] "qwerty \\ azerty "

De forma predeterminada, cuando creamos un objeto, su contenido no es devuelto por la consola. En Internet o en muchos libros podemos encontrar el nombre del objeto en una línea para devolver sus contenidos:

myText <- "a 'ze' 'rt' y"
myText
## [1] "a 'ze' 'rt' y"

En este libro, no lo usaremos de esta manera y preferiremos el uso de la función print(), que permite mostrar en la consola el contenido de un objeto. El resultado es el mismo, pero el código es más fácil de leer y más explícito sobre lo que hace.

myText <- "a 'ze' 'rt' y"
print(myText)
## [1] "a 'ze' 'rt' y"
nbrRep <- 5
print(nbrRep)
## [1] 5

También podemos poner números en formato de texto, pero no debemos olvidar poner comillas para especificar el tipo character o usar la funciónas.character(). Una operación entre un texto y un número devuelve un error. Por ejemplo, si agregamos 10 a 5, R nos dice que un argumento de la función + no es un tipo numeric y que, por lo tanto, la operación no es posible. Tampoco podemos agregar texto a texto, pero veremos más adelante cómo concatenar dos cadenas de texto.

myText <- "qwerty"
typeof(myText)
## [1] "character"
myText2 <- 5
typeof(myText2)
## [1] "double"
myText3 <- "5"
typeof(myText3)
## [1] "character"
myText2 + 10
## [1] 15
as.character(5)
## [1] "5"
# myText3 + 10 # Error in myText3 + 10 : non-numeric argument to binary operator
# "a" + "b" # Error in "a" + "b" : non-numeric argument to binary operator

Para resumir, el tipo character permite el ingreso de texto, podemos reconocerlo con comillas simples o dobles.

5.3 El tipo factor

El tipo factor corresponde a los factores. Los factores son una elección dentro de una lista finita de posibilidades. Por ejemplo, los países son factores porque existe una lista finita de países en el mundo en un momento dado. Un factor puede definirse con la función factor() o transformarse utilizando la función as.factor(). Al igual que con otros tipos de datos, podemos usar la función is.factor() para verificar el tipo de datos. Para obtener una lista de todas las posibilidades, existe la función levels() (esta función tendrá más sentido cuando nos acerquemos a los tipos de contenedores de información).

factor01 <- factor("aaa")
print(factor01)
## [1] aaa
## Levels: aaa
typeof(factor01)
## [1] "integer"
is.factor(factor01)
## [1] TRUE
levels(factor01)
## [1] "aaa"

Un factor se puede transformar en texto con la función as.character() pero también en número con as.numeric(). Al cambiar al tipo numeric, cada factor toma el valor de su posición en la lista de posibilidades. En nuestro caso, solo hay una posibilidad, por lo que la función as.numeric() devolverá 1:

factor01 <- factor("aaa")
as.character(factor01)
## [1] "aaa"
as.numeric(factor01)
## [1] 1

5.4 El tipo logical

El tipo logical corresponde a los valores TRUE y FALSE (y NA) que ya hemos visto con los operadores de comparación.

aLogic <- TRUE
print(aLogic)
## [1] TRUE
typeof(aLogic)
## [1] "logical"
is.logical(aLogic)
## [1] TRUE
aLogic + 1
## [1] 2
as.numeric(aLogic)
## [1] 1
as.character(aLogic)
## [1] "TRUE"

5.5 Acerca de NA

El valor NA se puede usar para especificar que no hay datos o datos faltantes. Por defecto, NA es logical, pero se puede usar para texto o números.

print(NA)
## [1] NA
typeof(NA)
## [1] "logical"
typeof(as.integer(NA))
## [1] "integer"
typeof(as.character(NA))
## [1] "character"
NA == TRUE
## [1] NA
NA == FALSE
## [1] NA
NA > 1
## [1] NA
NA + 1
## [1] NA

5.6 Conclusión

Felicitaciones, hemos llegado al final de este capítulo sobre los tipos de datos. Ahora sabemos:

  • Reconocer y hacer objetos en los principales tipos de datos
  • Transformar tipos de datos de un tipo a otro

Este capítulo es la base para el próximo capítulo sobre contenedores de datos.