1

Formation Complète en Python

Table des Matières

1. Introduction à Python
2. Installation et Configuration
3. Syntaxe de Base
4. Types de Données
5. Structures de Contrôle
6. Fonctions
7. Structures de Données Avancées
8. Programmation Orientée Objet
9. Gestion des Erreurs
10. Modules et Packages
11. Manipulation de Fichiers
12. Bibliothèques Importantes
13. Bases de Données
14. Développement Web
15. Data Science et Analyse
16. Tests et Débogage
17. Bonnes Pratiques
18. Projets Pratiques

Durée de la formation : 03 mois

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 2

1. Introduction à Python

1.1 Qu'est-ce que Python ?

Python est un langage de programmation interprété, orienté objet et de haut niveau créé par
Guido van Rossum en 1991. Il se distingue par :

Avantages de Python :

• Syntaxe claire et lisible : Proche du langage naturel

• Polyvalence : Web, data science, IA, automatisation, jeux
• Grande communauté : Support et ressources abondantes
• Bibliothèques riches : Plus de 300 000 packages disponibles
• Multiplateforme : Windows, Mac, Linux
• Open source : Gratuit et libre d'utilisation

Domaines d'application :

• Développement web (Django, Flask)

• Data Science et Machine Learning
• Automatisation et scripts
• Applications desktop
• Jeux vidéo
• Applications mobiles
• Intelligence artificielle

1.2 Philosophie Python - Le Zen de Python

import this

Principes fondamentaux :

• Beau vaut mieux que laid

• Explicite vaut mieux qu'implicite
• Simple vaut mieux que complexe
• La lisibilité compte
• Il devrait y avoir une façon évidente de le faire

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 3

2. Installation et Configuration

2.1 Installation de Python

Windows :

1. Télécharger depuis [Link]

2. Cocher "Add Python to PATH"
3. Installer avec les options par défaut

Mac :

# Via Homebrew (recommandé)

brew install python3

# Ou télécharger depuis [Link]

Linux (Ubuntu/Debian) :

sudo apt update

sudo apt install python3 python3-pip

2.2 Environnements de Développement

IDLE : Interface intégrée avec Python

PyCharm : IDE professionnel complet

VS Code : Éditeur léger avec extensions Python

Jupyter Notebook : Idéal pour data science

Spyder : Orienté scientifique

2.3 Environnements Virtuels

# Créer un environnement virtuel

python -m venv mon_env

# Activer (Windows)
mon_env\Scripts\activate
Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 4

# Activer (Mac/Linux)
source mon_env/bin/activate

# Désactiver
deactivate

2.4 Gestionnaire de Packages (pip)

# Installer un package
pip install numpy

# Installer plusieurs packages

pip install numpy pandas matplotlib

# Installer depuis [Link]

pip install -r [Link]

# Lister les packages installés

pip list

# Mettre à jour un package

pip install --upgrade numpy

3. Syntaxe de Base

3.1 Premier Programme

# Afficher "Hello World"

print("Hello, World!")

# Commentaire sur une ligne

"""
Commentaire
sur plusieurs
lignes
"""

3.2 Variables et Affectation

# Déclaration de variables
nom = "Alice"
age = 25
taille = 1.70
est_etudiant = True

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 5

# Affectation multiple
x, y, z = 1, 2, 3
a = b = c = 0

# Conventions de nommage
nom_utilisateur = "john" # snake_case (recommandé)
NOM_CONSTANT = "VALEUR" # Constantes en majuscules

3.3 Entrée et Sortie

# Saisie utilisateur
nom = input("Entrez votre nom : ")
age = int(input("Entrez votre âge : "))

# Affichage formaté
print(f"Bonjour {nom}, vous avez {age} ans")
print("Nom : {} - Age : {}".format(nom, age))
print("Nom : %s - Age : %d" % (nom, age))

3.4 Opérateurs

Opérateurs Arithmétiques :

a, b = 10, 3

addition = a + b # 13
soustraction = a - b # 7
multiplication = a * b # 30
division = a / b # 3.333...
division_entiere = a // b # 3
modulo = a % b # 1
puissance = a ** b # 1000

Opérateurs de Comparaison :

x, y = 5, 10

egal = (x == y) # False
different = (x != y) # True
inferieur = (x < y) # True
superieur = (x > y) # False
inf_egal = (x <= y) # True
sup_egal = (x >= y) # False

Opérateurs Logiques :

a, b = True, False

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 6

et_logique = a and b # False

ou_logique = a or b # True
negation = not a # False

4. Types de Données

4.1 Types de Base

Nombres :

# Entiers (int)
age = 25
population = 1_000_000 # Séparateurs pour lisibilité

# Flottants (float)
pi = 3.14159
temperature = -15.5

# Complexes (complex)
nombre_complexe = 3 + 4j

# Conversion de types
age_str = str(age) # "25"
pi_int = int(pi) # 3
age_float = float(age) # 25.0

Booléens :

est_actif = True
est_ferme = False

# Valeurs considérées comme False

print(bool(0)) # False
print(bool("")) # False
print(bool([])) # False
print(bool(None)) # False

# Valeurs considérées comme True

print(bool(1)) # True
print(bool("text")) # True
print(bool([1])) # True

4.2 Chaînes de Caractères (str)

# Création de chaînes

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 7

nom = "Alice"
prenom = 'Bob'
texte = """Texte
sur plusieurs
lignes"""

# Échappement
chemin = "C:\\Users\\nom\\Documents"
citation = "Il a dit : \"Bonjour\""

# Chaînes brutes (raw strings)

regex = r"\d+\.\d+"

# Opérations sur chaînes

prenom = "Alice"
nom = "Dupont"

# Concaténation
nom_complet = prenom + " " + nom
nom_complet = f"{prenom} {nom}" # f-string (recommandé)

# Méthodes utiles
print([Link]()) # ALICE
print([Link]()) # alice
print([Link]()) # Alice
print([Link]('a')) # 0
print([Link]('A', 'E')) # Elice
print([Link]('i')) # ['Al', 'ce']
print(" Alice ".strip()) # "Alice"

# Formatage avancé
prix = 19.99
print(f"Prix : {prix:.2f}€") # Prix : 19.99€
print(f"Prix : {prix:>10.2f}€") # Alignement droite

4.3 Listes (list)

# Création
fruits = ["pomme", "banane", "orange"]
nombres = [1, 2, 3, 4, 5]
mixte = ["texte", 42, True, 3.14]
vide = []

# Accès aux éléments

premier = fruits[0] # "pomme"
dernier = fruits[-1] # "orange"
sous_liste = fruits[1:3] # ["banane", "orange"]

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 8

# Modification
fruits[0] = "poire" # ["poire", "banane", "orange"]
[Link]("kiwi") # Ajouter à la fin
[Link](1, "mangue") # Insérer à l'index 1
[Link]("banane") # Supprimer par valeur
element = [Link]() # Retirer et retourner le dernier
element = [Link](0) # Retirer et retourner le premier

# Méthodes utiles
[Link](["citron", "lime"]) # Ajouter plusieurs éléments
[Link]() # Trier sur place
nouveau = sorted(fruits) # Nouvelle liste triée
[Link]() # Inverser
nombre = [Link]("pomme") # Compter occurrences
index = [Link]("orange") # Trouver l'index

# Compréhensions de liste
carres = [x**2 for x in range(10)] # [0, 1, 4, 9, ...]
pairs = [x for x in range(20) if x % 2 == 0]

4.4 Tuples (tuple)

# Création (immutable)
coordonnees = (10, 20)
couleurs = ("rouge", "vert", "bleu")
singleton = (42,) # Virgule obligatoire pour un seul élément

# Accès (comme les listes)

x, y = coordonnees # Déballage
rouge = couleurs[0]

# Avantages des tuples

# - Plus rapides que les listes
# - Peuvent servir de clés dans les dictionnaires
# - Garantissent l'immutabilité des données

4.5 Dictionnaires (dict)

# Création
personne = {
"nom": "Dupont",
"prenom": "Alice",
"age": 30
}

# Autre syntaxe

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 9

personne = dict(nom="Dupont", prenom="Alice", age=30)

# Accès et modification
nom = personne["nom"] # "Dupont"
nom = [Link]("nom", "Inconnu") # Avec valeur par défaut
personne["age"] = 31 # Modification
personne["ville"] = "Paris" # Ajout

# Méthodes utiles
cles = [Link]() # dict_keys(['nom', 'prenom',
'age'])
valeurs = [Link]() # dict_values(['Dupont', 'Alice',
31])
items = [Link]() # dict_items([('nom', 'Dupont'),
...])

# Suppression
del personne["ville"] # Supprimer une clé
age = [Link]("age", 0) # Retirer et retourner
[Link]() # Vider le dictionnaire

# Compréhensions de dictionnaire
carres = {x: x**2 for x in range(5)} # {0: 0, 1: 1, 2: 4, ...}

4.6 Ensembles (set)

# Création
fruits = {"pomme", "banane", "orange"}
nombres = set([1, 2, 3, 4, 5])
vide = set() # Attention : {} crée un dict vide

# Opérations
[Link]("kiwi") # Ajouter
[Link]("pomme") # Supprimer (erreur si absent)
[Link]("pomme") # Supprimer (pas d'erreur si
absent)

# Opérations mathématiques
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

union = a | b # {1, 2, 3, 4, 5, 6}
intersection = a & b # {3, 4}
difference = a - b # {1, 2}
diff_symetrique = a ^ b # {1, 2, 5, 6}

# Tests d'appartenance

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 10

print(3 in a) # True
print([Link](b)) # False
print([Link]({1, 2})) # True

5. Structures de Contrôle

5.1 Conditions (if/elif/else)

# Structure de base
age = 18

if age >= 18:

print("Vous êtes majeur")
else:
print("Vous êtes mineur")

# Conditions multiples
note = 85

if note >= 90:

mention = "Excellent"
elif note >= 80:
mention = "Très bien"
elif note >= 70:
mention = "Bien"
elif note >= 60:
mention = "Assez bien"
else:
mention = "Insuffisant"

print(f"Mention : {mention}")

# Opérateur ternaire
statut = "majeur" if age >= 18 else "mineur"

# Conditions complexes
temperature = 25
humidite = 60

if temperature > 20 and humidite < 70:

print("Temps agréable")
elif temperature < 0 or humidite > 90:
print("Temps désagréable")
else:
print("Temps correct")

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 11

# Test de présence
fruits = ["pomme", "banane", "orange"]
if "pomme" in fruits:
print("Il y a des pommes")

# Test de type
valeur = 42
if isinstance(valeur, int):
print("C'est un entier")

5.2 Boucles

Boucle for :

# Parcourir une liste

fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
print(f"J'aime les {fruit}s")

# Avec index
for i, fruit in enumerate(fruits):
print(f"{i}: {fruit}")

# Parcourir un dictionnaire
personne = {"nom": "Alice", "age": 30}
for cle, valeur in [Link]():
print(f"{cle}: {valeur}")

# Range (plage de nombres)

for i in range(5): # 0 à 4
print(i)

for i in range(1, 6): # 1 à 5

print(i)

for i in range(0, 10, 2): # 0, 2, 4, 6, 8

print(i)

# Compréhensions (plus pythonique)

carres = [x**2 for x in range(10)]
pairs = [x for x in range(20) if x % 2 == 0]

Boucle while :

# Boucle while basique

compteur = 0
while compteur < 5:

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 12

print(f"Compteur : {compteur}")
compteur += 1

# Boucle infinie avec break

while True:
reponse = input("Tapez 'quit' pour sortir : ")
if [Link]() == 'quit':
break
print(f"Vous avez tapé : {reponse}")

# Continue pour passer à l'itération suivante

for i in range(10):
if i % 2 == 0:
continue # Ignorer les nombres pairs
print(f"Nombre impair : {i}")

# Else avec les boucles (exécuté si pas de break)

for i in range(5):
if i == 10:
break
print(i)
else:
print("Boucle terminée normalement")

5.3 Contrôle de Flux Avancé

# Match-case (Python 3.10+)

def analyser_type(valeur):
match valeur:
case int() if valeur > 0:
return "Entier positif"
case int() if valeur < 0:
return "Entier négatif"
case 0:
return "Zéro"
case str() if len(valeur) > 10:
return "Chaîne longue"
case str():
return "Chaîne courte"
case list() | tuple():
return "Séquence"
case _:
return "Autre type"

# Boucles imbriquées
for i in range(3):
for j in range(3):

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 13

print(f"({i}, {j})", end=" ")

print() # Nouvelle ligne

# Break et continue dans boucles imbriquées

for i in range(5):
for j in range(5):
if j == 3:
break # Sort seulement de la boucle interne
print(f"{i}-{j}", end=" ")
print()

6. Fonctions

6.1 Définition et Appel

# Fonction simple
def saluer():
print("Bonjour !")

saluer() # Appel de la fonction

# Fonction avec paramètres

def saluer_personne(nom, age):
print(f"Bonjour {nom}, vous avez {age} ans")

saluer_personne("Alice", 25)

# Fonction avec valeur de retour

def additionner(a, b):
resultat = a + b
return resultat

somme = additionner(5, 3)
print(somme) # 8

# Retour multiple
def diviser(a, b):
quotient = a // b
reste = a % b
return quotient, reste

q, r = diviser(10, 3)
print(f"10 ÷ 3 = {q} reste {r}")

6.2 Paramètres Avancés

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 14

# Paramètres par défaut

def presenter(nom, age=18, ville="Paris"):
print(f"{nom}, {age} ans, habite à {ville}")

presenter("Alice") # Utilise les valeurs par

défaut
presenter("Bob", 25) # age=25, ville="Paris"
presenter("Charlie", ville="Lyon") # Paramètre nommé

# Paramètres variables (*args)

def additionner_tout(*nombres):
total = 0
for nombre in nombres:
total += nombre
return total

print(additionner_tout(1, 2, 3, 4, 5)) # 15

# Paramètres mots-clés variables (**kwargs)

def afficher_infos(**infos):
for cle, valeur in [Link]():
print(f"{cle}: {valeur}")

afficher_infos(nom="Alice", age=25, ville="Paris")

# Combinaison de tous les types

def fonction_complete(arg_obligatoire, arg_defaut="defaut",
*args, **kwargs):
print(f"Obligatoire: {arg_obligatoire}")
print(f"Défaut: {arg_defaut}")
print(f"Args supplémentaires: {args}")
print(f"Kwargs: {kwargs}")

fonction_complete("test", "nouveau", 1, 2, 3, nom="Alice",

age=25)

6.3 Portée des Variables (Scope)

# Variables globales et locales

x = 10 # Variable globale

def fonction():
x = 20 # Variable locale
print(f"x local: {x}")

fonction() # x local: 20
print(f"x global: {x}") # x global: 10

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 15

# Mot-clé global
compteur = 0

def incrementer():
global compteur
compteur += 1

incrementer()
print(compteur) # 1

# Mot-clé nonlocal (pour fonctions imbriquées)

def externe():
x = 10

def interne():
nonlocal x
x += 5

interne()
print(x) # 15

externe()

6.4 Fonctions Lambda

# Fonction lambda simple

carre = lambda x: x**2
print(carre(5)) # 25

# Équivalent avec def

def carre_def(x):
return x**2

# Utilisation avec map, filter, sort

nombres = [1, 2, 3, 4, 5]
carres = list(map(lambda x: x**2, nombres)) # [1, 4, 9, 16, 25]
pairs = list(filter(lambda x: x % 2 == 0, nombres)) # [2, 4]

# Tri avec key personnalisée

personnes = [("Alice", 25), ("Bob", 30), ("Charlie", 20)]
[Link](key=lambda personne: personne[1]) # Tri par âge
print(personnes) # [('Charlie', 20), ('Alice', 25), ('Bob', 30)]

6.5 Décorateurs (Concepts Avancés)

# Décorateur simple

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 16

def mon_decorateur(func):
def wrapper():
print("Avant l'exécution")
func()
print("Après l'exécution")
return wrapper

@mon_decorateur
def dire_bonjour():
print("Bonjour !")

dire_bonjour()
# Sortie:
# Avant l'exécution
# Bonjour !
# Après l'exécution

# Décorateur avec paramètres

import time
from functools import wraps

def mesurer_temps(func):
@wraps(func)
def wrapper(*args, **kwargs):
debut = [Link]()
resultat = func(*args, **kwargs)
fin = [Link]()
print(f"{func.__name__} a pris {fin - debut:.4f}
secondes")
return resultat
return wrapper

@mesurer_temps
def calcul_lent():
[Link](1)
return "Terminé"

calcul_lent()

7. Structures de Données Avancées

7.1 Collections Module

from collections import defaultdict, Counter, deque, namedtuple

# defaultdict - dictionnaire avec valeur par défaut

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 17

dd = defaultdict(list)
dd['fruits'].append('pomme')
dd['fruits'].append('banane')
print(dd) # defaultdict(<class 'list'>, {'fruits': ['pomme',
'banane']})

# Counter - compteur d'éléments

mots = ['pomme', 'banane', 'pomme', 'orange', 'banane', 'pomme']
compteur = Counter(mots)
print(compteur) # Counter({'pomme': 3, 'banane': 2, 'orange':
1})
print(compteur.most_common(2)) # [('pomme', 3), ('banane', 2)]

# deque - liste doublement liée

dq = deque([1, 2, 3])
[Link](0) # Ajouter à gauche
[Link](4) # Ajouter à droite
print(dq) # deque([0, 1, 2, 3, 4])

# namedtuple - tuple nommé

Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(f"x: {p.x}, y: {p.y}") # x: 10, y: 20

7.2 Compréhensions Avancées

# Compréhensions de liste conditionnelles

nombres = range(20)
pairs_carres = [x**2 for x in nombres if x % 2 == 0]
# [0, 4, 16, 36, 64, 100, 144, 196, 256, 324]

# Compréhensions imbriquées
matrice = [[j for j in range(i, i+3)] for i in range(3)]
# [[0, 1, 2], [1, 2, 3], [2, 3, 4]]

# Aplatir une matrice

matrice = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
aplatie = [element for ligne in matrice for element in ligne]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Compréhensions de dictionnaire
mots = ['hello', 'world', 'python']
longueurs = {mot: len(mot) for mot in mots}
# {'hello': 5, 'world': 5, 'python': 6}

# Compréhensions d'ensemble

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 18

voyelles = {[Link]() for char in "Hello World" if

[Link]() in 'aeiou'}
# {'e', 'o'}

7.3 Manipulation de Chaînes Avancée

import re
import string

# Expressions régulières
texte = "Mon email est alice@[Link] et mon numéro est 06-12-
34-56-78"
emails = [Link](r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-
z]{2,}\b', texte)
telephones = [Link](r'\d{2}-\d{2}-\d{2}-\d{2}-\d{2}', texte)

# Template de chaîne
from string import Template
template = Template("Bonjour $nom, vous avez $age ans")
message = [Link](nom="Alice", age=25)

# Formatage avancé
prix = 1234.567
print(f"{prix:,.2f}") # 1,234.57
print(f"{prix:>10.2f}") # " 1234.57"
print(f"{prix:0>10.2f}") # "001234.57"

# Manipulation de caractères
texte = "Hello World"
print([Link]([Link]('lo', '10'))) # "He110
W0r1d"

8. Programmation Orientée Objet

8.1 Classes et Objets de Base

# Définition de classe simple

class Personne:
# Attribut de classe (partagé par tous les objets)
espece = "Homo sapiens"

def __init__(self, nom, age):

# Attributs d'instance
[Link] = nom
[Link] = age

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 19

def presenter(self):
return f"Je suis {[Link]} et j'ai {[Link]} ans"

def avoir_anniversaire(self):
[Link] += 1
print(f"Joyeux anniversaire ! {[Link]} a maintenant
{[Link]} ans")

# Création d'objets
alice = Personne("Alice", 25)
bob = Personne("Bob", 30)

print([Link]()) # Je suis Alice et j'ai 25 ans

alice.avoir_anniversaire() # Joyeux anniversaire ! Alice a
maintenant 26 ans

8.2 Méthodes Spéciales (Magic Methods)

class Rectangle:
def __init__(self, largeur, hauteur):
[Link] = largeur
[Link] = hauteur

def __str__(self):
return f"Rectangle({[Link]}x{[Link]})"

def __repr__(self):
return f"Rectangle(largeur={[Link]},
hauteur={[Link]})"

def __eq__(self, other):

if isinstance(other, Rectangle):
return [Link] == [Link] and [Link]
== [Link]
return False

def __add__(self, other):

if isinstance(other, Rectangle):
return Rectangle([Link] + [Link],
[Link] + [Link])
return NotImplemented

def __len__(self):
return int(2 * ([Link] + [Link])) #
Périmètre

def __getitem__(self, key):

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou
 20

if key == 0:
return [Link]
elif key == 1:
return [Link]
else:
raise IndexError("Index out of range")

@property
def aire(self):
return [Link] * [Link]

# Utilisation
rect1 = Rectangle(5, 3)
rect2 = Rectangle(5, 3)
rect3 = Rectangle(2, 4)

print(rect1) # Rectangle(5x3)
print(repr(rect1)) # Rectangle(largeur=5, hauteur=3)
print(rect1 == rect2) # True
print(rect1 == rect3) # False
print(rect1 + rect3) # Rectangle(7x7)
print(len(rect1)) # 16 (périmètre)
print(rect1[0], rect1[1]) # 5 3
print([Link]) # 15

8.3 Héritage

# Classe de base
class Animal:
def __init__(self, nom, espece):
[Link] = nom
[Link] = espece

def faire_bruit(self):
return "L'animal fait un bruit"

def presenter(self):
return f"Je suis {[Link]}, un {[Link]}"

# Classe dérivée

Formation proposée par M. Latini Jocelyn KIANSI KASSA, élève professeur en Mathématiques &
Informatiques à l’École Normale Supérieure de Natitingou