R PARA MUY PRINCIPIANTES es una iniciativa para intentar ayudar a todo el que esté interesado, a inciciarse en el uso del programa estadístico R, partiendo desde cero.
# Mediante el presente documento, veremos tablas de frecuencia, a partir de variables cuantitativas.
Vemos el ejemplo, basándonos en los datos del ensayo de patatas. Establezco el directorio de trabajo ```{r} setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R") ``` Importo los datos ```{r} DatosPatata = read.table("Potato.csv", header=T, sep="," , dec=".") head (DatosPatata) ```
Dejo una parte de la tabla aquí para el que quiera utilizarla a la hora de seguir el ejemplo.
Tratamiento
Variedad
Peso40
Peso41a45
Peso46a60
PesoMas61
Numero40
Numero41a45
Numero46a60
NumeroMas61
Testigo
Krone
380
1120
16180
2360
9
23
130
16
Testigo
Krone
2000
1480
15600
2340
42
25
124
14
Testigo
Krone
820
920
14840
6580
16
13
129
28
Testigo
Krone
130
1120
17180
11780
3
16
125
44
Testigo
Krone
1840
1240
12580
7040
22
16
101
30
Averiguamos la proporción que representa cada subcategoría de pesos, dentro de cada observación. ```{r} DatosPesos = as.table(as.matrix(DatosPatata[, 3:6])) # Seleccionamos los datos y los guardamos como tabla class (DatosPesos) # lo comprobamos prop.table (DatosPesos, 1) # Averiguamos la proporción por fila, es decir, por observación. ``` Si queremos agregar esta tabla DF DatosPatatas ```{r} PropDatosPesos = as.data.frame.matrix(prop.table (DatosPesos, 1)) # Añadimos "matrix" para que conserve la estructura. class (PropDatosPesos) head (PropDatosPesos)
colnames (PropDatosPesos) = paste("Prop", colnames(PropDatosPesos), sep="") # Cambiamos el nombre para que no coincida con el de las columnas del DF Datos. head (PropDatosPesos) DatosTotal = cbind(DatosPatata,PropDatosPesos) head (DatosTotal) ``` Si queremos tener la información en tanto porciento ```{r} DatosTotal = cbind(DatosPatata,PropDatosPesos*100) head(DatosTotal) ```
# Mediante el presente documento, veremos tablas de frecuencia, de contingencia o de recuento de datos.
Creamos un par de DF para usarlos en el ejemplo
```{r}
Datos = data.frame (
Cultivo = c("Trigo", "Melocoton", "Sandia", "Tomate", "Cebada","Ciruelo","Melon", "Almendro", "Calabacin", "Maiz"),
Grupo = c("Cereal", "Frutal", "Horticola", "Horticola", "Cereal", "Frutal", "Horticola", "Frutal", "Horticola", "Cereal"),
Agua = c("Secano", "Regadio", "Regadio", "Regadio", "Secano", "Regadio", "Regadio", "Secano", "Regadio", "Regadio"),
Terreno = c("Abierto", "Abierto", "Invernadero", "Invernadero", "Abierto", "Abierto", "Abierto", "Abierto", "Invernadero", "Abierto"))
Datos
```
Para saber cuantos cultivos de cada grupo hay, contamos las veces que se repite cada uno de los niveles de la variable Grupo, es decir, preparamos una Tabla de frecuencias.
```{r}
levels (Datos$Grupo)
table (Datos$Grupo) # Tabla de frecuencias
table (Datos$Grupo)/length(Datos$Grupo) # Tabla de proporciones
table (Datos$Grupo)/10 # Vemos que es el número de observaciones mirando el entorno. Pero si cambia esta número
# tenemos que cambiar el scrip, mientras que utilizando el comando length(), no es necesario.
```
Para averiguar los grupos que se riegan y los que no, preparamos una Tabla de contingencias.
```{r}
table (Datos$Grupo, Datos$Agua)
Tabla = table (Datos$Grupo, Datos$Agua)
```
Si queremos averiguar las frecuencias relativas, en vez de las absolutas.
```{r}
prop.table (Tabla) # Proporción con respecto al total de los datos de la tabla
prop.table (Tabla, 1) # Proporción con respecto al total de los datos de cada fila
prop.table (Tabla, 2) # Proporción con respecto al total de los datos de cada columna
```
Si queremos averiguar el total de datos por fila o columna
```{r}
Tabla
margin.table(Tabla, 1) # Por fila
margin.table(Tabla, 2) # Por columna
```
--- title: "Unir Data Frames II. merge() y Reduce()" author: "Raúl Ortiz" date: "Monday, May 11, 2015" output: pdf_document ---
# Mediante el presente documento, veremos unir data.frames con el comando merge().
Creamos un par de DF para usarlos en el ejemplo ```{r} Df1 = data.frame ( Cultivo = c("Trigo", "Melocoton", "Sandia", "Tomate", "Cebada"), Grupo = c("Cereal", "Frutal", "Horticola", "Horticola", "Cereal")) Df2 = data.frame ( Cultivo = c("Ciruelo", "Melocoton", "Sandia", "Tomate", "Trigo"), Agua = c("Regadio", "Regadio", "Regadio", "Regadio", "Secano")) Df1 Df2 ``` Unimos los DF mediante el comando merge() ```{r} merge (Df1, Df2, by = "Cultivo") merge (Df1, Df2, by = "Cultivo", sort=F) merge (Df1, Df2, by = "Cultivo", all.x=TRUE) ``` Qué ocurre si el campo con datos comunes no tiene el mismo nombre ```{r} Df1 = data.frame ( Cultivo = c("Cebada", "Melocoton", "Sandia", "Tomate", "Trigo"), Grupo = c("Cereal", "Frutal", "Horticola", "Horticola", "Cereal")) Df2 = data.frame ( Plantacion = c("Ciruelo", "Melocoton", "Sandia", "Tomate", "Trigo"), Agua = c("Regadio", "Regadio", "Regadio", "Regadio", "Secano")) Df1 Df2 ``` Los unimos ```{r} merge (Df1, Df2, by.x="Cultivo", by.y="Plantacion") merge (Df1, Df2, by.x="Cultivo", by.y="Plantacion", all=T) ``` Union de tres o mas DF con el comando Reduce() ```{r} Df3 = data.frame ( Cultivo = c("Cebada", "Melocoton", "Sandia", "Tomate", "Trigo","Ciruelo"), Terreno = c("Abierto", "Abierto", "Invernadero", "Invernadero", "Abierto", "Abierto")) Df3 names(Df2)[1] = "Cultivo"
Reduce(merge, list(Df1,Df2,Df3)) # Arroja un DF con datos en comunes de todos ellos
Reduce(function(...) merge (..., all=T), list(Df1,Df2,Df3)) # Resulta un DF con todos los datos ``` Por último, vemos el ejemplo con los datos del ensayo de patatas que hemos utilizado en vídeos anteriores Establezco el directorio de trabajo ```{r} setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R") ``` Cargo los datos ```{r} DatosTesPeso = read.table("PotatoTestigoFilOrd2Peso.csv", header=T, sep="," , dec=".") DatosTesNr = read.table("PotatoTestigoFilOrdNr.csv", header=T, sep="," , dec=".") DatosTesPeso View (DatosTesNr) ``` Uno los DF ```{r} DatosTesTotal = merge(DatosTesPeso, DatosTesNr, by = "Parcela") DatosTesTotal ``` Las variables que se repiten tras la union tiene un sufijo que indican de qué DF provienen. También podríamos haber hecho la unión por mas de una variable al mismo tiempo. ```{r} DatosTesTotal2 = merge(DatosTesPeso, DatosTesNr, by = c("Parcela", "Tratamiento", "Variedad")) DatosTesTotal2 ```
---
title: "Ordenar Data Frame II - Ordenar filas"
author: "Raúl Ortiz"
date: "Tuesday, May 05, 2015"
output: pdf_document
---
# Mediante el presente documento, veremos como reordenar las filas de un Data Frame.
Establezco el directorio de trabajo
```{r}
setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R")
```
En
el vídeo como "Unir Data Frames" vimos que para utilizar el comando
cbind(), uno de los requisitos era que las filas de los DF que íbamos a
unir estuvieran en el mismo orden.
Veamos que pasa si no están en el mismo orden.
```{r}
DatosTesPeso = read.table("PotatoTestigoFilOrdPeso.csv", header=T, sep="," , dec=".")
DatosTesNr = read.table("PotatoTestigoFilOrdNr.csv", header=T, sep="," , dec=".")
DatosTesPeso
View (DatosTesNr)
```
¿Qué orurre si unimos los DF tal y como están?
```{r}
DatosTotal = cbind(DatosTesPeso, DatosTesNr)
View (DatosTotal)
```
Los
mas lógico parece ordenar el DF "DatosTesNr"" para que el orden de las
observaciones coincida con el de las parcelas, tal y como ocurre en el
DF "DatosTesPeso".
Para ordenar el DF siguiendo poniendo las
observaciones de la parcela 1 en la primera posición y el de la 9 en la
úlitma, utilizaremos el siguiente comando.
```{r}
DatosTesNr [order(DatosTesNr$Parcela), ]
DatosTesNr1 = DatosTesNr [order(DatosTesNr$Parcela), ]
DatosTesNr # Orden del DF al cargarlo
View (DatosTesNr1)
```
Ahora ya sí podríamos utilizar rbind()
```{r}
DatosTotal = cbind(DatosTesPeso, DatosTesNr1)
View (DatosTotal)
```
Este
era un ejemplo fácil, porque el DF de referencia estaba ordenado según
el orden creciente (del 1 al 9) de una variable numérica.
¿Cómo lo haríamos si la variable "Parcela" del DF de referencia no estuviera ordenado de forma creciente?
```{r}
DatosTesPeso = read.table("PotatoTestigoFilOrd2Peso.csv", header=T, sep="," , dec=".")
DatosTesNr = read.table("PotatoTestigoFilOrdNr.csv", header=T, sep="," , dec=".")
DatosTesPeso
View (DatosTesNr)
```
Ninguno de los DF está ordenado de la misma manera.
Vamos a ordenar el DF "DatosTesNr" según el orden de parcela que tiene el DF "DatosTesPeso"
```{r}
DatosTesNr[order(match(DatosTesNr[,3],DatosTesPeso[,3])),]
DatosTesNr2 = DatosTesNr[order(match(DatosTesNr$Parcela,DatosTesPeso$Parcela)),]
DatosTesPeso
View (DatosTesNr2)
```
Ahora, también podríamos utilizar rbind()
```{r}
DatosTotal2 = cbind(DatosTesPeso, DatosTesNr2)
View (DatosTotal2)
```
Otras opciones para ordenar un DF es por ejemplo en orden decreciente de una variable numérica.
```{r}
DatosTesNr
DatosTesNr [order(DatosTesNr$Parcela), ]
DatosTesNr [rev(order(DatosTesNr$Parcela)), ]
DatosTesNr [order(-DatosTesNr$Parcela), ]
```
También la puedo ordenar según el orden de dos variables, una tipo Factor y otra tipo numérica
```{r}
DatosTesNr
DatosTesNr [order(DatosTesNr$Variedad,DatosTesNr$Numero40), ]
```
Si quiero que una de las variables se ordene de forma decreciente, puedo recurrir el signo "-"
```{r}
DatosTesNr [order(DatosTesNr$Variedad,-DatosTesNr$Numero40), ]
```
Por último, también se puede ordenar con comandos de la librería dplyr
```{r}
library(dplyr)
DatosTesNr %>% arrange(Parcela)
DatosTesNr %>% arrange(Variedad,Numero40)
```
--- title: "Odenar Data Frame I - Ordenar columnas" author: "Raúl Ortiz" date: "Monday, May 04, 2015" output: pdf_document ---
# Mediante el presente documento, veremos como reordenar las columnas de un Data Frame.
Establezco el directorio de trabajo ```{r} setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R") ``` En el vídeo como "Unir Data Frames" vimos que para utilizar el comando rbind(), uno de los requisitos era que las columnas o variables de los DF que íbamos a unir, tuvieran los mismos nombres y en el vídeo "Renombrar variables" aprendimos a cambiar los nombres para facilitar este proceso. Dije también en el vídeo que otro de los requisitos para utilizar el comando rbind() es que las columnas estén ordenados de la misma manera, pero vamos a ver si esto es así o no. ```{r} DatosTesPeso = read.table("PotatoTestigoPeso.csv", header=T, sep="," , dec=".") DatosTdoPeso = read.table("PotatoTratadoPeso3.csv", header=T, sep="," , dec=".") names (DatosTesPeso) names (DatosTdoPeso) ``` Los nombres de las variables son los mismos, pero no el orden en el que se presentan. Veamos que pasa cuando ejecutamos rbind() en estas condiciones. ```{r} DatosPesos = rbind(DatosTesPeso, DatosTdoPeso) View (DatosPesos) ``` Comprobamos que R ha identificado los nombres de las variables o columnas y los ha reordenado para que coincidan, antes de unirlos. En caso de que por cualquier motivo queramos dar un orden específico al DF, tenemos varias opciones.
Opción 1 Ordenar por el número de índice de las columnas. - Ya hablamos de los índices en el vídeo "Filtrar datos I" ```{r} names (DatosTesPeso) names (DatosTdoPeso) DatosTdoPeso1 = DatosTdoPeso [ , c(3,2,1,7,6,5,4)] names (DatosTdoPeso1) ```
Opción 2 Utilizar la función subset() - Ya hablamos de este comando en el vídeo "Filtrar datos II" ```{r} DatosTdoPeso2 = subset (DatosTdoPeso, select=c(3,2,1,7,6,5,4)) names (DatosTdoPeso2) ```
Opción 3 Utilizar la función del paquete dplyr - Ya hablamos de este comando en el vídeo "Filtrar datos III" ```{r} library(dplyr) DatosTdoPeso3 = DatosTdoPeso %>% select(Tratamiento, Variedad, Parcela, Peso40, Peso41a45, Peso46a60, PesoMas61) names (DatosTdoPeso3) ```
Opción 4 Utilizamos el orden de las variables o columnas del Data Frame referencia, para ordenar el DF objetivo. ```{r} DatosTdoPeso4 = DatosTdoPeso [ , c(names(DatosTesPeso))] names (DatosTdoPeso4) ```
Si en vez de ordenar las columnas, según el orden establecido en otro DF, queremos hacerlo en orden alfabético. ```{r} DatosTdoPesoAZ = DatosTdoPeso [ , order(c(names(DatosTdoPeso)))] names (DatosTdoPesoAZ) ``` En orden alfabético reverso. ```{r} DatosTdoPesoZA = DatosTdoPeso [ , rev(order(c(names(DatosTdoPeso))))] names (DatosTdoPesoZA) ```
--- title: "Cambiar el nombre a las variables" author: "Raúl Ortiz" date: "Thursday, April 30, 2015" output: pdf_document ---
# Mediante el presente documento, veremos como cambiar el nombre a las variables.
Establezco el directorio de trabajo ```{r} setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R") ``` En el vídeo anterior, sobre como "Unir Data Frames" vimos que para utilizar el comando rbind(), uno de los requisitos era que las columnas o variables de los DF que íbamos a unir, tuvieran los mismos nombres. ¿Pero qué pasa si los datos que nos envían no cumplen estos requisitos? ```{r} DatosTesPeso = read.table("PotatoTestigoPeso.csv", header=T, sep="," , dec=".") DatosTdoPeso = read.table("PotatoTratadoPeso1.csv", header=T, sep="," , dec=".") names (DatosTesPeso) names (DatosTdoPeso) ``` Para cambiar los nombres de las variables del DF DatosTdoPeso, hacemos lo siguiente. ```{r} names (DatosTdoPeso) = c("Tratamiento", "Variedad", "Parcela", "Peso40", "Peso41a45", "Peso46a60", "PesoMas61") names (DatosTdoPeso) names (DatosTesPeso) ``` En caso de que solo queremos cambiar el nombre de una variable en concreto, tenemos otra opción ```{r} DatosTdoPeso = read.table("PotatoTratadoPeso2.csv", header=T, sep="," , dec=".") names (DatosTdoPeso) names (DatosTesPeso) names (DatosTdoPeso)[3] = "Parcela" names (DatosTdoPeso) ``` Por último, si tuviéramos un DF con muchas columnas, averiguar el número de columna cuyo nombre quiero cambiar puede ser más complicado y dar lugar a error. En ese caso es más recomendable utilizar recurrir a la librería "reshape" ```{r} # install.packages("reshape") require(reshape) DatosTdoPeso = rename(DatosTdoPeso, c(Parcela="Subparcela")) names (DatosTdoPeso) ```
--- title: "Unir DataFrames. rbind() y cbind()" author: "Raúl Ortiz" date: "Tuesday, April 21, 2015" output: pdf_document ---
# Mediante el presente documento, veremos como unir DataFrames mediante los comandos rbind() y cbind().
Establezco el directorio de trabajo ```{r} setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R") ``` Supongamos que los datos nos llegan por partes, es decir, que nos llegan de las parcelas tratadas los pesos por un lado y el número de patatas por otro. Lo mismo con los datos de las parcelas testigo. En total, cuatro tablas con datos ```{r} DatosTesPeso = read.table("PotatoTestigoPeso.csv", header=T, sep="," , dec=".") DatosTesNr = read.table("PotatoTestigoNr.csv", header=T, sep="," , dec=".") DatosTdoPeso = read.table("PotatoTratadoPeso.csv", header=T, sep="," , dec=".") DatosTdoNr = read.table("PotatoTratadoNr.csv", header=T, sep="," , dec=".") ``` Unimos los DF con los datos de los pesos del Testigo con los del Tratado. rbind = unir agregando filas, cuando sabemos que los nombres de las columnas (variables), son iguales y están en el mismo orden. ```{r} names (DatosTesPeso) names (DatosTdoPeso) DatosPesos = rbind(DatosTesPeso, DatosTdoPeso) View (DatosPesos) ``` Hacemos lo mismo con los datos referentes al número de patatas de las parcelas Testigo y Tratadas. Comprobamos antes los nombres y el orden de las columnas. ```{r} names (DatosTesNr) names (DatosTdoNr) DatosNumero = rbind(DatosTesNr, DatosTdoNr) View (DatosNumero) ``` Ahora sólo nos falta unir los datos referentes al número de patatas por muestra. Vemos que las observaciones de cada parcela se han anotado en el mismo orden, la primera fila corresponde a la parcela 1 y la última a la 18, en ambos DF, el de DatosPesos y el de DatosNumero. Podemos proceder al la unión. ```{r} DatosTotal = cbind(DatosPesos, DatosNumero) View (DatosTotal) ``` Observamos que las columnas Tratamiento, Variedad y Parcela se encuentran repetidas. Lo podemos solucionar uniendo sólo las columnas que nos interesan. ```{r} DatosTotal = cbind(DatosPesos, DatosNumero[ , 4:7]) View (DatosTotal) ```
--- title: "Funciones de la familia apply()" author: "R para muy principiantes - Raúl Ortiz" date: "Tuesday, April 14, 2015" output: pdf_document ---
# Mediante el presente documento, repasaremos algunas funciones de la familia apply()
Establezco el directorio de trabajo ```{r} setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R") ``` Importo los datos ```{r} Datos = read.table("Potato.csv", header=T, sep="," , dec=".") ``` Estructura del comando apply apply (DataFrame, Margen, Funcion, Argumentos) Margen: 1 filas, 2 columnas
Queremos averiguar el peso total de cada muestra del ensayo, ya que nos han dado los datos de los pesos de las patatas de la muestra, clasificados por categoría. ```{r} apply (Datos[ , 3:6], 1, sum) Datos$PesoTotalMuestra = apply (Datos[ , 3:6], 1, sum) head (Datos,3) ``` Para averiguar el peso total por categoría, sumaremos por columna (categorias) en vez de por filas (muestras) ```{r} TotPesosCat = apply (Datos[ , 3:6], 2, sum) TotPesosCat ``` Los que hayais visto el vídeo de Sumar filas y columnas, os habréis dado cuenta de que el resultado es el mismo que cuando utilizamos los comandos rowSums y colSums. rowSums equivale a apply(DF, 1, sum) rowMeans equivale a apply(DF, 1, mean) colSums equivale a apply(DF, 2, sum) colMeans equivale a apply(DF, 2, mean)
Pero es que con apply(), además de sumar, podemos hacer otras operaciones que vienen cargadas por defecto en R. ```{r} getGroupMembers("Summary") ``` Así por ejemplo, podemos obtener el rango de los números de patatas por categorías. ```{r} apply (Datos[ , 7:10], 2, min) apply (Datos[ , 7:10], 2, max) apply (Datos[ , 7:10], 2, range) ``` Hay además otras operaciones aritméticas que vienen cargadas por defecto, como la media (mean), la varianza (var), la desviación estándar (sd) o la mediana (median) ```{r} apply (Datos[ , 7:10], 2, mean) ``` Tambien podemos personalizar la función. Por ejemplo, vamos a pasar las unidades del peso de las sub-muestras de gramos a kilogramos. Para ello dividimos las mismas columnas de antes entre 1000. ```{r} PesosCatKg = apply (Datos[ , 3:6], 2, function(x) x/1000) head (PesosCatKg) ``` Si lo que queremos es tener el total por categoría en kg ```{r} TotPesosCatKg = apply (Datos[ , 3:6], 2, function(x) sum(x)/1000) TotPesosCatKg ```
--- title: "Operaciones por filas o columnas de un DataFrame" author: "R para muy principiantes - Raúl Ortiz" date: "Tuesday, April 14, 2015" output: pdf_document ---
# Mediante el presente documento, repasaremos algunas formas de hacer operaciones por filas o columnas en un Data Frame
Establezco el directorio de trabajo ```{r} setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R") ``` Importo los datos ```{r} Datos = read.table("Potato.csv", header=T, sep="," , dec=".") ```
# Sumar datos por filas, rowSums.
Queremos averiguar el peso total de cada muestra del ensayo, ya que nos han dado los datos de los pesos de las patatas de la muestra, clasificados por categoría. Los datos de cada muestra están recogidos por filas en nuestro Data Frame. El comando rowSums suma todos los datos del Data Frame por filas, pero a nosotros nos interesa sumar sólo los datos de las columnas relativas a los pesos, es decir, los de las columanas de la posición 3 a la 6. Además, el resultado lo guardaremos en una nueva variable a la que llamaremos PesoTotalMuestra. ```{r} Datos$PesoTotalMuestra = rowSums (Datos[ , 3:6]) ``` De la misma manera, puedo averiguar el número de patatas total que tengo por muestra. Los datos relativos al número de patatas, son los de las columnas de la posición 9 a la 12. ```{r} Datos$NumPatatasTotal = rowSums (Datos[ , 7:10]) head (Datos) ```
####################################################### ### Filtrar datos por filas o columnas de un DF ### #######################################################
# Establezco el directorio de trabajo setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R")
# Importo los datos Datos = read.table("Potato.csv", header=T, sep="," , dec=".")
# Verifico los datos cargados head (Datos) # Verifico los primeros datos str(Datos) # Compruebo la estructura. summary(Datos) # Veo resumen de datos
###################################################################### ### Seleccionar datos del dataframe, usando libreria - dplyr - ### ######################################################################
library(dplyr) # Si es la primera vez que la usas, antes tendras que instalar el paquete (menu Tools).
filter (Datos, Variedad=="Krone") # La estructura es igual que subset.
### Encadenando ordenes con - %>% - que se puede leer como - entonces... -
# Sin encadenar filter (select (Datos, Tratamiento, Variedad), Tratamiento=="UTC") # Filtra seleccionando en el DF Datos las variables Tratamiento y Variedad, cuando Tratamiento sea igual UTC
# Encadenando Datos %>% select (Tratamiento, Variedad) %>% filter (Tratamiento=="UTC") # Trabaja con el DF Datos, despues seleciona las variables Tratamiento y Variedad, y despues las filtras
####################################################### ### Filtrar datos por filas o columnas de un DF ### #######################################################
# Establezco el directorio de trabajo setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R")
# Importo los datos Datos = read.table("Potato.csv", header=T, sep="," , dec=".")
# Verifico los datos cargados head (Datos) # Verifico los primeros datos str(Datos) # Compruebo la estructura. summary(Datos) # Veo resumen de datos
########################################################################### ### Seleccionar datos del dataframe, mediante el comando - subset - ### ###########################################################################
# Quiero seleccionar solo los datos de la variedad Krone subset (Datos, Variedad=="Krone")
SubKrone = subset (Datos, Variedad=="Krone")
# Quiero seleccionar solo los datos de la variedad Krone, pero cuando Treatment sea igua a UTC SubKroneUTC = subset (Datos, Variedad=="Krone" & Tratamiento=="UTC")
# En el video Vectores II ya hablamos sobre los simbolos para operaciones logicas e hicimos algunos # ejemplos con vectores, que se pueden aplicar tambien a los DF.
####################################################### ### Filtrar datos por filas o columnas de un DF ### #######################################################
# Establezco el directorio de trabajo
setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R")
# Importo los datos
Datos = read.table("Potato.csv", header=T, sep="," , dec=".")
# Verifico los datos cargados
head (Datos) # Verifico los primeros datos
str(Datos) # Compruebo la estructura.
summary(Datos) # Veo resumen de datos
########################################################
### Seleccionar datos del dataframe, mediante [] ###
########################################################
dataframe [fila , coluna]
# Quiero seleccionar solo los datos de la variedad Krone, que son los de las filas de la 1 a la 10
Datos [c(1:10) , ] # Selecciono filas de la 1 a la 10 y todas las columnas
DatosKrone = Datos [c(1:10) , ] # Meto la selección en un objeto
# Si quisiera los de la otra variedad
Datos [-c(1:10) , ]
Datos [c(11:18) , ]
DatosNicola = Datos [c(11:18) , ] # Meto la selección en un objeto
# Selecciono los datos de las pesadas
Datos [ , c(1:6)]
# Selecciono los datos de las pesadas, pero solo los de la variedad Nicola
Datos [c(11:18) , c(1:6)]
################################################# ### Importar desde la ventana del entorno ### #################################################
# Hay que asignar nombre, marcar las opciones que procedan. # Despues de hacerlo, lo recomendable es copiar el comando de la consola y pegarlo en el scrip para no tener # que volver a hacerlo en sucesivas sesiones de trabajo.
Datos <- read.csv("C:/Users/Raul Ortiz/Desktop/Proyectos R/Potato.csv", na.strings="Falta")
summary(Datos) rm(Datos)
########################################### ### Importar desde el porta papeles ### ###########################################
Datos3 = read.table("clipboard", header=T, sep="\t", na.strings = "Falta") # Separacion tabulada es tipica de archivos excel.
summary(Datos3) str(Datos3)
############################################################### ### Importar asignando determinado tipo de cada columna ### ###############################################################
############################## ### Importar datos a R ### ##############################
# Cuando tenemos nuestros datos en una hoja de calculo, lo mas recomendable es guardar el archivo # como uno del tipo *.csv o *.txt
# Hemos visto en videos anteriores como averiguar cual es nuestro directorio de trabajo # y como establecerlo, mediante los comandos
getwd() setwd("~/Output/20 Importar datos a R")
# Tambien como hacerlo desde la pestaña "Files" o "Archivos".
setwd("C:/Users/Raul Ortiz/Desktop/Proyectos R")
# Una vez establecido desde esta pestaña, se puede copiar el comando desde la consola y pegarlo en el script # para facilitar el trabajo en proxima sesiones.
###################################### ### Importar datos en archivos ### ######################################
# Hay diversos comandos para importar datos:
read.csv("nombrearchivo.csv") # Tiene los parametros de un csv designados por defecto.
# header indica si R debe interpretar la primera fila como encabezado (TRUE o T) o no (FALSE o F).
read.csv("nombrearchivo.csv", header=T) # Asignara los nombres del encabezado a cada variable.
read.table("nombrearchivo.csv", header=T, sep=",") # Como no tiene los parametros del csv asignados, # hay que especificarlos diciendo que la separacion es mediante ","
read.delim("nombrearchivo.txt", header=T) # Tiene los parametros de un txt designados por defecto.
read.table("nombrearchivo.txt", header=T, sep="/t") # Como no tiene los parametros del csv asignados, # hay que especificarlos diciendo que la separacion es tabulada.
Datos2 = read.table(file.choose(), header=T, sep=",", dec=".", na.strings = "Falta") # sep indica el separador del campo, que los mas comunes son "," "." "/t" # dec indica el separador de decimales. # na.strings indica la cadena de caracteres que interpretara R como valores perdidos (y converitira en NA)
plot(df$x, df$y, main="Nombre del grafico", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Subtitulo", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(df$x, df$y, type="p", # "p": puntos (por defecto), # "l": lineas, # "b": puntos conectados por lineas, # "o": igual al anterior, pero las lineas estan sobre los puntos, # "h": lineas verticales, # "s": escaleras, los datos se representan como la parte superior de las lineas verticales, # "S": igual al anterior pero los datos se representan como la parte inferior de las l´ineas verticales
main="Nombre del grafico", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Tipo p (defecto)", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(x, y, type="l", # "l": lineas, main="Grafico de lineas", # Texto del titulo cex.main=3, # Tamaño de letra del titulo sub="Tipo l", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(x, y, type="b", # "b": puntos conectados por lineas, main="Lineas y puntos", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Tipo b", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(x, y, type="o", # "o": igual al anterior, pero las lineas estan sobre los puntos, main="Lineas sobre los puntos", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Tipo o", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(x, y, type="h", # "h": lineas verticales, main="Lineas verticales", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Tipo h", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
dev.off() # Desactivamos todas las ventanas graficas o dispositivos
plot(x, y, type="o", # "p": puntos (por defecto), main="Nombre del grafico", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Subtitulo", # Texto del subtitulo cex.sub=1.5, # Tamaño de letra del subtitulo xlab="Explicacion eje X", # Texto en el eje X ylab="Explicacion eje Y", # Texto en el eje Y cex.lab=0.8, # Tamaño de letra de los ejes axes=T, # Definir si se dibujan los ejes (TRUE, opcion por defecto), o no se dibujan (FALSE) xlim=c(0, 15), # Rango de datos del eje X ylim=c(0, 50), # Rango de datos del eje Y pch=24, # Forma de los puntos. Mas info en help("points"). col="red", # Color del borde de los puntos bg="seagreen2", # especifica el color del fondo. La lista de los 657 colores disponibles se # puede ver con colors()) bty="7", # controla el tipo de caja que se dibuja alrededor del grafico: # "o", "l", "7", ¨c", ¨u" o "]" (la caja se # parece a su respectivo caracater); # si bty="n" no se dibuja la caja tcl=-0.5, # un valor que especifica la longitud de los marcadores de eje # como una fraccion de la altura de una linea # de texto (por defecto tcl=-0.5) las=1, # un entero que controla la orientacion de los caracteres en los ejes (0: paralelo a los ejes, 1: horizontal, 2: # perpendicular a los ejes, 3: vertical) cex=1.5) # un valor que controla el tama~no del texto y simbolos con respecto al valor por defecto; los siguientes # parametros tienen el mismo control para n´umeros en los ejes, cex.axis, t´itulos en los ejes, cex.lab, # el titulo principal, cex.main, y el subtitulo, cex.sub
?plot # par = parametros modificables en un grafico help("points") colors()
boxplot(df$x) # Diagrama de cajas y bigotes o boxplot.
boxplot(df$x ~ df$z) # Diagrama de cajas y bigotes o boxplot # en funcion de una variable con dos niveles.
barplot(df$x) # Diagrama de barras
qqnorm(df$x) # Compara la distribucion de datos con los # valores teoricos de una distribucion normal
qqline(df$x) # Añade una linea.
hist(df$x) # Histograma.
# Se pueden dividir las ventanas de muchas formas, # segun nuestras necesidades.
x11()
Conf2mas1 = matrix(c(1:3, 3), nrow=2, byrow=F) # Creamos un matriz a partir de un vector con los valores #c(1:3,3) que es igual que c(1,2,3,3) Conf2mas1
layout(Conf2mas1) layout.show(3)
plot(df$x, df$y) # Scatter plot.
boxplot(df$x) # Diagrama de cajas y bigotes o boxplot.
boxplot(df$x ~ df$z) # Diagrama de cajas y bigotes o boxplot # en funcion de una variable con dos niveles.
# Se pueden hacer las divisiones en particiones irregulares
x11() Conf2mas1 layout(Conf2mas1) layout.show(3) layout(Conf2mas1, widths=c(1, 3), # con "widths" configuramos la anchura heights=c(3, 1)) # con "heights" configuramos la altura layout.show(3)
# En R se pueden hacer graficos muy complejos, especialmente # si utilizamos paquetes diseñados especificamente para ello. # Vamos a empezar poco a poco, sin cargar ningun paquete, porque # muchos de los comandos que aprendamos nos serviran de base # para manejar con mas soltura los graficos complejos.
x = c(3,3,5,8,10,7,4,6,8,10) x y = c(15,45,44,40,35,33,30,27,22,16) y z = rep((c("A","B")),c(5,5)) z
df=data.frame(x,y,z) df
x11() # Abre una ventana para la representacion grafica
plot(x, y) # Scatter plot. # El primer vector indica las coordenadas de los puntos # en el eje de las abcisas (X) # y el segundo en el de las ordenadas (y). # Representa los puntos de las coordenadas # en el mismo orden que tienen los vectores. plot(df$x, df$y)
boxplot(x) # Diagrama de cajas y bigotes o boxplot. boxplot(df$y)
boxplot(x ~ z) # Diagrama de cajas y bigotes o boxplot # en funcion de una variable con dos niveles. boxplot(df$x ~ df$z)
barplot(x) # Grafica de barras. x y qqplot(x,y) # Quantile Quantile plot. # Ordena los valores de ambos vectores # y los representa unos frente a los otros con puntos.
qqnorm(x) # Compara la distribucion de datos de un vector # con los valores teoricos de una distribucion normal.
qqline(x) # Añade una linea para hacer la evaluacion visial # mas facil. # Cuanto mas se aproximen todos los puntos a la linea, # mas proximos a una distribucion normal # estaran los valores del vector.
hist(x) # Histograma. # Representa la frecuencia de los datos del vector, # dados unos rangos de datos.
################################################################ ### DISPOSITIVOS GRAFICOS. Trabajar y organizar ventanas ### ################################################################
x11()
dev.list() # Nos da la lista de dispositivos graficos abiertos.
x11() # Abrimos otra ventana mas
dev.list() # Nos da la lista de dispositivos graficos abiertos.
dev.cur() # Para saber cual es el dispositivo activo
dev.set(2) # Para activar el dispositivo grafico en el que queramos # representar las graficas.
dev.cur() # Lo comprobamos
dev.off() # Para desactivar la ventana activa.
# Ejemplo del uso de varias ventanas graficas.
x11() # Abrimos el primer dispositivo
plot(df$x, df$y) # Dibujamos en el el scatter plot de x frente a y
x11() # Abrimos el segundo dispositivo
boxplot(df$x ~ df$z) # Dibujamos en el segundo # la grafica de cajas y bigotes de x en funcion de z
x11() # Abrimos el tercer dispositivo.
barplot(df$x) # Dibujamos el grafico de barras de x
# Supongamos que por algun motivo nos interesa cambiar # el grafico de la ventana 2
dev.cur() # Para saber cual es el dispositivo activo
dev.set(2) # Activamos la ventana 2
boxplot(df$y ~ df$z)
################################## ### VARIOS GRAFICOS EN UNO ### ##################################
dev.off() # Desactivamos todas las ventanas graficas o dispositivos
boxplot(df$x) # Diagrama de cajas y bigotes o boxplot.
boxplot(df$x ~ df$z) # Diagrama de cajas y bigotes o boxplot # en funcion de una variable con dos niveles.
barplot(df$x) # Diagrama de barras
qqnorm(df$x) # Compara la distribucion de datos con los # valores teoricos de una distribucion normal
qqline(df$x) # Añade una linea.
hist(df$x) # Histograma.
# Se pueden dividir las ventanas de muchas formas, # segun nuestras necesidades.
x11()
Conf2mas1 = matrix(c(1:3, 3), nrow=2, byrow=F) # Creamos un matriz a partir de un vector con los valores #c(1:3,3) que es igual que c(1,2,3,3) Conf2mas1
layout(Conf2mas1) layout.show(3)
plot(df$x, df$y) # Scatter plot.
boxplot(df$x) # Diagrama de cajas y bigotes o boxplot.
boxplot(df$x ~ df$z) # Diagrama de cajas y bigotes o boxplot # en funcion de una variable con dos niveles.
# Se pueden hacer las divisiones en particiones irregulares
x11() Conf2mas1 layout(Conf2mas1) layout.show(3) layout(Conf2mas1, widths=c(1, 3), # con "widths" configuramos la anchura heights=c(3, 1)) # con "heights" configuramos la altura layout.show(3)
plot(df$x, df$y, main="Nombre del grafico", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Subtitulo", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(df$x, df$y, type="p", # "p": puntos (por defecto), # "l": lineas, # "b": puntos conectados por lineas, # "o": igual al anterior, pero las lineas estan sobre los puntos, # "h": lineas verticales, # "s": escaleras, los datos se representan como la parte superior de las lineas verticales, # "S": igual al anterior pero los datos se representan como la parte inferior de las l´ineas verticales
main="Nombre del grafico", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Tipo p (defecto)", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(x, y, type="l", # "l": lineas, main="Grafico de lineas", # Texto del titulo cex.main=3, # Tamaño de letra del titulo sub="Tipo l", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(x, y, type="b", # "b": puntos conectados por lineas, main="Lineas y puntos", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Tipo b", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(x, y, type="o", # "o": igual al anterior, pero las lineas estan sobre los puntos, main="Lineas sobre los puntos", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Tipo o", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
plot(x, y, type="h", # "h": lineas verticales, main="Lineas verticales", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Tipo h", # Texto del subtitulo cex.sub=1.5) # Tamaño de letra del subtitulo
dev.off() # Desactivamos todas las ventanas graficas o dispositivos
plot(x, y, type="o", # "p": puntos (por defecto), main="Nombre del grafico", # Texto del titulo cex.main=2, # Tamaño de letra del titulo sub="Subtitulo", # Texto del subtitulo cex.sub=1.5, # Tamaño de letra del subtitulo xlab="Explicacion eje X", # Texto en el eje X ylab="Explicacion eje Y", # Texto en el eje Y cex.lab=0.8, # Tamaño de letra de los ejes axes=T, # Definir si se dibujan los ejes (TRUE, opcion por defecto), o no se dibujan (FALSE) xlim=c(0, 15), # Rango de datos del eje X ylim=c(0, 50), # Rango de datos del eje Y pch=24, # Forma de los puntos. Mas info en help("points"). col="red", # Color del borde de los puntos bg="seagreen2", # especifica el color del fondo. La lista de los 657 colores disponibles se # puede ver con colors()) bty="7", # controla el tipo de caja que se dibuja alrededor del grafico: # "o", "l", "7", ¨c", ¨u" o "]" (la caja se # parece a su respectivo caracater); # si bty="n" no se dibuja la caja tcl=-0.5, # un valor que especifica la longitud de los marcadores de eje # como una fraccion de la altura de una linea # de texto (por defecto tcl=-0.5) las=1, # un entero que controla la orientacion de los caracteres en los ejes (0: paralelo a los ejes, 1: horizontal, 2: # perpendicular a los ejes, 3: vertical) cex=1.5) # un valor que controla el tama~no del texto y simbolos con respecto al valor por defecto; los siguientes # parametros tienen el mismo control para n´umeros en los ejes, cex.axis, t´itulos en los ejes, cex.lab, # el titulo principal, cex.main, y el subtitulo, cex.sub
?plot # par = parametros modificables en un grafico help("points") colors()
####################################### ### DataFrames o Marco de datos ### #######################################
# En videos anteriores hemos visto como crear y trabajar con vectores y matrices, pero realmente # el DataFrame es la estructura mas versatil y con la que mas cosas podremos hacer.
# Puede estar compuesto por elementos de distinta clase y esto es bueno, porque cuando tengamos entre # nuestros datos variables cuantitativas podremos trabajar con la clase numeric y cuando tengamos variables # cualitativas, trabajaremos con variables tipo factor. # Todo bajo la misma estructura, el df.
# Es como una matriz, pero con la posibilidad de albergar datos de distintas naturaleza.
############################## ### Crear un DataFrame ### ##############################
Datos = data.frame(tratamiento, plantas) # Creamos un df con los dos vectores. Cada vector es de distinta clase
################################ ### Explorar el DataFame ### ################################
Datos # La consola nos ofrece los datos del DF, pero puede resultar poco practico cuando es muy grande.
head(Datos) # Vemos los 6 primeros datos del DF. head(Datos, 10)
# Los nombres de las columnas son los que le dimos a cada vector.
dim(Datos) # Nos da las dimensiones del DF, el numero de filas y de columnas.
str(Datos) # Tipo de datos y muestra
summary(Datos) # El resumen varia segun sean variables cualitativas (factor) o cuantitativas (mumerico)
plot(Datos) # El resultado de este comando puede variar segun el tipo de variables, # pero ya estudiaremos lo graficos en profundidad, en futuros videos.
# Para ver una variable en concreto, escribiremos el nombre del DF seguido por $ y el nombre de la variable.
# Una matriz es basicamente es un conjunto de datos del mismo tipo, definidos en filas y columnas.
# Podemos crear una matriz de valores con el comando matrix.
matrix(c(1,2,3,4,5,6,7,8,9,10,11,12), nrow=3, byrow=TRUE) # nrow indica el numero de filas # byrow=TRUE indica que los valores son introducidos por fila
matrix(c(1:12), nrow=3, byrow=FALSE)
Mt = matrix(c(1:12), nrow=3, byrow=FALSE) Mt
# Al igual que con los vectores, se pueden extraer datos de las matrices
Mt[1,3] # Fila, columna
Mt[1:2,2:4] # Se puede extraer datos indicando un rango de filas y columnas.
# al dejar uno hueco antes o despues de la coma, indicamos que queremos todos los elementos de esa fila o # de la columna especificada
Mt[1,] Mt[,4]
Mt[Mt[,3]>=8,4] # Extrae los elementos de la columan 4, pero solo cuando los de la 3 sean mayores o igual que 8.
# Los Data Frames son extructuras parecidas pero mas versatiles porque pueden almacenar datos de distinto tipo, # asi que veremos mas operaciones en los videos que haga sobre ellos.
############################################## ### Vectores II - Comparacíon y lógica ### ##############################################
# Los principales símbolos para comparar son >,>=,<,<=,==,!=
araña = c(2,1,5,3,4,9,9,7,5,5,4,7,5,6,3,1,4,7,1,2) araña == 2 # Decimos a R que nos diga de todas las muestras, cuales tienen dos arañas y cuales no. which (araña==2) # ¿Qué muestras tienen 2 arañas? mean(araña) which (araña>=(mean(araña))) # ¿Qué muestras están por encima de la media? POSICIONES mayor.media = which (araña>=(mean(araña))) araña[mayor.media] # VALORES sum (araña>=(mean(araña))) # ¿Cuántas muestras están por encima de la media?
# Los símbolos para valores logicos son "&" (ampersand ) y, "|" (pipe) o, "!" no
My2yMn6 = which(araña>2 & araña<6) # ¿Qué muestras tienen más de 2 arañas, pero menos que 6? My2yMn6 araña[My2yMn6]
Mn2oMy6 = which(araña<2 | araña>6) # ¿Qué muestras tienen menos que 2 o más de 6 arañas? Mn2oMy6 araña[Mn2oMy6]
# Si al cabo de un rato trabajando vemos en nuestras notas que la muestra 9 tenía 6 arañas # aunque al escribirlo en el cuaderno de campo el número se podía confundir con un 5 y te entra la # duda de si lo has introducido bien.
araña[9] # Podemos preguntar a R cual es el noveno componente del objeto/vector "araña".
araña[9]=6 # Reemplazamos el valor de la novena muestra. Ahora es 6. No es necesario introducir # todos los datos nuevamente. araña[9] # Lo comprobamos
araña[21] # Al preguntar por el vigésimo primero, la consola nos muestra NA "Not Avaliable", # es decir, que no está disponible o no existe.
araña[21] = 8 # Introducimos el número 8 en la vigésimo primera posición del vector. araña # Lo comprobamos
# No es necesario volver a escribir todos los comandos, nos vamos a la línea 14 # y corremos de nuevo el script.
pulgon=c(5,9,6,2,4,7,8,2,1,7,6)
comment(araña) = "Muestras de araña de la finca de Juan" comment(pulgon) = "Muestras de pulgón de la finca de Luis" comment(araña) comment(pulgon)
##########################################################
### Vectores I - Creación y principales parámetros ###
##########################################################
# La mayoría de las operaciones y funciones en R están definidas con carácter vectorial.
# La forma principal para definir un vector es através de sus componentes, con la función c().
# Un vector es una serie de valores en un orden determinado.
# Supongamos estamos haciendo un ensayo con un acaricida y queremos analizar en R el número de arañas
# que hay en cada una de las 20 muestras que hemos tomado. Para ello tenemos que crear un vector y
# asociarlo a un objeto, es decir, darle un nombre.
araña = c(2,1,5,3,4,9,9,7,5,5,4,7,5,6,3,1,4,7,1,2)
# Para asignar un nombre a un vector se puede utilizar tanto "<-" como "=".
araña
length(araña) # Nos aseguramos de que hemos introducido los datos de las 20 muestras
max(araña) # Averiguamos cuál es el máximo número de arañas que hemos visto en una muestra
min(araña) # y el mínimo
mean(araña) # ¿y la media?
araña[1:3] # Por si queremos repasar solamente los valores de las primeras muestras.
araña[c(1,2,3)] # Pedimos que sólo nos muestre las tres primeras entradas.
tres.primeros = 1:3
araña[tres.primeros]
head(araña) # head nos muestra los primeros 6 valores del vector por defecto
head(araña, 3) # podemos modificar el número de valores, especificándolo con una coma tras el nombre del vector.
tail(araña) # la función tail nos muestra los 6 últimos valores del vector por defecto.
tail(araña, 3) # al igual que con head, podemos especificar el número de valores a mostrar.
araña[(length(araña)-10):(length(araña)-5)] # Para valores intermedios, la cosa se complica un poco más. Los valores extremos del rango
# también se mostrarán.
#################################### ### R para muy principiantes ### ####################################
########################## ### Tipos de datos ### ##########################
# Los datos en R pueden ser de diferentes tipos. R asigna automáticamente la clase que estime # sea las más conveniente.
a = 5 class(a) # R le asignó la clase numérico.
b = "Tratamiento" class(b) # R automáticamente le asignó la clase caracter.
# Hay muchas clases de datos en R, pero las más importantes son; # numeric, character y factor.
# Cuando no sepamos la clase del objeto, se lo podemos preguntar is.numeric(a) is.character(a)
# Si queremos convertirlo en un objeto de tipo distinto. as.character(a)
# A veces, nos conviene convertir el objeto, de clase character a factor. Es la clase adecuada # para almacenar variables de tipo cualitativa, como los Tratamientos, Color, Edad, etc..
# Hay funciones que se pueden ejecutar mediante comandos que ya están en el programa base,
# como por ejemplo la media de una serie de valores, que se calcula mendiante el comando mean().
a <- c(2,3,4,4,4,4,4,6,6,8,10)
mean(a)
# Hay otros paquetes de comandos que ni siquiera están instalados y hay que descargarlos
# antes de poder usar las funciones que éstos contienen.
# En www.r-project.org puedes ver la lista de paquetes.
# Hay mas de 5.000 y pueden ser muy específicos sobre un tema.
# Es posible que la primera vez que instalas un paquete te pida que elijas una localización
# desde la que quieras instalarlo. Simplemente elige el país en el que te encuentres.
# Para saber los comandos del paquete y sus funciones, basta con pedirlo con la ayuda.
help (package = agricolae)
# Para usar comandos de las librerías que hemos instalados, hay que cargar los paquetes
# en la memoria primero. Esto habrá que hacerlo cada vez que iniciemos sesión.
library(agricolae)
# Ejemplo bar.err
library(agricolae)
data(sweetpotato)
model<-aov(yield~virus,data=sweetpotato)
out <- waller.test(model,"virus", console=TRUE,
main="Yield of sweetpotato\ndealt with different virus")
par(mfrow=c(2,2),cex=1)
bar.err(out$means,variation="range",horiz=TRUE,xlim=c(0,45),angle=125,density=6,
main="range")
bar.err(out$means,variation="SD",ylim=c(0,45),col=colors()[30],
main="Standard deviation",density=8)
bar.err(out$means,variation="SE",horiz=TRUE,xlim=c(0,45),density=8,
col="brown",main="Standard error")
bar.err(out$means,variation="range",ylim=c(0,45),bar=FALSE,col="green",
main="range")
par(mfrow=c(1,2),cex=1)
bar.err(out$means,variation="range",ylim=c(0,45),bar=FALSE,col=0)
abline(h=0)
# horiz = TRUE
bar.err(out$means,variation="SE",horiz=TRUE,xlim=c(0,45),bar=FALSE,col=0)
#startgraph
par(mfrow=c(1,1))
#endgraph
# Para buscar ayuda especifica sobre una función, por ejemplo sum
help(sum)
# Presenta una descripción, la forma de usarla, sus argumentos, qué valores nos devuelve la función y referencias
# y además nos muestras funciones relacionadas.
# Cuando en vez de buscar una función queremos buscar sobre un concepto estadístico utilizaremos el comando
help.search("")
# El concepto hay que meterlo entre comillas porque no estamos buscando una función sino una cadena de caracteres.
help.search("boxplot")
# Podemos sustituir la palabra help por el simbolo de interrogación de la siguiente manera, aunque los resultados
# van a ser los mismos.
####################################
### El directorio de trabajo ###
####################################
# Es el lugar definido en el que busca los scripts y datos y donde también va guardando los resultados.
# Para saber cual es el directorio de trabajo.
getwd()
# Establecer una nueva dirección para el directorio de trabajo.
setwd("C:/Users/Raul Ortiz/Documents/R")
# Lo comprobamos
getwd()
# En R es habitual que las cosas se puedan hacer de varias formas diferentes.
# Cuando utilizamos RStudio, podemos establecer el directorio desde la pestaña "Files"
#####################
### El script ###
#####################
# La forma más eficaz y recomendable de comunicarse con R
# Nos permite que guardemos todos los comandos que ejecutemos
# y poder ulitizarlos de nuevo en próximas sesiones de trabajo o proyectos.
# Facilita el trabajo entre colaboradores, basta con enviarles el script y la base de datos
# para compatir con ellos nuestros avances.
# R guarda los scripts con el formato *.R pero en realidad no es más que un archivo de texto.
# Se pueden dar órdenes a R directamente desde la consola,
# pero sólo queda registro de los comandos que ejecutamos en el historial
# y tener un guión es mucho más organizado y eficaz.
1+1
5*2
mean(c(1,2,3,4,5))
# Itroduciendo el símbolo de almohadilla (#) antes de un comando,
# conseguimos que R lo considere como texto y no lo ejecute.
# Es una forma de introducir comentarios en el script
# para poder recordarlos en futuras sesiones.
1+1 # Sumamos 1+1
5*2 # Averiguo el total de alumnos en las dos clases.
# También pueden ser utilizados para explicar comandos a otros colaboradores
mean(c(1,2,3,4,5)) # Con este comando saco la media de los cinco valores.
# O para organizar el script en secciones,
# ocultando lo que hay entre dos cadenas largas de almohadillas (###########)
####################################
### R para muy principiantes ###
####################################
### El directorio de trabajo ###
####################################
# Es el lugar definido en el que busca los scripts y datos y donde también va guardando los resultados.
# Para saber cual es el directorio de trabajo.
getwd()
# Establecer una nueva dirección para el directorio de trabajo.
setwd("C:/Users/Raul Ortiz/Documents/R")
# Lo comprobamos
getwd()
# En R es habitual que las cosas se puedan hacer de varias formas diferentes.
# Cuando utilizamos RStudio, podemos establecer el directorio desde la pestaña "Files"
####################################
### R para muy principiantes ###
####################################
##############################
### El área de trabajo ###
##############################
# En R es muy común que originemos scripts muy largos para hacer operaciones, gráficas y funciones.
# Sirva el siguiente ejercicio a modo de ejemplo básico.
5+5
7 * (5+5)
9 * (5+5)
# Si la operacion 5+5 la voy a utilizar muchas veces,
# podemos meterla en un objeto y trabajar con ese objeto en adelante de modo que la programción
# resulte mas rápida y eficaz (porque disminuiremos las probabilidades de equivocarnos al escribir).
a <- 5+5 # Vemos en entorno global que aparece la variable que hemos creado y sus características
7 * a
9 * a
# Ojo que R es "key sensitive", es decir, que hace distinción entre mayúsculas y minúsculas
a
A
b <- 2+2
b
# Podemos manejar los objetos creados desde la ventana del entorno de trabajo,
# por ejemplo, borrarlos
# Es muy práctico, pero no deja rastro en el script y a veces nos interesará que sí lo deje.
ls() # List. Así podemos consultar los objetos activos.
rm(b) # Remove. Sirve para borrar un objeto.
ls() # Comprobamos que el objeto b ya no existe.
# Para buscar ayuda especifica sobre una función, por ejemplo sum
help(sum)
# Presenta una descripción, la forma de usarla, sus argumentos,
# qué valores nos devuelve la función y referencias y además nos muestras funciones relacionadas.
# Cuando en vez de buscar una función queremos buscar sobre un concepto estadístico
# utilizaremos el comando
help.search("")
# El concepto hay que meterlo entre comillas porque no estamos buscando una función
# sino una cadena de caracteres.
help.search("boxplot")
# Podemos sustituir la palabra help por el simbolo de interrogación de la siguiente manera,
# aunque los resultados van a ser los mismos.
?sum # igual que el comando help(sum)
??boxplot # igual que el comando help.seach("boxplot").
# Fijaos que con la dobre interrogación no son necesarias las comillas
