R

R es un lenguaje de programación de código abierto ampliamente utilizado en estadísticas y análisis de datos. Desarrollado en la década de 1990, R es apreciado por su capacidad en análisis de datos, gráficos estadísticos y visualización. Es utilizado por profesionales en todo el mundo para tareas de análisis exploratorio, modelado estadístico y generación de informes

Palabras reservadas

A diferencia de los lenguajes humanos, el vocabulario de R es relativamente limitado. A estas palabras clave las llamamos ‘palabras reservadas’. Estas palabras tienen un significado especial dentro de R. Cuando R encuentra estas palabras en un programa, cada una tiene una interpretación específica y única en el contexto del lenguaje.

Algunas de las palabras reservadas en el lenguaje de programación R incluyen las siguientes:

if         else        repeat 
while      for         in       
next       break       function   
return     NULL        NA         
Inf        -Inf        NaN

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:

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

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

x<-10

Reglas para definir un nombre de variable

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

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

  3. Es importante recordar que en R 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.

✋ Precaución: Las funciones integradas de R (built-in) no son palabras reservadas y es fácil anularlos accidentalmente. Por ejemplo, si usa el nombre list o abs para una variable, ya no podrá usar esos nombres para crear listas o encontrar valores absolutos.

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 Símbolo del operador Descripción Ejemplo
suma + Suma los dos operandos a + b
resta - Resta los operandos derechos del operando izquierdo a - b
multiplicación * Multiplica los dos operandos a*b
división o división flotante / El operando izquierdo se divide por el operando derecho y da como resultado el valor flotante a/b
división de piso // El operando izquierdo se divide por el operando derecho y da como resultado el valor mínimo de división a//b
exponente ** Elevó el operando izquierdo a la potencia del derecho a**b (3**2, significa 3 elevado a la 2)
módulos % Da el resto de la división del operando izquierdo por el operando derecho a%b

Ejemplos:

SUMA

s<-3+3
s
## [1] 6

RESTA

r<-3-3
r
## [1] 0

MULTIPLICACIÓN

m<-3*3
m
## [1] 9

DIVISIÓN

d<-3/3
d
## [1] 1

EXPONENENTE

e<-3**3
e
## [1] 27

MÓDULOS

mo<-3%%3
mo
## [1] 0

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”:

Nombre del operador Símbolo del operador Descripción Ejemplo
igual a == comparar si el valor del operando izquierdo es igual al valor del operando derecho a == b
no igual o diferente ! = comparar si el valor del operando izquierdo no es igual al valor del operando derecho a! = b
menor que < comparar si el valor del operando izquierdo es menor que el valor del operando derecho a < b
mayor que > comparar si el valor del operando izquierdo es mayor que el valor del operando derecho a > b
menor que o igual a <= comparar el valor del operando izquierdo es menor o igual que el valor del operando derecho a <= b
mayor que o igual a >= comparar el valor del operando izquierdo es mayor o igual que el valor del operando derecho a >= b

Ejemplo:

# Declaramos dos variables
a = 20
b = 28
# igual a relación (==)
a == b
## [1] FALSE
print(paste("igual a la relación => (a==b) es:", a==b))
## [1] "igual a la relación => (a==b) es: FALSE"
# no es igual a la relación (!=)
a!=b
## [1] TRUE
print(paste("no es igual a la relación => (a!=b) es:", a!=b))
## [1] "no es igual a la relación => (a!=b) es: TRUE"
# relación menor que (<)
a < b
## [1] TRUE
print(paste("relación menor que => (a < b) es:", a < b))
## [1] "relación menor que => (a < b) es: TRUE"
# relación mayor que (>)
a > b
## [1] FALSE
print(paste("relación mayor que => (a > b) es:", a > b))
## [1] "relación mayor que => (a > b) es: FALSE"
# menor o igual a relación (<=)
a <= b
## [1] TRUE
print(paste("relación menor que => (a <= b) es:", a <= b))
## [1] "relación menor que => (a <= b) es: TRUE"
#mayor o igual a relación (>=)
a >= b
## [1] FALSE
print(paste("relacion mayor que => (a >= b) es", a >= b))
## [1] "relacion mayor que => (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 R:

Asi

Nombre del operador Simbolo del operador Descripción Ejemplo
Asignar = o <- “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)
Resta 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*10)
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 (= o <-)
a = 20
cat("Asignar (a = 20) => ", a, "\n")
## Asignar (a = 20) =>  20
b <- 25
cat("Asignar (b <- 25) => ", b, "\n")
## Asignar (b <- 25) =>  25
# Sumar y asignar (+=)
a <- a + 10
cat("Sumar y asignar (a <- a + 10) => ", a, "\n")
## Sumar y asignar (a <- a + 10) =>  30
# Restar y asignar (-=)
a <- a - 10
cat("Restar y asignar (a <- a - 10) => ", a, "\n")
## Restar y asignar (a <- a - 10) =>  20
# Multiplicar y asignar (*=)
a <- a * 10
cat("Multiplicar y asignar (a <- a * 10) => ", a, "\n")
## Multiplicar y asignar (a <- a * 10) =>  200
# Dividir y asignar (/=)
a <- a / 10
cat("Dividir y asignar (a <- a / 10) => ", a, "\n")
## Dividir y asignar (a <- a / 10) =>  20
# Piso-Dividir y asignar (%/%=)
b <- b %/% 3
cat("Piso-Dividir y asignar (b <- b %/% 3) => ", b, "\n")
## Piso-Dividir y asignar (b <- b %/% 3) =>  8
# Módulo y asignar (%%=)
b <- b %% 3
cat("Módulo y asignar (b <- b %% 3) => ", b, "\n")
## Módulo y asignar (b <- b %% 3) =>  2
# Exponenciación y asignar (^=)
b <- b^3
cat("Exponenciación y asignar (b <- b^3) => ", b, "\n")
## Exponenciación y asignar (b <- b^3) =>  8

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 and Da como resultado “True” si ambos operandos son ‘Verdadero’ y ‘False’ en caso contrario.
OR (O) lógico or Da “True” como resultado si alguno de los operandos es “Verdadero” y “False” en caso contrario.
NOT (No) lógico not 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)
cat("AND lógico => a y b es:", a & b, "\n")
## AND lógico => a y b es: FALSE
# Operador lógico OR (o)
cat("OR lógico => a o b es:", a | b, "\n")
## OR lógico => a o b es: TRUE
# Operador lógico NOT (no)
cat("NO lógico => no b es:", !b, "\n")
## NO lógico => no b es: FALSE

Tipos de datos integrados en R

Tipo numérico:

Al trabajar con números, necesitamos tipos de datos numéricos. En Python, los números son inmutables. En Python 3.x, tenemos tres tipos de datos numéricos. En R, existen tipos de datos numéricos que se utilizan para representar números:

Numeric (numérico): Este tipo de dato se utiliza para representar números con punto decimal, es decir, valores reales. Los números numéricos pueden incluir valores enteros y de punto flotante.

Integer (entero): R también tiene un tipo de datos específico llamado “Integer” que se utiliza para representar números enteros. A diferencia del tipo “Numeric”, los enteros se almacenan de forma precisa como números enteros.

Complex (complejo): Los números complejos se pueden expresar en la forma a + bi, donde “a” es la parte real y “b” es la parte imaginaria. R permite trabajar con números complejos para cálculos matemáticos avanzados si es necesario.

# Ejemplos
# Ejemplo de tipo de datos Numeric (numérico)
numero_numeric <- 5.25 # Valor numérico

# Imprimiendo el valor
cat("Número numérico:", numero_numeric, "\n")
## Número numérico: 5.25
# Comprobar el tipo de variable
cat("El tipo de variable numero_numeric es:", class(numero_numeric), "\n")
## El tipo de variable numero_numeric es: numeric
# Ejemplo de tipo de datos Integer (entero)
numero_entero <- as.integer(10) # Valor entero

# Imprimiendo el valor
cat("Número entero:", numero_entero, "\n")
## Número entero: 10
# Comprobar el tipo de variable
cat("El tipo de variable numero_entero es:", class(numero_entero), "\n")
## El tipo de variable numero_entero es: integer
# Ejemplo de tipo de datos Complex (complejo)
numero_complejo <- complex(real = 3, imaginary = 2) # Número complejo

# Imprimiendo el valor
cat("Número complejo:", numero_complejo, "\n")
## Número complejo: 3+2i
# Comprobar el tipo de variable
cat("El tipo de variable numero_complejo es:", class(numero_complejo), "\n") 
## El tipo de variable numero_complejo es: complex

Conversión de tipos en R

En R, puedes realizar la conversión de tipos de datos de la siguiente maneora:

  1. De integer a numeric o viceversa:

    • De integer a numeric: Utiliza la función as.numeric() para convertir un valor entero a decimal.

    • De numeric a integer: Utiliza la función as.integer() para convertir un valor decimal a entero.

  2. Verificación del tipo de variable: Puedes verificar el tipo de cualquier variable en R utilizando la función class().

  3. Conversión de numeric o integer a character o viceversa:

    • De numeric o integer a character: Utiliza la función as.character() para convertir un valor numérico a cadena de caracteres.

    • De cualquier cadena numérica a numeric o integer: Utiliza las funciones as.numeric() y as.integer() para convertir una cadena numérica en un valor numérico o entero, respectivamente.

Cadenas

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

 Se utilizan comillas simples (’’) o dobles (““) para escribir una cadena de una sola línea. 

# Cadenas de texto con comillas simples
cadena1 <- 'Esta es una cadena entre comillas simples'

# Cadenas de texto con comillas dobles
cadena2 <- "Esta es una cadena entre comillas dobles"

# Cadenas de texto multilínea
cadena3 <- "Línea uno\nLínea dos\nLínea tres"

# Mostrar resultados
cat(cadena1, "\n")
## Esta es una cadena entre comillas simples
cat(cadena2, "\n")
## Esta es una cadena entre comillas dobles
cat(cadena3)
## Línea uno
## Línea dos
## Línea tres

Accediendo a componentes de cadena

Una cadena en Python es un tipo de secuencia, por lo que admite la indexación.

La indexación en R comienza desde 1, lo que significa que el primer carácter de una cadena tiene el índice 1, el segundo carácter tiene el índice 2 y así sucesivamente.

R también admite índices negativos, donde -1 se refiere al último carácter de la cadena, -2 al penúltimo y así sucesivamente, permitiéndote acceder a los caracteres desde el final hacia el principio de la cadena.

# Declarar una cadena en R
lenguaje <- "Python"

# Imprimir resultados
cat("lenguaje[1] => ", substr(lenguaje, 1, 1), "\n")
## lenguaje[1] =>  P
cat("lenguaje[nchar(lenguaje)] => ", substr(lenguaje, nchar(lenguaje), nchar(lenguaje)), "\n")
## lenguaje[nchar(lenguaje)] =>  n
# Declarar una cadena en R
lenguaje <- "Python"

# Obtener el tercer carácter
tercer_caracter <- substr(lenguaje, 4, 4)

# Imprimir el tercer carácter
cat("lenguaje[4] => ", tercer_caracter, "\n")
## lenguaje[4] =>  h
# Declarar una cadena en R
lenguaje <- "Python"

# Obtener todos los caracteres excepto el tercer carácter
cadena_sin_tercer_caracter <- substr(lenguaje, -3, 4)

# Imprimir la cadena resultante
cat("lenguaje[-3] => ", cadena_sin_tercer_caracter, "\n")
## lenguaje[-3] =>  Pyth

Concatenación de cadenas

En R, puedes concatenar cadenas utilizando el operador +. Simplemente al usar cadena1 + cadena2, obtendrás una nueva cadena que es la concatenación de cadena1 y cadena2.

# Concatenando dos cadenas
cadena1 <- "Hola"
cadena2 <- "R"

# Concatenar las dos cadenas con un espacio en medio
cadena3 <- paste(cadena1, cadena2, sep = " ")

# Alternativamente, puedes usar paste0() sin separador:
# cadena3 <- paste0(cadena1, " ", cadena2)

# Mostrar la cadena concatenada
cat("La cadena concatenada es:", cadena3, "\n")
## La cadena concatenada es: Hola R

Operaciones de cadena y métodos integrados

En Python para realizar diversas operaciones con cadenas. La sintaxis básica es str.String_method(). Algunos de los métodos de cadena más importantes se detallan a continuación:

a. toupper(): Devuelve una cadena con letras en mayúsculas.

b. tolower(): Devuelve una cadena con letras en minúsculas.

c. strsplit(): Divide una cadena según un separador y devuelve una lista. El separador predeterminado es el espacio en blanco.

d. trimws(): Elimina los caracteres iniciales y finales de una cadena. En el caso predeterminado, eliminará los espacios en blanco iniciales y finales de una cadena.

e. nchar(): Devuelve la longitud de una cadena en R.

f. gsub(): Reemplaza la subcadena en una cadena.

g. gregexpr(): Busca la primera aparición de una subcadena especificada en una cadena y devuelve su posición.

h. startsWith(): Comprueba y devuelve 'TRUE' si una cadena comienza con una subcadena especificada.

i. endsWith(): Comprueba y devuelve 'TRUE' si una cadena termina con una subcadena especificada.

ii. grepl("[0-9]", cadena): Comprueba y devuelve "TRUE" si hay dígitos en la cadena.

j. grepl("^\\d+$", cadena): Comprueba y devuelve "TRUE" si todos los caracteres de la cadena son decimales.

k. grepl("[A-Za-z]", cadena): Comprueba y devuelve "TRUE" si hay caracteres alfabéticos en la cadena.

l. grepl("[a-z]", cadena): Comprueba y devuelve 'TRUE' si la cadena está en minúsculas.

ll. grepl("[A-Z]", cadena): Comprueba y devuelve 'TRUE' si la cadena está en mayúsculas.

m. grepl("[[:alnum:]]", cadena): Comprueba y devuelve "TRUE" si todos los caracteres de la cadena son alfanuméricos.
# Declarar una cadena en R
curso <- "Programación en Lenguaje Estadístico"
# Convertir todas las letras minúsculas a mayúsculas
toupper(curso)
## [1] "PROGRAMACIÓN EN LENGUAJE ESTADÍSTICO"
# Convertir todas las letras mayúsculas a minúsculas
tolower(curso)
## [1] "programación en lenguaje estadístico"
#Convertir la primera letra en mayúscula
paste(toupper(substr(curso, 1, 1)), substr(curso, 2, nchar(curso)), sep = "")
## [1] "Programación en Lenguaje Estadístico"
# Divide la cadena en palabras
strsplit(curso, " ")
## [[1]]
## [1] "Programación" "en"           "Lenguaje"     "Estadístico"
# Elimina los caracteres iniciales y finales de una cadena (espacios en blanco en este caso)
trimws(curso)
## [1] "Programación en Lenguaje Estadístico"
# Longitud de la cadena
nchar(curso)
## [1] 36

Ejemplo en clase:

# Declarar el texto en R
texto <- "Siempre oí hablar del Señor de los Milagros. Y siempre oí hablar de todos los inconvenientes de ir a la procesión del Señor de los Milagros: mucha gente, asfixia, una extensa caminata, robos, etcétera, etcétera, etcétera.

Dados estos inconvenientes (escuchados desde niño), nunca me animé a asistir, hasta que un día una persona que tiene fe en el Señor de los Milagros me regaló una estampa (las estampas te las deben obsequiar) y de alguna manera ú otra me ví 'obligado' a asistir.

Eran mediados de octubre del 2016 y tomé la decisión de asistir. El primer hecho destacable, casi instantáneo, el Señor de los Milagros se detuvo frente a mí en mi primera visita, no había mucha gente, no hubo extensa caminata, no hubo nada de lo que impidió que asista antes, todo fue exactamente al revés. Además la fe de quienes acompañan es tan grande que invade y lo hace sin que te des cuenta. Tuve la oportunidad de rezar, de agradecer pero sobretodo de vivir una experiencia inolvidable de paz, felicidad y esperanza en que algo bueno va a pasar, lo que sea que realmente necesites o necesite quien amas.

Ayer fui al último recorrido aprovechando el feriado y volveré a ir todos los años porque cuando llegas a estar allí, es imposible no querer sentir esa sensación de volver a estar embargado de fe porque la fe mueve montañas y siempre hay que aprender a dar para poder recibir..."
# Usar gregexpr() para buscar la palabra "milagros"
posiciones <- gregexpr("milagros", texto, ignore.case = TRUE)
print(posiciones[[1]])  # Esto muestra las posiciones donde se encuentra "milagros"
## [1]  36 132 363 614
## attr(,"match.length")
## [1] 8 8 8 8
# Aplicar trimws() para eliminar espacios en blanco iniciales y finales
trimws(texto)
## [1] "Siempre oí hablar del Señor de los Milagros. Y siempre oí hablar de todos los inconvenientes de ir a la procesión del Señor de los Milagros: mucha gente, asfixia, una extensa caminata, robos, etcétera, etcétera, etcétera.\n\nDados estos inconvenientes (escuchados desde niño), nunca me animé a asistir, hasta que un día una persona que tiene fe en el Señor de los Milagros me regaló una estampa (las estampas te las deben obsequiar) y de alguna manera ú otra me ví 'obligado' a asistir.\n\nEran mediados de octubre del 2016 y tomé la decisión de asistir. El primer hecho destacable, casi instantáneo, el Señor de los Milagros se detuvo frente a mí en mi primera visita, no había mucha gente, no hubo extensa caminata, no hubo nada de lo que impidió que asista antes, todo fue exactamente al revés. Además la fe de quienes acompañan es tan grande que invade y lo hace sin que te des cuenta. Tuve la oportunidad de rezar, de agradecer pero sobretodo de vivir una experiencia inolvidable de paz, felicidad y esperanza en que algo bueno va a pasar, lo que sea que realmente necesites o necesite quien amas.\n\nAyer fui al último recorrido aprovechando el feriado y volveré a ir todos los años porque cuando llegas a estar allí, es imposible no querer sentir esa sensación de volver a estar embargado de fe porque la fe mueve montañas y siempre hay que aprender a dar para poder recibir..."
# Convertir todas las letras a minúsculas
tolower(texto)
## [1] "siempre oí hablar del señor de los milagros. y siempre oí hablar de todos los inconvenientes de ir a la procesión del señor de los milagros: mucha gente, asfixia, una extensa caminata, robos, etcétera, etcétera, etcétera.\n\ndados estos inconvenientes (escuchados desde niño), nunca me animé a asistir, hasta que un día una persona que tiene fe en el señor de los milagros me regaló una estampa (las estampas te las deben obsequiar) y de alguna manera ú otra me ví 'obligado' a asistir.\n\neran mediados de octubre del 2016 y tomé la decisión de asistir. el primer hecho destacable, casi instantáneo, el señor de los milagros se detuvo frente a mí en mi primera visita, no había mucha gente, no hubo extensa caminata, no hubo nada de lo que impidió que asista antes, todo fue exactamente al revés. además la fe de quienes acompañan es tan grande que invade y lo hace sin que te des cuenta. tuve la oportunidad de rezar, de agradecer pero sobretodo de vivir una experiencia inolvidable de paz, felicidad y esperanza en que algo bueno va a pasar, lo que sea que realmente necesites o necesite quien amas.\n\nayer fui al último recorrido aprovechando el feriado y volveré a ir todos los años porque cuando llegas a estar allí, es imposible no querer sentir esa sensación de volver a estar embargado de fe porque la fe mueve montañas y siempre hay que aprender a dar para poder recibir..."
# Convertir todas las letras a mayúsculas
toupper(texto)
## [1] "SIEMPRE OÍ HABLAR DEL SEÑOR DE LOS MILAGROS. Y SIEMPRE OÍ HABLAR DE TODOS LOS INCONVENIENTES DE IR A LA PROCESIÓN DEL SEÑOR DE LOS MILAGROS: MUCHA GENTE, ASFIXIA, UNA EXTENSA CAMINATA, ROBOS, ETCÉTERA, ETCÉTERA, ETCÉTERA.\n\nDADOS ESTOS INCONVENIENTES (ESCUCHADOS DESDE NIÑO), NUNCA ME ANIMÉ A ASISTIR, HASTA QUE UN DÍA UNA PERSONA QUE TIENE FE EN EL SEÑOR DE LOS MILAGROS ME REGALÓ UNA ESTAMPA (LAS ESTAMPAS TE LAS DEBEN OBSEQUIAR) Y DE ALGUNA MANERA Ú OTRA ME VÍ 'OBLIGADO' A ASISTIR.\n\nERAN MEDIADOS DE OCTUBRE DEL 2016 Y TOMÉ LA DECISIÓN DE ASISTIR. EL PRIMER HECHO DESTACABLE, CASI INSTANTÁNEO, EL SEÑOR DE LOS MILAGROS SE DETUVO FRENTE A MÍ EN MI PRIMERA VISITA, NO HABÍA MUCHA GENTE, NO HUBO EXTENSA CAMINATA, NO HUBO NADA DE LO QUE IMPIDIÓ QUE ASISTA ANTES, TODO FUE EXACTAMENTE AL REVÉS. ADEMÁS LA FE DE QUIENES ACOMPAÑAN ES TAN GRANDE QUE INVADE Y LO HACE SIN QUE TE DES CUENTA. TUVE LA OPORTUNIDAD DE REZAR, DE AGRADECER PERO SOBRETODO DE VIVIR UNA EXPERIENCIA INOLVIDABLE DE PAZ, FELICIDAD Y ESPERANZA EN QUE ALGO BUENO VA A PASAR, LO QUE SEA QUE REALMENTE NECESITES O NECESITE QUIEN AMAS.\n\nAYER FUI AL ÚLTIMO RECORRIDO APROVECHANDO EL FERIADO Y VOLVERÉ A IR TODOS LOS AÑOS PORQUE CUANDO LLEGAS A ESTAR ALLÍ, ES IMPOSIBLE NO QUERER SENTIR ESA SENSACIÓN DE VOLVER A ESTAR EMBARGADO DE FE PORQUE LA FE MUEVE MONTAÑAS Y SIEMPRE HAY QUE APRENDER A DAR PARA PODER RECIBIR..."
# Obtener la longitud del texto limpio
nchar(texto)
## [1] 1378

Lista

En R, una lista es una colección ordenada de elementos que pueden ser de diferentes tipos. Puedes crear listas usando \[ \] o list(). Puedes acceder a los elementos por índice o nombre, y las listas son mutables, lo que significa que puedes modificarlas después de crearlas. Las listas son útiles para almacenar datos heterogéneos o estructuras de datos complejas.

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

Acceder a los elementos de la lista

Las listas son colecciones ordenadas de elementos. Puedes acceder a los elementos de una lista utilizando índices, comenzando desde 1 para el primer elemento. También puedes utilizar la indexación negativa, donde -1 representa el último elemento de la lista.

mi_lista3 <- list(1, 2, 3, 4, "Cinco", 6)
# Primer elemento de la lista
primer_elemento <- mi_lista3[[1]]
cat("Primer elemento de la lista =", primer_elemento, "\n")
## Primer elemento de la lista = 1
# Para acceder al último elemento de la lista
ultimo_elemento <- mi_lista3[[length(mi_lista3)]]
cat("Último elemento de la lista =", ultimo_elemento, "\n")
## Último elemento de la lista = 6

Agregar elemento(s) en la lista

En R, para agregar un valor o elemento a una lista, puedes utilizar la función append(value), que añadirá el valor al final de la lista. También puedes utilizar la asignación para insertar un valor en una posición específica dentro de la lista.

mi_lista2 <- list(1, 2, 3, 4, "Cinco", 6)
cat("Lista inicial:", toString(mi_lista2), "\n")
## Lista inicial: 1, 2, 3, 4, Cinco, 6
# Agregar un nuevo elemento al final
mi_lista2 <- c(mi_lista2, "NuevoElemento")
cat("Lista actualizada con un nuevo elemento al final:", toString(mi_lista2), "\n")
## Lista actualizada con un nuevo elemento al final: 1, 2, 3, 4, Cinco, 6, NuevoElemento
# Insertar un elemento en una posición específica 
posicion <- 4
nuevo_valor <- 5
mi_lista2 <- c(mi_lista2[1:(posicion - 1)], nuevo_valor, mi_lista2[posicion:length(mi_lista2)])
cat("Lista actualizada agregando un nuevo elemento en la posición 4:", toString(mi_lista2), "\n")
## Lista actualizada agregando un nuevo elemento en la posición 4: 1, 2, 3, 5, 4, Cinco, 6, NuevoElemento

Concatenación y repetición

En R, puedes concatenar dos listas utilizando el operador c() o la función append().

#Ejemplo
lista3 <- list(2, 4, 6, 8, 10)
lista4 <- list(1, 3, 5, 7)

# Concatenar las dos listas
numeros <- c(lista3, lista4)

# Mostrar el resultado
print(numeros)
## [[1]]
## [1] 2
## 
## [[2]]
## [1] 4
## 
## [[3]]
## [1] 6
## 
## [[4]]
## [1] 8
## 
## [[5]]
## [1] 10
## 
## [[6]]
## [1] 1
## 
## [[7]]
## [1] 3
## 
## [[8]]
## [1] 5
## 
## [[9]]
## [1] 7
# Extender lista4 con lista3
lista4 <- append(lista4, lista3)

# Mostrar lista4
print(lista4)
## [[1]]
## [1] 1
## 
## [[2]]
## [1] 3
## 
## [[3]]
## [1] 5
## 
## [[4]]
## [1] 7
## 
## [[5]]
## [1] 2
## 
## [[6]]
## [1] 4
## 
## [[7]]
## [1] 6
## 
## [[8]]
## [1] 8
## 
## [[9]]
## [1] 10

Actualizar la lista de R

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

numeros <- c(1, 2, 3, 4, 5, 6)

# Actualizar el valor en la posición 2 con 22
numeros[2] <- 22

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

Eliminar un elemento de la lista de R

Para eliminar un elemento de una lista, puedes utilizar la función list.remove() para eliminar un valor específico o simplemente usar la indexación para eliminar un elemento en una posición determinada.

list.remove() para eliminar un valor particular.

numeros <- c(1, 2, 3, 4, 5, 6)
valor_a_eliminar <- 6

# Eliminar el valor 6 de la lista
numeros <- numeros[numeros != valor_a_eliminar]

# Mostrar la lista actualizada
print(numeros)
## [1] 1 2 3 4 5
indice_a_eliminar <- 2
# Eliminar el elemento en la posición 2
numeros <- numeros[-indice_a_eliminar]

# Mostrar la lista actualizada
print(numeros)
## [1] 1 3 4 5

Comprobar la pertenencia de un elemento

En R, puedes verificar si un valor está presente en una lista utilizando la función %in%. Si el valor existe en la lista, esta función devuelve TRUE; de lo contrario, devuelve FALSE.

# Ejemplo
frutas <- c("fresa", "papaya", "piña")
esta_fresa <- "fresa" %in% frutas
cat("Comprobando si 'fresa' está en la lista:", esta_fresa, "\n")
## Comprobando si 'fresa' está en la lista: TRUE
esta_platano <- "plátano" %in% frutas
cat("Comprobando si 'plátano' está en la lista:", esta_platano, "\n")
## Comprobando si 'plátano' 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 <- strsplit(texto, "\\s+")[[1]]
#Verificar si "morado" está en la lista de palabras
esta_morado <- "morado" %in% texto_sep
# Mostrar el resultado
cat("Comprobando si la palabra 'morado' está en la lista:", esta_morado, "\n")
## Comprobando si la palabra '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)

numeros_orden_ascendente <- sort(numeros)
cat("Lista ordenada en orden ascendente:", numeros_orden_ascendente, "\n")
## Lista ordenada en orden ascendente: 15 20 22 25 28 64
numeros_orden_descendente <- sort(numeros, decreasing = TRUE)
cat("Lista ordenada en orden descendente:", numeros_orden_descendente, "\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 a longitud de una lista utilizando la función length() y contar cuántas veces aparece un elemento específico en la lista utilizando la función sum().

numeros <- c(20, 25, 22, 64, 15, 28, 25, 30, 25)

#Longitud
longitud_lista <- length(numeros)
cat("Longitud de la lista:", longitud_lista, "\n")
## Longitud de la lista: 9
# Cantidad
cant_lista <- sum(numeros == 25)
cat("Cantidad de veces que aparece el número 25 en la lista:", cant_lista, "\n")
## Cantidad de veces que aparece el número 25 en la lista: 3

Corte de 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:lista[start:stop]

start: El índice donde comienza el subconjunto (inclusive).

stop: El índice donde termina el subconjunto (exclusivo)..

lista_6 <- c("P", "Y", "T", "H", "O", "N")

# Obtener un segmento de lista desde el primer índice hasta el quinto índice
segmento1 <- lista_6[2:5]
cat("Segmento desde el índice 2 al 5:", segmento1, "\n")
## Segmento desde el índice 2 al 5: Y T H O
# Si no se menciona la parada, aparecerá hasta el final de la lista
segmento2 <- lista_6[2:length(lista_6)]
cat("Segmento desde el índice 2 hasta el final:", segmento2, "\n")
## Segmento desde el índice 2 hasta el final: Y T H O N
# Si no se menciona el inicio, aparecerá desde el principio hasta el índice 3
segmento3 <- lista_6[1:3]
cat("Segmento desde el principio hasta el índice 3:", segmento3, "\n")
## Segmento desde el principio hasta el índice 3: P Y T
# Si no se mencionan ni el índice inicial ni el final, devuelve la lista completa
segmento4 <- lista_6
cat("Lista completa:", segmento4, "\n")
## Lista completa: P Y T H O N
# También admite índices negativos
segmento5 <- lista_6[(length(lista_6) - 2):(length(lista_6) - 1)]
cat("Segmento desde el índice -3 al -1:", segmento5, "\n")
## Segmento desde el índice -3 al -1: H O
# Obtener un segmento de lista con paso 2 desde el índice 2 al 6
segmento <- lista_6[2:6]
segmento_con_paso <- segmento[seq(from = 1, to = length(segmento), by = 2)]

cat("Segmento con paso 2 desde el índice 2 al 6:", segmento_con_paso, "\n")
## Segmento con paso 2 desde el índice 2 al 6: Y H N

Convertir cadenas y tuplas en la lista

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

# Ejemplo
cadena3 <- "PYTHON"
tupla3 <- c("P", "Y", "T", "H", "O", "N")
cat("Tipo de cadena:", typeof(cadena3), "\n")
## Tipo de cadena: character
lista_cadena <- as.list(strsplit(cadena3, NULL)[[1]])
cat("Convertir una cadena en una lista:")
## Convertir una cadena en una lista:
print(lista_cadena)
## [[1]]
## [1] "P"
## 
## [[2]]
## [1] "Y"
## 
## [[3]]
## [1] "T"
## 
## [[4]]
## [1] "H"
## 
## [[5]]
## [1] "O"
## 
## [[6]]
## [1] "N"
lista_tupla <- as.list(tupla3)
cat("Convertir una tupla en una lista:")
## Convertir una tupla en una lista:
print(lista_tupla)
## [[1]]
## [1] "P"
## 
## [[2]]
## [1] "Y"
## 
## [[3]]
## [1] "T"
## 
## [[4]]
## [1] "H"
## 
## [[5]]
## [1] "O"
## 
## [[6]]
## [1] "N"

Tuplas

En R, puedes utilizar vectores para crear una colección ordenada de elementos, pero a diferencia de las tuplas en Python, los vectores en R son mutables y se pueden modificar.

# Crear un vector (similar a una tupla)
mi_vector <- c(1, 2, 3, 4, "Five", 6)
# Primer elemento del vector (índice 1)
cat("1er elemento del vector =", mi_vector[1], "\n")
## 1er elemento del vector = 1
# Segundo elemento del vector (índice 2)
cat("2do elemento del vector =", mi_vector[2], "\n")
## 2do elemento del vector = 2
# Último elemento del vector (usando índice negativo)
cat("Último elemento del vector =", mi_vector[length(mi_vector)], "\n")
## Último elemento del vector = 6

Agregar elemento(s) en tupla

Las listas en R son mutables, lo que significa que puedes modificarlas después de su creación. Puedes agregar nuevos elementos a una lista existente o modificar los elementos existentes. Aquí tienes un ejemplo de cómo hacerlo:

# Ejemplo
# Lista inicial
mi_lista <- list(1, 2, 3)
print("Lista inicial:")
## [1] "Lista inicial:"
print(mi_lista)
## [[1]]
## [1] 1
## 
## [[2]]
## [1] 2
## 
## [[3]]
## [1] 3
# Agregar un nuevo elemento (4) a la lista
mi_lista <- c(mi_lista, 4)
print("Lista actualizada con un nuevo elemento:")
## [1] "Lista actualizada con un nuevo elemento:"
print(mi_lista)
## [[1]]
## [1] 1
## 
## [[2]]
## [1] 2
## 
## [[3]]
## [1] 3
## 
## [[4]]
## [1] 4
# Modificar un elemento existente (por ejemplo, el segundo elemento se cambia a 22)
mi_lista[2] <- 22
print("Lista con el segundo elemento modificado:")
## [1] "Lista con el segundo elemento modificado:"
print(mi_lista)
## [[1]]
## [1] 1
## 
## [[2]]
## [1] 22
## 
## [[3]]
## [1] 3
## 
## [[4]]
## [1] 4

Concatenación y repetición

Para la concatenación de vectores en R, puedes utilizar la función c() para combinar dos o más vectores en uno solo. Por ejemplo, si tienes dos vectores v1 y v2, puedes crear un nuevo vector v3 concatenando v1 y v2 usando v3 <- c(v1, v2).

Para repetir un vector en R, puedes utilizar la función rep(). Si tienes un vector v1 y quieres repetirlo varias veces, puedes hacerlo de la siguiente manera: v1 <- rep(v1, times = n) donde n es el número de repeticiones que deseas.

# Ejemplo
# Vectores
v1 <- c(1, 2, 3)
v2 <- c("uno", "dos", "tres")
# Concatenación
v3 <- c(v1, v2)
cat("Concatenación:")
## Concatenación:
print(v3)
## [1] "1"    "2"    "3"    "uno"  "dos"  "tres"
# Repetición
v1 <- rep(c(1, 2, 3), times = 3)
cat("Repetición:")
## Repetición:
print(v1)
## [1] 1 2 3 1 2 3 1 2 3

La mayoría de los operadores de listas también funcionan en tuplas. El operador corchete indexa un elemento:

# Indexación
v4 <- c('a', 'b', 'c', 'd', 'e')
cat("Indexación:")
## Indexación:
print(v4[1])  # El índice en R comienza en 1
## [1] "a"

Diccionarios

En R, puedes utilizar listas con nombres para crear una estructura de datos que funcione de manera similar a un diccionario. Estas listas permiten asociar claves con valores de manera que puedas acceder a los valores a través de las claves.

# creando un diccionario en Python
mi_diccionario <- list("1" = "60%", "2" = "50%", "3" = "30%")
print(mi_diccionario)
## $`1`
## [1] "60%"
## 
## $`2`
## [1] "50%"
## 
## $`3`
## [1] "30%"

Trabajar con diccionarios

En R, puedes utilizar listas con nombres para trabajar con estructuras de datos que simulan diccionarios. Para acceder al valor de una clave específica en una lista con nombres, puedes usar el operador $ seguido del nombre de la clave. Si la clave especificada no está disponible en la lista, R devolverá NULL

valor <- mi_diccionario$"2"
cat("El valor de la clave '2' es:", valor, "\n")
## El valor de la clave '2' es: 50%
# Crear un "diccionario" en R utilizando listas con nombres
semaforo <- list("Rojo" = "Parar", "Ambar" = "Precaución", "Verde" = "Adelante")

# Acceder al valor de la clave "Ambar"
valor_ambar <- semaforo$"Ambar"
cat("El valor de la clave 'Ambar' es:", valor_ambar, "\n")
## El valor de la clave 'Ambar' es: Precaución
# Intentar acceder a una clave que no existe en el "diccionario"
valor_inexistente <- semaforo$"Azul"
cat("El valor de la clave 'Azul' (inexistente) es:", valor_inexistente, "\n")
## El valor de la clave 'Azul' (inexistente) es:

Agregar elemento(s) en el diccionario

En R, puedes agregar un nuevo elemento a un “diccionario” simulado utilizando la notación de doble corchete [[]] para asignar un valor a una nueva clave.

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

# Agregar un nuevo elemento con clave "4" y valor "25%"
mi_diccionario[["4"]] <- "25%"
print(mi_diccionario)
## $`1`
## [1] "60%"
## 
## $`2`
## [1] "50%"
## 
## $`3`
## [1] "30%"
## 
## $`4`
## [1] "25%"

Eliminar un elemento del diccionario de Python

n R, puedes eliminar un elemento de un “diccionario” simulado utilizando la función remove() o simplemente eliminando la clave correspondiente del “diccionario”.

# Crear un "diccionario" en R utilizando listas con nombres
mi_diccionario <- list("1" = "60%", "2" = "50%", "3" = "30%")
mi_diccionario$`3` <- NULL
print(mi_diccionario)
## $`1`
## [1] "60%"
## 
## $`2`
## [1] "50%"

Comprobar la pertenencia de un elemento

En R, puedes verificar si una clave existe en un “diccionario” simulado utilizando la función exists().

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

# Verificar si la clave "2" está en el "diccionario"
clave_existe <- exists("2", where = mi_diccionario)

cat("La clave '2' está en el diccionario:", clave_existe, "\n")
## La clave '2' está en el diccionario: TRUE
# Verificar si la clave "8" está en el "diccionario"
clave_no_existe <- exists("8", where = mi_diccionario)

cat("La clave '8' está en el diccionario:", clave_no_existe, "\n")
## La clave '8' está en el diccionario: FALSE

Obtener la lista de todas las claves de un dicionario

En R, puedes obtener la lista de todas las claves de un “diccionario” simulado utilizando la función names()

claves <- names(mi_diccionario)

cat("Lista de todas las claves del diccionario:", claves, "\n")
## Lista de todas las claves del diccionario: 1 2 3

Obtener la lista de todos los valores de un diccionario

En R, puedes obtener la lista de todos los valores de un “diccionario” simulado utilizando la función unlist().

valores <- unlist(mi_diccionario)

cat("Lista de todos los valores del diccionario:", valores, "\n")
## Lista de todos los valores del diccionario: 60% 50% 30%

Obtener la lista de tuplas de pares clave y valor

n R, puedes obtener una lista de tuplas de pares clave-valor de un “diccionario” simulado utilizando la función as.list().

tuplas <- as.list(mi_diccionario)

cat("Lista de tuplas de pares clave-valor del diccionario:\n")
## Lista de tuplas de pares clave-valor del diccionario:
print(tuplas)
## $`1`
## [1] "60%"
## 
## $`2`
## [1] "50%"
## 
## $`3`
## [1] "30%"

Iterando un diccionario

En R, puedes iterar a través de un “diccionario” simulado utilizando un bucle for y la función names() para obtener las claves y luego acceder a los valores correspondientes utilizando la notación $.

for (clave in names(mi_diccionario)) {
  valor <- mi_diccionario[[clave]]
  cat("Valor para la clave", clave, "es", valor, "\n")
}
## Valor para la clave 1 es 60% 
## Valor para la clave 2 es 50% 
## Valor para la clave 3 es 30%

Conversión de clave, valor iterable en diccionario

En R, puedes convertir una lista de tuplas clave-valor en un “diccionario” simulado utilizando la función list() para crear una lista de listas con nombres.

mi_lista <- list("1" = "60%", "2" = "50%", "3" = "30%")
mi_diccionario <- as.list(mi_lista)

cat("Diccionario resultante:\n")
## Diccionario resultante:
print(mi_diccionario)
## $`1`
## [1] "60%"
## 
## $`2`
## [1] "50%"
## 
## $`3`
## [1] "30%"

Caso: Problema de transporte de FOSTERS GENERATORS

Caso:

# Declaramos el origen (planta)
planta <- list(
  'Cleveland' = 5000,
  'Bedford' = 6000,
  'York' = 2500
)
# Declaramos los destinos (distribucion)
distribucion <- list(
  'Boston' = 6000,
  'Chicago' = 4000,
  'SanLuis' = 2000,
  'Lexington' = 1500
)
# Declaramos los costos (costos)
costos <- list(
  c('Boston', 'Cleveland', 3),
  c('Boston', 'Bedford', 7),
  c('Boston', 'York', 2),
  c('Chicago', 'Cleveland', 2),
  c('Chicago', 'Bedford', 5),
  c('Chicago', 'York', 5),
  c('SanLuis', 'Cleveland', 7),
  c('SanLuis', 'Bedford', 2),
  c('SanLuis', 'York', 4),
  c('Lexington', 'Cleveland', 6),
  c('Lexington', 'Bedford', 3),
  c('Lexington', 'York', 5)
)
# Mostramos los diccionarios
planta
## $Cleveland
## [1] 5000
## 
## $Bedford
## [1] 6000
## 
## $York
## [1] 2500
distribucion
## $Boston
## [1] 6000
## 
## $Chicago
## [1] 4000
## 
## $SanLuis
## [1] 2000
## 
## $Lexington
## [1] 1500
costos
## [[1]]
## [1] "Boston"    "Cleveland" "3"        
## 
## [[2]]
## [1] "Boston"  "Bedford" "7"      
## 
## [[3]]
## [1] "Boston" "York"   "2"     
## 
## [[4]]
## [1] "Chicago"   "Cleveland" "2"        
## 
## [[5]]
## [1] "Chicago" "Bedford" "5"      
## 
## [[6]]
## [1] "Chicago" "York"    "5"      
## 
## [[7]]
## [1] "SanLuis"   "Cleveland" "7"        
## 
## [[8]]
## [1] "SanLuis" "Bedford" "2"      
## 
## [[9]]
## [1] "SanLuis" "York"    "4"      
## 
## [[10]]
## [1] "Lexington" "Cleveland" "6"        
## 
## [[11]]
## [1] "Lexington" "Bedford"   "3"        
## 
## [[12]]
## [1] "Lexington" "York"      "5"