Cursus — Python Module 01 hecho, sin entregar

«Code Cultivation»: del programa suelto a las clases. El mismo huerto del módulo anterior, ahora modelado con objetos. Los siete ejercicios están hechos y aquí están explicados uno a uno, con su código y la salida real; falta subirlos al repositorio y entregarlos.

Estado: ex0–ex6 terminados: los siete se ejecutan sin errores, su salida reproduce la del enunciado, mypy no da ningún error y flake8 solo avisa de W191 (las tabulaciones, que son a propósito). Falta el paso de git: ex0–ex2 tienen cambios sin commitear y ex3–ex6 aún no están añadidos al repositorio.

De funciones sueltas a objetos — En el Module 00 cada fichero era una sola función y estaba prohibido el bloque if __name__ == "__main__":. Este módulo cambia las reglas: ahora cada fichero es un programa que se ejecuta con python3 fichero.py, el bloque __main__ está permitido y, desde ex1, todo debe ir en clases. Las anotaciones de tipo pasan a ser obligatorias en todas las funciones y métodos (se comprueban con mypy), y sigue mandando flake8. La progresión del enunciado va paso a paso: variables sueltas → una clase → métodos que cambian el estado → constructor → encapsulación → herencia → métodos estáticos y de clase. Viniendo de C, la clase es lo que harías con un struct y un puñado de funciones que reciben un puntero a él, solo que aquí datos y funciones viajan juntos y el puntero se llama self.

GGlosario de teoría

La programación orientada a objetos trae mucho vocabulario nuevo. Aquí está cada término explicado desde cero y con un ejemplo sacado del propio huerto del módulo. 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 programa y sus herramientas

__name__ y "__main__"

Python no tiene una función main por la que empiece todo: ejecuta el fichero de arriba abajo. Antes de empezar, rellena por su cuenta una variable llamada __name__. Si el fichero se ejecuta directamente (python3 ft_garden_intro.py) vale "__main__"; si otro fichero lo importa (import ft_garden_intro), vale el nombre del módulo, "ft_garden_intro".

Por eso if __name__ == "__main__": significa «esto solo cuando me ejecutan, no cuando me importan». Sirve para que un fichero pueda ofrecer su clase Plant a otros sin soltar por pantalla su demostración del huerto cada vez que alguien lo importa.

Shebang (#!)

Una primera línea que empieza por #! y le dice al sistema operativo con qué programa abrir el fichero. Con #!/usr/bin/env python3 arriba y permiso de ejecución (chmod +x ft_garden_intro.py) se puede lanzar como ./ft_garden_intro.py, sin escribir python3 delante. env busca python3 en el PATH, así que funciona aunque Python no esté en la misma ruta en todos los puestos. Para Python es un simple comentario. El nombre viene de hash (#) y bang (!), y el truco viene de Unix, de finales de los años setenta.

Anotaciones de tipo (type hints)

Indicaciones escritas en la firma de una función de qué tipos espera y qué devuelve: def grow(self, growth_amount: float) -> None dice «recibe un número decimal y no devuelve nada». Python no las comprueba al ejecutar: si le pasas una cadena a grow, el programa intenta seguir igual. Las comprueba una herramienta aparte, mypy, antes de ejecutar. En este módulo son obligatorias en todas las funciones y métodos. Un tipo puede ir entre comillas (-> "Plant") cuando la clase todavía no está definida del todo en ese punto del fichero.

flake8 y mypy

Dos revisores automáticos que leen el código sin ejecutarlo. flake8 vigila el estilo (la guía PEP 8): líneas de más de 79 caracteres, dos líneas en blanco entre funciones, espacios sobrantes… En este repositorio los .py llevan tabulaciones a propósito, y por eso flake8 solo protesta con W191 («indentación con tabuladores»). mypy comprueba los tipos: si get_height() promete devolver float y en algún camino devuelve una cadena, lo dice antes de que el programa llegue a ejecutarse. Es lo más parecido al compilador de C que hay en Python.

Coma flotante y round()

Los float se guardan en binario, y muchos decimales que en base 10 son exactos (0.8, 2.1) en binario tienen infinitas cifras y se guardan redondeados. El error es minúsculo, pero al sumar muchas veces se acumula: sumar 0.8 siete veces a 25.0 da 27.400000000000002 al tercer día y 30.600000000000005 al séptimo. round(x, 1) redondea a un decimal y lo deja en el número más cercano a lo que esperas, que es lo que se imprime. Es el mismo double de C; allí lo ocultaba el %.1f de printf.

Clases y objetos

Clase

Un molde que describe cómo es y qué sabe hacer un tipo de cosa. class Plant: dice que toda planta tiene nombre, altura y edad, y que sabe mostrarse, crecer y envejecer. La clase no es ninguna planta concreta: es la receta. En C sería un typedef struct más las funciones que trabajan con él, pero metidas en el mismo sitio. Por convención los nombres de clase van en PascalCase (Plant, TreeStats) y el resto en snake_case.

Objeto o instancia

Cada cosa concreta fabricada con el molde. rose = Plant() y oak = Plant() son dos objetos de la misma clase: comparten los métodos, pero cada uno guarda sus propios datos, y cambiar la altura de la rosa no toca la del roble. Instanciar es fabricar un objeto llamando a la clase como si fuera una función. Python libera el objeto solo cuando ya nadie lo usa: no hay malloc ni free.

Atributo

Una variable que vive dentro de un objeto: rose.height, rose.days. Es el campo de un struct, pero con una diferencia importante: en Python se pueden crear en cualquier momento con solo asignarlos (rose.color = "red"), aunque la clase no los mencione. Por eso conviene crearlos todos en __init__, para que estén siempre y para que mypy sepa de qué tipo es cada uno. Atributos y métodos comparten el mismo espacio de nombres: un atributo age tapa al método age().

Método

Una función definida dentro de una clase, que trabaja sobre un objeto concreto: rose.show(), rose.grow(0.8). Lo que en C sería plant_grow(&rose, 0.8). Python lo convierte en Plant.grow(rose, 0.8): el objeto de delante del punto llega como primer parámetro, que es self.

self

El primer parámetro de todo método normal: el objeto sobre el que se ha llamado. Dentro de grow, self.height es la altura de esta planta, la rosa si se llamó rose.grow(…). Es el puntero al struct que en C pasabas a mano (t_list *lst). self no es una palabra reservada, solo una convención que sigue todo el mundo.

Constructor (__init__)

El método que Python llama solo al crear un objeto, para dejarlo preparado. Plant("Rose", 25.0, 30) fabrica un objeto vacío y llama a __init__(objeto, "Rose", 25.0, 30), que guarda los datos en sus atributos. Si __init__ no recibe nada (como en ex1), el objeto nace con valores por defecto y los datos se ponen después, uno a uno. Los nombres con dos guiones bajos delante y detrás (dunder, de double underscore) son métodos especiales que Python llama por su cuenta en momentos concretos.

Estado

Los valores que tienen en un momento dado los atributos de un objeto. La rosa empieza en «25.0 cm, 30 días» y, tras siete llamadas a grow, su estado es «30.6 cm, 37 días». Los métodos que cambian el estado (grow, age, set_height) son la razón de tener objetos y no solo datos sueltos.

Proteger los datos

Encapsulación

Esconder los datos de un objeto y dejar que solo se cambien a través de sus métodos, para que el objeto pueda vigilar que siempre tengan sentido. Si cualquiera puede escribir rose.height = -25, la planta acaba con una altura imposible; si solo se puede usar set_height(-25), el método rechaza el valor y la planta sigue sana.

Atributo «protegido» (_) y name mangling (__)

Python no tiene private de verdad. Un guion bajo delante (self._height) es una convención: «esto es interno, no lo toques desde fuera». Nada lo impide (ni Python ni flake8 protestan), pero los programadores lo respetan; y las clases hijas sí pueden usarlo, por eso se llama «protegido». Con dos guiones bajos (self.__height) Python renombra el atributo por dentro a _Plant__height: eso es el name mangling, que dificulta el acceso (también a las hijas). El enunciado de ex4 pide la convención de un guion y no el mangling.

Getter y setter

Los dos métodos que dan acceso controlado a un atributo protegido. El getter (get_height()) lo devuelve; el setter (set_height(valor)) lo cambia, pero solo después de comprobar que el valor es válido. Toda la validación queda en un único sitio.

Herencia

Herencia, clase madre y clase hija

Crear una clase a partir de otra: class Flower(Plant): dice que una flor es una planta, así que recibe todos sus atributos y métodos sin volver a escribirlos y solo añade lo suyo (el color, florecer). Plant es la clase madre (o base) y Flower la hija (o derivada). Se puede encadenar: Seed hereda de Flower, que hereda de Plant. La prueba de que se ha usado bien es que el código común está escrito una sola vez.

super()

Da acceso a los métodos de la clase madre desde la hija. En el constructor de Flower, super().__init__(name, height, age) deja que Plant prepare el nombre, la altura y la edad, y luego la flor añade su color. Sin esa llamada, la flor no tendría altura. También sirve en cualquier otro método: super().show() imprime la línea normal de planta antes de añadir el color.

Sobrescritura (override)

Cuando una clase hija define un método con el mismo nombre que uno de su madre, el de la hija sustituye al heredado para sus objetos. Flower.show() sobrescribe a Plant.show(); Vegetable.age() sobrescribe a Plant.age() para sumar además valor nutricional. Con super() el método nuevo puede reutilizar el viejo en lugar de copiarlo.

Polimorfismo y despacho dinámico

Una misma llamada hace cosas distintas según la clase real del objeto. Python decide qué método ejecutar en el momento de la llamada, mirando primero en la clase del objeto y subiendo después por sus madres. Por eso, cuando Plant.grow llama a self.age(1) con un tomate, se ejecuta Vegetable.age aunque el código esté escrito en Plant; y una función que recibe «cualquier planta» funciona igual con una rosa, un roble o una semilla. En C se simula con punteros a función (como una tabla de dispatch).

Más allá del método normal

Decorador (@)

Una línea con @algo justo encima de un def, que transforma la función que viene debajo. @staticmethod encima de def older_year es lo mismo que escribir después older_year = staticmethod(older_year). El enunciado de ex6 acepta las dos formas.

Método estático (@staticmethod)

Una función que vive dentro de la clase porque tiene que ver con ella, pero que no recibe ni el objeto (self) ni la clase. Plant.older_year(400) responde si 400 días son más de un año sin necesitar ninguna planta concreta. Es una función normal guardada en el «cajón» de Plant.

Método de clase (@classmethod)

Un método que recibe la clase en lugar del objeto, en un primer parámetro que por convención se llama cls. Su uso típico es como constructor alternativo: Plant.anonymous() devuelve cls("Unknown plant", 0.0, 0), una planta con valores por defecto para cuando aún no se sabe nada de ella. Como cls es la clase con la que se llamó, Flower.anonymous() intentaría fabricar una flor.

Clase anidada

Una clase definida dentro de otra: class Stats: dentro de Plant. Desde fuera se nombra Plant.Stats. No crea ningún vínculo mágico entre los objetos de las dos clases: solo ordena el código y deja claro que las estadísticas son una pieza interna de la planta. Cada planta guarda su propio objeto Stats en un atributo.

ex0ft_garden_intro

Entrega: ft_garden_intro.pyAutorizado: print()
if __name__ == "__main__":
	name = "Rose"
	height = 25
	age = 30
	print("=== Welcome to My Garden ===")
	print(f"Plant: {name}")
	print(f"Height: {height}cm")
	print(f"Age: {age} days")
	print("=== End of Program ===")
$> python3 ft_garden_intro.py
=== Welcome to My Garden ===
Plant: Rose
Height: 25cm
Age: 30 days
=== End of Program ===

Tres variables simples y unos print, todo dentro del bloque __main__. La altura y la edad se guardan como números (25, 30) y las unidades se añaden solo al imprimir, dentro de la f-string (f"Height: {height}cm"): es la forma de guardar datos con la que luego se podrá calcular. Respecto al ejemplo del enunciado solo falta la línea en blanco antes de «=== End of Program ===»; el enunciado avisa de que la salida no se comprueba de forma estricta.

Qué te obliga a aprender — Dónde empieza un programa en Python. En C la respuesta era fija: main. En Python no hay función principal: el intérprete ejecuta el fichero de arriba abajo. __name__ es una variable que Python rellena solo: vale "__main__" si el fichero se ejecuta directamente, y el nombre del módulo si otro fichero lo importa. El if sirve para que el código de prueba no se ejecute al importar — justo lo que hacía el main.py del módulo anterior con tus funciones. El enunciado anuncia además que en la evaluación habrá que añadir en directo la línea shebang (#!/usr/bin/env python3), que permite ejecutar el script como ./ft_garden_intro.py tras darle permiso de ejecución.

ex1ft_garden_data

Entrega: ft_garden_data.pyAutorizado: print()
class Plant:
	def __init__(self) -> None:
		self.name = ""
		self.height = 0
		self.days = 0

	def show(self) -> None:
		print(f"{self.name}: {self.height}cm, {self.days} days old")


if __name__ == "__main__":
	rose = Plant()
	rose.name = "Rose"
	rose.height = 25
	rose.days = 30
	sunflower = Plant()
	sunflower.name = "Sunflower"
	sunflower.height = 80
	sunflower.days = 45
	cactus = Plant()
	cactus.name = "Cactus"
	cactus.height = 15
	cactus.days = 120
	print("=== Garden Plant Registry ===")
	rose.show()
	sunflower.show()
	cactus.show()
$> python3 ft_garden_data.py
=== Garden Plant Registry ===
Rose: 25cm, 30 days old
Sunflower: 80cm, 45 days old
Cactus: 15cm, 120 days old

Una clase Plant con un constructor __init__ que no recibe datos: deja cada atributo con un valor por defecto (cadena vacía y ceros). Después, en el bloque principal, se instancia cada planta y se le asignan sus datos uno a uno, que es exactamente lo que describe el enunciado: «la clase se instancia y luego se dan valor a los atributos». El método show imprime la ficha y añade las unidades; rose.show() es azúcar para Plant.show(rose).

Dos detalles que preparan los ejercicios siguientes: la edad se llama days y no age, de modo que no chocará con el método age() que pide ex2 (un atributo y un método con el mismo nombre se tapan); y los valores por defecto le sirven a mypy para saber que height y days son enteros. Los dos métodos llevan ya sus anotaciones de tipo (-> None: no devuelven nada), obligatorias en todo el módulo.

Qué te obliga a aprender — La idea de clase como molde: un único modelo para todas las plantas en lugar de tres juegos de variables sueltas. Es el struct de C con las funciones dentro: self hace el papel del puntero al struct que en C pasabas a mano (t_list *lst), y __init__ el de la función que reservaba e inicializaba el nodo — pero sin malloc: Python crea el objeto y lo libera cuando nadie lo usa. Y deja ver el problema que resolverá ex3: tres líneas de asignación por planta no escalan cuando el huerto crece.

ex2ft_plant_growth

Entrega: ft_plant_growth.pyAutorizado: print(), range(), round()
class Plant:
	def __init__(self) -> None:
		self.name = ""
		self.height = 0.0
		self.days = 0

	def show(self) -> None:
		print(f"{self.name}: {self.height}cm, {self.days} days old")

	def grow(self, growth_amount: float) -> None:
		self.height = round(self.height + growth_amount, 1)
		self.age(1)

	def age(self, days: int) -> None:
		self.days += days


def main() -> None:
	print("=== Garden Plant Growth ===")
	rose = Plant()
	rose.name = "Rose"
	rose.height = 25.0
	rose.days = 30
	start_height = rose.height
	rose.show()
	for day in range(1, 8):
		print(f"=== Day {day} ===")
		rose.grow(0.8)
		rose.show()
	print(f"Growth this week: {round(rose.height - start_height, 1)}cm")


if __name__ == "__main__":
	main()
$> python3 ft_plant_growth.py
=== Garden Plant Growth ===
Rose: 25.0cm, 30 days old
=== Day 1 ===
Rose: 25.8cm, 31 days old
=== Day 2 ===
Rose: 26.6cm, 32 days old
=== Day 3 ===
Rose: 27.4cm, 33 days old
=== Day 4 ===
Rose: 28.2cm, 34 days old
=== Day 5 ===
Rose: 29.0cm, 35 days old
=== Day 6 ===
Rose: 29.8cm, 36 days old
=== Day 7 ===
Rose: 30.6cm, 37 days old
Growth this week: 5.6cm

La clase de ex1 con dos métodos nuevos que cambian el estado de la planta. age(days) suma días a self.days. grow(growth_amount) suma la altura y, además, llama a self.age(1): en este diseño crecer un día implica envejecer un día, y así el bucle solo necesita una llamada por día. La altura pasa a ser 0.0 por defecto, un float, porque ahora crece de 0.8 en 0.8.

El programa principal está en una función main() llamada desde el bloque __main__. Guarda la altura inicial en start_height, recorre los días con range(1, 8) (del 1 al 7: el final no se incluye) y al acabar resta para el resumen. Que el crecimiento sea un parámetro de grow es lo que permite que «distintas plantas evolucionen de forma distinta», como sugiere el enunciado: a cada una se le puede pasar su ritmo.

El round(…, 1) no es decoración: sin él la salida sería Rose: 27.400000000000002cm al tercer día y el resumen diría 5.600000000000005cm, por cómo se guarda la coma flotante. Por eso se redondea en cada paso y también en la resta final.

Qué te obliga a aprender — Que un objeto tiene estado y que los métodos lo cambian: tras grow() la planta ya no es la misma. Que un método puede llamar a otro método del mismo objeto a través de self. Y la lección de guardar los datos en la forma con la que se calcula (números) y convertirlos a texto solo al mostrarlos: en una versión anterior la altura era la cadena "25cm" y cada método tenía que desmontarla y volver a montarla. Atributos y métodos viven en el mismo espacio de nombres de un objeto, así que un atributo age habría tapado al método age(): llamarlo days evita el choque.

ex3ft_plant_factory

Entrega: ft_plant_factory.pyAutorizado: print(), range(), round()
class Plant:
	def __init__(self, name: str, height: float, days: int) -> None:
		self.name = name
		self.height = height
		self.days = days

	def show(self) -> None:
		print(f"{self.name}: {self.height}cm, {self.days} days old")

	def grow(self, growth_amount: float) -> None:
		self.height = round(self.height + growth_amount, 1)
		self.age(1)

	def age(self, days: int) -> None:
		self.days += days


def main() -> None:
	print("=== Plant Factory Output ===")
	plants = [
		Plant("Rose", 25.0, 30),
		Plant("Oak", 200.0, 365),
		Plant("Cactus", 5.0, 90),
		Plant("Sunflower", 80.0, 45),
		Plant("Fern", 15.0, 120),
	]
	for plant in plants:
		print("Created: ", end="")
		plant.show()


if __name__ == "__main__":
	main()
$> python3 ft_plant_factory.py
=== Plant Factory Output ===
Created: Rose: 25.0cm, 30 days old
Created: Oak: 200.0cm, 365 days old
Created: Cactus: 5.0cm, 90 days old
Created: Sunflower: 80.0cm, 45 days old
Created: Fern: 15.0cm, 120 days old

El constructor ahora recibe los datos iniciales (name, height, days) y los guarda: cada planta nace completa en una sola expresión, Plant("Oak", 200.0, 365), lista para usar grow() sin más pasos. Las cinco plantas se fabrican dentro de una lista y un bucle las muestra todas.

print("Created: ", end="") imprime el prefijo sin salto de línea (end es lo que print añade al final, "\n" si no se dice nada), y a continuación show() completa la línea. Así se cumple la nota del enunciado: show() se usa sin cambiarlo. grow y age siguen en la clase aunque este programa no los llame: es la misma clase, mejorada, no una nueva.

Qué te obliga a aprender — Para qué sirve de verdad el constructor: garantizar que ningún objeto exista a medio hacer. En ex1 había un momento en que la rosa existía con nombre vacío y altura 0; aquí no. Es la diferencia entre malloc + rellenar los campos a mano y una función ft_lstnew que devuelve el nodo ya inicializado. Y, de paso, que los objetos se pueden guardar en listas y recorrer como cualquier otro valor.

ex4ft_garden_security

Entrega: ft_garden_security.pyAutorizado: print(), range(), round()
class Plant:
	def __init__(self, name: str, height: float, age: int) -> None:
		self.name = name
		self._height = height
		self._age = age
		if height < 0 or age < 0:
			print(f"{self.name}: Error, height and age can't be negative")
			if height < 0:
				self._height = 0.0
			if age < 0:
				self._age = 0

	def set_height(self, height: float) -> None:
		if height >= 0:
			self._height = height
			print(f"Height updated: {self._height}cm")
		else:
			print(f"{self.name}: Error, height can't be negative")
			print("Height update rejected")

	def set_age(self, age: int) -> None:
		if age >= 0:
			self._age = age
			print(f"Age updated: {self._age} days")
		else:
			print(f"{self.name}: Error, age can't be negative")
			print("Age update rejected")

	def get_height(self) -> float:
		return (self._height)

	def get_age(self) -> int:
		return (self._age)

	def show(self) -> None:
		print(f"{self.name}: {self._height}cm, {self._age} days old")

	def grow(self, growth_amount: float) -> None:
		self._height = round(self._height + growth_amount, 1)
		self.age(1)

	def age(self, days: int) -> None:
		self._age += days


def main() -> None:
	print("=== Garden Security System ===")
	rose = Plant("Rose", 15.0, 10)
	print("Plant created: ", end="")
	rose.show()
	rose.set_height(25.0)
	rose.set_age(30)
	rose.set_height(-25.0)
	rose.set_age(-30)
	print("Current state: ", end="")
	rose.show()


if __name__ == "__main__":
	main()
$> python3 ft_garden_security.py
=== Garden Security System ===
Plant created: Rose: 15.0cm, 10 days old
Height updated: 25.0cm
Age updated: 30 days
Rose: Error, height can't be negative
Height update rejected
Rose: Error, age can't be negative
Age update rejected
Current state: Rose: 25.0cm, 30 days old

La altura y la edad pasan a ser atributos protegidos, _height y _age, y solo se tocan a través de métodos de la clase. Los setters set_height y set_age validan antes de guardar: con un valor negativo imprimen el error y dejan el dato como estaba, que es lo que se ve en «Current state: Rose: 25.0cm, 30 days old». Los getters devuelven el valor sin más. El constructor también valida: si una planta nace con datos negativos, avisa y pone 0.0 o 0 en el dato malo («crear la planta con valores por defecto», la otra opción que da el enunciado).

Comparado con el ejemplo, cambian dos detalles que no se comprueban de forma estricta: «Height updated: 25.0cm» en lugar de «25cm» (porque se le pasa 25.0) y faltan las líneas en blanco entre los bloques. Los paréntesis de return (self._height) son costumbre de la norma de C; en Python sobran, pero no molestan.

Un hueco en la protección: grow y age escriben directamente en _height y _age sin validar. rose.grow(-50) deja la rosa en -35.0cm y rose.age(-100) en -89 days, justo lo que el ejercicio quiere impedir. El enunciado no pide validar esos métodos, pero es fácil que en la evaluación te pregunten si se puede corromper la planta de otra manera.

Qué te obliga a aprender — La encapsulación: un objeto no es solo un saco de datos, también es responsable de que esos datos tengan sentido. Y que en Python esa protección es un pacto entre programadores, no un muro: el guion bajo no impide escribir rose._height = -1, solo avisa de que no se debe. Lo que de verdad protege es que todo el código de la clase pase por los mismos puntos de control, y por eso conviene que todos los caminos que cambian un dato (también grow) pasen por su setter.

ex5ft_plant_types

Entrega: ft_plant_types.pyAutorizado: super(), print(), range(), round()
class Plant:
	def __init__(self, name: str, height: float, age: int) -> None:
		self.name = name
		self._height = height
		self._age = age
		if height < 0 or age < 0:
			print(f"{self.name}: Error, height and age can't be negative")
			if height < 0:
				self._height = 0.0
			if age < 0:
				self._age = 0

	def set_height(self, height: float) -> None:
		if height >= 0:
			self._height = height
			print(f"Height updated: {self._height}cm")
		else:
			print(f"{self.name}: Error, height can't be negative")
			print("Height update rejected")

	def set_age(self, age: int) -> None:
		if age >= 0:
			self._age = age
			print(f"Age updated: {self._age} days")
		else:
			print(f"{self.name}: Error, age can't be negative")
			print("Age update rejected")

	def get_height(self) -> float:
		return (self._height)

	def get_age(self) -> int:
		return (self._age)

	def show(self) -> None:
		print(f"{self.name}: {self._height}cm, {self._age} days old")

	def grow(self, growth_amount: float) -> None:
		self._height = round(self._height + growth_amount, 1)
		self.age(1)

	def age(self, days: int) -> None:
		self._age += days


class Flower(Plant):
	def __init__(
			self, name: str, height: float, age: int,
			color: str
	) -> None:
		super().__init__(name, height, age)
		self._color = color
		self._bloom = False

	def show(self) -> None:
		super().show()
		print(f" Color: {self._color}")
		if self._bloom:
			print(f" {self.name} is blooming beautifully!")
		else:
			print(f" {self.name} has not bloomed yet")

	def bloom(self) -> None:
		self._bloom = True


class Tree(Plant):
	def __init__(
			self, name: str, height: float, age: int,
			trunk_diameter: float
	) -> None:
		super().__init__(name, height, age)
		self._trunk_diameter = trunk_diameter

	def produce_shade(self) -> None:
		print(
			f"Tree {self.name} now produces a shade of {self._height}cm "
			f"long and {self._trunk_diameter}cm wide."
		)

	def show(self) -> None:
		super().show()
		print(f" Trunk diameter: {self._trunk_diameter}cm")


class Vegetable(Plant):
	def __init__(
			self, name: str, height: float, age: int,
			harvest_season: str
	) -> None:
		super().__init__(name, height, age)
		self._harvest_season = harvest_season
		self._nutritional_value = 0

	def show(self) -> None:
		super().show()
		print(f" Harvest season: {self._harvest_season}")
		print(f" Nutritional value: {self._nutritional_value}")

	def age(self, days: int) -> None:
		super().age(days)
		self._nutritional_value += days


def main() -> None:
	print("=== Garden Plant Types ===")
	print("=== Flower")
	rose = Flower("Rose", 15.0, 10, "red")
	rose.show()
	print("[asking the rose to bloom]")
	rose.bloom()
	rose.show()
	print()
	print("=== Tree")
	oak = Tree("Oak", 200.0, 365, 5.0)
	oak.show()
	print("[asking the oak to produce shade]")
	oak.produce_shade()
	print()
	print("=== Vegetable")
	tomato = Vegetable("Tomato", 5.0, 10, "April")
	tomato.show()
	print("[make tomato grow and age for 20 days]")
	for _ in range(20):
		tomato.grow(2.1)
	tomato.show()


if __name__ == "__main__":
	main()
$> python3 ft_plant_types.py
=== Garden Plant Types ===
=== Flower
Rose: 15.0cm, 10 days old
 Color: red
 Rose has not bloomed yet
[asking the rose to bloom]
Rose: 15.0cm, 10 days old
 Color: red
 Rose is blooming beautifully!

=== Tree
Oak: 200.0cm, 365 days old
 Trunk diameter: 5.0cm
[asking the oak to produce shade]
Tree Oak now produces a shade of 200.0cm long and 5.0cm wide.

=== Vegetable
Tomato: 5.0cm, 10 days old
 Harvest season: April
 Nutritional value: 0
[make tomato grow and age for 20 days]
Tomato: 47.0cm, 30 days old
 Harvest season: April
 Nutritional value: 20

Plant es la de ex4 sin cambios, y sobre ella se montan tres clases hijas por herencia: Flower (color y bloom()), Tree (diámetro del tronco y produce_shade()) y Vegetable (temporada de cosecha y valor nutricional, que empieza en 0). Ninguna repite el código común: cada constructor llama primero a super().__init__(...) para que Plant guarde nombre, altura y edad (y los valide), y luego añade sus propios atributos.

Las tres sobrescriben show() llamando primero a super().show(), que imprime la línea normal de planta, y añaden debajo sus características con un espacio delante. La firma de los constructores ocupa varias líneas (con la indentación extra de flake8) para no pasar de 79 caracteres.

El tomate es el caso interesante. Vegetable sobrescribe age(): llama a la de Plant y además suma los días al valor nutricional. El bucle solo llama 20 veces a grow(2.1), pero Plant.grow termina con self.age(1), y como self es un tomate se ejecuta Vegetable.age: por despacho dinámico, 20 llamadas a grow dan 20 días más y 20 puntos de valor nutricional. 5.0 + 20 × 2.1 = 47.0, y sale exacto gracias al round de cada paso (sin él serían 47.000000000000014).

Qué te obliga a aprender — A organizar el código por parentesco: lo que comparten todas las plantas va una vez en la madre y cada hija solo escribe lo que la distingue. A extender un método sin copiarlo, con super(). Y la idea más potente de la orientación a objetos: el código de Plant llama a self.age sin saber qué clase de planta tiene delante, y aun así se ejecuta la versión correcta. En C eso exigiría guardar un puntero a función en cada struct.

ex6ft_garden_analytics

Entrega: ft_garden_analytics.pyAutorizado: super(), print(), range(), round(), staticmethod(), classmethod()
class Plant:
	class Stats:
		def __init__(self) -> None:
			self._grow_calls = 0
			self._age_calls = 0
			self._show_calls = 0

		def add_grow(self) -> None:
			self._grow_calls += 1

		def add_age(self) -> None:
			self._age_calls += 1

		def add_show(self) -> None:
			self._show_calls += 1

		def display(self) -> None:
			print(
				f"Stats: {self._grow_calls} grow, {self._age_calls} age, "
				f"{self._show_calls} show"
			)

	def __init__(self, name: str, height: float, age: int) -> None:
		self.name = name
		self._height = height
		self._age = age
		self._stats = Plant.Stats()
		if (height < 0 or age < 0):
			print("Error: Height and age must be greater or equal to 0")
			if (height < 0):
				self._height = 0.0
			if (age < 0):
				self._age = 0

	def set_height(self, height: float) -> None:
		if height >= 0:
			self._height = height
			print(f"Height updated: {self._height}cm")
		else:
			print(f"{self.name}: Error, height can't be negative")
			print("Height update rejected")

	def set_age(self, age: int) -> None:
		if age >= 0:
			self._age = age
			print(f"Age updated: {self._age} days")
		else:
			print(f"{self.name}: Error, age can't be negative")
			print("Age update rejected")

	def get_height(self) -> float:
		return (self._height)

	def get_age(self) -> int:
		return (self._age)

	def get_stats(self) -> "Plant.Stats":
		return (self._stats)

	def show(self) -> None:
		self._stats.add_show()
		print(f"{self.name}: {self._height}cm, {self._age} days old")

	def grow(self, growth_amount: float) -> None:
		self._stats.add_grow()
		self._height = round(self._height + growth_amount, 1)

	def age(self, days: int) -> None:
		self._stats.add_age()
		self._age += days

	@staticmethod
	def older_year(days: int) -> bool:
		return (days > 365)

	@classmethod
	def anonymous(cls) -> "Plant":
		return (cls("Unknown plant", 0.0, 0))


class Flower(Plant):
	def __init__(
			self, name: str, height: float, age: int,
			color: str
	) -> None:
		super().__init__(name, height, age)
		self._color = color
		self._bloom = False

	def show(self) -> None:
		super().show()
		print(f" Color: {self._color}")
		if (self._bloom):
			print(f" {self.name} is blooming beautifully!")
		else:
			print(f" {self.name} has not bloomed yet")

	def bloom(self) -> None:
		self._bloom = True


class Seed(Flower):
	def __init__(
			self, name: str, height: float, age: int, color: str,
			seed_number: int
	) -> None:
		super().__init__(name, height, age, color)
		self._seed_number = seed_number

	def show(self) -> None:
		super().show()
		if (self._bloom):
			print(f" Seeds: {self._seed_number}")
		else:
			print(" Seeds: 0")


class Tree(Plant):
	class TreeStats(Plant.Stats):
		def __init__(self) -> None:
			super().__init__()
			self._shade_calls = 0

		def add_shade(self) -> None:
			self._shade_calls += 1

		def display(self) -> None:
			super().display()
			print(f" {self._shade_calls} shade")

	def __init__(
			self, name: str, height: float, age: int,
			trunk_diameter: float
	) -> None:
		super().__init__(name, height, age)
		self._trunk_diameter = trunk_diameter
		self._tree_stats = Tree.TreeStats()
		self._stats = self._tree_stats

	def produce_shade(self) -> None:
		self._tree_stats.add_shade()
		print(
			f"Tree {self.name} now produces a shade of {self._height}cm "
			f"long and {self._trunk_diameter}cm wide."
		)

	def show(self) -> None:
		super().show()
		print(f" Trunk diameter: {self._trunk_diameter}cm")


class Vegetable(Plant):
	def __init__(
			self, name: str, height: float, age: int,
			harvest_season: str
	) -> None:
		super().__init__(name, height, age)
		self._harvest_season = harvest_season
		self._nutritional_value = 0

	def show(self) -> None:
		super().show()
		print(f" Harvest season: {self._harvest_season}")
		print(f" Nutritional value: {self._nutritional_value}")

	def age(self, days: int) -> None:
		super().age(days)
		self._nutritional_value += days


def display_statistics(plant: Plant) -> None:
	print(f"[statistics for {plant.name}]")
	plant.get_stats().display()


def main() -> None:
	print("=== Garden statistics ===")
	print("=== Check year-old")
	print(f"Is 30 days more than a year? -> {Plant.older_year(30)}")
	print(f"Is 400 days more than a year? -> {Plant.older_year(400)}")
	print()
	print("=== Flower")
	rose = Flower("Rose", 15.0, 10, "red")
	rose.show()
	display_statistics(rose)
	print("[asking the rose to grow and bloom]")
	rose.grow(8.0)
	rose.bloom()
	rose.show()
	display_statistics(rose)
	print()
	print("=== Tree")
	oak = Tree("Oak", 200.0, 365, 5.0)
	oak.show()
	display_statistics(oak)
	print("[asking the oak to produce shade]")
	oak.produce_shade()
	display_statistics(oak)
	print()
	print("=== Seed")
	sunflower = Seed("Sunflower", 80.0, 45, "yellow", 42)
	sunflower.show()
	print("[make sunflower grow, age and bloom]")
	sunflower.grow(30.0)
	sunflower.age(20)
	sunflower.bloom()
	sunflower.show()
	display_statistics(sunflower)
	print()
	print("=== Anonymous")
	unknown = Plant.anonymous()
	unknown.show()
	display_statistics(unknown)


if __name__ == "__main__":
	main()
$> python3 ft_garden_analytics.py
=== Garden statistics ===
=== Check year-old
Is 30 days more than a year? -> False
Is 400 days more than a year? -> True

=== Flower
Rose: 15.0cm, 10 days old
 Color: red
 Rose has not bloomed yet
[statistics for Rose]
Stats: 0 grow, 0 age, 1 show
[asking the rose to grow and bloom]
Rose: 23.0cm, 10 days old
 Color: red
 Rose is blooming beautifully!
[statistics for Rose]
Stats: 1 grow, 0 age, 2 show

=== Tree
Oak: 200.0cm, 365 days old
 Trunk diameter: 5.0cm
[statistics for Oak]
Stats: 0 grow, 0 age, 1 show
 0 shade
[asking the oak to produce shade]
Tree Oak now produces a shade of 200.0cm long and 5.0cm wide.
[statistics for Oak]
Stats: 0 grow, 0 age, 1 show
 1 shade

=== Seed
Sunflower: 80.0cm, 45 days old
 Color: yellow
 Sunflower has not bloomed yet
 Seeds: 0
[make sunflower grow, age and bloom]
Sunflower: 110.0cm, 65 days old
 Color: yellow
 Sunflower is blooming beautifully!
 Seeds: 42
[statistics for Sunflower]
Stats: 1 grow, 1 age, 2 show

=== Anonymous
Unknown plant: 0.0cm, 0 days old
[statistics for Unknown plant]
Stats: 0 grow, 0 age, 1 show

Las clases de ex5 ampliadas con todo lo que pide el enunciado:

La salida coincide línea a línea con el ejemplo del enunciado.

Dos cosas que pueden salir en la evaluación: como grow ya no llama a age, el tomate de esta versión solo gana valor nutricional con age() (en ex5 también crecía con grow()); y anonymous solo funciona llamada sobre Plant, porque cls es la clase con la que se llama y los constructores de las hijas piden un dato más: Tree.anonymous() lanza TypeError: Tree.__init__() missing 1 required positional argument: 'trunk_diameter'. Ninguna de las dos aparece en el programa, que funciona sin errores.

Qué te obliga a aprender — Que los métodos no tienen por qué trabajar sobre un objeto: los hay del objeto (self), de la clase (cls) y de ninguno de los dos, y elegir uno u otro dice algo de lo que hace. Que un objeto puede contener otros objetos (la planta y sus estadísticas): composición, además de herencia. Y que todo junto funciona como un sistema: la evaluación avisa de que te pedirá explicar cómo interactúan las piezas, por ejemplo qué pasa exactamente, clase por clase, cuando se llama a sunflower.show() (Seed.show → Flower.show → Plant.show, que cuenta una vez).

?Preguntas probables de la evaluación

Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a la sección donde está explicado. El enunciado avisa de que pueden pedirte explicar conceptos, enseñar las relaciones de herencia o ampliar el código en directo. Antes de mirar la respuesta, intenta contestar tú.

El programa

¿Para qué sirve if __name__ == "__main__":?

Para que el código de prueba solo se ejecute cuando lanzas el fichero directamente. Si otro fichero lo importa, __name__ vale el nombre del módulo y el bloque no se ejecuta: se puede reutilizar la clase Plant sin que imprima la demostración del huerto. → __name__, ex0

Añade el shebang y ejecútalo sin escribir python3.

Primera línea #!/usr/bin/env python3, luego chmod +x ft_garden_intro.py y ./ft_garden_intro.py. env busca python3 en el PATH, así que vale en cualquier puesto. → Shebang

¿Por qué usas round() en grow?

Porque 0.8 no es exacto en binario y el error se acumula: sin redondear, el tercer día saldría 27.400000000000002cm. Redondear a un decimal en cada paso deja la altura en el valor que se espera. → Coma flotante, ex2

Clases y encapsulación

¿Qué es self y qué hace __init__?

self es el objeto sobre el que se llama el método: rose.show() es Plant.show(rose). __init__ es el constructor: Python lo llama solo al hacer Plant(...) para dejar el objeto con sus atributos listos. En ex1 no recibe datos y se rellenan después; desde ex3 los recibe y la planta nace completa. → self, ex1, ex3

¿Por qué _height y no __height? ¿Se puede saltar?

El enunciado pide la convención «protegida», un solo guion bajo, y no el name mangling de dos. Sí se puede saltar (rose._height = -1 funciona): es un pacto, no un muro. Lo que protege es que la clase solo cambie el dato tras validarlo en los setters. → Protegido, ex4

¿Hay alguna forma de dejar una planta con altura negativa?

Sí, sin tocar los atributos: grow y age no validan, y rose.grow(-50) deja la rosa en -35.0cm. Se arreglaría haciendo que pasen por la misma validación que los setters. → ex4

Herencia

¿Qué pasa si quitas super().__init__(...) del constructor de Flower?

Que nunca se ejecuta el __init__ de Plant: la flor tendría color pero no name, _height ni _age, y show() fallaría con AttributeError. super() es lo que evita copiar el código común en cada hija. → super(), ex5

Si el bucle solo llama a grow, ¿por qué sube el valor nutricional del tomate?

Porque Plant.grow llama a self.age(1) y self es un Vegetable, así que se ejecuta su age sobrescrito, que suma también al valor nutricional. Python elige el método según la clase real del objeto. → Polimorfismo, ex5

Dibuja las relaciones de herencia de ex6.

Plant ← Flower ← Seed; Plant ← Tree; Plant ← Vegetable. Y, aparte, las estadísticas: Plant.Stats ← Tree.TreeStats. Las clases Stats están anidadas, pero eso no es herencia: cada planta tiene un objeto de estadísticas. → ex6

Métodos especiales

¿Qué diferencia hay entre @staticmethod y @classmethod?

El estático no recibe ni objeto ni clase: older_year solo compara un número. El de clase recibe la clase en cls y puede fabricar objetos con ella: anonymous devuelve cls("Unknown plant", 0.0, 0). Ninguno necesita una planta ya creada. → Estático, De clase, ex6

¿Cómo muestra display_statistics la sombra solo en los árboles?

No lo decide ella: llama a plant.get_stats().display(), y el objeto de estadísticas de un árbol es un TreeStats, cuyo display sobrescrito añade la línea de sombra. La función funciona con cualquier planta sin preguntar su tipo. → ex6

Te piden en directo una nueva estadística, por ejemplo cuántas veces florece una flor.

El patrón ya está en el árbol: una clase de estadísticas hija de Plant.Stats con su contador y su display, puesta en el constructor de Flower, y una llamada a su add_… dentro de bloom(). → ex6