Variables en R:

Creación:

Una variable nos proporciona un almacenamiento con nombre que nuestros programas pueden manipular. Una variable en R puede almacenar un vector atómico, un grupo de vectores atómicos o una combinación de muchos Robjects.

Un nombre de variable válido consta de letras, números y el punto o el subrayado. El nombre de la variable comienza con una letra o el punto no seguido de un número.

Nombre de la variable Valido (T or F) Razón
var_name2. True Tiene letras, números,puntos y guión bajo.
var_name% False No es valido el %
2var_name False Comienza con un Numero
.var_name; var.name True Puede comenzar con un (.) Pero el (.) No debe ir seguido de un número.
.2var_name False El (.) inicial no pude seguir con un numero.
_var_name False Empezar con guión bajo no es valido
  • Nota: Los caracteres especiales como ‘#’, ‘&’, etc., junto con espacios en blanco (tabulaciones, espacio) no están permitidos en un nombre de variable.

Asignación de Valores:

Las variables en R se pueden asignar de tres formas:

  1. Operador =:
# Operador "=":

variable_con_igual = "Soy un characther definido con ="
print(variable_con_igual)
## [1] "Soy un characther definido con ="
v_equal = 321
print(v_equal)
## [1] 321
  1. Operador <-: Esto ya lo habias explicado Se peuden definir variables con el <- (Se tomaran como vector de longitud n => depende si es un numero o una cadena de texto)
# Operador "<-":
variable_con_fechas <- "Esto se tomara como un vector con length (depende del tamaño de la cadena de texto)"

"length() devuelve el tamaño de un vector, matriz, array, etc..."
## [1] "length() devuelve el tamaño de un vector, matriz, array, etc..."
length(variable_con_fechas)
## [1] 1
v <- 12.13

"No ejecutar: (invalido) _c_ <- c(12,1341,14214,13421,12.421)"
## [1] "No ejecutar: (invalido) _c_ <- c(12,1341,14214,13421,12.421)"
## Crear un vector con numerics (floats):
## c == combinar, definir un vector

f <- c(3.5,3.2,4.3,1.4,5.0,0.4,2.4) ## Notas de un estudiante.
## Miremos el tipo de varible de f
## además lo imprimimos
print(typeof(f))
## [1] "double"
## Notas de un estudiante en forma de vector.
print(f)
## [1] 3.5 3.2 4.3 1.4 5.0 0.4 2.4
  1. Operador ->: Podemos definir una variable de manera inversa, es decir, poner el valor de la variable y despúes definimos el nombre o la forma de identificar este valor en R.
# Definir vaibles a la inversa:
TRUE -> logico
print(logico) # podriamos decir lo mismo pero con la flecha al revez <-, pero al final los dos tendran el mismo resultado
## [1] TRUE
c("Sara", "Daniel", "Felipe", "Cesar", "Yadira", "Ronald") -> NombresDeEstudiantes

print(NombresDeEstudiantes)
## [1] "Sara"   "Daniel" "Felipe" "Cesar"  "Yadira" "Ronald"
## Observemso si con la flecha a la inversa sigue siendo un vector
print(is.vector(NombresDeEstudiantes))
## [1] TRUE

Nota:

La función cat() combina varios elementos en una salida de impresión continua.

Esta función es equivalente a print(value1, value2,...,value_n) ya que el print() de R, es limitado a solmante un valor a la vez (message() == solo imprime cadenas de texto)

# Cogemos las notas de los estudiantes y sus nombres para imprimirlos en dos lineas con cat():
cat("Notas de uno de los siguientes estudiantes: ", f, "\n") # con el \n es equivalente a un enter en un teclado
## Notas de uno de los siguientes estudiantes:  3.5 3.2 4.3 1.4 5 0.4 2.4
cat("Nombres de algunos estudiantes: ", NombresDeEstudiantes)
## Nombres de algunos estudiantes:  Sara Daniel Felipe Cesar Yadira Ronald

Nota :

el vector ln <- c(TRUE, 1L) tiene una combinación de clase lógica y numérica. Entonces, la clase lógica se convierte en una clase numérica, lo que hace que sea TRUE como 1L.

# Conversión de datos a causa de otros::

ln <- c(TRUE, 1L) # Con el "L", después del numero, le decimos que ese numero es un entero (integer)

## Como podemos ver el vector es de tipo entero, es decir Gracias a "1L", TRUE pasa a ser integer:
print(typeof(ln))
## [1] "integer"

Modificación:

En R, una variable en sí misma no se declara de ningún tipo de datos, sino que obtiene el tipo de datos del objeto R que se le asigna.

Entonces, R se llama lenguaje de tipado dinámico, lo que significa que podemos cambiar el tipo de datos de una variable de la misma variable una y otra vez cuando la usamos en un programa.

# Modificar una varible cuantas veces sea necesario:
Variable_de_Cambio <- "Soy una cadena de texto que muy pronto cambiara a otro tipo de dato"
cat("La clase de la varible es :", class(Variable_de_Cambio), "\n")
## La clase de la varible es : character
Variable_de_Cambio <- logical(2)
cat("Ahora soy de tipo :", class(Variable_de_Cambio), "\n")
## Ahora soy de tipo : logical
Variable_de_Cambio <- 1+21i
cat("Mi nueva clase es :", class(Variable_de_Cambio), "Que complejo es ser complejo", "\n")
## Mi nueva clase es : complex Que complejo es ser complejo

La Función ls() (¡Importante!):

Para conocer todas las variables disponibles actualmente en el espacio de trabajo usamos la función ls() . Además, la función ls() puede usar patrones para hacer coincidir los nombres de las variables.

# Vemaos el nombre de todas nuestra variables descritas hasta ahora:
print(ls())
## [1] "f"                    "ln"                   "logico"              
## [4] "NombresDeEstudiantes" "v"                    "v_equal"             
## [7] "variable_con_fechas"  "variable_con_igual"   "Variable_de_Cambio"
## Con la opción pattern = "@", encontraremos todas las varibales con el patron (imprima todas las varoables que empiencen "@")

print(ls(pattern = "variable"))
## [1] "variable_con_fechas" "variable_con_igual"
## Las variables que comienzan con un punto (.) Están ocultas, se pueden listar usando el argumento "all.names = TRUE" para la función ls ().

print(ls(all.names = TRUE))
## [1] "f"                    "ln"                   "logico"              
## [4] "NombresDeEstudiantes" "v"                    "v_equal"             
## [7] "variable_con_fechas"  "variable_con_igual"   "Variable_de_Cambio"

Eliminar variables:

Las variables se pueden eliminar utilizando la función rm().

# Eliminaremos variables con rm():

## Llamamos a la función para mostrar que si estan definidas dentro de R:
cat(v_equal, "\n")
## 321
cat(variable_con_igual, "\n")
## Soy un characther definido con =
## La eliminaremos con rm():
rm(v_equal)
rm(variable_con_igual)

## Volvemos a tomar las variables  ver si siguen definidas:

"Puede verificar si la variable se elimina o no con la ayuda de cat()"
## [1] "Puede verificar si la variable se elimina o no con la ayuda de cat()"
### NO EJECUTAR, (SALDRA ERROR):
"cat(v_equal)"
## [1] "cat(v_equal)"
"cat(variable_con_igual)"
## [1] "cat(variable_con_igual)"

Operadores:

Los operadores son los símbolos que le indican a R que debe realizar una tarea. Combinando datos y operadores es que logramos que R haga su trabajo.

Existen operadores específicos para cada tipo de tarea. Los tipos de operadores principales son los siguientes:

Operadores Aritméticos:

Como su nombre lo indica, este tipo de operador es usado para operaciones aritméticas.

En R tenemos los siguientes operadores aritméticos:

Operador Operación
+ Suma
- Resta
* Multiplicación
/ División
^ Potencia
%% División Entera
  • NOTA: Cuando intentas realizar una operación aritmética con otro tipo de dato, R primero intentará coercionar ese dato a uno numérico. Si la coerción tiene éxito se realizará la operación normalmente, si falla, el resultado será un error.
# Operadores Aritmeticos:
"No es necesario el cat(), solo para ver el resultado en la consola"
## [1] "No es necesario el cat(), solo para ver el resultado en la consola"
## Suma:
cat(12+21)
## 33
## Resta:
cat(5-3)
## 2
## Multiplicación:
cat(4*12413)
## 49652
## División:
cat(720000/225)
## 3200
# Potencia:
cat(990.1515^2)
## 980400
## División Entera:

"Es el resuido de divir un numero sobre el otro"
## [1] "Es el resuido de divir un numero sobre el otro"
cat(250 %% 9)
## 7

Operadores Relaciones:

Los operadores relacionales son usados para hacer comparaciones y siempre devuelven como resultado TRUE o FALSE.

Operador Comparación
< Menor que
<= Menor o igual que
> Mayor que
== Exactamente igual que
!= No es igual que

  • Nota: Es posible comparar cualquier tipo de dato sin que resulte en un error.

    Sin embargo, al usar los operadores >, >=, < y <= con cadenas de texto, estos tienen un comportamiento especial.

# ¿porque con texto, jorge > ana?:

cat("Jorge" > "Ana")
## TRUE

Este resultado se debe a que se ha hecho una comparación por orden alfabético. En este caso, la palabra "Jorge" tendría una posición posterior a "Ana", pues empieza con “J” y esta letra tiene una posición posterior a la “A” en el alfabeto. Por lo tanto, es verdadero que sea “mayor”.

# Operadores relacionales:

## Menor que:
cat(1<100000, "\n")
## TRUE
## Menor o igualque:
cat(6<= 12, "\n")
## TRUE
## Mayor que:
cat(3231121> 13131, "\n")
## TRUE
## Mayor o igual que:
cat(1241>=113, "\n")
## TRUE
## Exactamente igual que:
x <- 5
y <- 5
cat("x:",x, "y:", y, "\n")
## x: 5 y: 5
cat(x == 5, "\n")
## TRUE
## NO es igual que:
cat(x!=y, "\n")
## FALSE

Operadores Lógicos:

Los operadores lógicos son usados para operaciones de álgebra Booleana, es decir, para describir relaciones lógicas, expresadas como verdadero (TRUE) o falso (FALSE).

Operador Comparación
x|y x Ó y es verdadero
x & y x Y y son verdaderos
!x x no es verdadero(Negación)
isTRUE(x) x es verdadero (afirmación)

los operadores | y & siguen las siguientes reglas:

  • | devuelve TRUE si algunos de los datos es TRUE
  • & solo devuelve TRUE si ambos de los datos es TRUE
  • | solo devuelve FALSE si ambos datos son FALSE
  • & devuelve FALSE si alguno de los datos es FALSE

NOTA:

  1. Estos operadores pueden ser usados con estos con datos de tipo numérico, lógico y complejo. Al igual que con los operadores relacionales, los operadores lógicos siempre devuelven TRUE o FALSE.

  2. Para realizar operaciones lógicas, todos los valores numéricos y complejos distintos a 0 son coercionados a TRUE, mientras que 0 siempre es coercionado a FALSE.

# Operadores Lógicos:

## OR:
cat(5|0, "\n")
## TRUE
## AND:
cat(5 & 0, "\n")
## FALSE
"¿Cero es TRUE o FALSE?..."
## [1] "¿Cero es TRUE o FALSE?..."
## Afirmación:
cat("El cero es :", isTRUE(0), "\n")
## El cero es : FALSE
## Negación:
cat( "Numero Complejo 12+1i es: ",!(12+1i), "\n",!(FALSE & FALSE), "\n")
## Numero Complejo 12+1i es:  FALSE 
##  TRUE

Operadores de asignación:

Este opereador esta al principio del documento, es decir: “Como se definen varibles”:

  • =
  • <-