Exercice Corrigé: Python Avancé – Partie 2

Avec des exercices corrigés en Python, vous pratiquerez divers concepts du langage Python. Vous commencerez par des exercices Python de base à des exercices plus avancés. La solution est fournie pour chaque exercice. Vous devez essayer de résoudre chaque problème par vous-même avant de vérifier la solution. Si vous avez des questions concernant chaque problème, nous vous encourageons à les poster sur notre forum.
 
 

Exercice 1:

Écrivez un programme Python pour imbriquer deux listes dans une autre liste de manière aléatoire. Utilisez la fonction map().

Exemple:

Listes originales:
[1, 2, 3]
[4, 5, 6]

Résultat:
[1, 4, 5, 2, 3, 6]
Solution:

# Importer le module 'random'
import random

def insert_randomly(nbrs1, nbrs2):
    # Créer une liste d'itérateurs à l'aide de la fonction 'iter' pour chaque liste d'entrée.
    iterators = [iter(nbrs1)] * len(nbrs1) + [iter(nbrs2)] * len(nbrs2)
    # Utiliser la fonction 'random.sample' pour sélectionner au hasard des itérateurs dans la liste et créer une nouvelle liste de valeurs.
    # Utiliser la fonction 'map' avec 'next' pour extraire les valeurs des itérateurs sélectionnés
    result = list(map(next, random.sample(iterators, len(nbrs1) + len(nbrs2))))
    return result

# Définir deux listes
nbrs1 = [1, 2, 3]
nbrs2 = [4, 5, 6]

print("Listes originales:")
print(nbrs1)
print(nbrs2)

print("\nRésultat:")
print(insert_randomly(nbrs1, nbrs2))

Sortie:

Listes originales:
[1, 2, 3]
[4, 5, 6]

Résultat:
[1, 4, 5, 2, 3, 6]
 

Exercice 2:

Écrire un programme Python pour diviser un dictionnaire de listes donné en une liste de dictionnaires à l’aide de la fonction map.

Exemple:

Dictionnaire de listes original:
{'A': [1, 2, 3], 'B': [4, 5, 6]}

Découper le dictionnaire de listes en une liste de dictionnaires:
[{'A': 1, 'B': 4}, {'A': 2, 'B': 5}, {'A': 3, 'B': 6}]
Solution:

def dict_to_list(my_dict):
    result = map(dict, zip(*[[(key, val) for val in value] for key, value in my_dict.items()]))
    return list(result)

# Définir un dictionnaire
my_dict = {'A': [1, 2, 3], 'B': [4, 5, 6]}

print("Dictionnaire de listes original:")
print(my_dict)

print("\nDécouper le dictionnaire de listes en une liste de dictionnaires:")

print(dict_to_list(my_dict))

Sortie:

Dictionnaire de listes original:
{'A': [1, 2, 3], 'B': [4, 5, 6]}

Découper le dictionnaire de listes en une liste de dictionnaires:
[{'A': 1, 'B': 4}, {'A': 2, 'B': 5}, {'A': 3, 'B': 6}]

Explication:

Ici result = map(dict, zip(*[[(key, val) for val in value] for key, value in dict.items()])) Nous avons:

  • Utiliser une liste de compréhension pour créer une liste de tuples, où chaque tuple représente une paire clé-valeur du dictionnaire d’entrée.
  • Utilisez la fonction « zip » pour transposer la liste de tuples, en créant des tuples dont les valeurs se trouvent à la même position dans chaque tuple.
  • Utiliser une autre liste de compréhension pour convertir chaque tuple en un dictionnaire.
  • Utiliser la fonction « map » pour appliquer le constructeur « dict » à chaque tuple, ce qui permet d’obtenir un objet « map » de dictionnaires.
  • Convertir l’objet map en une liste et renvoyer le résultat.
 

Exercice 3:

Écrire un programme Python pour convertir une liste de chaînes de caractères en une liste de listes à l’aide de la fonction map.

Exemple:

Liste originale:
['Alex', 'Bob', 'Ali']

Convertir la liste de chaînes en liste de listes:
[['A', 'l', 'e', 'x'], ['B', 'o', 'b'], ['A', 'l', 'i']]
Solution:

def toListOflists(str):
    # Utilisez la fonction 'map' avec 'list' pour convertir chaque chaîne en une liste de ses caractères.
    result = map(list, str)
    # Convertit l'objet map en liste et renvoie le résultat
    return list(result)

names = ["Alex", "Bob", "Ali"]

print('Liste originale:')
print(names)

print("\nConvertir la liste de chaînes en liste de listes:")
print(toListOflists(names))

Sortie:

Liste originale:
['Alex', 'Bob', 'Ali']

Convertir la liste de chaînes en liste de listes:
[['A', 'l', 'e', 'x'], ['B', 'o', 'b'], ['A', 'l', 'i']]
 

Exercice 4:

Écrire un programme Python pour convertir une liste de tuples en une liste de chaînes de caractères à l’aide de la fonction map.

Exemple:

Liste de tuples:
[('Alex', 'Babtise'), ('Bob', 'Kifal')]

Convertir liste de tuples en une liste de chaînes de caractères:
['Alex Babtise', 'Bob Kifal']
Solution:

def tupleToList(liste):
    # Utiliser la fonction 'map' avec 'join' pour concaténer les éléments de chaque tuple en utilisant un espace comme séparateur.
    # Convertir l'objet map en liste et renvoyer le résultat
    result = list(map(' '.join, liste))
    return result

# Définir une liste de tuples
liste = [('Alex', 'Babtise'), ('Bob', 'Kifal')]

print("Liste de tuples:")
print(liste)

print("\nConvertir liste de tuples en une liste de chaînes de caractères:")
print(tupleToList(liste))

Sortie:

Liste de tuples:
[('Alex', 'Babtise'), ('Bob', 'Kifal')]

Convertir liste de tuples en une liste de chaînes de caractères:
['Alex Babtise', 'Bob Kifal']
 

Exercice 5:

Ecrivez une fonction Python qui filtre les nombres pairs d’une liste d’entiers à l’aide de la fonction filter.

Exemple:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Résultat: [1, 3, 5, 7, 9]
Solution:

def filtrer_nbr_pairs(liste):
    # Définir la fonction de filtrage
    def nbr_impaire(n):
        return n % 2 != 0

    #Utilisez la fonction filter pour supprimer les nombres pairs
    nbrs_impaires = list(filter(nbr_impaire, liste))

    return nbrs_impaires

liste = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(liste)
print("Résultat:", filtrer_nbr_pairs(liste))

Sortie:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Résultat: [1, 3, 5, 7, 9]

Explication:

Dans l’exercice ci-dessus:

  • La fonction « filtrer_nbr_pairs() » prend en entrée une liste d’entiers appelés ‘liste’.
  • À l’intérieur de la fonction, nous définissons une fonction imbriquée « nbr_impaire() » qui renvoie True pour les nombres impairs (nombres non divisibles par 2).
  • Nous utilisons ensuite la fonction filter pour filtrer les nombres pairs de la liste des nombres en appliquant la fonction ‘nbr_impaire’ comme condition de filtrage.
  • Les nombres impairs filtrés sont convertis en liste et renvoyés comme résultat.
 

Exercice 6:

Écrivez un programme Python qui utilise la fonction de filtrage pour extraire toutes les lettres majuscules d’une liste de chaînes de caractères mixtes.

Exemple:

liste: ["Hello", "waytolearnx", "PHP", "Bob"]
Extraire toutes les lettres majuscules:
['H', 'P', 'H', 'P', 'B']
Solution:

liste = ["Hello", "waytolearnx", "PHP", "Bob"]

#Utilisez la fonction filter pour extraire les lettres majuscules
maj_letters = list(filter(lambda char: char.isupper(), ''.join(liste)))

print("\nExtraire toutes les lettres majuscules:")
print(maj_letters)

Sortie:

Extraire toutes les lettres majuscules:
['H', 'P', 'H', 'P', 'B']

Explication:

Nous utilisons la fonction filter pour filtrer les caractères de toutes les chaînes et ne retenir que les lettres majuscules. Pour ce faire, nous utilisons une fonction lambda qui vérifie si un caractère est majuscule à l’aide de la méthode isupper(). La fonction filter renvoie un itérable de lettres majuscules, que nous convertissons en liste.

 

Exercice 7:

Écrire une fonction Python qui filtre tous les éléments inférieurs ou égaux à 10 dans une liste de nombres à l’aide de la fonction filter.

Exemple:

[12, 5, 2, 7, 17, 99]

Filtre tous les éléments <= 10 :
[5, 2, 7]
Solution:

def filter_numbers(liste, seuil):
    # Définir la fonction de filtrage
    def inf_seuil(n):
        return n <= seuil

    # Utilisez la fonction de filtrage pour filtrer la liste
    res = list(filter(inf_seuil, liste))

    return res

liste = [12, 5, 2, 7, 17, 99]
print(liste)
seuil = 10
print("\nFiltre tous les éléments <=",seuil,":")
res = filter_numbers(liste, seuil)
print(res)

Sortie:

[12, 5, 2, 7, 17, 99]

Filtre tous les éléments <= 10 :
[5, 2, 7]

Explication:

Dans l'exercice ci-dessus :

  • La fonction « filter_numbers() » prend deux arguments : des nombres (une liste de nombres) et un seuil (la valeur à comparer).
  • À l'intérieur de la fonction, nous définissons une fonction imbriquée « inf_seuil() » qui vérifie si un nombre est supérieur ou égal au seuil spécifié.
  • Nous utilisons la fonction filter pour filtrer les nombres de la liste des nombres en appliquant la fonction « inf_seuil() » comme condition de filtrage.
  • Les nombres filtrés sont convertis en liste et renvoyés en tant que résultat.
 

Exercice 8:

Écrivez un programme Python qui crée une liste de noms et utilise la fonction filter pour extraire les noms qui commencent par une voyelle (A, E, I, O, U).

Exemple:

['Alex', 'Bob', 'Ali', 'Emily', 'Jean']

Les noms commençant par une voyelle:
['Alex', 'Ali', 'Emily']
Solution:

names = ["Alex", "Bob", "Ali", "Emily", "Jean"]
print(names)

# Définir une fonction pour vérifier si un nom commence par une voyelle
def starts_with_vowel(name):
    return name[0].lower() in ['a', 'e', 'i', 'o', 'u']

# Utilisez la fonction filter pour extraire les noms commençant par une voyelle
res = list(filter(starts_with_vowel, names))
print("\nLes noms commençant par une voyelle:")
print(res)

Sortie:

['Alex', 'Bob', 'Ali', 'Emily', 'Jean']

Les noms commençant par une voyelle:
['Alex', 'Ali', 'Emily']

Explication:

Dans l'exercice ci-dessus :

  • Vous commencez par une liste de noms appelée « names ».
  • Définir une fonction appelée « starts_with_vowel() » qui vérifie si la première lettre d'un nom (convertie en minuscule) se trouve dans la liste des voyelles.
  • Ensuite, nous utilisons la fonction filter pour filtrer les noms de la liste en fonction des conditions définies par la fonction « starts_with_vowel() ».
  • Les noms filtrés sont convertis en liste et nous affichons les noms extraits.
 

Exercice 9:

Écrire une fonction Python qui filtre toutes les chaînes vides d'une liste de chaînes à l'aide de la fonction filter.

Exemple:

['', 'hello', 'Bob', '', 'Ali', '']

Une nouvelle liste contenant uniquement des chaînes non vides:
['hello', 'Bob', 'Ali']
Solution:

def my_filter(strings):
    # Définir la fonction de filtrage
    def is_not_empty(str):
        return str.strip() != ""

    #Utilisez la fonction filter pour supprimer les chaînes vides
    res = list(filter(is_not_empty, strings))
    return res

# Exemple d'utilisation:
str = ["", "hello", "Bob", "", "Ali", ""]
print(str)
print("\nUne nouvelle liste contenant uniquement des chaînes non vides:")
res = my_filter(str)
print(res)

Sortie:

['', 'hello', 'Bob', '', 'Ali', '']

Une nouvelle liste contenant uniquement des chaînes non vides:
['hello', 'Bob', 'Ali']

Explication:

Dans l'exercice ci-dessus :

  • Tout d'abord, la fonction « my_filter() » prend en entrée une liste de chaînes de caractères appelées 'strings'.
  • À l'intérieur de la fonction, nous définissons une fonction imbriquée « is_not_empty() » qui vérifie si une chaîne est non vide en utilisant la méthode strip() pour supprimer les espaces blancs de début et de fin, puis en vérifiant s'il s'agit d'une chaîne vide.
  • Nous utilisons la fonction filter() pour filtrer les chaînes vides de la liste des chaînes en appliquant la fonction « is_not_empty() » comme condition de filtrage.
  • Les « chaînes non vides ('res') » filtrées sont converties en liste et renvoyées en tant que résultat.
 

Exercice 10:

Écrivez un programme Python qui crée une liste de dictionnaires contenant des informations sur les étudiants (nom, age, note) et qui utilise la fonction filter pour extraire les étudiants dont la note est supérieure ou égale à 90.

Exemple:

Informations sur les étudiants:
[{'nom': 'Alex Babtise', 'age': 25, 'note': 85}, 
{'nom': 'Jean Nihade', 'age': 15, 'note': 92}, 
{'nom': 'Bob Finalod', 'age': 18, 'note': 90}]

Étudiants ayant obtenu des notes élevées:
[{'nom': 'Jean Nihade', 'age': 15, 'note': 92}, 
{'nom': 'Bob Finalod', 'age': 18, 'note': 90}]
Solution:

# Définir une liste de dictionnaires
etudiant = [
    {"nom": "Alex Babtise", "age": 25, "note": 85},
    {"nom": "Jean Nihade", "age": 15, "note": 92},
    {"nom": "Bob Finalod", "age": 18, "note": 90},
]
print("Informations sur les étudiants:")
print(etudiant)

# Définir une fonction permettant de vérifier si la note d'un étudiant est supérieure ou égale à 90
def check_note(etudiant):
    return etudiant["note"] >= 90

# Utilisez la fonction filter pour extraire les étudiants ayant des notes élevées.
res = list(filter(check_note, etudiant))
print("\nÉtudiants ayant obtenu des notes élevées:")
print(res)

Sortie:

Informations sur les étudiants:
[{'nom': 'Alex Babtise', 'age': 25, 'note': 85}, 
{'nom': 'Jean Nihade', 'age': 15, 'note': 92}, 
{'nom': 'Bob Finalod', 'age': 18, 'note': 90}]

Étudiants ayant obtenu des notes élevées:
[{'nom': 'Jean Nihade', 'age': 15, 'note': 92}, 
{'nom': 'Bob Finalod', 'age': 18, 'note': 90}]

Explication:

Dans l'exercice ci-dessus :

  • Tout d'abord, nous définissons une liste appelée étudiants, où chaque élément est un dictionnaire contenant des informations sur un étudiant (nom, age et note).
  • Ensuite, nous définissons une fonction appelée « check_note() » qui vérifie si la note d'un étudiant est supérieure ou égale à 90.
  • Enfin, nous utilisons la fonction filter pour filtrer les étudiants de la liste des étudiants en fonction de la condition définie par la fonction « check_note() ».
  • Les étudiants filtrés ayant des notes élevées sont convertis en liste et nous affichons les étudiants extraits.
 

Éditeur de code Python: Testez votre code en ligne!


 

QCM Python

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *