Sintaxis Basica en R & RStudio

Author

Andres del Rosario Jimenez Pacheco

R & RStudio

Historía de R & RStudio

R es un lenguaje de programación estadística y un entorno de desarrollo ampliamente utilizado en la investigación y análisis de datos. Fue creado por Ross Ihaka y Robert Gentleman en 1993 en la Universidad de Auckland, Nueva Zelanda. R se ha convertido en una herramienta fundamental en estadísticas y ciencia de datos debido a su flexibilidad y extensa comunidad de usuarios y desarrolladores.

RStudio, por otro lado, es un entorno de desarrollo integrado (IDE) diseñado específicamente para trabajar con R. Fue desarrollado por JJ Allaire y su equipo en 2010. RStudio simplifica la programación en R, ofreciendo características como la edición de código, visualización de resultados y la administración de paquetes de manera eficiente. Juntos, R y RStudio han revolucionado la forma en que se aborda el análisis de datos y la estadística en la era moderna.

Palabras Reservadas

Las palabras reservadas en el lenguaje donde los humanos hablan con RStudio incluyen las siguientes:

if else repeat while
quit break FALSE TRUE
for function in Inf
NA NaN next Null
repeat while NA_character NA_integer_

Variables y Tipos

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:

Pekines <- 15. Aquí, ‘x’ es el nombre de la variable, el signo igual (<-) es un operador de asignación y 10 es el valor o literal.

Entonces, al usar un operador de asignación (<-) en R & RStudio, podemos reservar memoria para el valor sin declararlo explícitamente.

Pekines <- 15

Reglas para definir un nombre de variable

  • El nombre de una variable debe comenzar con una letra o un guión bajo (_); no puede comenzar con un número.

  • Solo puede contener (AZ, az, 0-9 y _).

  • Es importante recordar que en python los nombres de las variables distinguen entre mayúsculas y minúsculas.

Para nombres de variables de varias palabras, se usan guiones bajos entre palabras (nombre_variable), pero algunos usan “camelCase” (a veces llamado “studlyCaps”) como nombreVariable.

Operadores aritméticos.

Los operadores aritméticos son necesarios para realizar operaciones aritméticas como suma, resta, multiplicación, división, etc. La siguiente tabla es la lista de operadores aritméticos en R.

Nombre del Operador Simbolo de Operador Descripcion Ejemplo
Suma + Suma de los Operandos X + Y
Resta - Resta de los Operandos X - Y
Multiplicacion * Multiplica los dos operandos X * Y
División Flotante / El operando izquierdo se divide por el operando derecho y da como resultado el valor flotante X/Y
División de Piso // El operando izquierdo se divide por el operando derecho y da como resultado el valor mínimo de división X//Y
Exponente ^ Elevó el operando izquierdo a la potencia del derecho. X^Y
Módulos % Da el resto de la división del operando izquierdo por el operando derecho X%Y

Operadores Relacionales

Los operadores relacionales se utilizan para comprobar la relación entre operandos y comparar los valores. Según la condición, estos operadores devuelven como resultado “Verdadero” o “Falso”:

Nombres del Operador Simbolos de Operador Descripcion Ejemplo
Igual a == Comparar si el valor del operando izquierdo es igual al valor del operando derecho X == Y
No igual o Diferente != Comparar si el valor del operando izquierdo no es igual al valor del operando derecho X!=Y
Menor que < Comparar si el valor del operando izquierdo es menor que el valor del operando derecho X<Y
Mayor que > Comparar si el valor del operando izquierdo es mayor que el valor del operando derecho X>Y
Menor o Igual que <= Comparar el valor del operando izquierdo es menor o igual que el valor del operando derecho X<=Y
Mayor o Igual que >= Comparar el valor del operando izquierdo es mayor o igual que el valor del operando derecho X>=Y 
#DECLARAMOS DOS VARIABLES
a <- 20
b <- 28
# Comprobar si a es igual a b
resultado_1<- a == b

# Mostrar el resultado
cat("igual a la relación => (a==b) es:", resultado_1, "\n")
igual a la relación => (a==b) es: FALSE 
# Comprobar si a no es igual a b
resultado_2 <- a != b

# Mostrar el resultado
cat("no es igual a la relación => (a!=b) es:", resultado_2, "\n")
no es igual a la relación => (a!=b) es: TRUE 
# Comprobar si a es menor que b
resultado_3 <- a < b

# Mostrar el resultado

cat("relación menor que => (a < b) es:", resultado_3, "\n")
relación menor que => (a < b) es: TRUE 
# Comprobar si a es mayor que b
resultado_4 <- a > b

# Mostrar el resultado
cat("relación mayor que => (a > b) es:", resultado_4, "\n")
relación mayor que => (a > b) es: FALSE 
# Comprobar si a es menor o igual a b
resultado_5 <- a <= b

# Mostrar el resultado
cat("relación menor o igual a => (a <= b) es:", resultado_5, "\n")
relación menor o igual a => (a <= b) es: TRUE 
# Comprobar si a es mayor o igual a b
resultado_6 <- a >= b

# Mostrar el resultado
cat("relación mayor o igual a => (a >= b) es:", resultado_6, "\n")
relación mayor o igual a => (a >= b) es: FALSE

Operador de asignación

Para asignar el valor a una variable, utilizamos operadores de asignación. La siguiente es una lista de operadores de asignación en Python:

Nombre del Operador Símbolo del Operador Descripción Ejemplo
Asignar = Asignar el valor del operando derecho al operando izquierdo. a=b
Sumar y asignar += Suma el valor del operando derecho al izquierdo y asigna el resultado al operando izquierdo a+=10 (a=a+10)
Restar y asignar -= Reste el valor del operando derecho al izquierdo y asigne el resultado al operando izquierdo a-=10 (a=a-10)
Multiplicar y asignar *= Multiplica el valor del operando derecho por el izquierdo y asigna el resultado al operando izquierdo. a=10 (a=a*5)
Dividir y asignar /= Divida el valor del operando derecho a la izquierda y asigne el resultado al operando izquierdo. a/=2 (a=a/2)
División y asignación del piso //= Piso divide el valor del operando derecho a la izquierda y asigna el resultado al operando izquierdo. a//=9 (a=a//9)
Módulo y asignación %= Realice el módulo por el valor del operando derecho a la izquierda y asigne el resultado al operando izquierdo. a%=3 (a=a%3)
Exponente y Asignación ** Realizar el exponente de operandos y asignar el resultado al operando izquierdo. a***=2(a=a**2) 
# Asignar (=)
a <- 20
print(paste("Asignar(a=20) =>", a))
[1] "Asignar(a=20) => 20"
b <- 25
print(paste("Asignar(b=25) =>", b))
[1] "Asignar(b=25) => 25"
# Suma y asignación (+=) --
a <- a + 10
print(paste("Suma y asignación (a+=10) =>", a))
[1] "Suma y asignación (a+=10) => 30"
# Restar y asignar (-=)
a <- a - 10
print(paste("Restar y asignar (a-=10) =>", a))
[1] "Restar y asignar (a-=10) => 20"
# Multiplicar y asignar (*=)
a <- a * 10
print(paste("Multiplicar y asignar (a*=10) =>", a))
[1] "Multiplicar y asignar (a*=10) => 200"
# Dividir y asignar (/=)
a <- a / 10
print(paste("Dividir y asignar (a/=10) =>", a))
[1] "Dividir y asignar (a/=10) => 20"
# Piso-Dividir y Asignar (//=)
b <- b / 3
print(paste("Dividir y asignar (b/3) =>", b))
[1] "Dividir y asignar (b/3) => 8.33333333333333"
# Módulo y Asignación (%=)
b <- b %% 3
print(paste("Módulo y asignación (b%=3) =>", b))
[1] "Módulo y asignación (b%=3) => 2.33333333333333"
# exponente y Asignar (**=)
b <- b ^ 3
print(paste("Exponente y asignación (b^3) =>", b))
[1] "Exponente y asignación (b^3) => 12.7037037037037"

Operadores Logicos

Estos operadores se utilizan para combinar expresiones condicionales en Python.

La siguiente tabla tiene la información completa sobre los operadores lógicos en Python.

Nombre del operador Símbolo del operador Descripción
AND (y) lógico & Da como resultado ‘True’ si ambos operandos son ‘Verdadero’ y ‘False’ en caso contrario.
OR (O) lógico | Da “True” como resultado si alguno de los operandos es “Verdadero” y “False” en caso contrario.
NOT (No) lógico ! Da como resultado ‘True’ si un operando es ‘Falso’ y ‘True’ si un operando es ‘Verdadero’. 
# Ejemplo
a= FALSE
b= TRUE
# Operador lógico AND (y)
print(paste("AND lógico => a y b es:", a & b))
[1] "AND lógico => a y b es: FALSE"
# Operador lógico OR (o)
print(paste("OR lógico => a o b es:", a | b))
[1] "OR lógico => a o b es: TRUE"
# Operador lógico NOT (no)
print(paste("NO lógico => no b es:", !b))
[1] "NO lógico => no b es: FALSE"

Tipos de datos integrados en R

1. Numeric (Numérico): Este tipo de dato se utiliza para representar números reales o enteros. Puede ser utilizado para cálculos matemáticos y estadísticos.

2. Caracter (Carácter): Este tipo de dato almacena texto o cadenas de caracteres. Se utiliza para representar palabras, frases y texto en general.

3. Logical (Lógico): Los valores lógicos son `TRUE` (verdadero) o `FALSE` (falso) y se utilizan para representar condiciones lógicas.

4. Integer (Entero): Al igual que el tipo numérico, pero se utiliza específicamente para números enteros.

5. Complex (Complejo): Este tipo de dato se utiliza para representar números complejos que constan de una parte real y una imaginaria.

6. Raw (Crudo): Este tipo de dato se utiliza para almacenar bytes o datos binarios sin procesar.

7. Factor (Factor): Se utiliza para representar variables categóricas o factores en estadísticas y análisis de datos.

8. Date (Fecha) y Time (Tiempo): Estos tipos de datos se utilizan para representar fechas y horas respectivamente.

9. Lists (Listas): Las listas son estructuras de datos flexibles que pueden contener elementos de diferentes tipos de datos.

10. Data Frames (Marcos de Datos): Los marcos de datos son estructuras tabulares que se utilizan para organizar datos en filas y columnas, similar a una hoja de cálculo.

Estos tipos de datos integrados en R son esenciales para realizar análisis de datos y tareas de programación en este lenguaje estadístico y de programación.

# Ejemplos
# Ejemplo de tipo de datos int
a = 20 # valor entero positivo
a1 = -20 # Valor entero negativo
# imprimiendo el valor
print(paste("a =", a))
[1] "a = 20"
print(paste("a1 =", a1))
[1] "a1 = -20"
# comprobar el tipo de variable a
print(paste("El tipo de variable a es:", class(a)))
[1] "El tipo de variable a es: numeric"
print(paste("El tipo de variable a1 es:", class(a1)))
[1] "El tipo de variable a1 es: numeric"
# Ejemplo para tipo de datos flotante
b = 20.5 # valor flotante positivo
b1 = -20.5 # Valor flotante negativo

# imprimiendo el valor
print(paste("b = ",b))
[1] "b =  20.5"
print(paste("b1 = ",b1))
[1] "b1 =  -20.5"
# comprobar el tipo de variable a
print(paste("El tipo de variable b es:", class(b)))
[1] "El tipo de variable b es: numeric"
print(paste("El tipo de variable b1 es:", class(b1)))
[1] "El tipo de variable b1 es: numeric"
# ejemplo datos complejos
a <- 20 + 5i
b <- 5i
c <- 10 - 5i
d <- -5i

# imprimiendo el valor de un
print (paste("a = ", a))
[1] "a =  20+5i"
# comprobar el tipo de variable a
print(paste("El tipo de variable a es:", class(a)))
[1] "El tipo de variable a es: complex"
print(paste("El tipo de variable b es:", class(b)))
[1] "El tipo de variable b es: complex"
print(paste("El tipo de variable c es:", class(c)))
[1] "El tipo de variable c es: complex"
print(paste("El tipo de variable d es:", class(d)))
[1] "El tipo de variable d es: complex"

Conversión de tipos o conversión de tipos

En R, es posible llevar a cabo conversiones de tipos similares a Python, como convertir de tipo numérico a tipo entero, de tipo numérico a tipo de punto flotante (decimal), y viceversa. Además, se puede verificar el tipo de una variable utilizando la función class(). Asimismo, se pueden realizar conversiones entre tipos numéricos y de carácter utilizando las funciones as.integer(), as.double(), as.character(), y viceversa. Aquí tienes una paráfrasis de las conversiones de tipos en R:

- Para convertir un valor numérico a entero en R, puedes utilizar la función “as.integer()”. Por ejemplo, `as.integer(5.6)` convertirá 5.6 a 5.

- Para convertir un valor numérico a punto flotante en R, puedes utilizar la función `as.double()`. Por ejemplo, `as.double(5)` convertirá 5 a 5.0.

- Para verificar el tipo de una variable en R, puedes utilizar la función `class()`. Por ejemplo, `class(x)` te dirá el tipo de la variable `x`.

- Para convertir un valor numérico a una cadena de caracteres en R, puedes utilizar la función `as.character()`. Por ejemplo, `as.character(5.6)` convertirá 5.6 en “5.6”.

- Para convertir una cadena de caracteres numérica a un valor numérico en R, puedes utilizar las funciones `as.integer()` o `as.double()`, dependiendo de si deseas un entero o un número de punto flotante. Por ejemplo, `as.double(“5.6”)` convertirá “5.6” en 5.6.

Estas funciones y técnicas permiten realizar conversiones de tipos de manera eficiente en R, lo que es útil en diversos contextos de programación y análisis de datos.

Cadenas

Las cadenas son una secuencia de caracteres encerrados entre comillas simples, dobles o triples o comillas dobles triples.

Se utilizan comillas simples y dobles para escribir una cadena de una sola línea, pero se utilizan comillas triples para escribir una cadena de varias líneas.

# Ejemplos de codificación
cadena1 = 'Esta es una cadena entre comillas simples'
cadena2 = "Esta es una cadena entre comillas dobles"

cadena3 = '
Línea uno
Línea dos
Línea tres' # cadena multilínea

# Mostrar resultados
print(cadena1)
[1] "Esta es una cadena entre comillas simples"
print(cadena2)
[1] "Esta es una cadena entre comillas dobles"
cat(cadena3)  # Utilizamos cat para imprimir cadenas de varias líneas

Línea uno
Línea dos
Línea tres

Accediendo a componentes de cadena

Acceder a componentes de cadena en R se refiere al proceso de extraer partes específicas o caracteres individuales de una cadena de caracteres (también conocida como texto) en un programa de R. Esto se logra utilizando índices o funciones que permiten acceder y manipular partes específicas de la cadena, como caracteres individuales, subcadenas o segmentos específicos.

Acceder a componentes de cadena es una tarea común en la programación y el análisis de datos, y se utiliza para tareas como búsqueda, extracción, manipulación y análisis de información textual contenida en cadenas de caracteres.

# cadenas
lenguaje <- "R"

# Imprimir resultados
print(paste("lenguaje[1] =>", substr(lenguaje, 1, 1)))
[1] "lenguaje[1] => R"
print(paste("lenguaje[n] =>", substr(lenguaje, nchar(lenguaje), nchar(lenguaje))))
[1] "lenguaje[n] => R"
# Letra H
lenguaje[3]
[1] NA
lenguaje[-3]
[1] "R"

Concatenación de cadenas

La concatenación de cadenas en R se refiere al proceso de combinar dos o más cadenas de caracteres (textos) en una sola cadena más larga. Esto se logra utilizando operadores o funciones que permiten unir o fusionar las cadenas, creando una nueva cadena que contiene la información de las cadenas originales en el orden especificado.

La concatenación de cadenas es una operación común en programación y análisis de datos cuando se necesita combinar texto de diferentes fuentes o agregar información adicional a una cadena existente. Puede realizarse utilizando el operador `paste()` o simplemente utilizando el operador de concatenación `paste()` o `paste0()`.

cadena1 <- "Hola" 
cadena2 <- "RStudio" 
cadena3 <- paste(cadena1, cadena2, sep = ' ') 

# Concatenando dos cadenas en R  
cat("La cadena concatenada es:", cadena3)
La cadena concatenada es: Hola RStudio

Operaciones de cadena y metodos integradospecificada en una cadena.

Por supuesto, aquí tienes una lista de algunas operaciones de cadena y métodos integrados en R:

1. Concatenación: `paste()`, `paste0()`

2. Longitud de cadena: `nchar()`

3. Subcadenas: `[ ]`

4. Búsqueda de subcadenas: `grep()`, `grepl()`

5. Reemplazo de texto: `gsub()`

6. División de cadenas: `strsplit()`

7. Mayúsculas y minúsculas: `toupper()`, `tolower()`

Estas funciones y métodos son fundamentales para trabajar eficazmente con cadenas de caracteres en R y realizar diversas tareas de manipulación y análisis de datos de texto.

#Ejemplos 
# Convertir todas las letras minúsculas a mayúsculas 

curso <- "Programación en Lenguaje Estadístico"
# Mayúsculas 
toupper(curso)
[1] "PROGRAMACIÓN EN LENGUAJE ESTADÍSTICO"
# Minúsculas 
tolower(curso)
[1] "programación en lenguaje estadístico"
# Primera minúscula 

paste(toupper(substring(curso, 1, 1)), tolower(substring(curso, 2)), sep = '')
[1] "Programación en lenguaje estadístico"
# Divide 
unlist(strsplit(curso, " "))
[1] "Programación" "en"           "Lenguaje"     "Estadístico" 
# Elimina los caracteres iniciales y finales de una cadena 
gsub("^\\s+|\\s+$", "", curso)
[1] "Programación en Lenguaje Estadístico"
# Longitud 
nchar(curso)
[1] 36

Lista

Una lista es una colección ordenada de elementos. Las listas son mutables, lo que significa que podemos actualizar el elemento de la lista a nivel de índice.

Sin embargo, una lista también es un tipo de secuencia, por lo que admite la indexación. Para crear la lista, necesitamos poner elementos dentro de los corchetes ([ ]) separándolos con una coma.

Por ejemplo, a = [ ] representa una lista vacía y mi_lista = [1,2,3,4,5]. Aquí mi_lista hay una lista de números del 1 al 5.

# Ejemplo 
mi_lista <- c(1, 2, 3, 4, 5) 
frutas <- c("manzana", "naranja", "mango")
print(paste(mi_lista)) 
[1] "1" "2" "3" "4" "5"
print(paste(frutas))
[1] "manzana" "naranja" "mango"

Acceder a los elementos de la lista

Si deseas acceder a elementos en una lista en R, puedes utilizar corchetes [ ] o la función [[ ]], dependiendo de si deseas acceder a elementos por su índice o por su nombre (clave) en la lista. Aquí tienes ejemplos de cómo acceder a los elementos de una lista en R:

mi_lista2 <- c(1, 2, 3, 4, "Cinco", 6)
# primer elemento de la lista @ índice => [0] 
print(paste("1er elemento de la lista =", mi_lista2[1]))
[1] "1er elemento de la lista = 1"
print(paste("2do elemento de la lista =", mi_lista2[2]))
[1] "2do elemento de la lista = 2"
# último elemento de la lista @ index => [-1] índice negativo  

mi_lista2[length(mi_lista2)]
[1] "6"

Agregar elemento(s) en la lista

Para agregar valor o elemento a la lista de Python, tenemos las funciones append(value) y insert(index, value); append() agregará el valor al final de la lista de Python, pero insert() agregará valor en el índice especificado de la lista.

mi_lista2 <- c(1, 2, 3, 4, "Cinco", 6) 
cat("Lista inicial:", mi_lista2, "\n")
Lista inicial: 1 2 3 4 Cinco 6 
# Agrega 
mi_lista2 <- c(mi_lista2, "NuevoElemento")
cat("Lista inicial:", mi_lista2, "\n")
Lista inicial: 1 2 3 4 Cinco 6 NuevoElemento 
# Insert 
mi_lista2 <- c(1, 2, 3, 4, "Cinco", 6) 
mi_lista2 <- append(mi_lista2, "NuevoElemento")
mi_lista2 <- c(mi_lista2[1:3], 5, mi_lista2[4:length(mi_lista2) - 1]) 

cat("Lista actualizada agregando un nuevo elemento:", mi_lista2, "\n")
Lista actualizada agregando un nuevo elemento: 1 2 3 5 3 4 Cinco 6

Concatenación y repetición

En R, puedes realizar concatenación y repetición de cadenas de caracteres de la siguiente manera:

#Ejemplo 
lista3 <- c(2, 4, 6, 8, 10) 
lista4 <- c(1, 3, 5, 7) 
numeros <- c(lista3, lista4)  
print(numeros)
[1]  2  4  6  8 10  1  3  5  7
# extend(secuencia)  
lista4 <- c(1, 3, 5, 7) 
lista3 <- c(2, 4, 6, 8, 10) 
lista4 <- c(lista4, lista3)  
print(lista4)
[1]  1  3  5  7  2  4  6  8 10

Actualizar la lista en R

Usando la indexación, podemos actualizar el valor indexado especificado en una lista.

numeros <- c(1, 2, 3, 4, 5, 6) 
numeros[2] <- 22 
print(numeros)
[1]  1 22  3  4  5  6
# Actualizar el valor de la posición 5 con 50 
numeros <- c(1, 22, 3, 4, 5, 6) 
numeros[5] <- 50 
print(numeros)
[1]  1 22  3  4 50  6

Eliminar un elemento de la lista en R

Eliminar un elemento de una lista en R se refiere al proceso de eliminar un elemento específico de una lista existente. Puedes eliminar un elemento de una lista utilizando diferentes métodos, dependiendo de tu necesidad y de cómo esté estructurada la lista. Algunas de las formas comunes de eliminar elementos de una lista en R incluyen:

numeros <- c(1, 2, 3, 4, 5, 6) 
posicion <- which(numeros == 6) 
numeros <- numeros[-posicion] 
print(numeros)
[1] 1 2 3 4 5
# pop(index) 
longitud <- length(numeros) 
valor_eliminado <- numeros[2] 
numeros <- numeros[-2] 

cat("Lista actualizada:", numeros, "\n")
Lista actualizada: 1 3 4 5

Comprobar la pertenencia de un elemento

Al utilizar el operador ‘in’, podemos verificar si algún valor está presente en la lista o no. Si el valor existe en la lista, devolverá “True”.

# Ejemplo 
frutas <- c("fresa", "papaya", "piña") 
cat("Comprobando si 'fresa' está en la lista:", "fresa" %in% frutas, "\n") 
Comprobando si 'fresa' está en la lista: TRUE 
cat("Comprobando si 'platano' está en la lista:", "platano" %in% frutas, "\n")
Comprobando si 'platano' está en la lista: FALSE

Ud. ha generé un lista con cada una de las palabras guardada anteriormente, utilizar la función in para evaluar si aparece la palabra “morado”

texto <- "El mar es chevere. Obvio que hay mares y balnearios a los que nunca entrare como los de Santa Rosa en Ancon , por la bravura de sus olas y su inestable patron al cual respeto . Lo ironico de esto es que a lado hay otro Balneario muy cerca donde el mar es tranquilo a pocos pasos de ahi. Y como ya lo conozco me meto con confianza mar adentro cientos de metros. En verano , si pasas por ahi y ves un Punto negro al fondo del mar nadando. Probablemente sea yo o mi Hermano con quien nado ahi desde que somos Niños..."
texto_sep <- unlist(strsplit(texto, " ")) 
resultado <- "Morado" %in% texto_sep 

cat("Comprobando si 'Morado' está en la lista:", resultado, "\n")
Comprobando si 'Morado' está en la lista: FALSE

Ordenar los elementos de la lista

Usando el método sort(), podemos ordenar los elementos de la lista.

numeros <- c(20, 25, 22, 64, 15, 28) 
cat("Lista inicial:", numeros, "\n") 
Lista inicial: 20 25 22 64 15 28 
numeros_ordenados <- sort(numeros) 
cat("Lista ordenada en orden ascendente:", numeros_ordenados, "\n") 
Lista ordenada en orden ascendente: 15 20 22 25 28 64 
numeros_ordenados_desc <- sort(numeros, decreasing = TRUE)
cat("Lista ordenada en orden descendente:", numeros_ordenados_desc, "\n")
Lista ordenada en orden descendente: 64 28 25 22 20 15

Longitud de una lista y recuento de un elemento en la lista

Para obtener la longitud de cualquier lista (tamaño de la lista), podemos usar la función len(). Y para obtener el recuento de cuántas apariciones del elemento o elemento especificado, podemos usar la función count().

numeros <- c(20, 25, 22, 64, 15, 28, 25, 30, 25)  
# Longitud de la lista 
longitud_lista <- length(numeros) 
cat("Longitud de la lista:", longitud_lista, "\n")  
Longitud de la lista: 9 
# Cantidad de veces que aparece el valor 25 en la lista 
cant_lista <- sum(numeros == 25) 
cat("Cantidad de veces que aparece el valor 25 en la lista:", cant_lista, "\n")
Cantidad de veces que aparece el valor 25 en la lista: 3

Corte de la lista

La división de listas es una forma práctica de obtener el subconjunto de una lista o una porción de una lista y se basa en la indexación.

Sintaxis:list[start:stop:step] start: El objeto de segmento comenzará desde este índice. stop: El objeto de segmento se detendrá en este índice, lo que significa que el valor en este índice no se incluirá en un segmento devuelto de la lista. step: El paso de división determina el incremento de un índice a otro índice. El valor predeterminado es 1.

lista_6 <- c("P", "Y", "T", "H", "O", "N")  
# Obtener un segmento desde el primer índice hasta el quinto índice

segmento <- lista_6[1:5]  
cat("Segmento de lista:", segmento, "\n")
Segmento de lista: P Y T H O 
# si no se menciona la parada, aparecerá hasta el final de la # lista 

segmento <- lista_6[1:length(lista_6)]  
cat("Segmento de lista:", segmento, "\n")
Segmento de lista: P Y T H O N 
# si no se menciona el inicio, aparecerá hasta el final de la # lista 

segmento <- lista_6[1:3]  
cat("Segmento de lista:", segmento, "\n")
Segmento de lista: P Y T 
# si no se mencionan ni el índice inicial ni el final, devuelve # la lista completa como segmento de lista 

cat("Segmento de lista:", lista_6, "\n")
Segmento de lista: P Y T H O N 
# también admite índices negativos 
segmento <- lista_6[-(length(lista_6) - 2) : -(length(lista_6) - 1)]  
cat("Segmento de lista:", segmento, "\n")
Segmento de lista: P Y T N 
# segmento de lista con paso = 2 

segmento <- lista_6[1:6:2]  
Warning in 1:6:2: numerical expression has 6 elements: only the first used
cat("Segmento de lista con paso de 2:", segmento, "\n")
Segmento de lista con paso de 2: P Y

Convertir cadenas y tuplas en la lista

Usando list(seq), podemos convertir una secuencia (cadena, tupla) en un tipo de lista.

# Ejemplo 
cadena3 <- "PYTHON" 
vector3 <- c("P", "Y", "T", "H", "O", "N")
cat("Tipo de cadena =", class(cadena3), "\n")
Tipo de cadena = character

Tuplas

Una tupla en R y RStudio es una estructura de datos que permite almacenar múltiples elementos de diferentes tipos en una sola entidad. A diferencia de otros objetos, como vectores o matrices, las tuplas son inmutables, lo que significa que una vez creadas, no se pueden modificar sus elementos. Se definen utilizando la función “c()” y se accede a sus elementos mediante índices. Las tuplas son útiles para organizar y mantener conjuntos de datos heterogéneos de manera ordenada en el entorno de programación R y su interfaz gráfica RStudio.

mi_lista <- list(1, 2, 3, 4, 'Five', 6)
primer_elemento <- mi_lista[[1]]
print(paste("1er elemento de la lista =", primer_elemento))
[1] "1er elemento de la lista = 1"
segundo_elemento <- mi_lista[[2]]
print(paste("2do elemento de la lista =", segundo_elemento))
[1] "2do elemento de la lista = 2"
ultimo_elemento <- mi_lista[length(mi_lista)]
print(paste("último elemento de la lista =", ultimo_elemento))
[1] "último elemento de la lista = 6"

Agregar Elementos en Tupla en R

En R, las tuplas no son estructuras de datos nativas y no pueden ser modificadas una vez creadas. A diferencia de otras estructuras como listas o vectores, no puedes agregar elementos a una tupla después de su creación ni modificar sus elementos existentes. Las tuplas en R se suelen representar utilizando vectores, matrices o listas, y estas estructuras sí permiten la adición y modificación de elementos. Por lo tanto, en R, para agregar elementos a una estructura de datos, debes utilizar las funciones y métodos apropiados para el tipo de estructura que estés utilizando, como `c()` para vectores, `cbind()` o `rbind()` para matrices, o simplemente agregar elementos a una lista con el operador `$` o `list()`.

# Lista inicial
lista_inicial <- list(1, 2, 3)
print(lista_inicial)
[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3
lista_inicial <- list(lista_inicial, 4)

print(lista_inicial)
[[1]]
[[1]][[1]]
[1] 1

[[1]][[2]]
[1] 2

[[1]][[3]]
[1] 3


[[2]]
[1] 4
# Crear una tupla con un solo elemento
lista_con_un_elemento <- list('a')

# Imprimir la lista
print(lista_con_un_elemento)
[[1]]
[1] "a"
class(lista_con_un_elemento)
[1] "list"

Concatenación y Repetición

t_1 <- c(1,2,3)
t_2 <- c("uno", "dos","tres")
t_1
[1] 1 2 3
t_2
[1] "uno"  "dos"  "tres"
t_3 <- c(t_1, t_2)
t_3
[1] "1"    "2"    "3"    "uno"  "dos"  "tres"
# Repetir la lista tres veces
t1_repetida <- rep(t_1, times = 3)
t1_repetida
[1] 1 2 3 1 2 3 1 2 3
# Crear un vector de caracteres
t4 <- c('a', 'b', 'c', 'd', 'e')

# Imprimir el vector
print(t4)
[1] "a" "b" "c" "d" "e"
print(t4[4])
[1] "d"

Diccionarios

En R, los diccionarios no son una estructura de datos nativa, como lo son en algunos otros lenguajes de programación como Python. Sin embargo, puedes emular diccionarios utilizando listas o matrices asociativas. En este contexto:

Un “diccionario” en R se puede definir como una estructura de datos que asocia claves (o nombres) con valores. Por lo general, se implementa como una lista donde los nombres de los elementos de la lista actúan como las claves y los valores asociados a esos nombres son los valores del diccionario. Puedes acceder a los valores del diccionario utilizando las claves correspondientes.

# Crear un diccionario en R
mi_diccionario <- list("1" = "60%", "2" = "50%", "3" = "30%")

# Imprimir el diccionario
print(mi_diccionario)
$`1`
[1] "60%"

$`2`
[1] "50%"

$`3`
[1] "30%"

Trabajando con Diccionarios en R

# Acceder al valor de la clave 2
valor_clave_2 <- mi_diccionario[["2"]]

# Imprimir el valor
print(paste("El valor de la clave 2 es", valor_clave_2))
[1] "El valor de la clave 2 es 50%"
# Crear un "diccionario" en R (lista con nombres)
semaforo <- list("Rojo" = "Parar", "Ambar" = "Precaución", "Verde" = "Adelante")

# Mostrar el valor asociado a la clave "Ambar"
valor_ambar <- semaforo[["Ambar"]]

# Imprimir el valor
print(paste("El valor asociado a la clave 'Ambar' es", valor_ambar))
[1] "El valor asociado a la clave 'Ambar' es Precaución"

Agregar Elementos al Diccionario

En R, para agregar elementos a un “diccionario” emulado utilizando una lista con nombres, puedes asignar un valor a una nueva clave utilizando el operador de asignación (`<-`) o la función `names()`. Agregar elementos a un diccionario en R significa asignar una nueva clave y valor al conjunto existente de pares clave-valor en la lista con nombres, lo que te permite expandir o actualizar el contenido del “diccionario”.

# Crear un "diccionario" en R (lista con nombres)
mi_diccionario <- list("1" = "60%", "2" = "50%", "3" = "30%")

# Imprimir el "diccionario" original
print(mi_diccionario)
$`1`
[1] "60%"

$`2`
[1] "50%"

$`3`
[1] "30%"
# Agregar un nuevo elemento (clave: "4", valor: "25%")
mi_diccionario$`4` <- "25%"

# Imprimir el "diccionario" después de agregar un elemento
print(mi_diccionario)
$`1`
[1] "60%"

$`2`
[1] "50%"

$`3`
[1] "30%"

$`4`
[1] "25%"

Eliminar Elementos del Diccionario

En R, eliminar elementos de un “diccionario” emulado con una lista con nombres implica la eliminación de una clave y su valor asociado de la lista. Esto se puede hacer utilizando la función `NULL` para asignar un valor nulo a la clave que deseas eliminar o mediante la función `rm()` para eliminar completamente la clave del entorno de trabajo. Eliminar elementos de un “diccionario” es útil para reducir su tamaño o para eliminar información que ya no es relevante.

# Eliminar el tercer elemento (clave "3")
mi_diccionario$`3` <- NULL

# Imprimir el "diccionario" después de eliminar el elemento
print(mi_diccionario)
$`1`
[1] "60%"

$`2`
[1] "50%"

$`4`
[1] "25%"

Comprobar la pertenencia de un Elemento

Comprobar la pertenencia de un elemento significa verificar si dicho elemento forma parte de una colección o estructura de datos en un lenguaje de programación, como una lista, un diccionario o un conjunto. En este contexto, estamos verificando si la clave 2 forma parte del “diccionario” mi_diccionario, es decir, si está presente como una de las claves en la estructura de datos.

# Verificar si la clave 2 está en el "diccionario"
clave_existe <- "2" %in% names(mi_diccionario)

# Imprimir el resultado
print(paste("La clave 2 está en mi_diccionario:", clave_existe))
[1] "La clave 2 está en mi_diccionario: TRUE"
print(paste("La clave 8 está en mi_diccionario:", "8" %in% names(mi_diccionario)))
[1] "La clave 8 está en mi_diccionario: FALSE"

Obtener la lista de todas las variables de un diccionario

Obtener la lista de todas las variables de un “diccionario” en R se refiere al proceso de recuperar todas las claves (o nombres) presentes en la estructura de datos, lo que permite acceder a todos los valores asociados a esas claves o realizar operaciones en masa en el conjunto de claves y valores.

# Obtener una lista de todos los valores
unlist(mi_diccionario)
    1     2     4 
"60%" "50%" "25%" 
# Obtener una lista de tuplas clave-valor
mapply(function(k, v) list(Clave = k, Valor = v), 
                             names(mi_diccionario), 
                             unlist(mi_diccionario), 
                             SIMPLIFY = FALSE)
$`1`
$`1`$Clave
[1] "1"

$`1`$Valor
[1] "60%"


$`2`
$`2`$Clave
[1] "2"

$`2`$Valor
[1] "50%"


$`4`
$`4`$Clave
[1] "4"

$`4`$Valor
[1] "25%"

Iterar un Diccionario

Se refiere al proceso de recorrer y acceder a cada uno de los elementos, ya sea claves o valores, en un diccionario (o estructura similar) en un lenguaje de programación. Durante la iteración, se ejecuta un bloque de código repetidamente para cada elemento del diccionario, lo que permite realizar operaciones específicas en cada par clave-valor o en cada elemento del diccionario. La iteración es una técnica comúnmente utilizada para procesar y manipular datos contenidos en diccionarios y es esencial en la programación para tareas como búsqueda, filtrado, transformación o cálculos basados en los datos del diccionario.

# Iterar a través del "diccionario" e imprimir los pares clave-valor
for (k in names(mi_diccionario)) {
  v <- mi_diccionario[[k]]
  cat("Valor para la clave", k, "es", v, "\n")}
Valor para la clave 1 es 60% 
Valor para la clave 2 es 50% 
Valor para la clave 4 es 25%

Conversión de clave, valor iterable en diccionario

La “conversión de clave-valor iterable en diccionario” en R se refiere al proceso de tomar dos vectores o listas, uno que contiene las claves y otro que contiene los valores, y combinarlos para crear un diccionario (o estructura de datos similar) en el que las claves están asociadas a los valores correspondientes. Este proceso permite transformar dos secuencias de datos en un formato más organizado y accesible, lo que facilita el acceso y la manipulación de datos relacionados.

En R, puedes realizar esta conversión utilizando funciones como `setNames()`, `as.list()`, o simplemente creando un “diccionario” (lista con nombres) manualmente mediante asignaciones de clave-valor.

# Crear una lista de tuplas
mi_tupla <- list(
  list(Clave = 1, Valor = "60%"),
  list(Clave = 2, Valor = "50%"),
  list(Clave = 3, Valor = "30%")
)

# Convertir la lista de tuplas en un "diccionario" (lista con nombres)
diccionario2 <- setNames(lapply(mi_tupla, function(x) x$Valor), lapply(mi_tupla, function(x) x$Clave))

# Imprimir el "diccionario"
print(diccionario2)
$`1`
[1] "60%"

$`2`
[1] "50%"

$`3`
[1] "30%"

Caso: Problema de transporte de FOSTERS GENERATORS

En el caso aplicativo de FOSTERS GENERATORS, se trata de un problema de transporte en el que se tienen tres plantas de producción ubicadas en Cleveland, Bedford y York, y cada planta tiene una cantidad específica de generadores para transportar. El objetivo podría ser distribuir eficientemente estos generadores a varios destinos o puntos de entrega utilizando rutas óptimas y minimizando los costos asociados al transporte. Este tipo de problemas es común en logística y gestión de la cadena de suministro, y se pueden utilizar técnicas de programación lineal o métodos de optimización para encontrar la solución más eficiente.

# Declarar el origen y la cantidad de productos en cada planta
planta <- list(
  'Cleveland' = 5000,
  'Bedford' = 6000,
  'York' = 2500)
# Declarar los destinos y la cantidad de productos a distribuir
distribucion <- list(
  'Boston' = 6000,
  'Chicago' = 4000,
  'SanLuis' = 2000,
  'Lexington' = 1500)
# Declarar los costos de transporte desde cada planta de origen a cada destino
costos <- matrix(c(
  3, 7, 2,
  2, 5, 5,
  7, 2, 4,
  6, 3, 5
), nrow = 4, byrow = TRUE)

# Asignar nombres de fila y columna
rownames(costos) <- c('Boston', 'Chicago', 'SanLuis', 'Lexington')
colnames(costos) <- c('Cleveland', 'Bedford', 'York')

Mostramos los diccionarios

print(planta)
$Cleveland
[1] 5000

$Bedford
[1] 6000

$York
[1] 2500
print(distribucion)
$Boston
[1] 6000

$Chicago
[1] 4000

$SanLuis
[1] 2000

$Lexington
[1] 1500
print(costos)
          Cleveland Bedford York
Boston            3       7    2
Chicago           2       5    5
SanLuis           7       2    4
Lexington         6       3    5