Cursus — Python Module 00 rank 02

«Growing Code»: el primer contacto con Python después de todo el C. Ocho ejercicios ambientados en un huerto comunitario que recorren lo básico — print, input, conversión con int, condicionales, bucles, recursión y, al final, anotaciones de tipo.

De C a Python — Después de la piscine, Libft, printf y push_swap, todo era memoria a mano: malloc, free, punteros, write byte a byte y una Norma que vigila cada línea. Python le da la vuelta a casi todo. No se compila: el intérprete python3 lee y ejecuta. Las variables no tienen tipo, lo tienen los valores (tipado dinámico), y la memoria la gestiona el recolector de basura: no hay malloc ni free, ni segfaults. En lugar de la norminette, el enunciado exige flake8 (el estilo PEP 8: sangría de 4 espacios, dos líneas en blanco entre definiciones, sin espacios al final de línea…) y, en el último ejercicio, mypy para comprobar los tipos. Una regla curiosa del módulo: cada fichero debe contener solo la función, sin código suelto ni bloque if __name__ == "__main__":; para probarlas se usa el main.py que da el enunciado, que las importa y las llama. Todo el repo pasa flake8 y mypy sin avisos.

GGlosario de teoría

La página usa palabras básicas de Python y algunas que vienen de comparar Python con C. Aquí está cada una explicada desde cero y con un ejemplo sacado de los propios ejercicios. En el resto de la página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.

El lenguaje

Intérprete frente a compilador

Un compilador traduce todo el programa a código máquina antes de ejecutarlo (cc produce un ejecutable). Un intérprete lee el programa y lo va ejecutando él mismo. Python está en medio: python3 traduce cada fichero a un código intermedio (bytecode) y lo ejecuta en su máquina virtual, sin ejecutable aparte.

Por eso los errores de un ejercicio salen al ejecutarlo, no antes: un nombre mal escrito dentro de ft_plot_area no da ningún aviso hasta que main.py llama a la función.

Tipado dinámico

En Python las variables no tienen tipo; lo tienen los valores. Una variable es solo un nombre que apunta a un valor, y puede apuntar después a otro de otro tipo. El tipo se comprueba al ejecutar cada operación, no al escribir el código.

En ex3, a = input(...) guarda una cadena, y int(a) crea un valor nuevo de tipo entero sin cambiar a. Si se suma sin convertir, a + b + c con 5, 8 y 3 da "583".

Sangría como sintaxis

En Python la sangría (los espacios al principio de la línea) no es estética: marca qué líneas forman un bloque. Lo que en C va entre llaves aquí va sangrado debajo de una línea que acaba en dos puntos (def, if, for…). Si no cuadra, el programa no arranca: IndentationError.

En ex4, las dos llamadas a print van sangradas 8 espacios porque están dentro del if y del else, que a su vez están dentro de la función.

Función, parámetro y return

def nombre(parametros): define una función; su cuerpo es el bloque sangrado de debajo. Los parámetros son los nombres que reciben los valores de la llamada. return termina la función y devuelve un valor; sin return, o con un return vacío, devuelve None.

Los ejercicios 0 a 6 no reciben parámetros (leen con input) y el 7 recibe tres. En ex7, el return vacío de la rama else sale de la función antes de llegar al print final.

Módulo e import

Cada fichero .py es un módulo. import lo carga y ejecuta su código de arriba abajo; las def solo definen funciones, no las llaman. Si el fichero tuviera código suelto, se ejecutaría al importarlo.

Por eso el enunciado exige que cada fichero contenga solo la función: main.py hace __import__("ft_plot_area") y luego llama a ft_plot_area(). Un print suelto en el fichero se ejecutaría al importarlo, antes de que main.py llame a la función.

if __name__ == "__main__":

Cada módulo tiene una variable __name__: vale "__main__" si el fichero se ejecuta directamente (python3 fichero.py) y el nombre del módulo si se importa. El bloque if __name__ == "__main__": sirve para poner código que solo se ejecute en el primer caso.

El enunciado lo prohíbe en este módulo: los ficheros solo definen la función, y la prueba la hace main.py.

None

El valor que significa «nada»: lo devuelve una función sin return y se usa como valor por defecto cuando falta un dato. Hay un único None en todo el programa, por eso se compara con is (¿es el mismo objeto?) y no con ==.

En ex6 recursivo, days=None marca la primera llamada: if days is None: solo es cierto cuando main.py llama sin argumentos.

Parámetro con valor por defecto

Un parámetro escrito como nombre=valor en la def se puede omitir al llamar, y entonces toma ese valor. Así una misma función admite llamadas con y sin ese argumento.

ft_count_harvest_recursive(days=None) se llama sin nada desde main.py y con un número desde sí misma: ft_count_harvest_recursive(day - 1). Es una de las tres opciones que propone el enunciado.

Entrada, salida y texto

input y la entrada estándar

input(texto) escribe texto, espera a que el usuario escriba una línea y pulse Intro, y la devuelve como cadena, sin el salto de línea. Lee de la entrada estándar, así que también funciona con una tubería: printf "5\n" | python3 …. Si la entrada se acaba antes, lanza EOFError.

En ex2 hay dos input. Con una sola línea en la tubería, el primero lee el número y el segundo se encuentra el final: EOFError: EOF when reading a line.

Cadena (str) y método

Una cadena es un texto, entre comillas simples o dobles. En Python es un objeto con sus propias funciones, los métodos, que se llaman con un punto: texto.upper(). Las cadenas no se modifican: cada método devuelve una cadena nueva.

En ex7, seed_type.capitalize() devuelve "Tomato" a partir de "tomato". Si se pasa un número, ft_seed_inventory(42, 1, "grams") falla con AttributeError: 'int' object has no attribute 'capitalize'.

f-string

Una cadena con una f delante de las comillas, en la que lo que va entre llaves se evalúa y se inserta como texto: f"Day {day}". Es la forma moderna de componer texto en Python, desde la versión 3.6.

Casi todos los ejercicios la usan. En ex7, una sola f-string junta cuatro piezas: f"{seed_type.capitalize()} seeds: {covers}{quantity} {unit}".

Conversión de tipo: int()

int(x) crea un entero a partir de otro valor. Con una cadena, acepta dígitos con un signo opcional y espacios alrededor (int(" 7 ") da 7), y para todo lo demás lanza ValueError. Los enteros de Python no tienen tope: no hay INT_MAX.

ex2 convierte nada más leer (int(input(...))); ex3 lee las tres cadenas y convierte al sumar; ex5 convierte dentro de la condición.

Control y errores

if, elif y else

if ejecuta su bloque si la condición es cierta; elif («else if») prueba otra condición si las anteriores fallaron; else recoge el resto. Solo se ejecuta un bloque de la cadena, el primero que se cumpla.

ex7 tiene tres elif/if para las unidades conocidas y un else para la desconocida. En ex4, con 60 días exactos age > 60 es falso y sale «Plant needs more time to grow.».

for y range

El for de Python recorre los elementos de algo: for x in coleccion:. range(a, b) da los enteros de a hasta b sin incluir b. No hay inicialización, condición ni incremento como en C.

En ex6, range(1, days + 1) con 5 da 1, 2, 3, 4, 5. Con 0 o un negativo, range sale vacío y solo se imprime «Harvest time!».

Recursión y caso base

Una función recursiva se llama a sí misma con un problema más pequeño. Tiene que haber un caso base que no se llame otra vez, o no terminaría nunca.

En ex6 el caso base es day igual a 0: if day > 0 es falso y no hay más llamadas. Con 5 se anidan llamadas con 5, 4, 3, 2, 1 y 0, y cada una imprime su día al volver, por eso salen en orden creciente.

Pila de llamadas y RecursionError

Cada llamada a función que no ha terminado ocupa un marco en la pila de llamadas, con sus variables locales. En C, si se llena, segfault; Python pone un límite (1000 por defecto, sys.getrecursionlimit()) y lanza RecursionError antes.

Probado llamando directamente a ft_count_harvest_recursive: con 998 días funciona y con 999 da RecursionError: maximum recursion depth exceeded. La iterativa no tiene límite.

Excepción y traceback

Una excepción es la forma de Python de avisar de un error al ejecutar: ValueError (valor no válido), TypeError (tipo equivocado), AttributeError (el objeto no tiene ese método)… Si nadie la captura con try/except, el programa se para y escribe el traceback, la lista de llamadas por las que pasó.

En ex2, escribir a da ValueError: invalid literal for int() with base 10: 'a'. El enunciado no pide validar, así que no hay try en ningún ejercicio.

Herramientas

flake8 y PEP 8

PEP 8 es la guía de estilo oficial de Python: sangría de 4 espacios, líneas de 79 caracteres como mucho, dos líneas en blanco entre definiciones, sin espacios al final. flake8 es la herramienta que la comprueba; es lo que el enunciado exige en lugar de la norminette.

Los nueve ficheros del repo pasan sin un aviso. Están sangrados con 4 espacios, como pide PEP 8.

Anotaciones de tipo y mypy

Una anotación dice qué tipo se espera: quantity: int para un parámetro, -> None para lo que devuelve. Python no las comprueba al ejecutar; mypy las lee sin ejecutar nada y avisa de las incoherencias.

ex7 es el único con anotaciones obligatorias, y pasa mypy. Con mypy --strict, que exige anotar todo, el repo da 9 errores, todos en ex0–ex6, que no tienen anotaciones (el enunciado las deja como opcionales).

ex0ft_hello_garden

Entrega: ft_hello_garden.pyAutorizado: print()
def ft_hello_garden():
    print("Hello, Garden Community!")

Dos líneas. def define la función, los dos puntos abren el bloque y la sangría marca qué hay dentro: no hay llaves ni punto y coma. print añade el salto de línea por su cuenta.

Qué te obliga a aprender — Que en Python la sangría es sintaxis. En C la Norma te exigía tabular bien por estética; aquí, si la línea del print no está sangrada, el programa ni arranca (IndentationError). Y que print no es write: ni descriptor, ni longitud, ni "\n" a mano.

ex1ft_garden_name

Entrega: ft_garden_name.pyAutorizado: input(), print()
def ft_garden_name():
    garden_name = input("Enter garden name: ")
    print(f"Garden: {garden_name}")
    print("Status: Growing well!")

input muestra el texto que se le pasa, espera a que el usuario pulse Intro y devuelve lo escrito como cadena (sin el salto de línea). Luego una f-string: la f delante de las comillas permite meter variables entre llaves.

Qué te obliga a aprender — Leer de la entrada estándar sin read, sin buffer de tamaño fijo y sin preocuparte de cuánto escribirá el usuario: la cadena crece lo que haga falta. Y las f-strings, que hacen en una línea lo que en C pedía printf("%s", ...) — o tu propio ft_printf entero.

ex2ft_plot_area

Entrega: ft_plot_area.pyAutorizado: input(), int(), print()
def ft_plot_area():
    length = int(input("Enter length: "))
    width = int(input("Enter width: "))
    area = length * width
    print(f"Plot area: {area}")

input siempre devuelve texto; para multiplicar hay que convertirlo con int(). Si el usuario escribe algo que no es un número, Python lanza una excepción y se para:

Enter length: a
ValueError: invalid literal for int() with base 10: 'a'

El enunciado dice explícitamente que no hace falta validar la entrada, así que es el comportamiento esperado.

Qué te obliga a aprender — Que tipado dinámico no significa «sin tipos». "5" * "3" es un error y "5" * 3 da "555": los valores tienen tipo y Python lo respeta con rigor. int() es tu ft_atoi, pero en vez de devolver basura ante una entrada rara, protesta. Y los enteros de Python no desbordan: crecen sin límite, adiós a INT_MAX.

ex3ft_harvest_total

Entrega: ft_harvest_total.pyAutorizado: input(), int(), print()
def ft_harvest_total():
    a = input("Day 1 harvest: ")
    b = input("Day 2 harvest: ")
    c = input("Day 3 harvest: ")
    total_harvest = int(a) + int(b) + int(c)
    print(f"Total harvest: {total_harvest}")

Aquí la conversión se hace al final, en la suma, en lugar de al leer como en ex2. Las dos formas valen; la diferencia es cuándo existe la variable como texto y cuándo como número.

Qué te obliga a aprender — Que una misma variable no tiene un tipo fijo declarado: a guarda una cadena, y es int(a) quien produce un valor nuevo de tipo entero. Fíjate también en que + entre cadenas concatena: a + b + c sin los int daría "583", no 16.

ex4ft_plant_age

Entrega: ft_plant_age.pyAutorizado: input(), int(), print()
def ft_plant_age():
    age = int(input("Enter plant age in days: "))
    if age > 60:
        print("Plant is ready to harvest!")
    else:
        print("Plant needs more time to grow.")
Qué te obliga a aprender — El if/else de Python: sin paréntesis obligatorios, con dos puntos y sangría. Y leer el enunciado con lupa, como en C00 con el cero de ft_is_negative: «estrictamente más de 60 días» es >, no >=. Con 60 exactos la planta todavía no está lista.

ex5ft_water_reminder

Entrega: ft_water_reminder.pyAutorizado: input(), int(), print()
def ft_water_reminder():
    a = input("Days since last watering: ")
    if int(a) > 2:
        print("Water the plants!")
    else:
        print("Plants are fine")

El mismo esquema que ex4, con la conversión hecha dentro de la condición.

Qué te obliga a aprender — Que comparar sin convertir no funciona: "4" > 2 lanza un TypeError porque Python no compara texto con números. En C, comparar un char * con un int compilaba (con suerte con un aviso) y comparaba una dirección de memoria; Python prefiere fallar en voz alta.

ex6ft_count_harvest

Entrega: ft_count_harvest_iterative.py, ft_count_harvest_recursive.pyAutorizado: input(), int(), print(), range(), funciones auxiliares para la recursión

Contar de 1 a n y terminar con «Harvest time!», dos veces: con un bucle y con recursión.

Versión iterativa

def ft_count_harvest_iterative():
    days = int(input("Days until harvest: "))
    for day in range(1, days + 1):
        print(f"Day {day}")
    print("Harvest time!")

El for de Python no es el de C: no tiene inicialización, condición y avance, sino que recorre los valores que le da range(1, days + 1), que va de 1 a days (el final no se incluye, de ahí el + 1).

Versión recursiva

def ft_count_harvest_recursive(days=None):
    is_first_call = False
    if days is None:
        day = int(input("Days until harvest: "))
        is_first_call = True
    else:
        day = days
    if day > 0:
        ft_count_harvest_recursive(day - 1)
        print(f"Day {day}")
    if is_first_call:
        print("Harvest time!")

Usa una de las opciones que propone el enunciado: un parámetro con valor por defecto. La llamada desde main.py no pasa argumentos, así que days vale None: es la primera llamada, la única que pide el número y la única que imprime «Harvest time!» al final. Las llamadas recursivas reciben ya el número.

El truco del orden es el mismo de ft_putnbr en C00: la función baja primero hasta 0 y luego, al volver, imprime. Así la pila de llamadas da la vuelta al orden y sale Day 1, Day 2… aunque se empiece por n.

Days until harvest: 5
Day 1
Day 2
Day 3
Day 4
Day 5
Harvest time!

Ojo: Python limita la profundidad de recursión (por defecto, unas 1000 llamadas). Con 990 días funciona; con 1000 la versión recursiva se para con RecursionError: maximum recursion depth exceeded, mientras la iterativa sigue sin problema. Para el enunciado no importa, pero es una diferencia real entre las dos versiones.

Qué te obliga a aprender — La comparación directa entre iteración y recursión, ahora en un lenguaje que las trata distinto que C. En C la recursión solo está limitada por el tamaño de la pila y, si te pasas, segfault; Python pone un tope explícito y lanza una excepción legible. También introduce dos piezas propias de Python: los parámetros por defecto y None, el «no hay valor» que sustituye a NULL (y que se compara con is, no con ==).

ex7ft_seed_inventory

Entrega: ft_seed_inventory.pyAutorizado: print(), métodos de cadena

El único ejercicio que recibe parámetros en lugar de leerlos, y el único con anotaciones de tipo obligatorias (la firma la da el enunciado).

def ft_seed_inventory(seed_type: str, quantity: int, unit: str) -> None:
    if unit == "packets":
        unit = "packets available"
        covers = ""
    elif unit == "grams":
        unit = "grams total"
        covers = ""
    elif unit == "area":
        unit = "square meters"
        covers = "covers "
    else:
        print("Unknown unit type")
        return
    print(f"{seed_type.capitalize()} seeds: {covers}{quantity} {unit}")

La cadena if/elif/else prepara dos trozos de texto — el sufijo y un posible prefijo «covers » — y un único print final los compone. La unidad desconocida sale antes con return. Comparar cadenas con == funciona directamente: nada de ft_strcmp. capitalize() es un método del propio objeto cadena: pone la primera letra en mayúscula.

>>> ft_seed_inventory("tomato", 15, "packets")
Tomato seeds: 15 packets available
>>> ft_seed_inventory("carrot", 8, "grams")
Carrot seeds: 8 grams total
>>> ft_seed_inventory("lettuce", 12, "area")
Lettuce seeds: covers 12 square meters
>>> ft_seed_inventory("x", 1, "kg")
Unknown unit type

Un detalle: el parámetro unit se reutiliza para guardar el texto de salida. Funciona porque es una variable local; mypy no protesta porque sigue siendo un str.

Qué te obliga a aprender — Las anotaciones de tipo: la vuelta de los tipos de C, pero opcionales y sin efecto en tiempo de ejecución. Python ignora : int al ejecutar — puedes pasar una cadena y nadie se queja —; es mypy quien las lee y avisa antes de ejecutar, como haría un compilador. Y los métodos: en Python todo es un objeto, y una cadena trae sus propias funciones ("lettuce".capitalize()), un anticipo de la orientación a objetos del módulo siguiente.

?Preguntas probables de la evaluación

Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace al ejercicio donde está explicado. Están agrupadas en: reglas del módulo, tipos y conversiones, y recursión y anotaciones. Antes de mirar la respuesta, intenta contestar tú.

Reglas del módulo

¿Por qué los ficheros no llaman a su función ni tienen if __name__ == "__main__":?

Porque lo prohíbe el enunciado: cada fichero contiene solo la función pedida. La prueba la hace main.py, que importa el módulo y llama a la función; si el fichero tuviera código suelto, se ejecutaría al importarlo. → módulo e import

Pasa flake8 delante de mí. ¿Qué comprueba?

El estilo PEP 8: sangría de 4 espacios, líneas de 79 caracteres como mucho, dos líneas en blanco entre definiciones, nada de espacios al final… Los nueve ficheros pasan sin avisos. Es el equivalente de la norminette para Python. → flake8

¿Qué pasa si escribo abc cuando pide un número?

int("abc") lanza ValueError y el programa se para con un traceback. Es lo esperado: el enunciado dice que no hace falta validar la entrada y que con entradas inválidas o negativas el comportamiento no está definido. → ex2

Tipos y conversiones

¿Por qué hace falta int() si el usuario escribe un número?

Porque input siempre devuelve una cadena. Sin convertir, * entre dos cadenas da TypeError, + las concatena ("5" + "8" + "3" es "583") y > entre cadena y entero da TypeError. → ex2, ex3

En ex2 conviertes al leer y en ex3 al sumar. ¿Hay diferencia?

En el resultado, no. Cambia cuándo existe el número: en ex2 length ya es un entero; en ex3 a sigue siendo una cadena y int(a) crea un entero nuevo en la suma. Un dato no válido falla igual en los dos, solo que en ex3 después de leer los tres. → ex3

En ex4, ¿qué sale con 60 días?

«Plant needs more time to grow.». El enunciado dice más de 60 días, así que la condición es age > 60, no >=. Lo mismo en ex5 con los 2 días. → ex4

Recursión y anotaciones

Explícame la versión recursiva de ex6. ¿Por qué sale en orden creciente?

La primera llamada no recibe argumento (days es None): pide el número y se marca como primera. Cada llamada con day > 0 llama con day - 1 y después imprime su día, así que primero se baja hasta 0 y luego, al volver, salen 1, 2, 3… Solo la primera imprime «Harvest time!». → ex6

¿Hay algún caso en que la recursiva falle y la iterativa no?

Sí, con números grandes. Python limita la recursión a unas 1000 llamadas: probado llamando a la función directamente, con 998 días funciona y con 999 da RecursionError. La iterativa cuenta lo que haga falta. → ex6

¿Por qué days is None y no days == None?

Porque None es un único objeto y lo que se quiere saber es si days es ese objeto. is compara identidad y no se puede redefinir; == compara valor y una clase podría cambiar lo que significa. PEP 8 pide is para None. → None

¿Qué hace : int en ex7 si llamo con una cadena?

Nada al ejecutar: Python ignora las anotaciones. Si seed_type fuera un número, fallaría .capitalize() con AttributeError. Quien las usa es mypy, que avisaría antes de ejecutar si el código llamara a la función con un tipo equivocado. → ex7

¿Pasa mypy --strict?

ex7 sí. El repo entero no: da 9 errores en ex0–ex6, porque no tienen anotaciones, y el enunciado las deja como opcionales en esos ejercicios. Con mypy sin flags pasa todo. Si te lo piden, basta añadir -> None a cada función y anotar days en ex6. → anotaciones