«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.
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.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.
__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.
#!)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.
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.
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.
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.
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.
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.
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().
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.
selfEl 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.
__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.
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.
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.
_) 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.
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.
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.
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.
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).
@)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.
@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.
@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.
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.
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.
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.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.
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.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.
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.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.
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.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.
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.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).
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.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:
Plant.Stats guarda tres contadores protegidos y solo deja sumarles uno
(add_grow, add_age, add_show) o mostrarlos
(display): encapsulación. Cada planta crea la suya en el constructor y
show, grow y age la avisan cada vez que se llaman.
Ahora grow ya no llama a age(1): si lo hiciera, la rosa marcaría
«1 grow, 1 age» cuando el ejemplo pide «1 grow, 0 age».older_year(days) no
necesita ninguna planta: compara con 365 y se llama sobre la clase,
Plant.older_year(400). Usa la sintaxis de
decorador.anonymous(cls) fabrica
una planta «Unknown plant» de 0.0 cm y 0 días llamando a cls(...).Seed hereda de Flower, que hereda de Plant:
una cadena de herencia de tres niveles. Su show añade
la línea de semillas a lo que ya imprime la flor: 0 mientras no ha florecido y las guardadas
(42) después.Tree.TreeStats hereda de
Plant.Stats, añade un contador y sobrescribe
display para imprimir « 1 shade» debajo. El constructor de Tree crea
una TreeStats y la pone en _stats, sustituyendo la normal que acababa
de crear Plant.__init__, y guarda el mismo objeto en _tree_stats. Los
dos atributos apuntan al mismo objeto; el segundo existe para que mypy
acepte add_shade(), porque para él _stats es solo un
Plant.Stats.display_statistics(plant: Plant) sirve igual para una rosa, un roble, un girasol
o la planta anónima, porque todas son Plant y todas tienen
get_stats(). Con el roble, display() es la versión de
TreeStats: polimorfismo otra vez.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.
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).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ú.
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
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
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
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
_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
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
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
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
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
@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
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
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