<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 <!--
29/10
Archivos de texto. 
Operaciones con cadenas de caracteres.
String formaters.
CLASE DE LABORATORIO 
(Gonzalo)
-->
Manejo de strings
Con los strings podemos hacer muchas operaciones
Step1:  String formating
Existen varias formas crear, concatenar e imprimir strings
Step2:  Pero si no queremos imprimir ese último Enter lo que tenemos que hacer es poner una coma al final de la línea
Step3:  ¿Y si lo que quiero es imprimir un número pegado al string?
Step4:  String formating
Pero en algunas ocasiones vamos a tener que crear springs más complejos y agregarle una coma no va a ser suficiente, o tal vez queremos crearlos pero no para imprimirlos, por lo que no podríamos usar la función print. <br>
En esos casos, podemos usar la función format
Step5:  Format lo que hace es reemplazar las llaves con los parámetros que le pasen
Step6:  Aunque en realidad los números no son obligatorios
Step7:  Pero la ventaja de usar los números es que podemos imprimir ese parámetro varias veces, y no necesariamente en el órden que figura
Step8:  Incluso, se pueden usar parámetros nombrados
Step9:  Incluso, si en lugar de pasarle cada uno de los parámetros le pasamos un diccionario usando el operador **
Step10:  Incluso, si lo que le pasamos es una lista, podemos acceder a una posición en particular
Step11:  Incluso puedo alinear el texto que pongo usando los dos puntos (
Step12:  Pueden ver más ejemplos en la documentación oficial de Python<br>
También se puese usar el signo % para construir un string, aunque no suele quedar tan claro el código
Step13:  Y también podemos separar y combinar strings
Step14:  Unicodes
Los strings ocupan 1 byte en memoria, por lo que sólo se pueden representar 256 caractéres distintos; pero, si queremos representar los caracteres de todos los idiomas, 255 caracteres no son suficientes. Debido a esto, es que surgieron distintas codificaciones de los archivos, como pueden latin-1 (iso-8859-1), utf-8, etc.<br>
Y si bien en un principio esto fue una solución, la verdad es que con el tiempo trajo mucho problemas por no saber cómo interpretar cada letra. <br> 
Para solucionar este problema es que Python introdujo en la versión 2.0 los caracteres de tipo unicode que pasaron a ocupar 2 bytes, por lo que ahora se pueden representar 65.536 todos los caracteres necesarios. <br>
En Python 3 todos los strings pasaron a ser del tipo Unicode.
Persistencia de datos
Pero todo lo que vimos por el momento se guarda en memoria dinámica, por lo que al apagar la computadora, o simplemente con cerrar el programa y volver a abrirlo perdimos todos los datos que nos teníamos. La alternativa para esto siguen siendo los archivos. 
Apertura de archivos
Al igual que en C, en Python en el mismo momento que abrimos el archivo, se lo asignamos a uno físico y elegimos el modo de apertura, que si no le indicamos nada, tomará por defecto el de lectura. <br>
El modo de apertura puede ser cualquier combinación de
Step15:  La única condición que tenemos para usar este método es que el archivo lo hayamos abierto en modo lectura.
Step16:  Otra primitiva que podemos usar es readline, que al igual que read, también puede recibir un parámetro que indique la cantidad máxima de bytes a leer. Si no se le pasa ningún parámetro, lee toda la línea.
Step17:  Pero no es necesario que leamos de a una sola línea, sino que también podemos leer todas las líneas del archivo y guardarlas en una lista haciendo uso de la primitiva readlines.
Step18:  Sin embargo, la forma más Pythonic de leer el archivo por líneas es usando la estructura for y quedaría casi como lo diríamos en castellano
Step19:  Escritura de archivos
Para escribir en un archivo podemos usar las las primitivas write(string) y writelines(lista_strings), que la primera es para escribir una cadena de caracteres y la segunda para escribir una lista de strings, uno a continuación del otro. Es importante destacar que en ningún caso se escribe algún carácter que no figure en los strings, como por ejemplo, caracteres de fin de línea. <br>
El uso de writelines es equivalente a recorrer la lista y hacerle un write a cada elemento. <br>
Pero el costo de escribir algo en el disco es mucho mayor a escribirlo en memoria por lo que, al igual que en C, se usa un buffer, que no es más que una porción de memoria para ir guardando en forma temporal los datos y cuando alcanzan un tamaño considerable se lo manda a escribir al disco. Otra forma de asegurarse que se haga la escritura es usando la primitiva flush, la cual guarda en el disco el contenido del buffer y lo vacía. <br>
Step20:  ¿Y qué pasa si le quiero agregar algunas líneas a este archivo?
Step21:  Otra forma de asegurarse que se escriba lo que hay en el disco es cerrándolo.
Moverse en un archivo
Al igual que en los archivos binarios de Pascal, en Python también podemos saltar a distintas posiciones mediante la primitiva seek(pos) la cual recibe, como mínimo un parámetro que indica la posición a la que nos queremos mover. Opcionalmente puede recibir un segundo parámetro
Step22:  Y así como podemos movernos en un archivo, también podemos averiguar nuestra posición usando la primitiva tell().
Step23:  ¿Cómo recorrer todo un archivo?
Cuando llegamos al final de un archivo de texto usando la función read o readline Python no arroja ningún valor, pero tampoco retorna ningún caracter, por lo que podríamos usar eso como condición de corte
Step24:  Como pueden ver, todas las líneas hasta la 22 (que es la última linea del arhcivo) tienen una longitud mayor a 0; incluso las 5, 10 y 19 que aparentemente no tienen ningún caracter. Eso es así ya que siempre tienen por lo menos uno, que es el Enter o \n. <br>
Otra cosa a tener en cuenta es que, por más que intentamos leer más allá del fin de archivo, en ningún momento el interprete nos lanzó una excepción. <br>
Por lo tanto, si no sabemos la longitud del archivo como era este caso, podríamos usar esta información para darnos cuenta cuándo dejar de leer
Step25:  Aunque Python también nos ofrece otra forma de recorer un archivo, y es usando una de las estructuras que ya conocemos
Step26:  O, incluso, usar enumerate para saber qué línea estoy leyendo
<ASSISTANT_TASK:>
Python Code:
cadena_caracteres = "Hola mundo"
print dir(cadena_caracteres)
Explanation: <!--
29/10
Archivos de texto. 
Operaciones con cadenas de caracteres.
String formaters.
CLASE DE LABORATORIO 
(Gonzalo)
-->
Manejo de strings
Con los strings podemos hacer muchas operaciones:
End of explanation
print 'Hola mundo'
print 'Pero el print también imprime un Enter al terminar la línea'
Explanation: String formating
Existen varias formas crear, concatenar e imprimir strings:
¿Cómo imprimir un string?
Para imprimir un string sólo es necesario usar la palabra print:
End of explanation
print 'Pero al imprimir con la coma al final',
print 'cambia el enter por un espacio'
print 'También puedo escribir lo mismo' ' en dos partes'
print 'Lo que puedo usar ' \
    'cuando un string es muy largo' \
    'si le agrego una contrabarra'
Explanation: Pero si no queremos imprimir ese último Enter lo que tenemos que hacer es poner una coma al final de la línea:
End of explanation
print 'Entonces tengo que ponerlo después de la coma:', 5
print 'Al que también le agrega la coma para separarlo'
print 'También puedo ponerlo en el medio:\nHoy es', 29, 'de Octubre' 
Explanation: ¿Y si lo que quiero es imprimir un número pegado al string?
End of explanation
print str.format.__doc__
Explanation: String formating
Pero en algunas ocasiones vamos a tener que crear springs más complejos y agregarle una coma no va a ser suficiente, o tal vez queremos crearlos pero no para imprimirlos, por lo que no podríamos usar la función print. <br>
En esos casos, podemos usar la función format
End of explanation
print 'El nombre del jugador número {0} es {1}'.format(10, 'Lionel Messi')
Explanation: Format lo que hace es reemplazar las llaves con los parámetros que le pasen:
End of explanation
print 'El nombre del jugador número {} es {}'.format(10, 'Lionel Messi')
Explanation: Aunque en realidad los números no son obligatorios:
End of explanation
print '{0}{1}{0}'.format('abra', 'cad') 
Explanation: Pero la ventaja de usar los números es que podemos imprimir ese parámetro varias veces, y no necesariamente en el órden que figura:
End of explanation
print 'La nota del alumno {padron} - {nombre} es un {nota}.'. \
    format(padron=123, nombre='Carlos Sanchez', nota=8)
Explanation: Incluso, se pueden usar parámetros nombrados:
End of explanation
alumno = {
    'padron': 123,
    'nombre': 'Carlos Sanchez',
    'nota': 8
}
print 'La nota del alumno {padron} - {nombre} es un {nota}.'.\
    format(**alumno)
Explanation: Incluso, si en lugar de pasarle cada uno de los parámetros le pasamos un diccionario usando el operador **
End of explanation
alumno = {
    'padron': 123,
    'nombre': 'Carlos Sanchez',
    'tps': [8, 9] 
}
print 'La nota de los tps de {nombre} son {tps[0]} y {tps[1]}.'.\
    format(**alumno)
Explanation: Incluso, si lo que le pasamos es una lista, podemos acceder a una posición en particular:
End of explanation
print 'Imprimo un texto alineado a la |{:<20}| de 20 posiciones'.format(
        'izquierda')
print 'Imprimo un texto alineado a la |{:>20}| de 20 posiciones'.format(
        'derecha')
print 'Imprimo un texto |{:^20}| de 20 posiciones'.format('centrado')
print 'Relleno |{:#<20}| con #'.format('izquierda')
print 'Relleno |{:#>20}| con #'.format('derecha')
print 'Relleno |{:#^20}| con #'.format('centrado')
Explanation: Incluso puedo alinear el texto que pongo usando los dos puntos (:)
End of explanation
cadena_caracteres = 'Hola mundo'
print '"{0}" cambia a "{1}" con title'.format(cadena_caracteres, cadena_caracteres.title())
print '"{0}" cambia a "{1}" con lower'.format(cadena_caracteres, cadena_caracteres.lower())
print '"{0}" cambia a "{1} con upper"'.format(cadena_caracteres, cadena_caracteres.upper())
print '"{0}" cambia a "{1}" con capitalize'.format(cadena_caracteres, cadena_caracteres.capitalize())
print '"{0}" cambia a "{1}" cuando reemplazamos las o por 0'.format(cadena_caracteres, cadena_caracteres.replace('o', '0'))
x = 'mi string'
y = x.replace('i', 'AA')
print x, y
print id(x)
x += 'Hola mundo'
print id(x)
Explanation: Pueden ver más ejemplos en la documentación oficial de Python<br>
También se puese usar el signo % para construir un string, aunque no suele quedar tan claro el código:
Funciones de los strings
También existen varias funciones que podemos usar cuando trabajamos con strings:
End of explanation
print "Hola mundo".split()
print "Hola mundo".split('o')
print "Hola mundo".split('mu')
print ''.join(['Hola', 'mundo'])
print ' '.join(['Hola', 'mundo'])
var = '#separador#'.join(['Hola', 'mundo'])
print var
padron, nombre, nota = '12321,nom bekr,4'.split(',')
Explanation: Y también podemos separar y combinar strings:
End of explanation
arch = open("ejemplo.txt")
cadena = arch.read(15)
print "# Imprimo los primeros 15 caracteres del archivo. Tiene que ser 'Python was crea'"
print cadena
print "# Leo otros 7 caracteres y dejo el cursor del archivo en la siguiente posición. Tiene que ser 'ted in '"
cadena = arch.read(7)
print cadena
print "# Ahora leo el resto del archivo."
cadena = arch.read()
print cadena
print '# Cierro el archivo'
arch.close()
Explanation: Unicodes
Los strings ocupan 1 byte en memoria, por lo que sólo se pueden representar 256 caractéres distintos; pero, si queremos representar los caracteres de todos los idiomas, 255 caracteres no son suficientes. Debido a esto, es que surgieron distintas codificaciones de los archivos, como pueden latin-1 (iso-8859-1), utf-8, etc.<br>
Y si bien en un principio esto fue una solución, la verdad es que con el tiempo trajo mucho problemas por no saber cómo interpretar cada letra. <br> 
Para solucionar este problema es que Python introdujo en la versión 2.0 los caracteres de tipo unicode que pasaron a ocupar 2 bytes, por lo que ahora se pueden representar 65.536 todos los caracteres necesarios. <br>
En Python 3 todos los strings pasaron a ser del tipo Unicode.
Persistencia de datos
Pero todo lo que vimos por el momento se guarda en memoria dinámica, por lo que al apagar la computadora, o simplemente con cerrar el programa y volver a abrirlo perdimos todos los datos que nos teníamos. La alternativa para esto siguen siendo los archivos. 
Apertura de archivos
Al igual que en C, en Python en el mismo momento que abrimos el archivo, se lo asignamos a uno físico y elegimos el modo de apertura, que si no le indicamos nada, tomará por defecto el de lectura. <br>
El modo de apertura puede ser cualquier combinación de:
'r' Lectura: el archivo debe existir. Similar al reset de Pascal.
'w' Escritura: no es necesario que el archivo exista, pero si existe lo sobre escribe. Similar al rewrite de Pascal. 
'a' Append: Solo agrega al final y no es necesario que el archivo exista. Similar al append de Pascal.
't' Texto: Archivo de texto
'b' Binario: Archivo binario
'+' *Permite lectura y escrituras simultáneas
La primitiva del lenguaje para abrir y asignar un archivo es open, la cual puede recibir uno o dos parámetros. El primero es obligatorio, y corresponde a la ubicación relativa o absoluta del archivo físico. El segundo parámetro indica el modo de apertura y es opcional. Si no se lo pasamos asumirá que lo queremos abrir en modo Lectura. <br>
Supongamos que estamos usando el intérprete en un escenario en el que solo tenemos un archivo que se llama f2.txt y queremos trabajar con los archivos f1.txt y f2.txt. <br>
```Python
Lanza una excepción de IOError por no existir el archivo e
intentar abrirlo en modo lectura.
file1 = open("f1.txt")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IOError: [Errno 2] No such file or directory: 'f1.txt'
Intento abrir el archivo f1.txt, pero en modo escritura,
por lo crea y no falla. Si hubiera existido, lo hubiera
truncado y creado vacío.
file1 = open("f1.txt", "w")
Abro el archivo f2.txt en modo lectura sin problemas, ya
que éste si existe.
file2 = open("f2.txt")
```
Cerrar un archivo
Para cerrar un archivo solo tenemos que indicarlo poniendo la variable seguida de un punto y la primitiva close. La única restricción es que la variable sea de tipo archivo, si cerramos un archivo cerrado este sigue cerrado; y si cerramos uno abierto, el mismo cambia de estado.
```Python
file2 = open("f2.txt")  # Abro el archivo en modo lectura
file2.close()  # Cierro el archivo
```
Lectura de archivos
Supongamos que tenemos un archivo llamado ejemplo.txt y tiene el siguiente texto:
Python was created in the early 1990s by Guido van Rossum at Stichting
Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
as a successor of a language called ABC.  Guido remains Python's
principal author, although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for
National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
in Reston, Virginia where he released several versions of the
software.
In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
year, the PythonLabs team moved to Digital Creations (now Zope
Corporation, see http://www.zope.com).  In 2001, the Python Software
Foundation (PSF, see http://www.python.org/psf/) was formed, a
non-profit organization created specifically to own Python-related
Intellectual Property.  Zope Corporation is a sponsoring member of
the PSF.
All Python releases are Open Source (see http://www.opensource.org for
the Open Source Definition).  Historically, most, but not all, Python
releases have also been GPL-compatible.
Para leer un archivo podemos usar la primitiva read, la cual puede recibir un parámetro que indique la cantidad de caracteres a leer. Si no se pasa ese parámetro el intérprete leerá todo el archivo y lo retornará.
End of explanation
arch2 = open("ejemplo2.txt", "w")
arch2.read()
# Y si intentamos con un append?
arch3 = open("ejemplo1.txt", "a")
arch3.read()
Explanation: La única condición que tenemos para usar este método es que el archivo lo hayamos abierto en modo lectura.
End of explanation
arch = open("ejemplo.txt")
linea = arch.readline()  # Notar que también imprime el Enter o \n
print linea
linea = arch.readline(7)  # La segunda línea es 'Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands'
print linea
arch.close()
Explanation: Otra primitiva que podemos usar es readline, que al igual que read, también puede recibir un parámetro que indique la cantidad máxima de bytes a leer. Si no se le pasa ningún parámetro, lee toda la línea.
End of explanation
arch = open("ejemplo.txt")
lineas = arch.readlines()
print lineas
arch.close()
Explanation: Pero no es necesario que leamos de a una sola línea, sino que también podemos leer todas las líneas del archivo y guardarlas en una lista haciendo uso de la primitiva readlines.
End of explanation
arch = open("ejemplo.txt")
for linea in arch:
    print len(linea)
arch.close()
Explanation: Sin embargo, la forma más Pythonic de leer el archivo por líneas es usando la estructura for y quedaría casi como lo diríamos en castellano: "Para cada línea del archivo. <br>
Por ejemplo, si queremos imprimir la cantidad de caracteres de cada línea podríamos hacer:
End of explanation
arch2 = open("ejemplo2.txt", "w")
arch2.write("Es la primer cadena")
arch2.write("Seguida de la segunda con un fin de linea\n")
arch2.writelines(["1. Primero de la lista sin fin de línea. ", "2. Segundo string con fin de línea.\n", "3. Tercero con\\n.\n", "4. y último."])
arch2.flush()
arch2.close()
arch2 = open("ejemplo2.txt", "r+a")
strfile = arch2.read()
print strfile
Explanation: Escritura de archivos
Para escribir en un archivo podemos usar las las primitivas write(string) y writelines(lista_strings), que la primera es para escribir una cadena de caracteres y la segunda para escribir una lista de strings, uno a continuación del otro. Es importante destacar que en ningún caso se escribe algún carácter que no figure en los strings, como por ejemplo, caracteres de fin de línea. <br>
El uso de writelines es equivalente a recorrer la lista y hacerle un write a cada elemento. <br>
Pero el costo de escribir algo en el disco es mucho mayor a escribirlo en memoria por lo que, al igual que en C, se usa un buffer, que no es más que una porción de memoria para ir guardando en forma temporal los datos y cuando alcanzan un tamaño considerable se lo manda a escribir al disco. Otra forma de asegurarse que se haga la escritura es usando la primitiva flush, la cual guarda en el disco el contenido del buffer y lo vacía. <br>
End of explanation
arch2.write("Esto lo estoy agregando.\n.")
arch2.writelines("Y estas dos líneas también con un \\n al final\n de cada una.\n")
arch2.flush()
arch2 = open("ejemplo2.txt", "r")  # El open hace que me mueva a la primer posición del archivo.
print arch2.read()
arch2.close()
Explanation: ¿Y qué pasa si le quiero agregar algunas líneas a este archivo?
End of explanation
arch = open("ejemplo.txt")  
arch.seek(30)        # Voy a la posición número 30 del archivo
print arch.read(7)   # Debería salir 'y 1990s'
arch.seek(-5,1)      # Me muevo 5 posiciones para atrás desde mi posición actual.
print arch.read(7)   # Debería imprimir '1990s b'
arch.seek(-12,2)     # Me muevo a la posición número 12, comenzando a contar desde el final.
print arch.read(10)  # Debería imprimir 'compatible'
arch.close()
Explanation: Otra forma de asegurarse que se escriba lo que hay en el disco es cerrándolo.
Moverse en un archivo
Al igual que en los archivos binarios de Pascal, en Python también podemos saltar a distintas posiciones mediante la primitiva seek(pos) la cual recibe, como mínimo un parámetro que indica la posición a la que nos queremos mover. Opcionalmente puede recibir un segundo parámetro:
* 0: La posición es desde el inicio del archivo y debe ser mayor o igual a 0
* 1: La posición es relativa a la posición actual; puede ser positiva o negativa
* 2: La posición es desde el final del archivo, por lo que debe ser negativa
End of explanation
arch = open("ejemplo.txt")  
arch.seek(30)
print arch.tell()    # Debería imprimir 30
arch.seek(-5,1)      # Retrocedo 5 posiciones
print arch.tell()    # Debería imprimir 25
arch.seek(-12,2)     # Voy a 12 posiciones antes del fin de archivo
print arch.tell()    # Debería imprimir 1132
print arch.read(10)  # Leo 10 caracteres
print arch.tell()    # Debería imprimir 1142
Explanation: Y así como podemos movernos en un archivo, también podemos averiguar nuestra posición usando la primitiva tell().
End of explanation
arch = open("ejemplo.txt")  
# El archivo ejemplo.txt tiene 22 líneas, por lo que
# si quiero imprimirlo completo anteponiendo el 
# número de línea y la cantidad de caracteres
# puedo hacer:
for x in range(1, 25):
    linea = arch.readline()
    print '{:2}[{:02}] - {}'.format(x, len(linea), linea)
arch.close()
Explanation: ¿Cómo recorrer todo un archivo?
Cuando llegamos al final de un archivo de texto usando la función read o readline Python no arroja ningún valor, pero tampoco retorna ningún caracter, por lo que podríamos usar eso como condición de corte:
End of explanation
arch = open("ejemplo.txt")  
# Si no sabemos la cantidad de líneas que tiene 
# el archivo que queremos recorrer podemos hacer:
linea = arch.readline()
x = 0
while linea:  # Es decir, mientras me devuelva algo 
              # distinto al sting vacío
    x += 1
    print '{:2}[{:02}] - {}'.format(x, len(linea), linea)
    linea = arch.readline()
arch.close()
Explanation: Como pueden ver, todas las líneas hasta la 22 (que es la última linea del arhcivo) tienen una longitud mayor a 0; incluso las 5, 10 y 19 que aparentemente no tienen ningún caracter. Eso es así ya que siempre tienen por lo menos uno, que es el Enter o \n. <br>
Otra cosa a tener en cuenta es que, por más que intentamos leer más allá del fin de archivo, en ningún momento el interprete nos lanzó una excepción. <br>
Por lo tanto, si no sabemos la longitud del archivo como era este caso, podríamos usar esta información para darnos cuenta cuándo dejar de leer:
End of explanation
arch = open("ejemplo.txt")  
# Si no sabemos la cantidad de líneas que tiene 
# el archivo que queremos recorrer podemos hacer:
x = 0
for linea in arch:
    x += 1
    print '{:2}[{:02}] - {}'.format(x, len(linea), linea)
arch.close()
Explanation: Aunque Python también nos ofrece otra forma de recorer un archivo, y es usando una de las estructuras que ya conocemos: for
End of explanation
arch = open("ejemplo.txt")  
# Si no sabemos la cantidad de líneas que tiene 
# el archivo que queremos recorrer podemos hacer:
# Usando enumerate y comenzando en 1
for x, linea in enumerate(arch, 1):
    print '{:2}[{:02}] - {}'.format(x, len(linea), linea)
arch.close()
Explanation: O, incluso, usar enumerate para saber qué línea estoy leyendo:
End of explanation
<END_TASK>