<jupyter_start><jupyter_text>Extracción de datos===  Contenido > * [Lectura y escritura de archivos con `open`](Lectura-y-escritura-de-archivos-con-open)* [Lectura de archivos con la Python Standard Library](Lectura-de-archivos-con-la-Python-Standard-Library)   * [Formato nativo de Python usando la PSL](Formato-nativo-de-Python-usando-la-PSL)   * [TXT como formato libre usando la PSL](TXT-como-formato-libre-usando-la-PSL)   * [TXT como tablas de texto delimitado usando la PSL](TXT-como-tablas-de-texto-delimitado-usando-la-PSL)   * [JSON usando la PSL](JSON-usando-la-PSL)* [Lectura y escritura de archivos usando Pandas](Lectura-y-escritura-de-archivos-usando-Pandas)   * [Formato nativo de Python con Pandas](Formato-nativo-de-Python-con-Pandas)   * [Archivos delimitados por caracteres con Pandas](Archivos-delimitados-por-caracteres-con-Pandas)   * [TXT como tabla de texto con Pandas](TXT-como-tabla-de-texto-con-Pandas)   * [Formato de ancho fijo con Pandas](Formato-de-ancho-fijo-con-Pandas)   * [JSON con Pandas](JSON-con-Pandas)   * [HTML con Pandas](HTML-con-Pandas)   * [Excel con Pandas](Excel-con-Pandas)   * [HDF5 con Pandas](HDF5-con-Pandas)   * [STATA con Pandas](STATA-con-Pandas)* [Lectura de PDFs](Lectura-de-PDFs)* [Lectura de Matlab y Octave](Lectura-de-Matlab-y-Octave)  Lectura y escritura de archivos con `open` [Contenido](Contenido) > [`open`](https://docs.python.org/3/tutorial/inputoutput.html) La función `open(` _`filename`_ `,` _`mode`_ `)` permite abrir el archivo llamada _`filename`_; _`mode`_  es una cadena de texto que especifica la forma en que se habre el archivo asi: `'r'` para lectura, `'w'` para escritura (borra el contenido del archivo) y `'a'` para escribir al final (append); adicionalmente, se puede agregar `'b'` para indicar que el archivo se abre en modo binario (por defecto se abre en mdoeo texto). `open` devuelve un objeto que permite manipuar el archivo.<jupyter_code># abre el archivo, escribe y luego lo cierra.
open('out.1', 'w').write('linea 1\nlinea 2\nlinea 3\n') # retorna la cantidad de caracteres escritos
# abre el archivo, lee todo el contenido del archivo y luego lo cierra.
open('out.1', 'r').read()<jupyter_output><empty_output><jupyter_text>En el siguiente ejemplo se ilustra como escribir en un archivo después de abrirlo.<jupyter_code>f = open('out.1', 'w') # abre el archivo para escritura

# impresión de varias lineas en un solo print 
print("linea 1", "linea 2", "linea 3", sep='\n', file=f) 

# impresión de una línea por print
print("linea 4", file=f)   
print("linea 5", file=f)
print("linea 6", file=f)

# impresión usando write
f.write('linea 7')

# cierra el archivo
f.close()
open('out.1', 'r').read()
# impresión con formato del contenido de un archivo.
print(open('out.1', 'r').read())
# forma alternativa para leer el contenido de un archivo línea a línea.
f = open('out.1', 'r')
f.readline() # lee la primera línea.
f.readline() # lee la segunda línea.
f.readline() # lee la tercera línea.
# y así sucesivamente hasta alcanzar el final del archivo
f.close() # cierra el archivo.<jupyter_output><empty_output><jupyter_text>Se almacena un texto en una variable.<jupyter_code>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)<jupyter_output>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]<jupyter_text>Se escribe el contenido de la variable en el archivo.<jupyter_code>## escribe el archivo en disco
open('files/wikipedia.txt', 'w').write(txt)<jupyter_output><empty_output><jupyter_text>**Ejercicio.** Imprima la primera línea del archivo `customers`. En el siguiente ejemplo se ilustra como usar un ciclo `for` para leer el contenido de un archivo.<jupyter_code>f = open('out.1', 'r')
for line in f:
    print(line, end='')
f.close()
# forma alternativa 
with open('out.1', 'r') as f:
    print(f.read(), end='')    # el archivo se cierra al salir del bloque `with`

f.closed # es una función que devuelve `True` cuando el archivo está cerrado.<jupyter_output>linea 1
linea 2
linea 3
linea 4
linea 5
linea 6
linea 7<jupyter_text>En los siguientes ejemplo se leen las líneas del archivo y se almacenan en una lista. Esto permite manipular facilmente el contenido de un archivo a traves de las funciones para manejar listas, tal como se ilustra seguidamente.<jupyter_code>f = open('out.1', 'r')
x = list(f)
f.close()
x  # note que aparece el retorno de carro '\n' al final de cada línea
# se imprimen únicamente las tres primeras líneas del archivo
print(x[0:3])
# mejor
for z in x[0:3]:
    print(z, end = '')
# se imprimen únicamente las tres últimas líneas del archivo
print(x[-3:])
# mejor
for z in x[-3:]:
    print(z, end = '')
# se imprime todo el contenido del archivo, excepto las primeras tres lineas
# mejor
for z in x[3:]:
    print(z, end = '')<jupyter_output>linea 4
linea 5
linea 6
linea 7<jupyter_text>La manipulación de las líneas de un archivo permite hacer operaciones más complejas como concatenar archivos. El comando `cat` en los sistemas Unix permite la impresión de un conjunto de archivos de texto uno después de otro, tal que se puede usar para concaternar archivos. Por ejemplo,```bash      $ cat out.1 out.1      linea 1      linea 2      linea 3      linea 4      liena 5      linea 6      linea 7      linea 1      linea 2      linea 3      linea 4      liena 5      linea 6      linea 7```El siguiente código permite hacer lo mismo.<jupyter_code># abre el archivo 'out.1', lo lee y luego lo cierra
a =  open('out.1').readlines()  

# abre nuevamente el archivo 'out.1', lo lee y luego lo cierra
a += open('out.1').readlines()  

# se crea una nueva lista `z` que contiene las mismas cadenas de 
# caracteres de `a` pero eliminando los retornos de carro '\n' 

z = []
for x in a:
    if x[-1] == '\n':
        z.append(x[:-1])
    else:
        z.append(x) 
    
# se imprime con formato usando un ciclo `for`.
for x in z:
    print(x, end = '\n')<jupyter_output>linea 1
linea 2
linea 3
linea 4
linea 5
linea 6
linea 7
linea 1
linea 2
linea 3
linea 4
linea 5
linea 6
linea 7<jupyter_text>**Ejercicio.** Algunos sistemas Unix tienen el comando `tac` (reverso de `cat`) el cual imprime el contenido de un archivo en inverso, es decir, empezando por la última línea. Implemente esta función en Python. **Ejercicio.** En Unix, el comando `rev` imprime el contenido de un archivo invirtiendo el orden de los caracteres de cada línea. Por ejemplo, si el archivo contiene las lineas `1234` y `abcd`, `rev` imprime `4321` y `dcba`. Implemente esta función en Python. A continuación se presenta como implementar la funcionalidad del comando `wc` de Unix.<jupyter_code># se cuentan las líneas de un archivo
len(open('out.1','r').readlines())
# se cuentan las palabras que tiene un archivo
x = open('out.1','r').readlines()
y = ' '.join(x)
len(y.split(' '))
# se cuentan los caracteres que contiene un archivo
x = open('out.1','r').readlines()
x = ''.join(x)
len(x)<jupyter_output><empty_output><jupyter_text>Una de las principales tareas en ciencia de los datos, es la lectura de tablas de datos para su manipulación posterior. Para generar los datos de prueba se usa el *cellmagic* `%%bash` el cual indica que el contenido de la celda debe ejecutarse en la línea de comandos de Unix.<jupyter_code>%%bash
cat > out.1 <<EOF
Date, Year, CustomerID, Value
2013-01-12, 2013, 1, 100
2014-05-12, 2014, 1, 100
2013-02-25, 2013, 2, 200
2013-04-04, 2013, 1, 100
2013-06-21, 2013, 2, 200
2014-05-18, 2014, 1, 100
2014-06-23, 2014, 2, 200
2013-02-28, 2013, 1, 100
2013-08-02, 2013, 1, 100
EOF<jupyter_output><empty_output><jupyter_text>Seguidamente se carga el archivo (cada línea del archivo es almacenada como un string):<jupyter_code>x = open('out.1','r').readlines()
x<jupyter_output><empty_output><jupyter_text>Se remueven los retornos de carro ('`\n`') usando una *list comprenhension*.<jupyter_code>x = [z.replace('\n', '') for z in x]
x<jupyter_output><empty_output><jupyter_text>Se usan los delimitadores para separar los campos.<jupyter_code>x = [z.split(',') for z in x]
x<jupyter_output><empty_output><jupyter_text>Cada registro es almacenado como una lista. Ahora, por ejemplo, se agregará el campo `Month` extrayendo el mes del campo `Date`. El proceso se realizará incrementalmente para facilitar su visualización.<jupyter_code># extrae el campo Date
[z[0] for z in x[1:]] 
# separa Date en sus partes
[z[0].split('-') for z in x[1:]] 
# el mes ocupa la posicion 1
[z[0].split('-')[1] for z in x[1:]] # el mes<jupyter_output><empty_output><jupyter_text>Pega el mes al final de la lista<jupyter_code>x[1:] = [z+[z[0].split('-')[1]] for z in x[1:]] 
x<jupyter_output><empty_output><jupyter_text>Agrega el nombre del campo y los compoentes<jupyter_code>x[0].append('Month')
x<jupyter_output><empty_output><jupyter_text>También resulta muy simple la aplicación de filtros para seleccionar solo una porción de los datos. Por ejemplo, para obtener únicamente los registros del año 2013:<jupyter_code>[z for z in x if z[1] == ' 2013']<jupyter_output><empty_output><jupyter_text>**Ejercicio.** Imprima un listado de valores únicos para el campo `City` del archivo `files/customer`. **Ejercicio.** Agregue el campo `subtotal` a la tabla `orderline` el cual es calculado como `Quantity` por `Price`. **Ejercicio.** Agregue el campo `ProductName` a la tabla `orderline`. **Ejercicio.** Agregue el campo `Total` a la tabla `order`. Este campo se calcula como la suma de `ProductID` * `Price` para cada `OrderID` en la tabla `orderline`. **Ejercicio.** Escriba una función que implemente la funcionaldad del comando `sort` del `bash`. * Recibe el nombre de un archivo.* Lo lee del disco duro.* Tiene un parámetros que le indica si es orden ascendente o descendente.* Imprime el archivo ordenado en pantalla (podría ser al disco duro si se desea emular toda la funcionalidad de sort). **Ejercicio.** Modifique el programa anterior para poder indicar el número del campo (o campos) a partir de los cuales se realizará el ordenamiento. **Ejercicio.** Escriba una función que implemente la funcionaldad del comando `uniq` del `bash`. * Recibe el nombre de un archivo.* Lo lee del disco duro.* Elimina líneas consecutivas iguales.* Imprime el resultado en la pantalla. **Ejercicio.** Escriba una función que implemente la funcionaldad del comando `join` del `bash`. * Recibe el nombre de dos archivos.* Suponga que la primera columna de cada archivo contiene la clave a partir de la cual se hará el `join`.* Imprima el resultado en pantalla. **Ejercicio.** Escriba una función que implemente la funcionaldad del comando `paste` del `bash`. * Recibe el nombre de dos archivos.* Imprima el resultado en pantalla.  Lectura de archivos con la Python Standard Library [Contenido](Contenido) Se crea una tabla para los realizar los ejemplos.<jupyter_code>## crea la tabla de datos de prueba.
## cada fila es un vector
df = [["index", "name", "value"],
      [1, "A", 3.03],
      [2, "B", 5.14],
      [3, "C", 0.40],
      [4, "D", 1.13],
      [5, "E", 8.25]]
df<jupyter_output><empty_output><jupyter_text>Formato nativo de Python usando la PSL [Contenido](Contenido) > [`pickle`](https://docs.python.org/3/library/pickle.htmlmodule-pickle)<jupyter_code>## carga la librería
import pickle
## salva el objeto en el disco
with open('files/data.pickle', 'wb') as f:
    pickle.dump(obj = df, file = f)
## borra la variable x
del df
whos
## recupera el objeto del disco
with open('files/data.pickle', 'rb') as f:
    df = pickle.load(f)
    
print(df)<jupyter_output>[['index', 'name', 'value'], [1, 'A', 3.03], [2, 'B', 5.14], [3, 'C', 0.4], [4, 'D', 1.13], [5, 'E', 8.25]]<jupyter_text>TXT como formato libre usando la PSL [Contenido](Contenido) > [`open`](https://docs.python.org/3/tutorial/inputoutput.html)<jupyter_code>## lee el archivo de disco
x = open('files/wikipedia.txt', 'r').read()
x
## divide el texto en palabras.
x.split()
## divide el texto en líneas
x.split('\n')
## separa el texto por '.'
x.split('.')<jupyter_output><empty_output><jupyter_text>TXT como tablas de texto delimitado usando la PSL [Contenido](Contenido) > [`csv`](https://docs.python.org/3.5/library/csv.html) En esta sección se aborda la lectura de archivos delimitados por caracteres. Los delimitadores incluyen el espacio en blanco, la coma y el punto y coma. El parámetro `delimiter` permite especificar el caracter delimitador, mientrasq que el parámetro `quoting` permite especificar los delimitadores para los strings.<jupyter_code>## importa la librería
import csv<jupyter_output><empty_output><jupyter_text>**Archivos delimitados por espacios**<jupyter_code>## escribe el archivo en forma de tabla de texto
with open('files/data.txt', 'w') as f:             # abre el archivo para escritura
    x = csv.writer(f,                              # crea el objeto x
                   delimiter=' ',                  # delimitado por ' '
                   quoting=csv.QUOTE_NONNUMERIC)   # sin " " para los strings
    for r in df:
        x.writerow(r)<jupyter_output><empty_output><jupyter_text>Note que los strings están entre comillas.<jupyter_code>## verifica el archivo creado
print(open('files/data.txt', 'r').read())
## Lee el archivo como una tabla de texto
with open('files/data.txt', 'r') as f:  
     x = csv.reader(f, 
                    delimiter=' ', 
                    quoting=csv.QUOTE_NONNUMERIC) 
     for r in x:
        print(r)<jupyter_output>['index', 'name', 'value']
[1.0, 'A', 3.03]
[2.0, 'B', 5.14]
[3.0, 'C', 0.4]
[4.0, 'D', 1.13]
[5.0, 'E', 8.25]<jupyter_text>**Archivos delimitados por comas (CSV)** [Contenido](Contenido) > [`csv`](https://docs.python.org/3.5/library/csv.html)<jupyter_code>with open('files/data.csv', 'w') as f:
    x = csv.writer(f, 
                   delimiter = ',',
                   quoting=csv.QUOTE_NONNUMERIC)
    for r in df:
        x.writerow(r)
    
## verifica el archivo creado
print(open('files/data.csv', 'r').read())
## lee el archivo csv 
with open('files/data.csv', 'r') as f:
     x = csv.reader(f, 
                    delimiter=',', 
                    quoting=csv.QUOTE_NONNUMERIC)
     for r in x:
        print(r)<jupyter_output>['index', 'name', 'value']
[1.0, 'A', 3.03]
[2.0, 'B', 5.14]
[3.0, 'C', 0.4]
[4.0, 'D', 1.13]
[5.0, 'E', 8.25]<jupyter_text>**Ejercicio.** Escriba una función que permita convertir un archivo de formato csv a csv2 (español). **Ejercicio.** Escriba una función que permita leer un archivo `csv` y lo convierta a formato de ancho fijo.  JSON usando la PSL [Contenido](Contenido) > [`json`](https://docs.python.org/3/library/json.htmlmodule-json)<jupyter_code>## importa la libreria
import json

## convierte los datos en string
json.dumps(df)
## mismo caso anterior pero con impresion 'bonita'
json.dumps(df, 
           sort_keys = True, 
           indent = 4)
y = json.dumps(df, 
               sort_keys = True, 
               indent = 4)
print(y)
## convierte el string en datos
json.loads(y)
## convierte los datos en string y
## los guarda en un archivo 
with open('files/data.json', 'w') as f:
    json.dump(obj = df,   # datos 
              fp = f)     # archivo
## recupera los datos desde el archivo
with open('files/data.json', 'r') as f:
    x = json.load(fp = f)
x<jupyter_output><empty_output><jupyter_text>Lectura y escritura de archivos usando Pandas [Contenido](Contenido)<jupyter_code>import pandas

## salida de texto
pandas.set_option('display.notebook_repr_html', False)<jupyter_output><empty_output><jupyter_text>**Datos de ejemplo**.  > [`pandas.DataFrame`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html)<jupyter_code>## crea el DataFrame
## los DataFrame en Pandas son diccionarios
df = pandas.DataFrame( {'index': list(range(1,6)),
                        'name': ['A', 'B', 'C', 'D', 'E'],
                        'value': [3.03, 5.14, 0.40, 1.13, 8.25]})<jupyter_output><empty_output><jupyter_text>Formato nativo de Python con Pandas [Contenido](Contenido) > [`pandas.DataFrame`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html)  [`pandas.DataFrame.to_pickle`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_pickle.html)  [`pandas.to_pickle`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-pickle)  [`pandas.read_pickle`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-pickle)<jupyter_code>## pandas.DataFrame
df.to_pickle('files/data.pickle')
pandas.read_pickle('files/data.pickle')<jupyter_output><empty_output><jupyter_text>Archivos delimitados por caracteres con Pandas [Contenido](Contenido) > [`pandas.DataFrame.to_csv`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_csv.html)  [`pandas.DataFrame.from_csv`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.from_csv.html)  [`pandas.to_csv`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-store-in-csv)  [`pandas.read_csv`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-read-csv-table)<jupyter_code>## escribe el archivo
df.to_csv('files/data.csv',   # el nombre del archivo
          index = False)      # imprime los nombres de las filas?

## verifica el archivo creado
print(open('files/data.csv', 'r').read())
pandas.read_csv('files/data.csv')
## opciones mas importantes
pandas.read_csv('files/data.csv',  # el archivo
                    sep = ',',         # separador de campos
                    thousands = None,  # separador de miles para números
                    decimal = '.')     # separador de los decimales para números<jupyter_output><empty_output><jupyter_text>En español: ';' como separador de campos y ',' como separador decimal.<jupyter_code>## escribe el archivo
df.to_csv('files/data.csv2',     # nombre del archivo
           sep = ';',            # separador de campos
           decimal = ',',        # caracter decimal
           index = False)        # imprime indice de las filas?

## verifica el archivo creado
print(open('files/data.csv2', 'r').read())
## lee el archivo
pandas.read_csv('files/data.csv2',
                 sep = ';',
                 thousands = None,
                 decimal = ',')<jupyter_output><empty_output><jupyter_text>TXT como tabla de texto con Pandas [Contenido](Contenido) > [`pandas.read_table`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_table.htmlpandas.read_table)<jupyter_code>## escribe el archivo
df.to_csv('files/data.txt',     # nombre del archivo
          sep = ' ',            # separador de campos
          decimal = '.',        # caracter decimal
          index = False)        # imprime indice de las filas?

## verifica el archivo creado
print(open('files/data.txt', 'r').read())
# lee el archivo del disco
pandas.read_table('files/data.txt',
                   sep = ' ',
                   decimal = '.',
                   thousands = None)<jupyter_output><empty_output><jupyter_text>Formato de ancho fijo con Pandas [Contenido](Contenido) > [`pandas.read_fwf`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_fwf.html)<jupyter_code># crea un archivo separado por multiples espacios en blanco.
# los nombres de las columnas están separados por comas.
text = """indexnames      valuescodes
    1<NAME>    2.13   10
    2<NAME>    3.14   11
    3<NAME>     4.34   12
    4<NAME>    2.31   13
    5<NAME>    4.98   14"""

with open('files/data.txt', 'w') as f:
    f.write(text)
    
## verifica el archivo creado
print(open('files/data.txt', 'r').read())
pandas.read_fwf('files/data.txt', 
                colspecs = 'infer', 
                widths = [5, 9, 8, 5])<jupyter_output><empty_output><jupyter_text>JSON con Pandas [Contenido](Contenido) > [`pandas.DataFrame.to_json`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_json.html)  [`pandas.to_json`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-json-writer)  [`pandas.read_json`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-json-reader)  > `JSON` en [wikipedia](https://en.wikipedia.org/wiki/JSON)<jupyter_code>## escribe el DataFrame al archivo
df.to_json('files/data.json')

## verifica el archivo creado
print(open('files/data.json', 'r').read())
## lo recupera 
pandas.read_json('files/data.json')<jupyter_output><empty_output><jupyter_text>HTML con Pandas [Contenido](Contenido) > [`pandas.DataFrame.to_html`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_html.html)   [`pandas.to_html`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-html)  [`pandas.read_html`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-read-html)<jupyter_code>## convierte el DataFrame a HTML
df.to_html('files/data.html',
           index = False)

## verifica el archivo creado
print(open('files/data.html', 'r').read())
pandas.read_html('files/data.html')<jupyter_output><empty_output><jupyter_text>Excel con Pandas [Contenido](Contenido) > [`pandas.DataFrame.to_excel`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_excel.html)  [`pandas.to_excel`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-excel-writer)  [`pandas.read_excel`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-excel-reader)<jupyter_code>df.to_excel('files/data.xlsx',
            index = False)
import pandas
pandas.read_excel('files/data.xlsx')<jupyter_output><empty_output><jupyter_text>HDF5 con Pandas [Contenido](Contenido) > [`pandas.DataFrame.to_hdf`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_hdf.html)  [`pandas.to_hdf`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-hdf5)  [`pandas.read_hdf`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-hdf5)<jupyter_code>## escribe el archivo a disco
df.to_hdf('files/data.h5', 
          key = 'G1')
## lectura
pandas.read_hdf('files/data.h5',
                key = 'G1')
pandas.read_hdf('files/data.h5')<jupyter_output><empty_output><jupyter_text>STATA con Pandas [Contenido](Contenido) > [`pandas.DataFrame.to_stata`](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_stata.html)  [`pandas.to_stata`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-stata-writer)  [`pandas.read_stata`](http://pandas.pydata.org/pandas-docs/stable/io.htmlio-stata-reader)<jupyter_code>## escribe el archivo
df.to_stata('files/data.dta')

## lee el archivo
pandas.read_stata('files/data.dta')<jupyter_output><empty_output><jupyter_text>Lectura de PDFs > [`PyPDF2`](https://pythonhosted.org/PyPDF2/)  Instalación:> ```pip install PyPDF2``` [Contenido](Contenido)<jupyter_code>import PyPDF2
pdfFileObj = open('files/wikipedia.pdf', 'rb')
pdfReader = PyPDF2.PdfFileReader(pdfFileObj)
pageObj = pdfReader.getPage(0)
pageObj.extractText()<jupyter_output><empty_output><jupyter_text>Lectura de Matlab y Octave [Contenido](Contenido) > [`sio.loadmat`](http://docs.scipy.org/doc/scipy/reference/tutorial/io.html)   [`sio.savemat`](http://docs.scipy.org/doc/scipy/reference/tutorial/io.html)<jupyter_code>import scipy.io as sio
sio.savemat('files/data', {'df': df})
sio.loadmat('files/data')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13478662634408603, 'fraction_numerical': 0.01797715053763441, 'mean_word_length': 4.193935427574171, 'pattern_counts': {'":': 0, '<': 153, '<?xml version=': 0, '>': 173, 'https://': 8, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '38', 'dir': 'jupyter-structured-clean-dedup', 'id': '53250', 'license': 'MIT', 'n_tokens_mistral': 9129, 'n_tokens_neox': 8873, 'n_words': 2330, 'path': 'P03-extraccion.ipynb', 'repo_name': 'dazulu4/sura-dojo-ml', 'size': '23822'}