1  Introduction

1.1 Operadores aritmeticos

A continuacion veremos algunas operaciones aritmeticas con su respectivo ejemplo

aritmetic_operators <- data.frame(
  Nombre_del_operador = c("suma", "resta", "multiplicacion", "division o division flotante", "division de piso", "exponente", "modulos"),
  Simbolo_del_operador = c("+", "-", "*", "/", "%/%", "^", "%%"),
  Descripcion = c("Suma los dos operandos", "Resta los operandos derechos del operando izquierdo", "Multiplica los dos operandos", "El operando izquierdo se divide por el operando derecho y da como resultado el valor flotante", "El operando izquierdo se divide por el operando derecho y da como resultado el valor minimo de division", "Eleva el operando izquierdo a la potencia del derecho", "Da el resto de la division del operando izquierdo por el operando derecho"),
  Ejemplo = c("a + b", "a - b", "a * b", "a / b", "a%/%b", "a ^ b", "a %% b")
)

print(aritmetic_operators)

           Nombre_del_operador Simbolo_del_operador
1                         suma                    +
2                        resta                    -
3               multiplicacion                    *
4 division o division flotante                    /
5             division de piso                  %/%
6                    exponente                    ^
7                      modulos                   %%
                                                                                              Descripcion
1                                                                                  Suma los dos operandos
2                                                     Resta los operandos derechos del operando izquierdo
3                                                                            Multiplica los dos operandos
4           El operando izquierdo se divide por el operando derecho y da como resultado el valor flotante
5 El operando izquierdo se divide por el operando derecho y da como resultado el valor minimo de division
6                                                   Eleva el operando izquierdo a la potencia del derecho
7                               Da el resto de la division del operando izquierdo por el operando derecho
  Ejemplo
1   a + b
2   a - b
3   a * b
4   a / b
5   a%/%b
6   a ^ b
7  a %% b

1.2 Operadiores relacionales

A continuacion veremos algunas operaciones relacionales con su respectivo ejemplo

Relationals_operators <- data.frame(
  Nombre_del_operador = c("igualdad", "diferente", "Menor que", "Mayor que", "Menor o igual", "Mayor o igual"),
  Simbolo_del_operador = c("==", "!=", "<", ">", "<=", ">="),
  Descripcion = c("comparar si el valor del operando izquierdo es igual al valor del operando derecho", "comparar si el valor del operando izquierdo no es igual al valor del operando derecho", "comparar si el valor del operando izquierdo es menor que el valor del operando derecho", "comparar si el valor del operando izquierdo es mayor que el valor del operando derecho", "comparar el valor del operando izquierdo es menor o igual que el valor del operando derecho", "comparar el valor del operando izquierdo es mayor o igual que el valor del operando derecho"),
  Ejemplo = c("a == b", "a != b", "a < b", "a > b", "a<=b", "a>=b")
)

print(Relationals_operators)

  Nombre_del_operador Simbolo_del_operador
1            igualdad                   ==
2           diferente                   !=
3           Menor que                    <
4           Mayor que                    >
5       Menor o igual                   <=
6       Mayor o igual                   >=
                                                                                  Descripcion
1          comparar si el valor del operando izquierdo es igual al valor del operando derecho
2       comparar si el valor del operando izquierdo no es igual al valor del operando derecho
3      comparar si el valor del operando izquierdo es menor que el valor del operando derecho
4      comparar si el valor del operando izquierdo es mayor que el valor del operando derecho
5 comparar el valor del operando izquierdo es menor o igual que el valor del operando derecho
6 comparar el valor del operando izquierdo es mayor o igual que el valor del operando derecho
  Ejemplo
1  a == b
2  a != b
3   a < b
4   a > b
5    a<=b
6    a>=b

# Declaramos dos variables
a = 20
b = 28

a == b

[1] FALSE

print(paste("igual a la relacion => (a==b) es:", a==b))

[1] "igual a la relacion => (a==b) es: FALSE"

# no es igual a la relacion (!=)
a!=b

[1] TRUE

print(paste("no es igual a la relacion => (a!=b) es:", a!=b))

[1] "no es igual a la relacion => (a!=b) es: TRUE"

# relacion menor que (<)
print(paste("relacion menor que => (a < b) es:", a < b))

[1] "relacion menor que => (a < b) es: TRUE"

# relacion mayor que (>)

print(paste("relacion mayor que => (a > b) es:", a > b))

[1] "relacion mayor que => (a > b) es: FALSE"

# menor o igual a relacion (<=)
print(paste("relacion menor que => (a <= b) es:", a <= b))

[1] "relacion menor que => (a <= b) es: TRUE"

# mayor o igual a relacion (>=)
print(paste("relacion mayor que => (a >= b) es", a >= b))

[1] "relacion mayor que => (a >= b) es FALSE"

1.3 Operador de asignacion

A continuacion veremos el operador de asignacion con su respectivo ejemplo

Asigment_operators <- data.frame(
  Nombre_del_operador = c("Asignar"),
  Simbolo_del_operador = c("<- ??? ="),
  Descripcion = c("Asigna un valor a una variable"),
  Ejemplo = c("a = b o a <- b")
)

print(Asigment_operators)

  Nombre_del_operador Simbolo_del_operador                    Descripcion
1             Asignar             <- ??? = Asigna un valor a una variable
         Ejemplo
1 a = b o a <- b

# Asignar (=)
a <-  20
print(paste("Asignar(a=20) => ",a))

[1] "Asignar(a=20) =>  20"

b <-  25
print(paste("Asignar(b=25) =>",b))

[1] "Asignar(b=25) => 25"

2 Operadores l�gicos en R

# Creaci�n de vectores de ejemplo
vector_a <- c(TRUE, TRUE, FALSE, FALSE)
vector_b <- c(TRUE, FALSE, TRUE, FALSE)

# Operador AND l�gico (&& y &)
resultado_and <- vector_a & vector_b
resultado_and

[1]  TRUE FALSE FALSE FALSE

# Operador OR l�gico (|| y |)
resultado_or <- vector_a | vector_b
resultado_or

[1]  TRUE  TRUE  TRUE FALSE

# Operador NOT l�gico (!)
resultado_not_a <- !vector_a
resultado_not_b <- !vector_b
resultado_not_a

[1] FALSE FALSE  TRUE  TRUE

resultado_not_b

[1] FALSE  TRUE FALSE  TRUE

# Operador XOR l�gico (xor())
resultado_xor <- xor(vector_a, vector_b)
resultado_xor

[1] FALSE  TRUE  TRUE FALSE

2.1 Acceso a los elementos del vector

Para acceder un elemento del vector, usaremos “[ ]”. En R, el primer elemento es el n�mero 1, el segundo, n�mero 2 y asi los demas elementos.

#Acceder al elemento 1
v2 <- c(3, 4.5, 100, 23, 19.8, 3)
v2[1]

[1] 3

#Acceder al elemento 2
v2 <- c(3, 4.5, 100, 23, 19.8, 3)
v2[2]

[1] 4.5

#Acceder valores desde un punto a otro
v2 <- c(3, 4.5, 100, 23, 19.8, 3)
v2[3:5]

[1] 100.0  23.0  19.8

#Selecci�n de solo 2 �ndices espec�ficos
v2 <- c(3, 4.5, 100, 23, 19.8, 3)
v2[c(1,3)]

[1]   3 100

Si queremos descartar elementos del vector, sera usar “[-x]”.

#Eliminar el primer elemento
v2 <- c(3, 4.5, 100, 23, 19.8, 3)
v2[-1]

[1]   4.5 100.0  23.0  19.8   3.0

#Acceder valores desde un punto a otro
v2 <- c(3, 4.5, 100, 23, 19.8, 3)
v2[-2:-4]

[1]  3.0 19.8  3.0

#Selecci�n de solo 2 �ndices espec�ficos
v2 <- c(3, 4.5, 100, 23, 19.8, 3)
v2[-c(2,4)]

[1]   3.0 100.0  19.8   3.0

2.1.1 Algunas funciones extras

v2 <- c(3, 4.5, 100, 23, 19.8, 3)
# Longitud (tama�o) de un vector
length(v2)

[1] 6

# �ltimo elemento del vector
v2[length(v2)]

[1] 3

# Vector en reversa
rev(v2)

[1]   3.0  19.8  23.0 100.0   4.5   3.0

# Elementos �nicos del vector
unique(v2)

[1]   3.0   4.5 100.0  23.0  19.8

2.2 Ordenamiento del vector

v3 <- c(20, 4, 100, 31, 57, 3)
# Ordena en orden creciente
sort(v3)

[1]   3   4  20  31  57 100

# Retorna los �ndices
order(v3)

[1] 6 2 1 4 5 3

# Ordenamiento usando los �ndices
v3[order(v3)]

[1]   3   4  20  31  57 100

# �ndices ordenados del vector
rank(v3)

[1] 3 2 6 4 5 1

# Valor m�ximo
max(v3)

[1] 100

# �ndice del m�ximo
which.max(v3)

[1] 3

# M�ximo usando el �ndice
v3[which.max(v3)]

[1] 100

# Valor m�nimo
min(v3)

[1] 3

# �ndice del valor m�nimo
which.min(v3)

[1] 6

2.3 Aritm�tica de vectores

Usamos las opereciones basicas, presentadas en anteriores cap�tulos, pero con vectores.

Ejemplos{.underline}:

v4 <- c(34, 10, 4, 21, 12)
#Multiplicaci�n
100*v4

[1] 3400 1000  400 2100 1200

#Suma
200+v4

[1] 234 210 204 221 212

Cuando hay 2 vectores, se realiza t�rmino a t�rmino si tienen igual longitud

v5 <- c(2, 4, 6, 8, 10)
v6 <- c(1, 3, 5, 7, 11)
v5+v6

[1]  3  7 11 15 21

v5-v6

[1]  1  1  1  1 -1

v5*v6

[1]   2  12  30  56 110

v5/v6

[1] 2.0000000 1.3333333 1.2000000 1.1428571 0.9090909

v5**v6

[1]            2           64         7776      2097152 100000000000

OBS: Si no son del mismo tama�o, el m�s corto se “repite”

v7 <- c(1, 2, 3)
v8 <- c(10, 20, 30, 40, 50)
v9 <- v7+v8

Warning in v7 + v8: longitud de objeto mayor no es múltiplo de la longitud de
uno menor

v9

[1] 11 22 33 41 52

3 Listas

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

Sin embargo, una lista tambi�n es un tipo de secuencia, por lo que admite la indexaci�n. Para crear la lista, necesitamos poner elementos dentro de “list( )” separ�ndolos con una coma.

#Creando una lista
lista1 <- list("Juan Perez", 234)
lista1

[[1]]
[1] "Juan Perez"

[[2]]
[1] 234

#Clase de la lista
class(lista1)

[1] "list"

3.1 Acceder a los elementos de la lista

La lista admite la indexaci�n (comenzando desde 1), por lo que, para acceder a los elementos de una lista de R, usaremos el �ndice de ese elemento.

# Accede al primer elemento
lista1[[1]]

[1] "Juan Perez"

# Accede al segundo elemento
lista1[[2]]

[1] 234

Podemos incluir en una listas, secuencias y vectores.

#Creando una lista que incluye secuencias y vectores
lista2 <- list(2:5, c("a", "b"), c(TRUE, FALSE, TRUE), 10.5, "Elemento")
lista2

[[1]]
[1] 2 3 4 5

[[2]]
[1] "a" "b"

[[3]]
[1]  TRUE FALSE  TRUE

[[4]]
[1] 10.5

[[5]]
[1] "Elemento"

# Accede al primer elemento
lista2[[1]]

[1] 2 3 4 5

# Muestra la estructura de la lista
str(lista2)

List of 5
 $ : int [1:4] 2 3 4 5
 $ : chr [1:2] "a" "b"
 $ : logi [1:3] TRUE FALSE TRUE
 $ : num 10.5
 $ : chr "Elemento"

3.2 Agregar elementos a una lista

lista3 <- list(3, "Pepe", 5:9)
elemento_nuevo <- "Sara"
#Podemos actualizar la lista3 o crear una nueva lista donde este agregado el elemento_nuevo
lista3 <- list(lista3, elemento_nuevo)
lista3

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

[[1]][[2]]
[1] "Pepe"

[[1]][[3]]
[1] 5 6 7 8 9


[[2]]
[1] "Sara"

3.3 Concatenacion y repeticion

Estos son los codigos que se usan para distintas funciones en R.

De esta manera se pueden combinar elementos de una lista a otra. Las listas se colocan en el orden que se desea que aparezcan.

lista1 <- list(2, 4, 6, 8, 10)
lista2 <- list(1, 3, 5, 7)
numeros <- list(lista2, lista1)
print(numeros)

[[1]]
[[1]][[1]]
[1] 1

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

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

[[1]][[4]]
[1] 7


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

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

[[2]][[3]]
[1] 6

[[2]][[4]]
[1] 8

[[2]][[5]]
[1] 10

3.4 Actualizar la lista de Python

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

numeros <- list(1,2,3,4,5,6)
numeros[2] <- 22
print(numeros)

[[1]]
[1] 1

[[2]]
[1] 22

[[3]]
[1] 3

[[4]]
[1] 4

[[5]]
[1] 5

[[6]]
[1] 6

3.5 Eliminar un elemento de la lista

Para eliminar un elemento se usa el siguiente codigo:

numeros <- list(1,2,3,4,5,6)
numeros <- numeros[numeros != 6]
print(numeros)

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] 4

[[5]]
[1] 5

Analogamente, tambien se puede usar:

numeros <- list(1,2,3,4,5,6)
numeros <- numeros[-2]
print(numeros)

[[1]]
[1] 1

[[2]]
[1] 3

[[3]]
[1] 4

[[4]]
[1] 5

[[5]]
[1] 6

3.6 Comprobar la pertenencia de un elemento

Podemos usar la funcion %in% para comprobar si un elemento se encuentra en la lista.

frutas <- list("fresa", "papaya", "pi�a")
"fresa" %in% frutas

[1] TRUE

cat("Comprobando si el mango est� en la lista :", "pl�tano" %in% frutas)

Comprobando si el mango est� en la lista : FALSE

3.7 Ordenar los elementos de la lista

Para ordenar los elementos de una lista primero debemos transformarla a un vector, luego ordenamos el vector con la funcion “sort” y por ultimo volvemos a convertirla a una lista.

mi_lista <- list(20, 25, 22, 64, 15, 28)

mi_vector <- unlist(mi_lista)
mi_vector_ordenado <- sort(mi_vector)

mi_lista_ordenada <- list(mi_vector_ordenado)
print(mi_lista_ordenada)

[[1]]
[1] 15 20 22 25 28 64

Si queremos ordenarla de manera decreciente deberemos seguir los mismos pasos pero agregando “decreasing = True” en la funcion sort.

mi_lista <- list(20, 25, 22, 64, 15, 28)

mi_vector <- unlist(mi_lista)
mi_vector_ordenado <- sort(mi_vector, decreasing = TRUE)

mi_lista_ordenada <- list(mi_vector_ordenado)
print(mi_lista_ordenada)

[[1]]
[1] 64 28 25 22 20 15

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

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

# Ejemplo 1 
mi_lista <- list(20, 25, 22, 64, 15, 28,25,30,25)

cat("Mi Lista:\n")

Mi Lista:

print(mi_lista)

[[1]]
[1] 20

[[2]]
[1] 25

[[3]]
[1] 22

[[4]]
[1] 64

[[5]]
[1] 15

[[6]]
[1] 28

[[7]]
[1] 25

[[8]]
[1] 30

[[9]]
[1] 25

#  Hallar la longitud

longitud_lista <- length(mi_lista)

print(longitud_lista)

[1] 9

# Hallar cuantas veces contengo un elemento 

cant_lista <- sum(mi_lista ==25) 
print(cant_lista)

[1] 3

# Ejemplo 2

mi_lista <- c(1,2,3,4,5) 

5 Agregar elemento(s) en tupla

Como las tuplas son inmutables, no podemos agregar ni modificar la tupla existente. Pero de otra forma, podemos usar el operador de concatenaci�n “+” y concatenar la nueva tupla con un solo elemento de la existente y crear una nueva referencia de tupla.

# Ejemplo 1 
# Tupla Inicial
tupla_inicial <- c(1, 2, 3)
print(paste("tupla t1 =", tupla_inicial))

[1] "tupla t1 = 1" "tupla t1 = 2" "tupla t1 = 3"

# Crear una nueva tupla agregando (4,), tupla con un solo elemento en la tupla inicial

tupla_inicial_1 <- c(tupla_inicial, 4)
print(paste("tuple tupla_inicial_1.1 =", tupla_inicial_1))

[1] "tuple tupla_inicial_1.1 = 1" "tuple tupla_inicial_1.1 = 2"
[3] "tuple tupla_inicial_1.1 = 3" "tuple tupla_inicial_1.1 = 4"

tupla_inicial_1

[1] 1 2 3 4

# Para crear una tupla con un solo elemento, es necesario incluir una coma al final:

t1 <- c('a')
t1

[1] "a"

#Averiguar el tipo de data
class(t1)

[1] "character"

# Otra forma de construir una tupla es utilizando la funci�n interna tuple. Sin argumentos, �sta crea una tupla vac�a:
t3 <- c()
t3

NULL

# Si el argumento es una secuencia (cadena, lista, o tupla), el resultado de la llamada a tuple es una tupla con los elementos de la secuencia:

# Crear una lista con cada letra de la palabra "Programaci�n"
palabra <- 'Programaci�n'
lista_de_letras <- strsplit(palabra, split = '')[[1]]

# Imprimir la lista de letras
print(lista_de_letras)

 [1] "P" "r" "o" "g" "r" "a" "m" "a" "c" "i" "�" "n"

Parte de Carla: #TUPLAS

Una tupla tambi�n es una colecci�n ordenada de elementos como una lista, pero las tuplas son inmutables, es decir, no podemos cambiar ni modificar el valor de los elementos de la tupla. En R, las tuplas no son un tipo de dato nativo como en algunos otros lenguajes de programaci�n, pero puedes representar una tupla como un vector o una lista con varios elementos.

5.0.1 Crear una tupla como un vector

mi_tupla <- c("valor1", 42, TRUE, 5,0)

5.0.2 Acceder a elementos de la tupla

primer_elemento <- mi_tupla[1] 
primer_elemento

[1] "valor1"

segundo_elemento <- mi_tupla[2]
segundo_elemento

[1] "42"

tercer_elemento <- mi_tupla[3]
tercer_elemento

[1] "TRUE"

# Ejemplo
# Tupla inicial
tupla_inicial <- c(1,2,3,7,9,12,15)
tupla_inicial

[1]  1  2  3  7  9 12 15

# Crear una nueva tupla agregando 60, tupla con un solo elemento en la tupla inicial
tupla_nueva <- c(tupla_inicial, 60)
tupla_nueva

[1]  1  2  3  7  9 12 15 60

# Eliminar el elemento del �ndice 5
tupla_e <- tupla_inicial[-5]
tupla_e

[1]  1  2  3  7 12 15

Creando un diccionario Vamos a tener una serie de valores asociados a unas claves

#Cargamos nuestros datos
mi_diccionario<- c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ,11, 12 ,13, 14 , 15, 16, 17, 18, 19, 20, 21, 22 , 23, 24, 25, 26)
mi_diccionario

 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26

#Asociamos a un nombre
names(mi_diccionario)<- c("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z")

#Comprobamos el valor de la clave
mi_diccionario["a"]

a 
1 

mi_diccionario["m"]

 m 
13 

mi_diccionario["z"]

 z 
26 

 #Obtener la lista de pares clave y valor
mi_diccionario

 a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z 
 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26