APUNTES R - PLE MELANY MONTERO

Variables y tipos

Una variable es un nombre que hace referencia a un valor, específicamente es el nombre de una ubicación de memoria reservada que contiene algún valor.

Por ejemplo:

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

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

x <- 10

Reglas para definir un nombre de variable

1. El nombre de una variable debe comenzar con una letra o un guión bajo (_); no puede comenzar con un número.
2. Solo puede contener (AZ, az, 0-9 y _).
3. Es importante recordar que en R los nombres de las variables distinguen entre mayúsculas y minúsculas.

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

#Operadores aritméticos.

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

$$\begin{array}{|cccc|}\hline \text{ Nombre del operador }& \text{ Símbolo del operador }& \text{ Descripción }& \text{ Ejemplo }\\ \text{ suma }& +& \text{ Suma los dos operandos }& a+b\\ \text{ resta }& -& \text{ Resta los operandos derechos del operando izquierdo }& ab\\ \text{ multiplicación }& \text{ * }& \text{ Multiplica los dos operandos }& a^{\ast }b\\ \text{ división o división flotante }& \text{ / }& \begin{array}{l}\text{ El operando izquierdo se divide por el operando }\\ \text{ derecho y da como resultado el valor flotante }\end{array}& a/b\\ \text{ división de piso }& //& \begin{array}{l}\text{ El operando izquierdo se divide por el operando }\\ \text{ derecho y da como resultado el valor mínimo de }\\ \text{ división }\end{array}& \mathrm{a}//\mathrm{b}\\ \text{ exponente }& \ast \ast & \text{ Elevó el operando izquierdo a la potencia del derecho. }& \begin{array}{l}{a}^{\ast \ast }b(3^{\ast \ast }2\text{ significa }3\\ \text{ elevado a }2)\end{array}\\ \text{ módulos }& \mathrm{\%}& \begin{array}{l}\text{ Da el resto de la división del operando izquierdo por el }\\ \text{ operando derecho }\end{array}& a\mathrm{\%}b\\ \hline\end{array}$$

Operadores relacionales

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

$$\begin{array}{|cccc|}\hline \text{ Nombre del operador }& \text{ Símbolo del operador }& \text{ Descripción }& \text{ Ejemplo }\\ \text{ igual a }& ==& \begin{array}{l}\text{ comparar si el valor del operando izquierdo es igual al }\\ \text{ valor del operando derecho }\end{array}& a==b\\ \text{ no igual a o diferente }& !=& \begin{array}{l}\text{ comparar si el valor del operando izquierdo no es igual }\\ \text{ al valor del operando derecho }\end{array}& a!=b\\ \text{ menor que }& <& \begin{array}{l}\text{ comparar si el valor del operando izquierdo es menor }\\ \text{ que el valor del operando derecho }\end{array}& a<b\\ \text{ mayor que }& >& \begin{array}{l}\text{ comparar si el valor del operando izquierdo es mayor }\\ \text{ que el valor del operando derecho }\end{array}& a>b\\ \text{ Menor que o igual a }& <=& \begin{array}{l}\text{ comparar el valor del operando izquierdo es menor o }\\ \text{ igual que el valor del operando derecho }\end{array}& a<=b\\ \text{ Mayor qué o igual a }& >=& \begin{array}{l}\text{ comparar el valor del operando izquierdo es mayor o }\\ \text{ igual que el valor del operando derecho }\end{array}& a>=b\\ \hline\end{array}$$

Ejemplo:

# Declaramos dos variables
a <- 20
b <- 28

# igual a relación (==)

a==b

[1] FALSE

cat("igual a la relación => (a==b) es:" , a==b)

igual a la relación => (a==b) es: FALSE

# no es igual a la relación (!=)
a!=b

[1] TRUE

cat("no es igual a la relación => (a!=b) es:" , a!=b)

no es igual a la relación => (a!=b) es: TRUE

# relación menor que (<)
cat("relación menor que => (a < b) es:" , a < b)

relación menor que => (a < b) es: TRUE

# relación mayor que (>)

cat("relación mayor que => (a > b) es:" , a > b)

relación mayor que => (a > b) es: FALSE

# menor o igual a relación (<=)
cat("relación menor que => (a <= b) es:" , a <= b)

relación menor que => (a <= b) es: TRUE

# mayor o igual a relación (>=)

cat("relación mayor que => (a >= b) es" , a >= b)

relación mayor que => (a >= b) es FALSE

#Operador de asignación

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

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

Asignar(a=20) =>  20

b <- 25
cat("Asignar(b=25) =>" , b)

Asignar(b=25) => 25

b

[1] 25

# Suma y asignación (+=) --
a<- a +  10

cat ("Suma y asignación (a +=10) =>", a)

Suma y asignación (a +=10) => 30

# Restar y asignar (-=)
a<- a-10
cat("Restar y asignar (a -=10) =>",a)

Restar y asignar (a -=10) => 20

# Multiplicar y asignar (*=)
a <- a*10
cat("Multiplicar y asignar (a*=10) =>",a)

Multiplicar y asignar (a*=10) => 200

# Dividir y asignar (/=)
a<- a/10
cat("Dividir y asignar(a/=10) =>",a)

Dividir y asignar(a/=10) => 20

# Piso-Dividir y Asignar (//=)
b<- floor(b/3)
cat("Piso-Dividir y Asignar(b//=3) =>",b)

Piso-Dividir y Asignar(b//=3) => 8

# Módulo y Asignación (%%=)
b<- b %% 3
cat("Módulo y Asignación(b%%=3) =>",b)

Módulo y Asignación(b%%=3) => 2

# exponente y Asignar (**=)
b<- b^3

cat("exponente y Asignar(b^=3) =>",b)

exponente y Asignar(b^=3) => 8

#Operadores logicos

Estos operadores se utilizan para combinar expresiones condicionales en R.

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

$$\begin{array}{|lcl|}\hline \text{ Nombre del operador }& \text{ Símbolo del operador }& \text{ Descripción }\\ \text{ AND (y) lógico }& \text{and}& \begin{array}{c}\text{ Da como resultado ’True’ si ambos operandos son ’Verdadero’ y }\\ \text{ ’False’ en caso contrario. }\end{array}\\ \text{ OR (O) lógico }& \text{or}& \begin{array}{c}\text{ Da "True" como resultado si alguno de los operandos es }\\ \text{ "Verdadero" y "False" en caso contrario. }\end{array}\\ \text{ NOT (No) lógico }& \text{not}& \begin{array}{c}\text{ Da como resultado ’True’ si un operando es ’Falso’ y ’True’ si }\\ \text{ un operando es ’Verdadero’. }\end{array}\\ \hline\end{array}$$

# Ejemplo
a= F
b= T

# Operador lógico AND (y)
cat("AND lógico => a y b es:", a & b)

AND lógico => a y b es: FALSE

# Operador lógico OR (o)
cat("OR lógico => a o b es:", a | b)

OR lógico => a o b es: TRUE

# Operador lógico NOT (no)
cat("NO lógico => no b es:", ! b)

NO lógico => no b es: FALSE

Tipos de datos integrados en R

Tipo numérico:

Al trabajar con números, necesitamos tipos de datos numéricos. En R, los números son inmutables. En R 3.x, tenemos tres tipos de datos numéricos.

Int o Integer: Los números enteros son números enteros positivos o negativos; es decir, no tienen punto decimal.

Flotante: Son valores flotantes de tipo numérico o valores reales; a diferencia de los números enteros, el flotante tiene un punto decimal.

Complejo: Los números complejos se pueden expresar en la forma a + bi, aquí, a es la parte real y b es la parte imaginaria [a y b son los números enteros pero i es el número imaginario (raíz cuadrada de -1)].

# Ejemplos
# Ejemplo de tipo de datos int
a <- 20 # valor entero positivo
a1 <- -20 # Valor entero negativo

# imprimiendo el valor
cat("a = ",a)

a =  20

cat("a1 = ",a1)

a1 =  -20

# comprobar el tipo de variable a
cat("El tipo de variable a es:", typeof(a))

El tipo de variable a es: double

cat("El tipo de variable a1 es:", typeof(a1))

El tipo de variable a1 es: double

# Ejemplo para tipo de datos flotante
b <- 20.5 # valor flotante positivo
b1 <- -20.5 # Valor flotante negativo

# imprimiendo el valor
cat("b = ",b)

b =  20.5

cat("b1 = ",b1)

b1 =  -20.5

# comprobar el tipo de variable a
cat("El tipo de variable b es:", typeof(b))

El tipo de variable b es: double

cat("El tipo de variable b1 es:", typeof(b1))

El tipo de variable b1 es: double

# ejemplo datos complejos
a <- 20+5i
b <- 5i
c <- 10-5i
d <- -5i

# imprimiendo el valor de un
cat ("a = ", a)

a =  20+5i

# comprobar el tipo de variable a
cat("El tipo de variable c es :", typeof(a))

El tipo de variable c es : complex

cat("El tipo de variable d e :", typeof(b))

El tipo de variable d e : complex

cat("El tipo de variable d es :", typeof(c))

El tipo de variable d es : complex

cat("El tipo de variable d e s:", typeof(d))

El tipo de variable d e s: complex

Conversión de tipos o conversión de tipos

1. En R, se puede convertir los tipos de int a float o float a int o int a complex usando los métodos integer(), float() y complex().

2. Se puede verificar el tipo de cualquier variable usando el método type().

3. Se puede convertir un int o float a String usando str() o cualquier cadena numérica a Int o float usando int() un método float().

Cadenas

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

En R, no hay una distinción explícita entre cadenas simples y dobles como en Python. En R, las comillas simples (‘...’) y las comillas dobles (“...”) se utilizan de manera similar para representar cadenas de caracteres.

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

#imprimir resultados
cat(cadena1)

Esta es una cadena entre comillas simples

cat(cadena2)

Esta es una cadena entre comillas dobles

Accediendo a componentes de cadena

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

En R studio, la indexación comienza desde 1. Por ejemplo, lenguaje <- “Rstudio”; podemos evaluar el primer elemento de String con substr (Rstudio, 1, 1) => R.

De manera similar, lenguaje [2] => s, lenguaje [3] => t, y así sucesivamente.

R a diferencia de Phyton no admite índices negativos, es decir, -1, -2, etc.

# cadenas
lenguaje<- "Rstudio"

# Acceder al primer elemento de la cadena (indexación comienza en 1 en R)
primer<- substr(lenguaje, 1, 1)

# Imprimir resultados
paste("La primera letra es: ", primer)

[1] "La primera letra es:  R"

# Acceder al segundo elemento de la cadena
segundo<- substr(lenguaje, 2, 2)

# Imprimir resultados
paste("La segunda letra es: ", segundo)

[1] "La segunda letra es:  s"

Concatenación de cadenas

En R, para concatenar las dos cadenas, usamos la función paste() . La función paste() en R es equivalente al operador + para concatenación de cadenas en Python.

# Definir dos cadenas en R
cadena1 <- "Hola,"
cadena2 <- "Rstudio!"

# Concatenar las dos cadenas usando paste()
cadena_concatenada <- paste(cadena1, cadena2)

# Imprimir la cadena concatenada
print(cadena_concatenada)

[1] "Hola, Rstudio!"

Operaciones de cadena y métodos integrados.

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

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

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

c. Poner primera letra en mayúscula (capitalize() en Python): En R, para poner la primera letra de una cadena en mayúscula, se utiliza la función paste() junto con toupper() y substr() para manipular la cadena.

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

e. trimws(): Elimina los espacios en blanco iniciales y finales de una cadena.

f. sub(): Para eliminar caracteres específicos del lado derecho de una cadena, se puede usar la función sub() o técnicas de subconjuntos.

g. sub(): para eliminar caracteres específicos del lado izquierdo de una cadena, se puede usar la función sub() o técnicas de subconjuntos.

h. nchar(): Da la longitud de una cadena.

i. Reemplazar subcadena : Para reemplazar una subcadena en una cadena, se utiliza la función sub()

ii. grep(): busca la primera aparición de una subcadena especificada en una cadena.

j. startsWith(): Este método comprobará y devolverá ‘T’ si una cadena comienza con una subcadena especificada.

k. substring(): este método verificará y devolverá ‘T’ si una cadena termina con una subcadena especificada.

l. grepl(): Este método comprobará y devolverá ‘T’ si todos los caracteres de la cadena son dígitos, decimales, alfabetos, mayusculas, minusculas y tambien si son alfanuméricos.

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

curso <- "Programacion en Lenguaje Estadistico"

# Convertir a mayúsculas
mayusculas <- toupper(curso)
cat(mayusculas)

PROGRAMACION EN LENGUAJE ESTADISTICO

# Elimina los espacios en blanco iniciales y finales de una cadena
ejemplo_2 <- trimws(curso)
paste(ejemplo_2)

[1] "Programacion en Lenguaje Estadistico"

# Longitud
longitud<- nchar(curso)
longitud

[1] 36

# Comprobar si está en minúsculas
es_minusculas <- grepl("^[a-z]+$", curso)
cat("¿Está en minúsculas? ", es_minusculas)

¿Está en minúsculas?  FALSE

# Comprobar si son decimales
es_decimales <- grepl("^\\d*\\.?\\d+$", curso)
cat("¿Es decimales? ", es_decimales)

¿Es decimales?  FALSE

# Cadena de ejemplo
cadena <- "A bC"

# Comprobar si son letras (mayúsculas o minúsculas)
es_letras <- grepl("^[A-Za-z]+$", cadena)
print(paste("¿Es letras? ", es_letras))

[1] "¿Es letras?  FALSE"

# Comprobar si está en minúsculas
es_minusculas <- grepl("^[a-z]+$", curso)
print(paste("¿Está en minúsculas? ", es_minusculas))

[1] "¿Está en minúsculas?  FALSE"

# Comprobar si es alfanumérico
es_alfanumerico <- grepl("^[A-Za-z0-9]+$", curso)
print(paste("¿Es alfanumérico? ", es_alfanumerico))

[1] "¿Es alfanumérico?  FALSE"