Exercice 1 : Programmation Orientée Objet avec
Propriétés et Méthodes Magiques (30-40 minutes)
Créez une classe BankAccount qui démontre une encapsulation appropriée et une surcharge
d'opérateurs :
Exigences :
• Attribut balance privé qui ne peut pas être directement accessible
• Décorateurs de propriété pour un accès sécurisé au solde avec validation
• Implémenter les méthodes magiques __str__, __repr__ et __eq__
• Surcharger les opérateurs + et - pour les dépôts et les retraits
• Protocole de gestionnaire de contexte (__enter__ et __exit__) pour la journalisation des
transactions
• Gestion d'exceptions personnalisées pour les fonds insuffisants
Exemple d'utilisation que votre classe doit supporter :
with BankAccount("Alice", 1000) as account:
account += 500 # dépôt
account -= 200 # retrait
print([Link]) # Devrait afficher 1300
Exercice 2 : Itérateurs et Générateurs Avancés (30-40
minutes)
Implémentez une classe itératrice personnalisée PrimeGenerator et les fonctions correspondantes
:
Partie A : Créez un itérateur qui génère des nombres premiers jusqu'à une limite donnée
• Implémentez les méthodes __iter__ et __next__
• Incluez une gestion appropriée de StopIteration
• Ajoutez une méthode reset pour redémarrer l'itération
Partie B : Écrivez une fonction générateur fibonacci_primes(n) qui renvoie les n premiers
nombres qui sont à la fois des nombres de Fibonacci et des nombres premiers
Partie C : Créez un décorateur @memoize qui met en cache les résultats de fonction et
appliquez-le pour optimiser une fonction récursive
Bonus : Faites en sorte que votre itérateur fonctionne avec les fonctions itertools comme islice et
takewhile
Exercice 3 : Algorithme de Graphe avec Fonctionnalités
Python Avancées (50-60 minutes)
Implémentez l'algorithme du plus court chemin de Dijkstra en utilisant les fonctionnalités avancées
de Python :
Exigences :
• Utilisez [Link] et le module heapq de manière appropriée
• Implémentez l'algorithme comme méthode de classe dans une classe Graph
• Utilisez des annotations de type tout au long de votre implémentation
• Incluez des docstrings complètes suivant le style Google/NumPy
• Implémentez la reconstruction du chemin pour retourner les chemins les plus courts réels,
pas seulement les distances
• Ajoutez la validation des données en utilisant des setters @property
• Gérez les cas limites (graphes déconnectés, poids négatifs, boucles auto-référentes)
Fonctionnalités supplémentaires à implémenter :
• Un constructeur @classmethod qui construit un graphe à partir d'une liste d'adjacence
• Chaînage de méthodes pour les opérations de graphe
• Représentation en chaîne personnalisée montrant les statistiques du graphe
• Tests unitaires utilisant des assertions pour vérifier que votre algorithme fonctionne
correctement
La classe doit supporter une utilisation comme :
g = Graph.from_adjacency_list({
'A': [('B', 4), ('C', 2)],
'B': [('C', 1), ('D', 5)],
'C': [('D', 8), ('E', 10)],
'D': [('E', 2)]
})
distance, path = [Link]('A', 'E')
print(f"Distance la plus courte : {distance}, Chemin : {' -> '.join(path)}")
Distribution de la Notation :
• Exercice 1 : 25 points (Focus sur les concepts POO et les méthodes magiques Python)
• Exercice 2 : 25 points (Protocole d'itérateur et fonctions génératrices)
• Exercice 3 : 50 points (Implémentation d'algorithme + fonctionnalités Python avancées)
Conseils pour les étudiants :
• Lisez d'abord tous les exercices et allouez le temps en conséquence
• L'exercice 3 est le plus complexe - commencez par une implémentation de base puis ajoutez
des fonctionnalités
• Le style de code, la documentation et la gestion des erreurs comptent pour obtenir tous les
points
• Testez votre code avec les exemples fournis
Cet examen teste les concepts fondamentaux de Python (POO, itérateurs, décorateurs), les
fonctionnalités avancées du langage (méthodes magiques, gestionnaires de contexte, annotations
de type) et la pensée algorithmique, tout en restant difficile mais réalisable en 2 heures.