# Gestión de Archivos: Persistencia y Manipulación de Datos

## 🎯 Introducción: La Necesidad de Persistencia

En el mundo de la computación, los programas operan con datos. Mientras un programa

se ejecuta, estos datos residen en la memoria principal (RAM), que es volátil: su
contenido se pierde cuando el programa termina o el sistema se apaga. Pero, ¿qué
sucede si necesitamos que nuestros datos sobrevivan más allá de la ejecución de un
programa? ¿O si queremos compartir información entre diferentes programas, usuarios
o incluso a lo largo del tiempo?

🧠 **Concepto Clave: Persistencia de Datos**

La **persistencia** se refiere a la capacidad de los datos de sobrevivir al proceso
que los creó. Logramos la persistencia almacenando los datos en un medio **no
volátil**, como un disco duro, SSD o una unidad USB. Estas estructuras de datos
persistentes se conocen genéricamente como **archivos**.

**¿Por qué son cruciales los archivos?**

1. **Almacenamiento a Largo Plazo:** Guardan información (documentos,
configuraciones, bases de datos, resultados de cálculos) de forma duradera.
2. **Intercambio de Información:** Permiten que diferentes programas, usuarios y
sistemas accedan y compartan los mismos datos.
3. **Entrada/Salida de Programas:** Los programas pueden leer datos de entrada
desde archivos y escribir sus resultados en archivos.

🔗 **Conexión: Arquitectura Von Neumann y el Flujo de Datos**

Recordemos la arquitectura Von Neumann: la CPU procesa datos que residen en la
Memoria Interna (MI o RAM).
* Para que los datos de un archivo puedan ser **procesados**, primero deben ser
leídos del dispositivo de almacenamiento (disco) y cargados en la MI.
* Para **guardar** resultados o datos modificados de forma persistente, deben ser
transferidos desde la MI de vuelta al archivo en el disco.

Este flujo es fundamental: **no hay procesamiento directo sobre el disco; todo pasa
por la MI.**

## 🌉 El Puente entre el Programa y el Disco: Buffers y el Sistema Operativo

Copiar un archivo entero a la MI, especialmente si es grande, puede ser ineficiente

o incluso imposible si el archivo supera la capacidad de la RAM.

🧠 **Concepto Clave: Buffers**

Un **buffer** (o memoria intermedia) es una pequeña porción de la MI que el Sistema
Operativo (SO) reserva temporalmente para transferir datos entre un dispositivo de
almacenamiento (como el disco donde reside el archivo) y el programa.

**¿Por qué usar buffers? La eficiencia es la clave.**

1. **Transferencia por Partes:** En lugar de cargar todo el archivo de golpe, los
datos se mueven en fragmentos (bloques) hacia o desde el buffer. A medida que el
programa necesita más datos, se carga el siguiente bloque. A medida que el programa
genera datos para guardar, se acumulan en el buffer y luego se escriben al disco.
2. ⚙️ **Operaciones de E/S en Bloque:** El SO gestiona estas transferencias. Leer
o escribir un bloque grande de datos de una vez es mucho más eficiente que realizar
múltiples operaciones pequeñas para cada byte individual. Esto se debe a que cada
operación de E/S con el disco tiene una latencia (un tiempo de preparación).
Agrupar datos reduce el número total de estas costosas operaciones.
* *Analogía:* Imagina mover una pila de libros. Es más rápido llevar varios
libros a la vez (un bloque) que llevarlos uno por uno.
3. **Localidad de Referencia:** A menudo, si un programa accede a un dato, es
probable que pronto acceda a datos cercanos. Cargar un bloque que contiene el dato
solicitado y sus vecinos anticipa estas necesidades (localidad espacial).

**Idea Visual: Flujo de Datos con Buffers**

Use code with caution.
Markdown
+-------------------+ Lee/Escribe +---------------------+ Lee/Escribe en Bloques
+---------------------+
| Programa | <-----------------> | Buffer (en RAM) | <-----------------------------
> | Archivo (en Disco) |
| (Variables en MI) | | (Gestionado por SO) | | (Datos Persistentes)|
+-------------------+ +---------------------+ +---------------------+

* Cuando el programa pide leer datos, el SO puede traer un bloque entero del
archivo al buffer. El programa luego consume datos del buffer.
* Cuando el programa escribe datos, estos pueden ir primero al buffer. El SO los
escribirá al disco cuando el buffer se llene, se cierre el archivo, o
explícitamente se le indique (flush).

## Operaciones Fundamentales con Archivos en Python

Python, como la mayoría de los lenguajes, proporciona funciones integradas para

interactuar con archivos.

### 1. Abrir un Archivo: `open()`

💡 **Intuición:** Antes de poder leer o escribir en un archivo, necesitamos

"abrirlo". Esta operación es como establecer un canal de comunicación entre tu
programa y el archivo en el disco, gestionado a través del SO y su sistema de
buffers.

⚙️ **Sintaxis y Funcionamiento:**
La función `open()` es el punto de partida.

```python
archivo_alias = open('nombre_del_archivo.ext', 'modo')
Use code with caution.
'nombre_del_archivo.ext' (String):

Es el nombre (y extensión, si la tiene) del archivo que queremos abrir.

Puede ser un path relativo (ej., '[Link]', asume que el archivo está en el mismo
directorio que el script) o un path absoluto (ej.,
'/home/usuario/documentos/[Link]' o 'C:\\Usuarios\\TuUsuario\\Documentos\\
[Link]').

🧠 Por qué un string: El nombre del archivo es la forma en que los humanos y el SO
identifican el recurso en el sistema de archivos.

'modo' (String):

Especifica la intención con la que abrimos el archivo: ¿vamos a leer, escribir,

añadir, o una combinación? Esto determina qué operaciones son permitidas y cómo se
comporta el archivo al abrirse (ej., si se borra su contenido). Lo veremos en
detalle más adelante.

Si se omite, el modo por defecto es 'r' (lectura).

archivo_alias (Objeto Archivo / File Handler):

Si open() tiene éxito, devuelve un objeto archivo (también llamado manejador de

archivo o file handler). Este objeto es nuestra "llave" o "referencia" para
interactuar con el archivo abierto (leer, escribir, etc.) dentro del programa.

Internamente, este objeto está asociado con el buffer que el SO ha asignado para
este archivo.

🧠 Por qué un alias: Un programa puede trabajar con múltiples archivos

simultáneamente. Cada alias permite referenciar unívocamente a cada archivo abierto
y su buffer asociado.

💻 Ejemplo Básico:

# Abrir un archivo llamado "mi_documento.txt" en modo lectura

try:
manejador_archivo = open("mi_documento.txt", "r")
# ... aquí irían las operaciones de lectura ...
print("Archivo abierto exitosamente.")
except FileNotFoundError:
print("Error: El archivo no fue encontrado.")
# Es crucial cerrar el archivo después de usarlo
finally:
if 'manejador_archivo' in locals() and not manejador_archivo.closed:
manejador_archivo.close()
print("Archivo cerrado.")
Use code with caution.
Python
Nota: El ejemplo incluye manejo básico de errores (FileNotFoundError) y la
importantísima operación de cierre, que veremos a continuación.

2. Cerrar un Archivo: close()

💡 Importancia Crítica: Una vez que hemos terminado de trabajar con un archivo, es
esencial cerrarlo usando el método close() del objeto archivo.

manejador_archivo.close()
Use code with caution.
Python
¿Por qué es tan importante cerrar un archivo?

Liberar Recursos del SO: Cada archivo abierto consume recursos del sistema
(descriptores de archivo, memoria para buffers). Cerrar el archivo libera estos
recursos para que otros programas o partes de tu programa los puedan usar. Existe
un límite en la cantidad de archivos que un proceso puede tener abiertos
simultáneamente.

⚙️ Asegurar la Escritura Completa (Flushing): Cuando escribes datos en un archivo,

estos a menudo se almacenan primero en un buffer en memoria (por eficiencia). El SO
decide cuándo "volcar" (flush) estos datos del buffer al disco.

La operación close() fuerza a que cualquier dato pendiente en el buffer se escriba

físicamente al disco.

⚠️ Advertencia: Si tu programa termina (normal o anormalmente) sin cerrar un

archivo en el que estabas escribiendo, los últimos datos podrían perderse porque
nunca salieron del buffer.

Permitir Acceso a Otros: En algunos sistemas operativos o con ciertos tipos de

archivos, un archivo abierto en modo escritura puede bloquear el acceso de otros
programas. Cerrarlo lo libera.

3. Gestión Automática de Recursos: with open(...) as ...:

Olvidar cerrar un archivo es un error común. Python ofrece una construcción más
elegante y segura para manejar archivos, asegurando que se cierren automáticamente,
incluso si ocurren errores: el manejador de contexto with.

💡 Ventaja Principal: Garantiza que el método close() se llame automáticamente al

salir del bloque with, sin importar cómo se salga (normalmente o por una
excepción).

⚙️ Sintaxis:

with open('nombre_del_archivo.ext', 'modo') as archivo_alias:

# Código para trabajar con archivo_alias
# (leer, escribir, etc.)
# No necesitas llamar a archivo_alias.close() explícitamente.
# Al salir de este bloque, el archivo se cierra automáticamente.
Use code with caution.
Python
💻 Ejemplo Comparativo:

# Forma tradicional (requiere close() explícito y a menudo try/finally)

try:
f = open("[Link]", "w")
[Link]("Hola, mundo!")
except IOError:
print("Ocurrió un error de E/S.")
finally:
if 'f' in locals() and not [Link]:
[Link]()

# Forma recomendada con 'with'

try:
with open("[Link]", "w") as f:
[Link]("Hola, mundo con with!")
# [Link]() se llama automáticamente aquí
except IOError:
print("Ocurrió un error de E/S.")
Use code with caution.
Python
✅ Práctica Recomendada: Siempre que sea posible, utiliza la declaración with para
trabajar con archivos. Es más conciso, menos propenso a errores y maneja el cierre
de recursos de forma robusta.

📜 Modos de Apertura: Definiendo la Interacción

El parámetro modo en la función open() es crucial porque define:

Qué operaciones puedes realizar (leer, escribir, ambas).

Qué sucede si el archivo no existe (¿se crea o da error?).

Qué sucede si el archivo ya existe (¿se sobrescribe, se añaden datos, o da error?).

Dónde se posiciona inicialmente el "puntero" o "cursor" del archivo.

Imagina un cursor en un editor de texto; el puntero del archivo es similar,

indicando la posición para la próxima operación de lectura o escritura.
⚖️ Tabla Comparativa de Modos Comunes:

Modo Descripción ¿Lee? ¿Escribe? ¿Crea si no existe? ¿Trunca (borra

contenido) si existe? Posición Inicial del Puntero
'r' Lectura (Read) ✅ ❌ ❌ ❌ Inicio
'w' Escritura (Write) ❌ ✅ ✅ ✅ Inicio
'a' Añadir/Anexar (Append) ❌ ✅ ✅ ❌ Final
'r+' Lectura y Escritura ✅ ✅ ❌ ❌ Inicio
'w+' Escritura y Lectura (Trunca) ✅ ✅ ✅ ✅ Inicio
'a+' Añadir/Anexar y Lectura ✅ ✅ ✅ ❌ Final (escritura), Inicio
(lectura después de seek)
Modos Binarios: Añadir b al modo (ej. 'rb', 'wb'). Para archivos no textuales
(imágenes, audio, etc.). Los datos se tratan como bytes.
Explorando cada modo en detalle:

Modo 'r' (Read - Leer)

💡 Propósito: Acceder al contenido de un archivo existente sin modificarlo. Es el
modo por defecto si no se especifica ninguno.

⚙️ Comportamiento:

Si el archivo no existe, open() lanzará un error FileNotFoundError.

Si el archivo existe, se abre para lectura.

El puntero del archivo se posiciona al inicio del archivo.

Métodos Comunes de Lectura:

[Link](size=-1):

Lee y devuelve una cadena con el contenido del archivo.

Si size se omite o es negativo, lee todo el archivo hasta el final.

Si size es un número positivo, lee y devuelve como máximo size bytes (o caracteres,
dependiendo del modo texto/binario y la codificación).

Si se llega al final del archivo, llamadas subsiguientes a read() devuelven una

cadena vacía ''.

💻 Ejemplo:

# Asumiendo que existe un archivo [Link]

# with open("[Link]", "r") as f:
# contenido_completo = [Link]()
# print(contenido_completo)

# with open("[Link]", "r") as f:

# primeros_10_caracteres = [Link](10)
# print(f"Primeros 10: '{primeros_10_caracteres}'")
# siguientes_5_caracteres = [Link](5)
# print(f"Siguientes 5: '{siguientes_5_caracteres}'")
Use code with caution.
Python
⚠️ Consideración: read() sin size puede consumir mucha memoria si el archivo es muy
grande, ya que carga todo su contenido en una sola cadena.
[Link](size=-1):

Lee y devuelve una sola línea del archivo, desde la posición actual del puntero
hasta encontrar un carácter de nueva línea (\n), o hasta size bytes si se
especifica.

El carácter \n (si se encuentra) se incluye al final de la cadena devuelta.

Si se llega al final del archivo y no hay más líneas, devuelve una cadena vacía ''.

💻 Ejemplo:

# Asumiendo que existe un archivo lista_compras.txt

# with open("lista_compras.txt", "r") as f:
# linea1 = [Link]()
# print(f"L1: {[Link]()}") # .strip() para quitar el \n final
# linea2 = [Link]()
# print(f"L2: {[Link]()}")
Use code with caution.
Python
[Link](hint=-1):

Lee todas las líneas restantes del archivo (o hasta hint bytes aproximadamente) y
las devuelve como una lista de cadenas.

Cada cadena en la lista representa una línea del archivo y conserva el carácter \n
al final (excepto posiblemente la última línea si el archivo no termina con \n).

Si se llega al final del archivo, devuelve una lista vacía [].

💻 Ejemplo:

# Asumiendo que existe un archivo [Link]

# with open("[Link]", "r") as f:
# todas_las_lineas = [Link]()
# for i, linea in enumerate(todas_las_lineas):
# print(f"Línea {i+1}: {[Link]()}")
Use code with caution.
Python
⚠️ Consideración: Similar a read(), readlines() puede consumir mucha memoria con
archivos grandes. Para procesar archivos línea por línea de forma eficiente en
memoria, es mejor iterar directamente sobre el objeto archivo:

# Asumiendo que existe un archivo [Link]

# with open("[Link]", "r") as f:
# for linea in f: # Esto es eficiente en memoria
# print([Link]())
Use code with caution.
Python
Esto funciona porque los objetos archivo en Python son iterables, y cada iteración
produce la siguiente línea.

Modo 'w' (Write - Escribir)

💡 Propósito: Crear un nuevo archivo para escribir datos, o sobrescribir
completamente un archivo existente.

⚙️ Comportamiento:

Si el archivo no existe, open() lo crea.

Si el archivo ya existe, su contenido se borra completamente (trunca) antes de
escribir nuevos datos. ¡Este es un comportamiento destructivo!

El puntero del archivo se posiciona al inicio del archivo (que ahora está vacío o
es nuevo).

⚠️ Advertencia Fundamental: Usar 'w' en un archivo existente eliminará

irreversiblemente su contenido anterior. Asegúrate de que esto es lo que deseas.

Métodos Comunes de Escritura:

[Link](string):

Escribe la string proporcionada en el archivo en la posición actual del puntero.

No añade automáticamente un carácter de nueva línea (\n). Si quieres que cada write
comience en una nueva línea, debes incluir \n en la cadena.

Devuelve el número de caracteres escritos.

💻 Ejemplo:

with open("[Link]", "w") as f:

[Link]("Primera línea.\n")
[Link]("Segunda línea, ")
[Link]("continuación en la misma línea.\n")
[Link]("Tercera línea.")
# Contenido de [Link]:
# Primera línea.
# Segunda línea, continuación en la misma línea.
# Tercera línea.
Use code with caution.
Python
[Link](lista_de_strings):

Escribe cada cadena de la lista_de_strings en el archivo, una tras otra.

Similar a write(), no añade automáticamente caracteres de nueva línea entre las

cadenas o al final de cada una. Debes incluirlos en las propias cadenas si los
necesitas.

💻 Ejemplo:

lineas_para_escribir = ["Manzanas\n", "Peras\n", "Naranjas\n"]

with open("[Link]", "w") as f:
[Link](lineas_para_escribir)
# Contenido de [Link]:
# Manzanas
# Peras
# Naranjas
Use code with caution.
Python
Modo 'a' (Append - Añadir/Anexar)
💡 Propósito: Agregar nuevos datos al final de un archivo existente. Si el archivo
no existe, se crea.

⚙️ Comportamiento:
Si el archivo no existe, open() lo crea (similar a 'w').

Si el archivo ya existe, su contenido no se borra.

El puntero del archivo se posiciona siempre al final del archivo para las
operaciones de escritura, independientemente de cualquier intento de moverlo
(seek()). Esto asegura que los nuevos datos siempre se añadan al final.

Las operaciones de lectura no son permitidas en modo 'a' simple. Para leer y
añadir, se usa 'a+'.

Los métodos de escritura son los mismos que para 'w': write() y writelines().

💻 Ejemplo:

# Crear archivo [Link] si no existe para el ejemplo

with open("[Link]", "w") as f_init:
f_init.write("Evento A\n")
f_init.write("Evento B\n")

with open("[Link]", "a") as f:

[Link]("Evento C\n")
[Link]("Evento D\n")

# Contenido de [Link] ahora:

# Evento A
# Evento B
# Evento C
# Evento D
Use code with caution.
Python
⚠️ Problema Común: La Nueva Línea al Añadir
Si el archivo existente no termina con un carácter de nueva línea, y añades
contenido directamente, el nuevo contenido se pegará a la última línea existente.

Archivo [Link] (sin \n al final de la última línea):

Nota 1
Nota 2
Use code with caution.
Código para añadir:

# Crear [Link] para el ejemplo

with open("[Link]", "w") as f_notas_init:
f_notas_init.write("Nota 1\n")
f_notas_init.write("Nota 2") # Sin \n al final

with open("[Link]", "a") as f:

[Link](["Nota 3\n", "Nota 4\n"])
Use code with caution.
Python
Resultado en [Link]:

Nota 1
Nota 2Nota 3
Nota 4
Use code with caution.
Observa cómo "Nota 3" se pegó a "Nota 2".
💡 Soluciones:

Añadir \n al inicio del primer string que se añade (si es necesario):

# Restaurar [Link]
with open("[Link]", "w") as f_notas_init:
f_notas_init.write("Nota 1\n")
f_notas_init.write("Nota 2")

with open("[Link]", "a") as f:

[Link]("\nNota 3\n")
[Link]("Nota 4\n")
# Resultado:
# Nota 1
# Nota 2
# Nota 3
# Nota 4
Use code with caution.
Python
Procurar que todas las líneas escritas (incluso las originales) terminen con \n:
Esta es la práctica más robusta.

Modos de Actualización (Lectura y Escritura)

Estos modos son más complejos porque el puntero del archivo se comparte para
lectura y escritura, y su comportamiento puede ser sutil.

Modo 'r+' (Leer y Escribir)

💡 Propósito: Abrir un archivo existente para leer y modificar su contenido.

⚙️ Comportamiento:

Si el archivo no existe, open() lanzará un error FileNotFoundError.

Si el archivo existe, se abre para lectura y escritura.

El puntero del archivo se posiciona inicialmente al inicio del archivo.

Comportamientos:

Solo Lectura: Si solo usas métodos de lectura, se comporta como el modo 'r'.

# Crear archivo_r_plus.txt para el ejemplo

with open("archivo_r_plus.txt", "w") as f_init:
f_init.write("Linea 1\n")
f_init.write("Linea 2\n")

with open("archivo_r_plus.txt", "r+") as f:

print([Link]().strip())
print([Link]().strip())
Use code with caution.
Python
Solo Escritura: La escritura comienza desde el inicio del archivo, sobrescribiendo
el contenido existente.

# archivo_r_plus.txt antes:
# Linea 1
# Linea 2
with open("archivo_r_plus.txt", "r+") as f:
[Link]("Nuevo Contenido")
# archivo_r_plus.txt después (parcialmente):
# Nuevo Contenido
# Linea 2 (si "Nuevo Contenido" es más corto que "Linea 1")
Use code with caution.
Python
Lectura y LUEGO Escritura: La escritura ocurre en la posición actual del puntero
(después de lo leído), sobrescribiendo.

# Restaurar archivo_r_plus.txt
with open("archivo_r_plus.txt", "w") as f_init:
f_init.write("ABCDEFG\n")
f_init.write("HIJKLMN\n")

with open("archivo_r_plus.txt", "r+") as f:

data = [Link](3) # Lee "ABC", puntero después de C
print(f"Leído: {data}")
[Link]("123") # Escribe "123" donde estaba "DEF"
# archivo_r_plus.txt después:
# ABC123G
# HIJKLMN
Use code with caution.
Python
Escritura y LUEGO Lectura: Para leer lo que acabas de escribir en la misma sesión,
necesitas [Link]() (para asegurar que el buffer se escriba al SO) y [Link](0) (o
la posición deseada) para reposicionar el puntero antes de leer.

with open("archivo_rw.txt", "w+") as f: # Usamos w+ para empezar limpio

[Link]("Nuevo dato al inicio.")
[Link]()
[Link](0)
contenido_leido = [Link]()
print(contenido_leido)
Use code with caution.
Python
⚠️ Complejidad de r+: El manejo del puntero es clave. seek(offset, whence=0)
permite mover el puntero.

Modo 'w+' (Escribir y Leer)

💡 Propósito: Abrir un archivo para escribir desde cero y luego poder leer lo que se
escribió.

⚙️ Comportamiento:

Si el archivo no existe, open() lo crea.

Si el archivo ya existe, su contenido se borra completamente (trunca).

El puntero del archivo se posiciona inicialmente al inicio.

Comportamientos:

Solo Lectura (o Lectura antes de Escritura): Leerás un archivo vacío.

# Crear archivo_w_plus.txt con contenido

with open("archivo_w_plus.txt", "w") as f_init:
f_init.write("Contenido previo.\n")

with open("archivo_w_plus.txt", "w+") as f:

contenido = [Link]()
 print(f"Contenido leído: '{contenido}'") # Imprime: Contenido leído: ''
Use code with caution.
Python
Solo Escritura: Se comporta como el modo 'w'.

with open("nuevo_archivo_w_plus.txt", "w+") as f:

[Link]("Este es el único contenido.")
Use code with caution.
Python
Escritura y LUEGO Lectura: Debes reposicionar el puntero al inicio con [Link](0)
para leer lo escrito.

with open("w_plus_ejemplo.txt", "w+") as f:

[Link]("Hola desde w+.\n")
[Link]("Segunda línea.\n")
[Link](0)
contenido_leido = [Link]()
print("Contenido leído después de seek(0):\n" + contenido_leido)
Use code with caution.
Python
⚠️ Advertencia Clave para w+: Siempre recuerda que borra el contenido del archivo
al abrirlo.

Modo 'a+' (Añadir/Anexar y Leer)

💡 Propósito: Abrir un archivo para añadir al final y también para leer su
contenido.

⚙️ Comportamiento:

Si el archivo no existe, open() lo crea.

Si el archivo ya existe, su contenido no se borra.

Al abrir, el puntero se posiciona al final del archivo para las operaciones de

escritura.

Para leer desde el inicio, necesitas usar seek() después de abrir.

💻 Ejemplo:

# Crear log_aplus.txt si no existe

with open("log_aplus.txt", "a+") as f:
[Link]("Nuevo evento registrado.\n")
[Link](0)
historial_log = [Link]()
print("Historial completo del log:")
print(historial_log)
Use code with caution.
Python
Modos Binarios ('rb', 'wb', 'ab', etc.)
💡 Propósito: Trabajar con archivos que no son de texto plano (imágenes, audio,
etc.).

⚙️ Diferencia Principal:

Modo Texto: Python realiza codificación/decodificación de caracteres y maneja

finales de línea.

Modo Binario: Los datos se leen/escriben como objetos bytes puros, sin
transformación.

💻 Ejemplo:

datos_binarios = b'\x00\x01\x02\x03\x04\x05'
with open("[Link]", "wb") as f_bin:
f_bin.write(datos_binarios)

with open("[Link]", "rb") as f_bin:

contenido_binario = f_bin.read()
print(contenido_binario)
Use code with caution.
Python
💊 Puntos Clave de Repaso (Operaciones Fundamentales y Modos):

open() establece la conexión, close() la termina y guarda cambios. with es

preferible.

El modo define permiso, comportamiento ante existencia/inexistencia, y posición

inicial del puntero.

'r': Leer existente. Error si no existe.

'w': Escribir (nuevo o truncado). Crea si no existe. ¡Borra contenido!

'a': Añadir al final. Crea si no existe. No borra.

'r+': Leer y escribir existente. Error si no existe. Puntero al inicio. Escritura

sobrescribe.

'w+': Escribir y leer (nuevo o truncado). Crea si no existe. ¡Borra contenido!

Puntero al inicio. seek(0) necesario para leer tras escribir.

'a+': Añadir y leer. Crea si no existe. Puntero al final para escribir. seek(0)
necesario para leer desde el inicio.

Modos binarios ('b') para datos no textuales.

Tarjetas de Estudio Sugeridas:

P: ¿Por qué es crucial usar close() o la declaración with al trabajar con archivos?
R: Para liberar recursos del SO y asegurar que todos los datos escritos en buffers
se guarden en el disco (flushing), evitando pérdida de datos.

P: ¿Cuál es la diferencia principal entre abrir un archivo en modo 'w' y modo 'a'?
R: 'w' borra el contenido del archivo si ya existe antes de escribir. 'a' preserva
el contenido existente y añade los nuevos datos al final. Ambos crean el archivo si
no existe.

P: ¿Qué sucede si abro un archivo existente en modo 'w+'? ¿Y en 'r+'?

R: 'w+' borrará (truncará) el contenido del archivo existente. 'r+' no lo borrará y
permitirá leer y escribir sobre el contenido existente desde el inicio.

P: Si escribo datos en un archivo abierto con 'w+' y luego quiero leerlos en la

misma sesión open(), ¿qué debo hacer?
R: Debes usar [Link](0) para mover el puntero de vuelta al inicio del archivo
antes de intentar leer.

P: ¿Para qué se usan los modos binarios (ej. 'rb', 'wb')?

R: Para trabajar con archivos que no son de texto plano (imágenes, audio, etc.),
leyendo y escribiendo datos como secuencias de bytes crudos sin interpretación de
caracteres.

📄 Tipos de Archivos Comunes y su Procesamiento

1. Archivos de Texto Plano (.txt)
🧠 Características:

Contienen secuencias de caracteres legibles.

Universales, a menudo organizados línea por línea (\n).

⚙️ Procesamiento Típico:

Leer/escribir línea por línea o todo el contenido.

Buscar, modificar, añadir, eliminar texto.

💻 Ejemplo Práctico (Adaptado del documento fuente: [Link])

Problema: Leer la primera línea de [Link]. Pedir al usuario texto; si contiene

"vaca", añadirlo al final del archivo. Mostrar contenido actualizado.

Código Python (Interpretación para añadir al final):

nombre_archivo_txt = 'arch1_ejemplo.txt'

# Crear el archivo si no existe para el ejemplo

with open(nombre_archivo_txt, 'w', encoding='utf-8') as f:
[Link]("La vaca LOCA\n")
[Link]("VACAYENDO gente al baileee\n")

print(f"Contenido INICIAL de '{nombre_archivo_txt}':")

with open(nombre_archivo_txt, 'r', encoding='utf-8') as f_display:
print(f_display.read(), end="")
print("--------------------------------------")

with open(nombre_archivo_txt, 'r', encoding='utf-8') as f_lectura:

primera_linea_leida = f_lectura.readline()
print(f"Primera línea leída: {primera_linea_leida.strip()}")

texto_usuario = input('Ingresá un texto con vaca: ')

while (texto_usuario.lower()).count('vaca') == 0:
texto_usuario = input('Ingresá un texto con vaca (debe contener "vaca"): ')

# Abrir en modo 'a' (append) para añadir al final

with open(nombre_archivo_txt, 'a', encoding='utf-8') as f_anadir:
f_anadir.write(texto_usuario + '\n')

print(f"\nContenido de '{nombre_archivo_txt}' DESPUÉS de añadir:")

with open(nombre_archivo_txt, 'r', encoding='utf-8') as f_display:
print(f_display.read(), end="")
print("--------------------------------------")

print("\nMostrando contenido final línea por línea (strip):")

with open(nombre_archivo_txt, 'r', encoding='utf-8') as f_final:
todas_las_lineas = f_final.readlines()
for linea_actual in todas_las_lineas:
print(linea_actual.strip('\n'))
Use code with caution.
Python
2. Archivos CSV (Comma Separated Values - .csv)
🧠 Características:

Representan datos tabulares. Cada línea es una fila, valores separados por un
delimitador (, o ;).

Usados para intercambio con hojas de cálculo y bases de datos.

⚙️ Procesamiento Típico:

Abrir, leer línea por línea.

strip() y split('delimitador') para obtener campos.

Convertir tipos (ej., str a int).

Para escribir: [Link](delimitador, lista_valores) y añadir \n.

⚠️ Delimitadores y Comillas: El delimitador puede variar. El módulo csv de Python

maneja esto y las comillas en los datos de forma robusta.

💻 Ejemplo Práctico (Consolidar y Ordenar Datos de Concursantes)

Problema: Leer varios CSVs, combinar datos, convertir puntaje a int, ordenar por
puntaje (descendente), guardar en nuevo CSV.

Código Python (sin módulo csv, adaptado del fuente):

def generar_archivos_entrada_ejemplo_csv():
with open('[Link]', 'w', encoding='utf-8') as f:
[Link]("Luciana;juárez;santiago del estero;95\n")
[Link]("Julián;manzur;santiago del estero;98\n")
with open('[Link]', 'w', encoding='utf-8') as f:
[Link]("Jazmín;gerez;formosa;95\n")
[Link]("ana laura;jiménez;chaco;98\n")
with open('[Link]', 'w', encoding='utf-8') as f:
[Link]("Andrés;gil gómez;caba;85\n")
[Link]("Andrea;paz;caba;99\n")

generar_archivos_entrada_ejemplo_csv()

archivo_salida_nombre = '[Link]'
delimitador = ';'
datos_consolidados = []
nombres_archivos_entrada = [f'datos{i}.csv' for i in range(1, 4)]

for nombre_archivo_entrada in nombres_archivos_entrada:

try:
with open(nombre_archivo_entrada, 'r', encoding='utf-8') as dat_entrada:
lineas_archivo_actual = dat_entrada.readlines()
for linea_str in lineas_archivo_actual:
linea_limpia = linea_str.strip('\n')
if not linea_limpia: continue
campos = linea_limpia.split(delimitador)
if len(campos) == 4:
try:
campos[3] = int(campos[3])
 datos_consolidados.append(campos)
except ValueError:
print(f"Advertencia: No se pudo convertir puntaje:
'{linea_limpia}' en '{nombre_archivo_entrada}'")
else:
print(f"Advertencia: Formato incorrecto: '{linea_limpia}' en
'{nombre_archivo_entrada}'")
except FileNotFoundError:
print(f"Error: Archivo '{nombre_archivo_entrada}' no encontrado.")
except Exception as e:
print(f"Error procesando '{nombre_archivo_entrada}': {e}")

datos_consolidados.sort(key=lambda fila: (fila[3], fila[2]), reverse=True)

print("\n--- Datos Consolidados y Ordenados (en pantalla) ---")

for fila_dato in datos_consolidados:
print(fila_dato)

try:
with open(archivo_salida_nombre, 'w', encoding='utf-8') as f_completo:
for fila_dato in datos_consolidados:
fila_dato[3] = str(fila_dato[3])
linea_a_escribir = [Link](fila_dato) + '\n'
f_completo.write(linea_a_escribir)
print(f"\nArchivo '{archivo_salida_nombre}' generado exitosamente.")
except IOError:
print(f"Error al escribir el archivo '{archivo_salida_nombre}'.")
Use code with caution.
Python
💊 Puntos Clave de Repaso (Archivos TXT y CSV):

Archivos .txt son secuencias de caracteres. Se procesan con read(), readline(),

write(), y métodos de string.

Archivos .csv almacenan datos tabulares con delimitador. Se procesan con split() y
join().

La conversión de tipos es crucial para operaciones numéricas.

El módulo csv de Python es recomendado para CSV.

La gestión del puntero y modo de apertura es vital al modificar archivos.

Tarjetas de Estudio Sugeridas:

P: ¿Diferencia entre .txt y .csv?

R: .txt es texto plano genérico. .csv es texto plano para datos tabulares con
delimitador.

P: ¿Por qué convertir campos numéricos de CSV de str a int/float?

R: Para operaciones matemáticas y comparaciones numéricas correctas.

P: ¿Qué hace [Link]('\n')?

R: Elimina \n del inicio/final de la cadena. Útil porque readline()/readlines() los
conservan.

P: ¿Qué hace [Link](lista_de_strings)?

R: Concatena strings de la lista con delimitador entre ellos. Usado para crear
líneas CSV.
P: ¿Modo para añadir a .txt/.csv existente sin borrar?
R: Modo 'a' (append) o 'a+' (append y lectura).

⚠️ Consideraciones Adicionales Importantes

1. Manejo de Errores (try-except)
Las operaciones con archivos son propensas a errores: FileNotFoundError,
PermissionError, IOError, IsADirectoryError.
Es fundamental envolverlas en bloques try-except.

try:
with open("archivo_sensible.dat", "r") as f:
contenido = [Link]()
# Procesar contenido
except FileNotFoundError:
print("Error: El archivo 'archivo_sensible.dat' no se encontró.")
except PermissionError:
print("Error: No tienes permiso para leer 'archivo_sensible.dat'.")
except Exception as e: # Captura genérica para otros errores inesperados
print(f"Ocurrió un error inesperado: {e}")
Use code with caution.
Python
2. Codificación de Caracteres (Encodings)
Los archivos de texto almacenan caracteres, pero las computadoras fundamentalmente
almacenan bytes. La codificación de caracteres (encoding) es el sistema que mapea
caracteres a secuencias de bytes y viceversa.

Ejemplos comunes: UTF-8 (muy versátil, soporta casi todos los idiomas,
recomendado), ASCII (limitado a caracteres ingleses básicos), ISO-8859-1 (Latin-1).

Si un archivo se escribió con una codificación y se intenta leer con otra

incorrecta, pueden ocurrir errores (UnicodeDecodeError) o el texto puede aparecer
corrupto (caracteres extraños).

La función open() en Python 3 toma un parámetro encoding:

# Escribir con UTF-8 (recomendado)

with open("texto_utf8.txt", "w", encoding="utf-8") as f:
[Link]("Hola, mundo con acentos: áéíóúñ €")

# Leer especificando la codificación correcta

with open("texto_utf8.txt", "r", encoding="utf-8") as f:
contenido = [Link]()
print(contenido)
Use code with caution.
Python
Si no se especifica encoding, Python usa una codificación por defecto dependiente
del sistema operativo, lo cual puede llevar a problemas de portabilidad. Es una
buena práctica especificar siempre el encoding, usualmente utf-8.

📝 Preguntas Conceptuales de Comprensión

¿Por qué la persistencia de datos es un concepto fundamental en la mayoría de las
aplicaciones de software?

✅ Respuesta Modelo: La persistencia permite que los datos sobrevivan más allá de la
ejecución de un solo programa, lo que es esencial para almacenar información a
largo plazo (configuraciones, documentos, bases de datos), compartir datos entre
diferentes programas o usuarios, y reanudar trabajos o estados previos. Sin
persistencia, toda la información generada o utilizada por un programa se perdería
al cerrarse.

Explica el rol de los buffers del sistema operativo en las operaciones de E/S de
archivos. ¿Por qué mejoran la eficiencia?

✅ Respuesta Modelo: Los buffers son áreas temporales en la RAM que el SO usa para
transferir datos entre el programa y el disco. Mejoran la eficiencia porque
permiten:

Transferencia en bloque: Leer/escribir grandes trozos de datos de una vez es más

rápido que muchas operaciones pequeñas, reduciendo el overhead de las llamadas al
sistema y el tiempo de acceso al disco.

Desacoplamiento: El programa puede continuar procesando mientras el SO maneja la

E/S en segundo plano.

Caching: Datos leídos frecuentemente pueden permanecer en el buffer (caché) para

accesos más rápidos.

Si abres un archivo en modo 'r+' y realizas una operación read(), ¿dónde se

posiciona el puntero del archivo? Si luego realizas una operación write(), ¿dónde
se escribirán los datos y qué sucederá con el contenido existente en esa posición?

✅ Respuesta Modelo: Después de read(), el puntero se posiciona justo después del

último carácter leído. Si luego realizas write(), los datos se escribirán a partir
de esa posición actual del puntero, sobrescribiendo cualquier contenido que
existiera previamente desde ese punto en adelante.

Compara y contrasta los modos 'w+' y 'r+'. ¿Cuándo elegirías uno sobre el otro?

✅ Respuesta Modelo:

Ambos: Permiten leer y escribir en un archivo.

'w+': Si el archivo existe, lo trunca (borra su contenido) al abrirlo. Si no

existe, lo crea. El puntero se sitúa al inicio. Se usa cuando quieres empezar con
un archivo "limpio" para escribir y luego poder leer lo escrito.

'r+': Si el archivo existe, no borra su contenido. Si no existe, da un error

FileNotFoundError. El puntero se sitúa al inicio. Se usa cuando quieres leer y
modificar un archivo existente, conservando su contenido inicial.

Elección: Usa 'w+' si necesitas empezar de cero o sobrescribir completamente y

luego leer. Usa 'r+' si necesitas modificar partes de un archivo existente sin
perder el resto de su contenido.

¿Cuál es el propósito de la declaración with open(...) as ...: en Python y por qué

se considera una buena práctica?

✅ Respuesta Modelo: La declaración with implementa un manejador de contexto. Su

propósito principal al trabajar con archivos es asegurar que el archivo se cierre
automáticamente (close() se llama) cuando se sale del bloque with, incluso si
ocurren excepciones. Es buena práctica porque:

Evita errores comunes: Reduce la posibilidad de olvidar cerrar un archivo.

Código más limpio: No requiere bloques try...finally explícitos solo para el

cierre.
Manejo robusto de recursos: Garantiza la liberación de recursos del SO.

🧪 Problemas de Diseño/Programación Resueltos

Problema 1: Contador de Palabras Específicas
Escribe una función en Python que reciba el nombre de un archivo de texto y una
palabra. La función debe leer el archivo, contar cuántas veces aparece la palabra
(ignorando mayúsculas/minúsculas), y devolver ese conteo.

def contar_palabra_en_archivo(nombre_archivo, palabra_a_buscar):

"""
Cuenta las ocurrencias de una palabra en un archivo de texto,
ignorando mayúsculas y minúsculas.
"""
conteo = 0
palabra_lower = palabra_a_buscar.lower()
try:
with open(nombre_archivo, 'r', encoding='utf-8') as f:
for linea in f: # Procesar línea por línea para eficiencia de memoria
palabras_en_linea = [Link]().split() # Convertir a minúsculas
y dividir en palabras
for palabra_actual in palabras_en_linea:
# Podríamos limpiar la palabra de puntuación si es necesario
# ej. palabra_limpia = palabra_actual.strip('.,!?;:"()')
if palabra_actual == palabra_lower:
conteo += 1
except FileNotFoundError:
print(f"Error: El archivo '{nombre_archivo}' no fue encontrado.")
return -1 # Indicar error
except Exception as e:
print(f"Ocurrió un error: {e}")
return -1 # Indicar error
return conteo

# Ejemplo de uso:
# Crear un archivo de prueba
with open("prueba_palabras.txt", "w", encoding='utf-8') as f_test:
f_test.write("Esta es una prueba. La prueba es simple.\n")
f_test.write("Prueba, prueba, prueba!")

palabra = "prueba"
cantidad = contar_palabra_en_archivo("prueba_palabras.txt", palabra)
if cantidad != -1:
print(f"La palabra '{palabra}' aparece {cantidad} veces.") # Esperado: 5

cantidad_no_existe = contar_palabra_en_archivo("no_existe.txt", "test")

Use code with caution.
Python
💡 Razonamiento de la Solución:

La función toma nombre_archivo y palabra_a_buscar.

La palabra_a_buscar se convierte a minúsculas una vez para comparaciones

insensibles al caso.

Se usa with open(...) para abrir el archivo en modo lectura ('r') con codificación
utf-8.

Se itera sobre el archivo línea por línea (for linea in f:), lo cual es eficiente
para archivos grandes.
Cada linea se convierte a minúsculas y se divide en palabras usando split().
split() sin argumentos divide por cualquier espacio en blanco y maneja múltiples
espacios.

Se itera sobre las palabras_en_linea. Si se quisiera un conteo más preciso, se

debería limpiar cada palabra de signos de puntuación (ej., [Link]('.,!?')
antes de comparar. El ejemplo actual cuenta "prueba." y "prueba" como diferentes si
no se limpia. Para simplificar, el ejemplo no incluye limpieza exhaustiva de
puntuación, pero se menciona.

Si una palabra_actual coincide con palabra_lower, se incrementa conteo.

Se incluyen bloques try-except para FileNotFoundError y errores genéricos.

Se devuelve el conteo o -1 en caso de error.

🔍 Ejercicios de Análisis y Depuración

Ejercicio 1:
El siguiente código intenta copiar el contenido de [Link] a [Link].
Encuentra y corrige los errores o problemas potenciales.

# Código con problemas

# def copiar_archivo_problematico(origen_path, destino_path):
# f_origen = open(origen_path, "r")
# contenido = f_origen.read()
# f_destino = open(destino_path, "w")
# f_destino.write(contenido)
# # ¿Qué falta aquí? ¿Qué podría salir mal?
Use code with caution.
Python
✅ Análisis y Solución:

Falta close(): Los archivos f_origen y f_destino no se cierran. Esto puede llevar a
pérdida de datos en [Link] (si el buffer no se vacía) y a consumir recursos
del SO.

Manejo de Errores Inexistente: Si [Link] no existe, open() fallará con

FileNotFoundError. Si hay problemas de permisos o disco lleno al escribir, también
fallará.

Archivos Grandes: f_origen.read() carga todo el contenido de [Link] en memoria.

Si el archivo es muy grande, esto puede causar problemas de memoria.

Código Corregido y Mejorado:

def copiar_archivo_corregido(origen_path, destino_path):

try:
with open(origen_path, "r", encoding='utf-8') as f_origen:
with open(destino_path, "w", encoding='utf-8') as f_destino:
# Copiar en trozos para eficiencia con archivos grandes
chunk_size = 4096 # Leer en trozos de 4KB
while True:
trozo = f_origen.read(chunk_size)
if not trozo: # Fin del archivo
break
f_destino.write(trozo)
print(f"Archivo '{origen_path}' copiado a '{destino_path}' exitosamente.")
except FileNotFoundError:
 print(f"Error: El archivo origen '{origen_path}' no fue encontrado.")
except IOError as e: # Captura errores de E/S más generales
print(f"Error de E/S al copiar: {e}")
except Exception as e:
print(f"Ocurrió un error inesperado: {e}")

# Crear un archivo origen para probar

with open("[Link]", "w") as f:
[Link]("Línea 1 de prueba.\nLínea 2 de prueba.")

copiar_archivo_corregido("[Link]", "[Link]")
copiar_archivo_corregido("no_existe.txt", "otro_destino.txt")
Use code with caution.
Python
Mapa Conceptual Sugerido (Idea)
graph TD
A[Gestión de Archivos] --> B{Necesidad de Persistencia};
A --> C{Arquitectura Von Neumann: MI vs. Disco};
A --> D{Operaciones Fundamentales};
D --> D1[Abrir: open()];
D1 --> D1a[Nombre/Path];
D1 --> D1b[Modo];
D1 --> D1c[Objeto Archivo/Alias];
D --> D2[Cerrar: close()];
D2 --> D2a[Importancia: Flush, Liberar Recursos];
D --> D3[Context Manager: 'with open...as...'];
D3 --> D3a[Cierre Automático];

A --> E{Modos de Apertura};

E --> Ea['r' (Leer)];
Ea --> Ea1[read(), readline(), readlines()];
E --> Eb['w' (Escribir)];
Eb --> Eb1[write(), writelines()];
Eb --> Eb2[TRUNCA archivo!];
E --> Ec['a' (Añadir)];
Ec --> Ec1[Puntero al final];
E --> Ed['r+' (Leer/Escribir)];
Ed --> Ed1[No trunca, puntero al inicio];
E --> Ee['w+' (Escribir/Leer)];
Ee --> Ee1[TRUNCA archivo!, puntero al inicio];
E --> Ef['a+' (Añadir/Leer)];
E --> Eg[Modos Binarios 'b'];

A --> F{Tipos de Archivos Comunes};

F --> F1[Archivos de Texto .txt];
F1 --> F1a[Procesamiento: strip(), split(), join()];
F --> F2[Archivos CSV];
F2 --> F2a[Delimitadores];
F2 --> F2b[Módulo 'csv' de Python];
F2 --> F2c[Conversión de Tipos];

A --> G{Consideraciones Avanzadas};

G --> G1[Manejo de Errores: try-except];
G1 --> G1a[FileNotFoundError, PermissionError];
G --> G2[Codificación de Caracteres: Encodings];
G2 --> G2a['utf-8' recomendado];

A --> H{Buffers y SO};

H --> H1[Eficiencia: E/S en Bloque];
 subgraph "Comportamiento del Puntero"
P1[Posición Inicial]
P2[Avance con Lectura/Escritura]
P3[seek()]
end
Ea --> P1; Eb --> P1; Ec --> P1; Ed --> P1; Ee --> P1; Ef --> P1;
Ea1 --> P2; Eb1 --> P2;
Use code with caution.
Mermaid
📖 Glosario
Archivo (File): Una colección de datos almacenados en un medio no volátil (como un
disco duro), identificado por un nombre. Es la unidad fundamental de almacenamiento
persistente.

Persistencia (Data Persistence): La característica de los datos de sobrevivir al

proceso que los creó y de permanecer almacenados incluso después de que el sistema
se apague.

No Volátil (Non-volatile Storage): Medio de almacenamiento que retiene los datos

incluso cuando no recibe energía eléctrica (ej. discos duros, SSD, USB). Contrasta
con la memoria RAM, que es volátil.

Memoria Interna (MI) / RAM: Memoria principal de la computadora, rápida pero

volátil, donde los programas y los datos que están siendo procesados activamente
residen.

Buffer (Memoria Intermedia): Una región temporal de memoria (generalmente en RAM)

utilizada para almacenar datos mientras se transfieren entre dos dispositivos o
entre un dispositivo y una aplicación (ej. entre el disco y el programa). Ayuda a
optimizar la E/S.

Sistema Operativo (SO): Software que gestiona los recursos de hardware y software
de la computadora, incluyendo el sistema de archivos y las operaciones de E/S.

open(): Función (en Python y otros lenguajes) para establecer una conexión con un
archivo, preparándolo para operaciones de lectura o escritura. Devuelve un objeto
archivo.

Modo de Apertura (File Mode): Un string que se pasa a open() para especificar cómo
se va a interactuar con el archivo (leer, escribir, añadir, etc.) y cómo tratarlo
si existe o no.

Objeto Archivo (File Object) / Manejador de Archivo (File Handler): El objeto

devuelto por open() que representa la conexión al archivo abierto y proporciona
métodos para interactuar con él (ej. read(), write(), close()).

close(): Método del objeto archivo para cerrar la conexión con el archivo,
asegurando que los datos en buffers se escriban al disco (flush) y se liberen los
recursos del SO.

with statement (Manejador de Contexto): Construcción de Python que simplifica la

gestión de recursos (como archivos), asegurando que se configuren y liberen
adecuadamente (ej. llamando a close() automáticamente).

Puntero de Archivo (File Pointer/Cursor): Una referencia interna que mantiene la

posición actual dentro de un archivo abierto, indicando dónde comenzará la próxima
operación de lectura o escritura.
Truncar (Truncate): Acortar o vaciar un archivo. El modo 'w' y 'w+' truncan el
archivo si ya existe, eliminando todo su contenido anterior.

read(): Método para leer datos (una cantidad específica de bytes o todo el
contenido) de un archivo.

readline(): Método para leer una sola línea de un archivo.

readlines(): Método para leer todas las líneas restantes de un archivo y

devolverlas como una lista de strings.

write(): Método para escribir una cadena de texto en un archivo.

writelines(): Método para escribir una lista de cadenas en un archivo.

strip(): Método de string para eliminar caracteres especificados (por defecto,

espacios en blanco y saltos de línea) del inicio y final de una cadena.

split(): Método de string para dividir una cadena en una lista de subcadenas,
usando un delimitador especificado.

join(): Método de string para concatenar los elementos de una lista de strings en
una sola cadena, usando el string original como separador.

Archivo de Texto Plano (.txt): Archivo que contiene solo caracteres legibles, sin
formato complejo ni metadatos incrustados.

CSV (Comma Separated Values): Formato de archivo de texto plano para almacenar
datos tabulares, donde los valores de cada fila están separados por un delimitador
(coma, punto y coma, etc.).

Delimitador (Delimiter): Carácter o secuencia de caracteres utilizado para separar

campos o valores en datos estructurados (ej. en un archivo CSV).

Codificación de Caracteres (Encoding): Esquema que define cómo se representan los

caracteres (letras, números, símbolos) como secuencias de bytes en la memoria o en
un archivo. Ejemplos: UTF-8, ASCII.

UTF-8: Una codificación de caracteres de longitud variable muy utilizada que puede
representar la mayoría de los caracteres de todos los idiomas del mundo.

Modo Binario (Binary Mode): Modo de apertura de archivo (ej. 'rb', 'wb') que trata
los datos como secuencias de bytes crudos, sin interpretación de caracteres. Usado
para archivos no textuales (imágenes, audio, etc.).

seek(): Método de objeto archivo para mover el puntero de archivo a una posición
específica.

Flush: La acción de forzar la escritura de los datos de un buffer al dispositivo de

almacenamiento subyacente (ej. disco).