Programación orientada a objetos

Author

Erik Chávez Altamirano

R y Rstudio

R se presentó al mercado en 1993 de la mano de sus creadores Robert Gentleman y Ross Ihaka, que desarrollaron la herramienta en el Departamento de Estadística de la Universidad de Auckland. Sin embargo la base de sus orígenes se encuentra en el desarrollo del lenguaje S.R es un leguaje de programación especializado para análisis de datos. Es de fuente abierta (Open Source) y uso gratuito. Rstudio es un editor de R que también de uso sin cargo. Ambas herramientas están disponibles en internet y son de amplio uso tanto en el mundo académico como la industria.

Se puede descargar e instalar R accediendo a esta URL: https://cran.r-project.org/mirrors.html.

Para Rstudio la URL es: https://www.rstudio.com/products/rstudio/download/#download.

Se recomienda siempre instalar R primero y luego Rstudio ya que este depende de aquel.

Palabras reservadas

Las palabras reservadas se refieren a un conjunto específico de palabras que tienen un significado predefinido en el lenguaje de programación R. Estas palabras reservadas están destinadas a realizar funciones específicas en el código y no pueden ser utilizadas como nombres de variables, funciones u objetos en tu programa. Utilizar una palabra reservada como un nombre de variable o función generará un error en tu código.

Aquí hay algunas palabras reservadas comunes en R:

  • if: Se utiliza para realizar una condición y ejecutar un bloque de código si la condición es verdadera.

  • else: Se utiliza junto con if para especificar un bloque de código que se ejecutará si la condición en el if es falsa.

  • for: Se utiliza para crear bucles for que recorren una secuencia de valores.

  • while: Se utiliza para crear bucles while que ejecutan un bloque de código mientras una condición sea verdadera.

  • function: Se utiliza para definir funciones personalizadas en R.

  • return: Se utiliza dentro de una función para devolver un valor específico como resultado de la función.

  • repeat: Se utiliza para crear un bucle repeat que ejecuta un bloque de código indefinidamente hasta que se use una declaración break para salir del bucle.

  • break: Se utiliza dentro de un bucle repeat para salir de él.

  • next: Se utiliza dentro de un bucle para pasar a la siguiente iteración del bucle.

  • NULL: Representa un valor nulo en R.

  • NA: Representa un valor ausente o no disponible en R.

Es importante recordar que estas palabras reservadas están escritas en minúsculas en R y son parte integral de la sintaxis del lenguaje. Si intentas usar una palabra reservada como un nombre de variable o función, recibirás un error en tu código. Por lo tanto, es recomendable evitar usar palabras reservadas como nombres de identificadores en tus programas en R.

Ejemplos:

#if, else, for, while, function, return, repeat, break, next, NULL, NA

Variables y Tipos

Una variable permite asociar un valor u objeto a un identificador. En la memoria del ordenador habrá una zona donde se almacena el objeto asociado a la variable.

Para crear una variable en R hay que asignarle un valor mediante una operación llamada asignación. La asignación consta de tres elementos:

  1. el identificador o nombre de la variable.
  2. el operador de asignación una expresión que produce.
  3. el valor a asignar.

Vamos a ver un ejemplo:

x <- 10

Aquí la variable tiene el nombre x, el operador de asignación está compuesto por los caracteres < y - escritos juntos (<-). Por último, la expresión es el valor 10. A partir de ahora, la variable x tiene asociado el valor 10

Reglas para definir el nombre de una variable

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

  • Pueden ser una combinación de letras, dígitos, punto (.) y subrayado (_).

  • Deben comenzar por una letra o punto. Si comienzan con punto, el siguiente carácter no puede ser un dígito.

  • Las palabras reservadas de R, como if o for no pueden usarse como identificadores. (Ejecuta ?Reserved para consultar las palabras reservadas).

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

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

Operadores matemáticos

Los operadores matemáticos son herramientas esenciales en RStudio para realizar cálculos y manipulación de datos. En este documento, exploraremos algunos de los operadores matemáticos más comunes en R.

Operador Descripción Ejemplo
+ Suma 5 + 3
- Resta 10 - 7
* Multiplicación 6 * 4
/ División 15 / 3
^ Potencia 2 ^ 3
%% Módulo (residuo de la división) 17 %% 4

Estos operadores se utilizan para realizar operaciones matemáticas básicas en R. Puedes copiar y pegar esta tabla en tu documento R Markdown para tener una referencia rápida de los operadores matemáticos.

Operadores relacionales

Los operadores de relación, también conocidos como operadores de comparación, se utilizan en R y en muchos otros lenguajes de programación para comparar dos valores y determinar si una cierta relación es verdadera o falsa. Estos operadores son fundamentales para la toma de decisiones en programación, ya que permiten evaluar condiciones y controlar el flujo del programa en función de los resultados de estas comparaciones.

A continuación, te presento los operadores de relación más comunes en R junto con una tabla que muestra su uso y ejemplos:

Operador Descripción Ejemplo Resultado
== Igual a 5 == 5 TRUE
!= Diferente de 5 != 3 TRUE
< Menor que 4 < 7 TRUE
> Mayor que 6 > 3 TRUE
<= Menor o igual que 3 <= 3 TRUE
>= Mayor o igual que 5 >= 7 FALSE

Estos operadores se utilizan para comparar valores y devuelven un resultado lógico, que es TRUE (verdadero) o FALSE (falso), dependiendo de si la relación especificada es verdadera o falsa. Por ejemplo, en la expresión 5 == 5, el operador == compara si 5 es igual a 5, y dado que esto es cierto, el resultado es TRUE.

Puedes usar estos operadores de relación en condiciones, bucles y otras estructuras de control de flujo para tomar decisiones en tu programa en función de las comparaciones que realices.

# Verificar si dos números son iguales
a <- 5
b <- 5
a == b
[1] TRUE
# Verificar si dos números son diferentes
x <- 7
y <- 3
x != y
[1] TRUE
# Verificar si un número es menor que otro
m <- 4
n <- 8
m < n
[1] TRUE
# Verificar si un número es mayor que otro
p <- 10
q <- 3
p > q
[1] TRUE
# Verificar si un número es menor o igual que otro
r <- 5
s <- 5
r <= s
[1] TRUE
# Verificar si un número es mayor o igual que otro
u <- 6
v <- 6
u >= v
[1] TRUE

Operadores de asignación

El operador de asignación en R se utiliza para asignar un valor a una variable. El operador más comúnmente utilizado para la asignación en R es <-, aunque también puedes usar = con fines de asignación. Aquí está una tabla que muestra el operador de asignación y ejemplos de cómo se utiliza:

Operador Descripción Ejemplo
<- Asigna un valor a una variable x <- 5
= Asigna un valor a una variable y = 10

En estos ejemplos, se asigna el valor 5 a la variable x usando <- y el valor 10 a la variable y usando =. Ambos operadores de asignación son equivalentes en R, por lo que puedes elegir cuál usar según tu preferencia personal.

Además de estos operadores de asignación básicos, R también admite otros operadores de asignación especiales que son útiles en situaciones específicas, como <<- para asignaciones en entornos anidados y %<>% para operaciones de asignación y transformación de datos en un solo paso.

Es importante recordar que en R, las variables se asignan por valor, lo que significa que el valor se copia en la variable en lugar de referenciar la ubicación de la memoria original. Esto puede afectar cómo se manejan las variables en R en comparación con otros lenguajes de programación.

# Usando el operador '<-' para asignar un valor a una variable
x <- 5
y <- 10
# Usando el operador '=' para asignar un valor a una variable
a = 7
b = 3

Operadores lógicos

Los operadores lógicos en R se utilizan para realizar operaciones de lógica booleana en valores lógicos (VERDADERO o FALSO). Estos operadores son fundamentales para tomar decisiones basadas en condiciones en la programación. Aquí están los operadores lógicos más comunes en R junto con una tabla que muestra su uso y ejemplos:

Operador Descripción Ejemplo Resultado
! Negación (NO) !TRUE FALSE
& Conjunción (Y) TRUE & FALSE FALSE
| Disyunción (O) TRUE | FALSE TRUE
xor Disyunción exclusiva (XOR) TRUE xor FALSE TRUE
&& Conjunción de cortocircuito (Y) TRUE && FALSE FALSE
|| Disyunción de cortocircuito (O) TRUE || FALSE TRUE
%in% Pertenece a (en vectores) 2 %in% c(1, 2, 3) TRUE
isTRUE Verifica si un valor es VERDADERO isTRUE(FALSE) FALSE

Estos operadores lógicos se utilizan para combinar, negar y evaluar condiciones en R. A continuación, algunos ejemplos de uso:

  • El operador ! se utiliza para negar un valor lógico. Por ejemplo, !TRUE es igual a FALSE.

  • Los operadores & y | se utilizan para realizar operaciones de conjunción y disyunción lógica. Por ejemplo, TRUE & FALSE es igual a FALSE porque ambas condiciones deben ser VERDADERAS para que el resultado sea VERDADERO.

  • El operador xor realiza una disyunción exclusiva, lo que significa que el resultado es VERDADERO solo cuando una de las condiciones es VERDADERA, pero no ambas.

  • Los operadores && y || son versiones de cortocircuito de la conjunción y disyunción. Realizan una evaluación perezosa, lo que significa que detienen la evaluación tan pronto como se conoce el resultado. Esto puede ser útil en situaciones de evaluación condicional.

  • El operador %in% se utiliza para verificar si un valor está contenido en un vector. Por ejemplo, 2 %in% c(1, 2, 3) es igual a TRUE porque 2 está en el vector c(1, 2, 3).

  • La función isTRUE se utiliza para verificar si un valor es VERDADERO o FALSO. Puede ser útil para validar valores lógicos en situaciones donde el valor podría no ser estrictamente TRUE o FALSE. Por ejemplo, isTRUE(FALSE) es igual a FALSE.

Estos operadores lógicos son fundamentales para la programación en R, ya que permiten controlar el flujo del programa y tomar decisiones basadas en condiciones.

#Ejemplo
a <- TRUE
b <- FALSE
# Negación de una variable
negacion_a <- !a
negacion_b <- !b

print(negacion_a)
[1] FALSE
print(negacion_b)
[1] TRUE
# Conjunción lógica
conjuncion_resultado <- a & b

print(conjuncion_resultado)
[1] FALSE
# Disyunción lógica
disyuncion_resultado <- a | b

print(disyuncion_resultado)
[1] TRUE
# Disyunción exclusiva
disyuncion_exclusiva_resultado <- xor(a, b)

print(disyuncion_exclusiva_resultado)
[1] TRUE
# Conjunción de cortocircuito
conjuncion_cortocircuito_resultado <- a && b

print(conjuncion_cortocircuito_resultado)
[1] FALSE
# Disyunción de cortocircuito
disyuncion_cortocircuito_resultado <- a || b

print(disyuncion_cortocircuito_resultado)
[1] TRUE

Tipos de datos integrados

En R Studio, hay varios tipos de datos integrados que se utilizan para representar diferentes tipos de información. A continuación, te proporciono una descripción de algunos de los tipos de datos más comunes y cómo puedes realizar la conversión entre ellos

Is Numeric

Los números representan valores numéricos, ya sean enteros o decimales.

numero_entero <- 42
numero_decimal <- 3.14

class(numero_entero)
[1] "numeric"
class(numero_decimal)
[1] "numeric"

Caracteres (Character) Los caracteres representan texto y se encierran en comillas simples o dobles.

texto_simple <- 'Hola, mundo!'
texto_doble <- "Nombre"

class(texto_simple)
[1] "character"
class(texto_doble)
[1] "character"

Factores (Factor) Los factores representan variables categóricas con niveles que representan las categorías.

factor_categorias <- factor(c("Bajo", "Medio", "Alto", "Bajo"))

class(factor_categorias)
[1] "factor"

Vectores (Vector) Los vectores son conjuntos ordenados de elementos del mismo tipo de datos.

vector_numerico <- c(1, 2, 3, 4, 5)
vector_caracter <- c("manzana", "banana", "cereza")

class(vector_numerico)
[1] "numeric"
class(vector_caracter)
[1] "character"

Listas (List) Las listas son contenedores de datos heterogéneos.

lista_heterogenea <- list(nombre = "Juan", edad = 30, casado = TRUE)

class(lista_heterogenea)
[1] "list"

Matrices (Matrix) Las matrices son arreglos bidimensionales con elementos del mismo tipo de datos.

matriz_ejemplo <- matrix(c(1, 2, 3, 4), nrow = 2, ncol = 2)

class(matriz_ejemplo)
[1] "matrix" "array"

Data Frames (DataFrame) Los Data Frames son estructuras de datos tabulares.

data_frame_ejemplo <- data.frame(
  Nombre = c("Juan", "Ana"),
  Edad = c(30, 25),
  Casado = c(TRUE, FALSE)
)

class(data_frame_ejemplo)
[1] "data.frame"

Lógicos (Logical) Los valores lógicos representan TRUE (verdadero) o FALSE (falso).

valor_verdadero <- TRUE
valor_falso <- FALSE

class(valor_verdadero)
[1] "logical"
class(valor_falso)
[1] "logical"

Complejos (Complex) Los números complejos tienen una parte real e imaginaria.

numero_complejo <- 1 + 2i

class(numero_complejo)
[1] "complex"

Conversión de tipos o conversión de tipos

La conversión de tipos, también conocida como “casting” en algunos lenguajes de programación, es el proceso de cambiar un valor de un tipo de datos a otro. En R, puedes encontrarte con la necesidad de convertir tipos de datos por diversas razones, como realizar operaciones matemáticas, comparar valores o preparar datos para su visualización. Aquí hay una descripción general de cómo se realiza la conversión de tipos en R:

  1. Funciones de Conversión: R proporciona un conjunto de funciones específicas para realizar conversiones de tipos. Algunas de las funciones de conversión más comunes son:
  • as.numeric(): Convierte un valor a un tipo numérico (doble precisión).
  • as.integer(): Convierte un valor a un tipo entero.
  • as.character(): Convierte un valor a un tipo de caracter.
  • as.logical(): Convierte un valor a un tipo lógico (TRUE o FALSE).
  • as.factor(): Convierte un valor a un factor (útil para variables categóricas).

  1. Automática o Implícita: En muchas situaciones, R realiza conversiones de tipos de forma automática o implícita. Por ejemplo, cuando realizas operaciones matemáticas con diferentes tipos de datos, R convertirá los valores automáticamente para que sean compatibles. Sin embargo, es importante entender cómo se realiza esta conversión implícita, ya que puede llevar a resultados inesperados en algunos casos.

  2. Controlando la Conversión: Puedes controlar la conversión de tipos utilizando funciones de conversión explícita, como las mencionadas anteriormente. Esto te permite asegurarte de que los datos se conviertan de la manera que desees.

  3. Manejo de Errores: En algunos casos, la conversión de tipos puede generar errores si los valores no son compatibles. Por ejemplo, intentar convertir un texto que no representa un número en un tipo numérico generará un error. Por lo tanto, es importante manejar los posibles errores de conversión utilizando bloques tryCatch() u otras técnicas de manejo de errores.

Ejemplo de conversión de tipos en R:

# Conversión explícita de tipos
texto <- "42"
numero <- as.numeric(texto)
class(numero)  # Devolverá "numeric"
[1] "numeric"
# Conversión implícita de tipos
x <- 5
y <- 2
resultado <- x / y  # R realiza una conversión implícita de tipos
class(resultado)   # Devolverá "numeric"
[1] "numeric"

En resumen, la conversión de tipos es un proceso común en la programación en R, y es importante entender cómo se realiza y cómo controlarla para garantizar que los datos se manejen de manera adecuada y se eviten errores inesperados.

Cadenas de carácteres

En temas previos ya hemos trabajado con tipos de datos básicos como números y valores lógicos. Las cadenas de caracteres también son un tipo de dato básico. Consisten en una secuencia de caracteres y sirven para representar información de tipo texto, como el nombre de una persona, el nombre de una calle, una matrícula de un coche, etcétera.

En R una cadena de caracteres se representa como una serie de caracteres encerradas entre comillas dobles o simples:

nombre <- "Diego"        # usando comillas dobles
matricula <- '1234 ABC'  # usando comillas simplesç

Independientemente de que usemos comillas dobles o simples, R nos mostrará la cadena en la consola con comillas dobles o sin ningún tipo de entrecomillado, pero nunca con comillas simples.

Si es necesario usar un tipo de comillas en una cadena de caracteres, podemos usar el otro tipo de comillas para delimitar la cadena:

'Me dijo: "detente"'
[1] "Me dijo: \"detente\""
## [1] "Me dijo: \"detente\""
"Me dijo: 'detente'"
[1] "Me dijo: 'detente'"
## [1] "Me dijo: 'detente'"

Otra posibilidad es usar una secuencia de escape con el carácter de escape :

"Me dijo: \"detente\""
[1] "Me dijo: \"detente\""
## [1] "Me dijo: \"detente\""

Otras secuencias de escape muy utilizas son: \ (barra invertida), (salto de línea) y tabulador).

Existen funciones como paste, paste0 o substr que permiten trabajar con cadenas de caracteres, aunque no las vamos a estudiar aquí. Estas funciones son muy versátiles y, dependiendo de cómo se invoquen, son capaces de realizar distintos procesamientos. Por ejemplo, con paste se puede obtener una cadena de caracteres mezclando información de tipo texto con numérica, trabajando de una forma parecida a cat.

ang <- 0
cadena <- paste("El coseno de", ang, "vale", cos(ang))
cadena
[1] "El coseno de 0 vale 1"
## [1] "El coseno de 0 vale 1"

Accediendo a componentes de catena

En RStudio, puedes acceder a componentes de una cadena (texto) utilizando índices y funciones específicas. Aquí te mostraré cómo hacerlo:

Acceder a caracteres individuales:

Puedes acceder a caracteres individuales dentro de una cadena utilizando corchetes [ ] y especificando el índice del carácter que deseas obtener. Los índices comienzan en 1 en R.

cadena <- "Hola, mundo!"
primer_caracter <- cadena[1]  # Accede al primer carácter
segundo_caracter <- cadena[5]  # Accede al quinto carácter

print(primer_caracter)  # Esto mostrará "H"
[1] "Hola, mundo!"
print(segundo_caracter) # Esto mostrará ","
[1] NA
Acceder a subcadenas (slicing):

Puedes obtener una subcadena de una cadena más grande utilizando una combinación de corchetes [ ] y dos índices separados por :. El primer índice indica el inicio de la subcadena, y el segundo índice (opcional) indica el final. Por ejemplo:

cadena <- "Hola, mundo!"
subcadena <- cadena[1:4]   # Obtiene los primeros cuatro caracteres
subcadena2 <- cadena[7:11] # Obtiene los caracteres desde el séptimo al undécimo

print(subcadena)  # Esto mostrará "Hola"
[1] "Hola, mundo!" NA             NA             NA            
print(subcadena2) # Esto mostrará "mundo"
[1] NA NA NA NA NA
Funciones para trabajar con cadenas:

R ofrece varias funciones que te permiten realizar diversas operaciones en cadenas:

  • nchar(): Devuelve la longitud (número de caracteres) de una cadena.
  • substring(): Permite extraer una subcadena a partir de una cadena dada.
  • paste(): Concatena múltiples cadenas en una sola.
  • toupper() y tolower(): Convierten una cadena a mayúsculas o minúsculas, respectivamente.
cadena <- "¡Hola, mundo!"
longitud <- nchar(cadena)  # Obtiene la longitud de la cadena
subcadena <- substring(cadena, 1, 4)  # Obtiene "¡Hol"
concatenacion <- paste("Hola", "mundo")  # Concatena dos cadenas
mayusculas <- toupper(cadena)  # Convierte a mayúsculas

print(longitud)     # Esto mostrará 13
[1] 13
print(subcadena)   # Esto mostrará "¡Hol"
[1] "¡Hol"
print(concatenacion) # Esto mostrará "Hola mundo"
[1] "Hola mundo"
print(mayusculas)   # Esto mostrará "¡HOLA, MUNDO!"
[1] "¡HOLA, MUNDO!"

Concatenación de cadenas

La concatenación de cadenas es el proceso de unir varias cadenas de texto en una sola cadena más larga. En RStudio, puedes realizar la concatenación de cadenas de varias formas. Aquí te muestro las principales:

Operador paste():

La función paste() se utiliza para concatenar cadenas de texto. Puedes pasar múltiples argumentos a paste(), y se unirán en orden. Puedes especificar un separador opcional para separar las cadenas concatenadas. Aquí tienes ejemplos:

palabra1 <- "Hola"
palabra2 <- "mundo"
resultado <- paste(palabra1, palabra2) # Concatenación simple
resultado_con_separador <- paste(palabra1, palabra2, sep = ", ") # Con separador

print(resultado) # Esto mostrará "Hola mundo"
[1] "Hola mundo"
print(resultado_con_separador) # Esto mostrará "Hola, mundo"
[1] "Hola, mundo"
Operador de concatenación c():

Puedes utilizar el operador de concatenación c() para unir múltiples cadenas en un vector de caracteres. Este operador también se usa para concatenar otros tipos de datos, pero en el contexto de cadenas, se utiliza para crear un vector de caracteres con las cadenas especificadas.

cadena1 <- "Hola"
cadena2 <- "mundo"
vector_concatenado <- c(cadena1, cadena2)

print(vector_concatenado) # Esto mostrará "Hola" "mundo"
[1] "Hola"  "mundo"
Usando el operador paste0():

La función paste0() es una variante de paste() que no agrega ningún separador entre las cadenas concatenadas. Es útil cuando solo deseas unir cadenas sin espacio ni ningún otro carácter intermedio:

palabra1 <- "Hola"
palabra2 <- "mundo"
resultado <- paste0(palabra1, palabra2) # Concatenación sin separador

print(resultado) # Esto mostrará "Holamundo"
[1] "Holamundo"
Usando el operador de concatenación paste() con el argumento collapse:

Si tienes un vector de cadenas y deseas unirlas en una sola cadena, puedes usar paste() con el argumento collapse. Esto es útil cuando deseas unir elementos de un vector en una única cadena de texto:

vector_de_palabras <- c("Hola", "a", "todos")
cadena_concatenada <- paste(vector_de_palabras, collapse = " ")

print(cadena_concatenada) # Esto mostrará "Hola a todos"
[1] "Hola a todos"

La elección de la forma de concatenación depende de tus necesidades específicas. La función paste() es versátil y te permite personalizar la concatenación según tus requisitos. La concatenación de cadenas es una operación común en el procesamiento de datos y análisis de texto en RStudio.

Operaciones de cadena y métodos integrados

En RStudio, puedes realizar una variedad de operaciones en cadenas de texto (strings) y aprovechar los métodos integrados para manipular y procesar cadenas de manera eficiente.

# 1. Longitud de una cadena (nchar()):

cadena <- "Hola, mundo!"
longitud <- nchar(cadena)
print(longitud)  # Esto mostrará 13
[1] 12
# 2. Extracción de subcadenas (substring()):

cadena <- "Hola, mundo!"
subcadena <- substring(cadena, first = 1, last = 3)
print(subcadena) #Esto mostrará Hola
[1] "Hol"
# 3. Conversión de mayúsculas y minúsculas (toupper() y tolower()):

cadena <- "Hola, Mundo!"
mayusculas <- toupper(cadena)
minusculas <- tolower(cadena)

print(mayusculas)  # Esto mostrará "HOLA, MUNDO!"
[1] "HOLA, MUNDO!"
print(minusculas)  # Esto mostrará "hola, mundo!"
[1] "hola, mundo!"
# 4. Reemplazo de texto (gsub()):

cadena <- "Hola, mundo!"
nueva_cadena <- gsub("mundo", "RStudio", cadena)
print(nueva_cadena)  # Esto mostrará "Hola, RStudio!"
[1] "Hola, RStudio!"
# 5. División de cadenas (strsplit()):

cadena <- "manzana,banana,cereza"
subcadenas <- strsplit(cadena, split = ",")
print(subcadenas)  # Esto mostrará una lista con las subcadenas ["manzana", "banana", "cereza"]
[[1]]
[1] "manzana" "banana"  "cereza" 
# 6. Concatenación de cadenas (paste() y paste0()):

palabra1 <- "Hola"
palabra2 <- "mundo"
resultado <- paste(palabra1, palabra2)  # Concatenación simple
resultado_con_separador <- paste(palabra1, palabra2, sep = ", ")  # Con separador

print(resultado)  # Esto mostrará "Hola mundo"
[1] "Hola mundo"
print(resultado_con_separador)  # Esto mostrará "Hola, mundo"
[1] "Hola, mundo"
# 7. Búsqueda de patrones (grep() y grepl()):

cadena <- "El número de teléfono es 555-123-4567."
patron <- "\\d+"  # Patrón para buscar números

indices_coincidencias <- grep(patron, cadena)
print(indices_coincidencias)  # Esto mostrará 6, 8, 9, 10, 11, 12, 13, 14, 15
[1] 1

Vectores

Definición y propiedades

Un vector es es una colección de uno o más datos del mismo tipo y tiene tres propiedades:

  1. Tipo. Un vector tiene el mismo tipo que los datos que contiene. Los vectores son atómicos, pues sólo pueden contener datos de un sólo tipo, no es posible mezclar datos de tipos diferentes dentro de ellos. Puede consultarse la proxima sección, en lo que se refiere a la jerarquía de los vectores.

  2. Largo. Es el número de elementos del vector. Es la única dimensión que tiene esta estructura de datos.

  3. Atributos. Un atributo es una parte de informacion que se puede adjuntar a un vector atómico o cualquier objeto de R. El atributo no afectara a ningún valor del objeto. Podríamos denominar a los atributos como metadata. Los atributos mas comunes de un vector atómico son los nombres, las dimensiones y las clases.

Jerarquía de los vectores

La jerarquía es la siguiente:

Logical < Integer < Numeric < Complex < Character

Por ejemplo, si el vector contiene un elemento caracter considerará a los otros elementos como caracteres.

Crear vectores

Todos los objetos anteriores que hemos estado manipulando son vectores de longitud 1. Hay varias maneras de crear objetos que sean vectores con múltiples entradas.

Concatenando

Utilizar la función c (que significa concatenar). El vector de abajo es un ejemplo de tipo numérico (por eso, sale TRUE en el ejemplo de abajo).

v <- c(15, 10, 41, 18, 32, 10, 56, 20)  #J) Un vector
is.integer(v)      #Sale FALSE
[1] FALSE
is.numeric(v)      #Sale TRUE
[1] TRUE
is.logical(v)      #Sale FALSE   
[1] FALSE
is.character(v)    #Sale FALSE
[1] FALSE
is.complex(v)      #Sale FALSE
[1] FALSE

El siguiente vector es un ejemplo de uno de tipo character (por eso, sale TRUE en el ejemplo de abajo), porque existe una jerarquía de elementos.

v<- c(12, "azul", 2+1i, pi)  #K) Vector de tipo caracter
is.integer(v)      #Sale FALSE
[1] FALSE
is.numeric(v)      #Sale FALSE
[1] FALSE
is.logical(v)      #Sale FALSE   
[1] FALSE
is.character(v)    #Sale TRUE
[1] TRUE
is.complex(v)      #Sale FALSE
[1] FALSE

###Con elementos consecutivos Utilizando la función : (dos puntos). Ejemplo:

3:6       #M) Números consecutivos desde 3 hasta 6. Sale: 3 4 5 6
[1] 3 4 5 6

Vectores con patrones: rep

Sintaxis general

La función rep significa repetición. Tiene la sintaxis:

#rep(elemento, veces)

Ejemplos:

rep(3,4)          #N) Repetir el 3 cuatro veces. Sale: 3 3 3 3
[1] 3 3 3 3
rep("Mujer",2)    #L) Repetir "Mujer" cinco veces: Sale: "Mujer" "Mujer"
[1] "Mujer" "Mujer"

Sintaxis con time() o each()

Este comando también puede repetir vectores. Para lo cual usa la siguiente sintaxis:

#rep("vector", "time" o "each")

La condición time se usa cuando se quiere repetir el vector un número determinado de veces y each cuando se requiere repetir los elementos del vector.

A <- 1:2
rep(A, time=3)        #O) Repetir el vector A tres veces. Sale: 1 2 1 2 1 2
[1] 1 2 1 2 1 2
rep(A, each=3)        #P) Repetir elementos del vector A tres veces: 1 1 1 2 2 2
[1] 1 1 1 2 2 2
rep(A, each=2,time=2) #Q) Elementos de A tres veces; nuevo vector, dos: 1 1 2 2 1 1 2 2
[1] 1 1 2 2 1 1 2 2

Sintaxis con c()

Para repetir arbitrariamente los elementos del vector, se usa el comando concatenar c y se indica la veces que se desea repetir cada elemento del vector.

rep(A, c(3,2))   #R) Primer elemento de A tres veces y el segundo, cuatro: 1 1 1 2 2 
[1] 1 1 1 2 2

Vectores con patrones: seq

Sintaxis general

La función seq significa secuencia. Tiene los argumentos from, to, by y length.out que se pueden combinar de acuerdo a lo que se necesite. La sintaxis geenral es:

#seq(from="inicio", to="final")

Ejemplos de secuencias:

seq(from = 3, to = 6)   #A) Secuencia consecutiva de 3 a 6. Sale: 3 4 5 6
[1] 3 4 5 6
seq(3, 6)               #B) Sale igual que el anterior
[1] 3 4 5 6

Sintaxis con by

La opción by es el comando en donde se tendrá que indicar la razón aritmética (que puede ser positiva o negativa). Cuando la razón es negativa, el número inicial debe ser mayor que el número final.

seq(7, 10, by = 1)     #C) Desde 7 a 10, aumentando de 1 en 1. Sale:  7  8  9 10
[1]  7  8  9 10
seq(10, 2, by = -2)    #D) Desde 10 a 2, disminuyendo de 2 en 2. Sale: 10  8  6  4  2
[1] 10  8  6  4  2

Sintaxis con c()

Para concatenar elementos, como se explicó antes, se usa el comando c y se puede aplicar también en secuencias.

A <- seq(2, 6, by=2)  #F) Secuencia 2 4 6 
c(A, 3)               #G) Sale: 2 4 6 3
[1] 2 4 6 3
c(1,A, 7)             #H) Sale: 1 2 4 6 7
[1] 1 2 4 6 7

Indexar vectores

A veces no queremos todo el vector, sino solo una parte de él. Esto se puede llevar a cabo con el operador corchete []. Ejemplo:

B <- c(15, 10, 41, 18, 32)
B[2]              #F) Solo valor en segunda posición de B. Sale: 10
[1] 10
B[3:4]            #G) Solo valores en posiciones 3 y 4. Sale:  41 18 
[1] 41 18
B[c(1, 3, 5)]     #H) Solo valores en posiciones 1, 3, 4 y 8  de B. Sale: 15 41 32
[1] 15 41 32
B[-c(1, 3, 5)]    #I) Quitar valores en posiciones 1, 3, 4 y 8  de B. Sale: 10 18
[1] 10 18
LETTERS[2:3]      #J) Solo letras mayúsculas en posiciones 2, y 3. Sale: "B" "C" 
[1] "B" "C"
letters[-(2:25)]  #K) Solo dejar la primera y la última letra minúscula. Sale: "a" "z"
[1] "a" "z"

Listas

Una lista en R es un objeto cuyas entradas pueden ser números, vectores y/o data.frame’s. Por ejemplo, cremos una lista que almacene en sus dos primeras entradas, dos vectores, y que en la siguiente entrada genere un data.frame cuyas columnas sean tales vectores.

rm(list = ls())
set.seed(1987)
x <- runif(10,2,5)  # generamos 10 numeros aleatorios uniformes entre [2,5]
y <- rnorm(10,15,3) # generamos 10 numeros aleatorios normales de media 15 y desviacion estandar de 3
lista <- list(a=x, b=y, c=data.frame(x,y))

Existen varias formas equivalentes de llamar a un elemento de una lista:

lista$a
 [1] 2.296293 4.415145 3.822722 3.148497 4.993411 4.977279 3.148723 2.698193
 [9] 3.789526 3.037013
lista[[1]]
 [1] 2.296293 4.415145 3.822722 3.148497 4.993411 4.977279 3.148723 2.698193
 [9] 3.789526 3.037013
lista$c
          x         y
1  2.296293 15.805805
2  4.415145 16.733891
3  3.822722 13.400677
4  3.148497 11.728232
5  4.993411 17.723527
6  4.977279 13.470132
7  3.148723 15.317252
8  2.698193 14.981638
9  3.789526  9.847181
10 3.037013 16.344272
lista[[3]]
          x         y
1  2.296293 15.805805
2  4.415145 16.733891
3  3.822722 13.400677
4  3.148497 11.728232
5  4.993411 17.723527
6  4.977279 13.470132
7  3.148723 15.317252
8  2.698193 14.981638
9  3.789526  9.847181
10 3.037013 16.344272
lista$b[5]
[1] 17.72353
lista[[2]][5]
[1] 17.72353

Podemos crear listas vacías y llenarlas a través de un for. Por ejemplo, podemos llenar en cada elemento de una lista, un vector aleatorio de diferentes dimensiones, como se ilustra a continuación:

rm(list = ls())
set.seed(1987)
lista2 <- list()
n <- 10
for (i in 1:n) {
  lista2[[i]] <- runif(i,2,5)
}
lista2
[[1]]
[1] 2.296293

[[2]]
[1] 4.415145 3.822722

[[3]]
[1] 3.148497 4.993411 4.977279

[[4]]
[1] 3.148723 2.698193 3.789526 3.037013

[[5]]
[1] 3.817646 4.231153 4.155067 2.534407 2.890938

[[6]]
[1] 3.402144 2.413180 3.968950 4.454058 3.139918 2.915123

[[7]]
[1] 2.039117 3.626330 3.654594 3.492675 2.877256 2.128803 2.642409

[[8]]
[1] 4.018868 3.799652 4.149620 2.597014 3.327200 3.308157 3.210291 2.984963

[[9]]
[1] 3.077262 4.360543 2.846235 4.842422 4.064210 4.110764 3.063852 3.447566
[9] 3.202773

[[10]]
 [1] 2.459022 2.713820 3.551228 4.560394 3.419739 3.831390 3.093279 3.314575
 [9] 2.787503 2.172409

Agregar un elemento a una lista

Puedes agregar un elemento a una lista utilizando el operador de concatenación c() o la función append(). Aquí hay ejemplos de ambas formas:

# Crear una lista inicial
mi_lista <- list(1, 2, 3)

# Usar el operador de concatenación c() para agregar un elemento
mi_lista <- c(mi_lista, 4)

# O usar la función append() para agregar un elemento
mi_lista <- append(mi_lista, 5)

mi_lista
[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] 4

[[5]]
[1] 5

Concatenación y repetición de listas

Puedes concatenar dos o más listas utilizando el operador de concatenación c(). También puedes repetir una lista varias veces utilizando la función rep(). Aquí tienes ejemplos:

# Crear dos listas
lista1 <- list(1, 2, 3)
lista2 <- list("a", "b", "c")

# Concatenar las listas
lista_concatenada <- c(lista1, lista2)

# Repetir una lista
lista_repetida <- rep(lista1, times = 2)

lista_concatenada
[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] "a"

[[5]]
[1] "b"

[[6]]
[1] "c"
lista_repetida
[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] 1

[[5]]
[1] 2

[[6]]
[1] 3

Eliminar elementos de una lista

Puedes eliminar elementos de una lista utilizando la función [-índice], donde índice es el índice del elemento que deseas eliminar. Aquí tienes un ejemplo:

# Crear una lista
mi_lista <- list("a", "b", "c", "d")

# Eliminar el tercer elemento (índice 3)
mi_lista <- mi_lista[-3]

mi_lista
[[1]]
[1] "a"

[[2]]
[1] "b"

[[3]]
[1] "d"

Ordenar elementos de una lista

Para ordenar los elementos de una lista, puedes utilizar la función sort(). Ten en cuenta que esta función ordenará los elementos en orden ascendente por defecto.

# Crear una lista desordenada
mi_lista <- list(5, 1, 3, 2, 4)

# Ordenar la lista
mi_lista_ordenada <- sort(unlist(mi_lista))

mi_lista_ordenada
[1] 1 2 3 4 5

Longitud de una lista

Puedes obtener la longitud de una lista utilizando la función length(). Esto te dará el número de elementos en la lista.

# Crear una lista
mi_lista <- list("a", "b", "c", "d")

# Obtener la longitud de la lista
longitud_lista <- length(mi_lista)

longitud_lista
[1] 4

R - Tuplas

En R, a diferencia de algunos lenguajes de programación que admiten tuplas como una estructura de datos inmutable y ordenada, R no tiene tuplas como un tipo de dato nativo. Sin embargo, puedes simular el comportamiento de las tuplas utilizando vectores, listas o marcos de datos, dependiendo de tu necesidad.

Usando Vectores

Si deseas crear una tupla que contenga elementos de diferentes tipos y que sea inmutable, puedes usar un vector de una sola dimensión. Aquí tienes un ejemplo:

mi_tupla <- c(nombre = "Erik", edad = 24, ciudad = "Lima")
mi_tupla
nombre   edad ciudad 
"Erik"   "24" "Lima"

En este caso, “mi_tupla” es un vector con tres elementos, y cada elemento tiene un nombre (nombre, edad, ciudad). Puedes acceder a los elementos de la tupla utilizando el operador “$” o mediante índices.

Usando Listas

Las listas son una estructura de datos más versátil para simular tuplas, ya que permiten contener elementos de diferentes tipos y pueden ser modificadas si es necesario. Aquí tienes un ejemplo:

mi_tupla <- list(nombre = "Erik", edad = 24, ciudad = "Lima")
mi_tupla
$nombre
[1] "Erik"

$edad
[1] 24

$ciudad
[1] "Lima"

Al igual que en el ejemplo anterior, “mi_tupla” es una lista con tres elementos, y cada elemento tiene un nombre. Puedes acceder a los elementos de la tupla utilizando el operador “$” o mediante índices.

Usando Marcos de Datos

Si necesitas trabajar con tuplas que representan registros de datos tabulares, los marcos de datos son una excelente opción. Cada fila del marco de datos puede considerarse una tupla, y las columnas representan los elementos individuales de cada tupla. Aquí tienes un ejemplo:

tuplas <- data.frame(nombre = c("Erik", "Luis", "Juan"),edad = c(24, 16, 6),ciudad = c("Lima", "Piura", "Ayacucho"))
tuplas
  nombre edad   ciudad
1   Erik   24     Lima
2   Luis   16    Piura
3   Juan    6 Ayacucho

Agregar Elementos a una Tupla

Para agregar elementos a una lista que representa una “tupla”, puedes utilizar la función “append()” o simplemente asignar un nuevo valor a un nuevo nombre en la lista. Aquí tienes ejemplos:

mi_tupla <- list(nombre = "Erik", edad = 24, ciudad = "Lima")
mi_tupla
$nombre
[1] "Erik"

$edad
[1] 24

$ciudad
[1] "Lima"
mi_tupla$telefono <- "2345-3232-23423" # Usando el operador \$
mi_tupla$telefono
[1] "2345-3232-23423"
mi_tupla <- append(mi_tupla, list(email = "erik.altamirano.012@gmail.com"))
mi_tupla
$nombre
[1] "Erik"

$edad
[1] 24

$ciudad
[1] "Lima"

$telefono
[1] "2345-3232-23423"

$email
[1] "erik.altamirano.012@gmail.com"
mi_tupla$nombre
[1] "Erik"
mi_tupla$edad
[1] 24
mi_tupla$ciudad
[1] "Lima"

Eliminar Elementos de una “Tupla” (Lista)

Para eliminar elementos de una lista que representa una “tupla”, puedes asignar “NULL” al elemento que deseas eliminar o usar la función “rm()” para eliminar un nombre de la lista. Aquí tienes ejemplos:

mi_tupla$telefono <- NULL # Eliminar un elemento de la "tupla" asignando NULL
mi_tupla$telefono 
NULL

Aplicaciones de las “Tuplas” en R

Representación de Datos Estructurados: Puedes usar vectores, listas o marcos de datos para representar datos estructurados, como registros de una base de datos, donde cada elemento representa un campo o atributo.

Manejo de Datos Mixtos: Si necesitas almacenar datos de diferentes tipos en una única estructura, una lista es útil para simular una tupla que contiene elementos heterogéneos.

Procesamiento de Datos Tabulares: Los marcos de datos se utilizan comúnmente para manejar datos tabulares, donde cada fila representa una tupla y cada columna es un atributo.

Si bien R no tiene tuplas como un tipo de dato específico, se puede lograr el mismo propósito utilizando vectores, listas o marcos de datos, según la naturaleza de los datos que se necesite representar y manipular.

Diccionarios en R

En R, no se utilizan diccionarios como en Python, en su lugar, se emplean estructuras de datos llamadas listas (lists) y data frames para lograr funcionalidades similares a las de los diccionarios en Python.

Lista (List) como un diccionario

En R, una lista puede ser utilizada de manera similar a un diccionario en Python. Puedes asignar nombres (etiquetas o claves) a elementos de la lista para acceder a ellos de forma similar a cómo se accede a los valores en un diccionario en Python. Aquí tienes un ejemplo:

# Crear una lista con nombres
mi_lista <- list(nombre = "Juan", edad = 30, casado = TRUE)

# Acceder a elementos por nombre
nombre <- mi_lista$nombre
edad <- mi_lista$edad
casado <- mi_lista$casado

print(nombre)  # Esto mostrará "Juan"
[1] "Juan"
print(edad)    # Esto mostrará 30
[1] 30
print(casado)  # Esto mostrará TRUE
[1] TRUE

Data Frame como un diccionario:

Un data frame en R es una estructura de datos tabular que puede utilizarse de manera similar a un diccionario. Puedes acceder a las columnas del data frame utilizando nombres y realizar operaciones similares a las que harías con un diccionario en Python. Aquí tienes un ejemplo:

# Crear un data frame con columnas etiquetadas
mi_data_frame <- data.frame(nombre = c("Juan", "Ana", "Luis"),
                            edad = c(30, 25, 28),
                            casado = c(TRUE, FALSE, TRUE))

# Acceder a columnas por nombre
nombres <- mi_data_frame$nombre
edades <- mi_data_frame$edad
casados <- mi_data_frame$casado

print(nombres)  # Esto mostrará "Juan" "Ana" "Luis"
[1] "Juan" "Ana"  "Luis"
print(edades)   # Esto mostrará 30 25 28
[1] 30 25 28
print(casados)  # Esto mostrará TRUE FALSE TRUE
[1]  TRUE FALSE  TRUE

En resumen, en R, puedes utilizar listas con nombres o data frames para lograr funcionalidades similares a las de los diccionarios en Python. Las listas son más flexibles y pueden contener una variedad de tipos de datos, mientras que los data frames son más adecuados para datos tabulares. Puedes elegir la estructura de datos que mejor se adapte a tus necesidades específicas.