Las interrogaciones ya pasaron, las listas dejaron de asustarte y llega el examen de IIC1103. El error más común en este punto es estudiar repasando la I1 y la I2 con más detalle, como si el examen fuera una tercera interrogación más larga. Esta guía parte de una tesis distinta: el examen se gana en la segunda mitad del programa, justo la parte que tuviste menos tiempo de practicar.

Va dirigida a quien cursa el ramo por primera vez y llega con una base razonable de Python. Si programas hace años y las clases te salen solas, te sobrará la mitad del texto: salta a la tabla de errores y úsala como lista de chequeo.

Lo que el examen hereda y lo que trae nuevo

El programa oficial de IIC1103 en el Catálogo UC (consultado el 11 de octubre de 2026) lista once unidades: algoritmos, Python, variables y expresiones, control de flujo, funciones, strings, listas, archivos, programación orientada a objetos y clases, ordenación y búsqueda, y recursión. Ese mismo programa reparte la nota en pruebas 30%, examen 30%, tareas 30% y participación 10%. Es una versión del programa y tu sección puede ajustar ponderaciones, así que confirma en tu syllabus.

Lo importante es el orden. Las primeras siete unidades las cubren las interrogaciones. Las cuatro últimas (archivos, clases, ordenación y búsqueda, recursión) suelen llegar tarde en el semestre y con menos ejercicios de práctica. Dónde cae exactamente cada tema en tu examen lo define tu profesor; lo que sí puedo decirte es que, si sólo repasas lo antiguo, estás apostando a que lo nuevo no salga.

Archivos: cada línea es un string que hay que desarmar

Un enunciado típico de archivos entrega algo como un listado de alumnos con sus notas, una línea por persona. Todo se reduce a tres pasos que ya conoces de la unidad de strings: leer la línea, limpiarla con strip() y partirla con split(). Lo nuevo es la apertura segura del archivo y el hábito de cerrarlo, que resuelve with open(...).

Dos detalles que cuestan puntos sin que te des cuenta. Primero, lo que sale de split() son strings, incluso si parecen números: hay que convertir con float() o int() antes de promediar. Segundo, la última línea del archivo puede venir vacía, y una línea vacía te rompe el programa en el primer índice que toques. Si el enunciado no lo descarta, protégete con un if linea: o filtrando antes de partir.

Clases: modela antes de programar

Las clases asustan más de lo que complican. Una clase es un molde con datos (atributos) y acciones (métodos) que se refieren a esos datos. En el examen, la pregunta casi nunca es “escribe una clase brillante”, sino “representa esta situación con una clase y haz que responda una pregunta”.

Por eso conviene un ritual de dos minutos antes de escribir código: subraya los sustantivos del enunciado (alumno, curso, tablero) y pregúntate cuáles necesitan guardar datos propios. Esos son tus candidatos a clase. Los verbos (calcular promedio, agregar nota, mover ficha) son tus métodos. Si haces esa lectura primero, la sintaxis de __init__ y self es lo de menos.

Un ejemplo comentado que junta las tres piezas

Supón un archivo notas.txt con líneas como Pérez;6.1;5.4;4.8. Se pide leerlo, crear un objeto por alumno y mostrar los que aprueban. Así se ve una solución ordenada:

class Alumno:
    def __init__(self, nombre, notas):
        self.nombre = nombre      # string
        self.notas = notas        # lista de floats

    def promedio(self):
        return sum(self.notas) / len(self.notas)

def leer_alumnos(ruta):
    alumnos = []
    with open(ruta, encoding="utf-8") as archivo:
        for linea in archivo:
            linea = linea.strip()
            if not linea:         # ignora líneas vacías
                continue
            partes = linea.split(";")
            notas = [float(n) for n in partes[1:]]   # convertir ANTES de promediar
            alumnos.append(Alumno(partes[0], notas))
    return alumnos

for alumno in leer_alumnos("notas.txt"):
    if alumno.promedio() >= 4.0:
        print(alumno.nombre, round(alumno.promedio(), 1))

Fíjate en la división de responsabilidades: la clase sabe calcular su promedio, la función sabe leer el archivo, y el programa principal sólo decide qué mostrar. Cuando una respuesta de examen tiene esa forma, es fácil de revisar y fácil de corregir, que es justo lo que quiere el corrector.

Recursión: el caso base primero, siempre

La recursión es la unidad que más gente deja para el final y la que más rinde si la entiendes. La regla es mecánica: antes de escribir el paso recursivo, escribe el caso base, la situación mínima que se responde sin llamarse a sí misma.

def suma_digitos(n):
    if n < 10:                  # caso base: un solo dígito
        return n
    return n % 10 + suma_digitos(n // 10)   # paso: último dígito + el resto

Para comprobar tu función, rutea con un valor pequeño: suma_digitos(472) da 2 + suma_digitos(47), que da 7 + suma_digitos(4), que da 4. Si en el ruteo la entrada nunca se acerca al caso base, tienes recursión infinita. Python no la deja correr para siempre: según la documentación del módulo sys, existe un límite de recursividad justamente para evitar que una recursión infinita bloquee el intérprete.

En ordenación y búsqueda pasa algo parecido. Te conviene saber explicar con tus palabras por qué la búsqueda binaria exige una lista ya ordenada y cuántas comparaciones se ahorra. Eso se pregunta más que el código de memoria.

Los errores del examen, en una tabla

Esta tabla resume los fallos que aparecen una y otra vez en las cuatro unidades nuevas. Úsala como checklist antes de entregar.

Ninguna fila se arregla sabiendo más sintaxis. Todas se arreglan con ruteo, es decir, seguir el programa a mano con datos concretos, así que ese es el hábito que más vale la pena entrenar.

A quién le sirve esta estrategia y un plan de siete días

Este enfoque le sirve a quien llega con la I1 y la I2 aprobadas o apenas rozando el 4,0, y siente que lo nuevo quedó flojo. No le sirve a quien aún confunde listas con referencias o no domina los ciclos: en ese caso el problema está más atrás y conviene volver a la guía de listas de listas de la I2 antes de tocar clases.

Si te quedan siete días, esto es lo que haría:

1. Días 1 y 2: archivos. Dos ejercicios por día, en papel, con el ejemplo de arriba como molde.
2. Días 3 y 4: clases. Para cada enunciado, primero sustantivos y verbos, y recién después código.
3. Día 5: recursión. Cinco funciones cortas, todas ruteadas a mano.
4. Día 6: una prueba anterior completa, con tiempo real y sin ayuda.
5. Día 7: corrige esa prueba con la tabla de errores y deja el resto del día libre.

Si prefieres practicar con alguien que ya pasó por el ramo, puedes ver los cursos de ARomperla para ramos UC. Y si estás armando el semestre completo, en el hub de la UC encuentras las guías por ramo y por prueba.

El examen no premia al que más Python sabe, sino al que traduce mejor un enunciado a una estructura. Eso se entrena con lápiz, un archivo de ejemplo y un par de tardes tranquilas.