L'héritage - l'évolution des espèces

Encore une fois bienvenue ! Darwin ici, avec un sujet passionnant.

Dans les leçons précédentes, tu as appris à créer des classes représentant des espèces. Mais dans la nature, les espèces ne sont pas isolées - elles font partie d'une hiérarchie taxonomique ! Les lions et les tigres sont des espèces différentes, mais tous deux sont des félins. Les félins et les canidés sont des familles différentes, mais tous deux sont des mammifères.

En programmation orientée objet, cette hiérarchie s'appelle l'héritage - l'un des mécanismes les plus puissants de la POO !

Qu'est-ce que l'héritage ?

L'héritage permet de créer de nouvelles classes à partir de classes existantes :

• Classe de base (parent, superclasse) - plus générale, par ex. « Mammifère »
• Classe dérivée (enfant, sous-classe) - plus spécifique, par ex. « Lion »

La classe dérivée hérite des attributs et des méthodes de la classe de base, et peut ensuite :

• Utiliser les méthodes héritées sans changement
• Étendre les classes de base (ajouter de nouvelles méthodes)
• Redéfinir des méthodes - changer le comportement

1# Classe de base - Mammifère général
2class Mammal:
3    def __init__(self, name):
4        self.name = name
5
6    def breathe(self):
7        return f"{self.name} respire de l'air"
8
9    def move(self):
10        return f"{self.name} se déplace"
11
12# Classe dérivée - Lion hérite de Mammal
13class Lion(Mammal):
14    def __init__(self, name, pride_name):
15        super().__init__(name)  # Appelle le constructeur du parent
16        self.pride_name = pride_name  # Ajoute son propre attribut
17
18    def roar(self):
19        """Nouvelle méthode - uniquement pour les lions"""
20        return f"{self.name} rugit : RRROAAR !"
21
22    def move(self):
23        """Redéfinit la méthode du parent"""
24        return f"{self.name} court à travers la savane"
25
26# Utilisation
27simba = Lion("Simba", "Pride Rock")
28
29# Hérité de Mammal
30print(simba.breathe())  # "Simba respire de l'air"
31
32# Redéfini dans Lion
33print(simba.move())  # "Simba court à travers la savane"
34
35# Méthode propre à Lion
36print(simba.roar())  # "Simba rugit : RRROAAR !"
37
38# Attribut propre à Lion
39print(simba.pride_name)  # "Pride Rock"

Syntaxe de l'héritage

Tu écris le nom de la classe de base entre parenthèses après le nom de la nouvelle classe. La classe enfant reçoit aussitôt toutes les méthodes du parent et peut aussi ajouter les siennes :

1# Syntaxe de base
2class ChildClass(ParentClass):
3    pass
4
5# Héritage avec extension
6class Animal:
7    def eat(self):
8        return "Je mange"
9
10class Dog(Animal):  # Dog hérite de Animal
11    def bark(self):
12        return "Ouaf ouaf !"
13
14dog = Dog()
15print(dog.eat())   # Hérité : "Je mange"
16print(dog.bark())  # Propre : "Ouaf ouaf !"

La fonction super()

super() permet de se référer à la classe de base - utilise-la pour :

• Appeler le constructeur du parent
• Étendre la méthode du parent (au lieu de la remplacer complètement)

1class Animal:
2    def __init__(self, name, age):
3        self.name = name
4        self.age = age
5        print(f"Création de l'animal : {name}")
6
7    def describe(self):
8        return f"{self.name}, âge : {self.age}"
9
10class Bird(Animal):
11    def __init__(self, name, age, wingspan):
12        # Appelle le constructeur de Animal
13        super().__init__(name, age)
14        # Ajoute son propre attribut
15        self.wingspan = wingspan
16        print(f"Envergure : {wingspan}m")
17
18    def describe(self):
19        # Étend la méthode du parent
20        base_desc = super().describe()  # Appelle Animal.describe()
21        return f"{base_desc}, envergure : {self.wingspan}m"
22
23eagle = Bird("Aigle", 5, 2.3)
24# Affiche :
25# Création de l'animal : Aigle
26# Envergure : 2.3m
27
28print(eagle.describe())  # "Aigle, âge : 5, envergure : 2.3m"

Redéfinition de méthode (Method Overriding)

Une classe dérivée peut remplacer complètement une méthode du parent :

1class Animal:
2    def speak(self):
3        return "L'animal fait un bruit"
4
5class Dog(Animal):
6    def speak(self):
7        """Redéfinit complètement"""
8        return "Ouaf ouaf !"  # Comportement totalement nouveau
9
10class Cat(Animal):
11    def speak(self):
12        """Redéfinit complètement"""
13        return "Miaou !"
14
15dog = Dog()
16cat = Cat()
17
18print(dog.speak())  # "Ouaf ouaf !" - pas "L'animal fait un bruit"
19print(cat.speak())  # "Miaou !"

Hiérarchie de classes - arbre taxonomique

Dans la nature, la hiérarchie est profonde : Règne → Embranchement → Classe → Ordre → Famille → Genre → Espèce

1# 1. Règne Animalia
2class Animal:
3    kingdom = "Animalia"
4
5    def __init__(self, name):
6        self.name = name
7
8    def is_alive(self):
9        return True
10
11    def __str__(self):
12        return f"{self.name} ({self.__class__.__name__})"
13
14# 2. Embranchement Chordata
15class Chordate(Animal):
16    phylum = "Chordata"
17
18    def has_notochord(self):  # corde dorsale
19        return True
20
21# 3. Classe Mammalia
22class Mammal(Chordate):
23    class_name = "Mammalia"
24
25    def __init__(self, name, fur_color):
26        super().__init__(name)
27        self.fur_color = fur_color
28
29    def nurse_young(self):
30        return f"{self.name} allaite ses petits"
31
32    def regulate_temperature(self):
33        return f"{self.name} maintient une température corporelle constante"
34
35# 4. Ordre Carnivora
36class Carnivore(Mammal):
37    order = "Carnivora"
38
39    def __init__(self, name, fur_color, hunting_style):
40        super().__init__(name, fur_color)
41        self.hunting_style = hunting_style
42
43    def hunt(self):
44        return f"{self.name} chasse avec : {self.hunting_style}"
45
46# 5. Famille Felidae
47class Feline(Carnivore):
48    family = "Felidae"
49
50    def retract_claws(self):
51        return f"{self.name} rétracte ses griffes"
52
53    def purr(self):
54        return f"{self.name} ronronne"
55
56# 6. Espèce Panthera leo (Lion)
57class Lion(Feline):
58    species = "Panthera leo"
59
60    def __init__(self, name, fur_color, pride_name):
61        super().__init__(name, fur_color, "chasse en meute")
62        self.pride_name = pride_name
63
64    def roar(self):
65        return f"{self.name} rugit fort !"
66
67    def lead_pride(self):
68        return f"{self.name} dirige la troupe {self.pride_name}"
69
70# Utilisation - le lion a accès à TOUTES les méthodes de la hiérarchie !
71simba = Lion("Simba", "doré", "Pride Rock")
72
73# Depuis Animal
74print(simba.is_alive())  # True
75
76# Depuis Chordate
77print(simba.has_notochord())  # True
78
79# Depuis Mammal
80print(simba.nurse_young())  # "Simba allaite ses petits"
81print(simba.regulate_temperature())  # "Simba maintient une température corporelle constante"
82
83# Depuis Carnivore
84print(simba.hunt())  # "Simba chasse avec : chasse en meute"
85
86# Depuis Feline
87print(simba.retract_claws())  # "Simba rétracte ses griffes"
88print(simba.purr())  # "Simba ronronne"
89
90# Méthodes propres à Lion
91print(simba.roar())  # "Simba rugit fort !"
92print(simba.lead_pride())  # "Simba dirige la troupe Pride Rock"
93
94# Attributs
95print(simba.kingdom)  # "Animalia"
96print(simba.species)  # "Panthera leo"
97print(simba.fur_color)  # "doré"

Vérifier les relations entre classes

Python offre des fonctions pour vérifier la hiérarchie :

1class Animal:
2    pass
3
4class Mammal(Animal):
5    pass
6
7class Lion(Mammal):
8    pass
9
10simba = Lion()
11
12# isinstance() - vérifie si un objet est une instance d'une classe
13print(isinstance(simba, Lion))    # True
14print(isinstance(simba, Mammal))  # True - Lion hérite de Mammal
15print(isinstance(simba, Animal))  # True - Lion hérite de Animal (via Mammal)
16print(isinstance(simba, str))     # False
17
18# issubclass() - vérifie si une classe hérite d'une autre classe
19print(issubclass(Lion, Mammal))   # True
20print(issubclass(Lion, Animal))   # True
21print(issubclass(Mammal, Lion))   # False
22print(issubclass(Lion, Lion))     # True - une classe est sous-classe d'elle-même
23
24# type() - renvoie le type exact
25print(type(simba))  # <class '__main__.Lion'>
26print(type(simba) == Lion)    # True
27print(type(simba) == Mammal)  # False - simba est un Lion, pas un Mammal

Héritage multiple

Python permet d'hériter de plusieurs classes à la fois - une classe peut avoir plusieurs parents !

1class Swimmer:
2    def swim(self):
3        return f"{self.name} nage"
4
5class Flyer:
6    def fly(self):
7        return f"{self.name} vole"
8
9class Walker:
10    def walk(self):
11        return f"{self.name} marche"
12
13# Duck hérite de trois classes !
14class Duck(Swimmer, Flyer, Walker):
15    def __init__(self, name):
16        self.name = name
17
18    def quack(self):
19        return f"{self.name} : Coin coin !"
20
21donald = Duck("Donald")
22
23# A accès aux méthodes de toutes les classes de base
24print(donald.swim())   # "Donald nage"
25print(donald.fly())    # "Donald vole"
26print(donald.walk())   # "Donald marche"
27print(donald.quack())  # "Donald : Coin coin !"

MRO - Method Resolution Order

Quand une classe hérite de plusieurs parents, Python utilise le MRO (Method Resolution Order) pour déterminer l'ordre de recherche des méthodes :

1class A:
2    def method(self):
3        return "A"
4
5class B(A):
6    def method(self):
7        return "B"
8
9class C(A):
10    def method(self):
11        return "C"
12
13class D(B, C):  # Hérite de B et C
14    pass
15
16d = D()
17print(d.method())  # "B" - Python cherche : D → B → C → A
18
19# Vérifier le MRO
20print(D.__mro__)
21# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>,
22#  <class '__main__.A'>, <class 'object'>)
23
24# Ou plus lisible :
25print(D.mro())

Règle : Python cherche les classes de gauche à droite, de la plus spécifique à la plus générale.

Exemple Safari - hiérarchie des espèces avec observations

Voici maintenant toute la hiérarchie du safari : une classe commune Species, en dessous les mammifères et les oiseaux, puis les carnivores et les herbivores, et tout en bas les félins et les canidés. Chaque niveau ajoute ses propres attributs et étend describe() avec super().

1class Species:
2    """
3    Classe de base pour toutes les espèces du catalogue Safari
4    """
5
6    kingdom = "Animalia"
7    total_species_count = 0
8
9    def __init__(self, scientific_name, common_name, habitat):
10        self.scientific_name = scientific_name
11        self.common_name = common_name
12        self.habitat = habitat
13        self.observations = []
14
15        Species.total_species_count += 1
16
17    def add_observation(self, date, location, count, notes=""):
18        """Ajoute une observation de terrain"""
19        self.observations.append({
20            "date": date,
21            "location": location,
22            "count": count,
23            "notes": notes
24        })
25
26    def get_total_observed(self):
27        """Nombre total d'individus observés"""
28        return sum(obs["count"] for obs in self.observations)
29
30    def describe(self):
31        """Description de base de l'espèce"""
32        return f"{self.common_name} ({self.scientific_name})"
33
34    def __str__(self):
35        return self.describe()
36
37class Mammal(Species):
38    """
39    Classe représentant les mammifères - étend Species
40    """
41
42    class_name = "Mammalia"
43
44    def __init__(self, scientific_name, common_name, habitat, fur_color, gestation_days):
45        # Appelle le constructeur de Species
46        super().__init__(scientific_name, common_name, habitat)
47        # Ajoute les attributs propres aux mammifères
48        self.fur_color = fur_color
49        self.gestation_days = gestation_days
50
51    def nurse_young(self):
52        """Les mammifères allaitent leurs petits"""
53        return f"{self.common_name} allaite ses petits (la gestation dure {self.gestation_days} jours)"
54
55    def describe(self):
56        """Étend la description avec les infos sur le mammifère"""
57        base = super().describe()  # Appelle Species.describe()
58        return f"{base} | Mammifère | Pelage : {self.fur_color}"
59
60class Bird(Species):
61    """
62    Classe représentant les oiseaux
63    """
64
65    class_name = "Aves"
66
67    def __init__(self, scientific_name, common_name, habitat, wingspan_m, can_fly=True):
68        super().__init__(scientific_name, common_name, habitat)
69        self.wingspan_m = wingspan_m
70        self.can_fly = can_fly
71
72    def lay_eggs(self):
73        return f"{self.common_name} pond des œufs"
74
75    def describe(self):
76        base = super().describe()
77        flight_status = "volant" if self.can_fly else "non-volant"
78        return f"{base} | Oiseau {flight_status} | Envergure : {self.wingspan_m}m"
79
80class Carnivore(Mammal):
81    """
82    Prédateurs - héritent de Mammal
83    """
84
85    order = "Carnivora"
86
87    def __init__(self, scientific_name, common_name, habitat, fur_color,
88                 gestation_days, hunting_style, pack_hunter=False):
89        super().__init__(scientific_name, common_name, habitat, fur_color, gestation_days)
90        self.hunting_style = hunting_style
91        self.pack_hunter = pack_hunter
92
93    def hunt(self):
94        style = "en meute" if self.pack_hunter else "en solitaire"
95        return f"{self.common_name} chasse {style} avec : {self.hunting_style}"
96
97    def calculate_danger_level(self):
98        """Calcule le niveau de danger (1-10)"""
99        base_danger = 5
100        if self.pack_hunter:
101            base_danger += 3
102        if "embuscade" in self.hunting_style:
103            base_danger += 2
104        return min(10, base_danger)
105
106    def describe(self):
107        base = super().describe()
108        danger = self.calculate_danger_level()
109        return f"{base} | Prédateur | Danger : {danger}/10"
110
111class Herbivore(Mammal):
112    """
113    Herbivores - héritent de Mammal
114    """
115
116    def __init__(self, scientific_name, common_name, habitat, fur_color,
117                 gestation_days, diet_type):
118        super().__init__(scientific_name, common_name, habitat, fur_color, gestation_days)
119        self.diet_type = diet_type  # "feuilles", "herbe", "fruits"
120
121    def graze(self):
122        return f"{self.common_name} mange {self.diet_type}"
123
124    def describe(self):
125        base = super().describe()
126        return f"{base} | Herbivore | Régime : {self.diet_type}"
127
128class Feline(Carnivore):
129    """
130    Félins - héritent de Carnivore
131    """
132
133    family = "Felidae"
134
135    def __init__(self, scientific_name, common_name, habitat, fur_color,
136                 gestation_days, has_mane=False, pride_size=1):
137        super().__init__(
138            scientific_name, common_name, habitat, fur_color,
139            gestation_days, "embuscade et poursuite", pack_hunter=(pride_size > 1)
140        )
141        self.has_mane = has_mane
142        self.pride_size = pride_size
143
144    def retract_claws(self):
145        return f"{self.common_name} rétracte ses griffes acérées"
146
147    def stalk_prey(self):
148        return f"{self.common_name} traque sa proie en silence"
149
150    def describe(self):
151        base = super().describe()
152        social = f"social ({self.pride_size})" if self.pride_size > 1 else "solitaire"
153        return f"{base} | Félin | {social}"
154
155class Canine(Carnivore):
156    """
157    Canidés - héritent de Carnivore
158    """
159
160    family = "Canidae"
161
162    def __init__(self, scientific_name, common_name, habitat, fur_color,
163                 gestation_days, pack_size=1):
164        super().__init__(
165            scientific_name, common_name, habitat, fur_color,
166            gestation_days, "poursuite d'endurance", pack_hunter=(pack_size > 1)
167        )
168        self.pack_size = pack_size
169
170    def howl(self):
171        return f"{self.common_name} hurle à la meute"
172
173    def track_scent(self):
174        return f"{self.common_name} pister sa proie à l'odeur"
175
176    def describe(self):
177        base = super().describe()
178        social = f"meute ({self.pack_size})" if self.pack_size > 1 else "solitaire"
179        return f"{base} | Canidé | {social}"
180
181# === DÉMONSTRATION - Création de la hiérarchie Safari ===
182
183print("=== CATALOGUE D'ESPÈCES SAFARI - HIÉRARCHIE ===\n")
184
185# Félins
186lion = Feline(
187    scientific_name="Panthera leo",
188    common_name="Lion",
189    habitat="savane",
190    fur_color="doré",
191    gestation_days=110,
192    has_mane=True,
193    pride_size=15
194)
195
196leopard = Feline(
197    scientific_name="Panthera pardus",
198    common_name="Léopard",
199    habitat="savane et forêts",
200    fur_color="jaune à taches noires",
201    gestation_days=90,
202    has_mane=False,
203    pride_size=1  # Solitaire
204)
205
206# Canidés
207wild_dog = Canine(
208    scientific_name="Lycaon pictus",
209    common_name="Lycaon",
210    habitat="savane",
211    fur_color="tacheté",
212    gestation_days=70,
213    pack_size=20
214)
215
216# Herbivores
217elephant = Herbivore(
218    scientific_name="Loxodonta africana",
219    common_name="Éléphant d'Afrique",
220    habitat="savane",
221    fur_color="gris",
222    gestation_days=645,  # La plus longue gestation !
223    diet_type="feuilles, écorce, herbe"
224)
225
226giraffe = Herbivore(
227    scientific_name="Giraffa camelopardalis",
228    common_name="Girafe",
229    habitat="savane",
230    fur_color="jaune à taches brunes",
231    gestation_days=440,
232    diet_type="feuilles d'acacia"
233)
234
235# Oiseaux
236eagle = Bird(
237    scientific_name="Aquila rapax",
238    common_name="Aigle ravisseur",
239    habitat="savane",
240    wingspan_m=2.1,
241    can_fly=True
242)
243
244# Ajout d'observations
245lion.add_observation("2024-01-15", "Serengeti", 12, "Troupe chassant des gnous")
246lion.add_observation("2024-01-20", "Masai Mara", 8, "Famille avec des petits")
247leopard.add_observation("2024-01-16", "Zone rocheuse", 1, "Mâle solitaire")
248wild_dog.add_observation("2024-01-18", "Savuti", 18, "Chasse en meute")
249elephant.add_observation("2024-01-17", "Amboseli", 45, "Grand troupeau au point d'eau")
250giraffe.add_observation("2024-01-19", "Tarangire", 23, "Girafes se nourrissant d'acacias")
251eagle.add_observation("2024-01-21", "Ciel au-dessus de la savane", 3, "Couple avec un juvénile")
252
253# Affichage des descriptions - chacune utilise sa propre version de describe()
254print("LION :")
255print(f"  {lion.describe()}")
256print(f"  {lion.hunt()}")
257print(f"  {lion.stalk_prey()}")
258print(f"  {lion.retract_claws()}")
259print(f"  {lion.nurse_young()}")
260print(f"  Observations : {lion.get_total_observed()} individus")
261
262print(f"\nLÉOPARD :")
263print(f"  {leopard.describe()}")
264print(f"  {leopard.hunt()}")
265print(f"  Niveau de danger : {leopard.calculate_danger_level()}/10")
266
267print(f"\nLYCAON :")
268print(f"  {wild_dog.describe()}")
269print(f"  {wild_dog.hunt()}")
270print(f"  {wild_dog.howl()}")
271print(f"  {wild_dog.track_scent()}")
272
273print(f"\nÉLÉPHANT :")
274print(f"  {elephant.describe()}")
275print(f"  {elephant.graze()}")
276print(f"  Observations : {elephant.get_total_observed()} individus")
277
278print(f"\nGIRAFE :")
279print(f"  {giraffe.describe()}")
280print(f"  {giraffe.graze()}")
281
282print(f"\nAIGLE :")
283print(f"  {eagle.describe()}")
284print(f"  {eagle.lay_eggs()}")
285
286# Vérification de la hiérarchie
287print(f"\n=== HIÉRARCHIE DES CLASSES ===")
288print(f"Le lion hérite-t-il de Feline ? {isinstance(lion, Feline)}")
289print(f"Le lion hérite-t-il de Carnivore ? {isinstance(lion, Carnivore)}")
290print(f"Le lion hérite-t-il de Mammal ? {isinstance(lion, Mammal)}")
291print(f"Le lion hérite-t-il de Species ? {isinstance(lion, Species)}")
292print(f"Le lion hérite-t-il de Bird ? {isinstance(lion, Bird)}")
293
294print(f"\nMRO Feline : {[cls.__name__ for cls in Feline.mro()]}")
295# ['Feline', 'Carnivore', 'Mammal', 'Species', 'object']
296
297print(f"\n=== STATISTIQUES ===")
298print(f"Total d'espèces dans le catalogue : {Species.total_species_count}")
299
300# Polymorphisme - chaque espèce a sa propre implémentation de describe()
301print(f"\nToutes les espèces :")
302all_animals = [lion, leopard, wild_dog, elephant, giraffe, eagle]
303for animal in all_animals:
304    print(f"  - {animal.describe()}")

Règles pratiques de l'héritage

1. Quand utiliser l'héritage ?

Utilise l'héritage quand :

• Relation « est-un » : un Lion est un Mammifère
• Tu veux réutiliser le code de la classe de base
• Tu crées une hiérarchie de types

N'utilise PAS l'héritage quand :

• Relation « a-un » : une Voiture a un Moteur (utilise la composition !)
• Les classes ne partagent pas une nature commune
• Tu veux juste emprunter quelques méthodes

1# Bon - relation « est-un »
2class Animal:
3    pass
4
5class Dog(Animal):  # Dog EST un animal
6    pass
7
8# Mauvais - relation « a-un »
9class Engine:
10    def start(self):
11        return "Moteur démarré"
12
13class Car(Engine):  # NON ! Une voiture N'EST PAS un moteur !
14    pass
15
16# Bon - composition
17class Car:
18    def __init__(self):
19        self.engine = Engine()  # La voiture A un moteur
20
21    def start(self):
22        return self.engine.start()

2. Principe de substitution de Liskov (LSP)

Un objet d'une classe dérivée doit pouvoir remplacer un objet de la classe de base sans changer la justesse du programme.

1def make_sound(animal):
2    """La fonction accepte n'importe quel Animal"""
3    print(animal.speak())
4
5class Animal:
6    def speak(self):
7        return "..."
8
9class Dog(Animal):
10    def speak(self):
11        return "Ouaf !"
12
13class Cat(Animal):
14    def speak(self):
15        return "Miaou !"
16
17# LSP - Dog et Cat peuvent remplacer Animal
18make_sound(Dog())  # "Ouaf !" - fonctionne
19make_sound(Cat())  # "Miaou !" - fonctionne

3. Évite les hiérarchies profondes

Chaque niveau d'héritage est une classe de plus à lire pour comprendre un objet. Compare six niveaux vides avec trois niveaux qui ont un sens :

1# Mauvais - hiérarchie trop profonde
2class A:
3    pass
4class B(A):
5    pass
6class C(B):
7    pass
8class D(C):
9    pass
10class E(D):
11    pass
12class F(E):  # 6 niveaux !
13    pass
14
15# Bon - hiérarchie plate et compréhensible
16class Animal:
17    pass
18
19class Mammal(Animal):
20    pass
21
22class Lion(Mammal):
23    pass

Trois niveaux, Animal → Mammal → Lion, se lisent d'un coup d'œil. Quand une hiérarchie dépasse trois ou quatre niveaux, vérifie si une partie des comportements ne serait pas mieux placée dans une composition.

Résumé

Dans cette leçon, tu as appris :

• Ce qu'est l'héritage et pourquoi il est puissant
• Comment créer des classes dérivées avec class Child(Parent)
• Utiliser super() pour appeler les méthodes du parent
• Redéfinir et étendre des méthodes
• Construire des hiérarchies de classes (arbre taxonomique)
• Vérifier les relations avec isinstance() et issubclass()
• L'héritage multiple et le MRO
• Des règles pratiques : quand utiliser l'héritage et quand ne pas le faire

Point de contrôle

Avant de passer à la suite :

• Tu comprends la différence entre classe de base et classe dérivée
• Tu sais utiliser super() dans un constructeur
• Tu sais redéfinir une méthode du parent
• Tu comprends la hiérarchie et l'héritage multi-niveaux
• Tu connais la différence entre « est-un » (héritage) et « a-un » (composition)

Analogie Safari : une hiérarchie de classes est un arbre évolutif - chaque descendant hérite des traits de ses ancêtres mais développe ses propres adaptations uniques !

Dans la prochaine leçon, Darwin t'apprendra l'encapsulation - comment protéger les données sensibles sur les espèces contre les accès non autorisés !