Inheritance & encapsulation · Héritage & encapsulation
Build on an existing class
- Inheritance lets a new class reuse an existing one.
- The new class is the subclass (child); the original is the superclass (parent).
- Write
class Bird(Animal):—Birdgets all ofAnimal's methods. (In exam pseudocode:CLASS Bird INHERITS Animal.)
Construire sur une classe existante
- L'héritage permet à une nouvelle classe de réutiliser une classe existante.
- La nouvelle classe est la sous-classe (enfant) ; l'originale est la super-classe (parent).
- Écrivez
class Bird(Animal):—Birdhérite de toutes les méthodes deAnimal. (En pseudocode d'examen :CLASS Bird INHERITS Animal.)
Call the parent with super()
- A subclass can add its own attributes in
__init__. - Use
super().__init__(...)to run the parent's__init__first. - This avoids repeating the parent's setup code.
Appeler le parent avec super()
- Une sous-classe peut ajouter ses propres attributs dans
__init__. - Utilisez
super().__init__(...)pour exécuter d'abord le__init__du parent. - Cela évite de répéter le code d'initialisation du parent.
class Animal:
def __init__(self, name):
self.name = name
def describe(self):
return self.name + " is an animal"
class Bird(Animal):
def fly(self):
return self.name + " flies"
b = Bird("Robin")
print(b.describe()) # inherited from Animal
print(b.fly()) # new in Bird
Override a method
- A subclass can override a method: define one with the same name.
- The subclass's version is used instead of the parent's.
- This lets each class behave in its own way.
Redéfinir une méthode
- Une sous-classe peut redéfinir une méthode : en définir une avec le même nom.
- La version de la sous-classe est utilisée au lieu de celle du parent.
- Cela permet à chaque classe de se comporter différemment.
class Animal:
def speak(self):
return "..."
class Cow(Animal):
def speak(self):
return "Moo"
print(Cow().speak())
Encapsulation
- Encapsulation means keeping an object's data safe inside it.
- Python has no real "private", but a leading underscore (
self._balance) signals "do not touch from outside". - Other code should use methods to read or change the data, not reach in directly.
Encapsulation
- L'encapsulation signifie garder les données d'un objet sécurisées à l'intérieur.
- Python n'a pas de véritable « privé », mais un underscore initial (
self._balance) signale « ne pas toucher depuis l'extérieur ». - D'autres codes doivent utiliser des méthodes pour lire ou modifier les données, et non accéder directement.
Polymorphism
- Polymorphism means one method name, but different behaviour per class.
- A loop can call
.speak()on many objects without knowing their exact type. - Each object responds in its own way.
Polymorphisme
- Le polymorphisme signifie un seul nom de méthode, mais un comportement différent par classe.
- Une boucle peut appeler
.speak()sur de nombreux objets sans connaître leur type exact. - Chaque objet répond de manière unique.
class Duck:
def speak(self):
return "Quack"
class Cow:
def speak(self):
return "Moo"
for animal in [Duck(), Cow()]:
print(animal.speak())
Common mistakes
- A subclass inherits from its parent and can add or override methods.
- Keep data private and reach it through methods (encapsulation).
Erreurs courantes
- Une sous-classe hérite de son parent et peut ajouter ou redéfinir des méthodes.
- Gardez les données privées et accédez-y via des méthodes (encapsulation).
Now you try
- Use inheritance, overriding, encapsulation, and calling methods on different objects.
- Press Check answer to test your code.
À vous maintenant
- Utilisez l'héritage, la redéfinition, l'encapsulation et l'appel de méthodes sur différents objets.
- Appuyez sur Vérifier la réponse pour tester votre code.
The class Animal is given. Write a subclass Cat(Animal) that inherits from it and adds a method speak(self) returning "Meow". (It should still have the inherited name_is.) · La classe Animal est donnée. Écrivez une sous-classe Cat(Animal) qui hérite de celle-ci et ajoute une méthode speak(self) retournant "Meow". (Elle devrait encore avoir l'attribut hérité name_is.)
Click Run to see the output here. · Cliquez sur Exécuter pour voir le résultat ici.
The class Shape is given (its area returns · rendements 0). Write Square(Shape): its __init__(self, side) should call super().__init__("square"), store side, and override area to return side * side. · La classe Shape est fournie (son area retourne 0). Écrivez Square(Shape) : son __init__(self, side) devrait appeler super().__init__("square"), stocker side, et surcharger area pour retourner side * side.
Click Run to see the output here. · Cliquez sur Exécuter pour voir le résultat ici.
Classes Dog and · et Cat are given, each with a speak(). Write speak_all(animals) that returns · rendements a list of each animal's speak() result, in order. · Les classes Dog et Cat sont fournies, chacune avec un speak(). Écrivez speak_all(animals) qui retourne une liste du résultat de speak() de chaque animal, dans l'ordre.
Click Run to see the output here. · Cliquez sur Exécuter pour voir le résultat ici.
Write a class Account whose __init__(self) sets a private balance · solde self._balance to · à 0. Add deposit(self, amount) to add to it, and balance(self) to · à return · rendement it. Other code should use these methods, not touch _balance directly. · Écrivez une classe Account dont le __init__(self) définit un solde privé self._balance à 0. Ajoutez deposit(self, amount) pour l'augmenter, et balance(self) pour le retourner. Autre code doit utiliser ces méthodes, pas toucher _balance directement.
Click Run to see the output here. · Cliquez sur Exécuter pour voir le résultat ici.