Supposons que nous voulions créer un système pour gérer une bibliothèque.

Nous avons besoin de

créer différentes classes pour représenter les objets dans notre système, tels que "Livre", "Auteur" et
"Bibliothèque".

1. Classe : Une classe est un modèle ou un plan pour créer des objets. Dans notre exemple, nous aurions
les classes "Livre", "Auteur" et "Bibliothèque".

```python

class Livre:

pass

class Auteur:

pass

class Bibliothèque:

pass

```

2. Constructeur : Un constructeur est une méthode spéciale qui est appelée lors de la création d'un
nouvel objet pour initialiser ses attributs. Dans notre exemple, nous pourrions ajouter un constructeur à
la classe "Livre" pour initialiser son titre et son auteur.

```python

class Livre:

def __init__(self, titre, auteur):

self.titre = titre
 self.auteur = auteur

```

3. Attributs : Les attributs sont des variables associées à une classe. Dans notre exemple, les classes
"Livre" et "Auteur" auraient des attributs tels que "titre", "auteur" et "année de publication".

```python

class Livre:

def __init__(self, titre, auteur, annee_publication):

self.titre = titre

self.auteur = auteur

self.annee_publication = annee_publication

class Auteur:

def __init__(self, nom, nationalite):

self.nom = nom

self.nationalite = nationalite

```

4. Méthodes : Les méthodes sont des fonctions définies à l'intérieur d'une classe et sont utilisées pour
effectuer des actions sur les objets de cette classe. Par exemple, nous pourrions ajouter une méthode à
la classe "Livre" pour afficher les détails du livre.

```python

class Livre:

def __init__(self, titre, auteur, annee_publication):

self.titre = titre
 self.auteur = auteur

self.annee_publication = annee_publication

def afficher_details(self):

print("Titre:", self.titre)

print("Auteur:", self.auteur.nom)

print("Année de publication:", self.annee_publication)

```

5. Objet : Un objet est une instance d'une classe. Par exemple, nous pouvons créer un objet de la classe
"Livre" pour représenter un livre spécifique.

```python

auteur1 = Auteur("J.K. Rowling", "Britannique")

livre1 = Livre("Harry Potter à l'école des sorciers", auteur1, 1997)

livre1.afficher_details() # Affiche les détails du livre

```

6. Héritage : L'héritage permet de créer une nouvelle classe (appelée classe dérivée ou sous-classe) à
partir d'une classe existante (appelée classe de base ou superclasse) en héritant de ses attributs et
méthodes. Par exemple, nous pouvons créer une classe "LivreEnfant" qui hérite de la classe "Livre" et
ajoute un nouvel attribut spécifique aux livres pour enfants.

```python

class LivreEnfant(Livre):

def __init__(self, titre, auteur, annee_publication, age_recommande):

 super().__init__(titre, auteur, annee_publication)

self.age_recommande = age_recommande

```

7. Encapsulation : L'encapsulation est une technique qui consiste à regrouper les données et les
méthodes connexes d'une classe en une seule unité. En Python, cela est souvent réalisé en définissant
les attributs comme étant privés et en fournissant des méthodes d'accès (getters) et de modification
(setters). Par exemple, nous pouvons ajouter des getters et des setters pour l'attribut "titre" de la classe
"Livre".

```python

class Livre:

def __init__(self, titre, auteur, annee_publication):

self._titre = titre

self.auteur = auteur

self.annee_publication = annee_publication

def get_titre(self):

return self._titre

def set_titre(self, nouveau_titre):

self._titre = nouveau_titre

```

8. Accesseurs et mutateurs : Les accesseurs (getters) et les mutateurs (setters) sont des méthodes
utilisées pour accéder aux attributs privés et les modifier respectivement. Dans notre exemple, nous
avons ajouté des méthodes "get_titre()" et "set_titre()" comme accesseur et mutateur pour l'attribut
"titre".
9. Classe Abstraite : Une classe abstraite est une classe qui ne peut pas être instanciée et sert de modèle
pour d'autres classes. En Python, nous utilisons le module abc pour définir des classes abstraites. Par
exemple, nous pouvons créer une classe abstraite "Media" pour représenter différents types de médias,
tels que les livres et les films.

```python

from abc import ABC, abstractmethod

class Media(ABC):

@abstractmethod

def afficher_details(self):

pass

```

10. Polymorphisme : Le polymorphisme permet à des objets de différentes classes d'être traités de
manière similaire s'ils implémentent des méthodes avec la même signature. Par exemple, nous pouvons
avoir une liste d'objets de différentes classes et appeler la méthode "afficher_details()" de chaque objet
de manière polymorphique.

```python

livre1 = Livre("Harry Potter à l'école des sorciers", auteur1, 1997)

livre_enfant1 = LivreEnfant("Le Petit Prince", auteur2, 1943, "3+")

liste_medias = [livre1, livre_enfant1]

for media in liste_medias:

media.afficher_details()
```

11. Surcharge : En Python, la surcharge des méthodes n'est pas directement prise en charge comme
dans certains autres langages de programmation. Cependant, vous pouvez utiliser des techniques telles
que la définition de méthodes avec des arguments par défaut ou l'utilisation de méthodes spéciales
pour simuler la surcharge. Par exemple, nous pouvons définir une méthode spéciale "__str__()" pour la
classe "Livre" afin de personnaliser la représentation d'un objet "Livre" lorsqu'il est converti en chaîne
de caractères.

```python

class Livre:

def __init__(self, titre, auteur, annee_publication):

self.titre = titre

self.auteur = auteur

self.annee_publication = annee_publication

def __str__(self):

return f"Livre: {self.titre} ({self.annee_publication})"

```

12. Généricité : La généricité permet de créer des classes ou des fonctions qui peuvent être utilisées
avec différents types de données. En Python, nous pouvons utiliser des types génériques tels que "Any"
pour indiquer qu'un type spécifique peut être utilisé. Par exemple, nous pourrions créer une classe
générique "Pile" qui peut être utilisée pour stocker différents types d'objets.

```python

class Pile(Generic[T]):

def __init__(self):

self.elements: List[T] = []
 def empiler(self, element: T):

self.elements.append(element)

def depiler(self) -> T:

return self.elements.pop()

```