Aprende Programación R

R es un lenguaje de programación que se utiliza principalmente para el aprendizaje automático, el análisis de datos y la computación estadística . Es un lenguaje interpretado y es independiente de la plataforma, lo que significa que se puede usar en plataformas como Windows, Linux y macOS.

En este tutorial de R Language, aprenderemos el lenguaje de programación R desde cero para avanzar y este tutorial es adecuado tanto para principiantes como para desarrolladores experimentados).

¿Por qué aprender el lenguaje de programación R?

• La programación R se utiliza como una herramienta líder para el aprendizaje automático, las estadísticas y el análisis de datos.
• R es un lenguaje de código abierto, lo que significa que es gratuito y cualquier persona de cualquier organización puede instalarlo sin comprar una licencia.
• Está disponible en plataformas ampliamente utilizadas como Windows, Linux y macOS.
• El lenguaje de programación R no es solo un paquete de estadísticas sino que también nos permite integrarnos con otros lenguajes (C, C++). Por lo tanto, puede interactuar fácilmente con muchas fuentes de datos y paquetes estadísticos.
• Su base de usuarios crece día a día y cuenta con un amplio apoyo de la comunidad.
• El lenguaje de programación R es actualmente uno de los lenguajes de programación más solicitados en el mercado laboral de Data Science, lo que lo convierte en la tendencia más popular en la actualidad.

Funciones y aplicaciones clave

Algunas características clave de R que hacen de R uno de los trabajos más exigentes en el mercado de la ciencia de datos son:

• Estadísticas básicas: los términos estadísticos básicos más comunes son la media, la moda y la mediana. Todos estos se conocen como «Medidas de tendencia central». Entonces, usando el lenguaje R podemos medir la tendencia central muy fácilmente.
• Gráficos estáticos: R es rico en funciones para crear y desarrollar varios tipos de gráficos estáticos, incluidos mapas gráficos, diagramas de mosaico, biplots, y la lista continúa.
• Distribuciones de probabilidad: al usar R, podemos manejar fácilmente varios tipos de distribución de probabilidad, como la distribución binomial, la distribución normal, la distribución de chi-cuadrado y muchas más.
• Paquetes R: una de las principales características de R es que tiene una amplia disponibilidad de bibliotecas. R tiene CRAN (Comprehensive R Archive Network), que es un repositorio que contiene más de 10,0000 paquetes.
• Computación distribuida: la computación distribuida es un modelo en el que los componentes de un sistema de software se comparten entre varias computadoras para mejorar la eficiencia y el rendimiento. En noviembre de 2015 se lanzaron dos nuevos paquetes, ddR y multidplyr, utilizados para la programación distribuida en R.

Aplicaciones de R

Descarga e Instalación

Hay muchos IDE disponibles para usar R, en este artículo trataremos la instalación de RStudio en R.

Consulte los artículos a continuación para obtener información detallada sobre RStudio y su instalación.

• ¿Cómo instalar R Studio en Windows y Linux?
• Introducción a R Studio
• Creación y ejecución de archivo R en R Studio

Hola mundo en R

El programa R se puede ejecutar de varias maneras. Puede elegir cualquiera de las siguientes opciones para continuar con este tutorial.

• Usando IDE como RStudio, Eclipse, Jupyter, Notebook, etc.
• Uso del símbolo del sistema R
• Uso de secuencias de comandos R

Ahora escriba el siguiente código para imprimir hola mundo en su consola.

# R Program to print
# Hello World
 
print("HelloWorld")

 Producción:

[1] "HelloWorld"

Nota: Para obtener más información, consulte Programación Hello World en R

Fundamentos de R

Variables:

R es un lenguaje tipado dinámicamente, es decir, las variables no se declaran con un tipo de datos, sino que toman el tipo de datos del objeto R que se les ha asignado. En R, la asignación se puede denotar de tres formas.

• Usando operadores iguales, los datos se copian de derecha a izquierda.

variable_name = value

• Usando el operador hacia la izquierda, los datos se copian de derecha a izquierda.

variable_name <- value

• Usando el operador hacia la derecha, los datos se copian de izquierda a derecha.

value -> variable_name

Ejemplo:

# R program to illustrate
# Initialization of variables
 
# using equal to operator
var1 = "gfg"
print(var1)
 
# using leftward operator
var2 <- "gfg"
print(var2)
 
# using rightward operator
"gfg" -> var3
print(var3)

 Producción:

[1] "gfg"
[1] "gfg"
[1] "gfg"

Nota: Para obtener más información, consulte R – Variables .

Comentarios:

Los comentarios son las oraciones en inglés que se utilizan para agregar información útil al código fuente para que sea más comprensible para el lector. Explica la parte lógica utilizada en el código y no tendrá ningún impacto en el código durante su ejecución. Cualquier declaración que comience con «#» es un comentario en R.

Ejemplo:

# all the lines starting with '#'
# are comments and will be ignored
# during the execution of the
# program
 
# Assigning values to variables
a <- 1
b <- 2
 
# Printing sum
print(a + b)

Producción:

[1] 3

Nota: Para obtener más información, consulte Comentarios en R

Operadores

Los operadores son los símbolos que dirigen los diversos tipos de operaciones que se pueden realizar entre los operandos. Los operadores simulan las diversas operaciones matemáticas, lógicas y de decisión realizadas en un conjunto de números complejos, enteros y numéricos como operandos de entrada. Estos se clasifican en función de su funcionalidad:

• Operadores aritméticos: Las operaciones aritméticas simulan varias operaciones matemáticas, como suma, resta, multiplicación, división y módulo.

Ejemplo:

# R program to illustrate
# the use of Arithmetic operators
a <- 12
b <- 5
 
# Performing operations on Operands
cat ("Addition :", a + b, "\n")
cat ("Subtraction :", a - b, "\n")
cat ("Multiplication :", a * b, "\n")
cat ("Division :", a / b, "\n")
cat ("Modulo :", a %% b, "\n")
cat ("Power operator :", a ^ b)

 Producción:

Addition : 17 
Subtraction : 7 
Multiplication : 60 
Division : 2.4 
Modulo : 2 
Power operator : 248832

• Operadores lógicos: las operaciones lógicas simulan operaciones de decisión por elementos, en función del operador especificado entre los operandos, que luego se evalúan como un valor booleano verdadero o falso.

Ejemplo:

# R program to illustrate
# the use of Logical operators
vec1 <- c(FALSE, TRUE)
vec2 <- c(TRUE,FALSE)
 
# Performing operations on Operands
cat ("Element wise AND :", vec1 & vec2, "\n")
cat ("Element wise OR :", vec1 | vec2, "\n")
cat ("Logical AND :", vec1 && vec2, "\n")
cat ("Logical OR :", vec1 || vec2, "\n")
cat ("Negation :", !vec1)

 Producción:

Element wise AND : FALSE FALSE 
Element wise OR : TRUE TRUE 
Logical AND : FALSE 
Logical OR : TRUE 
Negation : TRUE FALSE

• Operadores Relacionales: Los operadores relacionales realizan operaciones de comparación entre los elementos correspondientes de los operandos.

Ejemplo:

# R program to illustrate
# the use of Relational operators
a <- 10
b <- 14
 
# Performing operations on Operands
cat ("a less than b :", a < b, "\n")
cat ("a less than equal to b :", a <= b, "\n")
cat ("a greater than b :", a > b, "\n")
cat ("a greater than equal to b :", a >= b, "\n")
cat ("a not equal to b :", a != b, "\n")

 Producción:

a less than b : TRUE 
a less than equal to b : TRUE 
a greater than b : FALSE 
a greater than equal to b : FALSE 
a not equal to b : TRUE 

• Operadores de asignación: los operadores de asignación se utilizan para asignar valores a varios objetos de datos en R.

Ejemplo:

# R program to illustrate
# the use of Assignment operators
 
# Left assignment operator
v1 <- "GeeksForGeeks"
v2 <<- "GeeksForGeeks"
v3 = "GeeksForGeeks"
 
# Right Assignment operator
"GeeksForGeeks" ->> v4
"GeeksForGeeks" -> v5
 
# Performing operations on Operands
cat("Value 1 :", v1, "\n")
cat("Value 2 :", v2, "\n")
cat("Value 3 :", v3, "\n")
cat("Value 4 :", v4, "\n")
cat("Value 5 :", v5)

 Producción:

Value 1 : GeeksForGeeks 
Value 2 : GeeksForGeeks 
Value 3 : GeeksForGeeks 
Value 4 : GeeksForGeeks 
Value 5 : GeeksForGeeks

Nota: Para obtener más información, consulte R – Operadores

Palabras clave:

Las palabras clave son palabras reservadas específicas en R, cada una de las cuales tiene una característica específica asociada. Aquí está la lista de palabras clave en R:

Nota: Para obtener más información, consulte R – Palabras clave

Tipos de datos

Cada variable en R tiene un tipo de datos asociado . Cada tipo de datos requiere diferentes cantidades de memoria y tiene algunas operaciones específicas que se pueden realizar sobre él. R admite 5 tipos de tipos de datos. Estos son –

Ejemplo:

# A simple R program
# to illustrate data type
 
print("Numberic type")
# Assign a decimal value to x
x = 12.25
 
# print the class name of variable
print(class(x))
 
# print the type of variable
print(typeof(x))
 
print("----------------------------")
print("Integer Type")
# Declare an integer by appending an
# L suffix.
y = 15L
 
# print the class name of y
print(class(y))
 
# print the type of y
print(typeof(y))
 
print("----------------------------")
print("Logical Type")
# Sample values
x = 1
y = 2
 
# Comparing two values
z = x > y
 
# print the logical value
print(z)
 
# print the class name of z
print(class(z))
 
# print the type of z
print(typeof(z))
 
print("----------------------------")
print("Complex Type")
# Assign a complex value to x
x = 12 + 13i
 
# print the class name of x
print(class(x))
 
# print the type of x
print(typeof(x))
 
print("----------------------------")
print("Character Type")
 
# Assign a character value to char
char = "GFG"
 
# print the class name of char
print(class(char))
 
# print the type of char
print(typeof(char))

 
 Producción:

[1] "Numberic type"
[1] "numeric"
[1] "double"
[1] "----------------------------"
[1] "Integer Type"
[1] "integer"
[1] "integer"
[1] "----------------------------"
[1] "Logical Type"
[1] TRUE
[1] "logical"
[1] "logical"
[1] "----------------------------"
[1] "Complex Type"
[1] "complex"
[1] "complex"
[1] "----------------------------"
[1] "Character Type"
[1] "character"
[1] "character"

Nota: para obtener más información, consulte R – Tipos de datos

Conceptos básicos de entrada/salida

Tomando la entrada del usuario:

R Language nos proporciona dos funciones incorporadas para leer la entrada desde el teclado.

• método readline(): Toma entrada en formato de string. Si uno ingresa un número entero, entonces se ingresa como una string.

Ejemplo:

# R program to illustrate
# taking input from the user
 
# taking input using readline()
# this command will prompt you
# to input a desired value
var = readline();

• Método scan(): este método lee datos en forma de vector o lista. Este método es muy útil, ya que se necesitan entradas para realizar rápidamente cualquier cálculo matemático o para cualquier conjunto de datos.

Ejemplo:

# R program to illustrate
# taking input from the user
 
# taking input using scan()
x = scan()

Nota: Para obtener más información, consulte Toma de entrada del usuario en la programación R

Salida de impresión a la consola:

R Proporciona varias funciones para escribir la salida en la pantalla, veámoslas:

• print(): es el método más común para imprimir la salida.

Ejemplo: 

# R program to illustrate
# printing output of an R program
 
# print string
print("Hello")
 
# print variable
# it will print 'GeeksforGeeks' on
# the console
x <- "Welcome to GeeksforGeeks"
print(x)

 Producción:

[1] "Hello"
[1] "Welcome to GeeksforGeeks"

• cat(): cat() convierte sus argumentos en strings de caracteres. Esto es útil para imprimir resultados en funciones definidas por el usuario.
   

Ejemplo:

# R program to illustrate
# printing output of an R
# program
 
# print string with variable
# "\n" for new line
x = "Hello"
cat(x, "\nwelcome")
 
# print normal string
cat("\nto GeeksForGeeks")

 Producción:

Hello 
welcome
to GeeksForGeeks

Nota: Para obtener más información, consulte Salida de impresión de un programa R

Toma de decisiones

La toma de decisiones decide el flujo de ejecución del programa en función de ciertas condiciones. En la toma de decisiones, el programador debe proporcionar alguna condición que sea evaluada por el programa, junto con ella también se proporcionan algunas declaraciones que se ejecutan si la condición es verdadera y, opcionalmente, otras declaraciones si la condición se evalúa como falsa.

Declaraciones de toma de decisiones en lenguaje R:

• si declaración
• sentencia if-else
• if-else-if escalera
• instrucción if-else anidada
• declaración de cambio

Ejemplo 1: demostración de if y if-else

# R program to illustrate
# decision making
 
a <- 99
b <- 12
 
# if statement to check whether
# the number a is larger or not
if(a > b)
{
    print("A is Larger")
}
 
 
# if-else statement to check which
# number is greater
if(b > a)
{
    print("B is Larger")
} else
{
    print("A is Larger")
}

 Producción:

[1] "A is Larger"
[1] "A is Larger"

Ejemplo 2: demostración de if-else-if y if anidado

# R program to demonstrate
# decision making
  
a <- 10
  
# is-elif
if (a == 11)
{
    print ("a is 11")
} else if (a==10)
{
    print ("a is 10")
} else
    print ("a is not present")
 
# Nested if to check whether a
# number is divisible by both 2 and 5
if (a %% 2 == 0)
{
    if (a %% 5 == 0)
        print("Number is divisible by both 2 and 5")
}

 Producción:

[1] "a is 10"
[1] "Number is divisible by both 2 and 5"

Ejemplo 3: Demostración del interruptor

# R switch statement example
 
# Expression in terms of the index value
x <- switch(
    2,             # Expression
    "Welcome",     # case 1
    "to",         # case 2
    "GFG"         # case 3
)
print(x)
 
# Expression in terms of the string value
y <- switch(
    "3",                 # Expression
    "0"="Welcome",     # case 1
    "1"="to",         # case 2
    "3"="GFG"         # case 3
)
print(y)
 
z <- switch(
    "GfG",                 # Expression
    "GfG0"="Welcome",     # case 1
    "GfG1"="to",         # case 2
    "GfG3"="GFG"         # case 3
)
print(z)

 Producción:

[1] "to"
[1] "GFG"
NULL 

Nota: Para obtener más información, consulte Toma de decisiones en programación R

Flujo de control

Los bucles se utilizan siempre que tenemos que ejecutar un bloque de sentencias repetidamente. Por ejemplo, imprimir «hola mundo» 10 veces. Los diferentes tipos de bucles en R son:

• En bucle

Ejemplo:

# R Program to demonstrate the use of
# for loop along with concatenate
for (i in c(-8, 9, 11, 45))
{
    print(i)
}

 
 Producción:

[1] -8
[1] 9
[1] 11
[1] 45

• Mientras bucle

Ejemplo:

# R program to demonstrate the
# use of while loop
 
val = 1
 
# using while loop
while (val <= 5 )
{
    # statements
    print(val)
    val = val + 1
}

 Producción:

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

• Repetir bucle

Ejemplo:

# R program to demonstrate the use
# of repeat loop
 
val = 1
 
# using repeat loop
repeat
{
    # statements
    print(val)
    val = val + 1
 
    # checking stop condition
    if(val > 5)
    {
        # using break statement
        # to terminate the loop
        break
    }
}

 Producción:

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

Nota: Para obtener más información, consulte Bucles en R

Declaraciones de control de bucle

Las declaraciones de control de bucle cambian la ejecución de su secuencia normal. Las siguientes son las declaraciones de control de bucle proporcionadas por R Language:

• Instrucción Break: La palabra clave break es una declaración de salto que se utiliza para terminar el ciclo en una iteración particular.
• Siguiente declaración: la siguiente declaración se usa para omitir la iteración actual en el bucle y pasar a la siguiente iteración sin salir del bucle.

# R program for break statement
no <- 15:20
 
for (val in no)
{
    if (val == 17)
    {
        break
    }
    print(paste("Values are: ", val))
}
 
print("------------------------------------")
 
# R Next Statement Example
for (val in no)
{
    if (val == 17)
    {
        next
    }
    print(paste("Values are: ", val))
}

 
Producción:

[1] "Values are:  15"
[1] "Values are:  16"
[1] "------------------------------------"
[1] "Values are:  15"
[1] "Values are:  16"
[1] "Values are:  18"
[1] "Values are:  19"
[1] "Values are:  20"

Nota: Para obtener más información, consulte las sentencias Break y Next en R

Funciones

Las funciones son el bloque de código que le da al usuario la capacidad de reutilizar el mismo código, lo que ahorra el uso excesivo de memoria y proporciona una mejor legibilidad del código. Básicamente, una función es una colección de declaraciones que realizan una tarea específica y devuelven el resultado a la persona que llama. Las funciones se crean en R usando la palabra clave command function()

Ejemplo:

# A simple R program to
# demonstrate functions
 
ask_user = function(x){
    print("GeeksforGeeks")
}
 
my_func = function(x){
    a <- 1:5
    b <- 0
     
    for (i in a){
        b = b +1
    }
    return(b)
}
 
ask_user()
res = my_func()
print(res)

 Producción: 

[1] "GeeksforGeeks"
[1] 5

Función con argumentos:

Los argumentos de una función se pueden especificar en el momento de la definición de la función, después del nombre de la función, dentro del paréntesis.

Ejemplo:

# A simple R function to check
# whether x is even or odd
 
evenOdd = function(x){
    if(x %% 2 == 0)
         
        # return even if the number
        # is even
        return("even")
    else
         
        # return odd if the number
        # is odd
        return("odd")
}
 
# Function definition
# To check a is divisible by b or not
divisible <- function(a, b){
    if(a %% b == 0)
    {
        cat(a, "is divisible by", b, "\n")
    } else
    {
        cat(a, "is not divisible by", b, "\n")
    }
}
 
# function with single argument
print(evenOdd(4))
print(evenOdd(3))
 
# function with multiple arguments
divisible(7, 3)
divisible(36, 6)
divisible(9, 2)

 Producción:

[1] "even"
[1] "odd"
7 is not divisible by 3 
36 is divisible by 6 
9 is not divisible by 2 

• Argumentos predeterminados: el valor predeterminado en una función es un valor que no es necesario especificar cada vez que se llama a la función.

Ejemplo:

# Function definition to check
# a is divisible by b or not.
 
# If b is not provided in function call,
# Then divisibility of a is checked
# with 3 as default
isdivisible <- function(a, b = 9){
    if(a %% b == 0)
    {
        cat(a, "is divisible by", b, "\n")
    } else
    {
        cat(a, "is not divisible by", b, "\n")
    }
}
 
# Function call
isdivisible(20, 2)
isdivisible(12)

 Producción:

20 is divisible by 2 
12 is not divisible by 9 

• Argumentos de longitud variable: el argumento de puntos (…) también se conoce como puntos suspensivos, lo que permite que la función tome un número indefinido de argumentos.

Ejemplo:

# Function definition of dots operator
fun <- function(n, ...){
    l <- c(n, ...)
    paste(l, collapse = " ")
}
 
# Function call
fun(5, 1L, 6i, TRUE, "GFG", 1:2)

 Producción:

5 1 0+6i TRUE GFG 1 2

Consulte los siguientes artículos para obtener información detallada sobre las funciones en R

• Funciones en Programación R
• Argumentos de función en la programación R
• Tipos de funciones en la programación R

Estructuras de datos

Una estructura de datos es una forma particular de organizar los datos en una computadora para que pueda usarse de manera efectiva. 

Vectores:

Los vectores en R son los mismos que las arrays en lenguaje C que se utilizan para contener múltiples valores de datos del mismo tipo. Un punto clave importante es que en R la indexación del vector comenzará desde ‘1’ y no desde ‘0’.

Ejemplo:

# R program to illustrate Vector
 
# Numeric Vector
N = c(1, 3, 5, 7, 8)
 
# Character vector
C = c('Geeks', 'For', 'Geeks')
 
# Logical Vector
L = c(TRUE, FALSE, FALSE, TRUE)
 
# Printing vectors
print(N)
print(C)
print(L)

 Producción:

[1] 1 3 5 7 8
[1] "Geeks" "For"   "Geeks"
[1]  TRUE FALSE FALSE  TRUE

Acceso a elementos vectoriales: 

Hay muchas formas a través de las cuales podemos acceder a los elementos del vector. El más común es usar el símbolo ‘[]’.

Ejemplo:

# Accessing elements using
# the position number.
X <- c(2, 9, 8, 0, 5)
print('using Subscript operator')
print(X[2])
 
# Accessing specific values by passing
# a vector inside another vector.
Y <- c(6, 2, 7, 4, 0)
print('using c function')
print(Y[c(4, 1)])
 
# Logical indexing
Z <- c(1, 6, 9, 4, 6)
print('Logical indexing')
print(Z[Z>3])

 Producción:

[1] "using Subscript operator"
[1] 9
[1] "using c function"
[1] 4 6
[1] "Logical indexing"
[1] 6 9 4 6

Consulte los siguientes artículos para obtener información detallada sobre los vectores en R.

• R-Vector
• Tipos de vectores en programación R
• Operaciones sobre Vectores en R

Liza:

Una lista es un objeto genérico que consta de una colección ordenada de objetos. Las listas son estructuras de datos heterogéneas.

Ejemplo: 

# R program to create a List
 
# The first attributes is a numeric vector
# containing the employee IDs which is created
# using the command here
empId = c(1, 2, 3, 4)
 
# The second attribute is the employee name
# which is created using this line of code here
# which is the character vector
empName = c("Nisha", "Nikhil", "Akshu", "Sambha")
 
# The third attribute is the number of employees
# which is a single numeric variable.
numberOfEmp = 4
 
# The fourth attribute is the name of organization
# which is a single character variable.
Organization = "GFG"
 
# We can combine all these three different
# data types into a list
# containing the details of employees
# which can be done using a list command
empList = list(empId, empName, numberOfEmp, Organization)
 
print(empList)

 Producción: 

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

[[2]]
[1] "Nisha"  "Nikhil" "Akshu"  "Sambha"

[[3]]
[1] 4

[[4]]
[1] "GFG"

Acceder a los elementos de la lista:

• Acceder a los componentes por nombres: todos los componentes de una lista se pueden nombrar y podemos usar esos nombres para acceder a los componentes de la lista usando el comando dólar.
• Acceder a los componentes por índices: También podemos acceder a los componentes de la lista mediante índices. Para acceder a los componentes de nivel superior de una lista, debemos usar un operador de doble corte «[[ ]]» que son dos corchetes y si queremos acceder a los componentes de nivel inferior o interno de una lista, debemos usar otro cuadrado corchete «[ ]» junto con el operador de doble corte «[[ ]]».

Ejemplo: 

# R program to access
# components of a list
 
# Creating a list by naming all its components
empId = c(1, 2, 3, 4)
empName = c("Nisha", "Nikhil", "Akshu", "Sambha")
numberOfEmp = 4
empList = list(
"ID" = empId,
"Names" = empName,
"Total Staff" = numberOfEmp
)
print("Initial List")
print(empList)
 
# Accessing components by names
cat("\nAccessing name components using $ command\n")
print(empList$Names)
 
# Accessing a top level components by indices
cat("\nAccessing name components using indices\n")
print(empList[[2]])
print(empList[[1]][2])
print(empList[[2]][4])

 Producción:

[1] "Initial List"
$ID
[1] 1 2 3 4

$Names
[1] "Nisha"  "Nikhil" "Akshu"  "Sambha"

$`Total Staff`
[1] 4


Accessing name components using $ command
[1] "Nisha"  "Nikhil" "Akshu"  "Sambha"

Accessing name components using indices
[1] "Nisha"  "Nikhil" "Akshu"  "Sambha"
[1] 2
[1] "Sambha"

Agregar y modificar elementos de la lista:

• También se puede modificar una lista accediendo a los componentes y reemplazándolos por los que desee.
• Los elementos de la lista se pueden agregar simplemente asignando nuevos valores usando nuevas etiquetas.

Ejemplo:

# R program to access
# components of a list
 
# Creating a list by naming all its components
empId = c(1, 2, 3, 4)
empName = c("Nisha", "Nikhil", "Akshu", "Sambha")
numberOfEmp = 4
empList = list(
"ID" = empId,
"Names" = empName,
"Total Staff" = numberOfEmp
)
print("Initial List")
print(empList)
 
# Adding new element
empList[["organization"]] <- "GFG"
cat("\nAfter adding new element\n")
print(empList)
 
# Modifying the top-level component
empList$"Total Staff" = 5
   
# Modifying inner level component
empList[[1]][5] = 7
 
cat("\nAfter modification\n")
print(empList)

 Producción: 

[1] "Initial List"
$ID
[1] 1 2 3 4

$Names
[1] "Nisha"  "Nikhil" "Akshu"  "Sambha"

$`Total Staff`
[1] 4


After adding new element
$ID
[1] 1 2 3 4

$Names
[1] "Nisha"  "Nikhil" "Akshu"  "Sambha"

$`Total Staff`
[1] 4

$organization
[1] "GFG"


After modification
$ID
[1] 1 2 3 4 7

$Names
[1] "Nisha"  "Nikhil" "Akshu"  "Sambha"

$`Total Staff`
[1] 5

$organization
[1] "GFG"

Consulte los siguientes artículos para obtener información detallada sobre las listas en R

• R – Listas
• Operaciones sobre Listas en Programación R
• Lista bidimensional en programación R
• Lista nombrada en programación R

Arrays:

Una array es un arreglo rectangular de números en filas y columnas. Las arrays son estructuras de datos bidimensionales y homogéneas.

Ejemplo:

# R program to illustrate a matrix
 
A = matrix(
    # Taking sequence of elements
    c(1, 4, 5, 6, 3, 8),
 
    # No of rows and columns
    nrow = 2, ncol = 3,
 
    # By default matrices are
    # in column-wise order
    # So this parameter decides
    # how to arrange the matrix
    byrow = TRUE
)
 
print(A)

 Producción:

     [,1] [,2] [,3]
[1,]    1    4    5
[2,]    6    3    8

Accediendo a los Elementos de la Array:

Se puede acceder a los elementos de la array usando el nombre de la array seguido de un corchete con una coma entre la array. El valor antes de la coma se usa para acceder a las filas y el valor que está después de la coma se usa para acceder a las columnas.

Ejemplo:

# R program to illustrate
# access rows in metrics
 
# Create a 3x3 matrix
A = matrix(
c(1, 4, 5, 6, 3, 8),
nrow = 2, ncol = 3,
byrow = TRUE       
)
cat("The 2x3 matrix:\n")
print(A)
 
print(A[1, 1]) 
print(A[2, 2])
 
# Accessing first and second row
cat("Accessing first and second row\n")
print(A[1:2, ])
 
# Accessing first and second column
cat("\nAccessing first and second column\n")
print(A[, 1:2])

 Producción:

The 2x3 matrix:
     [,1] [,2] [,3]
[1,]    1    4    5
[2,]    6    3    8
[1] 1
[1] 3
Accessing first and second row
     [,1] [,2] [,3]
[1,]    1    4    5
[2,]    6    3    8

Accessing first and second column
     [,1] [,2]
[1,]    1    4
[2,]    6    3

 Modificación de elementos de array:

Puede modificar los elementos de las arrays mediante una asignación directa.

Ejemplo:

# R program to illustrate
# editing elements in metrics
 
# Create a 3x3 matrix
A = matrix(
    c(1, 4, 5, 6, 3, 8),
    nrow = 2,
    ncol = 3,
    byrow = TRUE
)
cat("The 2x3 matrix:\n")
print(A)
 
# Editing the 3rd rows and 3rd
# column element from 9 to 30
# by direct assignments
A[2, 1] = 30
 
cat("After edited the matrix\n")
print(A)

 Producción:

The 2x3 matrix:
     [,1] [,2] [,3]
[1,]    1    4    5
[2,]    6    3    8
After edited the matrix
     [,1] [,2] [,3]
[1,]    1    4    5
[2,]   30    3    8

Consulte los siguientes artículos para obtener información detallada sobre Arrays en R

• R – Arrays
• Operaciones sobre Arrays en R
• Operaciones algebraicas sobre una array en R
• Transposición de array en R
• Inversa de array en R

Marco de datos:

Los marcos de datos son objetos de datos genéricos de R que se utilizan para almacenar los datos tabulares. Son estructuras de datos bidimensionales y heterogéneas. Estas son listas de vectores de igual longitud.

Ejemplo:

# R program to illustrate dataframe
 
# A vector which is a character vector
Name = c("Nisha", "Nikhil", "Raju")
 
# A vector which is a character vector
Language = c("R", "Python", "C")
 
# A vector which is a numeric vector
Age = c(40, 25, 10)
 
# To create dataframe use data.frame command
# and then pass each of the vectors
# we have created as arguments
# to the function data.frame()
df = data.frame(Name, Language, Age)
 
print(df)

 Producción:

    Name Language Age
1  Nisha        R  40
2 Nikhil   Python  25
3   Raju        C  10

Obtener la estructura y los datos de DataFrame:

• Uno puede obtener la estructura del marco de datos usando la función str() .
• Se puede extraer una columna específica de un marco de datos usando su nombre de columna.

Ejemplo:

# R program to get the
# structure of the data frame
 
# creating a data frame
friend.data <- data.frame(
    friend_id = c(1:5),
    friend_name = c("Aman", "Nisha",
                    "Nikhil", "Raju",
                    "Raj"),
    stringsAsFactors = FALSE
)
# using str()
print(str(friend.data))
 
# Extracting friend_name column
result <- data.frame(friend.data$friend_name)
print(result)

 
 Producción:

'data.frame':    5 obs. of  2 variables:
 $ friend_id  : int  1 2 3 4 5
 $ friend_name: chr  "Aman" "Nisha" "Nikhil" "Raju" ...
NULL
  friend.data.friend_name
1                    Aman
2                   Nisha
3                  Nikhil
4                    Raju
5                     Raj

Resumen del marco de datos:

El resumen estadístico y la naturaleza de los datos se pueden obtener aplicando la función summary() .

Ejemplo:

# R program to get the
# structure of the data frame
 
# creating a data frame
friend.data <- data.frame(
    friend_id = c(1:5),
    friend_name = c("Aman", "Nisha",
                    "Nikhil", "Raju",
                    "Raj"),
    stringsAsFactors = FALSE
)
# using summary()
print(summary(friend.data))

 
 Producción:

   friend_id friend_name       
 Min.   :1   Length:5          
 1st Qu.:2   Class :character  
 Median :3   Mode  :character  
 Mean   :3                     
 3rd Qu.:4                     
 Max.   :5                     

Consulte los siguientes artículos para obtener información detallada sobre DataFrames en R

• R – Marcos de datos
• Operaciones de tramas de datos
• Manipulación de tramas de datos
• Unión de marcos de datos
• Remodelación de datos
• Manejo de valores faltantes

Arrays:

Las arrays son los objetos de datos R que almacenan los datos en más de dos dimensiones. Los arreglos son estructuras de datos n-dimensionales.

Ejemplo:

# R program to illustrate an array
 
A = array(
    # Taking sequence of elements
    c(2, 4, 5, 7, 1, 8, 9, 2),
 
    # Creating two rectangular matrices
    # each with two rows and two columns
    dim = c(2, 2, 2)
)
 
print(A)

 Producción:

, , 1

     [,1] [,2]
[1,]    2    5
[2,]    4    7

, , 2

     [,1] [,2]
[1,]    1    9
[2,]    8    2

Accediendo a las arrays:

Se puede acceder a las arrays mediante el uso de índices para diferentes dimensiones separados por comas. Se pueden especificar diferentes componentes mediante cualquier combinación de nombres o posiciones de elementos.

Ejemplo:

vec1 <- c(2, 4, 5, 7, 1, 8, 9, 2)
vec2 <- c(12, 21, 34)
 
row_names <- c("row1", "row2")
col_names <- c("col1", "col2", "col3")
mat_names <- c("Mat1", "Mat2")
 
arr = array(c(vec1, vec2), dim = c(2, 3, 2),
            dimnames = list(row_names,
                            col_names, mat_names))
 
# accessing matrix 1 by index value
print ("Matrix 1")
print (arr[,,1])
 
# accessing matrix 2 by its name
print ("Matrix 2")
print(arr[,,"Mat2"])
 
# accessing matrix 1 by index value
print ("1st column of matrix 1")
print (arr[, 1, 1])
   
# accessing matrix 2 by its name
print ("2nd row of matrix 2")
print(arr["row2",,"Mat2"])
 
# accessing matrix 1 by index value
print ("2nd row 3rd column matrix 1 element")
print (arr[2, "col3", 1])
   
# accessing matrix 2 by its name
print ("2nd row 1st column element of matrix 2")
print(arr["row2", "col1", "Mat2"])
 
# print elements of both the rows and columns
# 2 and 3 of matrix 1
print (arr[, c(2, 3), 1])

 Producción:

[1] "Matrix 1"
     col1 col2 col3
row1    2    5    1
row2    4    7    8
[1] "Matrix 2"
     col1 col2 col3
row1    9   12   34
row2    2   21    2
[1] "1st column of matrix 1"
row1 row2 
   2    4 
[1] "2nd row of matrix 2"
col1 col2 col3 
   2   21    2 
[1] "2nd row 3rd column matrix 1 element"
[1] 8
[1] "2nd row 1st column element of matrix 2"
[1] 2
     col2 col3
row1    5    1
row2    7    8

Agregar elementos a la array:

Los elementos se pueden agregar en las diferentes posiciones de la array. La secuencia de elementos se conserva en el orden en que se agregaron a la array. Hay varias funciones integradas disponibles en R para agregar nuevos valores:

• c(vector, valores)
• agregar (vector, valores):
• Usando la función de longitud de la array

Ejemplo:

# creating a uni-dimensional array
x <- c(1, 2, 3, 4, 5)
 
# addition of element using c() function
x <- c(x, 6)
print ("Array after 1st modification ")
print (x)
 
# addition of element using append function
x <- append(x, 7)
print ("Array after 2nd modification ")
print (x)
 
# adding elements after computing the length
len <- length(x)
x[len + 1] <- 8
print ("Array after 3rd modification ")
print (x)
 
# adding on length + 3 index
x[len + 3]<-9
print ("Array after 4th modification ")
print (x)
 
# append a vector of values to the
# array after length + 3 of array
print ("Array after 5th modification")
x <- append(x, c(10, 11, 12), after = length(x)+3)
print (x)
 
# adds new elements after 3rd index
print ("Array after 6th modification")
x <- append(x, c(-1, -1), after = 3)
print (x)

 Producción:

[1] "Array after 1st modification "
[1] 1 2 3 4 5 6
[1] "Array after 2nd modification "
[1] 1 2 3 4 5 6 7
[1] "Array after 3rd modification "
[1] 1 2 3 4 5 6 7 8
[1] "Array after 4th modification "
 [1]  1  2  3  4  5  6  7  8 NA  9
[1] "Array after 5th modification"
 [1]  1  2  3  4  5  6  7  8 NA  9 10 11 12
[1] "Array after 6th modification"
 [1]  1  2  3 -1 -1  4  5  6  7  8 NA  9 10 11 12

Eliminación de elementos de la array:

• Los elementos se pueden eliminar de las arrays en R, ya sea uno a la vez o varios juntos. Estos elementos se especifican como índices de la array, donde los valores de la array que satisfacen las condiciones se conservan y el resto se elimina.
• Otra forma de eliminar elementos es mediante el uso del operador %in% en el que el conjunto de valores de los elementos que pertenecen a los valores VERDADEROS del operador se muestran como resultado y el resto se elimina.

Ejemplo:

# creating an array of length 9
m <- c(1, 2, 3, 4, 5, 6, 7, 8, 9)
print ("Original Array")
print (m)
 
# remove a single value element:3
# from array
m <- m[m != 3]
print ("After 1st modification")
print (m)
 
# removing elements based on condition
# where either element should be
# greater than 2 and less than equal
# to 8
m <- m[m>2 & m<= 8]
print ("After 2nd modification")
print (m)
 
# remove sequence of elements using
# another array
remove <- c(4, 6, 8)
 
# check which element satisfies the
# remove property
print (m % in % remove)
print ("After 3rd modification")
print (m [! m % in % remove])

 Producción:

[1] "Original Array"
[1] 1 2 3 4 5 6 7 8 9
[1] "After 1st modification"
[1] 1 2 4 5 6 7 8 9
[1] "After 2nd modification"
[1] 4 5 6 7 8
[1]  TRUE FALSE  TRUE FALSE  TRUE
[1] "After 3rd modification"
[1] 5 7

Consulte los artículos a continuación para obtener información detallada sobre las arrays en R.

• R-array
• Array multidimensional
• Operaciones de array

Factores:

Los factores son los objetos de datos que se utilizan para categorizar los datos y almacenarlos como niveles. Son útiles para almacenar datos categóricos.

Ejemplo:

# Creating a vector
x<-c("female", "male", "other", "female", "other")
 
# Converting the vector x into
# a factor named gender
gender<-factor(x)
print(gender)

 Producción: 

[1] female male   other  female other 
Levels: female male other

Accediendo a elementos de un Factor:

Al igual que accedemos a los elementos de un vector, de la misma manera accedemos a los elementos de un factor
 

Ejemplo:

x<-c("female", "male", "other", "female", "other")
print(x[3])

 Producción:

[1] "other"

Modificación de un factor:

Después de que se forma un factor, sus componentes pueden modificarse pero los nuevos valores que deben asignarse deben estar en el nivel predefinido.

Ejemplo:

x<-c("female", "male", "other", "female", "other")
x[1]<-"male"
print(x)

Producción:

[1] "male"   "male"   "other"  "female" "other" 

Consulte los siguientes artículos para obtener información detallada Factores.

• R – Factores
• Nivel de ordenación de factores

Manejo de errores

El manejo de errores es un proceso en el que nos ocupamos de los errores no deseados o anómalos que pueden causar la terminación anormal del programa durante su ejecución. En R

• La función stop() generará errores
• La función stopifnot() tomará una expresión lógica y si alguna de las expresiones es FALSA, generará el error especificando qué expresión es FALSA.
• La advertencia() creará la advertencia pero no detendrá la ejecución.

El manejo de errores se puede hacer usando tryCatch(). El primer argumento de esta función es la expresión seguida de la condición que especifica cómo manejar las condiciones.

Sintaxis:

check = tryCatch({
   expression
}, warning = function(w){
   code that handles the warnings
}, error = function(e){
   code that handles the errors
}, finally = function(f){
   clean-up code
})

Ejemplo:

# R program illustrating error handling
 
# Evaluation of tryCatch
check <- function(expression){
 
  tryCatch(expression,
          
         warning = function(w){
           message("warning:\n", w)
         },
         error = function(e){
           message("error:\n", e)
         },
         finally = {
           message("Completed")
         })
}
 
check({10/2})
check({10/0})
check({10/'noe'})

 
 Producción:

Consulte los artículos a continuación para obtener información detallada sobre el manejo de errores en R

• Manejo de errores en la programación R
• Manejo de condiciones
• Depuración en Programación R

Tablas y Gráficos

En un escenario del mundo real, se produce una enorme cantidad de datos a diario, por lo que interpretarlos puede ser algo ajetreado. Aquí entra en juego la visualización de datos porque siempre es mejor visualizar esos datos a través de cuadros y gráficos , para obtener información significativa en lugar de examinar enormes hojas de Excel. Veamos algunas gráficas básicas en Programación R.

Gráfico de barras:

R usa la función barplot() para crear gráficos de barras . Aquí, se pueden dibujar tanto barras verticales como horizontales.

Ejemplo:

# Create the data for the chart
A <- c(17, 32, 8, 53, 1)
 
# Plot the bar chart
barplot(A, xlab = "X-axis", ylab = "Y-axis",
        main ="Bar-Chart")

Producción:

Nota: Para obtener más información, consulte Gráficos de barras en R

Histogramas:

R crea un histograma usando la función hist().

Ejemplo: 

# Create data for the graph.
v <- c(19, 23, 11, 5, 16, 21, 32,
       14, 19, 27, 39)
 
# Create the histogram.
hist(v, xlab = "No.of Articles ",
     col = "green", border = "black")

 
 Producción:

Nota: Para obtener más información, consulte Histogramas en lenguaje R

Gráfico de dispersión:

El diagrama de dispersión simple se crea utilizando la función plot().

Ejemplo:

# Create the data for the chart
A <- c(17, 32, 8, 53, 1)
B <- c(12, 43, 17, 43, 10)
 
 
# Plot the bar chart
plot(x=A, y=B, xlab = "X-axis", ylab = "Y-axis",
        main ="Scatter Plot")

Producción:

Nota: Para obtener más información, consulte Gráficos de dispersión en lenguaje R

Gráfico de linea:

La función plot() en R se usa para crear el gráfico de líneas.

Ejemplo:

# Create the data for the chart.
v <- c(17, 25, 38, 13, 41)
 
# Plot the bar chart.
plot(v, type = "l", xlab = "X-axis", ylab = "Y-axis",
        main ="Line-Chart")

 
 Producción:

Nota: Para obtener más información, consulte Gráficos de líneas en lenguaje R.

Gráficos circulares:

R usa la función pie() para crear gráficos circulares. Toma números positivos como entrada vectorial.

Ejemplo:

# Create data for the graph.
geeks<- c(23, 56, 20, 63)
labels <- c("Mumbai", "Pune", "Chennai", "Bangalore")
 
# Plot the chart.
pie(geeks, labels)

 
 Producción:

Nota: Para obtener más información, consulte Gráficos circulares en lenguaje R

diagramas de caja:

Los diagramas de caja se crean en R usando la función boxplot().

input <- mtcars[, c('mpg', 'cyl')]
 
# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars,
        xlab = "Number of Cylinders",
        ylab = "Miles Per Gallon",
        main = "Mileage Data")

 
 Producción:

Nota: Para obtener más información, consulte Gráficos de caja en lenguaje R

Para obtener más artículos, consulte Visualización de datos usando R

Estadísticas

Estadística simplemente significa datos numéricos, y es un campo de las matemáticas que generalmente se ocupa de la recopilación de datos, la tabulación y la interpretación de datos numéricos. Es un área de interés de las matemáticas aplicadas con el análisis, la interpretación y la presentación de la recopilación de datos. La estadística se ocupa de cómo se pueden utilizar los datos para resolver problemas complejos.

Media, mediana y moda:

• Media: Es la suma de la observación dividida por el número total de observaciones.
• Mediana: Es el valor medio del conjunto de datos.
• Moda: Es el valor que tiene la frecuencia más alta en el conjunto de datos dado. R no tiene una función incorporada estándar para calcular el modo.

Ejemplo:

# Create the data
A <- c(17, 12, 8, 53, 1, 12,
       43, 17, 43, 10)
 
print(mean(A))
print(median(A))
 
mode <- function(x) {
   a <- unique(x)
   a[which.max(tabulate(match(x, a)))]
}
 
# Calculate the mode using
# the user function.
print(mode(A)

Producción:

[1] 21.6
[1] 14.5
[1] 17

Nota: Para obtener más información, consulte Media, mediana y moda en Programación R

Distribución normal:

La distribución normal informa sobre cómo se distribuyen los valores de los datos. Por ejemplo, la altura de la población, el tamaño de los zapatos, el nivel de coeficiente intelectual, tirar un dado y muchos más. En R, hay 4 funciones integradas para generar una distribución normal:
 

• La función dnorm() en la programación R mide la función de densidad de distribución.

dnorm(x, mean, sd)

• La función pnorm() es la función de distribución acumulativa que mide la probabilidad de que un número aleatorio X tome un valor menor o igual que x

pnorm(x, mean, sd)

• La función qnorm() es la inversa de la función pnorm(). Toma el valor de probabilidad y da una salida que corresponde al valor de probabilidad.

qnorm(p, mean, sd)

• La función rnorm() en la programación R se usa para generar un vector de números aleatorios que se distribuyen normalmente.

rnorm(n, mean, sd)

Ejemplo:

# creating a sequence of values
# between -10 to 10 with a
# difference of 0.1
x <- seq(-10, 10, by=0.1)
 
 
y = dnorm(x, mean(x), sd(x))
plot(x, y, main='dnorm')
 
y <- pnorm(x, mean(x), sd(x))
plot(x, y, main='pnorm')
 
y <- qnorm(x, mean(x), sd(x))
plot(x, y, main='qnorm')
 
x <- rnorm(x, mean(x), sd(x))
hist(x, breaks=50, main='rnorm')

 
 Producción:

Nota: Para obtener más información, consulte Distribución normal en R

Distribución Binomial en Programación R:

La distribución binomial es una distribución discreta y tiene sólo dos resultados, es decir, éxito o fracaso. Por ejemplo, determinar si un billete de lotería en particular ha ganado o no, si una droga es capaz de curar a una persona o no, puede usarse para determinar el número de caras o cruces en un número finito de lanzamientos, para analizar el resultado de un dado, etc. Tenemos cuatro funciones para manejar la distribución binomial en R, a saber:

• dbinom()

dbinom(k, n, p)

• pbinom()

pbinom(k, n, p)

donde n es el número total de intentos, p es la probabilidad de éxito, k es el valor en el que se debe encontrar la probabilidad.

• qbinom()

qbinom(P, n, p)

Donde P es la probabilidad, n es el número total de intentos y p es la probabilidad de éxito.

• rbinom()

rbinom(n, N, p)

 Donde n es el número de observaciones, N es el número total de intentos, p es la probabilidad de éxito.

Ejemplo:

probabilities <- dbinom(x = c(0:10), size = 10, prob = 1 / 6)
plot(0:10, probabilities, type = "l", main='dbinom')
 
probabilities <- pbinom(0:10, size = 10, prob = 1 / 6)
plot(0:10, , type = "l", main='pbinom')
 
x <- seq(0, 1, by = 0.1)
y <- qbinom(x, size = 13, prob = 1 / 6)
plot(x, y, type = 'l')
 
probabilities <- rbinom(8, size = 13, prob = 1 / 6)
hist(probabilities)

 
Producción:

Nota: Para obtener más información, consulte Distribución binomial en programación R

Análisis de series temporales:

Las series temporales en R se utilizan para ver cómo se comporta un objeto durante un período de tiempo. En R, se puede hacer fácilmente con la función ts().

Ejemplo: Tomemos el ejemplo de la situación de pandemia de COVID-19. Tomando el número total de casos positivos de casos de COVID-19 semanalmente del 22 de enero de 2020 al 15 de abril de 2020 del mundo en vector de datos.

# Weekly data of COVID-19 positive cases from
# 22 January, 2020 to 15 April, 2020
x <- c(580, 7813, 28266, 59287, 75700,
    87820, 95314, 126214, 218843, 471497,
    936851, 1508725, 2072113)
 
# library required for decimal_date() function
library(lubridate)
 
# creating time series object
# from date 22 January, 2020
mts <- ts(x, start = decimal_date(ymd("2020-01-22")),
                            frequency = 365.25 / 7)
 
# plotting the graph
plot(mts, xlab ="Weekly Data",
        ylab ="Total Positive Cases",
        main ="COVID-19 Pandemic",
        col.main ="darkgreen")

Producción:

Nota: Para obtener más información, consulte Análisis de series temporales en R