Pensamiento Computacional · Resumen de las clases + cuestionario multiple choice
Un archivo es una secuencia de bytes almacenada en un soporte físico duradero (disco de estado sólido, disco rígido, pendrive). A diferencia de las variables, que viven en la memoria RAM y se borran al terminar el programa (son volátiles), los archivos representan la persistencia de los datos.
Cuando el programa interactúa con un archivo, no lo copia entero a la RAM de golpe (eso destruiría el rendimiento con archivos de gigabytes). Python abre un stream: un canal o "tubería" por donde los datos fluyen byte por byte o carácter por carácter, del disco al programa (lectura) o del programa al disco (escritura).
[1. APERTURA] → [2. OPERACIÓN (Lectura / Escritura)] → [3. CIERRE]
Si falta un paso, el programa está incompleto o es propenso a fallas.
open() y close()# 1. Apertura
archivo = open("notas_parcial.txt", "w", encoding="utf-8")
# 2. Operación de escritura
archivo.write("Estructuras de Datos en Python\n")
# 3. Cierre obligatorio
archivo.close()
open("ruta", "modo") recibe un string con la ruta (relativa o absoluta) y un
modo: un string de un solo carácter que define la operación.
| Modo | Nombre | Si el archivo NO existe | Si el archivo SÍ existe | Posición del cursor |
|---|---|---|---|---|
"r" | Lectura (Read) | ❌ Error FileNotFoundError | Lo abre para leer | Al principio (posición 0) |
"w" | Escritura (Write) | Crea uno nuevo vacío | ⚠️ Borra TODO el contenido (lo trunca a 0 bytes) | Al principio |
"a" | Anexado (Append) | Lo crea | Agrega al final, no borra nada | Al final |
write() NO agrega saltos de línea solo.
Hay que escribir \n explícitamente:
archivo.write("Primer parcial: 24 de Mayo\n")
Supongamos que notas.txt contiene: Gomez,8 · Perez,7 · Lopez,10 (una línea cada uno).
read() - todo en un stringIdeal si el archivo es chico y queremos procesar el texto completo como un único gran string.
archivo = open("notas.txt", "r", encoding="utf-8")
todo = archivo.read() # string completo con sus saltos de línea
print(todo)
archivo.close()
readlines() - una lista de líneasLee todo y crea una lista de Python donde cada elemento es una línea (un string).
archivo = open("notas.txt", "r", encoding="utf-8")
lista_lineas = archivo.readlines()
archivo.close()
for linea in lista_lineas:
print("Línea procesada:", linea.strip()) # .strip() quita el \n invisible del final
for directo sobre el archivoEl objeto archivo se puede recorrer directamente línea por línea, sin cargar todo en una lista intermedia.
archivo = open("notas.txt", "r", encoding="utf-8")
for linea in archivo:
print("Estudiante:", linea.strip())
archivo.close()
with open(...)write y el
close ocurre un error inesperado?
archivo = open("notas_parcial.txt", "w", encoding="utf-8")
archivo.write("Estructuras de Datos en Python\n")
resultado = 10 / 0 # ¡El programa explota aquí!
archivo.close() # Esta línea NUNCA se ejecuta
La solución estándar y profesional: la sentencia with, técnicamente llamada
Administrador de Contexto (Context Manager).
with open("notas_parcial.txt", "w", encoding="utf-8") as archivo:
archivo.write("Estructuras de Datos en Python\n")
# más operaciones acá adentro...
# Al salir de la indentación, el archivo YA SE CERRÓ automáticamente.
with open(...) as archivo: abre el archivo y crea la variable.Ventaja clave: aunque el código de adentro falle o lance una excepción, Python
garantiza que el archivo se cierra correctamente. No requiere .close() explícito.
Leer temperaturas.txt (un valor por línea), calcular el promedio y guardar el
resultado en reporte.txt:
suma = 0
cantidad = 0
with open("temperaturas.txt", "r", encoding="utf-8") as archivo:
for linea in archivo:
suma += float(linea.strip())
cantidad += 1
promedio = suma / cantidad
with open("reporte.txt", "w", encoding="utf-8") as salida:
salida.write("Promedio de temperaturas: " + str(promedio) + "\n")
La estructura if __name__ == "__main__": es el punto de entrada estándar en Python.
Sirve para controlar el comportamiento del código según cómo se está ejecutando el archivo.
__name__Cada vez que Python ejecuta un archivo .py, antes de leer el código define automáticamente
algunas variables ocultas. Una de ellas es __name__, y su valor depende exclusivamente
de cómo se llamó al archivo:
| Escenario | Cómo se ejecuta | Valor de __name__ |
|---|---|---|
| A - Ejecución directa (programa principal) | python mi_programa.py desde la terminal |
"__main__" |
| B - Importación (módulo o librería de apoyo) | import mi_programa desde otro archivo |
El nombre real del archivo (ej. "mi_programa") |
def funcion_matematica():
print("Aquí va una función matemática")
# Código secundario...
def main():
# Aquí va el verdadero corazón y flujo de tu programa principal
print("Iniciando el sistema principal...")
# El guardián del punto de entrada
if __name__ == "__main__":
main()
main() solo se ejecuta cuando el archivo corre como
programa principal. Si otro archivo lo importa para usar sus funciones, el bloque no se ejecuta y
el módulo funciona como librería de apoyo sin efectos secundarios.
Elegí una opción en cada pregunta: la corrección es inmediata y con explicación. Al final vas a ver tu puntaje.