lección 5 R, Ejercicios de Matemáticas

¡Descarga lección 5 R y más Ejercicios en PDF de Matemáticas solo en Docsity!

AprendeR:

Introducción al tratamiento

de datos con R y RStudio

Módulo 3

Lección 5

http:// moocs .uib.cat

Campus Extens

UIB Virtual

Data frames

Edició: abril 2016 Edita: Campus Extens – UIB Virtual Disseny portada: Direcció de l'Estratègia de Comunicació i Promoció Institucional (dircom.uib.cat)

Datos de tipo atributo, o cualitativos. Son los que expresan una cualidad del individuo,

tales como el sexo, el DNI, la especie... En R, guardaremos las listas de datos cualitativos

en vectores (habitualmente, de palabras), o en factores si vamos a usarlos para clasificar

individuos.

Datos ordinales. Son datos similares a los cualitativos, con la única diferencia de que

se pueden ordenar de manera natural. Por ejemplo, los niveles de calidad ambiental de

un ecosistema (malo, regular, normal, bueno, muy bueno) o las calificaciones en un exa-

men (suspenso, aprobado, notable, sobresaliente) son datos ordinales. En cambio, no se

pueden ordenar de manera significativa los sexos o las especies de los individuos. En R,

guardaremos las listas de datos ordinales en factores ordenados.

Datos cuantitativos. Son datos que se refieren a medidas, tales como edades, longitu-

des, pesos, tiempos, números de individuos, etc. En R, guardaremos las listas de datos

cuantitativos en vectores de números.

El análisis, tanto descriptivo como inferencial, de un conjunto de datos es diferente según su

tipo. Así, para datos cualitativos sólo tiene interés estudiar y representar las frecuencias con que

aparecen sus diferentes valores, mientras que el análisis de datos cuantitativos suele involucrar

el cálculo de medidas estadísticas que evalúen numéricamente sus propiedades.

5.1. Estructura de un data frame

La instalación básica de R lleva predefinidos algunos objetos de datos. Podemos echarles un

vistazo entrando la instrucción data(), que abrirá una ventana con la lista de los objetos de

datos a los que tenemos acceso en la sesión actual de R (los que lleva la instalación básica de

R y los que aportan los paquetes que tengamos cargados). Estos objetos no aparecen cuando

hacemos ls() ni se borran con rm(list=ls()), y podemos pedir información sobre cada uno

de ellos en la ventana de Ayuda. Al final de la lista que obtenemos con data() se nos indica

que si entramos

data(package=.packages(all.available=TRUE)),

obtendremos la lista de todos los objetos de datos a los que tenemos acceso, incluyendo los de

los paquetes instalados pero no cargados en la sesión actual.

Una de las tablas de datos más populares que lleva R es el llamado iris data set, que contiene la

longitud y la anchura de los pétalos y sépalos y la especie de 150 flores iris. El famoso estadístico

Sir R. A. Fisher usó este conjunto de datos en su artículo «The Use of Multiple Measurements

in Taxonomic Problems» (Annals of Eugenics 7 (1936), pp. 179–188).^1 En R, este conjunto de

datos de flores iris está recogido en el data frame iris. Para más información sobre estos datos,

podéis leer su entrada en la Wikipedia,^2 y para más información específica sobre la tabla iris

de R, podéis consultar la Ayuda de iris.

En esta sección vamos a trabajar con esta tabla de datos, así que lo primero que haremos

será copiarla en un nuevo data frame que llamaremos d.f; de este modo trabajaremos sobre la

copia d.f y tendremos acceso al data frame iris original si necesitamos volver a él. De todas

(^1) Se puede descargar de http://digital.library.adelaide.edu.au/coll/special//fisher/138.pdf.

(^2) http://en.wikipedia.org/wiki/Iris_flower_data_set.

formas, si trabajamos directamente sobre iris y lo echamos a perder, lo podemos recuperar

ejecutando la instrucción data(iris), que devolverá a este data frame su contenido original.

d. f = iris

Si pidiéramos ahora a R que nos mostrase el objeto d.f,

d. f

obtendríamos el contenido del data frame en la consola: una larga lista de datos formada por las

150 filas de la tabla; naturalmente, no vamos a copiar aquí esta salida. Para echarle un vistazo

al data frame, y así poder entender su estructura y conocer los nombres de sus variables, os

recomendamos usar la instrucción

View ( d. f )

que lo mostrará en la ventana superior izquierda de RStudio. Véase la Figura 5.1.

Figura 5.1. Vista de un data frame con View.

También podemos consultar en la consola las primeras filas del data frame, aplicando la

función head al data frame y al número de filas que queremos que muestre; su valor por defecto

es 6.

head ( d .f ,5) # Las primeras 5 filas Sepal. Length Sepal. Width Petal. Length Petal. Width Species 1 5.1 3.5 1.4 0.2 setosa 2 4.9 3.0 1.4 0.2 setosa 3 4.7 3.2 1.3 0.2 setosa 4 4.6 3.1 1.5 0.2 setosa 5 5.0 3.6 1.4 0.2 setosa

La función tail, con una estructura similar a head, nos muestra la «cola» de la tabla.

rownames ( d. f ) [1] " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " " 8 " " 9 " " 10 " [11] " 11 " " 12 " " 13 " " 14 " " 15 " " 16 " " 17 " " 18 " " 19 " " 20 " [21] " 21 " " 22 " " 23 " " 24 " " 25 " " 26 " " 27 " " 28 " " 29 " " 30 " [31] " 31 " " 32 " " 33 " " 34 " " 35 " " 36 " " 37 " " 38 " " 39 " " 40 " [41] " 41 " " 42 " " 43 " " 44 " " 45 " " 46 " " 47 " " 48 " " 49 " " 50 " [51] " 51 " " 52 " " 53 " " 54 " " 55 " " 56 " " 57 " " 58 " " 59 " " 60 " [61] " 61 " " 62 " " 63 " " 64 " " 65 " " 66 " " 67 " " 68 " " 69 " " 70 " [71] " 71 " " 72 " " 73 " " 74 " " 75 " " 76 " " 77 " " 78 " " 79 " " 80 " [81] " 81 " " 82 " " 83 " " 84 " " 85 " " 86 " " 87 " " 88 " " 89 " " 90 " [91] " 91 " " 92 " " 93 " " 94 " " 95 " " 96 " " 97 " " 98 " " 99 " " 100 " [101] " 101 " " 102 " " 103 " " 104 " " 105 " " 106 " " 107 " " 108 " " 109 " " 110 " [111] " 111 " " 112 " " 113 " " 114 " " 115 " " 116 " " 117 " " 118 " " 119 " " 120 " [121] " 121 " " 122 " " 123 " " 124 " " 125 " " 126 " " 127 " " 128 " " 129 " " 130 " [131] " 131 " " 132 " " 133 " " 134 " " 135 " " 136 " " 137 " " 138 " " 139 " " 140 " [141] " 141 " " 142 " " 143 " " 144 " " 145 " " 146 " " 147 " " 148 " " 149 " " 150 " dimnames ( d. f ) [[1]] [1] " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " " 8 " " 9 " " 10 " [11] " 11 " " 12 " " 13 " " 14 " " 15 " " 16 " " 17 " " 18 " " 19 " " 20 " [21] " 21 " " 22 " " 23 " " 24 " " 25 " " 26 " " 27 " " 28 " " 29 " " 30 " [31] " 31 " " 32 " " 33 " " 34 " " 35 " " 36 " " 37 " " 38 " " 39 " " 40 " [41] " 41 " " 42 " " 43 " " 44 " " 45 " " 46 " " 47 " " 48 " " 49 " " 50 " [51] " 51 " " 52 " " 53 " " 54 " " 55 " " 56 " " 57 " " 58 " " 59 " " 60 " [61] " 61 " " 62 " " 63 " " 64 " " 65 " " 66 " " 67 " " 68 " " 69 " " 70 " [71] " 71 " " 72 " " 73 " " 74 " " 75 " " 76 " " 77 " " 78 " " 79 " " 80 " [81] " 81 " " 82 " " 83 " " 84 " " 85 " " 86 " " 87 " " 88 " " 89 " " 90 " [91] " 91 " " 92 " " 93 " " 94 " " 95 " " 96 " " 97 " " 98 " " 99 " " 100 " [101] " 101 " " 102 " " 103 " " 104 " " 105 " " 106 " " 107 " " 108 " " 109 " " 110 " [111] " 111 " " 112 " " 113 " " 114 " " 115 " " 116 " " 117 " " 118 " " 119 " " 120 " [121] " 121 " " 122 " " 123 " " 124 " " 125 " " 126 " " 127 " " 128 " " 129 " " 130 " [131] " 131 " " 132 " " 133 " " 134 " " 135 " " 136 " " 137 " " 138 " " 139 " " 140 " [141] " 141 " " 142 " " 143 " " 144 " " 145 " " 146 " " 147 " " 148 " " 149 " " 150 "

[[2]] [1] " Sepal. Length " " Sepal. Width " " Petal. Length " " Petal. Width " [5] " Species "

dim ( d. f ) [1] 150 5

Fijaos en que el resultado de rownames son los identificadores de las filas entre comillas, es

decir, considerados como palabras; R entiende siempre que estos identificadores son palabras,

aunque, como en este caso, sean números.

Recordaréis que se puede obtener el valor de una componente de una list añadiendo al

nombre de esta última un sufijo formado por el signo $ seguido del nombre de la componente.

De manera similar, para obtener una columna concreta de un data frame basta añadir a su

nombre un sufijo formado por el signo $ seguido del nombre de la variable; el resultado será un

vector o un factor, según cómo esté definida la columna dentro del data frame.

d. f $ Sepal. Length [1:30]

[1] 5.1 4.9 4.7 4.6 5.0 5.4 4.6 5.0 4.4 4.9 5.4 4.8 4.8 4.3 5.

[16] 5.7 5.4 5.1 5.7 5.1 5.4 5.1 4.6 5.1 4.8 5.0 5.0 5.2 5.2 4.

d. f $ Species [1:30] [1] setosa setosa setosa setosa setosa setosa setosa setosa setosa [10] setosa setosa setosa setosa setosa setosa setosa setosa setosa [19] setosa setosa setosa setosa setosa setosa setosa setosa setosa [28] setosa setosa setosa Levels : setosa versicolor virginica

Como también pasaba con las componentes de las list, las variables de un data frame son

internas, no están definidas en el entorno global de trabajo de R.

Sepal. Length Error : object ’ Sepal. Length ’ not found

En la Sección 5.8 explicaremos cómo podemos declarar las variables internas de un data frame

como variables globales, y así poder usarlas directamente por su nombre, sin tener que añadirles

delante el nombre del data frame y el $.

Los data frames comparten con las matrices el uso de los corchetes para extraer trozos por

filas y columnas. Los resultados que se obtienen son de nuevo data frames, y tanto los nombres

de las columnas como los identificadores de las filas se heredan del data frame original; podemos

comprobarlo en los siguientes ejemplos:

d. f [1:5 , ] # La subtabla de las 5 primeras filas Sepal. Length Sepal. Width Petal. Length Petal. Width Species 1 5.1 3.5 1.4 0.2 setosa 2 4.9 3.0 1.4 0.2 setosa 3 4.7 3.2 1.3 0.2 setosa 4 4.6 3.1 1.5 0.2 setosa 5 5.0 3.6 1.4 0.2 setosa d. f [1:5 , 1:3] # La subtabla de las 5 primeras filas y las 3 primeras columnas Sepal. Length Sepal. Width Petal. Length 1 5.1 3.5 1. 2 4.9 3.0 1. 3 4.7 3.2 1. 4 4.6 3.1 1. 5 5.0 3.6 1. d. f [ d. f $ Species == " virginica " & d. f $ Sepal. Length >7 , ] # La subtabla de filas con Species = virginica y Sepal. Length > Sepal. Length Sepal. Width Petal. Length Petal. Width Species 103 7.1 3.0 5.9 2.1 virginica 106 7.6 3.0 6.6 2.1 virginica 108 7.3 2.9 6.3 1.8 virginica 110 7.2 3.6 6.1 2.5 virginica 118 7.7 3.8 6.7 2.2 virginica 119 7.7 2.6 6.9 2.3 virginica 123 7.7 2.8 6.7 2.0 virginica 126 7.2 3.2 6.0 1.8 virginica 130 7.2 3.0 5.8 1.6 virginica 131 7.4 2.8 6.1 1.9 virginica

stringsAsFactors. Por defecto, read.table transforma en factores las columnas de

palabras de la tabla que importa. Para impedir esta transformación, de manera que los

vectores de palabras se importen como tales, podemos usar stringsAsFactors=FALSE.

encoding. Como también ya explicamos en la función scan (página 3-4), este parámetro

sirve para indicar la codificación de alfabeto del fichero que se va a importar, y se ha

de usar si dicho fichero contiene palabras con letras acentuadas o caracteres especiales y

su codificación no coincide con la que espera nuestro ordenador: lo notaremos porque si

importamos el fichero sin especificar este parámetro, los acentos se importan mal. Como

los ficheros externos que usamos en este curso están codificados en utf8, los usuarios de

Windows de vez en cuando tendrán que usar encoding="latin1". Avisaremos cada vez

que sea necesario.

Para otros parámetros, podéis consultar la Ayuda de read.table.

Vamos a ilustrar el uso de esta función. Descargad en vuestro directorio de trabajo de R los

dos ficheros siguientes, manteniendo sus nombres y extensiones:

http://aprender.uib.es/Rdir/NotaHermanos.txt

http://aprender.uib.es/Rdir/NotaHermanosc.txt

Ambos ficheros son básicamente la misma tabla de datos, que recoge, para algunos estudiantes

de primer curso de la UIB de hace unos años, el grado en el que estaban matriculados (Bio-

logía, «BL», o Bioquímica, «BQ»), su número de hermanos y la nota que obtuvieron en un

determinado examen; la diferencia es que, en el primero, las columnas están separadas por es-

pacios en blanco, y en el segundo, por comas. Ambos ficheros contienen una primera fila con los

nombres de las variables. Están codificados en utf8, pero como no contienen letras acentuadas

ni caracteres especiales, no tenéis que preocuparos por su codificación.

Para crear un data frame llamado NH1 a partir de la copia local del fichero NotaHermanos.txt,

basta aplicar la función read.table a su nombre entre comillas y especificar header=TRUE.

NH1 = read. table ( " NotaHermanos. txt " , header = TRUE )

Es una buena costumbre, una vez definido un data frame a partir de un fichero externo,

comprobar que se ha importado bien. Como una tabla de datos puede tener muchas filas, verla

entera en la consola puede ser poco práctico; lo mejor es usar las funciones str y View o head.

Os aconsejamos que, siempre que vayáis a trabajar con un data frame, le echéis antes un vistazo

con estas funciones para comprobar su estructura, los nombres de sus variables, los tipos de

sus datos, etc. Esto es especialmente importante cuando se trata de data frames importados,

porque si no hemos especificado los parámetros adecuados, puede que en el proceso de lectura

y definición del data frame se hayan perdido los nombres de las variables o la estructura de

columnas.

head ( NH1 ) Grado Hermanos Nota 1 BQ 1 9. 2 BL 1 3. 3 BL 1 5. 4 BL 1 7. 5 BL 2 8.

6 BQ 0 8.

str ( NH1 ) ’ data. frame ’: 87 obs. of 3 variables : $ Grado : Factor w / 2 levels " BL " ," BQ " : 2 1 1 1 1 2 2 1 1 1 ... $ Hermanos : int 1 1 1 1 2 0 1 1 1 1 ... $ Nota : num 9.3 3.5 5.5 7.7 8.1 8.6 9.7 4 1.6 3. ...

Si no hubiéramos especificado header=TRUE, el formato del data frame resultante no habría

sido el adecuado.

NH1. mal = read. table ( " NotaHermanos. txt " ) str ( NH1. mal ) ’ data. frame ’: 88 obs. of 3 variables : $ V1 : Factor w / 3 levels " BL " ," BQ " ," Grado " : 3 2 1 1 1 1 2 2 1 1 ... $ V2 : Factor w / 6 levels " 0 " ," 1 " ," 2 " ," 3 " ,..: 6 2 2 2 2 3 1 2 2 2 ... $ V3 : Factor w / 50 levels " 1.0 " ," 1.1 " ," 1.6 " ,..: 50 48 13 26 38 41 45 49 17 3 ...

Sin el parámetro header=TRUE, R ha entendido que Grado, Hermanos y Nota son elementos

de sus columnas respectivas, y no sus nombres; en consecuencia, por un lado, ha llamado

por defecto V1, V2 y V3 a las columnas del data frame, y por otro, como Grado, Hermanos y

Nota son palabras y los datos de cada variable de un data frame han de ser del mismo tipo,

ha considerado que todas las entradas de cada columna eran palabras. Finalmente, como, al

crear un data frame, R interpreta los vectores de palabras como factores si no especificamos

lo contrario, hemos obtenido un data frame formado por tres factores, y hemos perdido la

información numérica que contenían las columnas con el número de hermanos y la nota.

Para importar el fichero NotaHermanosc.txt, donde las columnas están separadas por comas,

hay que usar el parámetro sep=",".

NH2 = read. table ( " NotaHermanosc. txt " , header = TRUE , sep = " ," ) str ( NH2 ) ’ data. frame ’: 87 obs. of 3 variables : $ Grado : Factor w / 2 levels " BL " ," BQ " : 2 1 1 1 1 2 2 1 1 1 ... $ Hermanos : int 1 1 1 1 2 0 1 1 1 1 ... $ Nota : num 9.3 3.5 5.5 7.7 8.1 8.6 9.7 4 1.6 3. ...

Sin este parámetro, R hubiera entendido cada fila como una sola palabra.

NH2. mal = read. table ( " NotaHermanosc. txt " , header = TRUE ) str ( NH2. mal ) ’ data. frame ’: 87 obs. of 1 variable : $ Grado. Hermanos. Nota : Factor w / 71 levels " BL ,0 ,2.0 " ," BL ,0 ,4.0 " ,..: 62 12 18 24 38 47 63 15 8 11 ...

Veamos el efecto de stringsAsFactors=FALSE:

NH3 = read. table ( " NotaHermanosc. txt " , header = TRUE , sep = " ," , stringsAsFactors = FALSE ) str ( NH3 )

Podemos indicar si tiene una primera fila con los nombres de las variables (en el campo

Heading).

Podemos especificar el signo que separa las columnas (en el campo Separator ) y el signo

que separa la parte entera de la decimal (en el campo Decimal ).

Podemos indicar si los vectores de palabras se han de convertir en factores (marcándolo

en Strings as factors).

La ventaja de este menú es que en su campo superior derecho vemos el fichero original, lo

que nos ayuda a rellenar los campos anteriores, y en el inferior derecho vemos el aspecto del

data frame que creamos con nuestras elecciones. Su inconveniente es que, si queremos que

nuestro análisis de datos sea reproducible por otras personas, es necesario incluir en el guión

que publiquemos la función read.table con los parámetros exactos que hemos usado.

Además de read.table, que sólo sirve para importar tablas en formato texto simple, R dispone

de otras instrucciones similares para importar otros tipos de ficheros. Las más útiles son:

read.csv, para importar ficheros en formato CSV.

read.xls y read.xlsx, del paquete xlsx, para importar hojas de cálculo tipo Excel u

OpenOffice en formato XLS o XLSX, respectivamente. Estas funciones usan Java; si no

lo tenéis instalado y no lo queréis instalar, lo mejor es que guardéis la hoja de cálculo en

formato CSV (tanto Excel como OpenOffice o Numbers ofrecen esta posibilidad) y uséis

read.csv.

read.mtb y read.spss, del paquete foreign, para importar tablas de datos de Minitab

y SPSS, respectivamente.

Si necesitáis otras funciones de este tipo, entrad help.search("read"), buscad la función que

os convenga y consultad su Ayuda.

Podemos exportar un data frame a un fichero usando la función write.table. Su sintaxis

básica es

write.table(data frame, file="nombre del fichero").

Esta función crea un fichero, en el directorio de trabajo de R, que contiene el data frame que

hemos especificado en el argumento, y lo llama el nombre que hemos especificado en file.

Además, podemos usar el parámetro sep para indicar el signo de separación de columnas en el

fichero que creemos y el parámetro dec para indicar el separador decimal; por ejemplo,

A = iris [1:5 , 1:4] A Sepal. Length Sepal. Width Petal. Length Petal. Width 1 5.1 3.5 1.4 0. 2 4.9 3.0 1.4 0.

3 4.7 3.2 1.3 0. 4 4.6 3.1 1.5 0. 5 5.0 3.6 1.4 0.

write. table (A , file = " trozoiris. txt " )

guarda el data frame A en un fichero llamado trozoiris.txt. Ahora podemos volver a importar

este fichero.

B = read. table ( " trozoiris. txt " , header = TRUE ) # Importamos la tabla B Sepal. Length Sepal. Width Petal. Length Petal. Width 1 5.1 3.5 1.4 0. 2 4.9 3.0 1.4 0. 3 4.7 3.2 1.3 0. 4 4.6 3.1 1.5 0. 5 5.0 3.6 1.4 0.

5.3. Cómo crear data frames

Además de trabajar con data frames importados o predefinidos, también podemos crearlos;

para ello, organizaremos en forma de tabla algunos vectores, cada uno de los cuales contendrá

las observaciones de una variable para un conjunto de individuos o casos, y de manera que los

datos en todos estos vectores estén en el mismo orden de los individuos: es decir, que la primera

entrada de cada vector corresponda a un mismo individuo, la segunda entrada de cada vector

corresponda a otro mismo individuo, y así sucesivamente.

Para construir un data frame a partir de unos vectores, se usa la función data.frame aplicada

a los vectores en el orden en el que queramos disponer las columnas de la tabla; de esta manera,

las variables tomarán los nombres de los vectores. Estos nombres también se pueden especificar

en el argumento de la función data.frame, entrando cada columna con una construcción de la

forma

Nombre de la variable=Vector con el contenido de la variable.

Vamos a ilustrar esta función con un ejemplo sencillo, que arrastraremos durante buena parte

de lo que queda de lección. Vamos a construir un data frame que contenga algunos datos sobre

estudiantes; concretamente, este data frame tendrá tres variables: una primera columna con el

sexo del estudiante, la segunda columna con su edad en años y la tercera con su número de

hermanos.

Sexo = c ( " Hombre " ," Hombre " ," Mujer " ," Hombre " ," Hombre " , " Hombre " ," Mujer " ) Edad = c (17 ,18 ,20 ,18 ,18 ,18 ,19) Hermanos = c (2 ,0 ,0 ,1 ,1 ,1 ,0) d. f1 = data. frame ( Sexo , Edad , Hermanos ) d. f Sexo Edad Hermanos 1 Hombre 17 2 2 Hombre 18 0 3 Mujer 20 0 4 Hombre 18 1 5 Hombre 18 1 6 Hombre 18 1 7 Mujer 19 0

[1] " Hombre " " Hombre " " Mujer " " Hombre " " Hombre " " Hombre " " Mujer "

Como vemos, el efecto de stringsAsFactors=FALSE ha sido que la variable sexo es ahora un

vector de palabras, y el del parámetro row.names ha sido llamar E1,E2,...,E7 a las filas.

Si hemos asignado identificadores a las filas, podemos usarlos para extraer subtablas del data

frame (aunque también podemos seguir usando los números de las filas). Recordad que, si usáis

los identificadores, como son palabras, hay que escribirlos entre comillas.

d. f2 [ c ( " E1 " ," E2 " ) , ] # Subtabla con las filas E1 y E Sexo Edad Hermanos E1 Hombre 17 2 E2 Hombre 18 0

Otra manera de crear un data frame con R es usando el editor de datos del que ya hemos

hablado en la Lección 3.^3 Recordaréis que, para abrir un objeto de datos con este editor, se le

aplica la función fix. R abre entonces el objeto en una nueva ventana de edición. Los cambios

que realicemos en un objeto con el editor de datos se guardarán cuando cerremos esta ventana.

Para crear un data frame con el editor de datos, lo primero que hay que hacer es crear un

data frame con la primera fila, y luego abrirlo con el editor para ir añadiendo filas (y columnas,

si se desea). La apariencia exacta de esta ventana y la manera de editar el data frame dependen

de la interfaz de R que se use; por ejemplo, en el RStudio de Mac OS X, entraríamos

d. f3 = data. frame ( Sexo = c ( " Hombre " ) , Edad = c (17) , Hermanos = c (2) ) fix ( d. f3 )

y se abriría la ventana que muestra la Figura 5.3.

Figura 5.3. Editor de data frames del RStudio de Mac OS X.

(^3) El uso del editor de RStudio para manipular data frames posiblemente requiera la instalación de algún programa auxiliar; por ejemplo, en el caso del Mac OS X, se tiene que tener instalada la última versión de XQuartz, que será el programa en el que se abrirá el editor. El instalador de XQuartz se puede descargar de http://xquartz.macosforge.org.

5.4. Cómo modificar un data frame

En esta sección veremos la manera de modificar un data frame una vez creado o importado.

Para cambiar los nombres de las variables, podemos usar la instrucción

names(data frame)=vector con los nombres de las variables.

Volvamos al d.f1. Tras recordar su estructura, cambiaremos los nombres de sus variables,

sustituyéndolos por sus iniciales, y volveremos a consultar su estructura para ver cómo han

cambiado estos nombres.

str ( d. f1 ) ’ data. frame ’: 7 obs. of 3 variables : $ Sexo : Factor w / 2 levels " Hombre " ," Mujer " : 1 1 2 1 1 1 2 $ Edad : num 17 18 20 18 18 18 19 $ Hermanos : num 2 0 0 1 1 1 0 names ( d. f1 ) = c ( " S " ," E " ," H " ) str ( d. f1 ) ’ data. frame ’: 7 obs. of 3 variables : $ S : Factor w / 2 levels " Hombre " ," Mujer " : 1 1 2 1 1 1 2 $ E : num 17 18 20 18 18 18 19 $ H : num 2 0 0 1 1 1 0

Si sólo queremos cambiar el nombre de algunas variables, basta redefinir el trozo correspon-

diente del vector names. Así, si en la nueva copia de d.f1 queremos volver a cambiar el nombre

de la variable E por Edad, podríamos usar una de las dos instrucciones siguientes:

names(d.f1)[2]="Edad" o names(d.f1)[names(d.f1)=="E"]="Edad".

Con la primera, cambiaríamos el nombre de la segunda variable por Edad; con la segunda,

cambiaríamos el nombre de la variable llamada E por Edad.

Para modificar los identificadores de las filas, podemos usar la instrucción

rownames(data frame)=vector con los nombres de las filas.

Como cada identificador ha de determinar el individuo al que corresponde la fila, conviene que

estos identificadores sean todos diferentes.

rownames ( d. f1 ) = paste ( " Alumno " , 1:7 , sep = " " ) d. f S E H Alumno 1 Hombre 17 2 Alumno 2 Hombre 18 0 Alumno 3 Mujer 20 0 Alumno 4 Hombre 18 1 Alumno 5 Hombre 18 1 Alumno 6 Hombre 18 1 Alumno 7 Mujer 19 0

Como podéis deducir de su efecto, la función paste pega vectores, entrada a entrada, usando

como separador el valor del parámetro sep; el separador por defecto es un espacio en blanco,

por lo que no hubiera hecho falta especificarlo, lo hemos hecho sólo para mostrar el parámetro.

Si en lugar de pegar un vector pegamos un elemento, éste se entiende como un vector constante

variable dentro del data frame) a su nuevo valor:

data frame$variable=nuevo valor.

Este nuevo valor puede ser el resultado de un cambio de tipo de datos aplicado a la varia-

ble. R dispone de una serie de funciones de la forma as.tipo_de_objeto, que convierten el

objeto al tipo que expresa el nombre de la función. Ya hemos visto en la Sección 3.4 la fun-

ción as.factor, que transforma un vector en un factor. Otras funciones de este estilo son

as.character, as.integer o as.numeric, que transforman todos los datos de un objeto en

palabras, números enteros o números reales, respectivamente.

Así, para transformar la variable Edad de la última versión estropeada de d.f1 en un vector

numérico, basta entrar lo siguiente:

d. f1 $ Edad = as. numeric ( d. f1 $ Edad ) str ( d. f1 ) ’ data. frame ’: 7 obs. of 3 variables : $ Sexo : Factor w / 2 levels " Hombre " ," Mujer " : 1 1 2 1 1 1 2 $ Edad : num 17 18 20 18 18 18 19 $ Hermanos : num 2 0 0 1 1 1 0

Un error típico al intentar modificar la variable Edad es entrar sólo as.numeric(d.f1$Edad);

con esta instrucción, obtenemos como resultado el vector 17 , 18 , 20 , 18 , 18 , 18 , 19 , pero no se

modifica la variable Edad del data frame. Tampoco sirve entrar Edad=as.numeric(d.f1$Edad),

porque esto define un vector llamado Edad de entradas 17 , 18 , 20 , 18 , 18 , 18 , 19 , pero sigue sin

modificar la variable Edad del data frame. La manera correcta de hacerlo es mediante

data frame$variable=nuevo valor.

Veamos otros ejemplos. Vamos a convertir la variable Sexo en un vector de palabras:

d. f1 $ Sexo = as. character ( d. f1 $ Sexo ) str ( d. f1 ) ’ data. frame ’: 7 obs. of 3 variables : $ Sexo : chr " Hombre " " Hombre " " Mujer " " Hombre " ... $ Edad : num 17 18 20 18 18 18 19 $ Hermanos : num 2 0 0 1 1 1 0

Y ahora vamos a convertir la variable Hermanos en un factor ordenado:

d. f1 $ Hermanos = ordered ( d. f1 $ Hermanos , levels = c (0 ,1 ,2) ) str ( d. f1 ) ’ data. frame ’: 7 obs. of 3 variables : $ Sexo : chr " Hombre " " Hombre " " Mujer " " Hombre " ... $ Edad : num 17 18 20 18 18 18 19 $ Hermanos : Ord. factor w / 3 levels " 0 " < " 1 " < " 2 " : 3 1 1 2 2 2 1

Naturalmente, podemos cambiar el contenido de toda una variable de otras maneras que no

sea sólo modificar su tipo de datos: basta igualarla a su nuevo valor.

d. f1 $ Edad = " Joven " d. f Sexo Edad Hermanos 1 Hombre Joven 2

2 Hombre Joven 0 3 Mujer Joven 0 4 Hombre Joven 1 5 Hombre Joven 1 6 Hombre Joven 1 7 Mujer Joven 0

Al igualar la variable Edad a la palabra «Joven», la ha substituido por el correspondiente vector

constante.

5.5. Cómo añadir filas y columnas a un data frame

Podemos añadir filas a un data frame definiéndolas con data frame[fila, ]=c(...); pero esta

construcción no es muy recomendable, porque si no vamos con cuidado puede provocar resul-

tados no deseados:

Las filas que añadimos de esta manera son vectores, y por lo tanto sus entradas han de

ser todas del mismo tipo. Por consiguiente, esta opción sólo se puede usar en data frames

cuyas variables contengan todas el mismo tipo de datos.

Si no añadimos las filas inmediatamente siguientes a la última del data frame, los valores

entre su última fila y las que añadimos quedarán no definidos, y aparecerán como NA; esto

puede ser un problema a la hora de aplicar funciones al data frame y además estropea los

factores.

La mejor manera de añadir filas a un data frame es organizándolas en un nuevo data frame

con los mismos nombres de las variables, y a continuación concatenarlas al data frame usando

la función rbind que ya usábamos para matrices.

d. f1 = d. f1bk # Volvemos a la copia original d. f Sexo Edad Hermanos 1 Hombre 17 2 2 Hombre 18 0 3 Mujer 20 0 4 Hombre 18 1 5 Hombre 18 1 6 Hombre 18 1 7 Mujer 19 0 nuevas. filas = data. frame ( Sexo = c ( " Hombre " ," Hombre " ) , Edad = c (18 ,18) , Hermanos = c (1 ,2) ) d. f1 = rbind ( d. f1 , nuevas. filas ) d. f Sexo Edad Hermanos 1 Hombre 17 2 2 Hombre 18 0 3 Mujer 20 0 4 Hombre 18 1 5 Hombre 18 1