APUNTES R - PLE MELANY MONTERO

Author

Melany Montero

Published

Invalid Date

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

El nombre de una variable debe comenzar con una letra o un guión bajo (_); no puede comenzar con un número.
Solo puede contener (AZ, az, 0-9 y _).
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}{|c|c|c|c|} \hline \text { Nombre del operador } & \text { Símbolo del operador } & \text { Descripción } & \text { Ejemplo } \\ \hline \text { suma } & + & \text { Suma los dos operandos } & a+b \\ \hline \text { resta } & - & \text { Resta los operandos derechos del operando izquierdo } & a b \\ \hline \text { multiplicación } & \text { * } & \text { Multiplica los dos operandos } & a^* b \\ \hline \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 \\ \hline \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} \\ \hline \text { exponente } & * * & \text { Elevó el operando izquierdo a la potencia del derecho. } & \begin{array}{l} a^{* *} b \quad\left(3^{* *} 2 \text { significa } 3\right. \\ \text { elevado a } 2) \end{array} \\ \hline \text { módulos } & \% & \begin{array}{l} \text { Da el resto de la división del operando izquierdo por el } \\ \text { operando derecho } \end{array} & a \% 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}{|c|c|c|c|} \hline \text { Nombre del operador } & \text { Símbolo del operador } & \text { Descripción } & \text { Ejemplo } \\ \hline \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 \\ \hline \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 \\ \hline \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 \\ \hline \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 \\ \hline \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 \\ \hline \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:

\[ \begin{array}{|c|c|c|c|} \hline \text { Nombre del operador } & \text { Símbolo del operador } & \text { Descripción } & \text { Ejemplo } \\ \hline \text { Asignar } & <- & \begin{array}{l} \text { Asignar el valor del operando derecho al operando } \\ \text { izquierdo } \end{array} & a<-b \\ \hline \text { Sumar y asignar } & <- + & \begin{array}{l} \text { Suma el valor del operando derecho al izquierdo y } \\ \text { asigna el resultado al operando izquierdo } \end{array} & a<- a+10 \ (a=a+10) \\ \hline \text { Restar y asignar } & -= & \begin{array}{l} \text { Reste el valor del operando derecho al izquierdo y } \\ \text { asigne el resultado al operando izquierdo } \end{array} & a<- a-10 \ (a=a-10) \\ \hline \text { Multiplicar y asignar } & { }^*= & \begin{array}{l} \text { Multiplica el valor del operando derecho por el } \\ \text { izquierdo y asigna el resultado al operando izquierdo. } \end{array} & a^*=10 \left(a=a^* 5\right) \\ \hline \text { Dividir y asignar } & /= & \begin{array}{l} \text { Divida el valor del operando derecho a la izquierda y } \\ \text { asigne el resultado al operando izquierdo } \end{array} & a /=2 \ (a=a / 2) \\ \hline \begin{array}{l} \text { División y asignación del } \\ \text { piso } \end{array} & / /= & \begin{array}{l} \text { Piso divide el valor del operando derecho a la izquierda } \\ \text { y asigna el resultado al operando izquierdo } \end{array} & a / /=9 \ (a=a / / 9) \\ \hline \text { Módulo y asignación } & \%%= & \begin{array}{l} \text { Realice el módulo por el valor del operando derecho a la } \\ \text { izquierda y asigne el resultado al operando izquierdo } \end{array} & a \%%=3 \ (a=a \%% 3) \\ \hline \text { Exponente y asignación } & ^{^=} & \begin{array}{l} \text { Realizar el exponente de operandos y asignar el } \\ \text { resultado al operando izquierdo. } \end{array} & a^{\star \star *}=2\left(a=a^{\star \star 2} 2\right) \\ \hline \end{array} \]

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

Asignar(a=20) =>  20

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

Asignar(b=25) => 25

[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}{|l|c|l|} \hline {\text { Nombre del operador }} & \text { Símbolo del operador } & {\text { Descripción }} \\ \hline \text { AND (y) lógico } & \text{&} & \begin{array}{l} \text { Da como resultado 'True' si ambos operandos son 'Verdadero' y } \\ \text { 'False' en caso contrario. } \end{array} \\ \hline \text { OR (O) lógico } & \text{|} & \begin{array}{l} \text { Da "True" como resultado si alguno de los operandos es } \\ \text { "Verdadero" y "False" en caso contrario. } \end{array} \\ \hline \text { NOT (No) lógico } & \text{!} & \begin{array}{l} \text { Da como resultado 'True' si un operando es 'Falso' y 'True' si } \\ \text { un operando es 'Verdadero'. } \end{array} \\ \hline \end{array} \]\[ \begin{array}{|l|c|l|} \hline {\text { Nombre del operador }} & \text { Símbolo del operador } & {\text { Descripción }} \\ \hline \text { AND (y) lógico } & \text{and} & \begin{array}{l} \text { Da como resultado 'True' si ambos operandos son 'Verdadero' y } \\ \text { 'False' en caso contrario. } \end{array} \\ \hline \text { OR (O) lógico } & \text{or} & \begin{array}{l} \text { Da "True" como resultado si alguno de los operandos es } \\ \text { "Verdadero" y "False" en caso contrario. } \end{array} \\ \hline \text { NOT (No) lógico } & \text{not} & \begin{array}{l} \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

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().
Se puede verificar el tipo de cualquier variable usando el método type().
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"