Partie 01: fonction lambda

2.1 Qu'est-ce qu'une fonction lambda ?

Définition : Fonction anonyme (sans nom) définie Composants :

en une seule ligne.
• lambda : mot-clé,
Analogie :Fonction normale = recette complète
• paramètres : variables d'entrée (comme dans une
dans un cahier
fonction)
Lambda = post-it avec formule rapide
• : : deux-points
2.2 Comparaison fonction normale vs lambda (voir
• expression : ce qui est calculé et retourné
le code)
PARTIE 3 : MAP, FILTER, REDUCE
PARTIE 3 : MAP, FILTER, REDUCE

3.1 map() - Transformer chaque élément 3.2 filter() - Garder certains éléments

Définition : Applique une fonction à tous les Garde seulement les éléments pour lesquels la
éléments d'une liste. fonction retourne True.

Syntaxe : Syntaxe :
PARTIE 3 : MAP, FILTER, REDUCE

3.3 reduce() - Accumuler/Réduire

Définition : Réduit une liste à une seule valeur en appliquant une fonction de
façon cumulative.

Important : Nécessite l'import du module functools.

PARTIE 4 : GESTION D'ERREURS (BASES)

4.1 Pourquoi gérer les erreurs ?

Sans gestion d'erreurs :

Avec gestion d’erreur

PARTIE 4 : GESTION D'ERREURS (BASES)

4.2 Structure try/except, Syntaxe de base :

Avec gestion d’erreur

Voir les exemples sur thonny

PARTIE 4 : GESTION D'ERREURS (BASES)

4.4 Erreurs Python courantes

 PARTIE 5 : MANIPULATION DE DONNÉES
STRUCTURÉES

5.1 Structure : Liste de dictionnaires

En analyse de données, on travaille souvent avec des tableaux représentés par des listes de
dictionnaires.

Exemple : Base d'étudiants

Structure :

• Chaque dictionnaire = une ligne (un étudiant)

• Chaque clé = une colonne (nom, age, notes)

 5.2 Opérations courantes

1. Extraire une colonne 3. Calculer des statistiques

2. Filtrer les données

 5.2 Opérations courantes

4. Ajouter une colonne calculée 5. Trier les données

SÉANCE 1 : POO - PARTIE 1 (FONDAMENTAUX)
 1. INTRODUCTION À LA POO

1.1 Définition 1.3 Avantages de la POO

La Programmation Orientée Objet (POO) est un •Modularité : Code organisé en unités logiques
paradigme de programmation qui organise le code autour
d'objets plutôt que de fonctions et de procédures.
•Réutilisabilité : Les classes peuvent être utilisées
dans différents contextes
1.2 Concepts fondamentaux

•Maintenabilité : Modifications localisées et

•Classe : Modèle abstrait définissant la structure et le
comportement d'objets
impact limité

•Objet : Instance concrète d'une classe •Abstraction : Masquage de la complexité interne

•Attribut : Variable appartenant à un objet

•Méthode: Fonction appartenant à une classe

 2. CLASSES ET OBJETS

2.1 Définition d'une classe

Syntaxe générale :

Convention : Nom en PascalCase (ex: MaClasse, VoitureElectrique)

2. CLASSES ET OBJETS

2.2 Distinction classe/objet

 3. ATTRIBUTS

3.1 Attributs d'instance 3.1 Attributs d'instance

Les attributs d'instance sont propres à chaque Méthode 2 : Utilisation du constructeur

objet. (recommandée)

Méthode 1 : Affectation directe (déconseillée)

 3. ATTRIBUTS

3.2 Le constructeur __init__

• Méthode spéciale appelée automatiquement

lors de la création d'un objet

• Initialise les attributs de l'instance

• Premier paramètre toujours self

 3. ATTRIBUTS

3.3 Le paramètre self

• Référence à l'instance courante

• Permet d'accéder aux attributs et méthodes de

l'objet

• Passé automatiquement par Python (ne pas

l'inclure lors de l'appel)
3. ATTRIBUTS
 4. MÉTHODES

4.1 Définition 4.2 Méthodes d'instance

Une méthode est une fonction définie à

l'intérieur d'une classe et qui opère sur les
attributs de l'objet.

Syntaxe :
 4. MÉTHODES

4.3 Méthodes avec retour de valeur 4.2 Méthodes d'instance

 Exercice 1
Classe Produit

Créez une classe Produit avec :

• Attributs : nom, prix, quantite

Méthodes :

• ajouter_stock(quantite) : ajoute au stock

• vendre(quantite) : retire du stock si possible

• valeur_stock() : retourne prix × quantité

SÉANCE 02 : POO - PARTIE 2
(ENCAPSULATION)
 1. RAPPEL SÉANCE 01
1.1 Code sans encapsulation

Problèmes :

• Aucun contrôle sur les modifications

• Données incohérentes possibles

• Violation des règles métier

 2. L'ENCAPSULATION
2.1 Définition 2.2 Avantages

L'encapsulation est un principe • Sécurité : Contrôle des valeurs

affectées
fondamental de la POO qui consiste à :

• Maintenance : Modification de
• Cacher les détails d'implémentation
l'implémentation sans impact externe

• Protéger les données contre les • Cohérence : Garantie de l'intégrité des

modifications non contrôlées données

• Exposer une interface publique pour • Abstraction : Simplification de

interagir avec l'objet l'utilisation
 3. ATTRIBUTS PRIVÉS ET PROTÉGÉS
3.1 Conventions de nommage en Python

Python n'a pas de véritables attributs privés, mais utilise des conventions :

3.2 Attributs publics

 3. ATTRIBUTS PRIVÉS ET PROTÉGÉS
3.3 Attributs protégés (un underscore _) 3.4 Attributs privés (double underscore _ _)

Convention : _attribut indique "utilisez cet Name Mangling : Python renomme _ _solde en
attribut avec précaution, c'est interne à la classe" _CompteBancaire_ _solde en interne
 4. GETTERS ET SETTERS
4.1 Définition et Rôle

Avant d'aborder la syntaxe, il faut comprendre pourquoi on utilise des getters et des setters. Considérons le
problème suivant :

La solution : utiliser des getters et des setters pour contrôler l'accès aux attributs.

💡 Règle générale :Un getter permet de lire la valeur d'un attribut privé.Un setter permet de modifier la valeur d'un
attribut privé avec validation
 4. GETTERS ET SETTERS
4.1 Définition et Rôle

Avant d'aborder la syntaxe, il faut comprendre pourquoi on utilise des getters et des setters. Considérons le
problème suivant :

La solution : utiliser des getters et des setters pour contrôler l'accès aux attributs.

💡 Règle générale :Un getter permet de lire la valeur d'un attribut privé.Un setter permet de modifier la valeur d'un
attribut privé avec validation
 4. GETTERS ET SETTERS
4.2 Méthodes d'accès classiques (style Java)

La première approche consiste à créer des méthodes get_xxx() et set_xxx() manuellement.

4. GETTERS ET SETTERS
4.2 Méthodes d'accès classiques (style Java)

**Ce qui se passe en mémoire :**

 4. GETTERS ET SETTERS
4.4 Propriétés calculées (read-only)

Certaines propriétés se calculent à partir d'autres attributs. On définit uniquement un getter, sans setter.
 4. GETTERS ET SETTERS
4.4 Propriétés calculées (read-only)

💡 Avantage : On ne stocke pas aire et perimetre en mémoire. Elles sont recalculées à chaque accès, donc toujours à
jour.
 4. GETTERS ET SETTERS
4.5 Récapitulatif : Quand utiliser quoi ?

À RETENIR

• @property transforme une méthode en attribut

intelligent

• @[Link] ajoute la validation lors de l'écriture

• Sans setter → lecture seule (propriété calculée)

• La syntaxe reste naturelle : [Link] au lieu

de objet.get_attribut()
 Exercices

Exercice 1 : Classe Temperature Exercice 2 : Classe DateNaissance

Créez une classe Temperature avec : Créez une classe DateNaissance avec :
•Attribut privé __celsius • Attributs privés : __jour, __mois, __annee
•Propriété celsius avec validation (≥ -273.15) • Validation : date valide (jour entre 1-31, mois
•Propriété calculée fahrenheit (lecture et écriture) entre 1-12, année entre 1900-2024)
•Propriété calculée kelvin (lecture et écriture) • Propriété calculée age (année actuelle - année de
Contraintes : naissance)
•Température minimale : -273.15°C (zéro absolu) • Méthode est_majeur() retournant True si age ≥
•Conversions :
•F = C × 9/5 + 32
•K = C + 273.15
SÉANCE 03 : HÉRITAGE
 3.1 Qu'est-ce que l'héritage ?

L'héritage est l'un des piliers de la POO. Il permet à une classe enfant (sous-classe) de réutiliser les attributs et
méthodes d'une classe parent (super-classe), et de les étendre ou modifier selon les besoins.

💡 Syntaxe de base
class Enfant(Parent): # Enfant hérite de Parent
pass
Avantages de l'héritage

• Réutilisation du code (DRY : Don't Repeat Yourself)

• Organisation hiérarchique des classes

• Facilite la maintenance et l'évolution du code

 3.2 Héritage simple – Exemple complet
Créons une classe Animal puis des classes Chien et Chat qui en héritent :

class Animal:
def __init__(self, nom, age):
[Link] = nom
[Link] = age

def respirer(self):
print(f"{[Link]} respire.")

def dormir(self):
print(f"{[Link]} dort.")

class Chien(Animal): # Chien hérite d'Animal

def aboyer(self):
print(f"{[Link]} dit : Ouaf !")

class Chat(Animal): # Chat hérite d'Animal

def miauler(self):
print(f"{[Link]} dit : Miaou !")

# Utilisation
rex = Chien("Rex", 3)
[Link]() # hérité → Rex respire.
[Link]() # propre à Chien → Rex dit : Ouaf !

mimi = Chat("Mimi", 5)
[Link]() # hérité → Mimi dort.
 3.3 super() et les constructeurs

Lorsqu'une classe enfant définit son propre __init__, il faut appeler super().__init__(...) pour initialiser les
attributs du parent.
class Animal:
def __init__(self, nom, age):
[Link] = nom
[Link] = age

class Chien(Animal):
def __init__(self, nom, age, race):
super().__init__(nom, age) # appel du constructeur parent
[Link] = race # attribut spécifique à Chien

def presentation(self):
print(f"{[Link]} ({[Link]}), {[Link]} ans")

rex = Chien("Rex", 3, "Berger Allemand")

[Link]() # Rex (Berger Allemand), 3 ans

⚠️ Règle importante
Sans super().__init__(), les attributs du parent ne sont pas initialisés.
Cela causera des AttributeError dès que vous tenterez d'y accéder.
 3.4 Redéfinition de méthodes (Override)

La redéfinition permet à la classe enfant de fournir sa

class Animal:
propre implémentation d'une méthode héritée. def parler(self):
print("L'animal fait un bruit.")
Résumé : Parent vs Enfant class Chien(Animal):
def parler(self): # redéfinition
print("Ouaf !")
Situation Méthode appelée Résultat
class Chat(Animal):
Pas de Méthode du parent Comportement par def parler(self): # redéfinition
redéfinition (héritée) défaut print("Miaou !")
Redéfinition Méthode de l'enfant Comportement
sans super() uniquement remplacé animaux = [Animal(), Chien(), Chat()]
for a in animaux:
Redéfinition Parent puis enfant Comportement étendu [Link]()
avec super() # L'animal fait un bruit.
# Ouaf !
# Miaou !
 🧪 TP Séance 3 — Animal → Chien & Chat

Énoncé du TP Étape 3 – Classe Chat

• Hérite d'Animal
Étape 1 – Classe Animal (base)
• Attribut supplémentaire : interieur (bool)
• Attributs : nom (str), age (int), poids (float)
• Méthodes : miauler(), ronronner(), description()
• Méthodes : description(), respirer(),
redéfinie
manger(aliment)
Étape 4 – Programme principal
Étape 2 – Classe Chien
• Créer une liste d'animaux mixte (Chien, Chat, Animal)
• Hérite d'Animal
• Afficher la description de chaque animal
• Attribut supplémentaire : race (str)
(polymorphisme !)
• Méthodes : aboyer(), chercher_balle(),
• Tester isinstance() pour identifier chaque type
description() redéfinie
Séance 4 — Polymorphisme & Méthodes Spéciales
 4.1 Polymorphisme

Le polymorphisme permet d'appeler la même

méthode sur des objets de types différents — class Animal:
def parler(self): pass
chacun répondant à sa façon. En Python, cela class Chien(Animal):
def parler(self): return "Ouaf !"
fonctionne naturellement grâce au duck typing : peu
class Chat(Animal):
importe la classe, si l'objet a la méthode, ça marche. def parler(self): return "Miaou !"

class Vache(Animal):
def parler(self): return "Meuh !"

animaux = [Chien(), Chat(), Vache()]

for animal in animaux: # même interface →

comportements différents
print([Link]())
# Ouaf !
# Miaou !
# Meuh !
 4.1 Polymorphisme

Polymorphisme sans héritage (Duck Typing)

class Robot:
def parler(self):
return "Bip bip !"

# Robot n'hérite pas d'Animal, mais fonctionne dans la

même boucle !
for obj in [Chien(), Chat(), Robot()]:
print([Link]())
 4.2 Méthodes spéciales : __str__ et __repr__

Les méthodes spéciales (ou méthodes magiques) entourées de class Animal:

def __init__(self, nom, age):
doubles underscores permettent à vos objets d'interagir avec [Link] = nom
[Link] = age
les fonctions Python natives.
def __str__(self):
Méthode Déclenchée par Usage return f"Animal : {[Link]}, {[Link]} ans"
__str__ str(obj) / Affichage lisible (utilisateur)
def __repr__(self):
print(obj)
return f"Animal(nom='{[Link]}',
__repr__ repr(obj) / Représentation technique age={[Link]})"
console (développeur)
__len__ len(obj) Taille / longueur de l'objet def __len__(self):
return [Link] # durée de vie en années

a = Animal("Rex", 5)
print(a) # Animal : Rex, 5 ans (via __str__)
print(repr(a)) # Animal(nom='Rex', age=5) (via
__repr__)
print(len(a)) # 5 (via __len__)
 4.3 Surcharge d'opérateurs

Python permet de redéfinir le comportement des opérateurs (+, -, *, ==, <, >, …) pour vos propres classes.

Opérateur Méthode spéciale Expression déclenchante

+ __add__(self, other) a+b
- __sub__(self, other) a-b
* __mul__(self, other) a*b
/ __truediv__(self, other) a / b
== __eq__(self, other) a == b
< __lt__(self, other) a<b
> __gt__(self, other) a>b
 TP Séance 4 — Classe Fraction

L'objectif est de créer une classe Fraction qui représente une Étape 3 – Opérations arithmétiques
fraction mathématique p/q et qui supporte toutes les opérations • __add__ : addition de deux fractions
arithmétiques courantes.
• __sub__ : soustraction

Étape 1 – Constructeur et validation • __mul__ : multiplication

• Attributs : numerateur (int), denominateur (int) • __truediv__ : division

• Vérifier que le dénominateur n'est pas 0 (lever ValueError) Étape 4 – Comparaisons

• Simplifier automatiquement la fraction avec pgcd • __eq__ : égalité (1/2 == 2/4 → True)

Étape 2 – Méthodes spéciales de représentation • __lt__ : plus petit que

• __str__ → "3/4" • __gt__ : plus grand que

• __repr__ → "Fraction(3, 4)"