IMPORTAR Y EXPORTAR BASE DE DATOS EN R DESDE STATA, SPSS, EXCEL Y OTROS

En esta guía se mostrará como importar y exportar base de datos desde distintos formatos como: .txt, .dat, .csv, .xlsx, .xls, .sav y .dta. Pero, primero se usarán los comandos getwd() y setwd() para saber nuestro directorio de trabajo y poder cambiarlo.

Puede descargar todas las base de datos que se usarán en el siguiente ENLACE DE DESCARGA

DIRECTORIO DE TRABAJO.

Es importante conocer nuestro directorio de trabajo ya que si guardamos nuestras base de datos en esa ubicación usaremos menos sintaxis a la hora de cargar a éstas.

Para saber en que carpeta se encuentra mi directorio de trabajo se usa el comando getwd().

getwd()

## [1] "F:/Tutos"

Podemos ver que mi directorio se ubica en F:/Tutos, si nosotros deseamos cambiarlo tendríamos que usar el comando setwd(), en los parentesis se tendría que especificar la nueva dirección estas tienen que ir en comillas " ".

Mostraré un ejemplo, en el cual lo deseo cambiar al disco F:/.

setwd("F:/")

Pero lo devolveré a la dirección anterior, porque ahí tengo mis base de datos.

setwd("F:/Tutos")

Una vez definido nuestro directorio, pasamos a la sección de “Importar base de datos”.

IMPORTAR BASE DE DATOS.

Si nosotros deseamos importar archivos de texto ASCII (.txt, .dat, entre otros) usaremos el comando read.table() o read.fwf().

La sintaxis para read.table es la siguiente:

read.table(file, header = FALSE, sep = "", quote = "\"'", dec = ".", row.names, col.names, as.is = FALSE, na.strings = "NA", colClasses = NA, nrows = -1, skip = 0, check.names = TRUE, fill = !blank.lines.skip, strip.white = FALSE, blank.lines.skip = TRUE, comment.char = "#")

En la siguiente tabla se muestra cada uno de estos argumentos.

ARGUMENTO	DESCRIPCIÓN
file	El nombre del archivo entre “”, si está en otra carpeta se tendrá que usar la dirección exacta, si la base de datos se encuentra en la web, es decir, cuenta con una url use (http://…)
header	Argumento lógico, en donde si es TRUE considera a la primera fila como la que contiene el nombre de las variables.
sep	Indica el separador usado en el archivo, algunos ejemplos para usar: “” " " “;” “,” “”.
quote	Indica los caracteres que se desean usar para los elementos caracteres, algunos ejemplos para usar: “” ’’ .
dec	El caracter que se usa para indicar el separador decimal. Puede usar . o , u otro.
row.names	El vector en el que se indican el nombre de las filas.
col.names	El vector en el que se indican el nombre de las columnas.
as.is	Argumento lógico, en donde si es FALSE convierte las variables caracteres en factor.
na.strings	El valor con el que se codificará a los datos ausentes, por defecto “NA”.
colClasses	Un vector de caracteres que proporciona clases para las columnas.
nrows	El número máximo de filas a leer de la base de datos.
skip	El numero de filas ignoradas antes de leer la base de datos
check.names	Argumento lógico, en donde si es TRUE verifica que el nombre de las variables son válidos para R.
fill	Argumento lógico, en donde si es TRUE y todas las filas no tienen el mismo numero de variables, agrega “blancos”.
strip.white	Argumento lógico, en donde si es TRUE borra los espacios en blanco antes y después de las variables de tipo caracter. Dependerá de los que se especifique en “sep”.
blank.lines.skip	Argumento lógico, en donde si es TRUE ignora las filas en blanco.
comment.char	Caracter que indica comentario en la base de datos. Si una observación comienza con el caracter “#”, R ignorará su lectura. Si se desea desactivar esta función usar comment.char =“”

A continuación se muestra un ejemplo:

Se importará la base de datos llamada pbigob.txt.

datos1<-read.table(file="pbigob.txt", header = TRUE, sep = "\t")

En donde a esta base la llamamos datos1. Como la base de datos se encuentra en mi directorio sólo escribo el nombre del archivo, luego en header asigno TRUE ya que la primera fila contiene los nombres de las variables, por último en sep uso \t, ya que el separador del archivo son las tabulaciones.

Para ver la base de datos que cargamos:

View(datos1)

Ahora mostraremos el caso de una base de datos en donde la primera fila no tiene el nombre de las variables, sino los datos propiamente dichos. Es decir, si colocaramos header=TRUE estaríamos perdiendo la primera fila.

Por tanto, para agregar los nombres a las variables se usará el comando col.names(). Antes de aquello pasamos a explicar lo que contiene este archivo.

La base de datos consta del precio de las monedas: Dólar, Euro y Yen expresado en la moneda nacional de Perú.

La primera columna es el periodo y las tres siguientes las monedas.

Como se puede ver la primera fila no contiene el nombre de las variables, por tanto es preciso agregarlo.

datos2<-read.table(file = "monedas.txt", 
                   sep = "", 
                   col.names = c("Periodo","Dólar","Euro","Yen"))

Ahora vemos como nos quedo la base de datos:

View(datos2)

Resultado de moneda.txt luego de agregar el nombre de las variables

Por último, vamos a hacer un ejemplo similar pero, esta vez la base de datos no se encuentra almacenado en nuestro directorio. Por tanto, se tendrá que especificar la dirección exacta.

A continuación se muestra la sintaxis:

datos3<-read.table(file = "F:/ingles/R- clases/R - scripts/monedas2.txt",
                   col.names=c("Periodo","Real","Libra","Peso"))

La dirección en donde estaba alojado el archivo era F:/ingles/R- clases/R - scripts/monedas2.txt, distinta a F:/Tutos por eso escribimos la ubicación exacta.

Es así como se vería esta base de datos:

View(datos3)

Resultado de moneda2.txt luego de agregar el nombre de las variables

En la práctica encontrará una infinidad de problemas y características de las bases de datos, aquí sólo se mencionó como solucionar las más fáciles. Al igual que uno aprende matemáticas, a R lo aprenderá practicando.

En las siguientes guías (cuando lo amerite), se verá como solucionar problemas reales de las base de datos usando varios argumentos del comando read.table(). Ahora pasamos a mostrar como deberíamos de importar una base de datos con extensión .csv.

IMPORTAR DESDE UN ARCHIVO “.CSV”.

Un archivo .csv es muy similar a un archivo .xlsx (excel) sólo que sin el formato. Este tipo de archivos se puede generar desde la mayoría de software, tiene un uso muy frecuente ya que es el paso anterior para poder usar excel. Y principalmente porque pesa menos que un archivo .xlsx.

Para cargar estos tipos de archivos vamos a usar el comando read.csv() que tiene argumentos similares a read.table. Por tanto, se hará muy fácil su comprensión.

Para el ejemplo cargaremos una parte de la base de datos de una de las encuestas del inei.

datos4<-read.csv("inei.csv",
                 sep=";",
                 header = TRUE)

En este caso, lo que separa a cada observación es el ;, por tanto en sep se colocó ese caracter. Adicionalmente, header=TRUE indica que la primera fila contiene el nombre de las variables.

Veamos como quedó:

View(datos4)

Importar archivos .csv es muy sencillo, si usted comprendió el comando read.table() compartirá esta afirmación.

IMPORTAR ARCHIVOS DESDE STATA, SPSS Y EXCEL.

Para importar archivos de Stata y Spss vamos a instalar el paquete foreign.

install.packages("foreign")

Por último cargamos el paquete:

library(foreign)

IMPORTAR DESDE SPSS.

Ahora si deseamos importar un archivo en formato .sav (desde SPSS), usaremos el comando read.spss().

Este comando tiene varios argumentos, por tal motivo, recomendamos revisar la documentación digitando en la consola ?read.spss.

Se hará un sencillo ejemplo. Si usted desea profundizar no omita revisar la documentación señalada.

Vamos a cargar la base de datos del trimestre móvil Abril - Mayo - Junio de la encuesta permanente de empleo (EPE) del INEI.

datos5<-read.spss("Trim Abr-May-Jun12.sav", to.data.frame = TRUE)

Se usó el argumento to.data.frame igual a TRUE, esto indica que al cargar la base de datos lo convierta en un data frame.

Veamos como nos quedo:

View(datos5)

IMPORTAR DESDE STATA.

Ahora si deseamos importar un archivo .dta (desde STATA) usaremos el comando read.dta(). Al igual que antes, se recomienda ver la documentación ?read.dta para mejor detalle.

Vamos a cargar la base de datos mundo.dta.

datos6<-read.dta("mundo.dta")

Si logra darse cuenta, al importar la base de datos los missing values se han convertido en valores “NA”. Si usted desea mantener a los missing values como “.” tendrá que usar el argumento missing.type.

También hay otra forma de importar archivos desde STATA. Para lo cual se tendrá que instalar el paquete haven.

install.packages("haven")

Cargamos el paquete:

library(haven)

Una vez cargado, usaremos el comando read_dta(). Usted puede preguntarse porque usar este comando al margen del read.dta(). Es por las etiquetas de las variables. Mientras con read_dta() se consigue observar las etiquetas de las variables con read.dta() éstas son omitidas.

Veamos que nos resulta si volvemos a cargar la base de datos mundo.dta

datos7<-read_dta("mundo.dta")

El resultado es:

View(datos7)

Base de datos Mundo (.dta) con el comando read_dta

En efecto, ahora las variables aparecen con sus respectivas etiquetas. Si usted desea conocer más sobre este comando le recomendamos observar la documentación, digitando en la consola ?read_dta.

IMPORTAR DESDE EXCEL.

Por último, se mostrará como cargar una base de datos con extensión .xlsx o .xls (desde EXCEL). Primero recordar que el archivo .xlsx se puede convertir a .csv y asi poder ganar tiempo y tener una base de datos de menor tamaño.

De igual forma vamos a mostrar como importar esta clase de archivos.

Lo primero, tiene que tener instalado y actualizado Java en su computador. Posteriormente, instalaremos el paquete readxl.

install.packages("readxl")

Cargamos el paquete:

library(readxl)

En este ejemplo, vamos a importar el archivo pobreza.xls, para lo cual se usará el comando read_xls().

datos8<-read_xls("pobreza.xls")

Veamos como nos quedó:

View(datos8)

Base de datos pobreza (.xls) con el comando read_xls

Si usted desea importar un archivo con extensión .xlsx, deberá usar el comando read_xlsx() muy similar al anterior.

Veamos un ejemplo:

datos9<-read_xlsx("datos.xlsx")

Veamos los resultados:

View(datos9)

Archivo datos (.xlsx) uso del comando read_xlsx

IMPORTAR DESDE UN SITIO WEB.

Si tiene la url de la base de datos se usará cualquiera de los comandos antes señalados dependiendo del tipo de archivo. Pero en la parte en donde se colocaba la dirección (ubicación en el disco) argumento file, ahora se colocará la dirección web, como antes entre comillas “”.

Veamos un ejemplo, desemos importar la base de datos llamada binary.dta que esta alojado en los servidores del UCLA (Universidad de California).

Entonces, la sintaxis sería la siguiente:

datos10<-read_dta("http://stats.idre.ucla.edu/stat/stata/dae/binary.dta")

Veamos que nos resultó:

View(datos10)

Base de datos binary.dta importado desde la web

Cabe precisar que se puede usar argumentos junto con la importación de archivos desde la web.

EXPORTAR BASE DE DATOS.

Al igual que importar desde una extensión predeterminada, se puede exportar en cualquier extensión.

Si deseamos exportar la base de datos a extensión .txt, usaremos el comando write.table() que tiene la sintaxis básica:

write.table(x, file="", ...)

Donde x es el objeto (data frame) que se desea exportar y file es el argumento en donde se coloca el nombre del archivo al que se exportará. Los ... indica que se puede usar otros argumentos, para poder porfundizar usted puede revisar la documentación digitando ?write.table.

Como ejemplo exportaremos la última base de datos importada, es decir, datos10. A formato .txt para que pese menos. Entonces, la sintaxis sería la siguiente:

write.table(datos10, file = "datos10_m.txt")  # Para exportarlo en un archivo txt.

En donde el objeto a ser exportado es la base de datos datos10 y el nombre con que el que deseo guardarlo es datos10_m.txt.

Si usted va a su directorio de trabajo encontrará el archivo “datos10_m.txt”

Si usted desea exportarlo como un archivo .dta, tendrá que usar el comando write_dta().

Que tendrá una sintaxis similar al de write.table() sólo que en este caso se podría agregar la versión de stata a la que se desea guardar.

write_dta(datos6, path = "mundotee.dta", version = 14L)

Lo que se hizo fue exportar la base de datos datos6 a la versión de STATA 14 y se guardó con el nombre mundotte.dta. Al igual que antes, este archivo se encontrará en su directorio de trabajo.

Es más que seguro que usted se ha dado cuenta cuales son los comandos para exportar, sólo hay que cambiar la palabra read por write y luego escribir el nombre de la extensión deseada. Si usted desea profundizar le recomendamos ver la documentación de cada comando y principalmente practicar como si fuese un juego muy divertido.

En la siguiente guía se desarrollará el tema de expresiones regulares.