madamasterclass.com

📔 Programmation Fonctionnelle

Introduction à la Programmation Fonctionnelle

La programmation fonctionnelle est un paradigme de programmation qui traite le calcul comme l'évaluation de fonctions mathématiques et évite les changements d'état et les données mutables. En Python, la programmation fonctionnelle est soutenue par des fonctionnalités intégrées et des bibliothèques qui facilitent son utilisation.


1. Introduction à la Programmation Fonctionnelle :
  • La programmation fonctionnelle se concentre sur l'utilisation de fonctions comme unités fondamentales de construction.
  • Les fonctions sont considérées comme des citoyens de première classe, ce qui signifie qu'elles peuvent être passées en arguments, retournées par d'autres fonctions et assignées à des variables.

2. Fonctions et Immutabilité :
  • Les données en programmation fonctionnelle sont souvent immuables, ce qui signifie qu'elles ne peuvent pas être modifiées après leur création.
  • Cela favorise la prévisibilité et la sécurité dans le code, car les effets de bord sont minimisés.

3. Fonctions d'Ordre Supérieur :
  • Une fonction d'ordre supérieur est une fonction qui prend une ou plusieurs fonctions en argument ou qui retourne une fonction.
  • Exemple de fonction d'ordre supérieur :
  • def appliquer(fonction, valeur):
    return fonction(valeur)

4. Utilisation des Lambdas :
  • Les fonctions lambda sont des fonctions anonymes qui peuvent être définies en une seule ligne.
  • Elles sont souvent utilisées avec des fonctions d'ordre supérieur comme map, filter et reduce.
  • carre = lambda x: x ** 2
    resultat = appliquer(carre, 5) # Retourne 25

5. Utilisation de map, filter et reduce :
  • La fonction map applique une fonction à tous les éléments d'un itérable.
  • La fonction filter filtre les éléments d'un itérable en fonction d'une condition.
  • La fonction reduce applique une fonction cumulativement aux éléments d'un itérable.
  • from functools import reduce
    liste = [1, 2, 3, 4]
    resultat_map = list(map(carre, liste)) # [1, 4, 9, 16]
    resultat_filter = list(filter(lambda x: x % 2 == 0, liste)) # [2, 4]
    resultat_reduce = reduce(lambda x, y: x + y, liste) # 10

6. Conclusion :

La programmation fonctionnelle en Python permet d'écrire un code clair, concis et modulaire. En utilisant des concepts tels que les fonctions d'ordre supérieur, l'immuabilité et les fonctions lambda, vous pouvez adopter un style de programmation qui favorise la réutilisabilité et la simplicité.

Exercice 1: ★ ★ ★ ☆ ☆

Soit la fonction \( f(x) = x^2 + 2x + 1 \).
1. Écrire une fonction Python qui prend un entier \( n \) et retourne \( f(n) \).
2. Utiliser cette fonction pour calculer \( f(3) \) et \( f(5) \).
3. Écrire une fonction d'ordre supérieur qui applique \( f \) à une liste de nombres et retourne une nouvelle liste avec les résultats.
4. Tester cette fonction avec la liste \([1, 2, 3, 4, 5]\).

1. Fonction pour \( f(n) \):

    def f(n):
       return n**2 + 2*n + 1

2. Calculer \( f(3) \) et \( f(5) \):
    f_3 = f(3) # Retourne 16
    f_5 = f(5) # Retourne 36

3. Fonction d'ordre supérieur :

    def appliquer_f(liste):
       return list(map(f, liste))

4. Tester avec \([1, 2, 3, 4, 5]\):
    resultat = appliquer_f([1, 2, 3, 4, 5]) # Retourne [4, 9, 16, 25, 36]


Exercice 2: ★ ★ ★ ★ ☆

Considérons la suite de Fibonacci, définie par \( F(0) = 0 \), \( F(1) = 1 \) et \( F(n) = F(n-1) + F(n-2) \) pour \( n \geq 2 \).
1. Écrire une fonction récursive pour calculer \( F(n) \).
2. Écrire une fonction qui utilise map pour générer les 10 premiers termes de la suite de Fibonacci.
3. Utiliser filter pour extraire les termes pairs des 10 premiers termes de la suite.

1. Fonction récursive pour \( F(n) \):

    def fibonacci(n):
       if n == 0:
         return 0
       elif n == 1:
         return 1
       else:
         return fibonacci(n-1) + fibonacci(n-2)

2. Générer les 10 premiers termes:
    fibonacci_10 = list(map(fibonacci, range(10)))

3. Extraire les termes pairs:
    termes_pairs = list(filter(lambda x: x % 2 == 0, fibonacci_10))


Exercice 3: ★ ★ ★ ★ ★

Écrire un programme qui effectue les opérations suivantes :
1. Écrire une fonction qui prend une liste de chaînes et retourne une nouvelle liste avec chaque chaîne en majuscules.
2. Écrire une fonction qui prend une liste de chaînes et retourne une nouvelle liste avec les longueurs de chaque chaîne.
3. Combiner les deux fonctions pour obtenir une liste de tuples, où chaque tuple contient une chaîne en majuscules et sa longueur.

1. Fonction pour mettre en majuscules:

    def majuscules(liste):
       return list(map(str.upper, liste))

2. Fonction pour les longueurs:

    def longueurs(liste):
       return list(map(len, liste))

3. Combiner les deux fonctions:

    def combiner(liste):
       return list(zip(majuscules(liste), longueurs(liste)))


Exercice 4: ★ ★ ★ ★ ★

Soit la fonction \( g(x) = 3x - 5 \).
1. Écrire une fonction Python qui prend un entier \( n \) et retourne \( g(n) \).
2. Utiliser cette fonction pour calculer \( g(-2) \) et \( g(10) \).
3. Écrire une fonction qui applique \( g \) à une liste de nombres et retourne une nouvelle liste contenant les résultats.
4. Tester cette fonction avec la liste \([-1, 0, 1, 2, 3]\).

1. Fonction pour \( g(n) \):

    def g(n):
       return 3*n - 5

2. Calculer \( g(-2) \) et \( g(10) \):
    g_neg2 = g(-2) # Retourne -11
    g_10 = g(10) # Retourne 25

3. Appliquer \( g \) à une liste:

    def appliquer_g(liste):
       return list(map(g, liste))

4. Tester avec \([-1, 0, 1, 2, 3]\):
    resultat_g = appliquer_g([-1, 0, 1, 2, 3]) # Retourne [-8, -5, -2, 1, 4]


Exercice 5: ★ ★ ★ ★ ☆

On considère une liste de mots :
\[ \text{mots} = ["hello", "world", "python", "functional", "programming"] \]
1. Écrire une fonction qui prend cette liste et retourne une nouvelle liste contenant uniquement les mots qui contiennent la lettre 'o'.
2. Écrire une fonction qui retourne la longueur de chaque mot de la liste d'origine.
3. Combiner les deux fonctions pour créer une liste de tuples où chaque tuple contient un mot contenant 'o' et sa longueur.

1. Fonction pour les mots contenant 'o':

    def mots_avec_o(liste):
       return list(filter(lambda mot: 'o' in mot, liste))

2. Fonction pour la longueur des mots:

    def longueurs_mots(liste):
       return list(map(len, liste))

3. Combiner les deux fonctions:

    def combiner_mots(liste):
       mots_o = mots_avec_o(liste)
       return list(zip(mots_o, longueurs_mots(mots_o)))


Exercice 6: ★ ★ ★ ☆ ☆

Vous travaillez sur un projet qui nécessite de manipuler des températures.
1. Écrire une fonction qui convertit une température en Celsius en Fahrenheit, avec la formule \( F = C \times \frac{9}{5} + 32 \).
2. Écrire une fonction qui prend une liste de températures en Celsius et retourne une liste de ces températures converties en Fahrenheit.
3. Tester votre fonction avec la liste de températures \([0, 10, 20, 30, 40]\).

1. Fonction de conversion:

    def celsius_to_fahrenheit(c):
       return c * 9/5 + 32

2. Liste de conversions:
    def convertir_liste(liste):
       return list(map(celsius_to_fahrenheit, liste))

3. Tester:
    resultat = convertir_liste([0, 10, 20, 30, 40]) # Retourne [32.0, 50.0, 68.0, 86.0, 104.0]


Exercice 7: ★ ★ ★ ★ ★

Dans une application de gestion de produits, vous devez traiter les prix.
1. Écrire une fonction qui applique une remise de 20% à un prix donné.
2. Écrire une fonction qui prend une liste de prix et retourne une nouvelle liste avec les prix après application de la remise.
3. Tester votre fonction avec la liste de prix \([100, 200, 300, 400, 500]\).

1. Fonction de remise:

    def appliquer_remise(prix):
       return prix * 0.8

2. Liste de prix après remise:
    def prix_apres_remise(liste):
       return list(map(appliquer_remise, liste))

3. Tester:
    resultat_remise = prix_apres_remise([100, 200, 300, 400, 500]) # Retourne [80.0, 160.0, 240.0, 320.0, 400.0]


Exercice 8: ★ ★ ★ ★ ☆

Vous développez un système de gestion de notes d'étudiants.
1. Écrire une fonction qui calcule la moyenne d'une liste de notes. 2. Écrire une fonction qui prend une liste de listes de notes et retourne une nouvelle liste avec les moyennes de chaque étudiant.
3. Tester votre fonction avec la liste \([[10, 12, 14], [15, 20, 18], [8, 7, 6]]\).

1. Fonction de moyenne:

    def moyenne(notes):
       return sum(notes) / len(notes)

2. Liste des moyennes:
    def moyennes_etudiants(liste):
       return list(map(moyenne, liste))

3. Tester:
    resultat_moyennes = moyennes_etudiants([[10, 12, 14], [15, 20, 18], [8, 7, 6]]) # Retourne [12.0, 17.67, 7.0]


Exercice 9: ★ ★ ★ ★ ★

Dans une application de filtrage de données, vous devez traiter une liste d'âges.
1. Écrire une fonction qui filtre les âges pour ne garder que ceux qui sont supérieurs ou égaux à 18.
2. Tester cette fonction avec la liste d'âges \([15, 18, 20, 17, 25, 30]\).

1. Fonction de filtrage:

    def filtrer_ages(liste):
       return list(filter(lambda age: age >= 18, liste))

2. Tester:
    resultat_filtre = filtrer_ages([15, 18, 20, 17, 25, 30]) # Retourne [18, 20, 25, 30]


Exercice 10: ★ ★ ★ ☆ ☆

Vous travaillez sur un projet de traitement de chaînes de caractères.
1. Écrire une fonction qui retourne la première lettre de chaque mot d'une phrase donnée.
2. Écrire une fonction qui prend une phrase et retourne une nouvelle phrase formée par ces premières lettres.
3. Tester cette fonction avec la phrase "La programmation fonctionnelle est puissante".

1. Fonction pour extraire les premières lettres:

    def premieres_lettres(phrase):
       return [mot[0] for mot in phrase.split()]

2. Fonction pour créer une nouvelle phrase:

    def phrase_initiales(phrase):
       return ''.join(premieres_lettres(phrase))

3. Tester:
    resultat_initiales = phrase_initiales("La programmation fonctionnelle est puissante") # Retourne "Lpfep"


Forum(s) associé(s)

Mathématiques Magiques : Dévoilez les Mystères des Nombres

08 Apr, 2016

Les mathématiques ont souvent la réputation d'être une discipline austère et difficile, mais ...

Read more.

Voyage à Travers les Suites Numériques : Découvertes et Applications

27 Jan, 2014

Plongez dans l'univers fascinant des suites numériques, où chaque terme révèle des patterns surprenants et des applications pratiques dans les mathématiques et au-delà.

Read more.

Fonctions en Action : Comprendre et Explorer les Relations Mathématiques

30 Feb, 2015

Découvrez comment les fonctions tissent des liens entre les nombres et les concepts, transformant des idées abstraites en outils puissants pour résoudre des problèmes du quotidien.

Read more.
Page: