Exercice Corrigé: Python Avancé – Partie 2

# 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]

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.

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']]

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']

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.

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.

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.

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.

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.

# 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.