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:
Ecrivez un programme Python qui filtre les nombres premiers d’une liste d’entiers à l’aide de la fonction filter.
Exemple:
Liste de nombres:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Liste de nombres premiers:
[2, 3, 5, 7]
Solution:
def nbr_premier(n):
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
liste = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("Liste de nombres:")
print(liste)
# Utiliser la fonction filter pour extraire les nombres premiers
res = list(filter(nbr_premier, liste))
print("\nListe de nombres premiers:")
print(res)
Sortie:
Liste de nombres:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Liste de nombres premiers:
[2, 3, 5, 7]
Explication:
Dans l'exercice ci-dessus :
Tout d'abord, nous définissons une fonction appelée « nbr_premier() » qui vérifie si un nombre donné n est premier. Cette fonction utilise le test de primordialité avec des optimisations.
Définir une liste appelée contenant des nombres entiers.
Ensuite, nous utilisons la fonction filter pour filtrer les nombres premiers de la liste en appliquant la fonction « nbr_premier() » comme condition de filtrage.
Les nombres premiers filtrés sont convertis en liste et nous affichons les nombres premiers extraits.
Exercice 2:
Écrivez un programme Python qui crée une liste de mots et utilisez la fonction filter pour extraire les mots qui contiennent plus de cinq lettres.
Exemple:
Liste des mots:
['Alex', 'Olivier', 'Bob', 'Alexander']
Extraire les mots de plus de cinq lettres:
['Olivier', 'Alexander']
Solution:
liste = ["Alex", "Olivier", "Bob", "Alexander"]
print("Liste des mots:")
print(liste)
# Définir une fonction pour vérifier si un mot a plus de cinq lettres
def check(word):
return len(word) > 5
# Utilisez la fonction filter pour extraire les mots de plus de cinq lettres.
res = list(filter(check, liste))
print("\nExtraire les mots de plus de cinq lettres:")
print(res)
Sortie:
Liste des mots:
['Alex', 'Olivier', 'Bob', 'Alexander']
Extraire les mots de plus de cinq lettres:
['Olivier', 'Alexander']
Explication:
Dans l'exercice ci-dessus :
Tout d'abord, nous définissons une liste contenant des mots sous forme de chaînes de caractères.
Définissez une fonction appelée « check() » qui vérifie si un mot a plus de cinq lettres en comparant sa longueur à 5.
Utilisez la fonction filter pour filtrer les mots de la liste des mots en fonction de la condition définie par la fonction « check() ».
Enfin, les mots filtrés comportant plus de cinq lettres sont convertis en liste et nous affichons les mots longs extraits.
Exercice 3:
Écrire une fonction Python qui filtre les éléments d'une liste de chaînes contenant une sous-chaîne spécifique à l'aide de la fonction filter.
Exemple:
Liste de mots:
['Assam', 'Asia', 'Autosampler', 'SMS', 'SOS']
La sous-chaîne: sam
Les chaînes contenant la sous-chaîne:
['Assam', 'Autosampler']
Solution:
def filter_substring(strings, substring):
# Définir la fonction de filtrage
def include_substring(str):
return substring in str
# Utilisez la fonction filter pour filtrer les chaînes contenant la sous-chaîne
res = list(filter(include_substring, strings))
return res
liste = ["Assam", "Asia", "Autosampler", "SMS", "SOS"]
print("Liste de mots:")
print(liste)
substr = "sam"
print("La sous-chaîne:",substr)
print("Les chaînes contenant la sous-chaîne:")
res = filter_substring(liste, substr)
print(res)
Sortie:
Liste de mots:
['Assam', 'Asia', 'Autosampler', 'SMS', 'SOS']
La sous-chaîne: sam
Les chaînes contenant la sous-chaîne:
['Assam', 'Autosampler']
Explication:
Dans l'exercice ci-dessus :
Tout d'abord, la fonction « filter_substring() » prend deux arguments : strings (une liste de chaînes) et substring (la sous-chaîne à rechercher).
À l'intérieur de la fonction, nous définissons une fonction imbriquée « include_substring() » qui vérifie si une chaîne contient la sous-chaîne spécifiée à l'aide de l'opérateur in.
La fonction filter permet de filtrer les chaînes de la liste en appliquant la fonction « include_substring() » comme condition de filtrage.
Enfin, les chaînes filtrées contenant la sous-chaîne spécifiée sont converties en liste et renvoyées en tant que résultat.
Exercice 4:
Écrire un programme Python qui filtre les dates (au format 'AAAA-MM-JJ') qui sont dans le futur à l'aide de la fonction filter.
Exemple:
Liste des dates:
['2022-01-24', '2026-03-12', '2025-06-19', '2011-12-30']
Date actuelle: 2024-09-15 09:22:11.445166
Date appartient au futur:
['2026-03-12', '2025-06-19']
Solution:
from datetime import datetime
liste_date = ["2022-01-24", "2026-03-12", "2025-06-19", "2011-12-30"]
print("Liste des dates:")
print(liste_date)
# Convertir les dates sous forme de string en objets datetime
dates = [datetime.strptime(date, "%Y-%m-%d") for date in liste_date]
# Récupérer la date courante
dc = datetime.now()
print("Date actuelle:",dc)
# Définir une fonction pour vérifier si une date est dans le futur
def check_date(date):
return date > dc
# Utiliser la fonction filter pour extraire des dates dans le passé
old = list(filter(check_date, dates))
# Convertir les dates filtrées en chaînes de caractères
res = [date.strftime("%Y-%m-%d") for date in old]
print("\nDate appartient au futur:")
print(res)
Sortie:
Liste des dates:
['2022-01-24', '2026-03-12', '2025-06-19', '2011-12-30']
Date actuelle: 2024-09-15 09:22:11.445166
Date appartient au futur:
['2026-03-12', '2025-06-19']
Explication:
Dans l'exercice ci-dessus :
Nous commençons par une liste de dates sous forme de string au format « YYYY-MM-DD ».
Nous convertissons les dates sous forme de string en objets datetime à l'aide de datetime.strptime.
Nous obtenons la date et l'heure actuelles à l'aide de datetime.now().
Définir une fonction « check_date() » qui vérifie si une date se situe dans le futur en la comparant à la date actuelle.
Utilisez la fonction filter pour filtrer les dates situées dans le futur à partir de la liste des dates en appliquant la fonction « check_date() » comme condition de filtrage.
Les objets datetime filtrés sont ensuite reconvertis en dates sous forme de string à l'aide de strftime au format « YYYY-MM-DD ».
Enfin, nous affichons les dates dans le futur.
Exercice 5:
Écrivez un programme Python qui crée une liste de tuples, chacun contenant un nom de ville et sa population. Utilisez la fonction filter pour extraire les villes dont la population est supérieure à 3 millions d'habitants.
Exemple:
Liste des villes et de leur population:
[
('Paris', 7500000),
('Montpellier', 6000000),
('Toulouse', 3700000),
('Lyon', 2300000),
('Nantes', 1600000),
('Marseille', 1500000),
('Bordeaux', 1500000)
]
Les villes dont la population est supérieure à 3 millions d'habitants:
[('Paris', 7500000), ('Montpellier', 6000000), ('Toulouse', 3700000)]
Solution:
# Définir une liste de tuples ville-population
villes = [
("Paris", 7500000),
("Montpellier", 6000000),
("Toulouse", 3700000),
("Lyon", 2300000),
("Nantes", 1600000),
("Marseille", 1500000),
("Bordeaux", 1500000),
]
print("Liste des villes et de leur population:")
print(villes)
# Définir une fonction permettant de vérifier si une ville a une population supérieure à 3 millions d'habitants
def check_pop(ville_pop):
return ville_pop[1] > 3000000
# Utilisez la fonction filter pour extraire les villes dont la population est supérieure à trois millions d'habitants.
res = list(filter(check_pop, villes))
print("\nLes villes dont la population est supérieure à 3 millions d'habitants:")
print(res)
Sortie:
Liste des villes et de leur population:
[
('Paris', 7500000),
('Montpellier', 6000000),
('Toulouse', 3700000),
('Lyon', 2300000),
('Nantes', 1600000),
('Marseille', 1500000),
('Bordeaux', 1500000)
]
Les villes dont la population est supérieure à 3 millions d'habitants:
[('Paris', 7500000), ('Montpellier', 6000000), ('Toulouse', 3700000)]
Explication:
Dans l'exercice ci-dessus :
Tout d'abord, nous commençons par une liste de tuples ville-population appelée « villes ».
Nous définissons une fonction appelée « check_pop() » qui vérifie si la population d'une ville (le deuxième élément de chaque tuple) est supérieure à 3 millions.
Nous utilisons la fonction filter pour filtrer les villes de la liste des villes en fonction de la condition définie par la fonction « check_pop() ».
Enfin, les villes filtrées dont la population est supérieure à 3 millions sont converties en liste et les villes extraites sont affichées.
Exercice 6:
Écrire un programme Python pour trier une liste de tuples en utilisant Lambda.
Exemple:
Liste de tuples originale:
[('B', 8), ('A', 5), ('X', 1), ('D', 9)]
Trier la liste des tuples:
[('X', 1), ('A', 5), ('B', 8), ('D', 9)]
Solution:
liste = [('B', 8), ('A', 5), ('X', 1), ('D', 9)]
print("Liste de tuples originale:")
print(liste)
# Trier la liste des tuples sur la base du deuxième élément de chaque tuple,
# en utilisant une fonction lambda comme clé de tri pour extraire le deuxième élément
liste.sort(key=lambda x: x[1])
print("\nTrier la liste des tuples:")
print(liste)
Sortie:
Liste de tuples originale:
[('B', 8), ('A', 5), ('X', 1), ('D', 9)]
Trier la liste des tuples:
[('X', 1), ('A', 5), ('B', 8), ('D', 9)]
Explication:
liste.sort(key=lambda x: x[1]) : Trie la liste des tuples sur la base du deuxième élément de chaque tuple (c'est-à-dire les nombres). Elle utilise une fonction lambda comme clé de tri, qui extrait le deuxième élément (x[1]) à des fins de tri.
Exercice 7:
Écrire un programme Python pour trier une liste de dictionnaires basé sur la clé 'letter' dans l'ordre croissant en utilisant Lambda.
Exemple:
Liste de dictionnaires originale:
[{'letter': 'X', 'nbr': 1},
{'letter': 'F', 'nbr': 5},
{'letter': 'A', 'nbr': 7}]
Trier la liste des dictionnaires:
[{'letter': 'A', 'nbr': 7},
{'letter': 'F', 'nbr': 5},
{'letter': 'X', 'nbr': 1}]
Solution:
liste = [
{'letter': 'X', 'nbr': 1},
{'letter': 'F', 'nbr': 5},
{'letter': 'A', 'nbr': 7}
]
print("Liste de dictionnaires originale:")
print(liste)
# Trier la liste des dictionnaires ('liste') en fonction de la valeur associée à la clé 'letter' dans chaque dictionnaire
# Utilise la fonction 'sorted()' avec une fonction lambda comme clé de tri pour trier sur la base de la valeur 'letter'.
res = sorted(liste, key=lambda x: x['letter'])
print("\nTrier la liste des dictionnaires:")
print(res)
Sortie:
Liste de dictionnaires originale:
[{'letter': 'X', 'nbr': 1}, {'letter': 'F', 'nbr': 5}, {'letter': 'A', 'nbr': 7}]
Trier la liste des dictionnaires:
[{'letter': 'A', 'nbr': 7}, {'letter': 'F', 'nbr': 5}, {'letter': 'X', 'nbr': 1}]
Explication:
Dans l'exercice ci-dessus, le code initialise une liste de dictionnaires. Il trie ensuite cette liste de dictionnaires en fonction de la valeur de la clé « letter » dans l'ordre croissant. Il utilise la fonction sorted() et une fonction lambda comme clé de tri. Enfin, il affiche la liste originale des dictionnaires et la liste triée sur la console.
Exercice 8:
Écrire un programme Python pour filtrer les nombres paires et impaires dans une liste d'entiers en utilisant Lambda.
Exemple:
Liste originale:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Les nombres pairs:
[2, 4, 6, 8, 10]
Les nombres impairs:
[1, 3, 5, 7, 9]
Solution:
liste = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("Liste originale:")
print(liste)
print("\nLes nombres pairs:")
# Utiliser la fonction 'filter()' avec une fonction lambda pour filtrer les nombres pairs de 'liste'
# Créer une nouvelle liste 'paires' contenant uniquement les nombres pairs de la liste originale
paires = list(filter(lambda x: x % 2 == 0, liste))
print(paires)
print("\nLes nombres impairs:")
# Utiliser la fonction 'filter()' avec une fonction lambda pour filtrer les nombres impairs de 'liste'
# Créer une nouvelle liste 'impaires' contenant uniquement les nombres impairs de la liste originale
impaires = list(filter(lambda x: x % 2 != 0, liste))
print(impaires)
Sortie:
Liste originale:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Les nombres pairs:
[2, 4, 6, 8, 10]
Les nombres impairs:
[1, 3, 5, 7, 9]
Exercice 9:
Écrire un programme Python pour mettre au carré et au cube tous les nombres d'une liste donnée d'entiers en utilisant Lambda.
Exemple:
Liste originale:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Mettre au carré chaque nombre de la liste:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Mettre au cube chaque nombre de la liste:
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
Solution:
liste = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("Liste originale:")
print(liste)
print("\nMettre au carré chaque nombre de la liste:")
caree = list(map(lambda x: x ** 2, liste))
print(caree)
print("\nMettre au cube chaque nombre de la liste:")
cube = list(map(lambda x: x ** 3, liste))
print(cube)
Sortie:
Liste originale:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Mettre au carré chaque nombre de la liste:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Mettre au cube chaque nombre de la liste:
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
Exercice 10:
Écrire un programme Python pour trouver si une chaîne donnée commence par le caractère 'A' en utilisant Lambda.
# Définir une fonction lambda 'commence_par' qui vérifie si une chaîne donnée commence par 'A'.
commence_par = lambda x: True if x.startswith('A') else False
# Vérifier si la chaîne commence par 'A' en utilisant la fonction lambda 'commence_par'.
# Afficher le résultat qui sera 'True' si la chaîne commence par 'A', sinon 'False'.
print(commence_par('Alex'))
print(commence_par('Bob'))
Sortie:
True
False
Éditeur de code Python: Testez votre code en ligne!
QCM Python – Partie 1Bienvenue dans notre QCM Python ! Que vous soyez débutant ou déjà expérimenté en programmation, ce questionnaire à choix multiples est l’occasion parfaite de tester…Lire plus