jueves, 29 de septiembre de 2011

"R" you ready for R? comandos básicos (Clase 1)

###########################################################################
#	  Análisis de datos estadísticos con R                            #
#                    MANEJO DE DATOS                                      #
#    	       		2011/2012		                          #      #	         Msc. Rosana Ferrero	                                  #
###########################################################################
# Clase 1. Introducción a R
###########################################################################
# 0. Antes de comenzar                                                    #
# 1. R como calculadora: Aritmética y Funciones básicas  		  #	 
# 2. R como lenguaje: objetos en R  		                          #
###########################################################################
 
 
###########################################################################
# 0. Antes de comenzar                                                    #
###########################################################################
 
# Ayuda detro del programa
  ?rnorm
  help("rnorm")
  help.start() # abre la ayuda en html
  ?help.search 
  help.search("normal") # lista de funciones o paquetes donde aparece una palabra
  ?apropos
  apropos("normal")
  ?demo
  demo() # lista de las demotraciones disponibles
  demo(graphics)
  demo(persp)
  demo(lm.glm)
  example("mean") # ejemplos de aplicación
  vignette("sandwich") # descarga un pdf del paquete sandwich
 
# Listado y remoción de objetos en memoria
  ls() # para saber los objetos que tenemos en el espacio de trabajo
  x # escribir el nombre de un objeto muestra su contenido
  save(<objetos>,file="nombre.RData") # para guardar el contenido del espacio de trabajo. También se puede usar: save.image() , si queremos que guarde todo.
  attach("misdatos.RData") # para acceder a los objetos de la carpeta de trabajo
  detach("misdatos.RData") # para deshacer la selección
  rm("x") # borra el objeto "x", y rm() todo el escritorio de trabajo
 
###########################################################################
# 1. R como calculadora: Aritmética y Funciones básicas  		  #
###########################################################################
 
# operaciones aritméticas básicas
  2 + 3 # suma
  2 - 3 # resta
  2*3   # multiplicación
  2/3   # división
  2^3   # potenciación
 
  exp(3) #exponencial
  sqrt(2) # raíz cuadrada
  log(1) # logaritmo
  sin(1); cos(1); tan(1) # trigonométricas
  max; min; range; mean; sum; diff; cumsum; sd; quantile # otras
 
#operadores lógicos
  <, >, <=, =>, ==, !=
  !, &, |, xor()
  &&, ||
  if()
 
# precedencia de operaciones
  4^2 - 3*2
  1 - 6 + 4
  2^-3
  (4^2) - (3*2) # usar paréntisis para agrupar, clarifica
 
# Funciones, argumentos en las funciones
  log(100)
  log(100, base=10)
  log10(100) # equivalente
  log(100, b=10)  # argumentos abreviados
  log(100, 10)  # argumentos por posición
  x<-log(100, 10)  # generación de objetos
 
###########################################################################
# 2. R como lenguaje: objetos en R  					  #
###########################################################################
 
# Creación de objetos y funciones básicas
  rnorm(5)
  x<-rnorm(5)
  x # equivalente a print(x)
  plot(x)
  summary(x)
 
# Tipos de objetos:  vector, array, matriz, factor, lista, hoja de datos, función
      x<-1:10; str(x)
  # Vector: colección ordenada de elementos del mismo tipo
    x<-c(1,2,3) ; y<-c("a", "b", "c")     #concatenación "c"
    z<-c(TRUE, TRUE, FALSE)
    is.vector(x); is.vector(y); is.vector(z)
    x[1] ; y[2]; z[3] #cómo acceder a los elementos del vector
 
  # Matrices y Array: generalización multidimensional del vector. Elementos del mismo tipo. Varias columnas (o filas) de vectores
    is.array(x)
    a<-array(9,dim=c(5,4)); a; a[1,];  a[1,,drop=FALSE]
    b<-matrix(1:20,nrow=5); b; b[1,2]
 
  # Data frame: similar al array, pero con columnas de diferentes tipos.
  dates<-data.frame(ID=c("gen0","genB","genZ"),subj1=c(10,25,33),subj2=c(NA,34,15),oncogen=c(TRUE, TRUE, FALSE),loc=c(1,30,125))
  data(iris); iris # carga la hoja de datos "iris"
 
  # Factor: tipo de vector para datos cualitativos (o categóricos)
  x<-factor(c(1,2,2,1,1,2,1,2,1))
 
  # List: vector generalizado. Sus componentes pueden ser también listas, o pueden ser de distinto tipo. No tienen estructura.
  una.lista<-c(un.vector=1:10,una.palabra="hola",una.matriz=matrix(rnorm(20),ncol=5),lista2=c(1=5,b=factor(c("a","b"))))
 
  #Funciones: código
  f1<-function(x) {return(2*x)} ; is.function(f1)
 
# Atributos de los objetos
    x<-1:15;   y<-matrix(5,3,4); z<-c(TRUE, FALSE)
    attributes(x);     attributes(y);    attributes(z)
 
    w<-list(a=1:3,b=5); attributes(w)
    f1<-function(x) {return(2*x)} ; attributes(f1); is.function(f1)
 
  # Modo (mode): lógico, entero, real, carácter, etc.
    mode(x); mode(y); mode(z)
 
  # Tipo (typeof): double, character...
    x1<-1:5, x2<-c(1,2,3,4,5); x3<-"patata"
    typeof(x1);  typeof(x2);  typeof(x3)
 
  # Nombres (names): etiquetas.
      #Poner un nombre en minúscula no es lo mismo que ponerlo en mayúscula (R es "case-sensitive": x!=X)
      #Hay nombres reservados, por lo que hay que evitarlos. Ej: "function", "if"
    z <- list(a=1, b="c", c=1:3)
    names(z)
 
  # Dimensiones (dim): número de filas y columnas (puede ser cero)
    length(x)
    dim(y)
 
  # Nombres de las dimensiones de los arrays (dimnames)
    y<-matrix(5,3,4)
    dimnames(y)[[1]]<-c("8am","9am","10am") # [[1]] para filas y [[2]] para columnas
    colnames(y)<-c("lunes", "martes", "miércoles", "jueves") # alternativa
 
  # Clase (class): lista de las clases del objeto (vector alfa-numérico)
    x <- 10
    class(x) # "numeric"
 
  # Otros: por ejemplo, para series temporales.
 
### Indexación o referenciación
   x<-1:5; x[1]
   x[x>3]
   y<-x>3; x[y]
 
   names(x)<-c("a","b","c","d","e"); x["c"]
 
   data(iris)
   iris
   iris[,1] # igual que iris[[1]]
   iris[1,]
   iris[2:4, ]
   iris[1, 1:2]
   iris$Sepal.Length # referencia a la columna "Sepal.Length" utilizando el formato dataframe$columna
   attach(iris); mean(Sepal.Length); detach(iris) # referencia a los nombres de las variables (columnas) mediante la función attach
 
### Valores ausentes: NA (not available); NaN (not a number); Inf (infinito)
  x<-c(1:3,NA);  is.na(x); which(is.na(x))
  x[is.na(x)]<-0 #sustituir NA por 0
  is.na(5/0)
  is.nan(0/0)
  is.infinite(-5/0)
  mean(x,na.rm=TRUE)    #quitar NA al evaluar la media
   x<-c(1:3,NA); y<-na.omit(x); y #para funciones de modelado como lm es mejor usar "na.omit" o "na.exclude", que eliminan los NA
 
### Ordenar vectores
  x<-c(5,1,8,3)
  order(x); order(x,decreasing=TRUE)
  sort(x)
  rank(x)
  x[order(x)]
  x[order(x,decreasing=TRUE)]
 
### Generación de secuencias
   # Secuencias aleatorias
   sample(5)
   sample(5,3)
   x<-1:10;sample(x);   sample(x,replace=TRUE)
   probs<-x/sum(x);sample(x,prob=probs)
 
   # Secuencias discretas y continuas
   x<-c(1,2,3,4,5)
   x<-1:5
   x<-seq(from=1,to=5,by=1)
 
   # Secuencias con repeticiones
   rep(1,5)
   x<-1:4; rep(x,2)
   gl(3,5) #como rep(1:3, rep(5,3))
   expand.grid(1:3,4:6,7:10)
 
### Vector de caracteres
  pegar<-paste(c("A","B"),2:3,sep="");  pegar
  substr("abcdef",2,4)
  y<-factor(1:5); y
 
  x <- c(as = "asfef", qu = "qwerty", "yuiop[", "b", "stuff.blah.yech")
  # split x on the letter e
  strsplit(x, "e")
 
### Discretizar
  v<-1:9
  cut1<-cut(v,3); cut1
  cut2<-cut(v,quantile(v,c(0, 1/3, 2/3, 1)),include.lowest=TRUE); cut2
  cut3<-cut(v,quantile(v,c(0, 1/3, 2/3, 1)),include.lowest=TRUE); cut3
 
### Combinar vectores o matrices
  rbind(1:5,1:10)
  cbind(1:5,1:10)
 
  a<-matrix(rnorm(20),ncol=5)
  mediai<-media<-NULL;for(i in 1:4){mediai<-mean(a[i,]); media<-c(media,mediai)} # loop
  apply(a,1,mean,na.rm=TRUE) # aplica una función a filas, columnas o ambas. Hay que especificar el "margin"
  sapply(a,mean,na.rm=TRUE) # simplifica el resultado a un vector o una matriz
  lapply(a,mean,na.rm=TRUE) # devuelve una lista
  require(stats); groups <- as.factor(rbinom(32, n = 5, prob = 0.4))
  tapply(groups, groups, length)
  aggregate(state.x77, list(Region = state.region), mean)
 
### Programar en R
   #Definición de funciones
      funcion1<-function(A,B,C) {x1<-A*B/C; x1}
   #Argumentos
      args(funcion1)
      funcion1(1,2,3)
   #Control de ejecución: condicionales, loops
    f = factor(sample(letters[1:5], 10, replace=TRUE))
        for( i in unique(f) ) print(i)
    x<-1:5; if(x==5) {x<-x+1} else {x<-x+2};  x
    x<-1:5; ifelse(x %% 2 == 1, "Odd", "Even")
    while(length(x)<=10) {x<-c(x,1)}
    require(stats)
          centre <- function(x, type)
          {
            switch(type, mean = mean(x), median = median(x), trimmed = mean(x, trim = .1))
          }
          x <- rcauchy(10); centre(x, "mean")
   #Control de errores: traceback, browser, debug
      debug(centre)
      undebug()
   #Control de la duración de la operación:
      unix.time(centre(rnorm(10),"mean"))   #unix.time, Rprof
      traceback()
 
Created by Pretty R at inside-R.org

No hay comentarios:

Publicar un comentario

Libros para descargar (gratis) sobre Estadística Computacional