# Python : création de classes et d’objets

Les classes Python sont comme des **plans de construction ou des gabarits**. Elles permettent d’écrire du code réutilisable sous forme d’attributs et de méthodes de classe.

## Classe Python : qu’est-ce que c’est ?

Une classe est un **concept abstrait** qui définit les attributs et les méthodes qu’un objet peut avoir. Les classes Python servent de modèle pour la création d’objets concrets qui sont des instances de cette classe. Par exemple, une classe peut s’appeler `voiture`, qui possède des attributs tels que la couleur et la marque, ainsi que les méthodes `conduire__` ou `freiner__`.

Chaque objet d’une classe peut avoir ses propres valeurs pour les attributs, mais **partage les méthodes et le cadre comportemental de base avec d’autres instances** de la même classe. Par exemple, un objet `ma_voiture` de la classe `voiture` peut être créé avec la couleur `__Rouge__` et la marque `__Toyota__`, et les méthodes `conduire__` ou `freiner__` de la classe seront automatiquement transférées à l’instance.

## Créer des classes Python

En Python, vous définissez les classes à l’aide du mot-clé `class`.

```python
class MyClass:
    # Constructor method called when creating an object
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2
    # Method defined within the class
    def my_method(self):
        return f"Attribute 1: {self.attribute1}, Attribute 2: {self.attribute2}"
```

Dans ce code Python, nous créons une classe appelée `MyClass`. Celle-ci possède un **constructeur** `__init__` qui est appelé lors de la création d’un objet et qui initialise deux attributs, `attribute1` et `attribute2`. La méthode `my_method` renvoie une chaîne de caractères formatée qui contient les valeurs de ces attributs.

Pour dériver un objet de cette classe, utiliser le nom de la classe suivi de parenthèses :

```python
object1 = MyClass("Value 1", "Value 2")
# Calling a method of the object
result = object1.my_method()
```

## Exemples d’utilisation des classes Python

Les classes Python peuvent créer des systèmes complexes et des relations entre différentes entités. Ci-dessous, nous présentons des possibilités de travailler avec des classes Python.

### La fonction `__str()__`

La fonction `__str__()` de Python est une méthode spéciale que vous pouvez définir dans les classes Python. Lorsqu’elle est implémentée, elle renvoie une chaîne de caractères qui représente une **représentation conviviale d’un objet**. Vous pouvez appliquer la fonction `str()` directement à l’objet ou la combiner avec une instruction `print()`.

```python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"
person1 = Person("Alice", 30)
print(person1) # Output: Name: Alice, Age: 30
```

Dans notre code, la méthode `__str__()` crée dans la classe `Person` une **chaîne de caractères formatée** contenant le nom et l’âge d’une personne. Quand `print(person1)` est exécutée, elle appelle automatiquement la méthode `__str__()` de l’objet `person1` et affiche la chaîne de caractères renvoyée par cette méthode.

### Définir des méthodes dans les classes Python

En Python, vous avez la possibilité de **définir des méthodes au sein d’une classe** pour effectuer des opérations sur les objets de cette classe. Ces méthodes peuvent ensuite être appelées par les objets créés.

```python
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
     
    def area(self):
        return self.length * self.width
    def perimeter(self):
        return 2 * (self.length + self.width)
# Creating an object of the class
my_rectangle = Rectangle(5, 10)
# Calling methods of the object
area = my_rectangle.area()
perimeter = my_rectangle.perimeter()
# Printing the calculated values
print("Area =", area) # Output: Area = 50
print("Perimeter =", perimeter) # Output: Perimeter = 30
```

Dans cet exemple Python, nous créons la classe `Rectangle`, qui comprend les deux méthodes `area()` et `perimeter()`. Celles-ci servent à calculer la surface et le périmètre d’un rectangle, en se basant sur les valeurs de longueur et de largeur passées lors de l’initialisation de l’objet. En Python, `self` dans une méthode de classe représente une **référence à l’objet courant** sur lequel la méthode est appliquée.

L’objet `my_rectangle` est créé avec une longueur de 5 et une largeur de 10. Ensuite, nous appelons les méthodes `area()` et `perimeter()` sur cet objet pour calculer les valeurs correspondantes.

### Modifier les propriétés des objets

L’opérateur de point `.` peut être utilisé pour accéder aux **attributs spécifiques de l’objet** et mettre à jour leurs valeurs. Il est possible d’attribuer directement de nouvelles valeurs à l’attribut.

```python
person1.name = "Sarah"
person1.age = 35
```

Le mot-clé `del` sert à supprimer les propriétés d’un objet.

```python
del person1.name
```

Note Vous devez tenir compte du fait que les variables d’instance sont différentes de [Python Class Variables](https://www.ionos.com/fr-ch/digitalguide/sites-internet/developpement-web/python-class-variables/). Les variables de classe sont **définies en dehors du constructeur** et ne peuvent être modifiées qu’en utilisant le nom de la classe.


This is a markdown version of: [https://www.ionos.com/fr-ch/digitalguide/sites-internet/developpement-web/classes-python/](https://www.ionos.com/fr-ch/digitalguide/sites-internet/developpement-web/classes-python/) for AI/LLM consumption.