Vous êtes sur la page 1sur 42

Introduction à la programmation en Python

Maria Zrikem

GE1, GI1, GS1 ENSA de Marrakech

2021 - 2022

Les fonctions

1. Notion de fonction en Python

2. Définition et Appel de fonctions

3. Notion de Portée

4. Passage de paramètres

5. Fonctions : Spécificités Python

6. Notion de module

7. Notion de package

2






Les fonctions
Fonction et procédures

En algorithmique :

• Les fonctions permettent de décomposer un programme complexe en une série de sous-


programmes plus simples, lesquels peuvent à leur tour être décomposés eux- mêmes en fragments
plus petits, et ainsi de suite...

• Un un sous-programmes est un regroupement d’instructions que l’on nomme par un nom afin de
pouvoir les exécuter de manière plus simple et/ou répétitive.

• un sous-programme peut être soit une procédure, soit une fonction : Une fonction doit retourner
un résultat contrairement à une procédure.

En Python :

• Une on désigne indifféremment fonction pour parler de fonctions ou de procédures. Une


procédure est une fonction qui ne retourne pas explicitement de valeur (implicitement la valeur
None).

• on trouve plusieurs fonctions prédéfinies comme : type(), print(), id()... Nous avons appelé ces
fonctions sans avoir besoin de les écrire. 3

Types
les fonctions
élémentaires : Rappel
Deux type de fonction en Python
• Les fonctions indépendantes qui n’ont besoin que des arguments pour s’exécuter. L’appel se fait avec :
nomFonction(listeArguments)

• Les fonctions attachées aux objets appelées méthodes (Python est un langage orienté objet). La fonction
s’applique sur un objet et l’appel se fait avec le nom de l’objet :

nomObjet.nomFonction(listeArguments)

Exemple avec des fonctions existantes :


groupe = [’Ali’,’Omar’,’Fatima’,’Samya’,’Anas’]
• len : fonction indépendante qui prend un paramètre.
print(”Le groupe, contient”,len(groupe),”étudiants”)

• append : méthode, une fonction attachée à l’objet ’groupe’ de type liste. Elle prend un
paramètre : groupe.append(’Sara’)

Autre exemple : Tri d’une collection


groupe.sort() méthode qui s’applique sur l’objet à trier
print(sorted(groupe)) fonction avec un paramètre, l’objet à trier 4

Les fonctions
Appel d’une fonction
Pour appeler une fonction, il n’y pas besoin de voir le détail de son code. Sa description suffit.

Syntaxe : nomFonction(Argument-1, Argument-2,...,Argument-n) pour une fonction avec n


arguments (dits aussi paramètres)

nomFonction() pour une fonction sans arguments

Attention
• Les L’appel doit respecter l’ordre des paramètres et leur type.
• Les parenthèses sont obligatoires même en absence d’arguments.
• Une fonction retournant une valeur doit être appelée dans une instruction (Exemple :
groupetrie=sorted(groupe)).

Remarque : Ce cours traite uniquement avec les fonction ”indépendante”. pour celles
attachées aux objets, il suffit de précéder le nom de la fonction par l’objet et
l’appel se fait comme une fonction classique.
5

Les fonctions
Exemples d’appel de fonctions
• fonction carre : prend en paramètre un réel et retourne son carré. Son appel se
fait dans une instruction avec :
- dans une expression : c= carre(3)
- ou dans un affichage : print(carre(2.5))

• fonction ligneMotif : prend dans l’ordre les arguments : un caractère et la


longueur de la ligne, un entier. Elle ne retourne pas de résultat. Son appel n’a
pas besoin d’être dans une instruction. Il doit respecter l’ordre des paramètres :
ligneMotif (”*”,80)

• fonction ligneSimple : ne prend pas de paramètre et dessine un trait horizontal


simple. Elle ne retourne pas de résultat. Son appel se fait avec les parenthèses :
ligneSimple()
6

Les fonctions
Définition d’une fonction
Quand ? : quand on a un ensemble d’instructions (bloc) qui se répète plusieurs
fois dans le programme.
Où ? : le code de la fonction est généralement placé au début du fichier Python,
avant le programme principal (voir structure prog. début cours)

• rend bloc d’instructions est obligatoire. S’il est vide, on le remplace par
l’instruction pass. Dans ce cas la fonction ne fait rien.
• La documentation (entre deux ”””) est appelée docstring. Elle est facultative
mais fortement conseillée. On peut la visualiser avec l’instruction
help(nomFonction).
• L’instruction return n’apparait pas dans le cas d’une procédure 7

Les fonctions

8
Les fonctions
Tapage des paramètres
• Sous Python le tapage des variables est un typage dynamique. Ce mécanisme
fonctionne aussi pour les paramètres d’une fonction : le type d’un paramètre
devient automatiquement le même que celui de l’argument qui a été transmis à
la fonction.

9
Les fonctions
Portée d’une variable (Espace de noms)
La portée : définit la visibilité d’une variable.
Les noms des objets sont créés lors de leur première affectation, mais ne
sont visibles que dans certaines régions de la mémoire (leur espace de
nom). On distingue :

• Portée locale : les objets internes aux fonctions sont locaux. Ils ne
sont pas reconnus en dehors de la fonction
• Portée globale : les objets du programme principal (main) sont
globaux. Ils sont reconnus dans le programme et les fonctions. Ils
ne sont pas modifiables dans les portées locales.
L’instruction global v : permet de modifier la valeur de v (globale).

Remarques
L’instruction globals() fournit les couples variable : valeur. C’est un dictionnaire.
L’instruction locals() : fournit les couples variable : valeur. 10



Les fonctions

Résultat :
Avant jeu :
Nombre de tours = : 0 Score = 20
Après jeu : 11
Nombre de tours = : 1 Score = 30



Les fonctions : passage de paramètres


Passage de paramètres : fixe / modifiable
• Paramètre de type simple : (int, float, boolean...) qui a été modifié à
l’intérieur d’une fonction ne garde pas cette valeur en dehors de
celle-ci.
• Paramètre de type String : qui a été modifié à l’intérieur d’une
fonction ne garde pas cette valeur en dehors de celle-ci.
• Paramètre de type collection (liste ou autre) : qui a été modifié dans
la fonction gardera cette modification en dehors de la fonction.

Exemples :
• Exemple 1 : Une fonction qui tente de modifier une valeur numérique,
une chaine de caractères et un booléen. Un programme qui affiche les
variables avant et après l’appel de la fonction
• Exemple 2 : Une fonction qui modifie une liste et un programme qui
affiche le contenu de la liste avant et après l’appel.
12

Les fonctions : passage de paramètres

Résultat :
Avant appel fonction
Score = 20 Message = Commencer gagner = False
Après appel fonction
Score = 20 Message = Commencer gagner = False 13

Les fonctions : passage de paramètres

Résultat :
Avant appel fonction
listeNotes= [12, 13, 7, 10]
Après appel fonction
listeNotes= [13, 14, 8, 11]
14

Les fonctions : passage de paramètres

Résultat : A retenir
Avant appel fonction En général, dans le parcours de
listeNotes= [12, 13, 7, 10] la liste avec for x in liste :
Après appel fonction une modification de l’élément x
listeNotes= [12, 13, 7, 10] ne modifie le contenu de la liste
15

Les fonctions
Portée : règle LGI
• Python gère les espaces de noms selon la règle LGI. Elle définit la portée (visibilité)
de chaque variable.
• Lorsque Python rencontre une variable, il va traiter la résolution de son nom avec
les priorités suivantes :
1. L pour local : d’abord il regarde si la variable est locale, puis si elle n’existe
pas localement,
2. G pour global : il vérifie si elle est globale et sinon,
3. I pour Interne : il teste enfin si elle est interne (par exemple la fonction
len() est considérée comme une fonction interne à Python, elle existe dès le
lancement le Python).

Attention :
• Ne pas utiliser des noms (variables ou fonctions) qui sont internes dans
Python pou éviter toute confusion dans le code (même si Python arrive
à faire la distinction).
• Ne pas rendre toutes les variables globales pour des raisons de facilité.
Cela rend les fonctions dépendantes du programme. 16


Les fonctions
Recommandations
• Avant de commencer à programmer, se poser la question de
comment décomposer le problème en tâches.
• Chaque tâche pouvant être effectuée par une fonction
• Si une fonction semble trop complexe, penser à la décompose
également en d’autres fonctions.
• Se forcer d’utiliser des fonctions en permanence.
• Comme pour tout code, chaque fonction doit être accompagnée de
sa documentation (docstring)
• Il existe des spécificités autour des fonctions qui sont liées au
langage de programmation. Celles offertes par Python sont
nombreuses. Quelques unes sont présentées ici, les autres restent à
découvrir en « Projet ».

17

Les fonctions : spéci cités Python


En Python, il est possible :
• que l’on fasse passer des paramètres avec des valeurs par défaut
• qu’une fonction retourne plusieurs résultats
• que l’on fasse passer le nom d’une fonction comme un paramètre
• que l’on définisse une fonction avec un nombre de paramètres arbitraire :
le cas de passage d’un tuple ou d’un dictionnaire.

18

fi

Les fonctions : spéci cités Python


Fonctions avec paramètres par défaut :
def tableMultiplication(n , deb=1, fin=3) : affiche la table de
multiplication de n en commençant par deb*n (1*n par défaut) jusqu’à
fin*n (3*n par défaut).

• Les paramètres avec valeur par défaut sont appelés paramètres par mots-clés. Il
n’y a pas besoin de respecter l’ordre des paramètres.
• Les paramètre sans valeur par défaut, sont appelés paramètres positionnels.
L’appel, s’il est fait sans les noms de paramètres, doit obligatoirement respecter
l’ordre donné dans la définition de la fonction. 19
fi

Les fonctions : spéci cités Python


Fonctions avec paramètres par défaut :
• Les paramètres passées avec des valeurs par défaut sont aussi appelés
des arguments op onnels
• Il ne faut pas passer une séquence modifiable en argument par défaut
d’une fonction.
En e et, ce sont les références aux objets qui sont passés comme arguments de la
fonc on les copies d’objets. On u lise donc des arguments op onnels qui sont
immuables (int, float, str, bool, tuple)car la modi ca on d’un
paramètre par un appel est visible pour les autres appels.

Exemple : E et de bord
def ranger(a,lst=[]):
lst.append(a)
return l

print(ranger(4,[5,9])) #[5, 9, 4]

#probleme : effet de bord


print(ranger(1)) #[1]
print(ranger(2)) #[1, 2] il n’y a pas de création d’une nouvelle liste vide !
print(ranger(3)) #[1, 2, 3]

20
ff
ti
ff

ti

ti

fi

ti
fi
ti

Les fonctions : spéci cités Python


Fonctions avec paramètres par défaut :
• Si on a besoin d’un argument optionnel qui soit modifiable (list, dict), on
utilise None comme valeur par défaut
• Exemple :
def ranger(a,lst=None):
if lst == None:
lst = []
lst.append(a)
return lst

print(ranger(4,[5,9])) #[5, 9, 4]

print(ranger(1)) #[1]
print(ranger(2)) #[2] création d’une nouvelle liste
print(ranger(3)) #[3]

21

fi

Les fonctions
Exercice :
• Ecrire un script qui calcul le volume d’une sphère à l'aide de la formule : V= 4/3* pi*r^3
Utiliser les fonctions :
- cube() qui calcule le cube d’une nombre passe en paramètres
- volumeSphere() calcule le volume d’une sphère de rayon r passé en paramètre (elle
appelle cube())

22

Les fonctions
Exercice :
• Ecrire un script qui calcul le volume d’une sphère à l'aide de la formule : V= 4/3* pi*r^3
Utiliser les fonctions :
- cube() qui calcule le cube d’une nombre passe en paramètres
- volumeSphere() calcule le volume d’une sphère de rayon r passé en paramètre (elle
appelle cube())

def cube(n):
return n**3
def volumeSphere(r):
return 4 * 3.1416 * cube(r) / 3
r = input('Entrez la valeur du rayon : ')
print ('Le volume de cette sphère vaut', volumeSphere(float(r)))

23



Les fonctions
Exemple : Fonction retournant plusieurs résultats
Une fonction qui retourne la surface et le volume d’une sphère.

def surfaceVolumeSphere(r):
surf =4.0 * 3.14 * r**2
vol = surf * r/3
return surf, vol

# programme principal
rayon = float(input("Entrer un rayon : "))
s, v = surfaceVolumeSphere(rayon)
print("Sphère de surface",s ,"et de volume",v)

24

Les fonctions
Exemple : Fonction avec un nombre arbitraire de paramètres
le cas de passage d'un tuple : se fait par un *
def inventaire(produit,*args):
”””Renvoie la somme de <tuple>.”””
stock = 0
for nombre in args:
stock += nombre
return “stock ” +produit+” = ” +str(stock)

# Exemples d’appel :
print(inventaire("savon",10)) # stock savon = 10
print(inventaire("sucre",7, 1, 12)) # stock sucre = 20

− La fonc on possède def somme(a, b, c):


plusieurs arguments dans return a+b+c
l’exemple, le tuple est placé
en dernière posi on.
− Il est aussi possible de # Exemple d’appel :
passer directement un valeurs = (5, 1, 9)
tuple à l’appel avec un * print(somme(*valeurs)) # 15
25
ti

ti

Les fonctions
Exemple : Fonction avec un nombre arbitraire de paramètres
le cas de passage d'un dictionnaire : se fait par **

def unDict(**kargs):
return kargs

# Exemples d’appels
## par des paramètres nommés :
print(unDict(a=1, b=20)) # {’a’: 1, ’b’: 20}

## en fournissant un dictionnaire :
d = {’b’: 2, ’a’: 20, ’c’:30}
print(unDict(**d)) # {'b': 2, 'a': 20, 'c': 30}

− La De même si la fonc on possède plusieurs arguments, le dic onnaire est placé en toute
dernière posi on (après un éventuel tuple).

26
ti

ti

ti

Les fonctions
Fonc on lambda
lambda permet de définir un objet fonc on anonyme dont le retour est
limité à une expression
Syntaxe : lambda [parameters]:expression

Exemple 1 : écritures équivalentes


def doubler(x):
return x*2

print(doubler(3)) #6

#équivalent à
doubler = lambda x: x*2
print(doubler(3)) #6
print(lambda x: x*2)(3) #6

27
ti

ti
Les fonctions
Fonc on lambda
lambda permet de définir un objet fonc on anonyme dont le retour est
limité à une expression
Syntaxe : lambda [parameters]:expression

Exemple 2 : valider un module de deux manières


def valider(seuil):
return lambda x: True if x >=seuil else False

# Création de deux fonctions une qui valide à 8 et l’autre à 10


f8=valider(8)
f10=valider(10)
print (f8(9),f10(9)) #True False

28
ti

ti

Les fonctions
Fonc on lambda
lambda permet de définir un objet fonc on anonyme dont le retour est
limité à une expression
Syntaxe : lambda [parameters]:expression

Exemple 3 : une équa on de 1er degré ax+b


def equation(a,b):
return lambda x: a*x + b

eq1= equation(5,3) # Création de eq1=5x+3


print(eq1(0),eq1(2)) #3 13

eq2= equation(2,8) # Création de eq1=2x+1


print(eq2(0),eq2(2)) #1 5

Exemple 4 : une liste de fonc ons


lst = [lambda x: x**2, lambda x: x**3, lambda x: x**4]
for fct in lst:
print(fct(2), end=" ") #4 8 16
29
ti

ti

ti

ti

Exercices
1. Ecrire Définissez une fonction compteCar(ca,ch) qui renvoie le nombre de fois
que l'on rencontre le caractère ca dans la chaîne de caractères ch. Par exemple,
l'exécution de l'instruction :
print compteCar('e','Cette phrase est un exemple') doit donner le résultat : 7

2. Définissez une fonction indexMax(liste) qui renvoie l'index de l'élément ayant la


valeur la plus élevée dans la liste transmise en argument. Exemple d'utilisation :
serie = [5, 8, 2, 1, 9, 3, 6, 7]
print indexMax(serie)
4

3. Définissez une fonction nomMois(n) qui renvoie le nom du nième mois de


l'année. Par exemple, l'exécution de l'instruction :
print nomMois(4) doit donner le résultat : Avril

4. Définissez une fonction inverse(ch) qui permette d'inverser l'ordre des caractères
d'une chaîne quelconque. (La chaîne inversée sera renvoyée au programme
appelant).

5. Définissez une fonction compteMots(ph) qui renvoie le nombre de mots


contenus dans la phrase ph (On considère comme mots les ensembles de
caractères inclus entre des espaces). 30









Exercices
6. Ecrire Définissez une fonction changeCar(ch, ca1, ca2, debut, fin) qui
remplace tous les caractères ca1 par des caractères ca2 dans la chaîne de
caractères ch, à partir de l'indice debut et jusqu'à l'indice fin. Exemples
de la fonctionnalité attendue :
7. >>> phrase = 'Ceci est une toute petite phrase.' >>> print
changeCar(phrase, ' ', '*', 8, 12)
Ceci est*une*toute petite phrase.
8. Définissez une fonction eleMax(liste, debut, fin) qui renvoie l'élément
ayant la plus grande valeur dans la liste transmise. Les deux arguments
debut et fin indiqueront les indices entre lesquels doit s'exercer la
recherche.

9. Définissez une fonction maximum(n1,n2,n3) qui renvoie le plus grand


de 3 nombres n1, n2, n3 fournis en arguments. Par exemple, l’exécution
de l’instruction : print(maximum(2,5,4)) doit donner le résultat : 5.

31

Modules et package
L’appel d’une fonction :

Une fonction peut être appelée :

• par le programme principal : comme dans les exemples


• par d’autres fonctions : si sa visibilité le permet
• par d’autres programmes : en utilisant la notion de module.
Notion de module :

• Un module est un ensemble de fonctions et de constantes autour d’un thème


précis, que l’on regroupe dans un fichier .py

• Python contient déjà un certains nombre de modules comme : math, random...


• L’utilisateur peut aussi créer ses propres modules.
• Pour utiliser un module, il faut l’importer avec import. 32

Modules et package
Notion de module :

• Les modules doivent donc être codés en toute indépendance les uns des autres. Ce
qui permet de les réutiliser dans d’autres programmes.

• Les modules sont exécutés dans les programmes qui les importent. Ils peuvent aussi
s’exécuter seuls (pour les tests par exemple) s’ils sont munis d’une fonction main

Notion de package :

• Un module peut contenir d’autres modules. Ce qu’on appelle un package (ou


paquet).

• Les modules d’un package peuvent être des sous-packages, ce qui donne une
structure arborescente.

• En pratique, un package est simplement un répertoire qui contient des modules et


un fichier __init__ .py décrivant l’arborescence du package.
33

Modules et package
Exemple : Utilisation de module
• calcul.py : est un module qui ne contient que des fonctions de calcul
• prog.py : est un programme qui importe le module calcul.py et utilise ses fonctions.

Résultat : Exécution de prog.py

34

Modules et importation

Puissance.py : un module contenant 2 fonctions : carre() et cube()


def carre(valeur):
resultat = valeur**2
return resultat

def cube(valeur):
resultat = valeur**3
return resultat

Exemple : on importe une seule fonction


from puissance import carre

a = 5
u = carre(a)
print("le carre vaut", u)

Attention: Le fichier puissance.py doit être dans le même répertoire que le


programme principal (ou bien se trouver dans le « path » de Python).
35

Modules et importation
def carre(valeur):
Puissance.py : un module resultat = valeur**2
contenant 2 fonctions : return resultat

carre() et cube() def cube(valeur):


resultat = valeur**3
return resultat

Exemple : on importe explicitement les deux fonctions


from puissance import carre, cube

a = 5
u = carre(a)
print("le carre vaut", u)
v = cube(a)
print("le cube vaut", v)

36

Modules et importation
def carre(valeur):
Puissance.py : un module resultat = valeur**2
contenant 2 fonctions : return resultat

carre() et cube() def cube(valeur):


resultat = valeur**3
return resultat

Exemple : on importe toutes les fonctions

from puissance import *


Attention : L’importation de toutes les
a = 5 fonctions avec * est fortement déconseillée.
u = carre(a)
En effet, elle ne permet pas d’avoir une
print("le carre vaut", u)
vision claire des fonctions qui ont été
v = cube(a)
print("le cube vaut", v) importées. Ceci est donc une source
potentielle d’erreurs.

37

Modules et importation
def carre(valeur):
Puissance.py : un module resultat = valeur**2
contenant 2 fonctions : return resultat

carre() et cube() def cube(valeur):


resultat = valeur**3
return resultat

Exemple : on importe le module

import puissance Attention : Dans ce cas, il faut préciser le


nom du module devant la fonction.
a = 5
u = puissance.carre(a)
print("le carre vaut", u)
v = puissance.cube(a)
print("le cube vaut", v)

38

Modules et importation
def carre(valeur):
Puissance.py : un module resultat = valeur**2
contenant 2 fonctions : return resultat

carre() et cube() def cube(valeur):


resultat = valeur**3
return resultat

Exemple : on importe le module et on lui donne un alias


import puissance as pu
a = 5
u = pu.carre(a)
print("le carre vaut", u)
v = pu.cube(a)
print("le cube vaut", v)

39

Modules et importation
def carre(valeur):
Puissance.py : un module resultat = valeur**2
contenant 2 fonctions : return resultat

carre() et cube() def cube(valeur):


resultat = valeur**3
return resultat

Exemple : on importe une fonction d’un module et on lui donne un alias

from puissance import carre as ca

a = 5
u = ca(a)
print("le carre vaut", u)

40

Exercice :
Soit la liste de tuples suivantes (nom, moyenne) :
etudiants = [('Maria',12),('Sara',11.5),('Alya',12),('Taha',15),('Samya',20),('Adil',10)]

Tri de la liste :
• Les deux fonctions sort et sorted permettent de trier la liste par la première clé « nom »
• Comment trier la liste par « moyenne »?

Indication :

- sort et sorted disposent d’un paramètre appelé key


- U liser la fonc on prédé nie itemgetter du module operator

41
ti

ti
fi

Exercice : introduction aux Expressions Régulières


Les expressions régulières sont très utilisées dans les chaines de caractères.
Elles sont un moyen rapide et puisant pour faire des recherches dans des
chaines de caractères. On peut s’en servir en Python grâce au package re.

Exemple d’utilisation :
Ecrire un script vérifiant si uns chaine de caractères est bien une
adresse email.

42

Vous aimerez peut-être aussi