Rstudio

R tiene sus orígenes en S, un lenguaje de programación creado en los Laboratorios Bell de Estados Unidos. Sí, los mismos laboratorios que inventaron el transistor, el láser, el sistema operativo Unix y algunas otras cosas más.

Dado que S y sus estándares son propiedad de los Laboratorios Bell, lo cual restringe su uso, Ross Ihaka y Robert Gentleman, de la Universidad de Auckland en Nueva Zelanda, decidieron crear una implementación abierta y gratuita de S. Este trabajo, que culminaría en la creación de R inició en 1992, teniendo una versión inicial del lenguaje en 1995 y en el 2000 una versión final estable.

R hereda muchas características de S, por lo que puedes correr código de este lenguaje usando R sin mayor problema. Para lograr esto, en R frecuentemente existe más de una manera de realizar tareas comunes, una compatible con S y otra diseñada específicamente para R. Lo anterior tiene como resultado inconsistencias, sintaxis poco intuitiva y abundante frustración de cabeza para las personas que quieren aprender R.

Palabras reservadas

R tiene palabras reservadas como son los nombres de las instrucciones utilizadas en el lenguaje de programación (break, for, function, if, in, next, repeat, return, while) y los de las funciones incorporadas en el propio entorno del programa, que no se pueden usar como identificador de objetos. En el caso de intentar redefinir una funci´on ya utilizada por el programa, R advierte de la duplicidad de definiciones.

Variables

Una variable es un nombre que hace referencia a un valor. Una de las características más poderosas de un lenguaje de programación es la capacidad de manipular variables. Una variable es el nombre de una ubicación de memoria reservada que contiene algún valor. Por ejemplo: x = <- 10. Aquí, ‘x’ es el nombre de la variable, <- es un operador de asignación y 10 es el valor. Entonces, al usar un operador de asignación (<-) en Rstudio, podemos reservar memoria para el valor sin declararlo explícitamente.

x <-10

El nombre de una variable es un identificador. Un identificador también puede ser, por ejemplo, el nombre de una función. Las siguientes reglas se aplican a los identificadores:

Ejemplos de identificadores válidos son: total, Suma, .bien, valor_total,nombre5. Ejemplos de identificadores inválidos son: alumn@, 7nombre, _bien, TRUE, .6nombre (TRUE no es válido porque es una palabra reservada de R).

R es sensible a las mayúsculas. Esto significa que los identificadores Nombre, nombre o NOMBRE son distintos. Aunque R lo permite, no uses identificadores que sólo se diferencian en si unas letras están en mayúsculas o minúsculas, pues puede causar confusión.

Operadores

Operaores Aritmeticos

SUMA. Suma de los dos operandos

4+5
## [1] 9

RESTA. Resta los operandos derechos del operando izquierdo

9-5
## [1] 4

MULTIPLICACION. Multiplica los dos operandos

4*3
## [1] 12

DIVISION. El operando izquierdo se divide por el operando derecho

5/3
## [1] 1.666667

POTENCIA. Elevo el operando izquiero a la potencia del derecho

4**3
## [1] 64

COCIENTE. Bota el cociente de una division

8%%3
## [1] 2

Operadores relacionales y lógicos

Ejemplos especiales

"casa">"barco"
## [1] TRUE

Este resultado se debe a que se ha hecho una comparación por orden alfabético. En este caso, la palabra “casa” tendría una posición posterior a “barco”, pues empieza con “c” y esta letra tiene una posición posterior a la “b” en el alfabeto. Por lo tanto, es verdadero que sea “mayor”.

Cuando intentamos comparar factores, siempre obtendremos como resultado NA y una advertencia acerca de que estos operadores no son significativos para datos de tipo factor.

as.factor("casa") > "barco"
## Warning in Ops.factor(as.factor("casa"), "barco"): '>' not meaningful for
## factors
## [1] NA

Los operadores | y & pueden ser usados con estos con datos de tipo numérico, lógico y complejo. Al igual que con los operadores relacionales, los operadores lógicos siempre devuelven TRUE o FALSE.

Para realizar operaciones lógicas, todos los valores numéricos y complejos distintos a 0 son coercionados a TRUE, mientras que 0 siempre es coercionado a FALSE.

Por ejemplo, 5 | 0 resulta en TRUE y 5 & FALSE resulta en FALSE. Podemos comprobar lo anterior con la función isTRUE().

5 | 0
## [1] TRUE
5 & 0
## [1] FALSE
isTRUE(5)
## [1] FALSE
isTRUE(0)
## [1] FALSE

Estos operadores se pueden combinar para expresar relaciones complejas.

Por ejemplo, la negación FALSE Y FALSE dará como resultado TRUE.

!(FALSE | FALSE)
## [1] TRUE

Tipos de datos

Datos atomicos

Los tipos de datos atómicos son los tipos de objetos con los que puedes crear vectores (atómicos). Los tipos de datos más comunes en R son los que se enumeran en la siguiente lista:

Con la funcion is.atomic. podremos verificar si el valor ingresado pertene a los datos atómicos

is.atomic(3) 
## [1] TRUE
is.atomic("R CODER")
## [1] TRUE
is.atomic(3+2i)
## [1] TRUE

Datos más comunes

La funcion class imprime el tipo de dato de un objeto en R studio. Entre estas clases existe una gran diversidad de tipos como:

class(1)#integer
## [1] "numeric"
class(1.3)#numeric
## [1] "numeric"
class("hola amiguito")#character
## [1] "character"
class(TRUE)#logico
## [1] "logical"
class(NA)#NA
## [1] "logical"
class(NULL)#null
## [1] "NULL"

Conversion

Podemos hacer coerciones usando la familia de funciones as() as.integer() Entero as.numeric() Numerico as.character() Cadena de texto as.factor() Factor as.logical() Lógico as.null() NULL Cuando estas funciones tienen éxito en la coerción, nos devuelven datos del tipo pedido. Si fallan, obtenemos NA como resultado.

#Ejemplo
as.character(5)
## [1] "5"
as.numeric("cinco")
## Warning: NAs introducidos por coerción
## [1] NA

Si coercionamos un dato de tipo lógico a numérico, TRUE siempre devolverá 1 y FALSE dará como resultado 0.

as.numeric(TRUE)
## [1] 1
as.numeric(FALSE)
## [1] 0

Por último, la funcón as.null() siempre devuelve NULL, sin importar el tipo de dato que demos como argumento.

as.null(FALSE)
## NULL
as.null(457)
## NULL
as.null("palabra")
## NULL

Cadenas de texto

En RStudio, como en el lenguaje de programación R en general, las cadenas de texto son una parte fundamental para trabajar con datos y realizar análisis. Las cadenas de texto se utilizan para representar y manipular información textual, como nombres, descripciones, etiquetas y más. Aquí te proporcionaré una introducción extensa a las cadenas de texto en RStudio, junto con una variedad de ejemplos y funciones predefinidas.

Creación de cadenas de texto: Puedes crear cadenas de texto en RStudio de varias formas:

# Usar comillas simples o dobles
cadena1 <- "Esto es una cadena de texto."
cadena2 <- 'Otra cadena de texto.'

# Combinar cadenas de texto con el operador de concatenación
cadena_completa <- paste("Hola", "Mundo")
cadena_completa
## [1] "Hola Mundo"

Longitud de una cadena: Para obtener la longitud de una cadena de texto, puedes usar la función nchar():

longitud <- nchar("Hola, ¿cómo estás?")
longitud
## [1] 18

Concatenación de cadenas Puedes combinar o concatenar cadenas de texto utilizando el operador de concatenación:

saludo <- "Hola"
nombre <- "Juan"
mensaje <- paste(saludo, nombre)  # Combina "Hola" y "Juan" en "Hola Juan"
mensaje
## [1] "Hola Juan"

Modificación de cadenas: Las cadenas de texto en R son inmutables, lo que significa que no puedes cambiar un carácter específico directamente. Sin embargo, puedes crear una nueva cadena con las modificaciones deseadas:

frase <- "Este es un ejemplo."
nueva_frase <- substring(frase, first = 1, last = 12)  # Obtiene los primeros 12 caracteres
nueva_frase
## [1] "Este es un e"

Búsqueda y reemplazo: Puedes buscar y reemplazar subcadenas en una cadena de texto utilizando la funcion sub()

texto <- "Hola, amigo. ¿Cómo estás, amigo?"
nuevo_texto <- sub("amigo", "amiga", texto)  # Reemplaza la primera instancia de "amigo" por "amiga"
nuevo_texto
## [1] "Hola, amiga. ¿Cómo estás, amigo?"

Formateo de cadenas: Puedes formatear cadenas de texto usando la función sprintf() para crear cadenas con formato:

nombre <- "Juan"
edad <- 30
mensaje <- sprintf("Hola, %s. Tienes %d años.", nombre, edad)
mensaje
## [1] "Hola, Juan. Tienes 30 años."

Caracteres de escape: Para incluir caracteres especiales en cadenas de texto, puedes utilizar caracteres de escape, como \n para un salto de línea o \t para un tabulador:

texto <- "Línea 1\nLínea 2"
cat(texto)  # Imprime dos líneas
## Línea 1
## Línea 2

Funciones de manejo de texto: R ofrece numerosas funciones para el manejo de texto, como tolower(), toupper(), substr(), trimws(), y más. Estas funciones te ayudarán a realizar manipulaciones más avanzadas en tus cadenas de texto.

texto <- "Hola, Mundo"
texto_en_mayusculas <- toupper(texto)  # Convierte a mayúsculas
substring <- substr(texto, start = 1, stop = 4)  # Obtiene un subconjunto de la cadena

Estos son solo algunos ejemplos de cómo trabajar con cadenas de texto en RStudio. R proporciona una amplia variedad de funciones y operadores para realizar operaciones de manipulación y análisis de texto de manera efectiva. Las cadenas de texto son esenciales para la programación y el análisis de datos en R, y su comprensión te permitirá trabajar de manera más eficiente con datos textuales en tus proyectos.

Lista

Las listas, al igual que los vectores, son estructuras de datos unidimensionales, sólo tienen largo, pero a diferencia de los vectores cada uno de sus elementos puede ser de diferente tipo o incluso de diferente clase, por lo que son estructuras heterogéneas.

Podemos tener listas que contengan datos atómicos, vectores, matrices, arrays, data frames u otras listas. Esta última característica es la razón por la que una lista puede ser considerada un vector recursivo, pues es un objeto que puede contener objetos de su misma clase.

Para crear una lista usamos la función list(), que nos pedirá los elementos que deseamos incluir en nuestra lista. Para e Ejemplo

mivector <- 1:10
mimatriz <- matrix(1:4, nrow = 2)
midf     <- data.frame("num" = 1:3, "let" = c("a", "b", "c"))
milista <- list("unvector" = mivector, "unamatriz" = mimatriz, "undf" = midf)
milista
## $unvector
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $unamatriz
##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4
## 
## $undf
##   num let
## 1   1   a
## 2   2   b
## 3   3   c

Una lista es unidimensional, sólo tiene largo.

El largo de una lista es igual al número de elementos que contiene, sin importar de qué tipo o clase sean. Usamos la lista recursiva que creamos en la sección anterior para ilustrar esto.

length(milista)
## [1] 3

Las listas tienen clase list, sin importar qué elementos contienen.

class(milista)
## [1] "list"

También se pueden extraer elementos de una lista, a diferencia de Python, en Rstudio inicamos a partir del valor 1 y no del 0

x <- c(45, 12, 56, 14, 16)
y <- c("Coche", "Bicicleta")
z <- matrix(1:12, ncol = 4)
mi_lista <- list(x, y, z)
# Primer elemento de la lista
mi_lista[1]
## [[1]]
## [1] 45 12 56 14 16
# Primer elemento de la lista, simplificando la salida
mi_lista[[1]]
## [1] 45 12 56 14 16
# Primer elemento del primer elemento de la lista.
mi_lista[[1]][1]
## [1] 45
# Primera columna del tercer elemento
mi_lista[[3]][, 1]
## [1] 1 2 3
# Segundo elemento de la primera columna
# del tercer elemento de la lista
mi_lista[[3]][, 1][2]
## [1] 2
mi_lista[[3]][2, 1] # Equivalente
## [1] 2

Si necesitas agregar un elemento a una lista, puedes especificar el objeto que deseas agregar en el siguiente índice a longitud de la lista. Es decir, si la longitud de la lista es 3, puede agregar el nuevo objeto en el cuarto índice.

mi_lista[[4]] <- data.frame(X = c(8, 5, 3), Y = c(7, 9, 1))

Para eliminar elementos hacer lo siguiente

mi_lista[-2]
## [[1]]
## [1] 45 12 56 14 16
## 
## [[2]]
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
## 
## [[3]]
##   X Y
## 1 8 7
## 2 5 9
## 3 3 1

Para poder unir dos listas se puede usar el código append

mi_lista_nombres <- list(A = x, B = y, C = z)
append(mi_lista, mi_lista_nombres)
## [[1]]
## [1] 45 12 56 14 16
## 
## [[2]]
## [1] "Coche"     "Bicicleta"
## 
## [[3]]
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
## 
## [[4]]
##   X Y
## 1 8 7
## 2 5 9
## 3 3 1
## 
## $A
## [1] 45 12 56 14 16
## 
## $B
## [1] "Coche"     "Bicicleta"
## 
## $C
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12

A su vez también se puede resaltar elementos comunes con intersect o elementos diferentes como setdiff o ver si son iguales con el código %in%

x <- 1:9
y <- 7:13
z <- 10:20
a <- list(x,y)
b <- list(y,z)
intersect(a,b)
## [[1]]
## [1]  7  8  9 10 11 12 13
setdiff(a,b)
## [[1]]
## [1] 1 2 3 4 5 6 7 8 9
a%in%b
## [1] FALSE  TRUE

En RStudio, un entorno de desarrollo integrado para el lenguaje de programación R, no existen estructuras de datos nativas específicas denominadas “tuplas” o “diccionarios” como se encuentran en algunos otros lenguajes de programación. En cambio, R se basa principalmente en listas y vectores con nombres para organizar y manipular datos de manera estructurada.

Para simular una tupla, los usuarios pueden utilizar listas o vectores con nombres, y para emular un diccionario, pueden recurrir a listas o paquetes adicionales como listenv o hash. Sin embargo, estas implementaciones son aproximaciones y carecen de las propiedades y funcionalidades específicas asociadas a las tuplas y diccionarios en otros lenguajes.

En resumen, en RStudio, se depende principalmente de listas y vectores con nombres para organizar y acceder a datos de manera estructurada, ya que no hay una implementación nativa de tuplas o diccionarios como se encuentran en otros lenguajes de programación