Entrada/Salida estándar

El módulo sys ofrece tres descriptores de fichero abiertos, habitual de los sistemas POSIX:

sys.stdin: entrada estándar
sys.stdout: salida estándar
sys.stderr: salida de error estándar.

Para leer (de la entrada) o escribir (en las salidas) se utilizan respectivamente los métodos read() y write():



In [1]:

    
import sys
sys.stdin.read()









    Out[1]:





''

La función builtin raw_input() lee de sys.stdin.



In [33]:

    
user_input = raw_input()









    



hola



In [34]:

    
sys.stdout.write("Escribiendo en stdout")
sys.stdout.write(" más")









    



Escribiendo en stdout más

La función print() escribe también sobre stdout:



In [35]:

    
print("escribiendo con print")
print("más")









    



escribiendo con print
más



In [5]:

    
sys.stderr.write("Escribiendo en stderr")









    



Escribiendo en stderr

Ficheros

La estrada/salida de datos a ficheros se realiza principalmente mediante la clase file. Veamos el uso básico.



In [6]:

    
fd = file('tmp/foo', 'w')
fd.write("hello hello\n")
fd.write("una segunda línea\n")
fd.write("y la última")
fd









    Out[6]:





<open file 'tmp/foo', mode 'w' at 0x7f6be112e9c0>



In [7]:

    
fd.close()
fd









    Out[7]:





<closed file 'tmp/foo', mode 'w' at 0x7f6be112e9c0>



In [8]:

    
fd = file('tmp/foo')
fd.closed









    Out[8]:





False

El descriptor POSIX es accesible es accesible con el método fileno().



In [9]:

    
fd.fileno()









    Out[9]:





59



In [10]:

    
fd.mode









    Out[10]:





'r'



In [11]:

    
fd.name









    Out[11]:





'tmp/foo'



In [12]:

    
fd.readline()









    Out[12]:





'hello hello\n'

Obtener la posición del puntero:



In [13]:

    
fd.tell()









    Out[13]:





12



In [14]:

    
fd.readlines()









    Out[14]:





['una segunda l\xc3\xadnea\n', 'y la \xc3\xbaltima']

Mover el puntero al comienzo.



In [15]:

    
fd.seek(0)

El fichero es iterable:



In [16]:

    
for line in fd:
    print(line),









    



hello hello
una segunda línea
y la última

El método read() acepta la cantidad de bytes a leer. Si no se indica lee todo lo posible.



In [17]:

    
fd.seek(0)
fd.read()









    Out[17]:





'hello hello\nuna segunda l\xc3\xadnea\ny la \xc3\xbaltima'



In [18]:

    
fd.seek(0)
fd.read(17)









    Out[18]:





'hello hello\nuna s'

E/S POSIX

El módulo os ofrece funciones a las llamadas al sistema POSIX para manejo de ficheros:



In [19]:

    
import os
fd = os.open('tmp/foo', os.O_RDONLY)
fd









    Out[19]:





60



In [20]:

    
os.read(fd, 20)









    Out[20]:





'hello hello\nuna segu'



In [21]:

    
os.close(fd)

Es posible obtener el descriptor entero de un file con el método fileno(). También es posible crear un objeto file a partir de un descriptor entero con os.fdopen():



In [22]:

    
fd = os.open('tmp/foo', os.O_RDONLY)
os.fdopen(fd)









    Out[22]:





<open file '<fdopen>', mode 'r' at 0x7f6be112eae0>

Buffering

El fichero no entrega inmediatamente los datos al disco. Por defecto, se crea con un buffer. Es posible "volcar" ese buffer explícitamente con el método flush().



In [23]:

    
fd = file('tmp/bar', 'w')
fd.write("some text")



In [24]:

    
!cat tmp/bar



In [25]:

    
fd.flush()



In [26]:

    
!cat tmp/bar









    



some text



In [27]:

    
fd.close()

También es posible definir el tamaño de ese buffer (que puede ser 0):



In [28]:

    
fd = file('tmp/bar', 'w', 0)
fd.write("some text")



In [29]:

    
!cat tmp/bar









    



some text



In [30]:

    
fd.close()

Redirección de la entrada/salida estándar

Se pueden substituir los descritores stdin, stdout y stderr por simple asignación. Esto se puede utilizar por ejemplo para reducir el buffer de stdout.



In [31]:

    
# sys.stdout = os.fdopen(1, 'w', 0)
# sys.stdout.write("hi!")

Memory files

StringIO permite crear objetos que tienen la misma interfaz que file pero que almacenan el contenido en memoria.



In [32]:

    
import StringIO

fd = StringIO.StringIO()
fd.write('foo bar')
fd.write('fuzz')

print(fd.getvalue())

fd.close()









    



foo barfuzz