Encapsulation
Explorez les concepts avancés de la POO.
Encapsulation est une leçon Python For Kids gratuite sur CoddyKit. Ceci est la leçon 4 sur 5. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python For Kids, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python For Kids comprend 5 leçons au total.
Encapsulation
Nous reprenons la leçon sur la programmation orientée objet (OOP) ! Aujourd'hui, nous allons découvrir l'encapsulation en Python, un concept clé qui aide à protéger vos données et vos méthodes au sein des classes.
Qu'est-ce que l'encapsulation ?
L'encapsulation consiste à regrouper les données (attributes) et les méthodes (fonctions) qui agissent sur ces données au sein d'une même unité appelée classe. Elle restreint également l'accès direct à certains composants d'un objet, ce qui masque sa représentation interne vis-à-vis de l'extérieur.
- Masquage des données : protéger l'état interne d'un objet contre les interventions involontaires.
- Contrôle de l'accès : définir comment les données et les méthodes peuvent être consultées ou modifiées.
L'encapsulation garantit que les objets contrôlent leurs propres données et n'exposent que ce qui est nécessaire.
Modificateurs d'accès
En Python, l'encapsulation est mise en œuvre à l'aide de modificateurs d'accès qui contrôlent la visibilité des membres d'une classe (attributes et méthodes). Il existe trois types de modificateurs d'accès :
- Public : accessible depuis n'importe où.
- Protégé : accessible au sein de la classe et de ses sous-classes.
- Privé : accessible uniquement au sein de la classe elle-même.
Voyons comment utiliser ces modificateurs d'accès en Python.
Attributes et méthodes publics
Les membres publics sont accessibles depuis l'extérieur de la classe. Par défaut, tous les attributes et toutes les méthodes sont publics, sauf indication contraire.
Exemple :
# Defines the Person class with public attributes and methods
class Person:
def __init__(self, name, age):
self.name = name # Public attribute
self.age = age # Public attribute
def greet(self):
print("Hello, my name is " + self.name + "!") # Public method
# Creates an object of the Person class
person1 = Person("Alice", 30)
# Accesses public attributes and methods
print(person1.name) # Output: Alice
person1.greet() # Output: Hello, my name is Alice!
Attributes et méthodes protégés
Les membres protégés sont indiqués par un préfixe composé d'un seul trait de soulignement (_). Ils sont accessibles au sein de la classe et de ses sous-classes, mais ne doivent pas être consultés directement depuis l'extérieur de la classe.
Exemple :
# Defines the Employee class with protected attributes and methods
class Employee:
def __init__(self, name, salary):
self._name = name # Protected attribute
self._salary = salary # Protected attribute
def _increase_salary(self, amount):
self._salary += amount # Protected method
print(self._name + "'s new salary is " + str(self._salary))
# Creates an object of the Employee class
employee1 = Employee("Bob", 50000)
# Accesses protected attributes and methods (not recommended)
print(employee1._name) # Output: Bob
employee1._increase_salary(5000) # Output: Bob's new salary is 55000
Attributes et méthodes privés
Les membres privés sont indiqués par un préfixe composé de deux traits de soulignement (__). Ils sont accessibles uniquement au sein de la classe elle-même et ne peuvent pas être consultés directement depuis l'extérieur de la classe.
Exemple :
# Defines the BankAccount class with private attributes and methods
class BankAccount:
def __init__(self, owner, balance):
self.__owner = owner # Private attribute
self.__balance = balance # Private attribute
def deposit(self, amount):
self.__balance += amount # Modifies private attribute
print("Deposited:", amount)
self.__show_balance()
def __show_balance(self):
print("Current Balance:", self.__balance) # Private method
# Creates an object of the BankAccount class
account1 = BankAccount("Charlie", 1000)
# Attempts to access private attributes and methods (will cause errors)
# print(account1.__owner) # AttributeError
# account1.__show_balance() # AttributeError
# Uses public methods to interact with private attributes
account1.deposit(500) # Output:
# Deposited: 500
# Current Balance: 1500
Pourquoi utiliser l'encapsulation ?
L'encapsulation offre plusieurs avantages :
- Contrôle : contrôler la manière dont les données sont consultées ou modifiées.
- Sécurité : protéger l'état interne d'un objet contre les modifications involontaires.
- Facilité de maintenance : rendre le code plus facile à maintenir et moins sujet aux erreurs.
L'encapsulation aide à créer des applications robustes et sécurisées.
Exemple d’encapsulation : classe Car
Créons une classe Car qui utilise l’encapsulation pour protéger ses attributs et ses méthodes.
Code :
# Defines the Car class with encapsulated attributes and methods
class Car:
def __init__(self, make, model, year):
self.make = make # Public attribute
self.model = model # Public attribute
self.__year = year # Private attribute
def get_year(self):
return self.__year # Public method to access private attribute
def set_year(self, year):
if year > 0:
self.__year = year # Public method to modify private attribute
print("Year updated to", self.__year)
else:
print("Invalid year!")
def __display_info(self):
print(self.make, self.model, self.__year) # Private method
def show_info(self):
self.__display_info() # Public method that calls a private method
# Creates an object of the Car class
car1 = Car("Tesla", "Model S", 2020)
# Accesses public attributes and methods
print(car1.make) # Output: Tesla
print(car1.get_year()) # Output: 2020
# Modifies the private attribute using a public method
car1.set_year(2021) # Output: Year updated to 2021
# Calls a public method that interacts with a private method
car1.show_info() # Output: Tesla Model S 2021
# Attempts to access private attributes and methods directly (will cause errors)
# print(car1.__year) # AttributeError
# car1.__display_info() # AttributeError
# Defines the Student class with encapsulated attributes
class Student:
def __init__(self, name, grade):
self.name = name # Public attribute
self.__grade = grade # Private attribute
def get_grade(self):
return self.__grade # Public method to access private attribute
def set_grade(self, grade):
if 0 <= grade <= 100:
self.__grade = grade # Updates the grade
else:
print("Invalid grade!")
# Creates an object of the Student class
student1 = Student("Diana", 85)
# Accesses and modifies the grade using public methods
print(student1.get_grade()) # Output: 85
student1.set_grade(90)
print(student1.get_grade()) # Output: 90
# Attempts to access the private attribute directly (will cause an error)
# print(student1.__grade) # AttributeError
Excellent travail !
Vous avez appris à utiliser l’encapsulation en Python pour protéger vos données et vos méthodes au sein des classes. L’encapsulation vous aide à contrôler l’accès aux données de vos objets, ce qui rend vos programmes plus sécurisés et plus faciles à maintenir. Continuez à vous entraîner en concevant des classes dotées de modificateurs d’accès appropriés afin de perfectionner vos compétences en programmation !
Questions Fréquemment Posées
La leçon « Encapsulation » est-elle gratuite ?
Oui — le texte complet de « Encapsulation » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python For Kids, passe à CoddyKit PRO. Le cours Python For Kids comprend 5 leçons au total.
Qu'est-ce que j'apprendrai dans « Encapsulation » ?
Explorez les concepts avancés de la POO. Tu pratiques Python For Kids avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Python For Kids ?
Aucune expérience préalable n'est requise. Python For Kids sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 5.
Combien de temps prend la leçon « Encapsulation » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Python For Kids ?
Oui. Chaque leçon Python For Kids inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.