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.
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.
Lire la suite :Méthodes de classe en Python :les différences importantes
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, excès de vitesse et couleur.
Cette classe de voitures 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.
Voiture de classe :
#Constructeur
#la méthode init est responsable de l'initialisation des valeurs des #variables d'instance dans la classe.
def __init__(self, car_name, driver_name, license_plate_number,
vitesse_actuelle, charge_vitesse, couleur) :
self.nom_voiture =nom_voiture
self._driver_name =driver_name
self._license_plate_number =license_plate_number
self._current_speed =current_speed
self._speeding_charge =speeding_charge
self._colour =couleur
#Méthodes d'accès
#La méthode get_car_name renvoie le nom de la voiture
def get_car_name(self):
renvoie self._car_name
#La méthode get_driver_name renvoie le nom du pilote
def get_driver_name(self):
renvoie self._driver_name
#La méthode get_license_plate renvoie la plaque d'immatriculation de la voiture
def get_license_plate(self):
retourner self._license_plate
#La méthode get_current_speed renvoie la vitesse actuelle à laquelle la voiture se #déplace
def get_current_speed(self):
retour self._current_speed
#La méthode get_speeding_charge renvoie le montant total d'argent que le
#conducteur doit payer pour excès de vitesse
def get_speeding_charge(self):
retour auto._speeding_charge
#La méthode get_colour renvoie la couleur de notre douce balade !
def get_color(self):
retour self._color
#Méthodes mutatrices
#La valeur set_driver change le conducteur de notre voiture.
def set_driver(self, new_driver):
self._driver_name =nouveau_pilote
#La méthode speeding_ticket garantit que le conducteur est facturé 50 dollars lorsqu#il est surpris à excès de vitesse supérieur à 140 miles par heure :(
def speeding_ticket(self, current_speed):
si vitesse_courante <=140 :
retourner Faux
autre:
self._speeding_charge +=50
retourner Vrai
#La méthode make_payment garantit que le conducteur est en mesure de payer tout le #montant qu'il doit pour les frais d'excès de vitesse.
def make_payment(self, amount_paid):
self._speeding_charge -=montant_payé
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, le get_colour méthode 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 (c'est-à-dire 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'.
En effet, 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.
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 en utilisant la syntaxe suivante :
#créer notre propre Bugatti :)
Voiture ("Bugatti", "David Sasu", 90828, 0, 0, "Rouge Cerise") L'exécution de ce code se traduit par un appel à la méthode __init__ dans la classe Car. La responsabilité de cette méthode est de générer un objet de 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 :
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 :
Ce sont des méthodes écrites pour modifier les informations d'état d'une instance d'objet. Dans la classe Car, les méthodes de mutation qui ont été écrites sont :
« 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 mieux comprendre le concept d'encapsulation, consultez notre article sur l'encapsulation.
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 les types des paramètres du constructeur. Cela pourrait entraîner le plantage du programme si l'utilisateur fournit un argument inattendu. 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.
Dans cet article, vous avez été initié au 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 de mutation.
Avec ces informations, vous devriez être capable de créer vous-même une classe Python simple et de la tester :)