R es un lenguaje de programación y un entorno de desarrollo ampliamente empleado en el campo del análisis estadístico y la representación gráfica de datos. Se trata de una herramienta sumamente robusta y versátil que ha experimentado un aumento en su adopción dentro de la comunidad de profesionales en ciencia de datos y estadísticas, gracias a su capacidad de adaptación y a la extensa selección de paquetes y bibliotecas disponibles.
RStudio es un ambiente de desarrollo integrado (IDE) creado con la finalidad de ser utilizado de manera específica con R. Ofrece una interfaz de usuario amigable que simplifica la tarea de escribir código, administrar proyectos y crear informes que puedan ser reproducidos fácilmente.
Tanto R como RStudio son herramientas fundamentales para quienes se dedican al análisis de datos, estadísticas, ciencia de datos o programación. Estas herramientas posibilitan la importación de datos, la ejecución de análisis estadísticos avanzados, la creación de gráficos impactantes y la comunicación efectiva de los resultados.
Existen algunas palabras reservadas que no pueden utilizarse como nombres de variables, funciones o objetos, ya que tienen un significado específico en el lenguaje. Aquí tienes una lista de algunas de las palabras reservadas en Rstudio:
if: Se utiliza para crear estructuras condicionales.
else: Se utiliza en combinación con ifpara especificar un bloque de código que se ejecutará si la condición en el ifno se cumple.
elseif o else if: Se utiliza en combinación con if para especificar condiciones adicionales que se evalúan si la primera condición no se cumple.
for: Se utiliza para crear bucles for.
while: Se utiliza para crear bucles while.
repeat: Se utiliza para crear bucles infinitos.
function: Se utiliza para definir funciones en R.
return: Se utiliza dentro de una función para especificar el valor que se debe devolver cuando la función se llama.
break: Se utiliza para salir de un bucle.
next: Se utiliza para pasar a la siguiente iteración de un bucle.
TRUE y FALSE: Representan los valores lógicos verdadero y falso, respectivamente.
NULL: Representa la falta de valor o la ausencia de un objeto.
NA: Representa un valor perdido o no disponible (No disponible).
Inf y -Inf: Representan infinito positivo y negativo infinito, respectivamente.
NaN: Representa “Not a Number”, utilizado para representar resultados indefinidos o no numéricos.
Una variable está formada por un espacio en el sistema de almacenaje (memoria principal de un ordenador) y un nombre simbólico (un identificador) que está asociado a dicho espacio. Ese espacio contiene una cantidad de información conocida o desconocida, es decir un valor. El nombre de la variable es la forma usual de referirse al valor almacenado: esta separación entre nombre y contenido permite que el nombre sea usado independientemente de la información exacta que representa. El identificador, en el código fuente de la computadora puede estar ligado a un valor durante el tiempo de ejecución y el valor de la variable puede por lo tanto cambiar durante el curso de la ejecución del programa. El concepto de variables en computación puede no corresponder directamente al concepto de variables en matemática.
Por ejemplo:
x <- 35Aquí, ‘x’ es el nombre de la variable, <- es un operador de asignación y 35 es el valor o literal. Entonces, al usar el operador de asignación <- en R, podemos reservar memoria para el valor sin declararlo explícitamente.
x <- 5
y <- as.integer(10)a <- 3.14
b <- -0.5-Puedes declarar variables que almacenen cadenas de caracteres utilizando comillas simples ( ’ ’) o comillas dobles ( ” “). Ejemplo:
nombre <- 'Juan'
apellido <- "Pérez"-Un vector es una colección ordenada de elementos del mismo tipo de datos. Puedes crear un vector utilizando la función c()(concatenar). Ejemplo:
numeros <- c(1, 2, 3, 4, 5)
colores <- c("rojo", "verde", "azul")-Una lista es una colección ordenada de elementos que pueden ser de diferentes tipos de datos. Puedes crear una lista utilizando la función list(). Ejemplo:
mi_lista <- list(nombre = "Juan", edad = 30, ciudad = "Bogotá")-Los factores son utilizados para representar datos categóricos o de tipo ordinal. Puedes crear factores utilizando la función factor(). Ejemplo:
nivel_educativo <- factor(c("Bachillerato", "Licenciatura", "Maestría"))-Los data frames son estructuras de datos bidimensionales similares a una tabla de base de datos. Puedes crear un marco de datos utilizando la función data.frame(). Ejemplo:
datos <- data.frame(
nombres = c("Juan", "María", "Carlos"),
edades = c(30, 25, 35),
ciudades = c("Bogotá", "Medellín", "Cali")
)-Una matriz es una estructura de datos bidimensional que contiene elementos del mismo tipo de datos. Puedes crear matrices utilizando la función matrix(). Ejemplo:
matriz <- matrix(1:9, nrow = 3, ncol = 3)a.Características permitidas:
-Los nombres de variables en R pueden contener letras (mayúsculas y minúsculas), números y el carácter de punto (.) o guión bajo (_). El primer carácter del nombre de la variable no puede ser un número ni un carácter especial (como un signo de dólar $).
b.Mayúsculas y minúsculas:
-R es sensible a mayúsculas y minúsculas, lo que significa que considera que miVariabley mivariableson nombres de variables diferentes.
c.Palabras reservadas:
-Evite usar palabras reservadas de R como nombres de variables. Puedes consultar la lista de palabras reservadas en una respuesta anterior.
d.Convenios de estilo:
-Se recomienda seguir las convenciones de estilo para hacer tu código más legible. Una convención común es usar letras minúsculas para los nombres de variables y separar palabras con guiones bajos (snake_case) o usar letras mayúsculas para cada palabra (CamelCase).
-Ejemplo de Snake_case: mi_variable, edad_promedio. -Ejemplo de CamelCase: miVariable, EdadPromedio.
e.Brevedad y claridad:
-Los nombres de variables deben ser descriptivos y significativos. Evite nombres demasiado cortos o demasiado largos. Un buen nombre de variable comunica su propósito en el contexto de tu código.
f.Evitar caracteres especiales:
-Si bien R permite el uso de caracteres especiales como el punto (.) en los nombres de variables, es una buena práctica evitarlos, ya que pueden causar confusiones y dificultar la lectura del código.
g.Usar nombres en inglés:
-Aunque no es una regla estricta, es una buena práctica utilizar nombres de variables en inglés para que tu código sea más comprensible para una audiencia global.
*Advertencia: Es esencial abstenerse de utilizar los nombres de funciones incorporadas en R para denominar tus variables, ya que esto podría generar conflictos en el código.
Son símbolos o signos que se utilizan para realizar operaciones matemáticas en números. Estos operadores permiten llevar a cabo cálculos matemáticos básicos y avanzados en el lenguaje de programación R, que es el entorno de desarrollo que proporciona RStudio para trabajar con el lenguaje R. Aquí están los operadores aritméticos más comunes en Rstudio:
1.Suma (+): Se utiliza para sumar dos números.
Ejemplo:
#Asignamos valores a las varibles 'm' y 'n'.
m <- 15
n <- 20# Suma
print(paste("Al sumar 'm' y 'n' su resultado es:", m + n))## [1] "Al sumar 'm' y 'n' su resultado es: 35"2.Resta (-): Se utiliza para restar un número de otro.
Ejemplo:
print(paste("Al restar 'm' y 'n' su resultado es:", m - n))## [1] "Al restar 'm' y 'n' su resultado es: -5"3.Multiplicación (*): Se utiliza para multiplicar dos números.
Ejemplo:
print(paste("Al multiplicar 'm' y 'n' su resultado es:", m * n))## [1] "Al multiplicar 'm' y 'n' su resultado es: 300"4.División (/): Se utiliza para dividir un número por otro.
Ejemplo:
print(paste("Al dividir 'm' y 'n' su resultado es:", m / n))## [1] "Al dividir 'm' y 'n' su resultado es: 0.75"5.Divison de piso (%/%): Devuelve la parte entera del cociente entre dos números, es decir, descarta la parte decimal del resultado y devuelve solo el valor entero.
Ejemplo:
print(paste("Al dividir 'm' y 'n' su cociente es:", m %/% n))## [1] "Al dividir 'm' y 'n' su cociente es: 0"6.Módulo (%%): Devuelve el residuo de la división de un número por otro. También se conoce como operador de “resto”.
Ejemplo:
print(paste("Al dividr 'm' y 'n' el residuo es:", m %% n))## [1] "Al dividr 'm' y 'n' el residuo es: 15"7.Potenciación (^) o ( ** ): Se utiliza para elevar un número a una potencia.
Ejemplo:
print(paste("Al elevar 'm' con exponente 'n' su resultado es:", m ^ n))## [1] "Al elevar 'm' con exponente 'n' su resultado es: 3.32525673007965e+23"Son utilizados para comparar valores y expresiones y evaluar si una relación entre ellos es verdadera o falsa. Estos operadores son fundamentales para crear expresiones condicionales y realizar pruebas lógicas en R.Aquí tienes una lista de los operadores relacionales más comunes en Rstudio:
#Asignamos valores a las varibles 'r' y 's'.
r <- 24
s <- 30a.Igualdad ( ==): Se utiliza para verificar si dos valores son iguales. Devuelve TRUE si son iguales y FALSE si no lo son.
Ejemplo:
print(paste("El valor de 'r' es igual al valor de 's', esto es:", r==s))## [1] "El valor de 'r' es igual al valor de 's', esto es: FALSE"b.Desigualdad ( !=): Se utiliza para verificar si dos valores son diferentes. Devuelve TRUE si son diferentes y FALSE si son iguales.
Ejemplo:
print(paste("El valor de 'r' no es igual al valor de 's', esto es:", r!=s))## [1] "El valor de 'r' no es igual al valor de 's', esto es: TRUE"c.Menor que ( <): Comprueba si un valor es menor que otro. Devuelve TRUE si es menor y FALSE si no lo es.
Ejemplo:
print(paste("El valor de 'r' es menor al valor de 's', esto es:", r<s))## [1] "El valor de 'r' es menor al valor de 's', esto es: TRUE"d.Mayor que ( >): Comprueba si un valor es mayor que otro. Devuelve TRUE si es mayor y FALSE si no lo es.
Ejemplo:
print(paste("El valor de 'r' es mayor al valor de 's', esto es:", r>s))## [1] "El valor de 'r' es mayor al valor de 's', esto es: FALSE"e.Menor o igual que ( <=): Verifica si un valor es menor o igual que otro. Devuelve TRUE si es menor o igual y FALSE si no lo es.
Ejemplo:
print(paste("El valor de 'r' es menor o igual al valor de 's', esto es:", r<=s))## [1] "El valor de 'r' es menor o igual al valor de 's', esto es: TRUE"f.Mayor o igual que ( >=): Verifica si un valor es mayor o igual que otro. Devuelve TRUE si es mayor o igual y FALSE si no lo es.
Ejemplo:
print(paste("El valor de 'r' es mayor o igual al valor de 's', esto es:", r>=s))## [1] "El valor de 'r' es mayor o igual al valor de 's', esto es: FALSE"Para asignar el valor a una variable, utilizamos operadores de asignación.los operadores de asignación más comunes son los siguientes:
1.Asignación ( <-o =): Se utiliza para asignar un valor a una variable. Ambos operadores ( <-y =) son intercambiables en R.
Ejemplo:
#Asignamos valores a las varibles 'o' y 'p'.
o <- 30
p <- 352.Sumar y asignar (+=): Se refiere al proceso de sumar un valor existente en una variable con otro valor y luego asignar el resultado de esa suma nuevamente a la misma variable. Esto es útil cuando deseas actualizar el valor de una variable agregando un valor adicional a la variable existente.
Ejemplo:
o <- o + 10
cat("Sumar y asignar (o <- o + 10) => ", o, "\n")## Sumar y asignar (o <- o + 10) => 403.Restar y asignar (-=): Se refiere al proceso de restablecer un valor existente en una variable a otro valor y luego asignar el resultado de esa resta nuevamente a la misma variable. Esto es útil cuando deseas actualizar el valor de una variable restando un valor específico de la variable existente.
Ejemplo:
o <- o - 10
cat("Restar y asignar (o <- o - 10) => ", o, "\n")## Restar y asignar (o <- o - 10) => 304.Multiplicar y asignar (*=): Se refiere al proceso de multiplicar un valor existente en una variable por otro valor y luego asignar el resultado de esa multiplicación nuevamente a la misma variable. Esto es útil cuando deseas actualizar el valor de una variable multiplicando su valor actual por otro valor.
Ejemplo:
o <- o * 10
cat("Multiplicar y asignar (o <- o * 10) => ", o, "\n")## Multiplicar y asignar (o <- o * 10) => 3005.Dividir y asignar (/=): Se refiere al proceso de dividir un valor existente en una variable por otro valor y luego asignar el resultado de esa división nuevamente a la misma variable. Esto es útil cuando deseas actualizar el valor de una variable dividiendo su valor actual por otro valor.
Ejemplo:
# Asignar el valor de o
o <- 30o <- o / 10
cat("Dividir y asignar (o <- o / 10) => ", o, "\n")## Dividir y asignar (o <- o / 10) => 36.Dividir y asignacion del piso (%/%): Se refiere al proceso de dividir un valor existente en una variable por otro valor y luego asignar el resultado de esa división nuevamente pero descarta la parte decimal del resultado y devuelve solo el valor entero. Esto es útil cuando deseas actualizar el valor de una variable dividiendo su valor actual por otro valor.
Ejemplo:
p <- p %/% 4
cat("Piso-Dividir y asignar (p <- p %/% 4) => ", p, "\n")## Piso-Dividir y asignar (p <- p %/% 4) => 87.Modulo y asignar (%=): Se refiere a realizar la operación de módulo en un valor existente de una variable y luego asignar el resultado de esa operación nuevamente a la misma variable. El operador de módulo ( %%) se utiliza para calcular el residuo de la división de un número por otro, y la operación de “módulo y asignación” es útil cuando deseas actualizar el valor de una variable al calcular el residuo de su valor actual dividido por otro número.
Ejemplo:
p <- p %% 3
cat("Módulo y asignar (p <- p %% 3) => ", p, "\n")## Módulo y asignar (p <- p %% 3) => 28.Exponenciacion y asignar (**=): Se refiere al proceso de elevar un valor existente en una variable a una potencia específica y luego asignar el resultado de esa operación nuevamente a la misma variable. Esto es útil cuando deseas actualizar el valor de una variable al elevarla a una potencia particular.
Ejemplo:
#Asignar el valor de p
p <-35p <- p^2
cat("Exponenciación y asignar (p <- p^2) => ", p, "\n")## Exponenciación y asignar (p <- p^2) => 1225Se utilizan para realizar operaciones lógicas o comparaciones entre valores lógicos, como verdadero ( ) o falso ( ) TRUE, FALSEo para combinar múltiples expresiones lógicas. Estos operadores son fundamentales para construir expresiones condicionales y tomar decisiones en tus programas Rstudio. A continuación, se presentan los operadores lógicos más comunes en Rstudio:
1.Operador lógico AND (y):Da como resultado ‘True’ si ambos operandos son ‘Verdadero’ y ‘False’ en caso contrario.
Ejemplo:
# Asignamos las variables "j" y "k"
j <- FALSE
k <- TRUEprint(paste("j y k es:", j & k))## [1] "j y k es: FALSE"2.Operador lógico OR (o): Da “True” como resultado si alguno de los operandos es “Verdadero” y “False” en caso contrario.
Ejemplo:
# Asignamos las variables "j" y "k"
j <- FALSE
k <- TRUEprint(paste("j o k es:", j | k))## [1] "j o k es: TRUE"3.Operador lógico NOT (no): Da como resultado ‘True’ si un operando es ‘Falso’ y ‘True’ si un operando es ‘Verdadero’.
Ejemplo:
# Asignamos las variables "j" y "k"
j <- FALSE
k <- TRUEprint(paste("no j es:", !j))## [1] "no j es: TRUE"print(paste("no k es:", !k))## [1] "no k es: FALSE"1.Números enteros ( integer): Representan números enteros, como -1, 0, 1, 2, etc.
2.Números de punto flotante ( numeric o double): Representan números reales con decimales, como 3.14, -0.001, etc.
3.Caracteres ( character): Representan texto o cadenas de caracteres.
4.Factores ( factor): Representan variables categóricas con un número limitado de categorías o niveles.
5.Lógicos ( logical): Representan valores lógicos verdadero o falso ( TRUEo FALSE).
6.Vectores ( vector): Son secuencias ordenadas de valores del mismo tipo de datos. Los vectores pueden ser de tipo entero, de punto flotante, de caracteres, etc.
7.Complex (Complejo): Este tipo de dato se utiliza para representar números complejos que constan de una parte real y una imaginaria.
8.Raw (Crudo): Este tipo de dato se utiliza para almacenar bytes o datos binarios sin procesar.
9.Listas ( list): Son estructuras de datos que pueden contener una variedad de tipos de datos, incluidos vectores, marcos de datos, matrices y otros objetos.
10.Matrices ( matrix): Son estructuras bidimensionales de datos que contienen elementos del mismo tipo.
11.Marcos de datos ( data.frame): Son estructuras bidimensionales similares a las tablas de una base de datos y pueden contener diferentes tipos de datos en sus columnas.
12.NULL ( NULL): Representa la falta de valor o datos faltantes.
13.Date (Fecha) y Time (Tiempo): Estos tipos de datos se utilizan para representar fechas y horas respectivamente.
a)Números de punto flotante ( numerico double): Representan números reales que pueden tener una parte decimal. Los números de punto flotante son el tipo de datos predeterminado para números en Rstudio.
Ejemplo:
# Asignamos valores a las varibles 'b1' y 'b2'.
b1 <- -13.5
b2 <- 7.0# Comprobar el tipo de variable b1 y b2
print(paste("El tipo de variable b1 es:", class(b1)))## [1] "El tipo de variable b1 es: numeric"print(paste("El tipo de variable b2 es:", class(b2)))## [1] "El tipo de variable b2 es: numeric"b)Números enteros ( integer): Representan números enteros sin parte decimal. En R, los números enteros se suelen denotar con la letra “L” al final del valor.
Ejemplo:
# Asignamos valores a las varibles 'c1' y 'c2'.
c1 <- 6L
c2 <- -8L# Comprobar el tipo de variable a1 y a2
print(paste("El tipo de variable c1 es:", class(c1)))## [1] "El tipo de variable c1 es: integer"print(paste("El tipo de variable c2 es:", class(c2)))## [1] "El tipo de variable c2 es: integer"c)Números complejos ( complex): Representan números complejos con una parte real y una parte imaginaria.
Ejemplo:
# Asignamos valores a las varibles 'd','f','g' y 'h'
d <- 5 + 8i
f <- 20 + 5i
g <- 6 + 9i
h <- -2i# Comprobar el tipo de variable de d,f,g y h
print(paste("El tipo de variable d es:", class(d)))## [1] "El tipo de variable d es: complex"print(paste("El tipo de variable f es:", class(f)))## [1] "El tipo de variable f es: complex"print(paste("El tipo de variable g es:", class(g)))## [1] "El tipo de variable g es: complex"print(paste("El tipo de variable h es:", class(h)))## [1] "El tipo de variable h es: complex"Puedes realizar conversiones de tipos de datos entre enteros ( integer), números de punto flotante ( numeric), y números complejos ( complex) utilizando las funciones as.integer(), as.numeric(), y as.complex(). Estas funciones te permiten convertir una variable de un tipo de datos a otro tipo de datos compatible. Aquí tienes ejemplos de cómo realizar estas conversiones:
1.De numeric a integer: Para convertir un valor numérico a entero en Rstudio, puedes utilizar la función “as.integer()”.
Ejemplo:
# Asignamos la variable 'x1'
x1 <- 5.7# Convierte x1 de numeric a integer
y1 <- as.integer(x1)# Imprimimos la variable y1
print(y1)## [1] 5# Comprobar el tipo de variable y1
print(paste("El tipo de variable y1 es:", class(y1)))## [1] "El tipo de variable y1 es: integer"2.De integer a numeric:Para convertir un valor entero a numerico en Rstudio, puedes utilizar la función “as.numeric()”.
Ejemplo:
# Asignamos la variable 'i1'
i1 <- 10L# Convierte i1 de integer a numeric
u1 <- as.numeric(i1)# Imprimimos la variable u1
print(u1)## [1] 10# Comprobar el tipo de variable u1
print(paste("El tipo de variable u1 es:", class(u1)))## [1] "El tipo de variable u1 es: numeric"3.De integer a complex:Para convertir un valor entero a complejo en Rstudio, puedes utilizar la función “as.complex()”.
Ejemplo:
# Asignamos la variable 'r1'
r1 <- 9L# Convierte r1 de integer a complex
t1 <- as.complex(r1)# Imprimimos la variable t1
print(t1)## [1] 9+0i# Comprobar el tipo de variable t1
print(paste("El tipo de variable t1 es:", class(t1)))## [1] "El tipo de variable t1 es: complex"4.De numeric a complex:Para convertir un valor numerico a complejo en Rstudio, puedes utilizar la función “as.complex()”.
Ejemplo:
# Asignamos la variable 'n1'
n1 <- 20.5# Convierte n1 de numeric a complex
m1 <- as.complex(n1)# Imprimimos la variable m1
print(m1)## [1] 20.5+0i# Comprobar el tipo de variable m1
print(paste("El tipo de variable m1 es:", class(m1)))## [1] "El tipo de variable m1 es: complex"5.De numéric a una cadena de caracteres:Para convertir un valor
numérico a una cadena de caracteres en R, puedes utilizar la función
as.character().
Ejemplo:
# Asignamos la variable 'f1'
f1 <- 12.6# Convierte f1 de numeric a cadena de caracteres
g1 <- as.character(f1)# Imprimimos la variable g1
print(g1)## [1] "12.6"# Comprobar el tipo de variable g1
print(paste("El tipo de variable g1 es:", class(g1)))## [1] "El tipo de variable g1 es: character"Las “cadenas” se refieren a secuencias de caracteres o texto. Las cadenas se utilizan para representar datos de texto, como nombres, descripciones, mensajes, etiquetas y más. Las cadenas se crean al rodear el texto con comillas, ya sea comillas simples ( ’) o comillas dobles ( “).
# Ejemplos de codificacion
cadena1 <- 'Hola, ¿cómo estás?' # Esta es una cadena entre comillas simples
cadena2 <- "Hola, ¿cómo estás?" # 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] "Hola, ¿cómo estás?"print(cadena2)## [1] "Hola, ¿cómo estás?"cat(cadena3) # Utilizamos cat para imprimir cadenas de varias líneas##
## Línea uno
## Línea dos
## Línea tresEn RStudio, puede acceder a componentes individuales de una cadena (como caracteres específicos) y realizar diversas operaciones de manipulación de cadenas utilizando índices y funciones incorporadas.
Una cadena en RStudio es un tipo de secuencia, por lo que admite la indexación. -Observación: En RStudio, la indexación comienza desde 1. También admite índices negativos, es decir, -1, -2, etc.; índice -1 significa el último elemento de una cadena, -2 significa el penúltimo carácter de una cadena, y así sucesivamente.
# Asignamos una cadena
mensaje = "Camaron que se duerme se lo lleva la corriente"# Imprimir resultados
print(paste("mensaje[1] es:", mensaje[1]))## [1] "mensaje[1] es: Camaron que se duerme se lo lleva la corriente"print(paste("\nmensaje[-1] es:", mensaje[-1]))## [1] "\nmensaje[-1] es: "# Letra C
mensaje[3]## [1] NA# Obtener el primer caracter
print(paste("mensaje[1] =>", substr(mensaje, 1, 1)))## [1] "mensaje[1] => C"# Obtener los 4 primeros caracteres
print(paste("mensaje[1] =>", substr(mensaje,1,4)))## [1] "mensaje[1] => Cama"La concatenación de cadenas en RStudio se refiere a la acción de combinar dos o más cadenas de texto en una sola cadena más larga.
Ejemplo:
#Asignamos las cadenas
nombre <- "Benjamin"
apellido <- "Romero"# Concatenación de cadenas
nombre_completo <- paste(nombre, apellido)# Imprimir el resultado
cat("Concatenación:", nombre_completo, "\n")## Concatenación: Benjamin Romero# Asignamos las cadenas
cad1 <- "Hola"
cad2 <- "RStudio"
cad3 <- paste(cad1, cad2, sep = ' ') # Concatenando dos cadenas en Rstudio
cat("La cadena concatenada es:", cad3)## La cadena concatenada es: Hola RStudioSe refieren a las funciones y técnicas que puedes utilizar para manipular y trabajar con cadenas de caracteres (texto) en el entorno de programación R y, por extensión, en RStudio, que es un IDE ( Entorno de Desarrollo Integrado) muy popular para Rstudio.
a.upper(): Devuelve una cadena con mayúsculas.
b.lower(): Devuelve una cadena con minúsculas.
c.capitalize(): Devuelve una cadena poniendo la primera letra en mayúscula.
d.split(): divide una cadena según un separador y devuelve una lista. El separador predeterminado es el espacio en blanco.
f.rstrip(): elimina los caracteres especificados del lado derecho de una cadena. En el caso predeterminado, eliminará los espacios en blanco del lado derecho de una cadena.
g.lstrip(): elimina los caracteres especificados del lado izquierdo de una cadena. En el caso predeterminado, eliminará los espacios en blanco del lado izquierdo de una cadena.
h.len(): Da la longitud de una cadena.
i.replace(): reemplaza la subcadena en una cadena.
j.find(): busca la primera aparición de una subcadena especificada en una cadena.
k.startswith(): Este método comprobará y devolverá ‘True’ si una cadena comienza con una subcadena especificada.
l.endswith(): este método verificará y devolverá ‘True’ si una cadena termina con una subcadena especificada.
ll.isdigit(): Este método comprobará y devolverá “True” si todos los caracteres de la cadena son dígitos.
m.isdecimal(): Este método comprobará y devolverá “True” si todos los caracteres de la cadena son decimales.
n.isalpha(): Este método comprobará y devolverá “True” si todos los caracteres de una cadena son alfabetos.
o.islower(): Este método comprobará y devolverá ‘True’ si la cadena está en minúsculas.
p.isupper(): Este método comprobará y devolverá ‘True’ si la cadena está en mayúsculas.
q.isalnum(): Este método comprobará y devolverá “True” si todos los caracteres de la cadena son alfanuméricos.
Ejemplos:
# Asignamos una cadena
curso = "Programacion en R y Rstudio"# Aplicar toupper para convertir a mayúsculas
cadena_mayusculas <- toupper(curso)# Imprimir el resultado
print(cadena_mayusculas)## [1] "PROGRAMACION EN R Y RSTUDIO"# Aplicar tolower para convertir a minúsculas
cadena_minusculas <- tolower(cadena_mayusculas)# Imprimir el resultado
print(cadena_minusculas)## [1] "programacion en r y rstudio"# Usar strsplit para dividir la cadena por espacios en blanco
resultado <- strsplit(curso, " ")# Imprimir el resultado
print(resultado)## [[1]]
## [1] "Programacion" "en" "R" "y" "Rstudio"# Definir una cadena con espacios en blanco iniciales y finales
cadena <- " Esto es un ejemplo de cadena con espacios en blanco "
# Usar trimws para eliminar espacios en blanco iniciales y finales
cadena_limpia <- trimws(cadena)
# Imprimir la cadena resultante
cat("Cadena original:", cadena, "\n")## Cadena original: Esto es un ejemplo de cadena con espacios en blancocat("Cadena limpia:", cadena_limpia, "\n")## Cadena limpia: Esto es un ejemplo de cadena con espacios en blanco# Definir una cadena
cadena <- "Al que madruga Dios le ayuda"
# Usar nchar para obtener la longitud de la cadena
longitud <- nchar(cadena)
# Imprimir la longitud
cat("La longitud de la cadena es:", longitud, "\n")## La longitud de la cadena es: 28# Definir una cadena
cadena <- "Hola, mundo. Hola, RStudio."
# Utilizar gsub para reemplazar "Hola" por "Saludos"
nueva_cadena <- gsub("Hola", "Saludos", cadena)
# Imprimir la nueva cadena
cat("Cadena original:", cadena, "\n")## Cadena original: Hola, mundo. Hola, RStudio.cat("Nueva cadena:", nueva_cadena, "\n")## Nueva cadena: Saludos, mundo. Saludos, RStudio.# Definir una cadena
cadena <- "Esta es una cadena de ejemplo en RStudio."
# Subcadena que queremos buscar
subcadena_a_buscar <- "cadena"
# Utilizar gregexpr para encontrar la posición de la subcadena
posiciones <- gregexpr(subcadena_a_buscar, cadena)
# Obtener la primera posición de la subcadena
primera_posicion <- posiciones[[1]][1]
# Imprimir la posición y la subcadena encontrada
cat("La primera posición de la subcadena es:", primera_posicion, "\n")## La primera posición de la subcadena es: 13cat("La subcadena encontrada es:", substr(cadena, primera_posicion, primera_posicion + nchar(subcadena_a_buscar) - 1), "\n")## La subcadena encontrada es: cadenaUna lista es una estructura de datos que puede contener elementos de diferentes tipos, como vectores, matrices, marcos de datos, otras listas y objetos de R. Las listas se utilizan para almacenar conjuntos de datos heterogéneos y permiten una gran flexibilidad en la organización y manipulación de datos.
Sin embargo, una lista también es un tipo de secuencia, por lo que admite la indexación (darle un orden). Para crear la lista, necesitamos poner elementos dentro de los corchetes ‘c( )’ separándolos con una coma.
Ejemplo:
mi_lista <- c(4,5,6,7,8)
paises <- c("Peru", "Bolivia", "Argentina")print(paste(mi_lista)) ## [1] "4" "5" "6" "7" "8"print(paste(paises)) ## [1] "Peru" "Bolivia" "Argentina"La lista admite la indexación (comenzando desde 1), por lo que, para acceder a los elementos de una lista de RStudio, usaremos el índice de ese elemento. La lista de RStudio también admite la indexación negativa (A partir de -1, el último elemento de la lista de RSTudio).
Ejemplo:
# Creamos una lista
distritos <- c("San Juan de Miraflores", "Villa EL Salvador", "El Agustino", "Comas")
# Primer y segundo elemento de la lista con indexación positiva:
print(paste("El 1er elemento de la lista es:", distritos[1]))## [1] "El 1er elemento de la lista es: San Juan de Miraflores"print(paste("El 2do elemento de la lista es:", distritos[2]))## [1] "El 2do elemento de la lista es: Villa EL Salvador"# último elemento de la lista @ index => [-1] con índice negativo:
print(paste("El ultimo elemento de la lista es:", distritos[4]))## [1] "El ultimo elemento de la lista es: Comas"Otro ejemplo:
# Creamos otra lista
mi_lista <- list(nombre = "Juan", edades = c(25, 30, 35), es_casado = TRUE)# Acceder al primer elemento de la lista
primer_elemento <- mi_lista[[1]]
# Acceder al segundo elemento de la lista
segundo_elemento <- mi_lista[[2]]# Primer y segundo elemento de la lista con indexación positiva:
print(paste("El 1er elemento de la lista es:", mi_lista[1]))## [1] "El 1er elemento de la lista es: Juan"print(paste("El 2do elemento de la lista es:", mi_lista[2]))## [1] "El 2do elemento de la lista es: c(25, 30, 35)"# Obtener la longitud de la lista
longitud_lista <- length(mi_lista)
# Acceder al último elemento usando la longitud
ultimo_elemento <- mi_lista[[longitud_lista]]
# Imprimir el último elemento
print(ultimo_elemento)## [1] TRUEAgregar elementos a una lista en RStudio implica ampliar la lista existente para incluir nuevos elementos. Puedes hacerlo de varias maneras, dependiendo de si deseas agregar un solo elemento o múltiples elementos a la lista.
Ejemplo:
# Crear una lista
utiles_escolares <- list("Lapiceros","Borrador","Cuadernos","Cartucheras")
# Agregar los elementos de la nueva lista a la lista existente
utiles_escolares <- c(utiles_escolares, "Reglas")
# Verificar la lista actualizada
print(utiles_escolares)## [[1]]
## [1] "Lapiceros"
##
## [[2]]
## [1] "Borrador"
##
## [[3]]
## [1] "Cuadernos"
##
## [[4]]
## [1] "Cartucheras"
##
## [[5]]
## [1] "Reglas"Otro ejemplo:
# Crear otra lista existente
mi_lista <- list("Manzana","Maracuya","Banana")
# Agregar un nuevo elemento a la lista
mi_lista <- append(mi_lista,"Piña")
# Verificar la lista actualizada
print(mi_lista)## [[1]]
## [1] "Manzana"
##
## [[2]]
## [1] "Maracuya"
##
## [[3]]
## [1] "Banana"
##
## [[4]]
## [1] "Piña"1.Concatenacion de listas:La concatenación de listas en RStudio significa combinar o unir dos o más listas en una sola lista. Una lista es una estructura de datos en R que puede contener elementos de diferentes tipos, como números, texto, otras listas u objetos más complejos. Cuando concatenas listas, estás creando una nueva lista que contiene todos los elementos de las listas originales, uno tras otro, en el orden en que se especifican.
Puedes concatenar listas en RStudio utilizando operadores como c()o funciones como append()y list(). Esto es útil cuando deseas combinar datos de diferentes fuentes o realizar operaciones de manipulación de datos.
Ejemplo:
# Crear dos listas
lista1 <- list("a", "b", "c")
lista2 <- list(1, 2, 3)
# Concatenar las listas usando c()
lista_concatenada <- c(lista1, lista2)
# Resultado: una lista con todos los elementos de lista1 y luego lista2
print(lista_concatenada)## [[1]]
## [1] "a"
##
## [[2]]
## [1] "b"
##
## [[3]]
## [1] "c"
##
## [[4]]
## [1] 1
##
## [[5]]
## [1] 2
##
## [[6]]
## [1] 32.Repeticion de listas:La repetición de listas implica duplicar una lista una cierta cantidad de veces. Esto se hace utilizando la función rep(), que toma como argumento la lista que deseas repetir y la cantidad de veces que deseas repetirla. La nueva lista resultante contendrá múltiples copias de la lista original una detrás de la otra.
Ejemplo:
# Crear una lista
mi_lista <- list("m", "n", "o")
# Repetir la lista 3 veces
lista_repetida <- rep(mi_lista, times = 3)
# Resultado: una lista con tres copias de mi_lista
print(lista_repetida)## [[1]]
## [1] "m"
##
## [[2]]
## [1] "n"
##
## [[3]]
## [1] "o"
##
## [[4]]
## [1] "m"
##
## [[5]]
## [1] "n"
##
## [[6]]
## [1] "o"
##
## [[7]]
## [1] "m"
##
## [[8]]
## [1] "n"
##
## [[9]]
## [1] "o"Actualizar una lista en RStudio implica realizar cambios en los elementos existentes de la lista, agregar nuevos elementos o eliminar elementos existentes según sea necesario para actualizar los datos contenidos en esa lista. Las listas en RStudio son estructuras de datos flexibles que pueden contener elementos de diferentes tipos (números, texto, otras listas, etc.), y es común necesitar actualizar o modificar estas listas durante el análisis de datos o la programación.
Ejemplo:
# Crear una lista con algunos elementos
mi_lista <- list("manzana", "banana", "cereza", "uva")
# Ver la lista original
print(mi_lista)## [[1]]
## [1] "manzana"
##
## [[2]]
## [1] "banana"
##
## [[3]]
## [1] "cereza"
##
## [[4]]
## [1] "uva"# Actualizar el tercer elemento (índice 3) a "naranja"
mi_lista[[3]] <- "naranja"
# Ver la lista actualizada
print(mi_lista)## [[1]]
## [1] "manzana"
##
## [[2]]
## [1] "banana"
##
## [[3]]
## [1] "naranja"
##
## [[4]]
## [1] "uva"Podemos eliminar elementos de un vector por medio de índices y el signo menos.
Ejemplo:
numeros <- c(1, 2, 3, 4, 5, 6,7)
posicion <- which(numeros == 7)
numeros <- numeros[-posicion]
print(numeros)## [1] 1 2 3 4 5 6Otro ejemplo:
# pop(index)
longitud <- length(numeros)
valor_eliminado <- numeros[2]
numeros <- numeros[-2]
cat("Lista actualizada:", numeros, "\n")## Lista actualizada: 1 3 4 5 6Para comprobar si un elemento pertenece a una lista en RStudio, puedes utilizar la función %in%, que devuelve un valor lógico (TRUE o FALSE) que indica si el elemento está presente en la lista.
Ejemplo:
# Crear una lista de frutas
frutas <- list("fresa", "durazno", "papaya", "arandanos")
# Comprobar si "fresa" está en la lista
esta_fresa <- "fresa" %in% frutas
# Comprobar si "kiwi" está en la lista
esta_kiwi <- "kiwi" %in% frutas
# Imprimir los resultados
print(esta_fresa) # Debería ser TRUE## [1] TRUEprint(esta_kiwi) # Debería ser FALSE## [1] FALSEOtro ejemplo:
# Crear una lista de marcas de automóviles
marcas_autos <- list("Toyota", "Honda", "Ford", "Chevrolet", "Volkswagen")
# Comprobar si "Toyota" está en la lista de marcas de autos
esta_toyota <- "Toyota" %in% marcas_autos
# Comprobar si "Mercedes-Benz" está en la lista de marcas de autos
esta_mercedes <- "Mercedes-Benz" %in% marcas_autos
# Imprimir los resultados
print(esta_toyota) # Debería ser TRUE## [1] TRUEprint(esta_mercedes) # Debería ser FALSE## [1] FALSEUd. 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: FALSEOrdenar los elementos de una lista en RStudio implica reorganizar los elementos de la lista de acuerdo a un cierto criterio, como ordenarlos alfabéticamente o numéricamente. RStudio ofrece varias funciones y métodos para ordenar listas y vectores. Aquí te muestro cómo hacerlo:
1.Ordenar elementos de una lista alfabéticamente:
Si tienes una lista con elementos de texto y deseas ordenarla alfabéticamente, puedes utilizar la función sort()o order().
Ejemplo:
# Crear una lista desordenada de nombres
nombres <- list("Ana", "Carlos", "Eva", "David", "Beatriz")
# Ordenar la lista alfabéticamente
nombres_ordenados <- sort(unlist(nombres))
# Convertir el resultado ordenado de nuevo a una lista
nombres_ordenados_lista <- list(nombres_ordenados)
# Ver la lista ordenada
print(nombres_ordenados_lista)## [[1]]
## [1] "Ana" "Beatriz" "Carlos" "David" "Eva"2.Ordenar elementos de una lista numéricamente:
Si tienes una lista con elementos numéricos y deseas ordenarla de manera ascendente o descendente, puedes utilizar la función sort()o order().
Ejemplo:
# Crear una lista desordenada de números
numeros <- list(7, 3, 10, 1, 5)
# Ordenar la lista numéricamente en orden ascendente
numeros_ordenados_asc <- sort(unlist(numeros))
# Ordenar la lista numéricamente en orden descendente
numeros_ordenados_desc <- sort(unlist(numeros), decreasing = TRUE)
# Convertir los resultados ordenados de nuevo a listas
numeros_ordenados_asc_lista <- list(numeros_ordenados_asc)
numeros_ordenados_desc_lista <- list(numeros_ordenados_desc)
# Ver las listas ordenadas
print(numeros_ordenados_asc_lista)## [[1]]
## [1] 1 3 5 7 10print(numeros_ordenados_desc_lista)## [[1]]
## [1] 10 7 5 3 1En RStudio, puede obtener la longitud de una lista y contar cuántas veces aparece un elemento específico en la lista utilizando funciones y operaciones específicas. Aquí te explico cómo hacerlo:
a)Longitud de una lista:
La longitud de una lista se refiere al número de elementos que contiene la lista. Para obtener la longitud de una lista en RStudio, puedes usar la función length().
Ejemplo:
# Crear una lista
mi_lista <- list(20, 25, 22, 64, 15, 28,25,30,25)
# Obtener la longitud de la lista
longitud_lista <- length(mi_lista)
# Imprimir la longitud
print(longitud_lista)## [1] 9b)Recuento de un elemento en la lista:
Si deseas contar cuántas veces aparece un elemento específico en una lista, puedes usar la función sum()junto con operadores lógicos.
Ejemplo:
# Crear una lista de frutas
planetas <- list("Tierra", "Marte", "Tierra", "Saturno", "Neptuno","Tierra")
# Definir el elemento que deseas contar
elemento_a_contar <- "Tierra"
# Contar cuántas veces aparece el elemento en la lista
conteo_elemento <- sum(unlist(planetas) == elemento_a_contar)
# Imprimir el conteo
print(conteo_elemento)## [1] 3En RStudio, el “corte de lista” se refiere a la operación de seleccionar un subconjunto de elementos de una lista basado en criterios específicos, como rangos de índices o condiciones lógicas. Esto te permite extraer una porción deseada de una lista para su posterior análisis o manipulación.
Existen varias formas de realizar un corte de lista en RStudio:
1.Corte por índices: Puede seleccionar elementos de una lista utilizando un rango de índices.
Ejemplo:
# Crear una lista
mi_lista <- list("a", "b", "c", "d", "e")
# Realizar un corte para obtener los primeros tres elementos
corte <- mi_lista[1:3]
# Ver el resultado del corte
print(corte)## [[1]]
## [1] "a"
##
## [[2]]
## [1] "b"
##
## [[3]]
## [1] "c"2.Corte por nombres: Si los elementos de la lista tienen nombres, puedes usar los nombres para seleccionar elementos específicos.
Ejemplo:
# Crear una lista con nombres
mi_lista <- list(nombre = "Juan", edad = 30, ciudad = "Nueva York")
# Realizar un corte para obtener el nombre y la edad
corte <- mi_lista[c("nombre", "edad")]
# Ver el resultado del corte
print(corte)## $nombre
## [1] "Juan"
##
## $edad
## [1] 303.Corte por condiciones lógicas: Puedes utilizar condiciones lógicas para filtrar elementos que cumplan ciertos criterios.
Ejemplo:
# Crear una lista de números
numeros <- list(1, 2, 3, 4, 5)
# Realizar un corte para obtener los números mayores que 3
corte <- numeros[numeros > 3]
# Ver el resultado del corte
print(corte)## [[1]]
## [1] 4
##
## [[2]]
## [1] 5En RStudio, puedes convertir cadenas de texto y tuplas en listas utilizando funciones y operaciones específicas de R. A continuación, te mostraré cómo hacerlo:
-Convertir cadenas de texto en una lista:
Puedes convertir una cadena de texto en una lista de caracteres utilizando la función strsplit().
Ejemplo:
# Crear una cadena de texto
cadena <- "Hola, cómo estás?"
# Convertir la cadena en una lista de caracteres
lista_caracteres <- strsplit(cadena, split = "")
# Ver la lista de caracteres
print(lista_caracteres)## [[1]]
## [1] "H" "o" "l" "a" "," " " "c" "ó" "m" "o" " " "e" "s" "t" "á" "s" "?"cat("Tipo de cadena =", class(lista_caracteres), "\n")## Tipo de cadena = list-Convertir tuplas en una lista:
Las tuplas no son una estructura de datos nativa en R, pero puedes representar una tupla como un vector o una lista.
Ejemplo:
# Crear una tupla representada como un vector
tupla <- c("Manzana", 3, TRUE)
# Convertir la tupla en una lista
lista_tupla <- as.list(tupla)
# Ver la lista resultante
print(lista_tupla)## [[1]]
## [1] "Manzana"
##
## [[2]]
## [1] "3"
##
## [[3]]
## [1] "TRUE"En RStudio, las tuplas no son una estructura de datos nativa como en algunos otros lenguajes de programación, como Python. R, en cambio, utiliza principalmente vectores, listas y matrices para almacenar datos y estructurar información. Sin embargo, puedes lograr un comportamiento similar al de una tupla en R al utilizar vectores o listas con nombres o índices adecuados.
Para emular una tupla en R, puedes utilizar un vector o una lista con nombres que actúan como etiquetas o claves para cada valor.
Ejemplo:
# Crear un vector con índices usando la función 'c()'
mi_tupla <- c(nombre = "Juan", edad = 30, ciudad = "Nueva York")
# Acceder a los elementos de la "tupla" por índice
nombre <- mi_tupla["nombre"]
edad <- mi_tupla["edad"]
ciudad <- mi_tupla["ciudad"]
# Imprimir los elementos
print(nombre)## nombre
## "Juan"print(edad)## edad
## "30"print(ciudad)## ciudad
## "Nueva York"Otro ejemplo:
mi_tupla <- list(3,4,5,6,"SEVEN",8)primer_elemento <- mi_tupla[[1]]
print(paste("1er elemento de la lista =", primer_elemento))## [1] "1er elemento de la lista = 3"segundo_elemento <- mi_tupla[[2]]
print(paste("2do elemento de la lista =", segundo_elemento))## [1] "2do elemento de la lista = 4"ultimo_elemento <- mi_tupla[length(mi_tupla)]
print(paste("último elemento de la lista =", ultimo_elemento))## [1] "último elemento de la lista = 8"En R y RStudio, como mencioné anteriormente, no existe una estructura de datos nativa llamada “tupla” como en algunos otros lenguajes de programación, por lo que no puedes agregar elementos a una tupla como lo harías en un lenguaje que admita tuplas inmutables.
Sin embargo, puedes emular una tupla en R utilizando otros tipos de datos, como un vector con índices o una lista, y estos tipos de datos son mutables, lo que significa que puedes agregar elementos a ellos.
Ejemplo:
# Crear una "tupla" simulada utilizando una lista
mi_tupla <- list(nombre = "Benjamin", edad = 23, ciudad = "Lima")
# Imprimir la "tupla" original
print(mi_tupla)## $nombre
## [1] "Benjamin"
##
## $edad
## [1] 23
##
## $ciudad
## [1] "Lima"# Agregar un nuevo elemento a la "tupla"
mi_tupla$profesion <- "Ingeniero"
# Imprimir la "tupla" actualizada
print(mi_tupla)## $nombre
## [1] "Benjamin"
##
## $edad
## [1] 23
##
## $ciudad
## [1] "Lima"
##
## $profesion
## [1] "Ingeniero"# Crear una nueva tupla agregando (4,), tupla con un solo elemento en la tupla inicial
mi_tupla <- c(1,2,3)
# Imprimir la "tupla" original
print(mi_tupla)## [1] 1 2 3# Agregar la nueva tupla (4,) a la "tupla" original
mi_tupla["nueva_tupla"] <- list(4)
# Imprimir la "tupla" actualizada
print(mi_tupla)## [[1]]
## [1] 1
##
## [[2]]
## [1] 2
##
## [[3]]
## [1] 3
##
## $nueva_tupla
## [1] 4# Crear una tupla con un solo elemento
mi_tupla <- list('a')
# Imprimir la tupla
print(mi_tupla)## [[1]]
## [1] "a"En RStudio, la concatenación y repetición de tuplas se realiza de manera similar a como se trabaja con otros tipos de secuencias, como vectores o listas. Sin embargo, es importante recordar que en R no existe una estructura de datos nativa llamada “tupla”. Las tuplas se emulan utilizando vectores o listas. A continuación, te mostraré cómo puedes realizar concatenación y repetición de elementos en una “tupla” simulada utilizando una lista:
a)Concatenación de tuplas simuladas (listas):
Puedes concatenar dos o más “tuplas” simuladas, que son en realidad listas, utilizando la función c()para combinar las listas en una nueva lista.
Ejemplo:
# Crear dos "tuplas" simuladas (listas) con información de marcas de computadoras
marca_computadora1 <- list(nombre = "Apple", año_fundacion = 1976, sede = "Cupertino, California, EE. UU.")
marca_computadora2 <- list(nombre = "Microsoft", año_fundacion = 1975, sede = "Redmond, Washington, EE. UU.")
# Concatenar las "tuplas" simuladas en una nueva lista de marcas de computadoras
marcas_computadoras_concatenadas <- c(marca_computadora1, marca_computadora2)
# Imprimir la lista de marcas de computadoras concatenadas
print(marcas_computadoras_concatenadas)## $nombre
## [1] "Apple"
##
## $año_fundacion
## [1] 1976
##
## $sede
## [1] "Cupertino, California, EE. UU."
##
## $nombre
## [1] "Microsoft"
##
## $año_fundacion
## [1] 1975
##
## $sede
## [1] "Redmond, Washington, EE. UU."b)Repetición de tuplas simuladas (listas):
Para repetir elementos en una “tupla” simulada, puedes utilizar la función rep(). Sin embargo, ten en cuenta que esto repetirá los elementos dentro de una lista y no una “tupla” como tal, ya que las tuplas no se suelen repetir en Rstudio.
Ejemplo:
# Crear una "tupla" simulada (lista) con información de una marca de computadoras
marca_computadora <- list(nombre = "Dell", año_fundacion = 1984, sede = "Round Rock, Texas, EE. UU.")
# Repetir la "tupla" simulada de la marca de computadoras cuatro veces
marcas_computadoras_repetidas <- rep(list(nombre = "Dell", año_fundacion = 1984, sede = "Round Rock, Texas, EE. UU."), times = 4)
# Imprimir la lista de marcas de computadoras repetidas
print(marcas_computadoras_repetidas)## $nombre
## [1] "Dell"
##
## $año_fundacion
## [1] 1984
##
## $sede
## [1] "Round Rock, Texas, EE. UU."
##
## $nombre
## [1] "Dell"
##
## $año_fundacion
## [1] 1984
##
## $sede
## [1] "Round Rock, Texas, EE. UU."
##
## $nombre
## [1] "Dell"
##
## $año_fundacion
## [1] 1984
##
## $sede
## [1] "Round Rock, Texas, EE. UU."
##
## $nombre
## [1] "Dell"
##
## $año_fundacion
## [1] 1984
##
## $sede
## [1] "Round Rock, Texas, EE. UU."Otro ejemplo:
# La mayoría de los operadores de listas también funcionan en tuplas. El operador corchete indexa un elemento:
# Crear una "tupla" simulada (lista) con información de una fruta
tupla_fruta <- list("Manzana", "Naranja", "Plátano", "Pera", "Uva")
# Acceder al segundo elemento por índice (índice 2)
segunda_fruta <- tupla_fruta[2]
# Acceder al cuarto elemento por índice (índice 4)
cuarta_fruta <- tupla_fruta[4]
# Imprimir los elementos
print(segunda_fruta)## [[1]]
## [1] "Naranja"print(cuarta_fruta)## [[1]]
## [1] "Pera"En RStudio, los diccionarios no son una estructura de datos nativa como en algunos otros lenguajes de programación (por ejemplo, en Python). Sin embargo, puedes simular diccionarios utilizando listas con nombres o vectores con nombres. En RStudio, estos se conocen comúnmente como “listas con nombres” o “vectores con nombres”.
Ejemplo:
# Crear un diccionario en R
mi_diccionario <- list("1" = "60%", "2" = "70%", "3" = "30%")
# Imprimir el diccionario
print(mi_diccionario)## $`1`
## [1] "60%"
##
## $`2`
## [1] "70%"
##
## $`3`
## [1] "30%"# 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 70%"# 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 a un diccionario en RStudio implica incluir nuevas claves y sus valores correspondientes en la estructura de datos que estás utilizando para representar el diccionario. Aunque RStudio no tiene una estructura de datos nativa llamada “diccionario”, puedes simularla utilizando listas con nombres o vectores con nombres.
Ejemplos:
# Crear un diccionario simulado
persona <- list(
nombre = "Raul",
edad = 40,
departamento = "Arequipa"
)
# Crear un nuevo diccionario con elementos adicionales
nuevos_elementos <- list(
profesion = "Escritor",
telefono = "123-456-7890"
)
# Agregar los nuevos elementos al diccionario existente utilizando la función `c` o `list`
persona <- c(persona, nuevos_elementos)
# Imprimir el diccionario actualizado
print(persona)## $nombre
## [1] "Raul"
##
## $edad
## [1] 40
##
## $departamento
## [1] "Arequipa"
##
## $profesion
## [1] "Escritor"
##
## $telefono
## [1] "123-456-7890"# 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%"En Rstudio, eliminar elementos de un “diccionario” simulado 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.
Ejemplos:
# Crear un diccionario simulado para representar marcas de bebidas alcohólicas
marcas_bebidas_alcoholicas <- list(
cerveza = "Heineken",
whisky = "Johnnie Walker",
vodka = "Absolut",
ron = "Bacardi",
tequila = "Patrón"
)
# Imprimir el diccionario de marcas de bebidas alcohólicas antes de la eliminación
print(marcas_bebidas_alcoholicas)## $cerveza
## [1] "Heineken"
##
## $whisky
## [1] "Johnnie Walker"
##
## $vodka
## [1] "Absolut"
##
## $ron
## [1] "Bacardi"
##
## $tequila
## [1] "Patrón"# Eliminar una marca de bebida alcohólica (por ejemplo, "vodka")
marcas_bebidas_alcoholicas$vodka <- NULL
# Imprimir el diccionario de marcas de bebidas alcohólicas después de la eliminación
print(marcas_bebidas_alcoholicas)## $cerveza
## [1] "Heineken"
##
## $whisky
## [1] "Johnnie Walker"
##
## $ron
## [1] "Bacardi"
##
## $tequila
## [1] "Patrón"# 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%"Para comprobar si un elemento (clave) pertenece a un diccionario simulado en RStudio, puedes utilizar la función exists()o la operación %in%. Ambas opciones te permitirán verificar si existe una clave específica en el diccionario.
Ejemplos:
# Crear un diccionario simulado para representar marcas de celulares
marcas_celulares <- list(
"Apple" = "iPhone",
"Samsung" = "Galaxy",
"Google" = "Pixel",
"Huawei" = "P40",
"OnePlus" = "8T"
)
# Marca de celular que queremos verificar
marca_a_verificar <- "Samsung"
# Verificar si la marca está en el diccionario
marca_existe <- "Samsung" %in% names(marcas_celulares)
# Imprimir el resultado
print(paste("La marca Samsung está en marcas_celulares:", marca_existe))## [1] "La marca Samsung está en marcas_celulares: TRUE"# 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"Para obtener la lista de todas las claves (o nombres de las claves) de un diccionario simulado en RStudio, que generalmente se implementa utilizando listas con nombres o vectores con nombres, puedes utilizar la función o la función en names()combinación names()con unlist().
Ejemplos:
# Crear un diccionario simulado como una lista con nombres
diccionario <- list(nombre = "Juan", edad = 30, ciudad = "Nueva York", profesion = "Ingeniero")
# Obtener las claves como un vector
claves <- unlist(names(diccionario))
# Imprimir el vector de claves
print(claves)## [1] "nombre" "edad" "ciudad" "profesion"# Obtener una lista de todos los valores
unlist(mi_diccionario)## 1 2 4
## "60%" "50%" "25%"Para obtener la lista de todos los valores de un diccionario simulado en RStudio, que generalmente se implementa utilizando listas con nombres o vectores con nombres, puedes utilizar la función unlist().
Ejemplo:
# Crear un diccionario simulado como una lista con nombres
diccionario <- list(nombre = "Juan", edad = 30, departamento = "Puno", profesion = "Ingeniero")
# Obtener la lista de todos los valores
valores <- unlist(diccionario)
# Imprimir la lista de valores
print(valores)## nombre edad departamento profesion
## "Juan" "30" "Puno" "Ingeniero"En RStudio, como se mencionó anteriormente, no existe una estructura de datos nativa llamada “diccionario” como en otros lenguajes de programación, como Python. Sin embargo, puedes simular diccionarios utilizando listas con nombres o vectores con nombres. Para obtener una lista de tuplas de pares clave-valor de un “diccionario” simulado en RStudio, puedes usar la función as.list()o la función mapply().
Ejemplo:
# 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 en RStudio se refiere al proceso de recorrer y procesar cada elemento (clave y valor) en la estructura de datos que simula un diccionario. En RStudio, los diccionarios generalmente se implementan utilizando listas con nombres o vectores con nombres. La iteración es útil cuando deseas realizar una operación específica en cada par clave-valor del diccionario.
Puedes utilizar bucles for, funciones como lapply()o sapply()incluso operaciones de vectorización para iterar sobre un diccionario en RStudio.
Ejemplos:
# Crear un diccionario simulado como una lista con nombres
diccionario <- list(nombre = "Paul", edad = 40, departamento = "Loreto", profesion = "Agronomo")
# Usar un bucle for para iterar sobre el diccionario e imprimir cada par clave-valor
for (clave in names(diccionario)) {
valor <- diccionario[[clave]]
cat("Clave:", clave, "- Valor:", valor, "\n")
}## Clave: nombre - Valor: Paul
## Clave: edad - Valor: 40
## Clave: departamento - Valor: Loreto
## Clave: profesion - Valor: Agronomo# 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%La conversión de claves y valores iterables en un diccionario en RStudio se refiere al proceso de tomar dos listas o vectores, uno que contiene las claves y otro que contiene los valores, y combinarlos para crear un diccionario (o estructura similar) donde las claves están vinculados a los valores correspondientes.
RStudio no tiene una estructura de datos nativa de diccionario como en algunos otros lenguajes de programación (como Python), pero puedes simularla utilizando listas con nombres o vectores con nombres.
Ejemplos:
# Crear una lista de claves
claves <- c("nombre", "edad", "departamento", "Codigo del alumno")
# Crear una lista de valores
valores <- c("Renzo", 24, "Ica", "21140080")
# Crear un diccionario simulado combinando las claves y valores
diccionario <- setNames(valores, claves)
# Imprimir el diccionario simulado
print(diccionario)## nombre edad departamento Codigo del alumno
## "Renzo" "24" "Ica" "21140080"# 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%"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] 2500print(distribucion)## $Boston
## [1] 6000
##
## $Chicago
## [1] 4000
##
## $SanLuis
## [1] 2000
##
## $Lexington
## [1] 1500print(costos)## Cleveland Bedford York
## Boston 3 7 2
## Chicago 2 5 5
## SanLuis 7 2 4
## Lexington 6 3 5