«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.
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.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.
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.
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".
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.
returndef 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.
importCada 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.
NoneEl 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.
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.
input y la entrada estándarinput(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.
str) y métodoUna 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'.
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}".
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.
if, elif y elseif 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 rangeEl 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!».
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.
RecursionErrorCada 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.
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.
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.
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).
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.
print no está sangrada, el programa ni arranca (IndentationError).
Y que print no es write: ni descriptor, ni longitud, ni
"\n" a mano.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.
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.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.
"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.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.
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.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.")
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.
"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.Contar de 1 a n y terminar con «Harvest time!», dos veces: con un bucle y con recursión.
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).
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.
None, el «no hay valor» que sustituye a
NULL (y que se compara con is, no con ==).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.
: 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.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ú.
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
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
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
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 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
«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
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
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
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
: 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
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