<jupyter_start><jupyter_text>Extracción de datos===  Contenido >  * [Lectura y escritura de archivos de texto](Lectura-y-escritura-de-archivos-de-texto)  * [Formato nativo de R   ](Formato-nativo-de-R)  * [Feather R/Python interchange format](Feather-R/Python-interchange-format)  * [CSV](CSV)  * [CSV2](CSV2)  * [TXT con formato libre](TXT-con-formato-libre)  * [TXT como tablas de texto](TXT-como-tablas-de-texto)  * [TXT con formato de ancho fijo](TXT-con-formato-de-ancho-fijo)  * [JSON](JSON)  * [HTML](HTML)  * [Excel](Excel)  * [HDF5](HDF5)  * [STATA](STATA)  * [SAS](SAS)  * [XBASE](XBASE)  * [MySQL y MariaDB](MySQL-y-MariaDB)  * [XML](XML)  * [ARFF Weka](ARFF-Weka)  * [MPT minitab portable worksheet  ](MPT-minitab-portable-worksheet)  * [PDF](PDF) **Datos de ejemplo**.  > [`Constants {base}`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/Constants.html)  [`Uniform {stats}`](https://stat.ethz.ch/R-manual/R-devel/library/stats/html/Uniform.html)<jupyter_code>## crea un dataframe de prueba
df <- data.frame(index = 1:5,
                 name = LETTERS[1:5],
                 value = round(runif(5)*10, 2))
print(df)                
## crea un texto de prueba en formato libre (obtenido de wikipedia)
## los cambios de línea introducen caracteres de retorno de carro '\n'
txt = "R is a programming language and software environment for statistical computing 
and graphics supported by the R Foundation for Statistical Computing.[3] The R language 
is widely used among statisticians and data miners for developing statistical software[4] 
and data analysis.[5] Polls, surveys of data miners, and studies of scholarly literature 
databases show that R's popularity has increased substantially in recent years.[6]"
print(txt)
## escribe el archivo en disco
cat(txt, file = 'files/wikipedia.txt')<jupyter_output><empty_output><jupyter_text>---  Lectura y escritura de archivos de texto [Contenido](Contenido) > [`readLines {base}`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/readLines.html)  [`writeLines {base}`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/writeLines.html)  [`scan {base}`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/scan.html)<jupyter_code># escribe el contenido del vector de strings al archivo
writeLines(text = sprintf('linea %d', seq(5)), # genera el vector de strings
           con = 'out.1',  # nombre del archivo
           sep = '\n')     # separador entre strings (retorno de carro)
# lee el contenido total o parcial del archivo
readLines(con = 'out.1',  # nombre del archivo
          n = -1L)        # la totalidad del archivo
# lee el contenido total o parcial del archivo
readLines(con = 'out.1',  # nombre del archivo
          n = 3)          # las primeras 3 lineas
writeLines(text = as.character(seq(10)), # genera una secuencia de enteros 1, ..., 10
           con = 'out.1',                # nombre del archivo
           sep = '\n')                   # separador entre strings (retorno de carro)
# imprime las lineas, una a una
cat("linea 1\n", file='out.1')
cat("linea 2\n", file='out.1', append=TRUE)
cat("linea 3\n", file='out.1', append=TRUE)
readLines('out.1')
cat("", file='out.1') # crea un archivo vacío
print(readLines('out.1'))<jupyter_output><empty_output><jupyter_text>En el siguiente ejemplo se realiza la concatenación del contenido de archivos.<jupyter_code># se crean tres archivos
cat(sprintf('linea %d', seq(from=1, to=3)), sep='\n', file='out.1')
cat(sprintf('linea %d', seq(from=4, to=6)), sep='\n', file='out.2')
cat(sprintf('linea %d', seq(from=7, to=9)), sep='\n', file='out.3')
x <- readLines('out.1')       # inicializa la variable con el contenido de `out.1`. 
x <- c(x, readLines('out.2')) # agrega el contenido de `out.2` a x
x <- c(x, readLines('out.3')) # agrega el contenido de `out.3` a x
cat(x, sep='\n')
# se leen las tres primeras lineas del archivo
cat(sprintf('linea %d', seq(10)), sep='\n', file='out.1') # crea el archivo
readLines('out.1', ok=TRUE, n=3)  
cat("linea 1", "linea 2", "linea 3", # cadenas de texto (strings)
    sep='\n',                        # separador entre strings
    file='out.1')                    # nombre del archivo 
readLines('out.1') # lee el archivo
cat(sprintf('linea %d', seq(10)), sep='\n', file='out.1') # crea el archivo
# se leen las tres últimas lineas del archivo
x <- readLines('out.1', ok=TRUE)
x[(length(x)-2):length(x)]
# se todas las lineas del archivo, exceptuando las cuatro primeras.
x <- readLines('out.1', ok=TRUE)
x[-(1:4)]
# cuenta la cantidad de líneas del archivo
length(readLines('out.1'))
# divide el contenido del archivo en palabras
x <- readLines('out.1')
#print(strsplit(x, split=' '))
print(unlist(strsplit(x, split=' ')))
# cuenta la cantidad de palabras del archivo
x <- readLines('out.1')
x <- paste(x, sep='', collapse=' ')  # pega todas las líneas en un solo string
x <- strsplit(x, split=' ')[[1]]
length(x)
# cuenta la cantidad de caracteres de un archivo
x <- readLines('out.1')
x <- paste(x, sep='', collapse=' ')
x <- strsplit(x, split=' ')[[1]]
sum(nchar(x))<jupyter_output><empty_output><jupyter_text>La función `scan()` permite la escritura directa a archivos en disco duro.<jupyter_code>cat(sprintf('%d', seq(10)), sep='\n', file='out.1') # crea el archivo
scan('out.1') # lee el contenido del archivo y lo convierte en vector
scan(text='1.2.3.4.5.6.7.8.9.10', sep='.') # tambien puede leer de strings<jupyter_output><empty_output><jupyter_text>Formato nativo de R    [Contenido](Contenido) > [`save {base}`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/save.html)  [`load {base}`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/load.html)  [`readRDS {base}`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/readRDS.html)  [`saveRDS {base}`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/readRDS.html)<jupyter_code>## Salva el dataframe. se pueden salvar varios objetos simultáneamente
save(df, file='files/data.RData') 
## Se listan las variables existentes en el entorno.
ls()
## remueve el dataframe.
rm(df)
ls()
## recupera el dataset `df` del archivo.
load(file='files/data.RData' )
print(df)
saveRDS(df, "files/data.rds")
print(readRDS("files/data.rds"))<jupyter_output><empty_output><jupyter_text>Feather R/Python interchange format [Contenido](Contenido) > [`read_feather {feather}`](https://cran.r-project.org/web/packages/feather/index.html)  [`write_feather {feather}`](https://cran.r-project.org/web/packages/feather/index.html)> Instalación:```devtools::install_github("wesm/feather/R")```<jupyter_code>library(feather)
write_feather(df, 'files/data.feather')
x <- read_feather('files/data.feather')
print(x)<jupyter_output><empty_output><jupyter_text>CSV [Contenido](Contenido) > [`write.csv {utils}`](https://stat.ethz.ch/R-manual/R-devel/library/utils/html/write.table.html)  [`read.csv {utils}`](https://stat.ethz.ch/R-manual/R-devel/library/utils/html/read.table.html)<jupyter_code>## lo escribe con formato csv.
write.csv(x = df, 
          file = 'files/data.csv',  # archivo
          row.names = FALSE)        # imprime los nombres de las filas?

## imprime el contenido del archivo
x <- readLines(con = 'files/data.csv', n = -1L)
cat(x , sep = '\n')
## graba el dataset 'iris' para usarlo en el tutorial de python
write.csv(x = iris, 
          file = 'files/iris.csv',  # archivo
          row.names = FALSE)        # imprime los nombres de las filas?
## lectura
x <- read.csv(file = 'files/data.csv', # nombre del archivo
              header = TRUE,           # nombres de columnas
              sep = ",",               # separador de campos
              dec = ".")               # separador de decimales
print(x)<jupyter_output><empty_output><jupyter_text>CSV2 [Contenido](Contenido) > [`write.csv2 {utils}`](https://stat.ethz.ch/R-manual/R-devel/library/utils/html/write.table.html)  [`read.csv2 {utils}`](https://stat.ethz.ch/R-manual/R-devel/library/utils/html/read.table.html)<jupyter_code>## ';' para campos y ',' para decimales.
write.csv2(x = df, 
           file = 'files/data.csv2',  # archivo
           row.names = FALSE)         # imprime los nombres de las filas?

## imprime el contenido del archivo
cat(readLines(con = 'files/data.csv2', n = -1L), sep = '\n')
## lectura
x <- read.csv(file='files/data.csv2', # nombre del archivo
              header=TRUE,            # nombres de columnas
              sep = ";",              # separador de campos
              dec = ",")              # separador de decimales
print(x)<jupyter_output><empty_output><jupyter_text>TXT con formato libre [Contenido](Contenido) > [`scan {base}`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/scan.html)<jupyter_code>## separa el contenido del archivo por palabra 
## (strings delimitados por espacios en blanco)
print(scan(file = 'files/wikipedia.txt',  # nombre del archivo
           what = character(0)))          # tipo de dato          
## separa el contenido del archivo por renglon y frase
print(scan(file = 'files/wikipedia.txt',   #
           what = character(0),            #
           quote='',                       # 
           sep='.'))                       # caracter de separación<jupyter_output><empty_output><jupyter_text>TXT como tablas de texto [Contenido](Contenido) > [`write.table {utils}`](https://stat.ethz.ch/R-manual/R-devel/library/utils/html/write.table.html)  [`read.table {utils}`](https://stat.ethz.ch/R-manual/R-devel/library/utils/html/read.table.html)<jupyter_code>## escribe el archivo en forma de tabla 
write.table(x = df,                   # el dataframe
            file = 'files/data.txt',  # archivo
            append = FALSE,           # lo agrega al final del archivo? 
            sep = ' ',                # caracter de separcion entre campos
            quote = FALSE,            # delimitador
            row.names = FALSE,        # imprime los nombres de las filas? No
            col.names = TRUE)         # imprime los nombres de las columnas? Si

## imprime el contenido del archivo
cat(readLines(con = 'files/data.txt', n = -1L), sep = '\n')
x <- read.table(file = 'files/data.txt', 
                header = TRUE, 
                sep = "", 
                quote = "\"'")     
print(x)<jupyter_output><empty_output><jupyter_text>TXT con formato de ancho fijo [Contenido](Contenido) > [`read.fwf {utils}`](https://stat.ethz.ch/R-manual/R-devel/library/utils/html/read.fwf.html)  [`write.fwf {gdata}`](http://svitsrv25.epfl.ch/R-doc/library/gdata/html/write.fwf.html)<jupyter_code># crea un archivo separado por multiples espacios en blanco.
# los nombres de las columnas están separados por comas.
cat("index,names,values,codes",
    "00001john wick002.1310",
    "00002mark twin003.1411",
    "00003louis ng 004.3412",
    "00004dan brown002.3113",
    "00005ann marie004.9814", sep = '\n', file = 'files/data.fwf')
x <- read.fwf(file='files/data.fwf',    # nombre del archivo
              widths=c(5,9,6,2),        # anchos de los campos
              header = TRUE,            # nombres de columnas
              sep = ",")                # separador de los nombres de columnas

print(x)<jupyter_output><empty_output><jupyter_text>JSON [Contenido](Contenido) > [`toJSON {jsonlite}`](https://cran.r-project.org/web/packages/jsonlite/index.html)  [`fromJSON {jsonlite}`](https://cran.r-project.org/web/packages/jsonlite/index.html) > [`toJSON {rjson}`](https://cran.r-project.org/web/packages/rjson/index.html)  [`fromJSON {rjson}`](https://cran.r-project.org/web/packages/rjson/index.html)> JSON en [Wikipedia](https://es.wikipedia.org/wiki/JSON)<jupyter_code># carga las librerias
library(jsonlite)
library(rjson)
## convierte a JSON
jsonlite::toJSON(df, pretty = TRUE)
jsonlite::fromJSON(jsonlite::toJSON(df))
print(x)
x <- rjson::fromJSON(file = "files/data.json" )
#str(x)
x<jupyter_output><empty_output><jupyter_text>HTML [Contenido](Contenido) > [`rio` Package](https://cran.r-project.org/web/packages/rio/index.html): : A Swiss-Army Knife for Data I/O<jupyter_code>library(rio)
export(df, 'files/data.html')

# imprime el archivo creado
cat(readLines(con = 'files/data.html', n = -1L), sep = '\n')<jupyter_output><empty_output><jupyter_text>Excel [Contenido](Contenido) > [`WriteXLS {WriteXLS}`](https://cran.r-project.org/web/packages/WriteXLS/)> [`read.xls {gdata}`](http://svitsrv25.epfl.ch/R-doc/library/gdata/html/read.xls.html)  [`read_excel {readxl}`](https://cran.r-project.org/web/packages/readxl/)  [`read.xlsx {xlsx}`](https://cran.r-project.org/web/packages/xlsx/)  [`loadWorkbook {XLConnect}`](https://cran.r-project.org/web/packages/XLConnect/)  [`readWorksheet {XLConnect}`](https://cran.r-project.org/web/packages/XLConnect/)<jupyter_code>## convierte el data.frame a Excel
library(WriteXLS)
WriteXLS(x = df, ExcelFileName = "files/data.xls")
library(gdata)                   # contiene la función read.xls
x <- read.xls(xls='files/data.xls',   # nombre del archivo
              sheet=1)                # indice de la hoja a leer.
print(x)
library(XLConnectJars)
library(XLConnect) 
x <- readWorksheet(loadWorkbook("files/data.xlsx"),  # carga el libro
                   sheet=1)                          # lee la hoja 1
print(x)
library(readxl)  # debe instalar el paquete readxl
x <- read_excel("files/data.xls")
print(x)
library(xlsx)  
x <- read.xlsx('files/data.xlsx',  # el archivo
               sheetIndex = 1,     # la hoja
               header = TRUE)      # la tabla tiene cabeceras?
print(x)<jupyter_output><empty_output><jupyter_text>HDF5 [Contenido](Contenido) > Para la manipulación de modelos de datos en HDF5 se usa el paquete `hdf5` disponible en bioconductor. Para instalarlo, ejecute los siguientes comandos en el prompt de comandos del IDLE de R.```> source("http://bioconductor.org/biocLite.R")   bioconductor installer> biocLite("rhdf5")                              instalador del paquete```El manual de usuario se puede obtener [aquí](http://www.bioconductor.org/packages/release/bioc/vignettes/rhdf5/inst/doc/rhdf5.pdf).<jupyter_code># si el archivo ya existe lo borra
if (file.exists('files/data.h5')) {
    file.remove('files/data.h5')
}

library(rhdf5)
h5createFile("files/data.h5")                # crea el archivo
h5createGroup("files/data.h5","myGroup1")    # crea un grupo
h5createGroup("files/data.h5","myGroup2")    # crea otro grupo
h5createGroup("files/data.h5","myGroup3")    # y otro grupo
h5ls("files/data.h5")                        # lista los grupos en el archivo
# se crean varios datos de diferentes tipos 
a = matrix(1:10,nr=5,nc=2)
b = c(1, 2, 3, 4, 5)
c = 'holamundo'
# se escriben los contenidos de las variables al archivo 
h5write(a,  "files/data.h5","myGroup1/a")
h5write(b,  "files/data.h5","myGroup1/b")
h5write(c,  "files/data.h5","myGroup1/c")
h5write(df, "files/data.h5","myGroup1/df")
x <- h5ls("files/data.h5")
H5close()

print(x)
# lectura del archivo
h5f = H5Fopen("files/data.h5")
h5f
h5f$myGroup1
H5close() # cierre de la conexión al archivo.<jupyter_output><empty_output><jupyter_text>STATA [Contenido](Contenido) > [`read.dta {foreign}`](http://www.inside-r.org/r-doc/foreign/read.dta)  [`write.dta {foreign}`](http://www.inside-r.org/r-doc/foreign/write.dta)<jupyter_code>library(foreign)
write.dta(df, 'files/data.dta')
x <- read.dta('files/data.dta')
print(x)<jupyter_output><empty_output><jupyter_text>SAS [Contenido](Contenido) > no hay info disponible<jupyter_code>#
# pendiente
#<jupyter_output><empty_output><jupyter_text>XBASE [Contenido](Contenido) > [`read.dbf {foreign}`](http://www.inside-r.org/r-doc/foreign/read.dbf)  [`write.dbf {foreign}`](http://www.inside-r.org/r-doc/foreign/write.dbf)<jupyter_code>library(foreign)
write.dbf(df, 'files/data.dbf')
read.dbf('files/data.dbf')<jupyter_output><empty_output><jupyter_text>MySQL y MariaDB [Contenido](Contenido) > Para estos ejemplos, la máquina local debe tener instalada la herramienta. Visite http://dev.mysql.com/downloads/ para más información.> **Nota.** A continuación se describe el proceso de instalación de MySQL.> 1. Descague el instalador y ejecutelo. Durante la instalación el sistema le suministrará un username y un password inicial. En mi caso: root@localhost y <PASSWORD>Vi2. Cuando finalice la instalación, vaya el prompt de comandos y ejecute MySQL. En OS X la ruta es `/usr/local/mysql/bin`.3. Como resultado se abrirá consola de comandos de MySQL.4. En la consola, el primer paso es reiniciar el password. Para ello, ejecute el siguiente comando en la consola:  `ALTER USER 'root'@'localhost' IDENTIFIED BY 'xxx';`5. Cree una base de datos de prueba:        `CREATE DATABASE test;`6. Salga de MySQL con `quit`.<jupyter_code># crea una conexión a la base de datos
library(RMySQL)
con_mysql <- dbConnect(RMySQL::MySQL(), 
                       user="root", 
                       password="<PASSWORD>", 
                       dbname='test')
# crea una tabla llamada 'mtcars' y graba el dataframe `mtcars` en ella.
dbSendQuery(con_mysql, 'drop table if exists mtcars')   # borra la tabla si existe
dbWriteTable(conn=con_mysql, name = 'mtcars', value = mtcars) # crea la tabla
# lista las tablas existentes en la base de datos actual.
# 'mtcars'  es la tabla que se acabo de crear
dbListTables(con_mysql)
# obtiene los registros con mpg > 30 de la tabla.
result = dbSendQuery(con_mysql, "select * from mtcars where mpg > 30")
df = fetch(result)
df
dbDisconnect(con_mysql)<jupyter_output><empty_output><jupyter_text>XML [Contenido](Contenido) > [`XML` Package](https://cran.r-project.org/web/packages/XML/index.html)  [`rio` Package](https://cran.r-project.org/web/packages/rio/index.html): : A Swiss-Army Knife for Data I/O> XML en [Wikipedia](https://en.wikipedia.org/wiki/XML)<jupyter_code>library(rio)
export(df, 'files/data.xml')
library(XML)

## lee el archivo en formato XML
xmlfile <- xmlTreeParse("files/data.xml")

##
topxml <- xmlRoot(xmlfile)
topxml <- xmlSApply(topxml, function(x) xmlSApply(x, xmlValue))

##
print(topxml)
xml_df <- data.frame(t(topxml),
                     row.names=NULL)
print(xml_df)
# otra forma
print(xmlToDataFrame('files/data.xml'))<jupyter_output><empty_output><jupyter_text>ARFF Weka [Contenido](Contenido) > [`read.arff {foreign}`](http://www.inside-r.org/r-doc/foreign/read.arff)  [`write.arff {foreign}`](http://www.inside-r.org/r-doc/foreign/write.arff)<jupyter_code>## no es compatible con la librería de Python
library(foreign)
write.arff(x = df,
           file = 'files/data.arff')
x <- read.arff(file = 'files/data.arff')
print(x)<jupyter_output><empty_output><jupyter_text>MPT minitab portable worksheet   [Contenido](Contenido) > [`read.mtp {foreign}`](http://www.inside-r.org/r-doc/foreign/read.mtp)<jupyter_code>library(foreign)
# read.mpt('data/data.mtp')<jupyter_output><empty_output><jupyter_text>PDF [Contenido](Contenido) > Para leer pdfs debe tener instalado el paquete tm (text mining). El paquete `tm` usa la función `pdftotext` del sistema Unix. Para instalarla (en Unix) use homebrew.```brew install poppler```<jupyter_code># Para este ejemplo se creó un archivo pdf que contiene el texto del ejemplo anterior.
library(NLP)
library(tm)
pdf_reader <- readPDF(control = list(text = "-layout"))      # crea la función para leer el documento
pdf_docs <- pdf_reader(elem = list(uri = 'files/data.pdf'),  # nombre del archivo
                       language = "en")                      # idioma
names(pdf_docs)
# metadatos
pdf_docs$meta
# contenido
pdf_docs$content<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.15520073929561556, 'fraction_numerical': 0.012372933566074546, 'mean_word_length': 3.7707567964731816, 'pattern_counts': {'":': 0, '<': 129, '<?xml version=': 0, '>': 128, 'https://': 33, 'lorem ipsum': 0, 'www.': 8, 'xml': 18}, 'pii_count': 2, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '23', 'dir': 'jupyter-structured-clean-dedup', 'id': '174162', 'license': 'MIT', 'n_tokens_mistral': 7350, 'n_tokens_neox': 7175, 'n_words': 1567, 'path': 'R03-extraccion.ipynb', 'repo_name': 'dazulu4/sura-dojo-ml', 'size': '19471'}