Cours Python - Chapitre 1.

Programmation Paython
FS Agadir
Prof. I. Akharraz

Chapitre 1. Notions de base du langage Python

1. Variable et type de variables

On a pas besoin de déclarere les variables : l'affectation d'une valeur à une variable suffit pour la déclarer et préciser son type.

In [ ]:

# Déclaration implécite de variables
x = 10          # Entier (int)
y = 3.14        # Flottant (float)
nom = "Ali"   # Chaîne de caractères (str)
actif = True    # Booléen (bool)

In [ ]:

# Affichage
x, y, nom, actif

In [ ]:

# Affichage des types e variables
type(x), type(y),  type(nom), type(actif)  

In [ ]:

nom, age, taille, homme = "Ali", 50, 1.74 , True

In [ ]:

nom, age, taille, homme

In [ ]:

type(nom), type(age), type(taille), type(homme)

In [ ]:

### Exemples de Booléens
x = -1
print((x > -2) and (x**2 < 5))
print(x <= -2) or (x**2 > 5)
print(not(x >= -2) )
print(-2 < x <= 0)
print((x > -2) and (x**2 < 5))
x, y = True, True
print(not (x and y)) == ((not x) or (not y))

In [ ]:

x = -1
(x > -2) and (x**2 < 5)

In [ ]:

x = -1
(x <= -2) or (x**2 > 5)

In [ ]:

x=-1
not(x >= -2)

In [ ]:

x=-1
-2 < x <= 0

In [ ]:

x=-1
x > -2 and x**2 < 5

In [ ]:

x, y = True, True
not (x and y) == ((not x) or (not y))

2. Lecture et écriture

2.1. Ecriture : "print"

L'instruction print demande à la machine d'afficher des massages ou des valeurs contenues dans des variables. SYNTAXE :

print("Message_à_afficher") ou print(nom_variable)

In [ ]:

# Afficher le  messsage : Hello World!
print("Hello World!")

In [ ]:

#Afficher le contenu de variable :
x=12
y=10
z= 2*x**2 +y
print(x)
print(y)
print(z)
print(x+y+z)
print("la valeur de x est", x)
print("la valeur de y est", y)
print("la valeur de z est", z)
print("la valeur de x+y+z est", x+y+z)

Contrôle du format d'affichage

In [ ]:

# la méthode Format() pour contrôler le format d'affichage
##########################
x= 25.123456789
print('Je vous affiche x ici {:g} au format le plus approprié'.format(x)) # choisit le format le plus approprié
print('Je vous affiche x ici {:.3f} avec 3 chiffres après la virgule'.format(x)) # fixe le nombre de décimales
print('Je vous affiche x ici {:.3e} en notation scientifique'.format(x)) # notations cientifique

In [ ]:

x= 2.3456
y= 5.6789
print(f"La somme de {x :.3f} et {y:.3f} est {x + y :.2f}")

In [ ]:

# Méthode plus simple : print(f"texte_à_afficher {variable : .Format}") 
x = 3.14159
print(f"Le nombre pi est = {x:.2f}")

2.2. Lecture : "input"

L'instruction input permet à la machine de lire des des valeurs sisies au clavier.
SYNTAXE :

nom_variable = type_valeur(input())

On demande à la machine d'affecter la valeur saisie au clavier à la variable nom_variable sous le type type_valeur.

In [ ]:

# Lecture : Saisit d'un réel au clavier   
x=float(input())
print(x)

In [ ]:

# On peut afficher un message demandant la saisie : 
x =int(input('Entrez une valeur pour la variable x : '))
print(x , x**2)

In [ ]:

# Autrement
x =eval(input('Entrez une valeur pour la variable x : '))
print (x , x**3)

3. Structures conditionnelles

In [ ]:

x=float(input())
if (x >= 0) :
    print("est positif")
else :
    print("est négatif")

In [ ]:

### Choix imbriqués : if imbriqués  
# Résolution de l'équation réelle ax^2 + bx +c =0
import math # importer la bibliothèque math pour utiliser la fonction racine carrée (sqrt)
a= float(input("Donner a"))
b= float(input("Donner b"))
c= float(input("Donner c"))
if a == 0:
    print("L'équation est du premier degré.")
else :
    delta = b**2 - 4*a*c
    if delta > 0:
        print("L'équation possède deux solutions réelles :")
        print("x1 =", (-b -math.sqrt(delta))/2*a)
        print("x2 =", (-b +math.sqrt(delta))/2*a)
    else :
        if delta == 0:
            print("L'équation possède une solution réelle .")
        else :
            print("L'équation ne possède pas de solution réelle .")

4. Fonctions

• Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique.
  
• Elle permet d’organiser et de structurer un programme, tout en évitant la répétition de code.
• En Python, on définit une fonction à l’aide du mot-clé def, suivi du nom de la fonction et des parenthèses pouvant contenir des paramètres. suivi du nom de la fonction et des parenthèses pouvant contenir des paramètres.
• Le bloc d'instructions est indenté sous la définition.
• Une fonction peut renvoyer une valeur grâce au mot-clé return.
• Elle peut prendre zéro ou plusieurs paramètres, effectuer des opérations (comme des calculs mathématiques).
• Elle rappelée chaque fois qu'on en a besoin.

Syntaxe de base :
def nom_de_la_fonction(paramètres):
Bloc d'instructions
return résultat # Optionnel : une fonction peut ne rien retourner

In [ ]:

def f(x) :
    y= x**3 + 2*x**2 + 4*x + 5
    return y

In [ ]:

print(f(1))

In [ ]:

def vabs(x) :
    if x >= 0 :
        return x
    else :
        return -x

In [ ]:

essai2(100)

4. LISTES

4.1. Définitions

In [ ]:

liste1 = [ 15, 'Lapin', 15.51, 62]
print(liste1,'\n', id(liste1),'\n', type(liste1))

In [ ]:

###################  Accès aux éléments à partir du dernier
print(liste1[2])
print(liste1[0],  liste1[3])
print('Elément 1:', liste1[0], ', Elément 2:', liste1[1], 'et Elément 3:',liste1[3])

In [ ]:

##################  Accès par indices négatifs  
print(liste1[-1])
print(liste1[-2])

In [ ]:

4*liste1[0] + liste1[2]**2

In [ ]:

##################  listes élément de listes 
L=[22, ['x','y'],'tot', [1, 2, 3]]
print(L[0])
print(L[1])
print(L[3][1])

In [ ]:

L3 = [1, 2, 3]
L2=[22, ['x','y'],'tot', L3]
print(L2[3])

In [ ]:

len(L2)

In [ ]:

##################  SOUS LISTE
uneliste = [2, 4, 8, 16, 32, 64, 128, 256]
L1=uneliste[2:6]
print('La sous-liste  L1 est : ', L1)

In [ ]:

##################  INDICES NEGATIFS
print(uneliste[-1])
print(uneliste[-5:-2])

In [ ]:

##################  Emplacement mémoire
L1 = [12, 'UN', 3.14]
print(L1 , id(L1) , type (L1))
print(L1[0] , id(L1[0] ) , type(L1[0]))
print(L1[1] , id(L1[1] ) , type(L1[1]))
print(L1[2] , id(L1[2] ) , type(L1[2]))

In [ ]:

##################  Modifier une liste
L2 = ['chat', 6.2, 'UN', 75]
#L2[0] = 2**5
#L2[1] = 2**6
#L2[2] = 2**7
#L2[3] = 2**8
print(L2)
L2.append(23)
print(L2)

4.2. Méthodes Courantes

.append() : Ajoute un élément à la fin.

In [ ]:

# Ajouter un élément
ma_liste = [1, 2, 3, 4, 5]
ma_liste.append(6)  # résultat[1, 2, 3, 4, 5,6]
ma_liste

extend(liste2) : Ajoute les éléments de liste2 à la fin d'une liste.

In [ ]:

ma_liste.extend([7, 8,9,10])
print(ma_liste)

insert(i, x) : Ajoute x à la position i.

In [ ]:

ma_liste.insert(0, 0)
print(ma_liste)  # ➜ [10, 15, 20, 30, 40, 50, 60]

remove(x) : Supprime la première occurrence de x.

In [ ]:

ma_liste.remove(2)
print(ma_liste)

pop(i) : Supprime et retourne l'élément à l'indice i

In [ ]:

valeur = ma_liste.pop()
print(valeur) 
print(ma_liste) 

D'autres méthodes :
ma_liste.clear() : supprime tous les éléments de la liste
index() :Renvoie l’index de la première occurrence (ma_liste.index("b"))
count() : Compte combien de fois l’élément apparaît (ma_liste.count("a"))
sort() : Trie la liste (in-place) (ma_liste.sort())
reverse() : Inverse l'ordre des éléments (ma_liste.reverse())
copy() : Fait une copie superficielle de la liste (copie = ma_liste.copy())

4.3. Copie de liste

In [ ]:

liste = [12 ,'un' , 3.14]
##################  COPIE SUPERFICIELLE / copie de pointeurs
copie = liste
liste[0] = 100         # modification de l'objet liste
print('liste = ',liste)   
print('copie = ',copie)    
print('##############')

copie[1] = 'ah?'       # modification de l'objet copie
print('liste = ',liste)  
print('copie = ', copie)   
print('##############')

##################  Afficher les identifiants pour  comprendre :

#print(liste , id(liste ))   
#print(copie , id(copie ))   

In [ ]:

##################  COPIE de référence   
L=[2, 4, 8, 16]
C = L[:]
L[0] = 20         # modification de l'objet liste
print('L = ',L) 
print('C = ',C)   
print('##############')

#C[1] = 'Bien'       # modification de l'objet copie
#print('L = ',L)    
#print('C = ', C)    
#print('##############')

##################  Afficher les identifiants pour  comprendre :
# print('##############')
# print(L , id(L ))   
# print(C , id(C ))  

In [ ]:

#  COPIE profonde : Quand la liste contient des objets listes; 
#  même la copie en reférence n'est pas suffisante
# On utilise la fonction deepcopy
###########################################################      
import copy
X = [ 'a' , 'b' , [ 4, 5 , 6] ]
Y=X
Z=X[:]
W= copy.deepcopy(X)
X[0] =  'c'
Z[1] = 't'
Z[2][2] = 365
print('X=', X, 'Y=', Y, 'Z=', Z, 'W=', W)  

In [ ]:

#  Concaténation de deux listes à l’aide de l’opérateur + :
L = [1, 2, 3] + [0.5, 0.5, 0.5]
print('L =', L)
L2 = [1, 2, 3]
L3 = [0.5, 0.5, 0.5]
L4 = L2 + L3
print('L4 =', L4)
####### Ajouter un élément en fin de liste
L5 = L2 + [4]
print('L5 =', L5)
L6 = ['a', 'b', 'b']

In [ ]:

###### Méthodes associées aux listes
##########################################
##list.append(x)      #ajoute l’élément x en fin de liste
##list.extend(L)      #ajoute en fin de liste les éléments de L
##list.insert(i,x)    #insère un élément x en position i
##list.remove(x)      #supprime la première occurrence de x
##list.pop([i])       #supprime l’élément d’indice i et le renvoie
##list.index(x)       #renvoie l’indice de la première occurrence de x
##list.count(x)       #renvoie le nombre d’occurrences de x
##list.sort()         #modifie la liste en la triant
##list.reverse()      #modifie la liste en inversant l’ordre des éléments

In [ ]:

L5.extend([10,20])
L6=L5
print('L6=', L6)

EXERCICES.

In [ ]:

Écrire une fonction booléenne qui cherche si un élément existe 
dans une liste.

In [ ]:

def  existe(x , liste) :
    for y in liste :
        if x == y : return 'True'
    return 'False'

In [ ]:

existe(5 , L6)

In [ ]:

L = ['a', 'b', 'b']
existe('a' , L)

4.3. Définition de listes par compréhension.

Equivalent de la définition des ensembles par compréhension en mathématiques.

In [ ]:

liste = [2,4,6,8,10]
[3*x for  x in liste]
[[x , x**3] for x in liste]
[3*x for x in liste if x > 5] 
[3*x for x in liste if x ** 2 < 50] 
liste2 = list(range(3))
[x*y for x in liste for y in liste2 ]

5. Les dictionnaires

- Un dictionnaire est une structure de données qui permet de stocker des paires clé-valeur.
- Contrairement aux listes qui sont indexées par des nombres (0, 1, 2, …), les dictionnaires sont indexés par des clés (de n'importe quel type immuable : chaînes, nombres, tuples…).
Syntaxe :
mon_dict = {
'clé1': 'valeur1',
'clé2': 'valeur2',
'clé3': 'valeur3'
}

In [ ]:

# Exemple de dictionnaire
personne = {"nom": "Ali", "age": 25}
print(personne["nom"])  # Resultat : Alice
personne["ville"] = "Zagora"  # Ajoute une cle

In [ ]:

# Dictionnaire avec Clés et listes de valeurs
personel = {
		'Nom': ['Ali', 'Brahim', 'Samira','Said'],
		'Age': [25, 30, 50, 17],
		'Ville': ['Casa', 'Agadir', 'Taroudant', 'Meknes']
        }
    

5.1. Accès aux éléments du dictionnaire

In [ ]:

# Accéder à une clé spécifique :
print(personel['Nom'])  # Renvoie : ['Alice', 'Bob', 'Sam']
print(personel['Age'][1])  # Renvoie : 30 (âge de Bob)
print(personel['Ville'][2])  # Renvoie : 'Vienne' (ville de Sam)

# Accéder à la liste des noms
print(personel['Nom'])  # ['Ali', 'Brahim', 'Samira', 'Said']

# Accéder au premier nom
print(personel['Nom'][0])  # Ali

# Accéder à l'âge de Samira (3e élément)
print(personel['Age'][2])  # 50

In [ ]:

#Parcourir toutes les clés et valeurs :
for cle, valeur in personel.items():
    print(f"{cle}: {valeur}")
		# Renvoie :
		# Nom: ['Alice', 'Bob', 'Sa m']
		# Age: [25, 30, 50]
		# Ville: ['Paris', 'Amsterdam', 'Vienne']

In [ ]:

#Ajouter un nouvel employé : 
personel['Nom'].append('Fatima')
personel['Age'].append(28)
personel['Ville'].append('Rabat')

print(personel)
# Résultat : {'Nom': ['Ali', 'Brahim', 'Samira', 'Said', 'Fatima'], 
	#             'Age': [25, 30, 50, 17, 28], 
	#             'Ville': ['Casa', 'Agadir', 'Taroudant', 'Meknes', 'Rabat']}	

In [ ]:

# Modifier des données existantes :	
# Modifier l'âge de Said (4e employé)
personel['Age'][3] = 18

# Changer la ville de Brahim (2e employé)
personel['Ville'][1] = 'Marrakech'

print(personel)
# Résultat : {'Nom': ['Ali', 'Brahim', 'Samira', 'Said'], 
	#             'Age': [25, 30, 50, 18], 
	#             'Ville': ['Casa', 'Marrakech', 'Taroudant', 'Meknes']}

In [ ]:

# Supprimer un employé :	
 # Supprimer Samira (3e employé)
 del personel['Nom'][2]
 del personel['Age'][2]
 del personel['Ville'][2]
 
 print(personel)
 # Résultat : {'Nom': ['Ali', 'Brahim', 'Said'], 
 	#             'Age': [25, 30, 18], 
 	#             'Ville': ['Casa', 'Marrakech', 'Meknes']}

In [ ]:

#Parcourir le dictionnaire avec une boucle :	
# Afficher les informations de chaque employé
for i in range(len(personel['Nom'])):
    print(f"Employé {i+1}: Nom={personel['Nom'][i]}, Age={personel['Age'][i]}, Ville={personel['Ville'][i]}") 

In [ ]:

# Filtrer les employés selon un critère :	
# Filtrer les employés ayant plus de 20 ans
adultes = {
        'Nom': [personel['Nom'][i] for i in range(len(personel['Nom'])) if personel['Age'][i] > 20],
        'Age': [age for age in personel['Age'] if age > 20],
     	'Ville': [personel['Ville'][i] for i in range(len(personel['Ville'])) if personel['Age'][i] > 20]
 }
 
print(adultes)
 # Résultat : {'Nom': ['Ali', 'Brahim'], 
 	#             'Age': [25, 30], 
 	#             'Ville': ['Casa', 'Marrakech']}

6. Les boucles

6.1. La boocle for :

In [ ]:

for i in [1, 2, 3, 4, 5] :
    print('Je me répète 5 fois')

In [ ]:

#  La fonction range(n) crée un itérateur parcourant l’intervalle [0,n-1]
#   un distributeur d’entiers consécutifs

In [ ]:

n=5
for i in range(n) :
    print ('Je me répète', n, 'fois')

In [ ]:

## avec deux arguments, range(n, m) parcourt l’intervalle 
## [n, m-1] 

In [ ]:

n=5
m=10
for i in range(n, m):
    print (i)

In [ ]:

# Avec trois arguments, range(n, m, k) parcourt l’intervalle [n, p-1]                
#               avec un pas égal à k.

In [ ]:

n=5
m=10
k=2
for i in range(n, m, k):
    print (i)

In [ ]:

# Création de listes d’entiers à l’aide de range() moyennant une conversion 
# de type par la fonction list . 

In [ ]:

list(range(10))

In [ ]:

list(range(1, 10))

In [ ]:

list(range(1, 10,2 ))

In [ ]:

# on peut aussi utiliser comme itérateur dans une boucle for
#         une chaîne de caractère

In [ ]:

for i in 'Agadir' :
    print ( i , end = '->')

Exercice.

In [ ]:

Écrire deux fonctions somme et maximum qui renvoient respectivement la somme
et le maximum d’une liste d’entiers. Vérifiez votre résultat en vous servant 
des primitives sum et max

6.2. La boucle WHILE.

In [ ]:

#n = 0
#N=100
#while (2**n <= N):
#    n += 1
#print(n) 

################ WHILE
#def essai1(N) :
#    n = 0
#    while (2**n <= N):
#        n += 1
#   return n
############################# 
def essai2(N) :
    n = 0
    while True :
        if (2**n > N):
            return n
        n += 1

Exemples.

In [ ]:

# boucle pour tester si un mot est un Plindrome ou non
def palindrome(chaine):
    i, longueur = 0, len(chaine)
 
    while i < longueur:
        if chaine[i] != chaine[-i - 1]:
              return False
        i += 1
 
    return True

In [ ]:

palindrome('noon')

In [ ]:

palindrome('rose')

In [ ]:

# Approximation du cosinus
import math
def cosinus(x, epsilon):

  n = 0
  cos_n = 1
  cos_n_prec = 0

  while abs(cos_n - cos_n_prec) > epsilon:
    cos_n_prec = cos_n
    terme = (-1)**n * x**(2*n) / math.factorial(2*n)
    cos_n += terme
    n += 1

  return cos_n -1

In [ ]:

print(cosinus(1, 1e-14))

7. Récursivité

On appelle fonction récursive une fonction qui comporte un appel à elle-même.

Une fonction récursive doit respecter les trois lois de la récursivité : a. Une fonction récursive contient un cas de base. b. Une fonction récursive doit modifier son état pour se ramener au cas de base. c. Une fonction récursive doit s’appeler elle-même.

Une fonction mathématique définie par une relation de récurrence et une condition initiale peut programmée de manière récursive.

Par exemple, pour un réel x fixé, $x^n$ peut se définir, comme fonction de n, par récurrence à partir des relations :
$x^0 = 1$
$x^n = x * x^{n-1}$ pour $n >= 1$

Le programme en Python s’écrit :

In [ ]:

def puissance(x ,n) :
    if n == 0 : 
        return 1
    else : 
        return x * puissance(x ,n - 1)

In [ ]:

puissance(2 ,5)

In [ ]:

Ajoutons des affichages au programme pour bien comprendre : 

In [ ]:

    def puissance(x, n) :
        if n == 0 : return 1
        else :
            print(' -- ' * n + '> appel de puissance',(x , n-1))
        y = x * puissance(x , n-1)
        print( ' -- ' * n +  '> sortie de puissance',(x , n-1))
        return y

In [ ]:

puissance(2 ,5)

In [ ]:

- La machine applique la règle : puissance(x, n) = x * puissance(x, n-1) tant que 
  l’exposant est  différent de 0, ce qui introduit des calculs intermédiaires jusqu’à aboutir au cas de
  base : puissance(x ,0) = 1. 
- Les calculs en suspens sont alors achevés dans l’ordre inverse jusqu’à obtenir le 
résultat final.

In [ ]:

# Exponentiation rapide
Il existe un algorithme plus performant que la méthode consistant à multiplier ce 
nombre n-1 fois par lui-même : la méthode dite d’exponentiation rapide. 
Étant donnés un réel positif a et un entier n, on remarque que :
   > a^n = (a^(n/2))^2 si n est pair
   > a^n = a*(a^((n-1)/2))^2 si n est impair

Code par une fonction récursive :

In [ ]:

 from time import *
t1 = time.
def expo(a ,n):
    if n == 0: return 1
    else :
        if n%2 == 0 :
            return expo(a, n//2)**2
        else : 
            return a*expo(a, (n-1)//2)**2
t1 = time.clock()
print(t1-t1)

In [ ]:

import time
expo(2 ,20)
t2=time.time()
print(t2)

Exercices.

Écrire une version itérative, puis une version récursive pour calculer la factorielle d’un entier.

8. Programmation fonctionnelle

8.1. Définitions

In [ ]:

# Problèmes chronique de la programmation :
    - On détecte les erreurs mais, ne peut pas confirmer l’absence d’érreurs.
    - “Program testing can be used to show the presence of bugs, but never show their absence” – Edsger W. Dijkstra
    - Les preuves formelles (mathématiques) difficiles et plus longues ques les programmes

# Preuve formelle d’un programme :
1) On suppose qu’il existe dans un programme un certain nombre de points P1, P2, ..., Pn où le concepteur 
   peut fournir des assertions a1, a2,...,an concernant les variables du programme et leurs relations. 
   L’assertion a1 concerne les entrées du programme et an ses sorties.

2) Pour prouver que les instructions du programme entre Pi et Pi+1 sont correctes, il faut démontrer que 
l’exécution de ces instructions transforme ai en ai+1.

3) Si les assertions d’entrée et de sortie sont correctement formulées et si le programme se termine, 
alors le programme est correct.

In [ ]:

- Pour remédier à ce problème et rendre la preuve mathématique plus aisée, les langages de programmation 
  ont eu recours au paradigme fonctionnelle : Toutes les procédures sont sous forme de fonctions.

- La programmation fonctionnelle est """déclarative""" :  consiste à décrire un problème et à laisser l’environnement de 
programmation trouver la solution. 

- On parle de programmation fonctionnelle pure lorsqu’elle est effectuée uniquement à l’aide de fonctions au sens 
mathématique du terme

# Programmation fonctionnel 
  1) Prévilège de fonctions pures
  2) Pas de boucles (utilisation systématique de la récursivité)  
  4) Vérification formelle facile des programmes

In [ ]:

# fonction pure :
Une fonction pure (Pure Function) peut se comparer aux fonctions mathématiques de base; 
c.à.d; une fonction qui présente les caractéristiques suivantes :

1) La fonction arrive au même résultat pour les mêmes arguments;
2) La fonction n’a accès qu’à ses arguments ;
3) La fonction ne déclenche pas d’effets secondaires : l’appel à une fonction pure n’entraîne 
   pas de changement dans l’environnement système.

In [ ]:

# Programmation fonctionnelle en Python :
    - Python n’est donc pas un langage fonctionnel au sens le plus strict du terme 
    - Mais, Python dispose de nombreux outils dédiés à la programmation fonctionnelle. :
                ~ Fonctions comme objets on peut affecter ou passer en paramètre  
                ~ map, filter, ... 
                ~ Lambda fonctions

Exemples.

In [ ]:

# la fonction f(x) = x * x peut être facilement mis en œuvre en tant que fonction pure dans Python
def f(x):
  return x * x

In [ ]:

# Fonction impure : renvoie un résultat différent à chaque appel :
def afficher_date():
  from datetime import datetime
  return datetime.now()

In [ ]:

# Fonction impure : elle modifie un argument mutable à son appel et 
# affecte donc l’environnement système :

def modifier():
  L[0] = 'Ali'
  return L

In [ ]:

L = ['Ahmed', 'Fatima']

In [ ]:

modifier()

8.2. Les fonctions lambdas

In [ ]:

- Les lambdas sont des fonctions anonymes.
- se définissent par le mot-clé lambda.
- Il s’agit de fonctions courtes et anonymes qui définissent une expression 
   avec des paramètres.

In [ ]:

# Exemple 1.
carré = lambda x: x * x

In [ ]:

# Exemple 2.
majuscule = lambda chaine : chaine.upper()

In [ ]:

# Exemple 3.
x = lambda a, b, c : a + b + c

In [ ]:

# La puissance des lambda se voit lorsqu on les utilisez comme fonction anonyme dans une autre fonction.
# on définit une fonction qui prend un argument et que cet argument sera multiplié par un nombre inconnu :
def f(n):
  return lambda a : a * n

# On utilisez cette fonction pour créer une fonction qui double toujours le nombre fourni :
doubler = f(2)

Calcul de la dérivée de $f(x)=x^3 +2x^2+4x+5$

In [ ]:

# Calculer la dérivée de f(x)=x^3 +2x^2+4x+5
f = lambda x: x**3 + 2*x**2 + 4*x + 5
df = lambda x: 3*x**2 + 4*x + 4

In [ ]:

print(f"La dérivée de f en 0.25 est égale à {df(0.25) :.2f}")

In [ ]:

df(-5)

9. Fonction d’ordre supérieur dans Python

• Une fonction est appelée fonction d’ordre supérieur si elle contient d’autres fonctions

en tant que paramètre ou renvoie une fonction en tant que sortie.

• Les lambdas sont beaucoup utilisés pour des fonctions d’ordre supérieur

comme map() et filter().

• Ainsi, les éléments d’un itérable peuvent être transformés sans passer par des boucles.

8.1. La fonction map().

- La fonction map() utilise comme paramètres une fonction et un itérable
- Exécute la fonction pour chaque élément de l’itérable.

In [ ]:

# Génération de nombres carrés :
L = [3, 5, 7]
def f(x):
    return x*x

Lcarré = list(map(f, L))

In [ ]:

# Génération de nombres carrés :
L = [3, 5, 7]
Lcarré = list(map(lambda x: x ** 2, L))

9.2. La fonction filter().

La fonction filter() permet de filtrer les éléments d’un itérable (comme une liste).
Syntaxe :
filter(nom_fonction, nom_itérable)

In [ ]:

#Exemple séléctionner uniquement les carrés pairs :
nums = [1, 2, 3, 4, 5, 6]
squares = list(map(lambda num: num ** 2, nums))
even_squares = list(filter(lambda square: square % 2 == 0, squares))

In [ ]:

even_squares

9.3. La fonction reduce()

- La fonction reduce() réduit une liste à une seule valeur (somme, produit, etc.)
- La fonction reduce() n’est pas disponible par défaut , elle est dans le module (bibliothèque) functools. On doit l'importer de cette bibliothèque par : from functools import reduce
Syntaxe de la fonction :
reduce(fonction, itérable[, valeur_initiale])

In [ ]:

from functools import reduce
liste = [1, 2, 3, 4, 5, 6, 7, 8]
# Réduire liste à une somme
somme_liste = reduce(lambda x, y: x + y, liste)

In [ ]:

L=[n for n in range(100)]
S=reduce(lambda x, y : x+y, L)

In [ ]:

S