Tipos de datos en R con ejemplo

¿Cuáles son los tipos de datos en R?

A continuación se muestran los tipos de datos o estructuras de datos en la programación R:

• Escalares
• Vectores (numéricos, de caracteres, lógicos)
• Matrices
• Marcos de datos
• Listas

Esa lista mezcla dos ideas relacionadas, y separarlas facilita la comprensión del resto de esta página. tipo de datos describe qué es un valor único: un número, un fragmento de texto, un VERDADERO o un FALSO. estructura de datos Describe cuántos valores se mantienen juntos y en qué forma. Los escalares, vectores, matrices, marcos de datos y listas son estructuras; los valores que contienen pertenecen a uno de los tipos básicos de R.

R no tiene un tipo de escalar separado: un escalar es simplemente un vector de longitud uno, razón por la cual gran parte del código R se escribe para vectores completos a la vez.

Tipos de datos básicos en R

Cada valor en R pertenece a uno de un pequeño conjunto de tipos básicos (atómicos):

• 4.5 es un valor decimal llamado numérico.
• El número 4 parece un número entero, pero R lo almacena como un número de punto flotante de doble precisión. Escribe 4L cuando se requiera un número entero verdadero.
• VERDADERO o FALSO es un valor booleano, llamado valor lógico en R.
• El valor dentro de ” ” o ' ' es texto (una cadena). Esos valores se llaman caracteres.

Otros dos tipos completan el conjunto. Los valores complejos, como 3+2i, contienen una parte real y una imaginaria, y los valores sin procesar contienen bytes. Ambos aparecen raramente en el análisis cotidiano, pero están listados en la base R. Documentación de typeof() junto con los cuatro tipos comunes.

Podemos comprobar el tipo de una variable con la función de clase.

Ejemplo 1: Comprobar una variable numérica

# Declare variables of different types
# Numeric
x <- 28
class(x)

Salida:

## [1] "numeric"

Ejemplo 2: Comprobar una variable de tipo carácter

# String
y <- "R is Fantastic"
class(y)

Salida:

## [1] "character"

Ejemplo 3: Comprobar una variable lógica

# Boolean
z <- TRUE
class(z)

Salida:

## [1] "logical"

Nótese que class() devuelve "numeric" para 28, aunque 28 no tenga parte decimal. R lo almacenó como un double, y solo typeof() lo revela. La siguiente diferencia que vale la pena conocer es cómo se asignan nombres a esos valores.

Variables en R

Las variables son uno de los componentes básicos de R para almacenar valores, y son fundamentales para cualquier persona que trabaje en ciencia de datos. Una variable en R puede almacenar un número, un objeto, un resultado estadístico, un vector, un conjunto de datos o una predicción de un modelo; básicamente, cualquier resultado que R pueda generar. Posteriormente, podemos usar esa variable simplemente llamando a su nombre.

Para declarar una variable en R, necesitamos asignarle un nombre. El nombre no debe contener espacios. Podemos usar _ para unir dos palabras.

Los nombres pueden contener letras, dígitos, puntos y guiones bajos, pero deben comenzar con una letra o un punto. No se pueden usar palabras reservadas como TRUE, FALSE y NULL. Para agregar un valor a la variable, use <- o =.

Aquí está la sintaxis:

# First way to declare a variable:  use the `<-`
name_of_variable <- value
# Second way to declare a variable:  use the `=`
name_of_variable = value

En la línea de comandos, podemos escribir los siguientes códigos para ver qué sucede:

Ejemplo 1: Asignar un valor e imprimirlo.

# Print variable x
x <- 42
x

Salida:

## [1] 42

Ejemplo 2: Declarar una segunda variable

y  <- 10
y

Salida:

## [1] 10

Ejemplo 3: Usar dos variables en una misma expresión

# We call x and y and apply a subtraction
x-y

Salida:

## [1] 32

Una variable que contiene varios valores del mismo tipo es un vector, que es la estructura que prácticamente todas las funciones de R esperan.

Vectores en R

Un vector es una colección unidimensional en la que todos los elementos son del mismo tipo. Podemos crear un vector con todos los tipos de datos básicos de R que vimos anteriormente. La forma más sencilla de crear un vector en R es usar la función c().

Ejemplo 1: Crear un vector numérico

# Numerical
vec_num <- c(1, 10, 49)
vec_num

Salida:

## [1]  1 10 49

Ejemplo 2: Crear un vector de caracteres

# Character 
vec_chr <- c("a", "b", "c")
vec_chr

Salida:

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

Ejemplo 3: Crear un vector lógico

# Boolean 
vec_bool <-  c(TRUE, FALSE, TRUE)
vec_bool

Salida:

##[1] TRUE FALSE TRUE

Si c() recibe una mezcla de tipos, no falla. Convierte silenciosamente cada elemento al tipo más general presente, de modo que c(1, "a", TRUE) se convierte en un vector de caracteres. También podemos realizar cálculos aritméticos con vectores en R.

Ejemplo 4: Sumar dos vectores elemento por elemento.

# Create the vectors
vect_1 <- c(1, 3, 5)
vect_2 <- c(2, 4, 6)
# Take the sum of A_vector and B_vector
sum_vect <- vect_1 + vect_2
# Print out total_vector
sum_vect

Salida:

[1]  3  7 11

La suma se realizó elemento por elemento porque ambos vectores tienen la misma longitud. Cuando las longitudes difieren, R reutiliza el vector más corto, repitiéndolo hasta que coincida con el más largo, y solo emite una advertencia cuando la longitud mayor no es un múltiplo de la menor.

Ejemplo 5: Dividir los primeros cinco elementos

En R, es posible segmentar un vector. En algunas ocasiones, solo nos interesan los primeros cinco elementos de un vector. Podemos usar el comando [1:5] para ello.tract los valores del 1 al 5.

# Slice the first five rows of the vector
slice_vector <- c(1,2,3,4,5,6,7,8,9,10)
slice_vector[1:5]

Salida:

## [1] 1 2 3 4 5

Ejemplo 6: Crear un rango con dos puntos Operator

La forma más sencilla de crear un rango de valores es usar el operador de dos puntos (:) entre dos números. Por ejemplo, en el ejemplo anterior, podemos escribir c(1:10) para crear un vector de valores del uno al diez.

# Faster way to create adjacent values
c(1:10)

Salida:

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

Dado que un vector cambia de tipo silenciosamente al ser mezclado, conviene saber cómo inspeccionar y convertir los tipos según sea necesario.

Cómo comprobar y convertir tipos de datos en R

Tres familias de funciones responden a las tres preguntas que surgen constantemente: ¿qué es esto?, ¿es esto un tipo dado?, y ¿puede esto convertirse en otro tipo?

# Three different views of the same value
x <- 28
class(x)      # "numeric"  -- the class used for method dispatch
typeof(x)     # "double"   -- how R stores the value internally
mode(x)       # "numeric"  -- the older S-style mode

# Ask a yes/no question about a type
is.numeric(x)     # TRUE
is.character(x)   # FALSE

# Convert between types
as.character(x)   # "28"
as.integer("28")  # 28 stored as an integer
as.numeric("abc") # NA, with a coercion warning

Dos reglas explican la mayoría de las sorpresas aquí. Primero, class() informa la clase utilizada para el despacho del método, mientras que typeof() informa el almacenamiento interno, razón por la cual 28 es "numérico" para uno y "doble" para el otro. Segundo, una conversión que no puede tener éxito no detiene el script: as.numeric("abc") devuelve NA e imprime una advertencia de coerción, por lo que los NA silenciosos después de una importación son casi siempre un problema de tipo. La misma lógica impulsa factores importantes, que almacenan categorías como códigos enteros más una tabla de niveles.

Una vez definidos los tipos, el siguiente paso es determinar los operadores que los utilizarán.

R aritmética Operatoros

Primero veremos los operadores aritméticos básicos en R. A continuación se muestran los operadores aritméticos en la programación en R y su significado:

Cada uno de estos operadores está vectorizado, por lo que la misma expresión funciona tanto con un solo valor como con una columna completa.

Ejemplo 1: Suma

# An addition
3 + 4

Salida:

## [1] 7

Puedes copiar y pegar fácilmente el código R anterior en el RStudio Consola. En este artículo, la salida se muestra en las líneas que comienzan con ##. Por ejemplo, si escribimos el código print("Guru99") la consola imprime [1] "Guru99", que esta página mostraría como ## [1] "Guru99 ".

El símbolo ## marca una línea de salida impresa, y el número entre corchetes ([1]) es el índice del primer valor de esa línea, no forma parte del resultado.

Las oraciones que comienzan con # son comentarios. Podemos usar # dentro de un script de R para agregar cualquier nota que queramos, y R la ignorará durante la ejecución.

Ejemplo 2: Multiplicación

# A multiplication
3*5

Salida:

## [1] 15

Ejemplo 3: División

# A division
(5+5)/2

Salida:

## [1] 5

Ejemplo 4: Exponenciación

# Exponentiation
2^5

Salida:

## [1] 32

Ejemplo 5: Módulo

# Modulo
28%%6

Salida:

## [1] 4

La aritmética produce números. El siguiente grupo de operadores produce VERDADERO y FALSO.

R Relacional (Comparación) Operatoros

Los operadores relacionales comparan dos valores y devuelven un resultado lógico. Son los operadores que establecen las condiciones utilizadas para el filtrado y se vectorizan exactamente igual que los operadores aritméticos.

a <- 10
b <- 3

a > b     # TRUE
a < b     # FALSE
a >= 10   # TRUE
a <= 3    # FALSE
a == b    # FALSE
a != b    # TRUE

# Relational operators are vectorised
scores <- c(45, 78, 90, 62)
scores >= 60   # FALSE TRUE TRUE TRUE

Dos hábitos ahorran tiempo aquí. Use == para comparación y <- para asignación, porque un solo = dentro de una condición es un error común de principiante. Y evite == en números de punto flotante: el redondeo de punto flotante significa que 0.1 + 0.2 == 0.3 es FALSO, por lo que isTRUE(all.equal(0.1 + 0.2, 0.3)) es la prueba segura. Comparaciones en marcos de datos ordenados Sigue las mismas reglas.

R lógico Operatoros

Con los operadores lógicos, queremos devolver valores dentro del vector en función de condiciones lógicas. La siguiente tabla enumera los operadores lógicos disponibles en R.

En R, las expresiones lógicas se encierran entre corchetes []. Podemos añadir tantas expresiones condicionales como queramos, pero debemos incluirlas entre paréntesis. Podemos seguir esta estructura para crear una expresión condicional:

variable_name[(conditional_statement)]

Utilizando `variable_name` como referencia a la variable que queremos usar en la instrucción, creamos la instrucción lógica, por ejemplo, `variable_name > 0`. Finalmente, usamos corchetes para finalizar la instrucción lógica. A continuación, se muestra un ejemplo de instrucción lógica.

Ejemplo 1: Comparar todos los elementos de un vector.

# Create a vector from 1 to 10
logical_vector <- c(1:10)
logical_vector>5

Salida:

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

En la salida anterior, R lee cada valor y lo compara con la condición logical_vector>5. Si el valor es estrictamente mayor que cinco, la condición es VERDADERA; de lo contrario, es FALSA. R devuelve un vector de VERDADERO y FALSO.

Ejemplo 2: Conservar solo los elementos que coinciden

En el ejemplo siguiente, queremos extract los valores que solo cumplen la condición 'es estrictamente mayor que cinco'. Para ello, podemos encerrar la condición entre corchetes precedida por el vector que contiene los valores.

# Print value strictly above 5
logical_vector[(logical_vector>5)]

Salida:

## [1]  6  7  8  9 10

Ejemplo 3: Combinar dos condiciones

# Print 5 and 6
logical_vector <- c(1:10)
logical_vector[(logical_vector>4) & (logical_vector<7)]

Salida:

## [1] 5 6

El ejemplo 3 utiliza el ampersand simple & a propósito. Los operadores de un solo carácter & y | comparan vectores elemento por elemento y devuelven un vector, que es lo que necesita el subconjunto. Las formas dobles && y || devuelven un valor y pertenecen a las condiciones if() y while(). Dado que R 4.3.0Pasar un argumento de más de un elemento a && o || es un error en lugar de una advertencia, por lo que las dos familias ya no son intercambiables. El operador ! niega una condición, y xor() da OR exclusivo.

Tarea de R Operatoros

Los operadores de asignación vinculan un valor a un nombre. R ofrece más de ellos que la mayoría de los lenguajes, y las diferencias importan una vez que el código pasa a funciones.

# Left assignment -- the idiomatic form
count <- 5

# Equals sign: works, but reserve it for function arguments
count = 5
round(3.14159, digits = 2)

# Right assignment
5 -> count

# Superassignment, used inside functions to reach an outer scope
count <<- 5

Las guías de estilo recomiendan <- para crear objetos y = para nombrar argumentos dentro de una llamada, porque así los dos roles se mantienen visualmente distintos. Use <<- con moderación: cambia un objeto fuera de la función actual y hace que el código sea más difícil de entender. Una vez que la asignación y los tipos sean familiares, los siguientes pasos son: Importación de datos reales y reshaping con dplyr; El Descripción general del lenguaje R Pone en contexto toda la cadena de herramientas.

Preguntas Frecuentes