Comentario
Soy un comentario
Salida
• print(“Hello World”) • cat(“Hello”, “World”)
Información sobre comandos de R
# Información sobre un comando específico p.ej. ‘which’ • apropos(“which”) • help(which) • ?which • RSiteSearch(“which”)
Historial de comandos y salida
# Mostrar comandos anteriores history()
# Salir de RStudio q()
Directorio de trabajo
# Mostrar mi directorio de trabajo en R getwd()
# Cambiar el directorio de trabajo
# Indicar un nuevo directorio de trabajo
setwd(‘PFAD’)
Guardar comandos/script de R
Guardar localmente comandos de R o R-Scribt save (myTable, file=“C:/Users/axxKreis/Desktop/myTable.RData”)
Cargar comandos/script de R
# Cargar resultados persistidos load (file=“C:/Users/axxKreis/Desktop/myTable.RData”)
Cargar archivo CSV
# Cargar una tabla (archivo CSV) myCsvTable <- read.table(file=“C:/[PFAD]/myCsvTable.csv”, header=TRUE, sep=";") o myCsvTable <- read.csv(file=“C:/[PFAD]/myCsvTable.csv”, header=TRUE, sep=";")
Bibliotecas
Información sobre bibliotecas disponibles
# Indica dónde están instaladas las bibliotecas .libPaths()
# Mostrar los paquetes básicos instalados getOption(“defaultPackages”)
# Listar todos los paquetes actualmente cargados (.packages())
# Todos los paquetes instalados y disponibles (.packages(all.available=TRUE)) o library() # Para más detalles o installed.packages()
# Ruta de las bibliotecas instaladas Sys.getenv(“R_LIBS_USER”)
Cargar una biblioteca
# Cargar biblioteca existente p.ej. rpart library(rpart)
Instalar una biblioteca
install.packages(c(“tree”,“maptree”)) install.packages(“Nombre de la biblioteca”, dependencies=TRUE)
Lista pública de bibliotecas de R
https://cran.r-project.org/web/packages/available_packages_by_date.html
Actualizar paquetes instalados
update.packages()
Cargar bibliotecas al iniciar RStudio
# Con un editor de texto en modo administrador, editar: C:\Program Files\R\R-3.2.4\etc\Rprofile.site # Dentro del archivo, añadir las bibliotecas deseadas library(DBI) library(FSelector) library(ggplot2) library(lattice) library(RODBC) library(RMySQL) library(lattice)
Instalar y cargar bibliotecas de bases de datos
RODBC equivale a ODBC DBI equivale a JDBC RMySQL equivale a MySQL
# Instalar paquetes de base de datos install.packages(“RODBC”) install.packages(“DBI”) install.packages(“RMySQL”) # MySQL
# Cargar paquete instalado library(RODBC) # En caso de error muestra un mensaje. De lo contrario, no hay salida. library(DBI) library(RMySQL)
Biblioteca para procesamiento de datos
install.packages(“FSelector”)
Determinar la entropía para ’target value’
entropy (entropyTargetValue)
Ganancia de información
information.gain(data)
# Calcular la ganancia de información para el atributo ‘xxx’ respecto a ’target value’ information.gain (head(data[c(“TARGET.VALUE”,“xxx”)],length(data$TARGET.VALUE)))
Biblioteca para visualización
# Paquetes de visualización • lattice # Debe estar instalado y cargado • ggplot2
Tipos de datos
# Tipos de datos más usados
- Vectors
- Logical
- Numeric
- Integer
- Complex (1+2x)
- Character
- Raw (Hexadecimal)
- Lists
- Matrices
- Arrays
- Factors
Variables (símbolos)
Declaración
a <- 1 o a = 1
# Notación funcional ‘<-’(a,1)
Mostrar todas las variables
ls()
# Mostrar variables que coincidan con el patrón ls(pattern = “var”)
# Mostrar todas las variables, incluidas las ocultas ls (all.names = TRUE)
Eliminar variable(s) ‘a’
rm(a)
# Eliminar todas las variables rm(list = ls())
Comparar variables
a = 1 b = 2 a==b # FALSE
Operadores
Operadores aritméticos
- + * / %% %/% ^
Operadores relacionales
> < == <= >= !=
Operadores lógicos
& | ! && ||
Operadores de asignación
<− (local) = «− (global) -> -»
Otros operadores
: %in% %*%
Ejemplos
# Módulo (%%)
a = c(4, 8, 12) b = c(12, 8, 4) a%%b
Resultado: 4 0 0
# Cuántas veces los valores de ‘a’ caben en ‘b’
a = c(4, 8, 12) b = c(12, 8, 4) a%/%b
Resultado: 0 1 3 # Elevar vectores: p.ej. 2*2*2=8; 3*3=9; 4*4=16 a = c(2, 3, 4) b = c(3, 2, 2) a^b
Resultado: 8 9 16
# Comprobar si valores de ‘a’ > ‘b’ a = c(4, 8, 12) b = c(12, 8, 4) a>b
Resultado: FALSE FALSE TRUE # Devuelve TRUE si ambos vectores tienen TRUE a = c(2, TRUE, 4) b = c(3, FALSE, 2) a&b
Resultado: TRUE FALSE TRUE
# Devuelve TRUE si al menos un elemento es TRUE a = c(3,0,TRUE,FALSE, 0) b = c(4,0,FALSE,FALSE, 0.1) a|b
Resultado: TRUE FALSE TRUE FALSE TRUE
# Comprobar si un valor está en el vector a = c(3,0,TRUE,FALSE, 0) 3%in%a
Resultado: TRUE String
Cadena
# Las comillas simples se convierten en dobles internamente ‘hello’ “Hello”
Longitud de cadena
nchar(a)
Subcadena
a=“abcdefg” substr(a,3,5)
Resultado: cde
Concatenación
a <- “Hello” b <- ‘How’ c <- “are you?”
paste(a,b,c) “Hello How are you?”
paste(a,b,c, sep = “@”) “Hello@How@are you?”
paste(a,b,c, sep = “”, collapse = “”) “HelloHoware you? "
Generar cadena de 5 caracteres
format(18, width = 5) [1] " 18”
Alineación de salida
format(“Hello”, width = 8, justify = “centre”) #left, right, centre, none " Hello "
Mayúsculas y minúsculas
x = “Hello” toupper(x) tolower(x)
Factor
v = c(“thomas”, “thomas”, “thomas”, “linda”)
levels(v) NULL
typeof(v) [1] “character”
class(v) [1] “character”
# Convertir a factor y comprobar
v = factor(v)
is.factor(v) TRUE
levels(v) “linda” “thomas”
typeof(v) “integer”
class(v) “factor”
# En un ‘data frame’, las cadenas se convierten en factores a <- c(“Thomas”, “Linda”, “Felix”, “Sam”) b <- c(34,19,18,56) myDataFrame <- data.frame(a,b) is.factor(a) is.factor(myDataFrame$a)
Resultado: FALSE TRUE
# Orden de niveles inicial a <- factor( c(“Thomas”, “Linda”, “Felix”, “Sam”, “Linda”)
Resultado: Levels: Felix Linda Sam Thomas
# Cambiar orden de niveles a <- factor( a, levels = c(“Linda”, “Sam”, “Thomas”, “Felix”) )
Resultado: Levels: Linda Sam Thomas Felix # Generar factor - 4 veces primer nivel, 4 veces segundo nivel a <- gl(2, 4, labels = c(“Linda”, “Sam”, “Thomas”, “Felix”))
Resultado: Linda Linda Linda Linda Sam Sam Sam Sam Levels: Linda Sam Thomas Felix
Vector
# Crear vector myVector <- c(1,2,c(3,4),5)
Resultado: 1 2 3 4 5 # Si incluye cadena, todo se convierte en cadena c(‘hello’,0,TRUE)
Resultado: “hello” “0” “TRUE”
# Índices days <- c(“mo”, “di”, “mi”, “do”, “fr”, “sa”, “so”) days[c(1,3)]
Resultado: “mo” “mi”
# Cada segundo valor days <- c(“mo”, “di”, “mi”, “do”, “fr”, “sa”, “so”) days[c(TRUE,FALSE)]
Resultado: “mo” “mi” “fr” “so”
# Eliminar índices days <- c(“mo”, “di”, “mi”, “do”, “fr”, “sa”, “so”) days[c(-2,-3)]
Resultado: “mo” “do” “fr” “sa” “so”
# Reordenar days <- c(“mo”, “di”, “mi”, “do”, “fr”, “sa”, “so”) days[c(1,7,6,5,4,3,2)]
Resultado: “mo” “so” “sa” “fr” “do” “mi” “di”
# Operar vectores +, -, *, /
# Longitudes desiguales: 1*1, 2*2, 3*3, 4*1, 5*2, 6*3 a = c(1, 2, 3) b = c(1, 2, 3, 4, 5, 6) a*b
Resultado: 1 4 9 4 10 18
# Ordenar a = c(1, 4, 9, 4, 10, 18) sort(a)
# Invertir orden sort(a, decreasing = TRUE)
# Longitud length (myVector)
# Ordenar sort(myVector)
# Duplicados duplicated (myVector)
# Vector 1:50
# Tercer elemento a[3]
# Elementos 1 a 3 a[1:3]
# Combinar para tabla first.name <- c(“Hannes”, “Julia”) last.name <- c(“Müller”, “Schmidt”) myTable <- data.frame(first.name, last.name)
o
x <- c(“a”, “b”) y <- c(“A”, “B”) paste(x,y) # Resultado: “a A” “b B” “a C”
o
rbin (x, y)
o
cbind (x,y)
Lista
# Crear lista ‘meineListe’ meineListe <- list(1, 2, c(3,4))
Resultado: [[1]] [1] 1
[[2]] [1] 2
[[3]] [1] 3 4
# Nombrar elementos names(meineListe) <- c(“Element1”, “Element2”) # Nombres para dos primeros elementos
Resultado: $Element1 [1] 1
$Element2 [1] 2
$
# Mostrar nombres names(meineListe)
# Acceder elementos meineListe[1] o meineListe$Element1
# Sobrescribir lista meineListe <- list(c(10, 20, 30), “Hello Liste”)
# Sobrescribir elemento meineListe[2] <- “Hello World!”
# Combinar listas a = list(1,2,3) b = list(4,5,6) meineNuevaLista = c(a,b)
# Lista a vector unlist(meineNuevaLista)
Resultado: [1] 1 2 3 4 5 6
Matriz
# Crear matriz (2D)
matrix( c(1,2,3,4,5,6), ncol = 3, nrow = 2, byrow = FALSE)
Resultado: [,1] [,2] [,3] [1,] 1 3 5 [2,] 2 4 6
o
matrix( c(1,2,3,4,5,6), ncol = 3, nrow = 2, byrow = TRUE) Resultado: [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6
# Matriz con nombres rownames = c(“row1”, “row2”, “row3”) colnames = c(“col1”, “col2”, “col3”, “col4”) myMatrix <- matrix(c(1:12), ncol = 4, nrow = 3, byrow = TRUE, dimnames = list(rownames, colnames))
Resultado: col1 col2 col3 col4 row1 1 2 3 4 row2 5 6 7 8 row3 9 10 11 12
# Leer primera fila myMatrix[1,]
Resultado: col1 col2 col3 col4 1 2 3 4
# Leer primera columna myMatrix[,1]
Resultado: row1 row2 row3 1 5 9
# Leer [1,3] myMatrix[1,3]
# Sumar matrices myMatrix1 … myMatrix2 … myMatrix1 + myMatrix2
Resultado: [,1] [,2] [,3] [1,] 2 4 6 [2,] 8 10 12
Array
# Array (nD) array(“a”, dim = c(3,4,2) )
Resultado: , , 1 … , , 2 …
# Array multidimensional a <- array(…) o …
Resultado: , , 1 … , , 2 …
# Leer [1,3,2] myArray[1,3,2]
Resultado: 7
# Leer dimensión 2 myArray[,,2]
# Sobrescribir dimensión 2 myArray[,,2] <- array(…)
# Aplicar función a lo largo de ejes apply(myArray, c(1), sum)
Resultado: row1 row2 row3 92 100 108
Data Frame
# Crear data.frame myDataFrame <- data.frame(…, stringsAsFactors = FALSE)
Resultado: name alter geschlecht 1 Thomas 34 M 2 Johan 21 M 3 Linda 49 W
# Estructura str(myDataFrame)
Resultado: ‘data.frame’: …
# Resumen summary(myDataFrame)
Resultado: …
# Leer columna data.frame(myDataFrame$name)
Resultado: myDataFrame.name …
# Dos primeras columnas myDataFrame[0:1,]
Resultado: name alter geschlecht 1 Thomas 34 M
# Columnas 1 y 3 myDataFrame[c(1,3)]
Resultado: name geschlecht …
# Añadir columna myDataFrame$SpaltenBezeichnung <- c(…)
Resultado: …
# Añadir filas newDataFrameRows <- data.frame(…) rbind(myDataFrame,newDataFrameRows)
Resultado: …
Tabla
# Editar GUI myTable <- edit (myTable) o fix (myTable)
# Dimensiones dim(tableName)
# Nombres de columnas colnames(tablName)
# Selección de columnas train[,c(‘age’,’name’)]
Condición (if/else)
# if/else x <- 1 if (1 > 2) “yes” else “no”
# Varias expresiones “hello”; 1+1; 1*3
Bucle
i = 5 repeat {if (i > 25) break else {print(i); i <- i + 5;}} o while (i <= 25) {print(i); i <- i + 5} o for (i in seq(from=0, to=100, by=5)) print(i)
o
seq(0, 100, by = 5)
Resultado: 0 5 10 … 100 Conexión a base de datos y consulta de Query
Funciones
# Diferentes sintaxis y parámetros log2(64) log(x=64,base=2) log(64,2)
# Crear función con argumentos x <- function(i) i^2 x(2) # Resultado: 4
# Función propia nameDerFunktion <- function(Übergabeparameter) { print(Übergabeparameter) }
# Llamar función nameDerFunktion(Übergabeparameter)
# Función con múltiples parámetros sayHelloWorld <- function(s,h) { cat(s, “”, h) } sayHelloWorld(s=“Hello”, h=“World”) o sayHelloWorld(“Hello”, “World”)
# Función con valores predeterminados sayHelloWorld <- function(s=“H”,h=“W”) { cat(s, “”, h) } sayHelloWorld() # Para valores predeterminados sayHelloWorld(“Hello”, “World”) # Para sobrescribir defaults
Funciones matemáticas
# Establecer decimales options(digits=17) # Redondear sqrt(99) round( sqrt(99) ) o round(x=sqrt(99), digits=2)
# Media x = c(1,2,3) mean(x) # 2
# Mediana x = c(1, 2, 4, 99) median(x) # 3
# Mín y máx min(x) max x) o range(x) # 1 99
# Diferencia diff( range(x) ) # Datos aleatorios sample(1:1000, 10, replace = FALSE, prob = NULL)
# 10 ceros a <- rep(0, 10)
# Formato format(20.0, nsmall = 10) # Rellenar decimales
Resultado: “20.0000000000”
# Reducción de decimales format(20.123456789, digits = 4)
Resultado: 20.12
# Notación científica format(20.0000000000, scientific = TRUE)
Resultado: 2e+01
# Formatear entrada format(100)
Resultado: “100”