Licence 2 GL 2024/2025
---------------------------
Programmation Python : Série d’exercices N°5
Exercice 1 :
Écrire une fonction associer_rang(liste) qui retourne une liste de tuples contenant chaque
élément de la liste avec son rang dans un classement décroissant.
● Utiliser sorted, enumerate et zip pour une solution.
Exemple : associer_rang([50, 20, 40, 30]) # ➝ [(50, 1), (40, 2), (30, 3), (20, 4)]
Exercice 2 :
Écrire une fonction indices_max_min(liste) qui retourne un tuple contenant les indices du
plus grand et du plus petit élément de liste.
● Utiliser enumerate et lambda pour une solution.
● Ne pas utiliser enumerate dans l’autre.
Exemple : indices_max_min([10, 20, 5, 30, 25]) # ➝ (3, 2)
Exercice 3 :
Écrire une fonction regrouper_listes(liste1, liste2) qui retourne une liste de tuples où chaque
tuple contient les éléments correspondants des deux listes.
● Si liste1 est plus courte que liste2, compléter avec None.
Exemple : regrouper_listes([1, 2, 3], ['a', 'b']) # ➝ [(1, 'a'), (2, 'b'), (3, None)]
Exercice 4 :
Écrire une fonction est_triee(liste, reverse=False) qui vérifie si la liste est triée dans l’ordre
croissant (reverse=False) ou décroissant (reverse=True).
● Utiliser sorted et zip.
Exemple :
est_triee([1, 2, 3, 4]) # ➝ True
est_triee([4, 3, 2, 1], reverse=True) # ➝ True
est_triee([1, 3, 2, 4]) # ➝ False
Exercice 5 :
Écrire une fonction convertir_en_tuples(liste) qui retourne une liste de tuples sous la forme
(index, valeur, carré de la valeur).
Exemple : convertir_en_tuples([2, 3, 4]) # ➝ [(0, 2, 4), (1, 3, 9), (2, 4, 16)]
Exercice 6 :
Écrire une fonction trouver_paires(liste, multiple=10) qui retourne une liste de tuples (a, b)
où la somme est un multiple de multiple.
● Utiliser enumerate pour une solution.
Exemple : trouver_paires([3, 7, 2, 8, 5, 5], multiple=10) # ➝ [(3, 7), (2, 8), (5, 5)]
Exercice 7 :
Écrire une fonction trier_tuples(liste_tuples, reverse=False) qui trie une liste de tuples en
fonction du deuxième élément.
● Utiliser sorted et lambda.
Exemple : trier_tuples([(1, 4), (3, 2), (2, 5)]) # ➝ [(3, 2), (1, 4), (2, 5)]
Exercice 8 :
Écrire une fonction sous_sequences_croissantes(liste) qui retourne une liste des
sous-séquences strictement croissantes.
Exemple : sous_sequences_croissantes([1, 2, 5, 3, 4, 8, 6]) # ➝ [[1, 2, 5], [3, 4, 8], [6]]
Exercice 9 : Décalage circulaire des éléments d’une liste
Écrire une fonction decalage_circulaire(liste, k=1, direction="droite") qui effectue un
décalage circulaire des éléments.
● Utiliser zip et enumerate .
Exemple : decalage_circulaire([1, 2, 3, 4, 5], k=2, direction="droite") # ➝ [4, 5, 1, 2, 3]
Exercice 10 : Partitionner une liste en n sous-listes équilibrées
Écrire une fonction partitionner_liste(liste, n) qui divise liste en n sous-listes de taille
presque égale.
● Utiliser zip et sorted pour organiser les partitions.
Exemple : partitionner_liste([1, 2, 3, 4, 5, 6, 7], 3) # ➝ [[1, 2, 3], [4, 5], [6, 7]]
Exercice 11 :
Réimplémenter les fonctions (sur les opérations ensemblistes) :
● Union
● Intersection
● Différence
● Différence symétrique
Les nouvelles fonctions renvoient des listes et peuvent prendre en arguments des listes, des
sets et des tuples