Chapitre2: Les fonctions, modules et

packages en Python
 Les fonctions
 Les fonctions Python :
 Fonctions prédéfinies : fonctions de la bibliothèque standard de python. Elles
sont toujours disponibles.
 Fonctions définies par l’utilisateur : développées par le programmeur.
 Fonctions définies dans des modules : ces fonctions sont développées dans
des modules particuliers et ne peuvent être utilisées que lorsque le module les
contenant est importé.

4
 Les fonctions prédéfinies
print():affiche sur la sortie standard
abs(x): retourne la valeur absolue d’un nombre
f loat(): retourne un nombre réel à virgule f lottante
int(): retourne un objet entier
str(): retourne un objet chaine de caractère
input():permet à l’utilisateurde saisir son entrée
len(): retourne la longueur d’un objet
list(): retourne une liste
pow(x,y): retourne le résultat de x puissance y
tuple(): retourne un tuple
sum(): somme d’éléments d’un objet itérable
dir(str):Liste tous les noms de function travaillant sur les chaines
dir(list):liste les noms de fonctions
dir(dict):Liste tous les noms de fonctions travaillant sur les dictionnaires
dir(tuple):L iste tous les noms de function travaillant sur les tuples
… 5
 Les fonctions prédéfinies : les
chaines
strip(): Supprime tous les espaces du début à la fin
S=" Hello, World! " # the output:
print(S.strip()) Hello,World!

replace(oldValue,NewValue):remplace une chaine par une autre

S="Hello, World!" # the output:
print(S.replace("H","J")) Jello, World!

split(): convertit une chaîne en une liste de sous-chaîne Il est possible

de spécifier le séparateur comme argument, sinon espace par défaut
S="Hello, World!" # the output:
print(S.split()) ['Hello,' ' World!']
find(value): cherche la position d'une sous-chaîne sch dans la chaîne.
Retourne -1 sinon
S="Hello, Hello!" # the output:
print(S.find("Hello")) 0

find(value,[start],[end]):value : la valeur recherchée, Start[optionelle] à

partir de quel indice(defaut 0), end [optionelle] jusqu’à quel indice(défaut
la fin de la chaine). 6
 Les fonctions prédéfinies : les
chaines
index(value): retrouve l'indice (index) de la première occurrence de la
valeur recherchée, une exception est levée si non trouvé
S=" Hello, Hello! " # the output:
print(S.index(‚Hello‛)) 0
rfind(): retrouve la dernière occurrence de la valeur recherchée sinon -1
rindex(): retrouve la dernière occurrence sinon une exception
S="Hello, Hello!" # the output:
print(S.rfind("Hello")) 7
join(string): rassemble une liste de chaînes (éléments itérables). Il faut
préciser le séparateur ainsi que la liste des chaînes à rassembler.

S=("Hello","Hi“,"World! ‚) # the output:

Print(“@".join (S)) Hello@Hi@World

7
Les fonctions prédéfinies : listes
append(element): ajoute un élément à la fin d’une liste.
fruits = ['apple','banana'] # the output:
fruits.append("orange") ['apple', 'banana', 'orange']
print(fruits)
clear(): supprime tous les éléments d’une liste
fruits = ['apple','banana'] # the output:
fruits.clear() []
print(fruits)
insert(pos,element): insère une valeur spécifiée à une position donnée
fruits = ['apple','banana'] # the output:
fruits.insert(1, ‚orange‚) ['apple','orange‘,'banana']
print(fruits)
extend(list): ajoute une liste d’éléments à la fin de la liste courant.

fruits = ['apple','banana'] # the output:

F=[‘cherry’,’orange’] ['apple','banana',‘cherry‘,'orange'
fruits.extend(F) ]
print(fruits) 8
Les fonctions prédéfinies : les
dictionnaires
fromkeys(keys,val): renvoie un dictionnaire avec des clés et des valeurs
spécifiées
D = (‘Key1',‘Key2‘) # the output:
X=0 {'key1': 0, 'key2': 0}
print(dict.fromkeys(D,x))
pop(): supprime un élément spécifié du dictionnaire

student = { # the output:

‚name":‚Med", IT
‚Major":‚IT", {'name': 'Med', 'year': 2019}
"year":2019
}
print(student.pop(‚Major‚))
print(student)

values(): Retourne une liste de toutes les valeurs dans le dictionnaire

print(student.values()) # the output: dict_values(['Med', 'IT', 2019])
9
 Les fonctions prédéfinies : les
tuples
count(value): retrourne le nombre d’occurences d’une valeur dans un tuple

T=(1,3,7,8,7,5,4,6,5) # the output:

print(T.count(7)) 2

index(value): retourne l’indice de la première occurrence d’une valeur

spécifiée et déclenche une exception si la valeur n’est pas trouvée

T=(1,3,7,8,7,5,4,6,5) # the output:

print(T.index(7)) 2

10
Fonctions définies par
l’utilisateur
 Une fonction (ou function ) est une suite d'instructions qui
s'exécutent lorsque la fonction est appelée avec un nom.
 Le bloc de code de la fonction commence avec le mot clé def, suivi du
nom de la function et de ()
 Peut disposer d’arguments
 Le code commence à la suite des : et doit être en retrait
 Le mot clé return [expression] marque la fin de la function et
renvoie une valeur à l’appellant.

def functionname (parameters):

function_suite
return [expression] 11
 Définition de fonction
 Définition de fonction
def affiche():
print (" Initiation fonction Python")

def afficheNb(n):
print ("Le nombre saisi est : ",n)

def sommeNB(n):
return(n*(n+1)/2)

 Appel
Output
affiche() Initiation fonction Python
afficheNb(45) Le nombre saisi est : 45
print(sommeNB(10)) 55.0
1
 Définition de fonction
 Définition de fonction
def Min(a,b):
if (a<b):
return a
elif (a>b):
return b
else:
s='egaux'
return s

 Appel
print(Min(3,5)) Output
print(Min(5,5)) 3
Egaux
13
Définition de fonction
 Définition de fonction
def Info(name,age):
print("Name: ",name)
print ("Age ",age)
return

 Appel par nom d’arguments

Output
Info('Med', 20) Name: Med
Age 20
Info(age=20, name='Med’ ) Name: Med
Age 20
Info(50,40) Name: 50
Age 40

14
Définition de fonction

 Appel par nom d’arguments

def small(a,b):
if (a<b):
d="le nombre a =", a,' est le plus petit que b=',b
else:
d='le nombre b =', b, 'est le plus petit que a=' , a
return d

print(small(b=2,a=4))

Output
('le nombre b =', 2, 'est le plus petit que a=', 4)
15
 Définition de fonction
 Définition de valeur d’argument par défaut (utilisé quand la
valeur d’un argument n’est pas passée en paramètre)
def Info(name,age=35): Output:
print ("Name: ",name) Name:Med
print ("Age ",age) Age 20
Info('Med', 20) Name: Med
Info('Med') Age 35

 Remarque : tous les arguments sans valeurs par défaut doivent

être listés en premier lors de la definition de la function.

def Info(age=35,name): ➔ SyntaxError: non-default argument

follows default argument
16
 Définition de fonctions
 Le packing et l'unpacking sont deux concepts Python
complémentaires qui offrent la possibilité de transformer une
succession d'arguments, nommés ou non, en liste/tuple ou
dictionnaire et vice-versa.
17
# Unpacking implicite : fonctionne avec des tuples, listes, strings, et tout
autre itérable
# le tuple (2,3) va être dépaqueté et sauvegardé dans les variables a et b
a, b = (2,3)
print a
print b
# Packing Implicite
# Les valeurs de a et b sont empaquetées dans une liste l
l = [a, b]
print l
 Définition de fonctions
 Nombre variable d’argument d’une fonction : Grâce aux
concepts de packing unpacking, une fonction python peut
accepter deux collections d’arguments :
 Tuple : cet argument spécial est identifié en le préfixant par une
étoile , nommé opérateur Splat (*args)
 Dictionnaire de longueur variable : contenant tous les arguments à
passer à la fonction et qui n’ont pas été définis de manière explicite en
préfixant le dictionnaire par deux étoiles (** kwargs).
 *args et **kwargs permettent, dans la définition d'une
fonction de récupérer les arguments, successivement sous
forme de tuple et de dictionnaire, et donc de faire du packing.
 À l'inverse, comme argument dans l'appel d'une
fonction, *args et **kwargs revient à effectuer de l'unpackin1g
8 .
 Définition de fonctions
 Exemple
# Unpacking explicite avec une liste, puis un dictionnaire
def aire_rectangle(a, b):
return a*b
def aire_rectangle(cote1=0, cote2=0):
return cote1*cote2
rec1 = [3, 8]
rec2 = {'cote1':4, 'cote2':8}
# La liste rec1 va etre dépaquetée en arguments unitaires
print (aire_rectangle(*rec1) )
# Le dictionnaire rec2 va être dépaqueté en arguments unitaires
print (aire_rectangle(**rec2)) Output
24
19
 Définitions de fonctions
# packing explicite (tuple)
def aire_rectangle(*args):
# les arguments passés en paramètre sont paquets dans args qui se
comporte comme un tuple
if len(args) == 2:
return args[0]*args[1]
else:
print('Merci de stipuler deux parametres’)
# Une liste va être créée a partir des arguments fournis
Print(aire_rectangle(3,8))
Output
24 20
Définition de fonction
# packing explicite (dictionnaire)
def aire_rectangle2(**kwargs):
# les arguments passés en paramètre sont paquets dans
kwargs qui se comporte comme un dictionnaire
if len(kwargs) == 2:
result = 1
for key, value in kwargs.items():
result *=value
return result
else:
print('Merci de stipuler deux parametres’)
# Un dictionnaire va être crée a partir des arguments nommés
print(aire_rectangle2(cote1=4, cote2=8)) Output
21
32
 Définitions de fonctions
▪ *args dans la définition de la fonction de traitement : va
récupérer l'ensemble des arguments non nommés, transmis lors de
l'appel de la fonction, afin de les assembler sous forme de liste
(packing).
 À l'intérieur de la fonction, args deviendra une liste comme une autre
que vous pourrez exploiter via une boucle for par exemple
def anyFunc(name, age, gender='M', *cap_letters):
# the output:
print ("name ", name) Name: Mack
print ("age ", age) Age 24
print ("gender ", gender) gender: M
for s in cap_letters: capital letter: A
print ("capital letter: ", s) capital letter: B
anyFunc(‘Mack',24,('A','B'))

22
Définitions de fonctions
 Arguments de longueur variable
def any_function(**K):
print(“Data type of argument:", type(K))
print (‘K:',K)
any_function(type=‘Senior‘,Age=22)

# the output:
Data type of argument: <class 'dict'>
K: {'type': ‘Senior ‘,'Age': 22}

 *args et **kwargs permettant à la fonction de prendre un

nombre variable d’arguments et la rendent f lexible.
 *args envoie un nombre variable d'arguments liste non nommée et
sur lesquels les opérations sur une liste peuvent être effectués.
 **kwargs envoie un nombre variable d’arguments dictionnaire non
nommé et sur lesquels les opérations sur les dictionnaires peuvent
23
 Exemple

def adder(*num):
sum = 0
for n in num:
sum = sum + n
print("Sum:",sum)
adder(3,5)
adder(4,5,6,7)

def countryISO_code(**code):
print (‚ISO codes")
print(code)
return
#Now you can call countryISO_code function
countryISO_code(tn=‚Tunisia‛,de="German",en="English",fr="French"
)

Output
ISO codes
{‘tn: Tunisia, 'fr': 'French', 'de': 'German', 'en': 'English'}
Exemple
Ecrire une function Python qui prend une chaine de caractère et calcule le
nombre de lettre en majuscule et le nombre de lettre en minuscule.
Utilisez un dictionnaire pour le faire.

def string_test(s):
d={"UPPER_CASE":0, "LOWER_CASE":0}
for c in s:
if c.isupper():
d["UPPER_CASE"]+=1 Original String : AAbbb
elif c.islower(): No. of Upper case characters : 2
d["LOWER_CASE"]+=1 No. of Lower case Characters : 3

print ("Original String : ", s)

print ("No. of Upper case characters : ", d["UPPER_CASE"])
print ("No. of Lower case Characters : ", d["LOWER_CASE"])
string_test(« « AAbbb")
25