Comment créer une classe simple en Python
Dans un langage orienté objet, une classe est un morceau de code extensible qui représente un modèle pour créer et utiliser les objets de cette classe. Un objet d'une classe fait simplement référence à une instance de la classe définie.
Principes de base de la classe Python
Dans le langage de programmation Python, chaque élément de données est représenté comme une instance d'une classe. Si vous n'êtes pas familier avec le langage, consultez notre guide du débutant sur Python avant de continuer.
Une classe fournit un ensemble de comportements sous la forme de fonctions membres (également appelées méthodes), qui a des implémentations communes à toutes les instances de cette classe, et elle détermine également la manière dont les informations d'état de son instance sont représentées dans le forme d'attributs.
Le code ci-dessous représente un exemple de classe définie en Python. La classe définie dans le code fournit une implémentation d'une classe RaceCar.
Chaque instance de la classe fournit un modèle simple pour différentes marques de voitures et contient les informations d'état suivantes: nom de la voiture, nom du conducteur, numéro de plaque d'immatriculation de la voiture, vitesse actuelle, frais d'excès de vitesse et couleur.
Cette classe de voiture modélise un capteur spécial dans chaque voiture qui enregistre une amende de 50 $ contre le conducteur de la voiture s'il dépasse la limite de vitesse légale de 140 miles par heure.
Exemple de classe (classe de voiture)
class Car:
#Constructor
#the init method is responsible for initialising the values of the instance #variables in the class.
def __init__(self, car_name, driver_name, license_plate_number,
current_speed, speeding_charge, colour):
self.car_name = car_name
self._driver_name = driver_name
self._license_plate_number = license_plate_number
self._current_speed = current_speed
self._speeding_charge = speeding_charge
self._colour = colour
#Accessor methods
#The get_car_name method returns the name of the car
def get_car_name(self):
return self._car_name
#The get_driver_name method returns the name of the driver
def get_driver_name(self):
return self._driver_name
#The get_license_plate method returns the license plate of the car
def get_license_plate(self):
return self._license_plate
#The get_current_speed method returns the current speed at which the car is #moving
def get_current_speed(self):
return self._current_speed
#The get_speeding_charge method returns the total amount of money that the
#driver has to pay for over-speeding
def get_speeding_charge(self):
return self._speeding_charge
#The get_colour method returns the colour of our sweet ride!
def get_colour(self):
return self._colour
#Mutator methods
#The set_driver value changes the driver of our car.
def set_driver(self, new_driver):
self._driver_name = new_driver
#The speeding_ticket method ensures that the driver is charged 50 bucks when#he or she caught speeding above 140 miles per hour :(
def speeding_ticket(self, current_speed):
if current_speed <= 140:
return False
else:
self._speeding_charge += 50
return True
#The make_payment method ensures that the driver is able to pay for all the #amount that he or she owes for speeding ticket charges.
def make_payment(self, amount_paid):
self._speeding_charge -= amount_paid
Une explication de l'exemple de classe Python
Le paramètre "Self"
Tout d'abord, notez qu'il existe une différence entre la signature de méthode déclarée dans la classe et la signature de méthode utilisée par le programmeur pour appeler la fonction. Par exemple, la méthode get_colour telle que définie dans la classe prend un paramètre qui est le paramètre «self».
Cependant, lorsque le programmeur appelle cette méthode sur une instance de la classe, il ne fournit aucun paramètre. Ce même phénomène peut être observé dans la méthode speeding_ticket qui est définie pour prendre deux paramètres dans la classe (ie self et current_speed), mais le programmeur est capable d'exécuter cette méthode en fournissant la valeur uniquement pour le paramètre 'current_speed'.
C'est parce que le but du paramètre 'self' fourni est de lier la méthode à l'instance d'objet sur laquelle elle a été appelée et ce n'est pas une valeur à donner par le programmeur.
Le constructeur
Un constructeur d'une classe fait référence à la méthode de la classe qu'un utilisateur peut appeler pour créer une instance d'objet de cette classe. Dans la classe Car, l'utilisateur peut créer une instance d'objet à l'aide de la syntaxe suivante:
#creating our very own Bugatti :)
Car(“Bugatti”, “David Sasu”, 90828, 0, 0, "Cherry Red")L'exécution de ce code entraîne un appel à la méthode __init__ dans la classe Car. La responsabilité de cette méthode est de générer un objet voiture de crédit nouvellement créé avec les valeurs d'instance fournies. Chaque objet de la classe Car est constitué de six variables d'instance qui sont:
- _nom_voiture
- _nom du conducteur
- _plaque d'immatriculation
- _vitesse actuelle
- _speeding_charge
- _Couleur
Méthodes d'accesseur
Ce sont des méthodes écrites pour accéder aux informations d'état d'une instance d'objet. Dans la classe Car, les méthodes d'accès qui ont été écrites sont:
- get_car_name
- get_driver_name
- get_license_plate
- get_current_speed
- get_speeding_charge
- get_colour
Méthodes de mutation:
Ce sont des méthodes écrites pour modifier les informations d'état d'une instance d'objet. Dans la classe Car, les méthodes mutator qui ont été écrites sont:
- set_driver
- excès de vitesse
- effectuer le paiement
Le concept d'encapsulation
«Encapsulation» est un terme utilisé pour décrire un principe de conception orientée objet où les composants d'un programme ne doivent pas révéler les détails internes de leurs implémentations respectives. Pour approfondir votre compréhension du concept d'encapsulation, consultez notre article sur l'encapsulation.
Vérification des erreurs
Notre implémentation de la classe Car n'est pas robuste car elle est susceptible de planter ou de mal fonctionner en fonction de l'entrée qu'elle reçoit du programmeur.
Tout d'abord, notez que nous ne vérifions pas les types des paramètres des méthodes speeding_ticket et make_payment, ni que nous ne vérifions les types d'aucun des paramètres du constructeur. Cela pourrait entraîner le blocage du programme si l'utilisateur fournit un argument qui n'était pas attendu. Par exemple, si l'utilisateur effectue un appel tel que speeding_ticket («chips ahoy»), le programme planterait car le type attendu par la méthode était un entier et non une chaîne.
Vous comprenez maintenant les bases des classes Python
Dans cet article, vous avez découvert le concept de classe Python et d'objet de classe Python. Vous avez également été initié aux idées sur lesquelles une classe python est construite, telles que: l'encapsulation, l'identifiant 'self', les méthodes d'accès et les méthodes mutator.
Avec ces informations, vous devriez pouvoir créer vous-même une classe Python simple et la tester 