Exercice Corrigé: Python Avancé – Partie 3

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.

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.

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.

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.

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

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.

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.

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]

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]

# 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