8. Entrada y salida¶

8.1. Formateo elegante de la salida¶

Hasta ahora encontramos dos maneras de escribir valores: declaraciones de expresión y la función print(). (Una tercer manera es usando el método write() de los objetos tipo archivo; el archivo de salida estándar puede referenciarse como sys.stdout. Mirá la Referencia de la Biblioteca para más información sobre esto.)

Frecuentemente querrás más control sobre el formateo de tu salida que simplemente imprimir valores separados por espacios. Hay dos maneras de formatear tu salida; la primera es hacer todo el manejo de las cadenas vos mismo: usando rebanado de cadenas y operaciones de concatenado podés crear cualquier forma que puedas imaginar. El tipo string contiene algunos métodos útiles para emparejar cadenas a un determinado ancho; estas las discutiremos en breve. La otra forma es usar formatted string literals o el método str.format().

El módulo string contiene una clase string.Template que ofrece otra forma de sustituir valores en las cadenas.

Nos queda una pregunta, por supuesto: ¿cómo convertís valores a cadenas? Afortunadamente, Python tiene maneras de convertir cualquier valor a una cadena: pasalos a las funciones repr() o str().

La función str() devuelve representaciones de los valores que son bastante legibles por humanos, mientras que repr() genera representaciones que pueden ser leídas por el el intérprete (o forzarían un SyntaxError si no hay sintáxis equivalente). Para objetos que no tienen una representación en particular para consumo humano, str() devolverá el mismo valor que repr(). Muchos valores, como números o estructuras como listas y diccionarios, tienen la misma representación usando cualquiera de las dos funciones. Las cadenas, en particular, tienen dos representaciones distintas.

Algunos ejemplos:

>>> s = 'Hola mundo.'
>>> str(s)
'Hola mundo.'
>>> repr(s)
"'Hola mundo.'"
>>> str(1 / 7)
'0.142857142857'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'El valor de x es ' + repr(x) + ', y es ' + repr(y) + '...'
>>> print(s)
El valor de x es 32.5, y es 40000...
>>> # El repr() de una cadena agrega apóstrofos y barras invertidas
... hola = 'hola mundo\n'
>>> holas = repr(hola)
>>> print(holas)
'hola mundo\n'
>>> # El argumento de repr() puede ser cualquier objeto Python:
... repr((x, y, ('carne', 'huevos')))
"(32.5, 40000, ('carne', 'huevos'))"

Acá hay dos maneras de escribir una tabla de cuadrados y cubos:

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x * x).rjust(3), end=' ')
...     # notar el uso de 'end' en la linea anterior
...     print(repr(x * x * x).rjust(4))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

>>> for x in range(1,11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x * x, x * x * x))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

(Notar que en el primer ejemplo, un espacio entre cada columna fue agregado por la manera en que print() trabaja: siempre agrega espacios entre sus argumentos)

Este ejemplo muestra el método str.rjust() de los objetos cadena, el cual ordena una cadena a la derecha en un campo del ancho dado llenándolo con espacios a la izquierda. Hay métodos similares str.ljust() y str.center(). Estos métodos no escriben nada, sólo devuelven una nueva cadena. Si la cadena de entrada es demasiado larga, no la truncan, sino la devuelven intacta; esto te romperá la alineación de tus columnas pero es normalmente mejor que la alternativa, que te estaría mintiendo sobre el valor. (Si realmente querés que se recorte, siempre podés agregarle una operación de rebanado, como en x.ljust(n)[:n].)

Hay otro método, str.zfill(), el cual rellena una cadena numérica a la izquierda con ceros. Entiende signos positivos y negativos:

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

El uso básico del método str.format() es como esto:

>>> print('Somos los {} quienes decimos "{}!"'.format('caballeros', 'Nop'))
Somos los caballeros quienes decimos "Nop!"

Las llaves y caracteres dentro de las mismas (llamados campos de formato) son reemplazadas con los objetos pasados en el método str.format(). Un número en las llaves se refiere a la posición del objeto pasado en el método.

>>> print('{0} y {1}'.format('carne', 'huevos'))
carne y huevos
>>> print('{1} y {0}'.format('carne', 'huevos'))
huevos y carne

Si se usan argumentos nombrados en el método str.format(), sus valores serán referidos usando el nombre del argumento.

>>> print('Esta {comida} es {adjetivo}.'.format(
...       comida='carne', adjetivo='espantosa'))
Esta carne es espantosa.

Se pueden combinar arbitrariamente argumentos posicionales y nombrados:

>>> print('La historia de {0}, {1}, y {otro}.'.format('Bill', 'Manfred',
...                                                   otro='Georg'))
La historia de Bill, Manfred, y Georg.

Se pueden usar '!a' (aplica apply()), '!s' (aplica str()) y '!r' (aplica repr()) para convertir el valor antes de que se formatee.

>>> contents = 'anguilas'
>>> print('Mi aerodeslizador esta lleno de {}.'.format(contents))
Mi aerodeslizador esta lleno de anguilas.
>>> print('My hovercraft is full of {!r}.'.format(contents))
Mi aerodeslizador esta lleno de 'anguilas'.

Un ': y especificador de formato opcionales pueden ir luego del nombre del campo. Esto aumenta el control sobre cómo el valor es formateado. El siguiente ejemplo redondea Pi a tres lugares luego del punto decimal.

>>> import math
>>> print('El valor de PI es aproximadamente {0:.3f}.'.format(math.pi))
El valor de PI es aproximadamente 3.142.

Pasando un entero luego del ':' causará que que el campo sea de un mínimo número de caracteres de ancho. Esto es útil para hacer tablas lindas.

>>> tabla = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for nombre, telefono in tabla.items():
...     print('{0:10} ==> {1:10d}'.format(nombre, telefono))
...
Dcab       ==>       7678
Jack       ==>       4098
Sjoerd     ==>       4127

Si tenés una cadena de formateo realmente larga que no querés separar, podría ser bueno que puedas hacer referencia a las variables a ser formateadas por el nombre en vez de la posición. Esto puede hacerse simplemente pasando el diccionario y usando corchetes '[]' para acceder a las claves

>>> tabla = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
...       'Dcab: {0[Dcab]:d}'.format(tabla))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Esto se podría también hacer pasando la tabla como argumentos nombrados con la notación ‘**’.

>>> tabla = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; '
          'Dcab: {Dcab:d}'.format(**tabla))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Esto es particularmente útil en combinación con la función integrada vars(), que devuelve un diccionario conteniendo todas las variables locales.

Para una completa descripción del formateo de cadenas con str.format(), mirá en Tipos integrados.

>>> import math
>>> print('El valor de PI es aproximadamente %5.3f.' % math.pi)
El valor de PI es aproximadamente 3.142.

8.2. Leyendo y escribiendo archivos¶

La función open() devuelve un objeto archivo, y se usa normalmente con dos argumentos: open(nombre_de_archivo, modo).

>>> f = open('archivodetrabajo', 'w')
>>> print(f)
<_io.TextIOWrapper name='archivodetrabajo' mode='w' encoding='UTF-8'>

El primer argumento es una cadena conteniendo el nombre de archivo. El segundo argumento es otra cadena conteniendo unos pocos caracteres que describen la forma en que el archivo será usado. El modo puede ser 'r' cuando el archivo será solamente leído, 'w' para sólo escribirlo (un archivo existente con el mismo nombre será borrado), y 'a' abre el archivo para agregarle información; cualquier dato escrito al archivo será automáticamente agregado al final. 'r+' abre el archivo tanto para leerlo como para escribirlo. El argumento modo es opcional; si se omite se asume 'r'.

Normalmente los archivos se abren en modo texto, lo que significa que podés leer y escribir cadenas del y al archivo, las cuales se codifican utilizando un código específico. Si el código no es especificado, el valor predeterminado depende de la plataforma. Si se agrega b al modo el archivo se abre en modo binario: ahora los datos se leen y escriben en forma de objetos bytes. Se debería usar este modo para todos los archivos que no contengan texto.

Cuando se lee en modo texto, por defecto se convierten los fines de lineas que son específicos a las plataformas (\n en Unix, \r\n en Windows) a solamente \n. Cuando se escribe en modo texto, por defecto se convierten los \n a los finales de linea específicos de la plataforma. Este cambio automático está bien para archivos de texto, pero corrompería datos binarios como los de archivos JPEG o EXE. Asegurate de usar modo binario cuando leas y escribas tales archivos.

Es una buena práctica usar la declaración with cuando manejamos objetos archivo. Tiene la ventaja que el archivo es cerrado apropiadamente luego de que el bloque termina, incluso si se generó una excepción. También es mucho más corto que escribir los equivalentes bloques try-finally

>>> with open('archivodetrabajo') as f:
...     datos_leidos = f.read()
>>> f.closed
True

Si no estuvieses usando el bloque with, entonces deberías llamar f.close() para cerrar el archivo e inmediatamente liberar cualquier recurso del sistema usado por este. Si no cierras explícitamente el archivo, el «garbage collector» de Python eventualmente destruirá el objeto y cerrará el archivo por vos, pero el archivo puede estar abierto por un tiempo. Otro riesgo es que diferentes implementaciones de Python harán esta limpieza en diferentes momentos.

Después de que un objeto de archivo es cerrado, ya sea por with o llamando a f.close(), intentar volver a utilizarlo fallará automáticamente:

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file

>>> f.read()
'Este es el archivo entero.\n'
>>> f.read()
''

>>> f.readline()
'Esta es la primer linea del archivo.\n'
>>> f.readline()
'Segunda linea del archivo\n'
>>> f.readline()
''

>>> for linea in f:
...     print(linea, end='')

Esta es la primer linea del archivo
Segunda linea del archivo

>>> f.write('Esto es una prueba\n')
19

>>> valor = ('la respuesta', 42)
>>> s = str(valor)  # Convierte la tupla a string
>>> f.write(s)
18

>>> f = open('archivodetrabajo', 'rb+')
>>> f.write(b'0123456789abcdef')
>>> f.seek(5)     # Va al sexto byte en el archivo
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # Va al tercer byte antes del final
13
>>> f.read(1)
b'd'

>>> import json
>>> json.dumps([1, 'simple', 'lista'])
'[1, "simple", "lista"]'

json.dump(x, f)

x = json.load(x, f)